@angular-wave/angular.ts 0.0.11 → 0.0.13

package/src/router/core/path/pathUtils.js

@@ -0,0 +1,199 @@
+import {
+  extend,
+  find,
+  pick,
+  omit,
+  tail,
+  mergeR,
+  unnestR,
+  inArray,
+  arrayTuples,
+} from "../common/common";
+import { prop, propEq } from "../common/hof";
+import { TargetState } from "../state/targetState";
+import { PathNode } from "./pathNode";
+/**
+ * This class contains functions which convert TargetStates, Nodes and paths from one type to another.
+ */
+export class PathUtils {
+  /** Given a PathNode[], create an TargetState */
+  static makeTargetState(registry, path) {
+    const state = tail(path).state;
+    return new TargetState(
+      registry,
+      state,
+      path.map(prop("paramValues")).reduce(mergeR, {}),
+      {},
+    );
+  }
+  static buildPath(targetState) {
+    const toParams = targetState.params();
+    return targetState
+      .$state()
+      .path.map((state) => new PathNode(state).applyRawParams(toParams));
+  }
+  /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */
+  static buildToPath(fromPath, targetState) {
+    const toPath = PathUtils.buildPath(targetState);
+    if (targetState.options().inherit) {
+      return PathUtils.inheritParams(
+        fromPath,
+        toPath,
+        Object.keys(targetState.params()),
+      );
+    }
+    return toPath;
+  }
+  /**
+   * Creates ViewConfig objects and adds to nodes.
+   *
+   * On each [[PathNode]], creates ViewConfig objects from the views: property of the node's state
+   */
+  static applyViewConfigs($view, path, states) {
+    // Only apply the viewConfigs to the nodes for the given states
+    path
+      .filter((node) => inArray(states, node.state))
+      .forEach((node) => {
+        const viewDecls = Object.values(node.state.views || {});
+        const subPath = PathUtils.subPath(path, (n) => n === node);
+        const viewConfigs = viewDecls.map((view) =>
+          $view.createViewConfig(subPath, view),
+        );
+        node.views = viewConfigs.reduce(unnestR, []);
+      });
+  }
+  /**
+   * Given a fromPath and a toPath, returns a new to path which inherits parameters from the fromPath
+   *
+   * For a parameter in a node to be inherited from the from path:
+   * - The toPath's node must have a matching node in the fromPath (by state).
+   * - The parameter name must not be found in the toKeys parameter array.
+   *
+   * Note: the keys provided in toKeys are intended to be those param keys explicitly specified by some
+   * caller, for instance, $state.transitionTo(..., toParams).  If a key was found in toParams,
+   * it is not inherited from the fromPath.
+   */
+  static inheritParams(fromPath, toPath, toKeys = []) {
+    function nodeParamVals(path, state) {
+      const node = find(path, propEq("state", state));
+      return extend({}, node && node.paramValues);
+    }
+    const noInherit = fromPath
+      .map((node) => node.paramSchema)
+      .reduce(unnestR, [])
+      .filter((param) => !param.inherit)
+      .map(prop("id"));
+    /**
+     * Given an [[PathNode]] "toNode", return a new [[PathNode]] with param values inherited from the
+     * matching node in fromPath.  Only inherit keys that aren't found in "toKeys" from the node in "fromPath""
+     */
+    function makeInheritedParamsNode(toNode) {
+      // All param values for the node (may include default key/vals, when key was not found in toParams)
+      let toParamVals = extend({}, toNode && toNode.paramValues);
+      // limited to only those keys found in toParams
+      const incomingParamVals = pick(toParamVals, toKeys);
+      toParamVals = omit(toParamVals, toKeys);
+      const fromParamVals = omit(
+        nodeParamVals(fromPath, toNode.state) || {},
+        noInherit,
+      );
+      // extend toParamVals with any fromParamVals, then override any of those those with incomingParamVals
+      const ownParamVals = extend(
+        toParamVals,
+        fromParamVals,
+        incomingParamVals,
+      );
+      return new PathNode(toNode.state).applyRawParams(ownParamVals);
+    }
+    // The param keys specified by the incoming toParams
+    return toPath.map(makeInheritedParamsNode);
+  }
+  /**
+   * Computes the tree changes (entering, exiting) between a fromPath and toPath.
+   */
+  static treeChanges(fromPath, toPath, reloadState) {
+    const max = Math.min(fromPath.length, toPath.length);
+    let keep = 0;
+    const nodesMatch = (node1, node2) =>
+      node1.equals(node2, PathUtils.nonDynamicParams);
+    while (
+      keep < max &&
+      fromPath[keep].state !== reloadState &&
+      nodesMatch(fromPath[keep], toPath[keep])
+    ) {
+      keep++;
+    }
+    /** Given a retained node, return a new node which uses the to node's param values */
+    function applyToParams(retainedNode, idx) {
+      const cloned = retainedNode.clone();
+      cloned.paramValues = toPath[idx].paramValues;
+      return cloned;
+    }
+    let from, retained, exiting, entering, to;
+    from = fromPath;
+    retained = from.slice(0, keep);
+    exiting = from.slice(keep);
+    // Create a new retained path (with shallow copies of nodes) which have the params of the toPath mapped
+    const retainedWithToParams = retained.map(applyToParams);
+    entering = toPath.slice(keep);
+    to = retainedWithToParams.concat(entering);
+    return { from, to, retained, retainedWithToParams, exiting, entering };
+  }
+  /**
+   * Returns a new path which is: the subpath of the first path which matches the second path.
+   *
+   * The new path starts from root and contains any nodes that match the nodes in the second path.
+   * It stops before the first non-matching node.
+   *
+   * Nodes are compared using their state property and their parameter values.
+   * If a `paramsFn` is provided, only the [[Param]] returned by the function will be considered when comparing nodes.
+   *
+   * @param pathA the first path
+   * @param pathB the second path
+   * @param paramsFn a function which returns the parameters to consider when comparing
+   *
+   * @returns an array of PathNodes from the first path which match the nodes in the second path
+   */
+  static matching(pathA, pathB, paramsFn) {
+    let done = false;
+    const tuples = arrayTuples(pathA, pathB);
+    return tuples.reduce((matching, [nodeA, nodeB]) => {
+      done = done || !nodeA.equals(nodeB, paramsFn);
+      return done ? matching : matching.concat(nodeA);
+    }, []);
+  }
+  /**
+   * Returns true if two paths are identical.
+   *
+   * @param pathA
+   * @param pathB
+   * @param paramsFn a function which returns the parameters to consider when comparing
+   * @returns true if the the states and parameter values for both paths are identical
+   */
+  static equals(pathA, pathB, paramsFn) {
+    return (
+      pathA.length === pathB.length &&
+      PathUtils.matching(pathA, pathB, paramsFn).length === pathA.length
+    );
+  }
+  /**
+   * 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,
+   * stopping when the first node matches the predicate.
+   *
+   * @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, predicate) {
+    const node = find(path, predicate);
+    const elementIdx = path.indexOf(node);
+    return elementIdx === -1 ? undefined : path.slice(0, elementIdx + 1);
+  }
+}
+PathUtils.nonDynamicParams = (node) =>
+  node.state.parameters({ inherit: false }).filter((param) => !param.dynamic);
+/** Gets the raw parameter values from a path */
+PathUtils.paramValues = (path) =>
+  path.reduce((acc, node) => extend(acc, node.paramValues), {});

package/src/router/core/resolve/interface.js

@@ -0,0 +1,10 @@
+export let resolvePolicies = {
+  when: {
+    LAZY: "LAZY",
+    EAGER: "EAGER",
+  },
+  async: {
+    WAIT: "WAIT",
+    NOWAIT: "NOWAIT",
+  },
+};

package/src/router/core/resolve/resolvable.js

@@ -0,0 +1,124 @@
+import { extend, identity } from "../../../core/utils";
+import { services } from "../common/coreservices";
+import { trace } from "../common/trace";
+import { stringify } from "../common/strings";
+import { isFunction, isObject } from "../common/predicates";
+import { isNullOrUndefined } from "../common/predicates";
+// TODO: explicitly make this user configurable
+export let defaultResolvePolicy = {
+  when: "LAZY",
+  async: "WAIT",
+};
+/**
+ * The basic building block for the resolve system.
+ *
+ * Resolvables encapsulate a state's resolve's resolveFn, the resolveFn's declared dependencies, the wrapped (.promise),
+ * and the unwrapped-when-complete (.data) result of the resolveFn.
+ *
+ * Resolvable.get() either retrieves the Resolvable's existing promise, or else invokes resolve() (which invokes the
+ * resolveFn) and returns the resulting promise.
+ *
+ * Resolvable.get() and Resolvable.resolve() both execute within a context path, which is passed as the first
+ * parameter to those fns.
+ */
+export class Resolvable {
+  constructor(arg1, resolveFn, deps, policy, data) {
+    this.resolved = false;
+    this.promise = undefined;
+    if (arg1 instanceof Resolvable) {
+      extend(this, arg1);
+    } else if (isFunction(resolveFn)) {
+      if (isNullOrUndefined(arg1))
+        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 = arg1;
+      this.policy = policy;
+      this.resolveFn = resolveFn;
+      this.deps = deps || [];
+      this.data = data;
+      this.resolved = data !== undefined;
+      this.promise = this.resolved ? services.$q.when(this.data) : undefined;
+    } else if (
+      isObject(arg1) &&
+      arg1.token &&
+      (arg1.hasOwnProperty("resolveFn") || arg1.hasOwnProperty("data"))
+    ) {
+      const literal = arg1;
+      return new Resolvable(
+        literal.token,
+        literal.resolveFn,
+        literal.deps,
+        literal.policy,
+        literal.data,
+      );
+    }
+  }
+  getPolicy(state) {
+    const thisPolicy = this.policy || {};
+    const statePolicy = (state && state.resolvePolicy) || {};
+    return {
+      when: thisPolicy.when || statePolicy.when || defaultResolvePolicy.when,
+      async:
+        thisPolicy.async || statePolicy.async || defaultResolvePolicy.async,
+    };
+  }
+  /**
+   * 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, trans) {
+    const $q = services.$q;
+    // Gets all dependencies from ResolveContext and wait for them to be resolved
+    const getResolvableDependencies = () =>
+      $q.all(
+        resolveContext
+          .getDependencies(this)
+          .map((resolvable) => resolvable.get(resolveContext, trans)),
+      );
+    // Invokes the resolve function passing the resolved dependencies as arguments
+    const invokeResolveFn = (resolvedDeps) =>
+      this.resolveFn.apply(null, resolvedDeps);
+    const node = resolveContext.findNode(this);
+    const state = node && node.state;
+    const asyncPolicy = this.getPolicy(state).async;
+    const customAsyncPolicy = isFunction(asyncPolicy) ? asyncPolicy : identity;
+    // After the final value has been resolved, update the state of the Resolvable
+    const applyResolvedValue = (resolvedValue) => {
+      this.data = resolvedValue;
+      this.resolved = true;
+      this.resolveFn = null;
+      trace.traceResolvableResolved(this, trans);
+      return this.data;
+    };
+    // Sets the promise property first, then getsResolvableDependencies in the context of the promise chain. Always waits one tick.
+    return (this.promise = $q
+      .when()
+      .then(getResolvableDependencies)
+      .then(invokeResolveFn)
+      .then(customAsyncPolicy)
+      .then(applyResolvedValue));
+  }
+  /**
+   * 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, trans) {
+    return this.promise || this.resolve(resolveContext, trans);
+  }
+  toString() {
+    return `Resolvable(token: ${stringify(this.token)}, requires: [${this.deps.map(stringify)}])`;
+  }
+  clone() {
+    return new Resolvable(this);
+  }
+}
+Resolvable.fromData = (token, data) =>
+  new Resolvable(token, () => data, null, null, data);

package/src/router/core/resolve/resolveContext.js

@@ -0,0 +1,211 @@
+import { find, tail, uniqR, unnestR, inArray } from "../common/common";
+import { propEq, not } from "../common/hof";
+import { trace } from "../common/trace";
+import { services } from "../common/coreservices";
+import { resolvePolicies } from "./interface";
+import { Resolvable } from "./resolvable";
+import { PathUtils } from "../path/pathUtils";
+import { stringify } from "../common/strings";
+import { isUndefined } from "../../../core/utils";
+
+const whens = resolvePolicies.when;
+const ALL_WHENS = [whens.EAGER, whens.LAZY];
+const EAGER_WHENS = [whens.EAGER];
+// tslint:disable-next-line:no-inferrable-types
+export const NATIVE_INJECTOR_TOKEN = "Native Injector";
+/**
+ * Encapsulates Dependency Injection for a path of nodes
+ *
+ * UI-Router states are organized as a tree.
+ * A nested state has a path of ancestors to the root of the tree.
+ * When a state is being activated, each element in the path is wrapped as a [[PathNode]].
+ * A `PathNode` is a stateful object that holds things like parameters and resolvables for the state being activated.
+ *
+ * The ResolveContext closes over the [[PathNode]]s, and provides DI for the last node in the path.
+ */
+export class ResolveContext {
+  constructor(_path) {
+    this._path = _path;
+  }
+  /** 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) {
+    const matching = this._path
+      .map((node) => node.resolvables)
+      .reduce(unnestR, [])
+      .filter((r) => r.token === token);
+    return tail(matching);
+  }
+  /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */
+  getPolicy(resolvable) {
+    const node = this.findNode(resolvable);
+    return resolvable.getPolicy(node.state);
+  }
+  /**
+   * Returns a ResolveContext that includes a portion of this one
+   *
+   * Given a state, this method creates a new ResolveContext from this one.
+   * The new context starts at the first node (root) and stops at the node for the `state` parameter.
+   *
+   * #### Why
+   *
+   * When a transition is created, the nodes in the "To Path" are injected from a ResolveContext.
+   * A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables.
+   * The "To State" can inject values from its own resolvables, as well as those from all its ancestor state's (node's).
+   * This method is used to create a narrower context when injecting ancestor nodes.
+   *
+   * @example
+   * `let ABCD = new ResolveContext([A, B, C, D]);`
+   *
+   * Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:
+   * When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.
+   * However, `B` should only be able to access resolvables from `A`, `B`.
+   *
+   * When resolving for the `B` node, first take the full "To Path" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.
+   * `let AB = ABCD.subcontext(a)`
+   */
+  subContext(state) {
+    return new ResolveContext(
+      PathUtils.subPath(this._path, (node) => node.state === state),
+    );
+  }
+  /**
+   * Adds Resolvables to the node that matches the state
+   *
+   * This adds a [[Resolvable]] (generally one created on the fly; not declared on a [[StateDeclaration.resolve]] block).
+   * The resolvable is added to the node matching the `state` parameter.
+   *
+   * These new resolvables are not automatically fetched.
+   * The calling code should either fetch them, fetch something that depends on them,
+   * or rely on [[resolvePath]] being called when some state is being entered.
+   *
+   * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.
+   *
+   * @param newResolvables the new Resolvables
+   * @param state Used to find the node to put the resolvable on
+   */
+  addResolvables(newResolvables, state) {
+    const node = find(this._path, propEq("state", state));
+    const keys = newResolvables.map((r) => r.token);
+    node.resolvables = node.resolvables
+      .filter((r) => keys.indexOf(r.token) === -1)
+      .concat(newResolvables);
+  }
+  /**
+   * Returns a promise for an array of resolved path Element promises
+   *
+   * @param when
+   * @param trans
+   * @returns {Promise<any>|any}
+   */
+  resolvePath(when = "LAZY", trans) {
+    // This option determines which 'when' policy Resolvables we are about to fetch.
+    const whenOption = inArray(ALL_WHENS, when) ? when : "LAZY";
+    // If the caller specified EAGER, only the EAGER Resolvables are fetched.
+    // if the caller specified LAZY, both EAGER and LAZY Resolvables are fetched.`
+    const matchedWhens =
+      whenOption === resolvePolicies.when.EAGER ? EAGER_WHENS : ALL_WHENS;
+    // get the subpath to the state argument, if provided
+    trace.traceResolvePath(this._path, when, trans);
+    const matchesPolicy = (acceptedVals, whenOrAsync) => (resolvable) =>
+      inArray(acceptedVals, this.getPolicy(resolvable)[whenOrAsync]);
+    // Trigger all the (matching) Resolvables in the path
+    // Reduce all the "WAIT" Resolvables into an array
+    const promises = this._path.reduce((acc, node) => {
+      const nodeResolvables = node.resolvables.filter(
+        matchesPolicy(matchedWhens, "when"),
+      );
+      const nowait = nodeResolvables.filter(matchesPolicy(["NOWAIT"], "async"));
+      const wait = nodeResolvables.filter(
+        not(matchesPolicy(["NOWAIT"], "async")),
+      );
+      // For the matching Resolvables, start their async fetch process.
+      const subContext = this.subContext(node.state);
+      const getResult = (r) =>
+        r
+          .get(subContext, trans)
+          // Return a tuple that includes the Resolvable's token
+          .then((value) => ({ token: r.token, value: value }));
+      nowait.forEach(getResult);
+      return acc.concat(wait.map(getResult));
+    }, []);
+    // Wait for all the "WAIT" resolvables
+    return services.$q.all(promises);
+  }
+  injector() {
+    return this._injector || (this._injector = new UIInjectorImpl(this));
+  }
+  findNode(resolvable) {
+    return find(this._path, (node) => inArray(node.resolvables, resolvable));
+  }
+  /**
+   * Gets the async dependencies of a Resolvable
+   *
+   * Given a Resolvable, returns its dependencies as a Resolvable[]
+   */
+  getDependencies(resolvable) {
+    const node = this.findNode(resolvable);
+    // Find which other resolvables are "visible" to the `resolvable` argument
+    // subpath stopping at resolvable's node, or the whole path (if the resolvable isn't in the path)
+    const subPath =
+      PathUtils.subPath(this._path, (x) => x === node) || this._path;
+    const availableResolvables = subPath
+      .reduce((acc, _node) => acc.concat(_node.resolvables), []) // all of subpath's resolvables
+      .filter((res) => res !== resolvable); // filter out the `resolvable` argument
+    const getDependency = (token) => {
+      const matching = availableResolvables.filter((r) => r.token === token);
+      if (matching.length) return tail(matching);
+      const fromInjector = this.injector().getNative(token);
+      if (isUndefined(fromInjector)) {
+        throw new Error(
+          "Could not find Dependency Injection token: " + stringify(token),
+        );
+      }
+      return new Resolvable(token, () => fromInjector, [], fromInjector);
+    };
+    return resolvable.deps.map(getDependency);
+  }
+}
+/** @internal */
+class UIInjectorImpl {
+  constructor(context) {
+    this.context = context;
+    this.native = this.get(NATIVE_INJECTOR_TOKEN) || services.$injector;
+  }
+  get(token) {
+    const resolvable = this.context.getResolvable(token);
+    if (resolvable) {
+      if (this.context.getPolicy(resolvable).async === "NOWAIT") {
+        return resolvable.get(this.context);
+      }
+      if (!resolvable.resolved) {
+        throw new Error(
+          "Resolvable async .get() not complete:" + stringify(resolvable.token),
+        );
+      }
+      return resolvable.data;
+    }
+    return this.getNative(token);
+  }
+  getAsync(token) {
+    const resolvable = this.context.getResolvable(token);
+    if (resolvable) return resolvable.get(this.context);
+    return services.$q.when(this.native.get(token));
+  }
+  getNative(token) {
+    return this.native && this.native.get(token);
+  }
+}