feat(Transition): Create resolves() method on Transition to return resolved data.

feat(Transition): Create addResolve() method on Transition to programmatically add resolves to a transition

Author: christopherthielen

src/resolve/resolvable.ts

@@ -1,9 +1,10 @@
 /// <reference path='../../typings/angularjs/angular.d.ts' />
-import {pick, map}  from "../common/common";
+import {pick, map, filter, not, isFunction}  from "../common/common";
 import trace from "../common/trace";
 import {runtime} from "../common/angular1"
 import {IPromise} from "angular";
 
+import {IResolveDeclarations} from "../state/interface";
 import {State} from "../state/state";
 
 import {IResolvables, IOptions1} from "./interface"
@@ -90,4 +91,15 @@ export default class Resolvable {
   toString() {
     return `Resolvable(name: ${this.name}, state: ${this.state.name}, requires: [${this.deps}])`;
   }
+
+  /**
+   * Validates the result map as a "resolve:" style object, then transforms the resolves into Resolvables
+   */
+  static makeResolvables(resolves: IResolveDeclarations): IResolvables {
+    // If a hook result is an object, it should be a map of strings to functions.
+    let invalid = filter(resolves, not(isFunction)), keys = Object.keys(invalid);
+    if (keys.length)
+      throw new Error(`Invalid resolve key/value: ${keys[0]}/${invalid[keys[0]]}`);
+    return map(resolves, (fn, name) => new Resolvable(name, fn));
+  }
 }

src/transition/hookBuilder.ts

@@ -77,11 +77,10 @@ export default class HookBuilder {
    */
   private _getTransitionHooks(hookType: string, context: (Node[]|State), locals = {}, options: ITransitionHookOptions = {}) {
     let node = tail(this.treeChanges.to);
-    let toFrom: IToFrom = this._toFrom();
     options.traceData = { hookType, context };
 
     const transitionHook = eventHook => this.buildHook(node, eventHook.callback, locals, options);
-    return this._matchingHooks(hookType, toFrom).map(transitionHook);
+    return this._matchingHooks(hookType, this._toFrom()).map(transitionHook);
   }
 
   /**

src/transition/transition.ts

@@ -15,10 +15,14 @@ import PathFactory from "../path/pathFactory";
 
 import {State} from "../state/state";
 import TargetState from "../state/targetState";
-import {IStateDeclaration} from "../state/interface";
+import {IStateDeclaration, IStateOrName} from "../state/interface";
 
 import Param from "../params/param";
 
+import Resolvable from "../resolve/resolvable";
+
+import {IResolveDeclarations} from "../state/interface";
+
 import {ViewConfig} from "../view/view";
 
 import {
@@ -149,6 +153,23 @@ export class Transition implements IHookRegistry {
     return this._treeChanges[pathname].map(prop("values")).reduce(mergeR, {});
   }
 
+  /**
+   * Returns an object with any settled resolve data
+   */
+  resolves = () => map(tail(this._treeChanges.to).resolveContext.getResolvables(), res => res.data);
+
+  /**
+   * Adds new resolves to this transition.
+   * @param resolves a IResolveDeclarations object which describes the new resolves
+   * @param state (optional) the state in the topath which should receive the new resolves (otherwise, the root state)
+   */
+  addResolves(resolves: IResolveDeclarations, state: IStateOrName = "") {
+    let stateName = state.name ? state.name : state;
+    let topath = this._treeChanges.to;
+    let targetNode = find(topath, node => node.state.name === stateName);
+    tail(topath).resolveContext.addResolvables(Resolvable.makeResolvables(resolves), targetNode.state);
+  }
+
   /**
    * @ngdoc function
    * @name ui.router.state.type:Transition#previous

src/transition/transitionHook.ts

@@ -43,9 +43,7 @@ export default class TransitionHook {
     // If the hook returns a Transition, halt the current Transition and redirect to that Transition.
     [is(Transition),    (transition) => REJECT.redirected(transition)],
     // A promise was returned, wait for the promise and then chain another hookHandler
-    [isPromise,         (promise) => promise.then(this.handleHookResult.bind(this))],
-    // If the hook returns any new resolves, add them to the pathContext via the PathElement
-    [isObject,          (obj) => this.resolveContext.addResolvables(this.mapNewResolves(obj), this.state)]
+    [isPromise,         (promise) => promise.then(this.handleHookResult.bind(this))]
   ]);
 
   invokeStep = (moreLocals) => {
@@ -64,20 +62,6 @@ export default class TransitionHook {
     return resolveContext.invokeLater(fn, locals, options).then(this.handleHookResult.bind(this));
   };
 
-  /**
-   * Validates the result map as a "resolve:" style object.
-   * Creates Resolvable objects from the result object and adds them to the target object
-   */
-  mapNewResolves(resolves: IResolveDeclarations) {
-    // If a hook result is an object, it should be a map of strings to functions.
-    let invalid = filter(resolves, not(isFunction)), keys = Object.keys(invalid);
-    if (keys.length)
-      throw new Error(`Invalid resolve key/value: ${keys[0]}/${invalid[keys[0]]}`);
-
-    const makeResolvable = (fn, name) => new Resolvable(name, fn);
-    return map(resolves, makeResolvable);
-  }
-
   handleHookResult(hookResult) {
     if (!isDefined(hookResult)) return undefined;
     trace.traceHookResult(hookResult, undefined, this.options);

test/transitionSpec.ts

@@ -394,17 +394,17 @@ describe('transition', function () {
         resolveDeferredFor("D"); expect(log.join(';')).toBe("#B;^B;#C;^C;#D;^D;DONE");
       }));
 
-      it("resolve-like objects returned from hooks should be added to the transition as Resolvables", inject(function($transitions, $q, $timeout) {
+      it("hooks can add resolves to a $transition$ and they will be available to be injected elsewhere", inject(function($transitions, $q, $timeout) {
         var log = [], transition = makeTransition("A", "D");
         var defer = $q.defer();
 
         transitionProvider.onEnter({}, function logEnter($state$) { log.push("Entered#"+$state$.name); }, {priority: -1});
 
-        transitionProvider.onEnter({ to: "B" }, function addResolves() {
+        transitionProvider.onEnter({ to: "B" }, function addResolves($transition$) {
           log.push("adding resolve");
-          return {
-            newResolve: function() { log.push("resolving"); return defer.promise; }
-          }
+          $transition$.addResolves({
+            newResolve: function () { log.push("resolving"); return defer.promise; }
+          })
         });
 
         transitionProvider.onEnter({ to: "C" }, function useTheNewResolve(newResolve) {