Explore the detailed information:

Resolve

Utilize resolve to furnish your controller with personalized content or data associated with the state. Resolve is an optional array of dependencies that should be inserted into the controller.

If any of these dependencies are promises, they will be resolved and transformed into a value before the controller gets instantiated and triggers the $stateChangeSuccess event.

The resolve property forms a map object comprising key/value pairs of:

• key – {string}: represents the name of a dependency intended for injection into the controller.
• factory - {string|function}:
  • If it's a string, it is an alias for a service.
  • Otherwise, if it's a function, it gets injected and its return value acts as the dependency. If the result turns out to be a promise, it is resolved prior to the instantiation of the controller and its value is directed into the controller.

Instances:

Each item in the resolve below must undergo resolution (via deferred.resolve() if they're a promise) before the controller arises. Notice how each resolve object is integrated as a parameter into the controller.

code snippet for state

$stateProvider.state('myState', {
  resolve:{

     // Example utilizing function with straightforward return value.
     // Since it isn't a promise, it resolves immediately.
     simpleObj:  function(){
        return {value: 'simple!'};
     },

     // Example employing function with returned promise.
     // This constitutes the common use scenario of resolve.
     // You need to inject all services that you are
     // using, such as $http in this case
     promiseObj:  function($http){
        // $http provides a promise for the url data
        return $http({method: 'GET', url: '/someUrl'});
     },

     // Another instance of a promise. If you need to conduct some 
     // processing on the result, utilize .then, and your 
     // promise is linked consecutively. This depicts another
     // routine use situation of resolve.
     promiseObj2:  function($http){
        return $http({method: 'GET', url: '/someUrl'})
           .then (function (data) {
               return doSomeStuffFirst(data);
           });
     },        

     // Example involving a service by name presented as a string.
     // This would examine for a 'translations' service
     // within the module and yield it.
     // Note: The service might return a promise and
     // it would operate similarly to the earlier example
     translations: "translations",

     // Instance showing insert of service into
     // resolve function. Service subsequently returns a
     // promise. Tip: Inject $stateParams to obtain
     // access to url parameters.
     translations2: function(translations, $stateParams){
         // Suppose getLang serves as a service method
         // leveraging $http to retrieve some translations.
         // Also presume our url was "/:lang/home".
         return translations.getLang($stateParams.lang);
     },

     // Scenario exhibiting formation of custom made promise
     greeting: function($q, $timeout){
         var deferred = $q.defer();
         $timeout(function() {
             deferred.resolve('Hello!');
         }, 1000);
         return deferred.promise;
     }
  },

example controller, utilizing the aforementioned resolve items

  // The controller awaits completion of every one of the above elements
  // being entirely resolved before instantiation. For instance, the
  // controller won't initiate until promiseObj's promise has 
  // been resolved. Then those items are infused into the controller
  // and accessible for implementation.  
  controller: function($scope, simpleObj, promiseObj, promiseObj2, translations, translations2, greeting){
      $scope.simple = simpleObj.value;

      // PromiseObj can undoubtedly be utilized!
      $scope.items = promiseObj.data.items;
      $scope.items = promiseObj2.items;

      $scope.title = translations.getLang("english").title;
      $scope.title = translations2.title;

      $scope.greeting = greeting;
  }
})

It's not recommended to modify the state configuration once it has been created, especially since you won't have access to $stateProvider in the run phase. Instead, consider using resolve when defining your states for a cleaner and more organized approach.

To unconditionally add resolve to one or more states, it is advisable to use an abstract state for inheritance:

$stateProvider
.state('root', {
    abstract: true,
    resolve: {
        common: ...
    },
})
.state('some', {
    parent: 'root',
    ...
});

This method is preferred as it does not require any hacking.

When trying to achieve the equivalent of a dynamic $route resolver in UI Router, there is a slight issue. Upon registering a state using the state method, it is internally stored and inherited through its prototype from the definition rather than simply being assigned to state storage.

While the definition can be retrieved later with $state.get('stateName'), it is not the same object used internally by the router. Due to how JS inheritance functions, having a resolve object in the state won't make a difference, allowing new resolver properties to be added there. However, if $state.get('stateName').resolve does not exist, it becomes a dead end.

The solution is to modify the state method and include a resolve object in all states, enabling later modifications to the resolver set.

angular.module('ui.router.hacked', ['ui.router'])
.config(function ($stateProvider) {
  var stateOriginal = $stateProvider.state;
  $stateProvider.state = function (name, config) {
    config.resolve = config.resolve || {};
    return stateOriginal.apply(this, arguments);
  }
})

angular.module('app', ['ui.router.hacked']).run(function ($state) {
  var state = $state.get('some');
  state.resolve.someResolver = ...;
});

Like any other modification, this approach may have drawbacks and is prone to breaking. Despite its simplicity and reliability, it is essential to conduct additional unit testing and consider conventional methods before resorting to this technique.