BC-BREAK: Replaced ViewConfig.node with ViewConfig.path. el.data('$uiView') is affected. Previously the .node was the node for the view. Now the last element in the path is the node for the view.

BC-BREAK: Nodes no longer have (stateful) `.resolveContext` properties. Instead, a new ResolveContext is wrapped over a Path of Nodes.  Removed `PathFactory.bindResolveContexts()`.
BC-BREAK: ResolveContext.resolvePath returns a promise for resolved data as an array of tuples, instead of a promise for an object of resolved data.  Removed `ResolveContext.resolvePathElement()`.

Author: christopherthielen

src/ng1/directives/stateDirectives.ts

@@ -5,10 +5,11 @@
  *
  * @preferred @module ng1_directives
  */ /** for typedoc */
-import {extend, forEach, toJson} from "../../common/common";
+import {extend, forEach, toJson, tail} from "../../common/common";
 import {isString, isObject} from "../../common/predicates";
 import {UIViewData} from "./viewDirective";
 import {parse} from "../../common/hof";
+import {PathNode} from "../../path/node";
 
 /** @hidden */
 function parseStateRef(ref, current) {
@@ -22,8 +23,8 @@ function parseStateRef(ref, current) {
 /** @hidden */
 function stateContext(el) {
   let $uiView: UIViewData = el.parent().inheritedData('$uiView');
-  let context = parse('$cfg.node.state')($uiView);
-  return context && context.name ? context : undefined;
+  let path: PathNode[] = parse('$cfg.path')($uiView);
+  return path ? tail(path).state.name : undefined;
 }
 
 /** @hidden */

src/ng1/directives/viewDirective.ts

@@ -1,6 +1,6 @@
 /** @module ng1_directives */ /** for typedoc */
 "use strict";
-import {extend, unnestR, filter} from "../../common/common";
+import {extend, unnestR, filter, tail} from "../../common/common";
 import {isDefined, isFunction, isString} from "../../common/predicates";
 import {trace} from "../../common/trace";
 import {ActiveUIView} from "../../view/interface";
@@ -13,7 +13,7 @@ import {PathNode} from "../../path/node";
 import {Param} from "../../params/param";
 import {kebobString} from "../../common/strings";
 import {HookRegOptions} from "../../transition/interface";
-import {Ng1Controller} from "../interface";
+import {Ng1Controller, Ng1StateDeclaration} from "../interface";
 import {getLocals} from "../services";
 
 /** @hidden */
@@ -315,7 +315,6 @@ $ViewDirectiveFill.$inject = ['$compile', '$controller', '$transitions', '$view'
 function $ViewDirectiveFill (  $compile,   $controller,   $transitions,   $view,   $timeout) {
   const getControllerAs = parse('viewDecl.controllerAs');
   const getResolveAs = parse('viewDecl.resolveAs');
-  const getResolveContext = parse('node.resolveContext');
 
   return {
     restrict: 'ECA',
@@ -335,8 +334,7 @@ function $ViewDirectiveFill (  $compile,   $controller,   $transitions,   $view,
         let controller = cfg.controller;
         let controllerAs: string = getControllerAs(cfg);
         let resolveAs: string = getResolveAs(cfg);
-        let resolveCtx: ResolveContext = getResolveContext(cfg);
-
+        let resolveCtx: ResolveContext = cfg.path && new ResolveContext(cfg.path);
         let locals = resolveCtx && getLocals(resolveCtx);
 
         scope[resolveAs] = locals;
@@ -390,16 +388,19 @@ function registerControllerCallbacks($transitions: TransitionService, controller
   // Call $onInit() ASAP
   if (isFunction(controllerInstance.$onInit) && !(cfg.viewDecl.component && hasComponentImpl)) controllerInstance.$onInit();
 
+  let viewState: Ng1StateDeclaration = tail(cfg.path).state.self;
+
   var hookOptions: HookRegOptions = { bind: controllerInstance };
   // Add component-level hook for onParamsChange
   if (isFunction(controllerInstance.uiOnParamsChanged)) {
+    let resolveContext: ResolveContext = new ResolveContext(cfg.path);
+    let viewCreationTrans = resolveContext.getResolvable('$transition$').data;
+
     // Fire callback on any successful transition
     const paramsUpdated = ($transition$: Transition) => {
-      let ctx: ResolveContext = cfg.node.resolveContext;
-      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;
+      if ($transition$ === viewCreationTrans || $transition$.exiting().indexOf(viewState) !== -1) return;
 
       let toParams = $transition$.params("to");
       let fromParams = $transition$.params("from");
@@ -424,7 +425,7 @@ function registerControllerCallbacks($transitions: TransitionService, controller
 
   // Add component-level hook for uiCanExit
   if (isFunction(controllerInstance.uiCanExit)) {
-    var criteria = {exiting: cfg.node.state.name};
+    var criteria = {exiting: viewState.name};
     $scope.$on('$destroy', $transitions.onBefore(criteria, controllerInstance.uiCanExit, hookOptions));
   }
 }

src/ng1/legacy/resolveService.ts

@@ -22,7 +22,12 @@ export const resolveFactory = () => ({
       const rewrap = _locals => resolvablesBuilder(<any> { resolve: map(_locals, local => () => local) });
       context.addResolvables(rewrap(parentLocals), parentNode.state);
       context.addResolvables(rewrap(locals), node.state);
-      return context.resolvePath();
+
+      const tuples2ObjR = (acc, tuple) => {
+        acc[tuple.token] = tuple.value;
+        return acc;
+      };
+      return context.resolvePath().then(results => results.reduce(tuples2ObjR, {}));
     };
 
     return parent ? parent.then(resolveData) : resolveData({});

src/ng1/statebuilders/onEnterExitRetain.ts

@@ -5,7 +5,7 @@ import {Transition} from "../../transition/transition";
 import IInjectorService = angular.auto.IInjectorService;
 import {services} from "../../common/coreservices";
 import {getLocals} from "../services";
-import {tail} from "../../common/common";
+import {ResolveContext} from "../../resolve/resolveContext";
 
 /**
  * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
@@ -18,8 +18,8 @@ export const getStateHookBuilder = (hookName) =>
 function stateHookBuilder(state: State, parentFn): TransitionStateHookFn {
   let hook = state[hookName];
   function decoratedNg1Hook(trans: Transition, inj: IInjectorService): HookResult {
-    let locals = getLocals(tail(trans.treeChanges().to).resolveContext);
-    return services.$injector.invoke(hook, this, locals);
+    let resolveContext = new ResolveContext(trans.treeChanges().to);
+    return services.$injector.invoke(hook, this, getLocals(resolveContext));
   }
 
   return hook ? decoratedNg1Hook : undefined;

src/ng1/statebuilders/views.ts

@@ -1,6 +1,6 @@
 /** @module ng1 */ /** */
 import {State} from "../../state/stateObject";
-import {pick, forEach, anyTrueR, unnestR, tail} from "../../common/common";
+import {pick, forEach, anyTrueR, unnestR, tail, extend} from "../../common/common";
 import {kebobString} from "../../common/strings";
 import {ViewConfig} from "../../view/interface";
 import {Ng1ViewDeclaration} from "../interface";
@@ -13,7 +13,7 @@ import {TemplateFactory} from "../templateFactory";
 import {ResolveContext} from "../../resolve/resolveContext";
 import {Resolvable} from "../../resolve/resolvable";
 
-export const ng1ViewConfigFactory = (node, view) => new Ng1ViewConfig(node, view);
+export const ng1ViewConfigFactory = (path, view) => new Ng1ViewConfig(path, view);
 
 /**
  * This is a [[StateBuilder.builder]] function for angular1 `views`.
@@ -105,15 +105,16 @@ export class Ng1ViewConfig implements ViewConfig {
   template: string;
   locals: any; // TODO: delete me
 
-  constructor(public node: PathNode, public viewDecl: Ng1ViewDeclaration) { }
+  constructor(public path: PathNode[], public viewDecl: Ng1ViewDeclaration) { }
 
   load() {
     let $q = services.$q;
     if (!this.hasTemplate())
       throw new Error(`No template configuration specified for '${this.viewDecl.$uiViewName}@${this.viewDecl.$uiViewContextAnchor}'`);
 
-    let context = this.node.resolveContext;
-    let params = this.node.paramValues;
+    let context = new ResolveContext(this.path);
+    let params = this.path.reduce((acc, node) => extend(acc, node.paramValues), {});
+
     let promises: any = {
       template: $q.when(this.getTemplate(params, new TemplateFactory(), context)),
       controller: $q.when(this.getController(context))

src/ng2/directives/uiView.ts

@@ -14,6 +14,7 @@ import {Inject} from "@angular/core";
 import {ViewContext, ViewConfig} from "../../view/interface";
 import {Ng2ViewDeclaration} from "../interface";
 import {Ng2ViewConfig} from "../statebuilders/views";
+import {ResolveContext} from "../../resolve/resolveContext";
 
 /** @hidden */
 let id = 0;
@@ -180,7 +181,7 @@ export class UiView {
     if (!config) return;
 
     // Map resolves to "useValue providers"
-    let context = config.node.resolveContext;
+    let context = new ResolveContext(config.path);
     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 } }));

src/ng2/providers.ts

@@ -69,7 +69,7 @@ let uiRouterFactory = (routerConfig: UIRouterConfig, location: UIRouterLocation,
 
   location.init();
 
-  router.viewService.viewConfigFactory("ng2", (node: PathNode, config: Ng2ViewDeclaration) => new Ng2ViewConfig(node, config));
+  router.viewService.viewConfigFactory("ng2", (path: PathNode[], config: Ng2ViewDeclaration) => new Ng2ViewConfig(path, config));
   router.stateRegistry.decorator('views', ng2ViewsBuilder);
 
   router.stateRegistry.stateQueue.autoFlush(router.stateService);

src/ng2/statebuilders/views.ts

@@ -39,7 +39,7 @@ export function ng2ViewsBuilder(state: State) {
 export class Ng2ViewConfig implements ViewConfig {
   loaded: boolean = true;
 
-  constructor(public node: PathNode, public viewDecl: Ng2ViewDeclaration) { }
+  constructor(public path: PathNode[], public viewDecl: Ng2ViewDeclaration) { }
 
   load() {
     return services.$q.when(this);

src/path/node.ts

@@ -5,7 +5,6 @@ import {State} from "../state/stateObject";
 import {RawParams} from "../params/interface";
 import {Param} from "../params/param";
 import {Resolvable} from "../resolve/resolvable";
-import {ResolveContext} from "../resolve/resolveContext";
 import {ViewConfig} from "../view/interface";
 
 /**
@@ -22,8 +21,6 @@ export class PathNode {
   public paramSchema: Param[];
   /** The parameter values that belong to the state */
   public paramValues: { [key: string]: any };
-  /** A context object used in conjunction with [[resolvables]] to manage resolves */
-  public resolveContext: ResolveContext;
   /** The individual (stateful) resolvable objects that belong to the state */
   public resolvables: Resolvable[];
   /** The state's declared view configuration objects */
@@ -41,7 +38,6 @@ export class PathNode {
       this.paramValues = extend({}, node.paramValues);
       this.resolvables = node.resolvables.slice();
       this.views = node.views && node.views.slice();
-      this.resolveContext = node.resolveContext;
     } else {
       this.state = state;
       this.paramSchema = state.parameters({ inherit: false });

src/path/pathFactory.ts

@@ -48,8 +48,9 @@ export class PathFactory {
    */
   static applyViewConfigs($view: ViewService, path: PathNode[]) {
     return path.map(node => {
+      let subPath = PathFactory.subPath(path, n => n === node);
       let viewDecls: _ViewDeclaration[] = values(node.state.views || {});
-      let viewConfigs: ViewConfig[][] = viewDecls.map(view => $view.createViewConfig(node, view));
+      let viewConfigs: ViewConfig[][] = viewDecls.map(view => $view.createViewConfig(subPath, view));
       node.views = viewConfigs.reduce(unnestR, []);
       return node;
     });
@@ -92,18 +93,6 @@ export class PathFactory {
     return <PathNode[]> toPath.map(makeInheritedParamsNode);
   }
 
-  /**
-   * Given a path of nodes, creates and binds a ResolveContext to each node.
-   * The ResolveContext is used to inject functions from the proper scoping in the resolve tree.
-   */
-  static bindResolveContexts(resolvePath: PathNode[]): PathNode[] {
-    let resolveContext = new ResolveContext(resolvePath);
-    return resolvePath.map((node: PathNode) => {
-      node.resolveContext = resolveContext.isolateRootTo(node.state);
-      return node;
-    });
-  }
-
   /**
    * Computes the tree changes (entering, exiting) between a fromPath and toPath.
    */