@angular-wave/angular.ts 0.9.3 → 0.9.5

package/src/router/path/path-utils.js

@@ -1,207 +0,0 @@
-import { find, pick, omit, unnestR, arrayTuples } from "../../shared/common.js";
-import { propEq } from "../../shared/hof.js";
-import { TargetState } from "../state/target-state.js";
-import { PathNode } from "./path-node.js";
-/**
- * This class contains functions which convert TargetStates, Nodes and paths from one type to another.
- */
-export class PathUtils {
-  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) => states.includes(node.state))
-      .forEach((node) => {
-        const viewDecls = Object.values(node.state.views || {});
-        const subPath = PathUtils.subPath(path, (n) => n === node);
-        const viewConfigs = viewDecls.map((view) => {
-          return $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) {
-      /** @type {PathNode} */
-      const node = find(path, propEq("state", state));
-      return Object.assign({}, node && node.paramValues);
-    }
-    const noInherit = fromPath
-      .map((node) => node.paramSchema)
-      .reduce(unnestR, [])
-      .filter((param) => !param.inherit)
-      .map((x) => x.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 = Object.assign({}, 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 = Object.assign(
-        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.
-   * @param {PathNode[]} fromPath
-   * @param {PathNode[]} toPath
-   * @param {boolean} [reloadState]
-   * @returns {import("../transition/interface.js").TreeChanges}
-   */
-  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);
-  }
-
-  static nonDynamicParams(node) {
-    return node.state
-      .parameters({ inherit: false })
-      .filter((param) => !param.dynamic);
-  }
-
-  /** Gets the raw parameter values from a path */
-  static paramValues(path) {
-    return path.reduce((acc, node) => Object.assign(acc, node.paramValues), {});
-  }
-}
-
-/** Given a PathNode[], create an TargetState
- * @param {import("../state/state-registry.js").StateRegistryProvider} registry
- * @param {Array<PathNode>} path
- * @returns
- */
-export function makeTargetState(registry, path) {
-  return new TargetState(
-    registry,
-    path.at(-1).state,
-    path
-      .map((x) => x.paramValues)
-      .reduce((acc, obj) => ({ ...acc, ...obj }), {}),
-    {},
-  );
-}

package/src/router/resolve/interface.ts

@@ -1,208 +0,0 @@
-/**
- * # The Resolve subsystem
- *
- * This subsystem is an asynchronous, hierarchical Dependency Injection system.
- *
- * Typically, resolve is configured on a state using a [[StateDeclaration.resolve]] declaration.
- *
- * @packageDocumentation
- */
-/**
- * An interface which is similar to an Angular 2 `Provider`
- */
-export interface ProviderLike {
-  provide: any;
-  useClass?: any;
-  useFactory?: Function;
-  useValue?: any;
-  useExisting?: any;
-  deps?: any[];
-}
-
-/**
- * A plain object used to describe a [[Resolvable]]
- *
- * These objects may be used in the [[StateDeclaration.resolve]] array to declare
- * async data that the state or substates require.
- *
- * #### Example:
- * ```js
- *
- * var state = {
- *   name: 'main',
- *   resolve: [
- *     { token: 'myData', deps: [MyDataApi], resolveFn: (myDataApi) => myDataApi.getData() },
- *   ],
- * }
- * ```
- */
-export interface ResolvableLiteral {
-  /**
-   * A Dependency Injection token
-   *
-   * This Resolvable's DI token.
-   * The Resolvable will be injectable elsewhere using the token.
-   */
-  token: any;
-
-  /**
-   * A function which fetches the Resolvable's data
-   *
-   * A function which returns one of:
-   *
-   * - The resolved value (synchronously)
-   * - A promise for the resolved value
-   * - An Observable of the resolved value(s)
-   *
-   * This function will be provided the dependencies listed in [[deps]] as its arguments.
-   * The resolve system will asynchronously fetch the dependencies before invoking this function.
-   */
-  resolveFn: Function;
-
-  /**
-   * Defines the Resolve Policy
-   *
-   * A policy that defines when to invoke the resolve,
-   * and whether to wait for async and unwrap the data
-   */
-  policy?: ResolvePolicy;
-
-  /**
-   * The Dependency Injection tokens
-   *
-   * This is an array of Dependency Injection tokens for the dependencies of the [[resolveFn]].
-   *
-   * The DI tokens are references to other `Resolvables`, or to other
-   * services from the native DI system.
-   */
-  deps?: any[];
-
-  /** Pre-resolved data. */
-  data?: any;
-}
-
-/**
- * Defines how a resolve is processed during a transition
- *
- * This object is the [[StateDeclaration.resolvePolicy]] property.
- *
- * #### Example:
- * ```js
- * // Fetched when the resolve's state is being entered.
- * // Wait for the promise to resolve.
- * var policy1 = { when: "LAZY", async: "WAIT" }
- *
- * // Fetched when the Transition is starting.
- * // Do not wait for the returned promise to resolve.
- * // Inject the raw promise/value
- * var policy2 = { when: "EAGER", async: "NOWAIT" }
- * ```
- *
- * The policy for a given Resolvable is merged from three sources (highest priority first):
- *
- * - 1) Individual resolve definition
- * - 2) State definition
- * - 3) Global default
- *
- * #### Example:
- * ```js
- * // Wait for an Observable to emit one item.
- * // Since `wait` is not specified, it uses the `wait`
- * // policy defined on the state, or the global default
- * // if no `wait` policy is defined on the state
- * import { RXWAIT } from '@uirouter/rx';
- *
- * var myResolvablePolicy = { async: RXWAIT }
- * ```
- */
-export interface ResolvePolicy {
-  /**
-   * Defines when a Resolvable is resolved (fetched) during a transition
-   *
-   * - `LAZY` (default)
-   *   - Resolved as the resolve's state is being entered
-   * - `EAGER`
-   *   - Resolved as the transition is starting
-   *
-   * #### Example:
-   * Resolves for `main` and `main.home` are fetched when each state is entered.
-   * All of `main` resolves are processed before fetching `main.home` resolves.
-   * ```js
-   * var state = {
-   *   name: 'main',
-   *   resolve: mainResolves, // defined elsewhere
-   *   resolvePolicy: { when: 'LAZY' }, // default
-   * }
-   *
-   * var state = {
-   *   name: 'main.home',
-   *   resolve: homeResolves, // defined elsewhere
-   *   resolvePolicy: { when: 'LAZY' }, // default
-   * }
-   * ```
-   *
-   * #### Example:
-   * Resolves for `main` and `main.home` are fetched at the same time when the transition starts.
-   * This happens earlier in the lifecycle than when states are entered.
-   * All of the `main` and `main.home` resolves are fetched as soon as possible.
-   * ```js
-   * var mainState = {
-   *   name: 'main',
-   *   resolve: mainResolves, // defined elsewhere
-   *   resolvePolicy: { when: 'EAGER' },
-   * }
-   *
-   * var homeState = {
-   *   name: 'main.home',
-   *   resolve: homeResolves, // defined elsewhere
-   *   resolvePolicy: { when: 'EAGER' },
-   * }
-   * ```
-   */
-  when?: PolicyWhen;
-
-  /**
-   * Determines the unwrapping behavior of asynchronous resolve values.
-   *
-   * - `WAIT` (default)
-   *   - If a promise is returned from the resolveFn, wait for the promise before proceeding
-   *   - The unwrapped value from the promise
-   * - `NOWAIT`
-   *   - If a promise is returned from the resolve, do not wait for the promise.
-   *   - Any other value returned is wrapped in a promise.
-   *   - The promise will not be unwrapped.
-   *   - The promise itself will be provided when the resolve is injected or bound elsewhere.
-   * - {@link CustomAsyncPolicy}
-   *   - You can define a custom function that will be called with the resolveFn value.
-   *   - This function must return a promise.
-   *   - The transition will wait for this promise before proceeding
-   *
-   *   NOTE: The previous `RXWAIT` policy has become a CustomAsyncPolicy function exported in `@uirouter/rx` package.
-   *
-   * #### Example:
-   * The `Transition` will not wait for the resolve promise(s) from `main` to settle before continuing.
-   * Resolves for `main` will be provided to components wrapped in a `Promise`.
-   *
-   * The `Transition` will wait for the `main.home` resolve promises.
-   * Resolved values will be unwrapped before being provided to components.
-   * ```js
-   * var mainState = {
-   *   name: 'main',
-   *   resolve: mainResolves, // defined elsewhere
-   *   resolvePolicy: { async: 'NOWAIT' },
-   * }
-   * var homeState = {
-   *   name: 'main.home',
-   *   resolve: homeResolves, // defined elsewhere
-   *   resolvePolicy: { async: 'WAIT' }, // default
-   * }
-   * ```
-   */
-  async?: PolicyAsync;
-}
-
-export type PolicyWhen = "LAZY" | "EAGER";
-export type PolicyAsync = "WAIT" | "NOWAIT" | CustomAsyncPolicy;
-export interface CustomAsyncPolicy {
-  (data: any): Promise<any>;
-}

package/src/router/resolve/resolvable.js

@@ -1,123 +0,0 @@
-import {
-  assert,
-  isFunction,
-  isObject,
-  isNullOrUndefined,
-  hasOwn,
-} from "../../shared/utils.js";
-import { trace } from "../common/trace.js";
-import { stringify } from "../../shared/strings.js";
-
-// 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) {
-      Object.assign(this, arg1);
-    } else if (isFunction(resolveFn)) {
-      assert(!isNullOrUndefined(arg1), "token argument is required");
-      this.token = arg1;
-      this.policy = policy;
-      this.resolveFn = resolveFn;
-      this.deps = deps || [];
-      this.data = data;
-      this.resolved = data !== undefined;
-      this.promise = this.resolved ? Promise.resolve(this.data) : undefined;
-    } else if (
-      isObject(arg1) &&
-      arg1.token &&
-      (hasOwn(arg1, "resolveFn") || hasOwn(arg1, "data"))
-    ) {
-      this.token = arg1.token;
-      this.resolveFn = arg1.resolveFn;
-      this.deps = arg1.deps;
-      this.policy = arg1.policy;
-      this.data = arg1.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) {
-    // Gets all dependencies from ResolveContext and wait for them to be resolved
-    const getResolvableDependencies = () =>
-      Promise.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 : (x) => x;
-    // 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.
-    this.promise = Promise.resolve()
-      .then(getResolvableDependencies)
-      .then(invokeResolveFn)
-      .then(customAsyncPolicy)
-      .then(applyResolvedValue);
-    return this.promise;
-  }
-  /**
-   * 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);