@angular-wave/angular.ts 0.9.3 → 0.9.5

package/src/router/transition/reject-factory.js

@@ -1,122 +0,0 @@
-import { silentRejection } from "../../shared/common.js";
-import { stringify } from "../../shared/strings.js";
-import { is } from "../../shared/hof.js";
-
-/**
- * An object for Transition Rejection reasons.
- * @enum {number}
- */
-export const 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 a new transition.
-   * @type {number}
-   */
-  SUPERSEDED: 2,
-
-  /**
-   * The transition was aborted.
-   *
-   * The transition was aborted by a hook which returned `false`.
-   * @type {number}
-   */
-  ABORTED: 3,
-
-  /**
-   * The transition was invalid.
-   *
-   * The transition was never started because it was invalid.
-   * @type {number}
-   */
-  INVALID: 4,
-
-  /**
-   * 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.
-   * @type {number}
-   */
-  IGNORED: 5,
-
-  /**
-   * The transition errored.
-   *
-   * This generally means a hook threw an error or returned a rejected promise.
-   * @type {number}
-   */
-  ERROR: 6,
-};
-
-let id = 0;
-export class Rejection {
-  /** 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) {
-    this.$id = id++;
-    this.type = type;
-    this.message = message;
-    this.detail = detail;
-    this.redirected = false;
-  }
-  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 Object.assign(silentRejection(this), { _transitionRejection: this });
-  }
-}

package/src/router/transition/transition-event-type.js

@@ -1,26 +0,0 @@
-import { TransitionHook } from "./transition-hook.js";
-/**
- * This class defines a type of hook, such as `onBefore` or `onEnter`.
- * Plugins can define custom hook types, such as sticky states does for `onInactive`.
- */
-export class TransitionEventType {
-  constructor(
-    name,
-    hookPhase,
-    hookOrder,
-    criteriaMatchPath,
-    reverseSort = false,
-    getResultHandler = TransitionHook.HANDLE_RESULT,
-    getErrorHandler = TransitionHook.REJECT_ERROR,
-    synchronous = false,
-  ) {
-    this.name = name;
-    this.hookPhase = hookPhase;
-    this.hookOrder = hookOrder;
-    this.criteriaMatchPath = criteriaMatchPath;
-    this.reverseSort = reverseSort;
-    this.getResultHandler = getResultHandler;
-    this.getErrorHandler = getErrorHandler;
-    this.synchronous = synchronous;
-  }
-}

package/src/router/transition/transition-hook.js

@@ -1,199 +0,0 @@
-import { TransitionHookPhase } from "./interface.js";
-import { defaults, silentRejection } from "../../shared/common.js";
-import { fnToString, maxLength } from "../../shared/strings.js";
-import { isPromise } from "../../shared/predicates.js";
-import { parse } from "../../shared/hof.js";
-import { trace } from "../common/trace.js";
-import { Rejection } from "./reject-factory.js";
-import { TargetState } from "../state/target-state.js";
-import { EventBus } from "../../services/pubsub/pubsub.js";
-
-const defaultOptions = {
-  current: () => {},
-  transition: null,
-  traceData: {},
-  bind: null,
-};
-
-export class TransitionHook {
-  /**
-   * Chains together an array of TransitionHooks.
-   *
-   * Given a list of [[TransitionHook]] objects, chains them together.
-   * Each hook is invoked after the previous one completes.
-   *
-   * #### Example:
-   * ```js
-   * var hooks: TransitionHook[] = getHooks();
-   * let promise: Promise<any> = TransitionHook.chain(hooks);
-   *
-   * promise.then(handleSuccess, handleError);
-   * ```
-   *
-   * @param hooks the list of hooks to chain together
-   * @param waitFor if provided, the chain is `.then()`'ed off this promise
-   * @returns a `Promise` for sequentially invoking the hooks (in order)
-   */
-  static chain(hooks, waitFor) {
-    // Chain the next hook off the previous
-    const createHookChainR = (prev, nextHook) =>
-      prev.then(() => nextHook.invokeHook());
-    return hooks.reduce(createHookChainR, waitFor || Promise.resolve());
-  }
-
-  /**
-   * Invokes all the provided TransitionHooks, in order.
-   * Each hook's return value is checked.
-   * If any hook returns a promise, then the rest of the hooks are chained off that promise, and the promise is returned.
-   * If no hook returns a promise, then all hooks are processed synchronously.
-   *
-   * @param hooks the list of TransitionHooks to invoke
-   * @param doneCallback a callback that is invoked after all the hooks have successfully completed
-   *
-   * @returns a promise for the async result, or the result of the callback
-   */
-  static invokeHooks(hooks, doneCallback) {
-    for (let idx = 0; idx < hooks.length; idx++) {
-      const hookResult = hooks[idx].invokeHook();
-      if (isPromise(hookResult)) {
-        const remainingHooks = hooks.slice(idx + 1);
-        return TransitionHook.chain(remainingHooks, hookResult).then(() => {
-          doneCallback();
-        });
-      }
-    }
-    return doneCallback();
-  }
-
-  /**
-   * Run all TransitionHooks, ignoring their return value.
-   */
-  static runAllHooks(hooks) {
-    hooks.forEach((hook) => hook.invokeHook());
-  }
-
-  constructor(transition, stateContext, registeredHook, options) {
-    this.transition = transition;
-    this.stateContext = stateContext;
-    this.registeredHook = registeredHook;
-    this.options = options;
-    this.isSuperseded = () =>
-      this.type.hookPhase === TransitionHookPhase.RUN &&
-      !this.options.transition.isActive();
-    this.options = defaults(options, defaultOptions);
-    this.type = registeredHook.eventType;
-  }
-
-  logError(err) {
-    EventBus.publish("$stateService:defaultErrorHandler", err);
-  }
-
-  invokeHook() {
-    const hook = this.registeredHook;
-    if (hook._deregistered) return;
-    const notCurrent = this.getNotCurrentRejection();
-    if (notCurrent) return notCurrent;
-    const options = this.options;
-    trace.traceHookInvocation(this, this.transition, options);
-    const invokeCallback = () =>
-      hook.callback.call(options.bind, this.transition, this.stateContext);
-    const normalizeErr = (err) => Rejection.normalize(err).toPromise();
-    const handleError = (err) => hook.eventType.getErrorHandler(this)(err);
-    const handleResult = (result) =>
-      hook.eventType.getResultHandler(this)(result);
-    try {
-      const result = invokeCallback();
-      if (!this.type.synchronous && isPromise(result)) {
-        return result.catch(normalizeErr).then(handleResult, handleError);
-      } else {
-        return handleResult(result);
-      }
-    } catch (err) {
-      // If callback throws (synchronously)
-      return handleError(Rejection.normalize(err));
-    } finally {
-      if (hook.invokeLimit && ++hook.invokeCount >= hook.invokeLimit) {
-        hook.deregister();
-      }
-    }
-  }
-  /**
-   * This method handles the return value of a Transition Hook.
-   *
-   * A hook can return false (cancel), a TargetState (redirect),
-   * or a promise (which may later resolve to false or a redirect)
-   *
-   * This also handles "transition superseded" -- when a new transition
-   * was started while the hook was still running
-   */
-  handleHookResult(result) {
-    const notCurrent = this.getNotCurrentRejection();
-    if (notCurrent) return notCurrent;
-    // Hook returned a promise
-    if (isPromise(result)) {
-      // Wait for the promise, then reprocess with the resulting value
-      return result.then((val) => this.handleHookResult(val));
-    }
-    trace.traceHookResult(result, this.transition);
-    // Hook returned false
-    if (result === false) {
-      // Abort this Transition
-      return Rejection.aborted("Hook aborted transition").toPromise();
-    }
-
-    // hook returned a TargetState
-    if (result instanceof TargetState) {
-      // Halt the current Transition and redirect (a new Transition) to the TargetState.
-      return Rejection.redirected(result).toPromise();
-    }
-  }
-  /**
-   * Return a Rejection promise if the transition is no longer current due
-   * a new transition has started and superseded this one.
-   */
-  getNotCurrentRejection() {
-    if (this.transition._aborted) {
-      return Rejection.aborted().toPromise();
-    }
-    // This transition is no longer current.
-    // Another transition started while this hook was still running.
-    if (this.isSuperseded()) {
-      // Abort this transition
-      return Rejection.superseded(this.options.current()).toPromise();
-    }
-  }
-  toString() {
-    const { options, registeredHook } = this;
-    const event = parse("traceData.hookType")(options) || "internal",
-      context =
-        parse("traceData.context.state.name")(options) ||
-        parse("traceData.context")(options) ||
-        "unknown",
-      name = fnToString(registeredHook.callback);
-    return `${event} context: ${context}, ${maxLength(200, name)}`;
-  }
-}
-/**
- * These GetResultHandler(s) are used by [[invokeHook]] below
- * Each HookType chooses a GetResultHandler (See: [[TransitionService._defineCoreEvents]])
- */
-TransitionHook.HANDLE_RESULT = (hook) => (result) =>
-  hook.handleHookResult(result);
-/**
- * If the result is a promise rejection, log it.
- * Otherwise, ignore the result.
- */
-TransitionHook.LOG_REJECTED_RESULT = (hook) => (result) => {
-  isPromise(result) &&
-    result.catch((err) => hook.logError(Rejection.normalize(err)));
-  return undefined;
-};
-/**
- * These GetErrorHandler(s) are used by [[invokeHook]] below
- * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])
- */
-TransitionHook.LOG_ERROR = (hook) => (error) => hook.logError(error);
-TransitionHook.REJECT_ERROR = () => (error) => silentRejection(error);
-TransitionHook.THROW_ERROR = () => (error) => {
-  throw error;
-};

package/src/router/transition/transition-service.js

@@ -1,302 +0,0 @@
-import { TransitionHookScope, TransitionHookPhase } from "./interface.js";
-import { Transition } from "./transition.js";
-import { makeEvent } from "./hook-registry.js";
-import {
-  registerAddCoreResolvables,
-  treeChangesCleanup,
-} from "../hooks/core-resolvables.js";
-import {
-  registerOnExitHook,
-  registerOnRetainHook,
-  registerOnEnterHook,
-} from "../hooks/on-enter-exit-retain.js";
-import {
-  registerEagerResolvePath,
-  registerLazyResolveState,
-  registerResolveRemaining,
-} from "../hooks/resolve.js";
-import {
-  registerActivateViews,
-  registerLoadEnteringViews,
-} from "../hooks/views.js";
-import { registerUpdateGlobalState } from "../hooks/update-globals.js";
-
-import { registerLazyLoadHook } from "../hooks/lazy-load.js";
-import { TransitionEventType } from "./transition-event-type.js";
-import { TransitionHook } from "./transition-hook.js";
-import { isDefined } from "../../shared/utils.js";
-import { createProxyFunctions } from "../../shared/common.js";
-import { val } from "../../shared/hof.js";
-import { registerIgnoredTransitionHook } from "../hooks/ignored-transition.js";
-import { registerInvalidTransitionHook } from "../hooks/invalid-transition.js";
-import { registerRedirectToHook } from "../hooks/redirect-to.js";
-import { registerUpdateUrl } from "../hooks/url.js";
-import { $injectTokens as $t, provider } from "../../injection-tokens.js";
-/**
- * The default [[Transition]] options.
- *
- * Include this object when applying custom defaults:
- * let reloadOpts = { reload: true, notify: true }
- * let options = defaults(theirOpts, customDefaults, defaultOptions);
- */
-export let defaultTransOpts = {
-  location: true,
-  relative: null,
-  inherit: false,
-  notify: true,
-  reload: false,
-  supercede: true,
-  custom: {},
-  current: () => null,
-  source: "unknown",
-};
-/**
- * This class provides services related to Transitions.
- *
- * - Most importantly, it allows global Transition Hooks to be registered.
- * - It allows the default transition error handler to be set.
- * - It also has a factory function for creating new [[Transition]] objects, (used internally by the [[StateService]]).
- *
- * At bootstrap, [[UIRouter]] creates a single instance (singleton) of this class.
- *
- * This API is located at `router.transitionService` ([[UIRouter.transitionService]])
- */
-export class TransitionProvider {
-  /* @ignore */ static $inject = provider([$t.$router, $t.$view]);
-
-  /**
-   * @param {import('../router.js').Router} globals
-   * @param viewService
-   */
-  constructor(globals, viewService) {
-    this._transitionCount = 0;
-    /** The transition hook types, such as `onEnter`, `onStart`, etc */
-    this._eventTypes = [];
-    /** @internal The registered transition hooks */
-    this._registeredHooks = {};
-    /** The  paths on a criteria object */
-    this._criteriaPaths = {};
-    this.globals = globals;
-    this.$view = viewService;
-    this._deregisterHookFns = {};
-    this._pluginapi = createProxyFunctions(val(this), {}, val(this), [
-      "_definePathType",
-      "_defineEvent",
-      "_getPathTypes",
-      "_getEvents",
-      "getHooks",
-    ]);
-    this._defineCorePaths();
-    this._defineCoreEvents();
-    this._registerCoreTransitionHooks();
-    globals.successfulTransitions.onEvict(treeChangesCleanup);
-  }
-
-  $get = [
-    $t.$state,
-    $t.$url,
-    $t.$stateRegistry,
-    $t.$view,
-    (stateService, urlService, stateRegistry, viewService) => {
-      // Lazy load state trees
-      this._deregisterHookFns.lazyLoad = registerLazyLoadHook(
-        this,
-        stateService,
-        urlService,
-        stateRegistry,
-      );
-
-      // After globals.current is updated at priority: 10000
-      this._deregisterHookFns.updateUrl = registerUpdateUrl(
-        this,
-        stateService,
-        urlService,
-      );
-
-      // Wire up redirectTo hook
-      this._deregisterHookFns.redirectTo = registerRedirectToHook(
-        this,
-        stateService,
-      );
-
-      this._deregisterHookFns.activateViews = registerActivateViews(
-        this,
-        viewService,
-      );
-      return this;
-    },
-  ];
-  /**
-   * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.
-   *
-   * Registers a transition lifecycle hook, which is invoked during transition construction.
-   *
-   * This low level hook should only be used by plugins.
-   * This can be a useful time for plugins to add resolves or mutate the transition as needed.
-   * The Sticky States plugin uses this hook to modify the treechanges.
-   *
-   * ### Lifecycle
-   *
-   * `onCreate` hooks are invoked *while a transition is being constructed*.
-   *
-   * ### Return value
-   *
-   * The hook's return value is ignored
-   *
-   * @internal
-   * @param criteria defines which Transitions the Hook should be invoked for.
-   * @param callback the hook function which will be invoked.
-   * @param options the registration options
-   * @returns a function which deregisters the hook.
-   */
-
-  /**
-   * Creates a new [[Transition]] object
-   *
-   * This is a factory function for creating new Transition objects.
-   * It is used internally by the [[StateService]] and should generally not be called by application code.
-   *
-   * @internal
-   * @param fromPath the path to the current state (the from state)
-   * @param targetState the target state (destination)
-   * @returns a Transition
-   */
-  create(fromPath, targetState) {
-    return new Transition(fromPath, targetState, this, this.globals);
-  }
-
-  _defineCoreEvents() {
-    const Phase = TransitionHookPhase;
-    const TH = TransitionHook;
-    const paths = this._criteriaPaths;
-    const NORMAL_SORT = false,
-      REVERSE_SORT = true;
-    const SYNCHRONOUS = true;
-    this._defineEvent(
-      "onCreate",
-      Phase.CREATE,
-      0,
-      paths.to,
-      NORMAL_SORT,
-      TH.LOG_REJECTED_RESULT,
-      TH.THROW_ERROR,
-      SYNCHRONOUS,
-    );
-    this._defineEvent("onBefore", Phase.BEFORE, 0, paths.to);
-    this._defineEvent("onStart", Phase.RUN, 0, paths.to);
-    this._defineEvent("onExit", Phase.RUN, 100, paths.exiting, REVERSE_SORT);
-    this._defineEvent("onRetain", Phase.RUN, 200, paths.retained);
-    this._defineEvent("onEnter", Phase.RUN, 300, paths.entering);
-    this._defineEvent("onFinish", Phase.RUN, 400, paths.to);
-    this._defineEvent(
-      "onSuccess",
-      Phase.SUCCESS,
-      0,
-      paths.to,
-      NORMAL_SORT,
-      TH.LOG_REJECTED_RESULT,
-      TH.LOG_ERROR,
-      SYNCHRONOUS,
-    );
-    this._defineEvent(
-      "onError",
-      Phase.ERROR,
-      0,
-      paths.to,
-      NORMAL_SORT,
-      TH.LOG_REJECTED_RESULT,
-      TH.LOG_ERROR,
-      SYNCHRONOUS,
-    );
-  }
-
-  _defineCorePaths() {
-    const { STATE, TRANSITION } = TransitionHookScope;
-    this._definePathType("to", TRANSITION);
-    this._definePathType("from", TRANSITION);
-    this._definePathType("exiting", STATE);
-    this._definePathType("retained", STATE);
-    this._definePathType("entering", STATE);
-  }
-
-  _defineEvent(
-    name,
-    hookPhase,
-    hookOrder,
-    criteriaMatchPath,
-    reverseSort = false,
-    getResultHandler = TransitionHook.HANDLE_RESULT,
-    getErrorHandler = TransitionHook.REJECT_ERROR,
-    synchronous = false,
-  ) {
-    const eventType = new TransitionEventType(
-      name,
-      hookPhase,
-      hookOrder,
-      criteriaMatchPath,
-      reverseSort,
-      getResultHandler,
-      getErrorHandler,
-      synchronous,
-    );
-    this._eventTypes.push(eventType);
-    makeEvent(this, this, eventType);
-  }
-
-  _getEvents(phase) {
-    const transitionHookTypes = isDefined(phase)
-      ? this._eventTypes.filter((type) => type.hookPhase === phase)
-      : this._eventTypes.slice();
-    return transitionHookTypes.sort((l, r) => {
-      const cmpByPhase = l.hookPhase - r.hookPhase;
-      return cmpByPhase === 0 ? l.hookOrder - r.hookOrder : cmpByPhase;
-    });
-  }
-  /**
-   * Adds a Path to be used as a criterion against a TreeChanges path
-   *
-   * For example: the `exiting` path in [[HookMatchCriteria]] is a STATE scoped path.
-   * It was defined by calling `defineTreeChangesCriterion('exiting', TransitionHookScope.STATE)`
-   * Each state in the exiting path is checked against the criteria and returned as part of the match.
-   *
-   * Another example: the `to` path in [[HookMatchCriteria]] is a TRANSITION scoped path.
-   * It was defined by calling `defineTreeChangesCriterion('to', TransitionHookScope.TRANSITION)`
-   * Only the tail of the `to` path is checked against the criteria and returned as part of the match.
-   *
-   * @internal
-   */
-  _definePathType(name, hookScope) {
-    this._criteriaPaths[name] = { name, scope: hookScope };
-  }
-
-  _getPathTypes() {
-    return this._criteriaPaths;
-  }
-
-  getHooks(hookName) {
-    return this._registeredHooks[hookName];
-  }
-
-  _registerCoreTransitionHooks() {
-    const fns = this._deregisterHookFns;
-    fns.addCoreResolves = registerAddCoreResolvables(this);
-    fns.ignored = registerIgnoredTransitionHook(this);
-    fns.invalid = registerInvalidTransitionHook(this);
-
-    // Wire up onExit/Retain/Enter state hooks
-    fns.onExit = registerOnExitHook(this);
-    fns.onRetain = registerOnRetainHook(this);
-    fns.onEnter = registerOnEnterHook(this);
-    // Wire up Resolve hooks
-    fns.eagerResolve = registerEagerResolvePath(this);
-    fns.lazyResolve = registerLazyResolveState(this);
-    fns.resolveAll = registerResolveRemaining(this);
-    // Wire up the View management hooks
-    fns.loadViews = registerLoadEnteringViews(this);
-
-    // Updates global state after a transition
-    fns.updateGlobals = registerUpdateGlobalState(this);
-    // Lazy load state trees
-    fns.lazyLoad = registerLazyLoadHook(this);
-  }
-}