npm - @angular-wave/angular.ts - Versions diffs - 0.0.27 → 0.0.28 - Mend

@angular-wave/angular.ts 0.0.27 → 0.0.28

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (73) hide show

package/README.md +1 -2
package/dist/angular-ts.esm.js +1 -1
package/dist/angular-ts.umd.js +1 -1
package/e2e/unit.spec.ts +2 -1
package/index.html +8 -9
package/package.json +1 -1
package/src/core/pubsub.js +329 -0
package/src/router/hooks/core-resolvables.js +12 -11
package/src/router/hooks/ignored-transition.js +1 -1
package/src/router/hooks/lazy-load.js +40 -41
package/src/router/hooks/redirect-to.js +32 -29
package/src/router/hooks/update-globals.js +1 -1
package/src/router/hooks/url.js +33 -24
package/src/router/hooks/views.js +21 -20
package/src/router/params/param-factory.js +17 -0
package/src/router/router.js +74 -10
package/src/router/state/state-queue-manager.js +5 -4
package/src/router/state/state-registry.js +8 -5
package/src/router/state/state-service.js +34 -29
package/src/router/transition/hook-builder.js +2 -2
package/src/router/transition/transition-hook.js +2 -1
package/src/router/transition/transition-service.js +12 -18
package/src/router/transition/transition.js +28 -25
package/src/router/url/url-config.js +1 -49
package/src/router/url/url-matcher-factory.js +10 -51
package/src/router/url/url-router.js +27 -17
package/src/router/url/url-rule.js +9 -13
package/src/router/url/url-rules.js +3 -3
package/src/router/url/url-service.js +22 -18
package/src/router/view/view.js +3 -3
package/src/shared/hof.js +1 -1
package/test/angular.spec.js +1 -0
package/test/aria/aria.spec.js +2 -1
package/test/core/pubsub.spec.js +314 -0
package/test/directive/bind.spec.js +2 -1
package/test/directive/boolean.spec.js +4 -2
package/test/directive/change.spec.js +1 -1
package/test/directive/class.spec.js +1 -0
package/test/directive/click.spec.js +2 -1
package/test/directive/cloak.spec.js +1 -2
package/test/directive/{constoller.spec.js → controller.spec.js} +1 -0
package/test/directive/element-style.spec.js +1 -0
package/test/directive/event.spec.js +1 -1
package/test/directive/href.spec.js +2 -1
package/test/directive/init.spec.js +1 -0
package/test/directive/input.spec.js +200 -285
package/test/directive/list.spec.js +2 -1
package/test/directive/model.spec.js +1 -0
package/test/directive/non-bindable.spec.js +2 -1
package/test/directive/script.spec.js +1 -0
package/test/directive/scrset.spec.js +2 -1
package/test/directive/show-hide.spec.js +1 -0
package/test/directive/src.spec.js +2 -1
package/test/directive/style.spec.js +1 -0
package/test/directive/switch.spec.js +2 -1
package/test/directive/validators.spec.js +1 -1
package/test/router/view-hook.spec.js +2 -2
package/test/router/view-scroll.spec.js +1 -1
package/test/router/view.spec.js +1 -1
package/types/router/core/common/coreservices.d.ts +2 -3
package/types/router/core/globals.d.ts +1 -4
package/types/router/core/interface.d.ts +2 -8
package/types/router/core/params/paramTypes.d.ts +0 -1
package/types/router/core/router.d.ts +2 -3
package/types/router/core/state/stateQueueManager.d.ts +1 -3
package/types/router/core/state/stateRegistry.d.ts +0 -2
package/types/router/core/state/stateService.d.ts +1 -2
package/types/router/core/transition/interface.d.ts +3 -3
package/types/router/core/transition/transitionService.d.ts +1 -2
package/types/router/core/url/urlConfig.d.ts +1 -2
package/types/router/core/url/urlRules.d.ts +1 -2
package/types/router/core/url/urlService.d.ts +1 -2
package/types/router/locationServices.d.ts +0 -1

package/e2e/unit.spec.ts CHANGED Viewed

@@ -1,10 +1,11 @@
 import { test, expect } from '@playwright/test';
 test('unit tests contain no errors', async ({ page }) => {
-  await page.goto('/?random=false');
+  await page.goto('/');
   await page.content();
   // on average 15-17 seconds
+  // TODO break these up
   await page.waitForTimeout(20000);
   //await page.screenshot({ path: 'errors-view.png' , fullPage: true });
   // Expect a jasmine bar to contain 0 failures

package/index.html CHANGED Viewed

@@ -16,7 +16,7 @@
       <!-- <script src="dist/angular-ts.umd.js"></script> -->
       <!-- include spec files here... -->
-<!--
       <script type="module" src="test/directive/boolean.spec.js"></script>
       <script type="module" src="test/directive/form.spec.js"></script>
       <script type="module" src="test/directive/input.spec.js"></script>
@@ -25,8 +25,8 @@
       <script type="module" src="test/directive/class.spec.js"></script>
       <script type="module" src="test/directive/click.spec.js"></script>
       <script type="module" src="test/directive/cloak.spec.js"></script>
-      <script type="module" src="test/directive/constoller.spec.js"></script>
-      <script type="module" src="test/directive/event.spec.js"></script>
+      <script type="module" src="test/directive/controller.spec.js"></script>
+      <!--   <script type="module" src="test/directive/event.spec.js"></script>
       <script type="module" src="test/directive/href.spec.js"></script>
       <script type="module" src="test/directive/if.spec.js"></script>
       <script type="module" src="test/directive/include.spec.js"></script>
@@ -95,9 +95,8 @@
       <script type="module" src="test/shared/common.spec.js"></script>
       <script type="module" src="test/shared/hof.spec.js"></script>
       <script type="module" src="test/shared/strings.spec.js"></script>
-      <script type="module" src="test/shared/utils.spec.js"></script> -->
-      <!-- Router specs-->
+      <script type="module" src="test/shared/utils.spec.js"></script>-->
+      <!-- <script type="module" src="test/core/pubsub.spec.js"></script>
       <script type="module" src="test/router/glob.spec.js"></script>
       <script type="module" src="test/router/services.spec.js"></script>
       <script type="module" src="test/router/state-directives.spec.js"></script>
@@ -108,11 +107,11 @@
       <script type="module" src="test/router/view-directive.spec.js"></script>
       <script type="module" src="test/router/view-hook.spec.js"></script>
       <script type="module" src="test/router/view-scroll.spec.js"></script>
-      <script type="module" src="test/router/view.spec.js"></script>
+      <script type="module" src="test/router/view.spec.js"></script> -->
-      <!-- Run asyncs last to prevent digest polution-->
       <!-- <script type="module" src="test/core/interval.spec.js"></script>
-      <script type="module" src="test/core/timeout.spec.js"></script> -->
+      <script type="module" src="test/core/timeout.spec.js"></script>  -->
     </head>
     <body>
       <div id="dummy"></div>

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "@angular-wave/angular.ts",
   "license": "MIT",
-  "version": "0.0.27",
+  "version": "0.0.28",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

package/src/core/pubsub.js ADDED Viewed

@@ -0,0 +1,329 @@
+export class PubSub {
+  /**
+   * Topic-based publish/subscribe channel.  Maintains a map of topics to
+   * subscriptions.  When a message is published to a topic, all functions
+   * subscribed to that topic are invoked in the order they were added.
+   * Uncaught errors abort publishing.
+   *
+   * Topics may be identified by any nonempty string, <strong>except</strong>
+   * strings corresponding to native Object properties, e.g. "constructor",
+   * "toString", "hasOwnProperty", etc.
+   *
+   * @param {boolean=} opt_async Enable asynchronous behavior.  Recommended for
+   *     new code.  See notes on the publish() method.
+   */
+  constructor(opt_async = false) {
+    this.disposed = false;
+    /**
+     * The next available subscription key.  Internally, this is an index into the
+     * sparse array of subscriptions.
+     *
+     * @private {number}
+     */
+    this.key = 1;
+    /**
+     * Array of subscription keys pending removal once publishing is done.
+     *
+     * @private {!Array<number>}
+     * @const
+     */
+    this.pendingKeys = [];
+    /**
+     * Lock to prevent the removal of subscriptions during publishing. Incremented
+     * at the beginning of {@link #publish}, and decremented at the end.
+     *
+     * @private {number}
+     */
+    this.publishDepth = 0;
+    /**
+     * Sparse array of subscriptions. Each subscription is represented by a tuple
+     * comprising a topic identifier, a function, and an optional context object.
+     * Each tuple occupies three consecutive positions in the array, with the
+     * topic identifier at index n, the function at index (n + 1), the context
+     * object at index (n + 2), the next topic at index (n + 3), etc. (This
+     * representation minimizes the number of object allocations and has been
+     * shown to be faster than an array of objects with three key-value pairs or
+     * three parallel arrays, especially on IE.) Once a subscription is removed
+     * via {@link #unsubscribe} or {@link #unsubscribeByKey}, the three
+     * corresponding array elements are deleted, and never reused. This means the
+     * total number of subscriptions during the lifetime of the pubsub channel is
+     * limited by the maximum length of a JavaScript array to (2^32 - 1) / 3 =
+     * 1,431,655,765 subscriptions, which should suffice for most applications.
+     *
+     * @private {!Array<?>}
+     * @const
+     */
+    this.subscriptions = [];
+    /**
+     * Map of topics to arrays of subscription keys.
+     *
+     * @private {!Object<!Array<number>>}
+     */
+    this.topics = {};
+    /**
+     * @private @const {boolean}
+     */
+    this.async_ = Boolean(opt_async);
+  }
+  /**
+   * Subscribes a function to a topic.  The function is invoked as a method on
+   * the given `opt_context` object, or in the global scope if no context
+   * is specified.  Subscribing the same function to the same topic multiple
+   * times will result in multiple function invocations while publishing.
+   * Returns a subscription key that can be used to unsubscribe the function from
+   * the topic via {@link #unsubscribeByKey}.
+   *
+   * @param {string} topic Topic to subscribe to.
+   * @param {Function} fn Function to be invoked when a message is published to
+   *     the given topic.
+   * @param {Object=} opt_context Object in whose context the function is to be
+   *     called (the global scope if none).
+   * @return {number} Subscription key.
+   */
+  subscribe(topic, fn, opt_context = null) {
+    let keys = this.topics[topic];
+    if (!keys) {
+      // First subscription to this topic; initialize subscription key array.
+      keys = this.topics[topic] = [];
+    }
+    // Push the tuple representing the subscription onto the subscription array.
+    const key = this.key;
+    this.subscriptions[key] = topic;
+    this.subscriptions[key + 1] = fn;
+    this.subscriptions[key + 2] = opt_context;
+    this.key = key + 3;
+    // Push the subscription key onto the list of subscriptions for the topic.
+    keys.push(key);
+    // Return the subscription key.
+    return key;
+  }
+  /**
+   * Subscribes a single-use function to a topic.  The function is invoked as a
+   * method on the given `opt_context` object, or in the global scope if
+   * no context is specified, and is then unsubscribed.  Returns a subscription
+   * key that can be used to unsubscribe the function from the topic via
+   * {@link #unsubscribeByKey}.
+   *
+   * @param {string} topic Topic to subscribe to.
+   * @param {Function} fn Function to be invoked once and then unsubscribed when
+   *     a message is published to the given topic.
+   * @param {Object=} opt_context Object in whose context the function is to be
+   *     called (the global scope if none).
+   * @return {number} Subscription key.
+   */
+  subscribeOnce(topic, fn, opt_context = null) {
+    let called = false;
+    // Behold the power of lexical closures!
+    const key = this.subscribe(
+      topic,
+      (...args) => {
+        if (!called) {
+          called = true;
+          // Unsubscribe before calling function so the function is unsubscribed
+          // even if it throws an exception.
+          this.unsubscribeByKey(key);
+          fn.apply(opt_context, args);
+        }
+      },
+      this,
+    );
+    return key;
+  }
+  /**
+   * Runs a function asynchronously.
+   *
+   * @private
+   * @param {Function} fn Function to run.
+   * @param {Object} context Context in which to run the function.
+   * @param {Array} args Arguments to pass to the function.
+   */
+  static runAsync_(fn, context, args) {
+    setTimeout(() => {
+      fn.apply(context, args);
+    }, 0);
+  }
+  /**
+   * Unsubscribes a function from a topic.  Only deletes the first match found.
+   * Returns a Boolean indicating whether a subscription was removed.
+   *
+   * @param {string} topic Topic to unsubscribe from.
+   * @param {Function} fn Function to unsubscribe.
+   * @param {Object=} opt_context Object in whose context the function was to be
+   *     called (the global scope if none).
+   * @return {boolean} Whether a matching subscription was removed.
+   */
+  unsubscribe(topic, fn, opt_context = null) {
+    const keys = this.topics[topic];
+    if (keys) {
+      const subscriptions = this.subscriptions;
+      const key = keys.find(
+        (k) =>
+          subscriptions[k + 1] === fn && subscriptions[k + 2] === opt_context,
+      );
+      if (key !== undefined) {
+        return this.unsubscribeByKey(key);
+      }
+    }
+    return false;
+  }
+  /**
+   * Removes a subscription based on the key returned by {@link #subscribe}.
+   * No-op if no matching subscription is found.  Returns a Boolean indicating
+   * whether a subscription was removed.
+   *
+   * @param {number} key Subscription key.
+   * @return {boolean} Whether a matching subscription was removed.
+   */
+  unsubscribeByKey(key) {
+    const topic = this.subscriptions[key];
+    if (topic) {
+      let keys = this.topics[topic];
+      if (this.publishDepth !== 0) {
+        // Defer removal until after publishing is complete, but replace the
+        // function with a no-op so it isn't called.
+        this.pendingKeys.push(key);
+        this.subscriptions[key + 1] = () => {};
+      } else {
+        if (keys) {
+          this.topics[topic] = keys.filter((k) => k !== key);
+        }
+        delete this.subscriptions[key];
+        delete this.subscriptions[key + 1];
+        delete this.subscriptions[key + 2];
+      }
+    }
+    return !!topic;
+  }
+  /**
+   * Publishes a message to a topic.  Calls functions subscribed to the topic in
+   * the order in which they were added, passing all arguments along.
+   *
+   * If this object was created with async=true, subscribed functions are called
+   * via setTimeout().  Otherwise, the functions are called directly, and if
+   * any of them throw an uncaught error, publishing is aborted.
+   *
+   * @param {string} topic Topic to publish to.
+   * @param {...*} var_args Arguments that are applied to each subscription
+   *     function.
+   * @return {boolean} Whether any subscriptions were called.
+   */
+  publish(topic, ...var_args) {
+    const keys = this.topics[topic];
+    if (keys) {
+      const args = var_args;
+      if (this.async_) {
+        // For each key in the list of subscription keys for the topic, schedule
+        // the function to be applied to the arguments in the appropriate context.
+        for (let i = 0; i < keys.length; i++) {
+          const key = keys[i];
+          PubSub.runAsync_(
+            this.subscriptions[key + 1],
+            this.subscriptions[key + 2],
+            args,
+          );
+        }
+      } else {
+        this.publishDepth++;
+        try {
+          for (
+            let i = 0, len = keys.length;
+            i < len && !this.isDisposed();
+            i++
+          ) {
+            const key = keys[i];
+            this.subscriptions[key + 1].apply(
+              this.subscriptions[key + 2],
+              args,
+            );
+          }
+        } finally {
+          this.publishDepth--;
+          if (this.pendingKeys.length > 0 && this.publishDepth === 0) {
+            let pendingKey;
+            while ((pendingKey = this.pendingKeys.pop())) {
+              this.unsubscribeByKey(pendingKey);
+            }
+          }
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Clears the subscription list for a topic, or all topics if unspecified.
+   * @param {string=} opt_topic Topic to clear (all topics if unspecified).
+   */
+  clear(opt_topic) {
+    if (opt_topic) {
+      const keys = this.topics[opt_topic];
+      if (keys) {
+        keys.forEach(this.unsubscribeByKey, this);
+        delete this.topics[opt_topic];
+      }
+    } else {
+      this.subscriptions.length = 0;
+      this.topics = {};
+    }
+  }
+  /**
+   * Returns the number of subscriptions to the given topic (or all topics if
+   * unspecified). This number will not change while publishing any messages.
+   * @param {string=} opt_topic The topic (all topics if unspecified).
+   * @return {number} Number of subscriptions to the topic.
+   */
+  getCount(opt_topic) {
+    if (opt_topic) {
+      const keys = this.topics[opt_topic];
+      return keys ? keys.length : 0;
+    }
+    let count = 0;
+    for (const topic in this.topics) {
+      count += this.getCount(topic);
+    }
+    return count;
+  }
+  isDisposed() {
+    return this.disposed;
+  }
+  dispose() {
+    this.clear();
+    this.pendingKeys.length = 0;
+    this.disposed = true;
+  }
+}
+export const EventBus = new PubSub(true);

package/src/router/hooks/core-resolvables.js CHANGED Viewed

@@ -1,18 +1,19 @@
 import { Transition } from "../transition/transition";
-import { UIRouter } from "../router";
 import { Resolvable } from "../resolve/resolvable";
 import { inArray, uniqR, unnestR } from "../../shared/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 function registerAddCoreResolvables(transitionService) {
-  transitionService.onCreate({}, addCoreResolvables);
+  transitionService.onCreate({}, function addCoreResolvables(trans) {
+    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);
+    });
+  });
 }
 const TRANSITION_TOKENS = ["$transition$", Transition];

package/src/router/hooks/ignored-transition.js CHANGED Viewed

@@ -12,7 +12,7 @@ function ignoredHook(trans) {
   const ignoredReason = trans._ignoredReason();
   if (!ignoredReason) return;
   trace.traceTransitionIgnored(trans);
-  const pending = trans.router.globals.transition;
+  const pending = trans.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'.

package/src/router/hooks/lazy-load.js CHANGED Viewed

@@ -23,45 +23,46 @@ import { services } from "../common/coreservices";
  *
  * 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 function registerLazyLoadHook(transitionService) {
+export function registerLazyLoadHook(
+  transitionService,
+  stateService,
+  urlService,
+  stateRegistry,
+) {
   return transitionService.onBefore(
     { entering: (state) => !!state.lazyLoad },
-    lazyLoadHook,
+    (transition) => {
+      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 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 result = urlService.match(urlService.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 stateService.target(state, params, transition.options());
+        }
+        // No matching state found, so let .sync() choose the best non-state match/otherwise
+        urlService.sync();
+      }
+      const promises = transition
+        .entering()
+        .filter((state) => !!state.$$state().lazyLoad)
+        .map((state) => lazyLoadState(transition, state, stateRegistry));
+      return services.$q.all(promises).then(retryTransition);
+    },
   );
 }
@@ -72,7 +73,7 @@ export function registerLazyLoadHook(transitionService) {
  * @param state the state to lazy load
  * @returns A promise for the lazy load result
  */
-export function lazyLoadState(transition, state) {
+export function lazyLoadState(transition, state, stateRegistry) {
   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"];
@@ -95,9 +96,7 @@ export function lazyLoadState(transition, state) {
   /** Register any lazy loaded state definitions */
   function updateStateRegistry(result) {
     if (result && Array.isArray(result.states)) {
-      result.states.forEach((_state) =>
-        transition.router.stateRegistry.register(_state),
-      );
+      result.states.forEach((_state) => stateRegistry.register(_state));
     }
     return result;
   }

package/src/router/hooks/redirect-to.js CHANGED Viewed

@@ -1,36 +1,39 @@
 import { isString, isFunction } from "../../shared/utils";
 import { services } from "../common/coreservices";
 import { TargetState } from "../state/target-state";
-/**
- * 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) =>
+export const registerRedirectToHook = (transitionService, stateService) => {
+  /**
+   * 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 = 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);
+  };
   transitionService.onStart(
     { to: (state) => !!state.redirectTo },
     redirectToHook,
   );
+};

package/src/router/hooks/update-globals.js CHANGED Viewed

@@ -12,7 +12,7 @@ import { copy } from "../../shared/common";
  * [[StateService.transition]], [[StateService.current]], [[StateService.params]]
  */
 const updateGlobalState = (trans) => {
-  const globals = trans.router.globals;
+  const globals = trans.globals;
   const transitionSuccessful = () => {
     globals.successfulTransitions.enqueue(trans);
     globals.$current = trans.$to();