BC-BREAK: remove ResolveContext.getResolvables() in favor of .getToken() and .getResolvable()`

BC-BREAK: remove `ResolveContext.invokeLater()` and `.invokeNow()`
BC-BREAK: remove support for `JIT` resolves
This also obviates the need for the `loadAllControllerLocals` hook

Author: christopherthielen

src/ng1/directives/viewDirective.ts

@@ -1,6 +1,6 @@
 /** @module ng1_directives */ /** for typedoc */
 "use strict";
-import {extend, map, unnestR, filter} from "../../common/common";
+import {extend, unnestR, filter} from "../../common/common";
 import {isDefined, isFunction, isString} from "../../common/predicates";
 import {trace} from "../../common/trace";
 import {ActiveUIView} from "../../view/interface";
@@ -14,6 +14,7 @@ import {Param} from "../../params/param";
 import {kebobString} from "../../common/strings";
 import {HookRegOptions} from "../../transition/interface";
 import {Ng1Controller} from "../interface";
+import {getLocals} from "../services";
 
 /** @hidden */
 export type UIViewData = {
@@ -335,7 +336,8 @@ function $ViewDirectiveFill (  $compile,   $controller,   $transitions,   $view,
         let controllerAs: string = getControllerAs(cfg);
         let resolveAs: string = getResolveAs(cfg);
         let resolveCtx: ResolveContext = getResolveContext(cfg);
-        let locals = resolveCtx && map(resolveCtx.getResolvables(), r => r.data);
+
+        let locals = resolveCtx && getLocals(resolveCtx);
 
         scope[resolveAs] = locals;
 
@@ -394,7 +396,7 @@ function registerControllerCallbacks($transitions: TransitionService, controller
     // Fire callback on any successful transition
     const paramsUpdated = ($transition$: Transition) => {
       let ctx: ResolveContext = cfg.node.resolveContext;
-      let viewCreationTrans = ctx.getResolvables()['$transition$'].data;
+      let viewCreationTrans = ctx.getResolvable('$transition$').data;
       // Exit early if the $transition$ is the same as the view was created within.
       // Exit early if the $transition$ will exit the state the view is for.
       if ($transition$ === viewCreationTrans || $transition$.exiting().indexOf(cfg.node.state.self) !== -1) return;

src/ng1/services.ts

@@ -12,9 +12,9 @@
 /** for typedoc */
 import {UIRouter} from "../router";
 import {services} from "../common/coreservices";
-import {map, bindFunctions, removeFrom, find, noop} from "../common/common";
+import {bindFunctions, removeFrom, applyPairs} from "../common/common";
 import {prop, propEq} from "../common/hof";
-import {isObject} from "../common/predicates";
+import {isObject, isString} from "../common/predicates";
 import {PathNode} from "../path/node";
 import {resolveFactory} from "./legacy/resolveService";
 import {trace} from "../common/trace";
@@ -28,6 +28,7 @@ import {UrlRouterProvider, UrlRouter} from "../url/urlRouter";
 import {UrlMatcherFactory} from "../url/urlMatcherFactory";
 import {Transition} from "../transition/transition";
 import {getStateHookBuilder} from "./statebuilders/onEnterExitRetain";
+import {ResolveContext} from "../resolve/resolveContext";
 
 /** @hidden */
 let app = angular.module("ui.router.angular1", []);
@@ -255,29 +256,6 @@ angular.module('ui.router.state').factory('$stateParams', ['ng1UIRouter', (ng1UI
 
 // $transitions service and $transitionsProvider
 function getTransitionsProvider() {
-  // TODO: check if we can remove loadAllControllerLocals.  Shouldn't be necessary without JIT resolve policy
-  function loadAllControllerLocals($transition$: Transition) {
-    const loadLocals = (vc: Ng1ViewConfig) => {
-      let node = (<PathNode> find($transition$.treeChanges().to, propEq('state', vc.viewDecl.$context)));
-      // Temporary fix; This whole callback should be nuked when fixing #2662
-      if (!node) return services.$q.when();
-      let resolveCtx = node.resolveContext;
-      let controllerDeps = annotateController(vc.controller);
-      let resolvables = resolveCtx.getResolvables();
-
-      function $loadControllerLocals() { }
-      $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 => !!(<Ng1ViewConfig>vc).controller).map(loadLocals);
-    return services.$q.all(loadAllLocals).then(noop);
-  }
-  router.transitionService.onFinish({}, loadAllControllerLocals);
-
   router.transitionService["$get"] = () => router.transitionService;
   return router.transitionService;
 }
@@ -300,6 +278,11 @@ export function watchDigests($rootScope) {
 }
 angular.module("ui.router").run(watchDigests);
 
+export const getLocals = (ctx: ResolveContext) => {
+  let tokens = ctx.getTokens().filter(isString);
+  let tuples = tokens.map(key => [ key, ctx.getResolvable(key).data ]);
+  return tuples.reduce(applyPairs, {});
+};
 
 /** Injectable services */
 

src/ng1/statebuilders/onEnterExitRetain.ts

@@ -4,8 +4,8 @@ import {TransitionStateHookFn, HookResult} from "../../transition/interface";
 import {Transition} from "../../transition/transition";
 import IInjectorService = angular.auto.IInjectorService;
 import {services} from "../../common/coreservices";
-import {isString} from "../../common/predicates";
-import {applyPairs} from "../../common/common";
+import {getLocals} from "../services";
+import {tail} from "../../common/common";
 
 /**
  * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
@@ -18,10 +18,7 @@ export const getStateHookBuilder = (hookName) =>
 function stateHookBuilder(state: State, parentFn): TransitionStateHookFn {
   let hook = state[hookName];
   function decoratedNg1Hook(trans: Transition, inj: IInjectorService): HookResult {
-    let tokens = trans.getResolveTokens().filter(isString);
-    let tuples = tokens.map(key => [ key, trans.getResolveValue(key) ]);
-    let locals = tuples.reduce(applyPairs, {});
-
+    let locals = getLocals(tail(trans.treeChanges().to).resolveContext);
     return services.$injector.invoke(hook, this, locals);
   }
 

src/ng1/statebuilders/views.ts

@@ -1,16 +1,17 @@
 /** @module ng1 */ /** */
 import {State} from "../../state/stateObject";
-import {pick, forEach, anyTrueR, unnestR} from "../../common/common";
+import {pick, forEach, anyTrueR, unnestR, tail} from "../../common/common";
 import {kebobString} from "../../common/strings";
 import {ViewConfig} from "../../view/interface";
 import {Ng1ViewDeclaration} from "../interface";
 import {ViewService} from "../../view/view";
-import {isInjectable, isDefined, isString, isObject} from "../../common/predicates";
+import {isArray, isInjectable, isDefined, isString, isObject} from "../../common/predicates";
 import {services} from "../../common/coreservices";
 import {trace} from "../../common/trace";
 import {PathNode} from "../../path/node";
 import {TemplateFactory} from "../templateFactory";
 import {ResolveContext} from "../../resolve/resolveContext";
+import {Resolvable} from "../../resolve/resolvable";
 
 export const ng1ViewConfigFactory = (node, view) => new Ng1ViewConfig(node, view);
 
@@ -111,11 +112,11 @@ export class Ng1ViewConfig implements ViewConfig {
     if (!this.hasTemplate())
       throw new Error(`No template configuration specified for '${this.viewDecl.$uiViewName}@${this.viewDecl.$uiViewContextAnchor}'`);
 
-    let injector = this.node.resolveContext;
+    let context = this.node.resolveContext;
     let params = this.node.paramValues;
     let promises: any = {
-      template: $q.when(this.getTemplate(params, new TemplateFactory(), injector)),
-      controller: $q.when(this.getController(injector))
+      template: $q.when(this.getTemplate(params, new TemplateFactory(), context)),
+      controller: $q.when(this.getController(context))
     };
 
     return $q.all(promises).then((results) => {
@@ -134,18 +135,21 @@ export class Ng1ViewConfig implements ViewConfig {
     return !!(this.viewDecl.template || this.viewDecl.templateUrl || this.viewDecl.templateProvider);
   }
 
-  getTemplate(params, $factory, injector: ResolveContext) {
-    return $factory.fromConfig(this.viewDecl, params, injector.invokeLater.bind(injector));
+  getTemplate(params, $factory, context: ResolveContext) {
+    return $factory.fromConfig(this.viewDecl, params, context);
   }
 
   /**
    * Gets the controller for a view configuration.
    *
    * @returns {Function|Promise.<Function>} Returns a controller, or a promise that resolves to a controller.
    */
-  getController(injector: ResolveContext) {
-    //* @param {Object} locals A context object from transition.context() to invoke a function in the correct context
+  getController(context: ResolveContext): (String|Function|Promise<Function|String>) {
     let provider = this.viewDecl.controllerProvider;
-    return isInjectable(provider) ? injector.invokeLater(provider, {}) : this.viewDecl.controller;
+    if (!isInjectable(provider)) return this.viewDecl.controller;
+    let deps = services.$injector.annotate(provider);
+    let providerFn = isArray(provider) ? tail(<any> provider) : provider;
+    let resolvable = new Resolvable("", <any> providerFn, deps);
+    return resolvable.get(context);
   }
 }

src/ng1/templateFactory.ts

@@ -1,8 +1,10 @@
 /** @module view */ /** for typedoc */
-import {isDefined, isFunction} from "../common/predicates";
+import {isArray, isDefined, isFunction} from "../common/predicates";
 import {services} from "../common/coreservices";
 import {Ng1ViewDeclaration} from "./interface";
-import {IInjectable} from "../common/common";
+import {IInjectable, tail} from "../common/common";
+import {ResolveContext} from "../resolve/resolveContext";
+import {Resolvable} from "../resolve/resolvable";
 
 /**
  * Service which manages loading of templates from a ViewConfig.
@@ -16,17 +18,16 @@ export class TemplateFactory {
    * that is defined is used to create the template:
    *
    * @param params  Parameters to pass to the template function.
-   * @param injectFn Function to which an injectable function may be passed.
-   *        If templateProvider is defined, this injectFn will be used to invoke it.
+   * @param context The resolve context associated with the template's view
    *
    * @return {string|object}  The template html as a string, or a promise for 
    * that string,or `null` if no template is configured.
    */
-  fromConfig(config: Ng1ViewDeclaration, params: any, injectFn: Function) {
+  fromConfig(config: Ng1ViewDeclaration, params: any, context: ResolveContext) {
     return (
       isDefined(config.template) ? this.fromString(config.template, params) :
       isDefined(config.templateUrl) ? this.fromUrl(config.templateUrl, params) :
-      isDefined(config.templateProvider) ? this.fromProvider(config.templateProvider, params, injectFn) :
+      isDefined(config.templateProvider) ? this.fromProvider(config.templateProvider, params, context) :
       null
     );
   };
@@ -67,7 +68,10 @@ export class TemplateFactory {
    * @return {string|Promise.<string>} The template html as a string, or a promise 
    * for that string.
    */
-  fromProvider(provider: IInjectable, params: any, injectFn: Function) {
-    return injectFn(provider);
+  fromProvider(provider: IInjectable, params: any, context: ResolveContext) {
+    let deps = services.$injector.annotate(provider);
+    let providerFn = isArray(provider) ? tail(<any[]> provider) : provider;
+    let resolvable = new Resolvable("", <Function> providerFn, deps);
+    return resolvable.get(context);
   };
 }

src/ng2/directives/uiView.ts

@@ -180,9 +180,9 @@ export class UiView {
     if (!config) return;
 
     // Map resolves to "useValue providers"
-    let rc = config.node.resolveContext;
-    let resolvables = rc.getResolvables();
-    let rawProviders = Object.keys(resolvables).map(key => provide(key, { useValue: resolvables[key].data }));
+    let context = config.node.resolveContext;
+    let resolvables = context.getTokens().map(token => context.getResolvable(token)).filter(r => r.resolved);
+    let rawProviders = resolvables.map(r => ({ provide: r.token, useValue: r.data }));
     rawProviders.push(provide(UiView.PARENT_INJECT, { useValue: { context: config.viewDecl.$context, fqn: uiViewData.fqn } }));
 
     // Get the component class from the view declaration. TODO: allow promises?

src/path/pathFactory.ts

@@ -145,12 +145,12 @@ export class PathFactory {
    *
    * @param path a path of [[PathNode]]s
    * @param predicate a [[Predicate]] fn that matches [[PathNode]]s
+   * @returns a subpath up to the matching node, or undefined if no match is found
    */
   static subPath(path: PathNode[], predicate: Predicate<PathNode>): PathNode[] {
     let node = find(path, predicate);
     let elementIdx = path.indexOf(node);
-    if (elementIdx === -1) throw new Error("The path does not contain a PathNode matching the predicate");
-    return path.slice(0, elementIdx + 1);
+    return elementIdx === -1 ? undefined : path.slice(0, elementIdx + 1);
   }
 
   /** Gets the raw parameter values from a path */

src/resolve/interface.ts

@@ -12,7 +12,6 @@ export interface IOptions1 {
 
 // Defines the available policies and their ordinals.
 export enum ResolvePolicy {
-  JIT, // JIT resolves are resolved just-in-time, right before an injected function that depends on them is invoked.
   LAZY, // Lazy resolves are resolved before their state is entered.
   EAGER // Eager resolves are resolved before the transition starts.
 }