@angular-wave/angular.ts 0.0.11 → 0.0.13

package/src/router/core/globals.js

@@ -0,0 +1,29 @@
+import { StateParams } from "./params/stateParams";
+import { Queue } from "./common/queue";
+/**
+ * Global router state
+ *
+ * This is where we hold the global mutable state such as current state, current
+ * params, current transition, etc.
+ */
+export class UIRouterGlobals {
+  constructor() {
+    /**
+     * Current parameter values
+     *
+     * The parameter values from the latest successful transition
+     */
+    this.params = new StateParams();
+    /** @internal */
+    this.lastStartedTransitionId = -1;
+    /** @internal */
+    this.transitionHistory = new Queue([], 1);
+    /** @internal */
+    this.successfulTransitions = new Queue([], 1);
+  }
+  dispose() {
+    this.transitionHistory.clear();
+    this.successfulTransitions.clear();
+    this.transition = null;
+  }
+}

package/src/router/core/hooks/coreResolvables.js

@@ -0,0 +1,33 @@
+import { Transition } from "../transition/transition";
+import { UIRouter } from "../router";
+import { Resolvable } from "../resolve/resolvable";
+import { inArray, uniqR, unnestR } from "../common/common";
+function addCoreResolvables(trans) {
+  trans.addResolvable(Resolvable.fromData(UIRouter, trans.router), "");
+  trans.addResolvable(Resolvable.fromData(Transition, trans), "");
+  trans.addResolvable(Resolvable.fromData("$transition$", trans), "");
+  trans.addResolvable(Resolvable.fromData("$stateParams", trans.params()), "");
+  trans.entering().forEach((state) => {
+    trans.addResolvable(Resolvable.fromData("$state$", state), state);
+  });
+}
+export const registerAddCoreResolvables = (transitionService) =>
+  transitionService.onCreate({}, addCoreResolvables);
+const TRANSITION_TOKENS = ["$transition$", Transition];
+const isTransition = inArray(TRANSITION_TOKENS);
+// References to Transition in the treeChanges pathnodes makes all
+// previous Transitions reachable in memory, causing a memory leak
+// This function removes resolves for '$transition$' and `Transition` from the treeChanges.
+// Do not use this on current transitions, only on old ones.
+export const treeChangesCleanup = (trans) => {
+  const nodes = Object.values(trans.treeChanges())
+    .reduce(unnestR, [])
+    .reduce(uniqR, []);
+  // If the resolvable is a Transition, return a new resolvable with null data
+  const replaceTransitionWithNull = (r) => {
+    return isTransition(r.token) ? Resolvable.fromData(r.token, null) : r;
+  };
+  nodes.forEach((node) => {
+    node.resolvables = node.resolvables.map(replaceTransitionWithNull);
+  });
+};

package/src/router/core/hooks/ignoredTransition.js

@@ -0,0 +1,25 @@
+import { trace } from "../common/trace";
+import { Rejection } from "../transition/rejectFactory";
+/**
+ * A [[TransitionHookFn]] that skips a transition if it should be ignored
+ *
+ * This hook is invoked at the end of the onBefore phase.
+ *
+ * If the transition should be ignored (because no parameter or states changed)
+ * then the transition is ignored and not processed.
+ */
+function ignoredHook(trans) {
+  const ignoredReason = trans._ignoredReason();
+  if (!ignoredReason) return;
+  trace.traceTransitionIgnored(trans);
+  const pending = trans.router.globals.transition;
+  // The user clicked a link going back to the *current state* ('A')
+  // However, there is also a pending transition in flight (to 'B')
+  // Abort the transition to 'B' because the user now wants to be back at 'A'.
+  if (ignoredReason === "SameAsCurrent" && pending) {
+    pending.abort();
+  }
+  return Rejection.ignored().toPromise();
+}
+export const registerIgnoredTransitionHook = (transitionService) =>
+  transitionService.onBefore({}, ignoredHook, { priority: -9999 });

package/src/router/core/hooks/invalidTransition.js

@@ -0,0 +1,14 @@
+/**
+ * A [[TransitionHookFn]] that rejects the Transition if it is invalid
+ *
+ * This hook is invoked at the end of the onBefore phase.
+ * If the transition is invalid (for example, param values do not validate)
+ * then the transition is rejected.
+ */
+function invalidTransitionHook(trans) {
+  if (!trans.valid()) {
+    throw new Error(trans.error().toString());
+  }
+}
+export const registerInvalidTransitionHook = (transitionService) =>
+  transitionService.onBefore({}, invalidTransitionHook, { priority: -10000 });

package/src/router/core/hooks/lazyLoad.js

@@ -0,0 +1,102 @@
+import { services } from "../common/coreservices";
+/**
+ * A [[TransitionHookFn]] that performs lazy loading
+ *
+ * When entering a state "abc" which has a `lazyLoad` function defined:
+ * - Invoke the `lazyLoad` function (unless it is already in process)
+ *   - Flag the hook function as "in process"
+ *   - The function should return a promise (that resolves when lazy loading is complete)
+ * - Wait for the promise to settle
+ *   - If the promise resolves to a [[LazyLoadResult]], then register those states
+ *   - Flag the hook function as "not in process"
+ * - If the hook was successful
+ *   - Remove the `lazyLoad` function from the state declaration
+ * - If all the hooks were successful
+ *   - Retry the transition (by returning a TargetState)
+ *
+ * ```
+ * .state('abc', {
+ *   component: 'fooComponent',
+ *   lazyLoad: () => import('./fooComponent')
+ *   });
+ * ```
+ *
+ * See [[StateDeclaration.lazyLoad]]
+ */
+const lazyLoadHook = (transition) => {
+  const router = transition.router;
+  function retryTransition() {
+    if (transition.originalTransition().options().source !== "url") {
+      // The original transition was not triggered via url sync
+      // The lazy state should be loaded now, so re-try the original transition
+      const orig = transition.targetState();
+      return router.stateService.target(
+        orig.identifier(),
+        orig.params(),
+        orig.options(),
+      );
+    }
+    // The original transition was triggered via url sync
+    // Run the URL rules and find the best match
+    const $url = router.urlService;
+    const result = $url.match($url.parts());
+    const rule = result && result.rule;
+    // If the best match is a state, redirect the transition (instead
+    // of calling sync() which supersedes the current transition)
+    if (rule && rule.type === "STATE") {
+      const state = rule.state;
+      const params = result.match;
+      return router.stateService.target(state, params, transition.options());
+    }
+    // No matching state found, so let .sync() choose the best non-state match/otherwise
+    router.urlService.sync();
+  }
+  const promises = transition
+    .entering()
+    .filter((state) => !!state.$$state().lazyLoad)
+    .map((state) => lazyLoadState(transition, state));
+  return services.$q.all(promises).then(retryTransition);
+};
+export const registerLazyLoadHook = (transitionService) =>
+  transitionService.onBefore(
+    { entering: (state) => !!state.lazyLoad },
+    lazyLoadHook,
+  );
+/**
+ * Invokes a state's lazy load function
+ *
+ * @param transition a Transition context
+ * @param state the state to lazy load
+ * @returns A promise for the lazy load result
+ */
+export function lazyLoadState(transition, state) {
+  const lazyLoadFn = state.$$state().lazyLoad;
+  // Store/get the lazy load promise on/from the hookfn so it doesn't get re-invoked
+  let promise = lazyLoadFn["_promise"];
+  if (!promise) {
+    const success = (result) => {
+      delete state.lazyLoad;
+      delete state.$$state().lazyLoad;
+      delete lazyLoadFn["_promise"];
+      return result;
+    };
+    const error = (err) => {
+      delete lazyLoadFn["_promise"];
+      return services.$q.reject(err);
+    };
+    promise = lazyLoadFn["_promise"] = services.$q
+      .when(lazyLoadFn(transition, state))
+      .then(updateStateRegistry)
+      .then(success, error);
+  }
+  /** Register any lazy loaded state definitions */
+  function updateStateRegistry(result) {
+    if (result && Array.isArray(result.states)) {
+      result.states.forEach((_state) =>
+        transition.router.stateRegistry.register(_state),
+      );
+    }
+    return result;
+  }
+  return promise;
+}

package/src/router/core/hooks/onEnterExitRetain.js

@@ -0,0 +1,55 @@
+/**
+ * A factory which creates an onEnter, onExit or onRetain transition hook function
+ *
+ * The returned function invokes the (for instance) state.onEnter hook when the
+ * state is being entered.
+ */
+function makeEnterExitRetainHook(hookName) {
+  return (transition, state) => {
+    const _state = state.$$state();
+    const hookFn = _state[hookName];
+    return hookFn(transition, state);
+  };
+}
+/**
+ * The [[TransitionStateHookFn]] for onExit
+ *
+ * When the state is being exited, the state's .onExit function is invoked.
+ *
+ * Registered using `transitionService.onExit({ exiting: (state) => !!state.onExit }, onExitHook);`
+ *
+ * See: [[IHookRegistry.onExit]]
+ */
+const onExitHook = makeEnterExitRetainHook("onExit");
+export const registerOnExitHook = (transitionService) =>
+  transitionService.onExit({ exiting: (state) => !!state.onExit }, onExitHook);
+/**
+ * The [[TransitionStateHookFn]] for onRetain
+ *
+ * When the state was already entered, and is not being exited or re-entered, the state's .onRetain function is invoked.
+ *
+ * Registered using `transitionService.onRetain({ retained: (state) => !!state.onRetain }, onRetainHook);`
+ *
+ * See: [[IHookRegistry.onRetain]]
+ */
+const onRetainHook = makeEnterExitRetainHook("onRetain");
+export const registerOnRetainHook = (transitionService) =>
+  transitionService.onRetain(
+    { retained: (state) => !!state.onRetain },
+    onRetainHook,
+  );
+/**
+ * The [[TransitionStateHookFn]] for onEnter
+ *
+ * When the state is being entered, the state's .onEnter function is invoked.
+ *
+ * Registered using `transitionService.onEnter({ entering: (state) => !!state.onEnter }, onEnterHook);`
+ *
+ * See: [[IHookRegistry.onEnter]]
+ */
+const onEnterHook = makeEnterExitRetainHook("onEnter");
+export const registerOnEnterHook = (transitionService) =>
+  transitionService.onEnter(
+    { entering: (state) => !!state.onEnter },
+    onEnterHook,
+  );

package/src/router/core/hooks/redirectTo.js

@@ -0,0 +1,36 @@
+import { isString, isFunction } from "../common/predicates";
+import { services } from "../common/coreservices";
+import { TargetState } from "../state/targetState";
+/**
+ * A [[TransitionHookFn]] that redirects to a different state or params
+ *
+ * Registered using `transitionService.onStart({ to: (state) => !!state.redirectTo }, redirectHook);`
+ *
+ * See [[StateDeclaration.redirectTo]]
+ */
+const redirectToHook = (trans) => {
+  const redirect = trans.to().redirectTo;
+  if (!redirect) return;
+  const $state = trans.router.stateService;
+  function handleResult(result) {
+    if (!result) return;
+    if (result instanceof TargetState) return result;
+    if (isString(result))
+      return $state.target(result, trans.params(), trans.options());
+    if (result["state"] || result["params"])
+      return $state.target(
+        result["state"] || trans.to(),
+        result["params"] || trans.params(),
+        trans.options(),
+      );
+  }
+  if (isFunction(redirect)) {
+    return services.$q.when(redirect(trans)).then(handleResult);
+  }
+  return handleResult(redirect);
+};
+export const registerRedirectToHook = (transitionService) =>
+  transitionService.onStart(
+    { to: (state) => !!state.redirectTo },
+    redirectToHook,
+  );

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

@@ -0,0 +1,57 @@
+import { noop } from "../common/common";
+import { ResolveContext } from "../resolve/resolveContext";
+import { val } from "../common/hof";
+export const RESOLVE_HOOK_PRIORITY = 1000;
+/**
+ * A [[TransitionHookFn]] which resolves all EAGER Resolvables in the To Path
+ *
+ * Registered using `transitionService.onStart({}, eagerResolvePath, { priority: 1000 });`
+ *
+ * When a Transition starts, this hook resolves all the EAGER Resolvables, which the transition then waits for.
+ *
+ * See [[StateDeclaration.resolve]]
+ */
+const eagerResolvePath = (trans) =>
+  new ResolveContext(trans.treeChanges().to)
+    .resolvePath("EAGER", trans)
+    .then(noop);
+export const registerEagerResolvePath = (transitionService) =>
+  transitionService.onStart({}, eagerResolvePath, {
+    priority: RESOLVE_HOOK_PRIORITY,
+  });
+/**
+ * A [[TransitionHookFn]] which resolves all LAZY Resolvables for the state (and all its ancestors) in the To Path
+ *
+ * Registered using `transitionService.onEnter({ entering: () => true }, lazyResolveState, { priority: 1000 });`
+ *
+ * When a State is being entered, this hook resolves all the Resolvables for this state, which the transition then waits for.
+ *
+ * See [[StateDeclaration.resolve]]
+ */
+const lazyResolveState = (trans, state) =>
+  new ResolveContext(trans.treeChanges().to)
+    .subContext(state.$$state())
+    .resolvePath("LAZY", trans)
+    .then(noop);
+export const registerLazyResolveState = (transitionService) =>
+  transitionService.onEnter({ entering: val(true) }, lazyResolveState, {
+    priority: RESOLVE_HOOK_PRIORITY,
+  });
+/**
+ * A [[TransitionHookFn]] which resolves any dynamically added (LAZY or EAGER) Resolvables.
+ *
+ * Registered using `transitionService.onFinish({}, eagerResolvePath, { priority: 1000 });`
+ *
+ * After all entering states have been entered, this hook resolves any remaining Resolvables.
+ * These are typically dynamic resolves which were added by some Transition Hook using [[Transition.addResolvable]].
+ *
+ * See [[StateDeclaration.resolve]]
+ */
+const resolveRemaining = (trans) =>
+  new ResolveContext(trans.treeChanges().to)
+    .resolvePath("LAZY", trans)
+    .then(noop);
+export const registerResolveRemaining = (transitionService) =>
+  transitionService.onFinish({}, resolveRemaining, {
+    priority: RESOLVE_HOOK_PRIORITY,
+  });

package/src/router/core/hooks/updateGlobals.js

@@ -0,0 +1,30 @@
+import { copy } from "../common/common";
+/**
+ * A [[TransitionHookFn]] which updates global UI-Router state
+ *
+ * Registered using `transitionService.onBefore({}, updateGlobalState);`
+ *
+ * Before a [[Transition]] starts, updates the global value of "the current transition" ([[Globals.transition]]).
+ * After a successful [[Transition]], updates the global values of "the current state"
+ * ([[Globals.current]] and [[Globals.$current]]) and "the current param values" ([[Globals.params]]).
+ *
+ * See also the deprecated properties:
+ * [[StateService.transition]], [[StateService.current]], [[StateService.params]]
+ */
+const updateGlobalState = (trans) => {
+  const globals = trans.router.globals;
+  const transitionSuccessful = () => {
+    globals.successfulTransitions.enqueue(trans);
+    globals.$current = trans.$to();
+    globals.current = globals.$current.self;
+    copy(trans.params(), globals.params);
+  };
+  const clearCurrentTransition = () => {
+    // Do not clear globals.transition if a different transition has started in the meantime
+    if (globals.transition === trans) globals.transition = null;
+  };
+  trans.onSuccess({}, transitionSuccessful, { priority: 10000 });
+  trans.promise.then(clearCurrentTransition, clearCurrentTransition);
+};
+export const registerUpdateGlobalState = (transitionService) =>
+  transitionService.onCreate({}, updateGlobalState);

package/src/router/core/hooks/url.js

@@ -0,0 +1,25 @@
+/**
+ * A [[TransitionHookFn]] which updates the URL after a successful transition
+ *
+ * Registered using `transitionService.onSuccess({}, updateUrl);`
+ */
+const updateUrl = (transition) => {
+  const options = transition.options();
+  const $state = transition.router.stateService;
+  const $urlRouter = transition.router.urlRouter;
+  // Dont update the url in these situations:
+  // The transition was triggered by a URL sync (options.source === 'url')
+  // The user doesn't want the url to update (options.location === false)
+  // The destination state, and all parents have no navigable url
+  if (
+    options.source !== "url" &&
+    options.location &&
+    $state.$current.navigable
+  ) {
+    const urlOptions = { replace: options.location === "replace" };
+    $urlRouter.push($state.$current.navigable.url, $state.params, urlOptions);
+  }
+  $urlRouter.update(true);
+};
+export const registerUpdateUrl = (transitionService) =>
+  transitionService.onSuccess({}, updateUrl, { priority: 9999 });

package/src/router/core/hooks/views.js

@@ -0,0 +1,39 @@
+import { noop } from "../common/common";
+import { services } from "../common/coreservices";
+/**
+ * A [[TransitionHookFn]] which waits for the views to load
+ *
+ * Registered using `transitionService.onStart({}, loadEnteringViews);`
+ *
+ * Allows the views to do async work in [[ViewConfig.load]] before the transition continues.
+ * In angular 1, this includes loading the templates.
+ */
+const loadEnteringViews = (transition) => {
+  const $q = services.$q;
+  const enteringViews = transition.views("entering");
+  if (!enteringViews.length) return;
+  return $q.all(enteringViews.map((view) => $q.when(view.load()))).then(noop);
+};
+export const registerLoadEnteringViews = (transitionService) =>
+  transitionService.onFinish({}, loadEnteringViews);
+/**
+ * A [[TransitionHookFn]] which activates the new views when a transition is successful.
+ *
+ * Registered using `transitionService.onSuccess({}, activateViews);`
+ *
+ * After a transition is complete, this hook deactivates the old views from the previous state,
+ * and activates the new views from the destination state.
+ *
+ * See [[ViewService]]
+ */
+const activateViews = (transition) => {
+  const enteringViews = transition.views("entering");
+  const exitingViews = transition.views("exiting");
+  if (!enteringViews.length && !exitingViews.length) return;
+  const $view = transition.router.viewService;
+  exitingViews.forEach((vc) => $view.deactivateViewConfig(vc));
+  enteringViews.forEach((vc) => $view.activateViewConfig(vc));
+  $view.sync();
+};
+export const registerActivateViews = (transitionService) =>
+  transitionService.onSuccess({}, activateViews);

package/src/router/core/interface.js

@@ -0,0 +1,3 @@
+export class UIRouterPluginBase {
+  dispose(router) {}
+}

package/src/router/core/params/README.md

@@ -0,0 +1,8 @@
+/\*\*
+
+- This module contains code for State Parameters.
+-
+- See [[ParamDeclaration]]
+-
+- @packageDocumentation @preferred
+  \*/