@angular-wave/angular.ts 0.0.11 → 0.0.13

package/src/router/core/state/targetState.js

@@ -0,0 +1,159 @@
+import { isObject, isString } from "../common/predicates";
+import { stringify } from "../common/strings";
+import { extend } from "../common/common";
+/**
+ * Encapsulate the target (destination) state/params/options of a [[Transition]].
+ *
+ * This class is frequently used to redirect a transition to a new destination.
+ *
+ * See:
+ *
+ * - [[HookResult]]
+ * - [[TransitionHookFn]]
+ * - [[TransitionService.onStart]]
+ *
+ * To create a `TargetState`, use [[StateService.target]].
+ *
+ * ---
+ *
+ * This class wraps:
+ *
+ * 1) an identifier for a state
+ * 2) a set of parameters
+ * 3) and transition options
+ * 4) the registered state object (the [[StateDeclaration]])
+ *
+ * Many UI-Router APIs such as [[StateService.go]] take a [[StateOrName]] argument which can
+ * either be a *state object* (a [[StateDeclaration]] or [[StateObject]]) or a *state name* (a string).
+ * The `TargetState` class normalizes those options.
+ *
+ * A `TargetState` may be valid (the state being targeted exists in the registry)
+ * or invalid (the state being targeted is not registered).
+ */
+export class TargetState {
+  /**
+   * The TargetState constructor
+   *
+   * Note: Do not construct a `TargetState` manually.
+   * To create a `TargetState`, use the [[StateService.target]] factory method.
+   *
+   * @param _stateRegistry The StateRegistry to use to look up the _definition
+   * @param _identifier An identifier for a state.
+   *    Either a fully-qualified state name, or the object used to define the state.
+   * @param _params Parameters for the target state
+   * @param _options Transition options.
+   *
+   * @internal
+   */
+  constructor(_stateRegistry, _identifier, _params, _options) {
+    this._stateRegistry = _stateRegistry;
+    this._identifier = _identifier;
+    this._identifier = _identifier;
+    this._params = extend({}, _params || {});
+    this._options = extend({}, _options || {});
+    this._definition = _stateRegistry.matcher.find(
+      _identifier,
+      this._options.relative,
+    );
+  }
+  /** The name of the state this object targets */
+  name() {
+    return (this._definition && this._definition.name) || this._identifier;
+  }
+  /** The identifier used when creating this TargetState */
+  identifier() {
+    return this._identifier;
+  }
+  /** The target parameter values */
+  params() {
+    return this._params;
+  }
+  /** The internal state object (if it was found) */
+  $state() {
+    return this._definition;
+  }
+  /** The internal state declaration (if it was found) */
+  state() {
+    return this._definition && this._definition.self;
+  }
+  /** The target options */
+  options() {
+    return this._options;
+  }
+  /** True if the target state was found */
+  exists() {
+    return !!(this._definition && this._definition.self);
+  }
+  /** True if the object is valid */
+  valid() {
+    return !this.error();
+  }
+  /** If the object is invalid, returns the reason why */
+  error() {
+    const base = this.options().relative;
+    if (!this._definition && !!base) {
+      const stateName = base.name ? base.name : base;
+      return `Could not resolve '${this.name()}' from state '${stateName}'`;
+    }
+    if (!this._definition) return `No such state '${this.name()}'`;
+    if (!this._definition.self)
+      return `State '${this.name()}' has an invalid definition`;
+  }
+  toString() {
+    return `'${this.name()}'${stringify(this.params())}`;
+  }
+  /**
+   * Returns a copy of this TargetState which targets a different state.
+   * The new TargetState has the same parameter values and transition options.
+   *
+   * @param state The new state that should be targeted
+   */
+  withState(state) {
+    return new TargetState(
+      this._stateRegistry,
+      state,
+      this._params,
+      this._options,
+    );
+  }
+  /**
+   * Returns a copy of this TargetState, using the specified parameter values.
+   *
+   * @param params the new parameter values to use
+   * @param replace When false (default) the new parameter values will be merged with the current values.
+   *                When true the parameter values will be used instead of the current values.
+   */
+  withParams(params, replace = false) {
+    const newParams = replace ? params : extend({}, this._params, params);
+    return new TargetState(
+      this._stateRegistry,
+      this._identifier,
+      newParams,
+      this._options,
+    );
+  }
+  /**
+   * Returns a copy of this TargetState, using the specified Transition Options.
+   *
+   * @param options the new options to use
+   * @param replace When false (default) the new options will be merged with the current options.
+   *                When true the options will be used instead of the current options.
+   */
+  withOptions(options, replace = false) {
+    const newOpts = replace ? options : extend({}, this._options, options);
+    return new TargetState(
+      this._stateRegistry,
+      this._identifier,
+      this._params,
+      newOpts,
+    );
+  }
+}
+/** Returns true if the object has a state property that might be a state or state name */
+TargetState.isDef = (obj) => {
+  return (
+    obj &&
+    obj.state &&
+    (isString(obj.state) || (isObject(obj.state) && isString(obj.state.name)))
+  );
+};

package/src/router/core/transition/hookBuilder.js

@@ -0,0 +1,127 @@
+import { extend, assertPredicate, unnestR, identity } from "../common/common";
+import { isArray } from "../common/predicates";
+import { TransitionHookPhase, TransitionHookScope } from "./interface";
+import { TransitionHook } from "./transitionHook";
+/**
+ * This class returns applicable TransitionHooks for a specific Transition instance.
+ *
+ * Hooks ([[RegisteredHook]]) may be registered globally, e.g., $transitions.onEnter(...), or locally, e.g.
+ * myTransition.onEnter(...).  The HookBuilder finds matching RegisteredHooks (where the match criteria is
+ * determined by the type of hook)
+ *
+ * The HookBuilder also converts RegisteredHooks objects to TransitionHook objects, which are used to run a Transition.
+ *
+ * The HookBuilder constructor is given the $transitions service and a Transition instance.  Thus, a HookBuilder
+ * instance may only be used for one specific Transition object. (side note: the _treeChanges accessor is private
+ * in the Transition class, so we must also provide the Transition's _treeChanges)
+ */
+export class HookBuilder {
+  constructor(transition) {
+    this.transition = transition;
+  }
+  buildHooksForPhase(phase) {
+    const $transitions = this.transition.router.transitionService;
+    return $transitions._pluginapi
+      ._getEvents(phase)
+      .map((type) => this.buildHooks(type))
+      .reduce(unnestR, [])
+      .filter(identity);
+  }
+  /**
+   * Returns an array of newly built TransitionHook objects.
+   *
+   * - Finds all RegisteredHooks registered for the given `hookType` which matched the transition's [[TreeChanges]].
+   * - Finds [[PathNode]] (or `PathNode[]`) to use as the TransitionHook context(s)
+   * - For each of the [[PathNode]]s, creates a TransitionHook
+   *
+   * @param hookType the type of the hook registration function, e.g., 'onEnter', 'onFinish'.
+   */
+  buildHooks(hookType) {
+    const transition = this.transition;
+    const treeChanges = transition.treeChanges();
+    // Find all the matching registered hooks for a given hook type
+    const matchingHooks = this.getMatchingHooks(
+      hookType,
+      treeChanges,
+      transition,
+    );
+    if (!matchingHooks) return [];
+    const baseHookOptions = {
+      transition: transition,
+      current: transition.options().current,
+    };
+    const makeTransitionHooks = (hook) => {
+      // Fetch the Nodes that caused this hook to match.
+      const matches = hook.matches(treeChanges, transition);
+      // Select the PathNode[] that will be used as TransitionHook context objects
+      const matchingNodes = matches[hookType.criteriaMatchPath.name];
+      // Return an array of HookTuples
+      return matchingNodes.map((node) => {
+        const _options = extend(
+          {
+            bind: hook.bind,
+            traceData: { hookType: hookType.name, context: node },
+          },
+          baseHookOptions,
+        );
+        const state =
+          hookType.criteriaMatchPath.scope === TransitionHookScope.STATE
+            ? node.state.self
+            : null;
+        const transitionHook = new TransitionHook(
+          transition,
+          state,
+          hook,
+          _options,
+        );
+        return { hook, node, transitionHook };
+      });
+    };
+    return matchingHooks
+      .map(makeTransitionHooks)
+      .reduce(unnestR, [])
+      .sort(tupleSort(hookType.reverseSort))
+      .map((tuple) => tuple.transitionHook);
+  }
+  /**
+   * Finds all RegisteredHooks from:
+   * - The Transition object instance hook registry
+   * - The TransitionService ($transitions) global hook registry
+   *
+   * which matched:
+   * - the eventType
+   * - the matchCriteria (to, from, exiting, retained, entering)
+   *
+   * @returns an array of matched [[RegisteredHook]]s
+   */
+  getMatchingHooks(hookType, treeChanges, transition) {
+    const isCreate = hookType.hookPhase === TransitionHookPhase.CREATE;
+    // Instance and Global hook registries
+    const $transitions = this.transition.router.transitionService;
+    const registries = isCreate
+      ? [$transitions]
+      : [this.transition, $transitions];
+    return registries
+      .map((reg) => reg.getHooks(hookType.name)) // Get named hooks from registries
+      .filter(assertPredicate(isArray, `broken event named: ${hookType.name}`)) // Sanity check
+      .reduce(unnestR, []) // Un-nest RegisteredHook[][] to RegisteredHook[] array
+      .filter((hook) => hook.matches(treeChanges, transition)); // Only those satisfying matchCriteria
+  }
+}
+/**
+ * A factory for a sort function for HookTuples.
+ *
+ * The sort function first compares the PathNode depth (how deep in the state tree a node is), then compares
+ * the EventHook priority.
+ *
+ * @param reverseDepthSort a boolean, when true, reverses the sort order for the node depth
+ * @returns a tuple sort function
+ */
+function tupleSort(reverseDepthSort = false) {
+  return function nodeDepthThenPriority(l, r) {
+    const factor = reverseDepthSort ? -1 : 1;
+    const depthDelta =
+      (l.node.state.path.length - r.node.state.path.length) * factor;
+    return depthDelta !== 0 ? depthDelta : r.hook.priority - l.hook.priority;
+  };
+}

package/src/router/core/transition/hookRegistry.js

@@ -0,0 +1,175 @@
+import { extend, removeFrom, tail, identity, mapObj } from "../common/common";
+import { isString, isFunction } from "../common/predicates";
+import { Glob } from "../common/glob";
+import {
+  // has or is using
+  TransitionHookScope,
+} from "./interface";
+/**
+ * Determines if the given state matches the matchCriteria
+ *
+ * @internal
+ *
+ * @param state a State Object to test against
+ * @param criterion
+ * - If a string, matchState uses the string as a glob-matcher against the state name
+ * - If an array (of strings), matchState uses each string in the array as a glob-matchers against the state name
+ *   and returns a positive match if any of the globs match.
+ * - If a function, matchState calls the function with the state and returns true if the function's result is truthy.
+ * @returns {boolean}
+ */
+export function matchState(state, criterion, transition) {
+  const toMatch = isString(criterion) ? [criterion] : criterion;
+  function matchGlobs(_state) {
+    const globStrings = toMatch;
+    for (let i = 0; i < globStrings.length; i++) {
+      const glob = new Glob(globStrings[i]);
+      if (
+        (glob && glob.matches(_state.name)) ||
+        (!glob && globStrings[i] === _state.name)
+      ) {
+        return true;
+      }
+    }
+    return false;
+  }
+  const matchFn = isFunction(toMatch) ? toMatch : matchGlobs;
+  return !!matchFn(state, transition);
+}
+/**
+ * The registration data for a registered transition hook
+ */
+export class RegisteredHook {
+  constructor(
+    tranSvc,
+    eventType,
+    callback,
+    matchCriteria,
+    removeHookFromRegistry,
+    options = {},
+  ) {
+    this.tranSvc = tranSvc;
+    this.eventType = eventType;
+    this.callback = callback;
+    this.matchCriteria = matchCriteria;
+    this.removeHookFromRegistry = removeHookFromRegistry;
+    this.invokeCount = 0;
+    this._deregistered = false;
+    this.priority = options.priority || 0;
+    this.bind = options.bind || null;
+    this.invokeLimit = options.invokeLimit;
+  }
+  /**
+   * Gets the matching [[PathNode]]s
+   *
+   * Given an array of [[PathNode]]s, and a [[HookMatchCriterion]], returns an array containing
+   * the [[PathNode]]s that the criteria matches, or `null` if there were no matching nodes.
+   *
+   * Returning `null` is significant to distinguish between the default
+   * "match-all criterion value" of `true` compared to a `() => true` function,
+   * when the nodes is an empty array.
+   *
+   * This is useful to allow a transition match criteria of `entering: true`
+   * to still match a transition, even when `entering === []`.  Contrast that
+   * with `entering: (state) => true` which only matches when a state is actually
+   * being entered.
+   */
+  _matchingNodes(nodes, criterion, transition) {
+    if (criterion === true) return nodes;
+    const matching = nodes.filter((node) =>
+      matchState(node.state, criterion, transition),
+    );
+    return matching.length ? matching : null;
+  }
+  /**
+   * Gets the default match criteria (all `true`)
+   *
+   * Returns an object which has all the criteria match paths as keys and `true` as values, i.e.:
+   *
+   * ```js
+   * {
+   *   to: true,
+   *   from: true,
+   *   entering: true,
+   *   exiting: true,
+   *   retained: true,
+   * }
+   */
+  _getDefaultMatchCriteria() {
+    return mapObj(this.tranSvc._pluginapi._getPathTypes(), () => true);
+  }
+  /**
+   * Gets matching nodes as [[IMatchingNodes]]
+   *
+   * Create a IMatchingNodes object from the TransitionHookTypes that is roughly equivalent to:
+   *
+   * ```js
+   * let matches: IMatchingNodes = {
+   *   to:       _matchingNodes([tail(treeChanges.to)],   mc.to),
+   *   from:     _matchingNodes([tail(treeChanges.from)], mc.from),
+   *   exiting:  _matchingNodes(treeChanges.exiting,      mc.exiting),
+   *   retained: _matchingNodes(treeChanges.retained,     mc.retained),
+   *   entering: _matchingNodes(treeChanges.entering,     mc.entering),
+   * };
+   * ```
+   */
+  _getMatchingNodes(treeChanges, transition) {
+    const criteria = extend(
+      this._getDefaultMatchCriteria(),
+      this.matchCriteria,
+    );
+    const paths = Object.values(this.tranSvc._pluginapi._getPathTypes());
+    return paths.reduce((mn, pathtype) => {
+      // STATE scope criteria matches against every node in the path.
+      // TRANSITION scope criteria matches against only the last node in the path
+      const isStateHook = pathtype.scope === TransitionHookScope.STATE;
+      const path = treeChanges[pathtype.name] || [];
+      const nodes = isStateHook ? path : [tail(path)];
+      mn[pathtype.name] = this._matchingNodes(
+        nodes,
+        criteria[pathtype.name],
+        transition,
+      );
+      return mn;
+    }, {});
+  }
+  /**
+   * Determines if this hook's [[matchCriteria]] match the given [[TreeChanges]]
+   *
+   * @returns an IMatchingNodes object, or null. If an IMatchingNodes object is returned, its values
+   * are the matching [[PathNode]]s for each [[HookMatchCriterion]] (to, from, exiting, retained, entering)
+   */
+  matches(treeChanges, transition) {
+    const matches = this._getMatchingNodes(treeChanges, transition);
+    // Check if all the criteria matched the TreeChanges object
+    const allMatched = Object.values(matches).every(identity);
+    return allMatched ? matches : null;
+  }
+  deregister() {
+    this.removeHookFromRegistry(this);
+    this._deregistered = true;
+  }
+}
+/** Return a registration function of the requested type. */
+export function makeEvent(registry, transitionService, eventType) {
+  // Create the object which holds the registered transition hooks.
+  const _registeredHooks = (registry._registeredHooks =
+    registry._registeredHooks || {});
+  const hooks = (_registeredHooks[eventType.name] = []);
+  const removeHookFn = removeFrom(hooks);
+  // Create hook registration function on the IHookRegistry for the event
+  registry[eventType.name] = hookRegistrationFn;
+  function hookRegistrationFn(matchObject, callback, options = {}) {
+    const registeredHook = new RegisteredHook(
+      transitionService,
+      eventType,
+      callback,
+      matchObject,
+      removeHookFn,
+      options,
+    );
+    hooks.push(registeredHook);
+    return registeredHook.deregister.bind(registeredHook);
+  }
+  return hookRegistrationFn;
+}

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

@@ -0,0 +1,14 @@
+var TransitionHookPhase;
+(function (TransitionHookPhase) {
+  TransitionHookPhase[(TransitionHookPhase["CREATE"] = 0)] = "CREATE";
+  TransitionHookPhase[(TransitionHookPhase["BEFORE"] = 1)] = "BEFORE";
+  TransitionHookPhase[(TransitionHookPhase["RUN"] = 2)] = "RUN";
+  TransitionHookPhase[(TransitionHookPhase["SUCCESS"] = 3)] = "SUCCESS";
+  TransitionHookPhase[(TransitionHookPhase["ERROR"] = 4)] = "ERROR";
+})(TransitionHookPhase || (TransitionHookPhase = {}));
+var TransitionHookScope;
+(function (TransitionHookScope) {
+  TransitionHookScope[(TransitionHookScope["TRANSITION"] = 0)] = "TRANSITION";
+  TransitionHookScope[(TransitionHookScope["STATE"] = 1)] = "STATE";
+})(TransitionHookScope || (TransitionHookScope = {}));
+export { TransitionHookPhase, TransitionHookScope };

package/src/router/core/transition/rejectFactory.js

@@ -0,0 +1,122 @@
+"use strict";
+import { extend, silentRejection } from "../common/common";
+import { stringify } from "../common/strings";
+import { is } from "../common/hof";
+/** An enum for Transition Rejection reasons */
+var RejectType;
+(function (RejectType) {
+  /**
+   * A new transition superseded this one.
+   *
+   * While this transition was running, a new transition started.
+   * This transition is cancelled because it was superseded by new transition.
+   */
+  RejectType[(RejectType["SUPERSEDED"] = 2)] = "SUPERSEDED";
+  /**
+   * The transition was aborted
+   *
+   * The transition was aborted by a hook which returned `false`
+   */
+  RejectType[(RejectType["ABORTED"] = 3)] = "ABORTED";
+  /**
+   * The transition was invalid
+   *
+   * The transition was never started because it was invalid
+   */
+  RejectType[(RejectType["INVALID"] = 4)] = "INVALID";
+  /**
+   * The transition was ignored
+   *
+   * The transition was ignored because it would have no effect.
+   *
+   * Either:
+   *
+   * - The transition is targeting the current state and parameter values
+   * - The transition is targeting the same state and parameter values as the currently running transition.
+   */
+  RejectType[(RejectType["IGNORED"] = 5)] = "IGNORED";
+  /**
+   * The transition errored.
+   *
+   * This generally means a hook threw an error or returned a rejected promise
+   */
+  RejectType[(RejectType["ERROR"] = 6)] = "ERROR";
+})(RejectType || (RejectType = {}));
+export { RejectType };
+/** @internal */
+let id = 0;
+export class Rejection {
+  /** Returns true if the obj is a rejected promise created from the `asPromise` factory */
+  static isRejectionPromise(obj) {
+    return (
+      obj &&
+      typeof obj.then === "function" &&
+      is(Rejection)(obj._transitionRejection)
+    );
+  }
+  /** Returns a Rejection due to transition superseded */
+  static superseded(detail, options) {
+    const message =
+      "The transition has been superseded by a different transition";
+    const rejection = new Rejection(RejectType.SUPERSEDED, message, detail);
+    if (options && options.redirected) {
+      rejection.redirected = true;
+    }
+    return rejection;
+  }
+  /** Returns a Rejection due to redirected transition */
+  static redirected(detail) {
+    return Rejection.superseded(detail, { redirected: true });
+  }
+  /** Returns a Rejection due to invalid transition */
+  static invalid(detail) {
+    const message = "This transition is invalid";
+    return new Rejection(RejectType.INVALID, message, detail);
+  }
+  /** Returns a Rejection due to ignored transition */
+  static ignored(detail) {
+    const message = "The transition was ignored";
+    return new Rejection(RejectType.IGNORED, message, detail);
+  }
+  /** Returns a Rejection due to aborted transition */
+  static aborted(detail) {
+    const message = "The transition has been aborted";
+    return new Rejection(RejectType.ABORTED, message, detail);
+  }
+  /** Returns a Rejection due to aborted transition */
+  static errored(detail) {
+    const message = "The transition errored";
+    return new Rejection(RejectType.ERROR, message, detail);
+  }
+  /**
+   * Returns a Rejection
+   *
+   * Normalizes a value as a Rejection.
+   * If the value is already a Rejection, returns it.
+   * Otherwise, wraps and returns the value as a Rejection (Rejection type: ERROR).
+   *
+   * @returns `detail` if it is already a `Rejection`, else returns an ERROR Rejection.
+   */
+  static normalize(detail) {
+    return is(Rejection)(detail) ? detail : Rejection.errored(detail);
+  }
+  constructor(type, message, detail) {
+    /** @internal */
+    this.$id = id++;
+    this.type = type;
+    this.message = message;
+    this.detail = detail;
+  }
+  toString() {
+    const detailString = (d) =>
+      d && d.toString !== Object.prototype.toString
+        ? d.toString()
+        : stringify(d);
+    const detail = detailString(this.detail);
+    const { $id, type, message } = this;
+    return `Transition Rejection($id: ${$id} type: ${type}, message: ${message}, detail: ${detail})`;
+  }
+  toPromise() {
+    return extend(silentRejection(this), { _transitionRejection: this });
+  }
+}