feat(resolve): Allow all resolved data for a node to be injected as $resolve$

Author: christopherthielen

src/ng1/services.ts

@@ -272,12 +272,16 @@ function getTransitionsProvider() {
   loadAllControllerLocals.$inject = ['$transition$'];
   function loadAllControllerLocals($transition$) {
     const loadLocals = (vc: ViewConfig) => {
-      let deps = annotateController(vc.controller);
-      let toPath: Node[] = $transition$.treeChanges().to;
-      let resolveInjector = find(toPath, propEq('state', vc.context)).resolveInjector;
+      let resolveCtx = find($transition$.treeChanges().to, propEq('state', vc.context)).resolveContext;
+      let controllerDeps = annotateController(vc.controller);
+      let resolvables = resolveCtx.getResolvables();
+
       function $loadControllerLocals() { }
-      $loadControllerLocals.$inject = deps;
-      return services.$q.all(resolveInjector.getLocals($loadControllerLocals)).then((locals) => vc.locals = locals);
+      $loadControllerLocals.$inject = controllerDeps.filter(dep => resolvables.hasOwnProperty(dep));
+      // Load any controller resolves that aren't already loaded
+      return resolveCtx.invokeLater($loadControllerLocals)
+          // Then provide the view config with all the resolved data
+          .then(() => vc.locals = map(resolvables, res => res.data));
     };
 
     let loadAllLocals = $transition$.views("entering").filter(vc => !!vc.controller).map(loadLocals);

src/state/hooks/resolveHooks.ts

@@ -1,11 +1,12 @@
 /** @module state */ /** for typedoc */
-import {extend, find, tail} from "../../common/common";
+import {extend, find, tail, map} from "../../common/common";
 import {propEq} from "../../common/hof";
 
 import {ResolvePolicy} from "../../resolve/interface";
 
 import {Transition} from "../../transition/transition";
 import {val} from "../../common/hof";
+import {Resolvable} from "../../resolve/resolvable";
 
 
 let LAZY = ResolvePolicy[ResolvePolicy.LAZY];
@@ -33,7 +34,16 @@ export class ResolveHooks {
     (<any> $lazyResolveEnteringState).$inject = ['$state$', '$transition$'];
     function $lazyResolveEnteringState($state$, $transition$) {
       let node = find(<any[]> treeChanges.entering, propEq('state', $state$));
-      return node.resolveContext.resolvePathElement(node.state, extend({transition: $transition$}, { resolvePolicy: LAZY }));
+
+      // A new Resolvable contains all the resolved data in this context as a single object, for injection as `$resolve$`
+      let $resolve$ = new Resolvable("$resolve$", () => map(context.getResolvables(), r => r.data));
+      let context = node.resolveContext;
+      var options = extend({transition: $transition$}, { resolvePolicy: LAZY });
+
+      // Resolve all the LAZY resolves, then resolve the `$resolve$` object, then add `$resolve$` to the context
+      return context.resolvePathElement(node.state, options)
+          .then(() => $resolve$.resolveResolvable(context))
+          .then(() => context.addResolvables({$resolve$}, node.state));
     }
 
     // Resolve eager resolvables before when the transition starts