feat(Resolve): support ng2-like provide object literals

`{ provide: token, useFactory: (Http) => http.get('data'), deps: [Http] }`

fix(Resolve): fix injection of resolves using array notation

refactor(path): PathFactory.subPath now takes a predicate, not a State

fix(Resolvable): create the resolvable promise when pre-resolving data (useValue)
feat(Resolvable): validate token and resolveFn in constructor

refactor(Resolvable): Switch dependency injection from object `locals` to fn.apply(null, arrayDeps)

feat(ResolveContext): getDependencies(Resolvable) uses path*.resolvables or root $injector

refactor(State): use `resolvables` StateBuilder to create property for  `Resolvable[]`

refactor(StateBuilder): extract builder functions

Author: christopherthielen

src/justjs.ts

@@ -5,8 +5,9 @@
  */ /** */
 export * from "./core";
 import {services} from "./common/coreservices";
-import {isDefined, isFunction, isArray, isObject, isInjectable} from "./common/predicates";
-import {extend, assertPredicate, forEach, applyPairs} from "./common/common";
+import {stringify} from "./common/strings";
+import {isFunction, isArray, isObject, isInjectable} from "./common/predicates";
+import {extend, assertPredicate} from "./common/common";
 
 /** $q-like promise api */
 services.$q = (executor: (resolve, reject) => void) => new Promise(executor);
@@ -28,20 +29,16 @@ services.$q.all = function (promises: { [key: string]: Promise<any> } | Promise<
   }
 
   if (isObject(promises)) {
-    // console.log("$q.all({}) Input:", promises);
-
     // Convert promises map to promises array.
     // When each promise resolves, map it to a tuple { key: key, val: val }
-    let chain = Object.keys(promises)
+    let objectToTuples = Object.keys(promises)
         .map(key => promises[key].then(val => ({key, val})));
 
-    // Then wait for all promises to resolve, and convert them back to an object
-    return services.$q.all(chain).then(values => {
-      let value = values.reduce((acc, tuple) => { acc[tuple.key] = tuple.val; return acc; }, {});
+    const tuplesToObject = values =>
+        values.reduce((acc, tuple) => { acc[tuple.key] = tuple.val; return acc; }, {});
 
-      // console.log("$q.all({}) Output:", value);
-      return value;
-    });
+    // Then wait for all promises to resolve, and convert them back to an object
+    return services.$q.all(objectToTuples).then(tuplesToObject);
   }
 };
 
@@ -60,7 +57,7 @@ services.$injector.has = (name) => services.$injector.get(name) != null;
 services.$injector.invoke = function(fn, context?, locals?) {
   let all = extend({}, globals, locals || {});
   let params = services.$injector.annotate(fn);
-  let ensureExist = assertPredicate(key => all.hasOwnProperty(key), key => `DI can't find injectable: '${key}'`);
+  let ensureExist = assertPredicate(key => all.hasOwnProperty(key), key => `Could not find Dependency Injection token: ${stringify(key)}`);
   let args = params.filter(ensureExist).map(x => all[x]);
   if (isFunction(fn)) return fn.apply(context, args);
   return fn.slice(-1)[0].apply(context, args);

src/ng1.ts

@@ -8,7 +8,6 @@ export * from "./core";
 
 export * from "./ng1/services";
 export * from "./ng1/statebuilders/views";
-export * from "./ng1/statebuilders/resolve";
 
 import "./ng1/directives/stateDirectives";
 import "./ng1/stateFilters";

src/ng1/legacy/resolveService.ts

@@ -2,7 +2,7 @@ import {State} from "../../state/stateObject";
 import {PathNode} from "../../path/node";
 import {ResolveContext} from "../../resolve/resolveContext";
 import {map} from "../../common/common";
-import {makeResolvables} from "../statebuilders/resolve";
+import {resolvablesBuilder} from "../../state/stateBuilder";
 
 export const resolveFactory = () => ({
   /**
@@ -12,14 +12,14 @@ export const resolveFactory = () => ({
    * @param parent a promise for a "parent resolve"
    */
   resolve: (invocables, locals = {}, parent?) => {
-    let parentNode = new PathNode(new State(<any> { params: {}, resolve: [] }));
-    let node = new PathNode(new State(<any> { params: {}, resolve: [] }));
+    let parentNode = new PathNode(new State(<any> { params: {}, resolvables: [] }));
+    let node = new PathNode(new State(<any> { params: {}, resolvables: [] }));
     let context = new ResolveContext([parentNode, node]);
 
-    context.addResolvables(makeResolvables(invocables), node.state);
+    context.addResolvables(resolvablesBuilder(<any> { resolve: invocables }), node.state);
 
     const resolveData = (parentLocals) => {
-      const rewrap = _locals => makeResolvables(<any> map(_locals, local => () => local));
+      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();

src/ng1/services.ts

@@ -20,7 +20,6 @@ import {resolveFactory} from "./legacy/resolveService";
 import {trace} from "../common/trace";
 import {ng1ViewsBuilder, ng1ViewConfigFactory, Ng1ViewConfig} from "./statebuilders/views";
 import {TemplateFactory} from "./templateFactory";
-import {ng1ResolveBuilder} from "./statebuilders/resolve";
 import {StateParams} from "../params/stateParams";
 import {TransitionService} from "../transition/transitionService";
 import {StateService} from "../state/stateService";
@@ -168,7 +167,6 @@ function ng1UIRouter($locationProvider) {
 
   // Apply ng1 specific StateBuilder code for `views`, `resolve`, and `onExit/Retain/Enter` properties
   router.stateRegistry.decorator("views", ng1ViewsBuilder);
-  router.stateRegistry.decorator("resolve", ng1ResolveBuilder);
   router.stateRegistry.decorator("onExit", getStateHookBuilder("onExit"));
   router.stateRegistry.decorator("onRetain", getStateHookBuilder("onRetain"));
   router.stateRegistry.decorator("onEnter", getStateHookBuilder("onEnter"));

src/ng1/statebuilders/resolve.ts

@@ -122,7 +122,7 @@ export class UiSrefStatus {
      * Then appends each to [a,b,] and returns: [a, b, c], [a, b, c, d]
      */
     function spreadToSubPaths (path: PathNode[], appendTo: PathNode[] = []): PathNode[][] {
-      return path.map(node => appendTo.concat(PathFactory.subPath(path, node.state)));
+      return path.map(node => appendTo.concat(PathFactory.subPath(path, n => n.state === node.state)));
     }
 
     let tc: TreeChanges = $transition$.treeChanges();

src/ng2/directives/uiSrefStatus.ts

@@ -46,7 +46,7 @@ export class PathNode {
       this.state = state;
       this.paramSchema = state.parameters({ inherit: false });
       this.paramValues = {};
-      this.resolvables = state.resolve.map(res => res.clone());
+      this.resolvables = state.resolvables.map(res => res.clone());
     }
   }
 

src/path/node.ts

@@ -1,6 +1,6 @@
 /** @module path */ /** for typedoc */
 
-import {extend, find, pick, omit, tail, mergeR, values, unnestR} from "../common/common";
+import {extend, find, pick, omit, tail, mergeR, values, unnestR, Predicate} from "../common/common";
 import {prop, propEq, not} from "../common/hof";
 
 import {RawParams} from "../params/interface";
@@ -138,18 +138,18 @@ export class PathFactory {
   }
 
   /**
-   * Find a subpath of a path that stops at the node for a given state
+   * Return a subpath of a path, which stops at the first matching node
    *
-   * Given an array of nodes, returns a subset of the array starting from the first node, up to the
-   * node whose state matches `stateName`
+   * Given an array of nodes, returns a subset of the array starting from the first node,
+   * stopping when the first node matches the predicate.
    *
    * @param path a path of [[PathNode]]s
-   * @param state the [[State]] to stop at
+   * @param predicate a [[Predicate]] fn that matches [[PathNode]]s
    */
-  static subPath(path: PathNode[], state): PathNode[] {
-    let node = find(path, _node => _node.state === state);
+  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 the state: " + state);
+    if (elementIdx === -1) throw new Error("The path does not contain a PathNode matching the predicate");
     return path.slice(0, elementIdx + 1);
   }
 

src/path/pathFactory.ts

@@ -7,6 +7,7 @@ import {Resolvables, IOptions1} from "./interface";
 
 import {ResolveContext} from "./resolveContext";
 import {stringify} from "../common/strings";
+import {isFunction} from "../common/predicates";
 
 /**
  * The basic building block for the resolve system.
@@ -48,61 +49,52 @@ export class Resolvable {
     if (token instanceof Resolvable) {
       extend(this, token);
     } else {
+      if (token == null || token == undefined) throw new Error("new Resolvable(): token argument is required");
+      if (!isFunction(resolveFn)) throw new Error("new Resolvable(): resolveFn argument must be a function");
+
       this.token = token;
       this.resolveFn = resolveFn;
-      this.deps = deps;
+      this.deps = deps || [];
       this.data = data;
       this.resolved = data !== undefined;
+      this.promise = this.resolved ? services.$q.when(this.data) : undefined;
     }
   }
 
-  // synchronous part:
-  // - sets up the Resolvable's promise
-  // - retrieves dependencies' promises
-  // - returns promise for async part
-
-  // asynchronous part:
-  // - wait for dependencies promises to resolve
-  // - invoke the resolveFn
-  // - wait for resolveFn promise to resolve
-  // - store unwrapped data
-  // - resolve the Resolvable's promise
-  resolveResolvable(resolveContext: ResolveContext, options: IOptions1 = {}) {
-    let {deps, resolveFn} = this;
-    
-    trace.traceResolveResolvable(this, options);
-    // First, set up an overall deferred/promise for this Resolvable
-    let deferred = services.$q.defer();
-    this.promise = deferred.promise;
-    // Load a map of all resolvables for this state from the context path
-    // Omit the current Resolvable from the result, so we don't try to inject this into this
-    let ancestorsByName: Resolvables = resolveContext.getResolvables(null, {  omitOwnLocals: [ this.token ] });
-
-    // Limit the ancestors Resolvables map to only those that the current Resolvable fn's annotations depends on
-    let depResolvables: Resolvables = <any> pick(ancestorsByName, deps);
-
-    // Get promises (or synchronously invoke resolveFn) for deps
-    let depPromises: any = map(depResolvables, (resolvable: Resolvable) => resolvable.get(resolveContext, options));
-
-    // Return a promise chain that waits for all the deps to resolve, then invokes the resolveFn passing in the
-    // dependencies as locals, then unwraps the resulting promise's data.
-    return services.$q.all(depPromises).then(locals => {
-      try {
-        let result = services.$injector.invoke(resolveFn, null, locals);
-        deferred.resolve(result);
-      } catch (error) {
-        deferred.reject(error);
-      }
-      return this.promise;
-    }).then(data => {
-      this.data = data;
-      trace.traceResolvableResolved(this, options);
-      return this.promise;
-    });
+  /**
+   * Asynchronously resolve this Resolvable's data
+   *
+   * Given a ResolveContext that this Resolvable is found in:
+   * Wait for this Resolvable's dependencies, then invoke this Resolvable's function
+   * and update the Resolvable's state
+   */
+  resolve(resolveContext: ResolveContext, options: IOptions1 = {}) {
+    let $q = services.$q;
+    return this.promise = $q.when()
+        // Get all dependencies from ResolveContext and wait for them to be resolved
+        .then(() =>
+            $q.all(resolveContext.getDependencies(this).map(r =>
+                r.get(resolveContext, options))))
+        // Invoke the resolve function passing the resolved dependencies
+        .then(resolvedDeps =>
+            this.resolveFn.apply(null, resolvedDeps))
+        // Wait for returned promise to resolve then update the Resolvable state
+        .then(resolvedValue => {
+          this.data = resolvedValue;
+          this.resolved = true;
+          trace.traceResolvableResolved(this, options);
+          return this.data;
+        });
   }
 
+  /**
+   * Gets a promise for this Resolvable's data.
+   *
+   * Fetches the data and returns a promise.
+   * Returns the existing promise if it has already been fetched once.
+   */
   get(resolveContext: ResolveContext, options?: IOptions1): Promise<any> {
-    return this.promise || this.resolveResolvable(resolveContext, options);
+    return this.promise || this.resolve(resolveContext, options);
   }
 
   toString() {

src/resolve/resolvable.ts

@@ -11,6 +11,7 @@ import {Resolvable} from "./resolvable";
 import {State} from "../state/stateObject";
 import {mergeR} from "../common/common";
 import {PathFactory} from "../path/pathFactory";
+import {stringify} from "../common/strings";
 
 // TODO: make this configurable
 let defaultResolvePolicy = ResolvePolicy[ResolvePolicy.LAZY];
@@ -29,7 +30,7 @@ export class ResolveContext {
         return <PathNode> find(this._path, propEq('state', state));
       },
       _pathTo(state: State): PathNode[] {
-        return PathFactory.subPath(this._path, state);
+        return PathFactory.subPath(this._path, node => node.state === state);
       }
     });
   }
@@ -186,6 +187,27 @@ export class ResolveContext {
 
     return {get};
   }
+
+  getDependencies(resolvable: Resolvable): Resolvable[] {
+    // predicate that finds the node the resolvable belongs to
+    const nodeForResolvable = node => node.resolvables.indexOf(resolvable) !== -1;
+    // Find which other resolvables are "visible" to the `resolvable` argument
+    var availableResolvables: Resolvable[] = PathFactory.subPath(this._path, nodeForResolvable) // subpath stopping at resolvable's  node
+        .reduce((acc, node) => acc.concat(node.resolvables), []) //all of subpath's resolvables
+        .filter(res => res !== resolvable); // filter out the `resolvable` arg
+
+    const getDependency = token => {
+      let matching = availableResolvables.filter(r => r.token === token);
+      if (matching.length) return tail(matching);
+
+      let fromInjector = services.$injector.get(token);
+      if (!fromInjector) throw new Error("Could not find Dependency Injection token: " + stringify(token));
+
+      return new Resolvable(token, () => fromInjector, [], fromInjector);
+    };
+
+    return resolvable.deps.map(getDependency);
+  }
 }
 
 /**