@angular-wave/angular.ts 0.0.26 → 0.0.28

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

@@ -7,6 +7,7 @@ import { trace } from "../common/trace";
 import { services } from "../common/coreservices";
 import { Rejection } from "./reject-factory";
 import { TargetState } from "../state/target-state";
+import { EventBus } from "../../core/pubsub";
 const defaultOptions = {
   current: () => {},
   transition: null,
@@ -79,7 +80,7 @@ export class TransitionHook {
     this.type = registeredHook.eventType;
   }
   logError(err) {
-    this.transition.router.stateService.defaultErrorHandler()(err);
+    EventBus.publish("$stateService:defaultErrorHandler", err);
   }
   invokeHook() {
     const hook = this.registeredHook;
@@ -142,16 +143,9 @@ export class TransitionHook {
   }
   /**
    * Return a Rejection promise if the transition is no longer current due
-   * to a stopped router (disposed), or a new transition has started and superseded this one.
+   * a new transition has started and superseded this one.
    */
   getNotCurrentRejection() {
-    const router = this.transition.router;
-    // The router is stopped
-    if (router._disposed) {
-      return Rejection.aborted(
-        `UIRouter instance #${router.$id} has been stopped (disposed)`,
-      ).toPromise();
-    }
     if (this.transition._aborted) {
       return Rejection.aborted().toPromise();
     }

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

@@ -5,7 +5,6 @@ import {
   registerAddCoreResolvables,
   treeChangesCleanup,
 } from "../hooks/core-resolvables";
-import { registerRedirectToHook } from "../hooks/redirect-to";
 import {
   registerOnExitHook,
   registerOnRetainHook,
@@ -16,17 +15,14 @@ import {
   registerLazyResolveState,
   registerResolveRemaining,
 } from "../hooks/resolve";
-import {
-  registerLoadEnteringViews,
-  registerActivateViews,
-} from "../hooks/views";
+import { registerLoadEnteringViews } from "../hooks/views";
 import { registerUpdateGlobalState } from "../hooks/update-globals";
-import { registerUpdateUrl } from "../hooks/url";
+
 import { registerLazyLoadHook } from "../hooks/lazy-load";
 import { TransitionEventType } from "./transition-event-type";
 import { TransitionHook } from "./transition-hook";
 import { isDefined } from "../../shared/utils";
-import { removeFrom, createProxyFunctions } from "../../shared/common";
+import { createProxyFunctions } from "../../shared/common";
 import { val } from "../../shared/hof";
 import { registerIgnoredTransitionHook } from "../hooks/ignored-transition";
 import { registerInvalidTransitionHook } from "../hooks/invalid-transition";
@@ -61,9 +57,9 @@ export let defaultTransOpts = {
  */
 export class TransitionService {
   /**
-   * @param {import('../router').UIRouter} _router
+   * @param {import('../router').UIRouter} router
    */
-  constructor(_router) {
+  constructor(router, globals, viewService) {
     this._transitionCount = 0;
     /** The transition hook types, such as `onEnter`, `onStart`, etc */
     this._eventTypes = [];
@@ -71,8 +67,9 @@ export class TransitionService {
     this._registeredHooks = {};
     /** The  paths on a criteria object */
     this._criteriaPaths = {};
-    this._router = _router;
-    this.$view = _router.viewService;
+    this.router = router;
+    this.globals = globals;
+    this.$view = viewService;
     this._deregisterHookFns = {};
     this._pluginapi = createProxyFunctions(val(this), {}, val(this), [
       "_definePathType",
@@ -84,7 +81,7 @@ export class TransitionService {
     this._defineCorePaths();
     this._defineCoreEvents();
     this._registerCoreTransitionHooks();
-    _router.globals.successfulTransitions.onEvict(treeChangesCleanup);
+    globals.successfulTransitions.onEvict(treeChangesCleanup);
   }
   /**
    * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.
@@ -110,18 +107,6 @@ export class TransitionService {
    * @returns a function which deregisters the hook.
    */
 
-  /**
-   * dispose
-   * @internal
-   */
-  dispose() {
-    Object.values(this._registeredHooks).forEach((hooksArray) =>
-      hooksArray.forEach((hook) => {
-        hook._deregistered = true;
-        removeFrom(hooksArray, hook);
-      }),
-    );
-  }
   /**
    * Creates a new [[Transition]] object
    *
@@ -134,7 +119,7 @@ export class TransitionService {
    * @returns a Transition
    */
   create(fromPath, targetState) {
-    return new Transition(fromPath, targetState, this._router);
+    return new Transition(fromPath, targetState, this, this.globals);
   }
 
   _defineCoreEvents() {
@@ -254,8 +239,7 @@ export class TransitionService {
     fns.addCoreResolves = registerAddCoreResolvables(this);
     fns.ignored = registerIgnoredTransitionHook(this);
     fns.invalid = registerInvalidTransitionHook(this);
-    // Wire up redirectTo hook
-    fns.redirectTo = registerRedirectToHook(this);
+
     // Wire up onExit/Retain/Enter state hooks
     fns.onExit = registerOnExitHook(this);
     fns.onRetain = registerOnRetainHook(this);
@@ -266,11 +250,9 @@ export class TransitionService {
     fns.resolveAll = registerResolveRemaining(this);
     // Wire up the View management hooks
     fns.loadViews = registerLoadEnteringViews(this);
-    fns.activateViews = registerActivateViews(this);
+
     // Updates global state after a transition
     fns.updateGlobals = registerUpdateGlobalState(this);
-    // After globals.current is updated at priority: 10000
-    fns.updateUrl = registerUpdateUrl(this);
     // Lazy load state trees
     fns.lazyLoad = registerLazyLoadHook(this);
   }

package/src/router/transition/transition.js

@@ -35,20 +35,6 @@ const stateSelf = prop("self");
  * It has information about all states being entered and exited as a result of the transition.
  */
 export class Transition {
-  /**
-   * Creates the transition-level hook registration functions
-   * (which can then be used to register hooks)
-   */
-  createTransitionHookRegFns() {
-    this.router.transitionService._pluginapi
-      ._getEvents()
-      .filter((type) => type.hookPhase !== TransitionHookPhase.CREATE)
-      .forEach((type) => makeEvent(this, this.router.transitionService, type));
-  }
-
-  getHooks(hookName) {
-    return this._registeredHooks[hookName];
-  }
   /**
    * Creates a new Transition object.
    *
@@ -59,10 +45,12 @@ export class Transition {
    * @param fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`
    *        encapsulates the "from state".
    * @param targetState The target state and parameters being transitioned to (also, the transition options)
-   * @param {import('../router').UIRouter} router The [[UIRouter]] instance
+   * @param {import('../transition/transition-service').TransitionService} transitionService The [[TransitionService]] instance
    * @internal
    */
-  constructor(fromPath, targetState, router) {
+  constructor(fromPath, targetState, transitionService, globals) {
+    this.globals = globals;
+    this.transitionService = transitionService;
     this._deferred = services.$q.defer();
     /**
      * This promise is resolved or rejected based on the outcome of the Transition.
@@ -76,8 +64,7 @@ export class Transition {
 
     this._hookBuilder = new HookBuilder(this);
     /** Checks if this transition is currently active/running. */
-    this.isActive = () => this.router.globals.transition === this;
-    this.router = router;
+    this.isActive = () => this.globals.transition === this;
     this._targetState = targetState;
     if (!targetState.valid()) {
       throw new Error(targetState.error());
@@ -87,7 +74,7 @@ export class Transition {
       { current: val(this) },
       targetState.options(),
     );
-    this.$id = router.transitionService._transitionCount++;
+    this.$id = transitionService._transitionCount++;
     const toPath = PathUtils.buildToPath(fromPath, targetState);
     this._treeChanges = PathUtils.treeChanges(
       fromPath,
@@ -99,12 +86,28 @@ export class Transition {
       TransitionHookPhase.CREATE,
     );
     TransitionHook.invokeHooks(onCreateHooks, () => null);
-    this.applyViewConfigs(router);
+    this.applyViewConfigs();
+  }
+
+  /**
+   * Creates the transition-level hook registration functions
+   * (which can then be used to register hooks)
+   */
+  createTransitionHookRegFns() {
+    this.transitionService._pluginapi
+      ._getEvents()
+      .filter((type) => type.hookPhase !== TransitionHookPhase.CREATE)
+      .forEach((type) => makeEvent(this, this.transitionService, type));
+  }
+
+  getHooks(hookName) {
+    return this._registeredHooks[hookName];
   }
-  applyViewConfigs(router) {
+
+  applyViewConfigs() {
     const enteringStates = this._treeChanges.entering.map((node) => node.state);
     PathUtils.applyViewConfigs(
-      router.transitionService.$view,
+      this.transitionService.$view,
       this._treeChanges.to,
       enteringStates,
     );
@@ -475,7 +478,7 @@ export class Transition {
       redirectOpts,
     );
     targetState = targetState.withOptions(newOptions, true);
-    const newTransition = this.router.transitionService.create(
+    const newTransition = this.transitionService.create(
       this._treeChanges.from,
       targetState,
     );
@@ -557,7 +560,7 @@ export class Transition {
   }
 
   _ignoredReason() {
-    const pending = this.router.globals.transition;
+    const pending = this.globals.transition;
     const reloadState = this._options.reloadState;
     const same = (pathA, pathB) => {
       if (pathA.length !== pathB.length) return false;
@@ -619,7 +622,7 @@ export class Transition {
       return TransitionHook.invokeHooks(allRunHooks, done);
     };
     const startTransition = () => {
-      const globals = this.router.globals;
+      const globals = this.globals;
       globals.lastStartedTransitionId = this.$id;
       globals.transition = this;
       globals.transitionHistory.enqueue(this);

package/src/router/url/url-config.js

@@ -14,12 +14,7 @@ import { isDefined, isString } from "../../shared/utils";
  * This API is found at `router.urlService.config` (see: [[UIRouter.urlService]], [[URLService.config]])
  */
 export class UrlConfig {
-  /**
-   * @param {import('../router').UIRouter} router
-   */
-  constructor(router) {
-    /** @type {import('../router').UIRouter} */
-    this.router = router;
+  constructor() {
     /** @type {ParamTypes} */
     this.paramTypes = new ParamTypes();
     /** @type {boolean} */
@@ -30,49 +25,6 @@ export class UrlConfig {
     this._isStrictMode = true;
     /** @type {boolean} */
     this._defaultSquashPolicy = false;
-    this.dispose = () => this.paramTypes.dispose();
-    // Delegate these calls to the current LocationConfig implementation
-    /**
-     * Gets the base Href, e.g., `http://localhost/approot/`
-     *
-     * @return the application's base href
-     */
-    this.baseHref = () => this.router.locationService.baseHref();
-    /**
-     * Gets or sets the hashPrefix
-     *
-     * This only applies when not running in [[html5Mode]] (pushstate mode)
-     *
-     * If the current url is `http://localhost/app#!/uirouter/path/#anchor`, it returns `!` which is the prefix for the "hashbang" portion.
-     *
-     * @return the hash prefix
-     */
-    this.hashPrefix = (newprefix) =>
-      this.router.locationService.$locationProvider.hashPrefix(newprefix);
-    /**
-     * Gets the host, e.g., `localhost`
-     *
-     * @return {string} the protocol
-     */
-    this.host = () => this.router.locationService.$location.host();
-    /**
-     * Returns true when running in pushstate mode
-     *
-     * @return {boolean} true when running in html5 mode (pushstate mode).
-     */
-    this.html5Mode = () => this.router.locationService.html5Mode();
-    /**
-     * Gets the port, e.g., `80`
-     *
-     * @return {number} the port number
-     */
-    this.port = () => this.router.locationService.$location.port();
-    /**
-     * Gets the protocol, e.g., `http`
-     *
-     * @return {string} the protocol
-     */
-    this.protocol = () => this.router.locationService.$location.protocol();
   }
   /**
    * Defines whether URL matching should be case sensitive (the default behavior), or not.

package/src/router/url/url-matcher-factory.js

@@ -1,40 +1,7 @@
 import { forEach, isDefined, isFunction, isObject } from "../../shared/utils";
 import { UrlMatcher } from "./url-matcher";
-import { DefType, Param } from "../params/param";
+import { ParamFactory } from "../params/param-factory";
 
-export class ParamFactory {
-  constructor(router) {
-    this.router = router;
-  }
-
-  fromConfig(id, type, state) {
-    return new Param(
-      id,
-      type,
-      DefType.CONFIG,
-      this.router.urlService.config,
-      state,
-    );
-  }
-  fromPath(id, type, state) {
-    return new Param(
-      id,
-      type,
-      DefType.PATH,
-      this.router.urlService.config,
-      state,
-    );
-  }
-  fromSearch(id, type, state) {
-    return new Param(
-      id,
-      type,
-      DefType.SEARCH,
-      this.router.urlService.config,
-      state,
-    );
-  }
-}
 /**
  * Factory for [[UrlMatcher]] instances.
  *
@@ -43,28 +10,20 @@ export class ParamFactory {
  */
 export class UrlMatcherFactory {
   // TODO: move implementations to UrlConfig (urlService.config)
-  constructor(router) {
-    this.router = router;
+  constructor(urlServiceConfig) {
+    this.urlServiceConfig = urlServiceConfig;
     /** Creates a new [[Param]] for a given location (DefType) */
-    this.paramFactory = new ParamFactory(this.router);
-    // TODO: Check if removal of this will break anything, then remove these
-    this.UrlMatcher = UrlMatcher;
-    this.Param = Param;
+    this.paramFactory = new ParamFactory(urlServiceConfig);
     /** @deprecated use [[UrlConfig.caseInsensitive]] */
-    this.caseInsensitive = (value) =>
-      this.router.urlService.config.caseInsensitive(value);
+    this.caseInsensitive = (value) => urlServiceConfig.caseInsensitive(value);
     /** @deprecated use [[UrlConfig.defaultSquashPolicy]] */
     this.defaultSquashPolicy = (value) =>
-      this.router.urlService.config.defaultSquashPolicy(value);
+      urlServiceConfig.defaultSquashPolicy(value);
     /** @deprecated use [[UrlConfig.strictMode]] */
-    this.strictMode = (value) =>
-      this.router.urlService.config.strictMode(value);
+    this.strictMode = (value) => urlServiceConfig.strictMode(value);
     /** @deprecated use [[UrlConfig.type]] */
     this.type = (name, definition, definitionFn) => {
-      return (
-        this.router.urlService.config.type(name, definition, definitionFn) ||
-        this
-      );
+      return urlServiceConfig.type(name, definition, definitionFn) || this;
     };
   }
   /**
@@ -75,7 +34,7 @@ export class UrlMatcherFactory {
    * @returns The UrlMatcher.
    */
   compile(pattern, config) {
-    const urlConfig = this.router.urlService.config;
+    const urlConfig = this.urlServiceConfig;
     // backward-compatible support for config.params -> config.state.params
     const params = config && !config.state && config.params;
     config = params ? Object.assign({ state: { params } }, config) : config;
@@ -110,7 +69,7 @@ export class UrlMatcherFactory {
   }
 
   $get() {
-    const urlConfig = this.router.urlService.config;
+    const urlConfig = this.urlServiceConfig;
     urlConfig.paramTypes.enqueue = false;
     urlConfig.paramTypes._flushTypeQueue();
     return this;

package/src/router/url/url-router.js

@@ -1,5 +1,5 @@
 import { stripLastPathElement } from "../../shared/strings";
-import { UrlRuleFactory } from "./url-rule";
+
 function appendBasePath(url, isHtml5, absolute, baseHref) {
   if (baseHref === "/") return url;
   if (isHtml5) return stripLastPathElement(baseHref) + url;
@@ -16,16 +16,16 @@ function appendBasePath(url, isHtml5, absolute, baseHref) {
  */
 export class UrlRouter {
   /**
-   *
-   * @param {import('../router').UIRouter} router
+   * @param {angular.UrlService} urlService
    */
-  constructor(router) {
-    this.router = router;
-    this.urlRuleFactory = new UrlRuleFactory(router);
+  constructor(urlService, urlRuleFactory, $locationProvider) {
+    this.urlService = urlService;
+    this.urlRuleFactory = urlRuleFactory;
+    this.$locationProvider = $locationProvider;
   }
-  /** Internal API. */
+
   update(read) {
-    const $url = this.router.locationService;
+    const $url = this.urlService;
     if (read) {
       this.location = $url.url();
       return;
@@ -34,8 +34,6 @@ export class UrlRouter {
     $url.url(this.location, true);
   }
   /**
-   * Internal API.
-   *
    * Pushes a new location to the browser history.
    *
    * @internal
@@ -45,7 +43,7 @@ export class UrlRouter {
    */
   push(urlMatcher, params, options) {
     const replace = options && !!options.replace;
-    this.router.urlService.url(urlMatcher.format(params || {}), replace);
+    this.urlService.url(urlMatcher.format(params || {}), replace);
   }
   /**
    * Builds and returns a URL with interpolated parameters
@@ -70,18 +68,30 @@ export class UrlRouter {
     let url = urlMatcher.format(params);
     if (url == null) return null;
     options = options || { absolute: false };
-    const cfg = this.router.urlService.config;
-    const isHtml5 = cfg.html5Mode();
+    const cfg = this.urlService.config;
+    const isHtml5 = this.urlService.html5Mode();
     if (!isHtml5 && url !== null) {
-      url = "#" + cfg.hashPrefix() + url;
+      url = "#" + this.$locationProvider.hashPrefix() + url;
     }
-    url = appendBasePath(url, isHtml5, options.absolute, cfg.baseHref());
+    url = appendBasePath(
+      url,
+      isHtml5,
+      options.absolute,
+      this.urlService.baseHref(),
+    );
     if (!options.absolute || !url) {
       return url;
     }
     const slash = !isHtml5 && url ? "/" : "";
-    const cfgPort = cfg.port();
+    const cfgPort = this.urlService.$location.port();
     const port = cfgPort === 80 || cfgPort === 443 ? "" : ":" + cfgPort;
-    return [cfg.protocol(), "://", cfg.host(), port, slash, url].join("");
+    return [
+      cfg.protocol(),
+      "://",
+      this.urlService.$location.host(),
+      port,
+      slash,
+      url,
+    ].join("");
   }
 }

package/src/router/url/url-rule.js

@@ -13,12 +13,10 @@ import { StateObject } from "../state/state-object";
  * - [[StateObject]]
  */
 export class UrlRuleFactory {
-  constructor(router) {
-    this.router = router;
-  }
-
-  compile(str) {
-    return this.router.urlMatcherFactory.compile(str);
+  constructor(urlMatcherFactory, stateService, routerGlobals) {
+    this.urlMatcherFactory = urlMatcherFactory;
+    this.stateService = stateService;
+    this.routerGlobals = routerGlobals;
   }
 
   /**
@@ -30,11 +28,11 @@ export class UrlRuleFactory {
   create(what, handler) {
     const { isState, isStateDeclaration } = StateObject;
     const makeRule = pattern([
-      [isString, (_what) => makeRule(this.compile(_what))],
+      [isString, (_what) => makeRule(this.urlMatcherFactory.compile(_what))],
       [is(UrlMatcher), (_what) => this.fromUrlMatcher(_what, handler)],
       [
         or(isState, isStateDeclaration),
-        (_what) => this.fromState(_what, this.router),
+        (_what) => this.fromState(_what, this.stateService, this.routerGlobals),
       ],
       [is(RegExp), (_what) => this.fromRegExp(_what, handler)],
       [isFunction, (_what) => new BaseUrlRule(_what, handler)],
@@ -81,8 +79,7 @@ export class UrlRuleFactory {
    */
   fromUrlMatcher(urlMatcher, handler) {
     let _handler = handler;
-    if (isString(handler))
-      handler = this.router.urlMatcherFactory.compile(handler);
+    if (isString(handler)) handler = this.urlMatcherFactory.compile(handler);
     if (is(UrlMatcher)(handler)) _handler = (match) => handler.format(match);
     function matchUrlParamters(url) {
       const params = urlMatcher.exec(url.path, url.search, url.hash);
@@ -115,7 +112,7 @@ export class UrlRuleFactory {
    * // Starts a transition to 'foo' with params: { fooId: '123', barId: '456' }
    * ```
    */
-  fromState(stateOrDecl, router) {
+  fromState(stateOrDecl, stateService, globals) {
     const state = StateObject.isStateDeclaration(stateOrDecl)
       ? stateOrDecl.$$state()
       : stateOrDecl;
@@ -127,8 +124,7 @@ export class UrlRuleFactory {
      * and the new URL are already identical
      */
     const handler = (match) => {
-      const $state = router.stateService;
-      const globals = router.globals;
+      const $state = stateService;
       if (
         $state.href(state, match) !==
         $state.href(globals.current, globals.params)

package/src/router/url/url-rules.js

@@ -62,20 +62,16 @@ function getHandlerFn(handler) {
  *
  * The most commonly used methods are [[otherwise]] and [[when]].
  *
- * This API is found at `router.urlService.rules` (see: [[UIRouter.urlService]], [[URLService.rules]])
+ * This API is found at `$urlService.rules` (see: [[UIRouter.urlService]], [[URLService.rules]])
  */
 export class UrlRules {
-  constructor(router) {
+  constructor(urlRuleFactory) {
     this._sortFn = defaultRuleSortFn;
     this._rules = [];
     this._id = 0;
-    this.urlRuleFactory = new UrlRuleFactory(router);
+    this.urlRuleFactory = urlRuleFactory;
   }
 
-  dispose() {
-    this._rules = [];
-    delete this._otherwiseFn;
-  }
   /**
    * Defines the initial state, path, or behavior to use when the app starts.
    *