BC-BREAK: Removed Transition.resolves() in favor of Transition.getResolveTokens() and Transition.getResolveValue()

This change is necessary to support injection tokens of arbitrary types, not just strings.

Author: christopherthielen

src/common/common.ts

@@ -119,7 +119,7 @@ export const inherit = (parent, extra) =>
 const restArgs = (args, idx = 0) => Array.prototype.concat.apply(Array.prototype, Array.prototype.slice.call(args, idx));
 
 /** Given an array, returns true if the object is found in the array, (using indexOf) */
-const inArray = (array: any[], obj: any) => array.indexOf(obj) !== -1;
+export const inArray = (array: any[], obj: any) => array.indexOf(obj) !== -1;
 
 /** Given an array, and an item, if the item is found in the array, it removes it (in-place).  The same array is returned */
 export const removeFrom = curry((array: any[], obj) => {
@@ -368,7 +368,10 @@ export const unnestR   = (memo: any[], elem) => memo.concat(elem);
  */
 export const flattenR  = (memo: any[], elem) => isArray(elem) ? memo.concat(elem.reduce(flattenR, [])) : pushR(memo, elem);
 /** Reduce function that pushes an object to an array, then returns the array.  Mostly just for [[flattenR]] */
-function pushR(arr: any[], obj) { arr.push(obj); return arr; }
+export function pushR(arr: any[], obj) { arr.push(obj); return arr; }
+
+/** Reduce function that filters out duplicates */
+export const uniqR = (acc, token) => inArray(acc, token) ? acc : pushR(acc, token);
 
 /**
  * Return a new array with a single level of arrays unnested.

src/ng1/statebuilders/onEnterExitRetain.ts

@@ -4,6 +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";
 
 /**
  * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
@@ -16,7 +18,11 @@ export const getStateHookBuilder = (hookName) =>
 function stateHookBuilder(state: State, parentFn): TransitionStateHookFn {
   let hook = state[hookName];
   function decoratedNg1Hook(trans: Transition, inj: IInjectorService): HookResult {
-    return services.$injector.invoke(hook, this, trans.resolves());
+    let tokens = trans.getResolveTokens().filter(isString);
+    let tuples = tokens.map(key => [ key, trans.getResolveValue(key) ]);
+    let locals = tuples.reduce(applyPairs, {});
+
+    return services.$injector.invoke(hook, this, locals);
   }
 
   return hook ? decoratedNg1Hook : undefined;

src/resolve/resolveContext.ts

@@ -1,5 +1,7 @@
 /** @module resolve */ /** for typedoc */
-import {IInjectable, find, filter, map, tail, defaults, extend, pick, omit} from "../common/common";
+import {
+    IInjectable, find, filter, map, tail, defaults, extend, pick, uniqR, unnestR
+} from "../common/common";
 import {prop, propEq} from "../common/hof";
 import {isString, isObject} from "../common/predicates";
 import {trace} from "../common/trace";
@@ -74,6 +76,25 @@ export class ResolveContext {
     }, <Resolvables> {});
   }
 
+  /** Gets all the tokens found in the resolve context, de-duplicated */
+  getTokens() {
+    return this._path.reduce((acc, node) => acc.concat(node.resolvables.map(r => r.token)), []).reduce(uniqR, []);
+  }
+
+  /**
+   * Gets the Resolvable that matches the token
+   *
+   * Gets the last Resolvable that matches the token in this context, or undefined.
+   * Throws an error if it doesn't exist in the ResolveContext
+   */
+  getResolvable(token) {
+    var matching = this._path.map(node => node.resolvables)
+        .reduce(unnestR, [])
+        .filter((r: Resolvable) => r.token === token);
+
+    return tail(matching)
+  }
+
   /** Inspects a function `fn` for its dependencies.  Returns an object containing any matching Resolvables */
   getResolvablesForFn(fn: IInjectable): { [key: string]: Resolvable } {
     let deps = services.$injector.annotate(<Function> fn, services.$injector.strictDi);

src/transition/transition.ts

@@ -5,7 +5,7 @@ import {
     map, find, extend, mergeR,  tail,
     omit, toJson, abstractKey, arrayTuples, unnestR, identity, anyTrueR
 } from "../common/common";
-import { isObject } from "../common/predicates";
+import { isObject, isArray } from "../common/predicates";
 import { prop, propEq, val, not } from "../common/hof";
 
 import {StateDeclaration, StateOrName} from "../state/interface";
@@ -214,17 +214,56 @@ export class Transition implements IHookRegistry {
   }
 
   /**
-   * Get resolved data
+   * Gets all available resolve tokens (keys)
    *
-   * @returns an object (key/value pairs) where keys are resolve names and values are any settled resolve data,
-   *    or `undefined` for pending resolve data
+   * This method can be used in conjunction with [[getResolve]] to inspect the resolve values
+   * available to the Transition.
+   *
+   * The returned tokens include those defined on [[StateDeclaration.resolve]] blocks, for the states
+   * in the Transition's [[TreeChanges.to]] path.
+   *
+   * @returns an array of resolve tokens (keys)
+   */
+  getResolveTokens(): any[] {
+    return tail(this._treeChanges.to).resolveContext.getTokens();
+  }
+
+
+  /**
+   * Gets resolved values
+   *
+   * This method can be used in conjunction with [[getResolveTokens]] to inspect what resolve values
+   * are available to the Transition.
+   *
+   * Given a token, returns the resolved data for that token.
+   * Given an array of tokens, returns an array of resolved data for those tokens.
+   *
+   * If a resolvable hasn't yet been fetched, returns `undefined` for that token
+   * If a resolvable doesn't exist for the token, throws an error.
+   *
+   * @param token the token (or array of tokens)
+   *
+   * @returns an array of resolve tokens (keys)
    */
-  resolves(): { [resolveName: string]: any } {
-    return map(tail(this._treeChanges.to).resolveContext.getResolvables(), res => res.data);
+  getResolveValue(token: (any|any[])): (any|any[]) {
+    var resolveContext = tail(this._treeChanges.to).resolveContext;
+    const getData = token => {
+      var resolvable = resolveContext.getResolvable(token);
+      if (resolvable === undefined) {
+        throw new Error("Dependency Injection token not found: ${stringify(token)}");
+      }
+      return resolvable.data;
+    };
+
+    if (isArray(token)) {
+      return token.map(getData);
+    }
+
+    return getData(token);
   }
 
   /**
-   * Adds a new [[Resolvable]] (`resolve`) to this transition.
+   * Dynamically adds a new [[Resolvable]] (`resolve`) to this transition.
    *
    * @param resolvable an [[Resolvable]] object
    * @param state the state in the "to path" which should receive the new resolve (otherwise, the root state)