@angular-wave/angular.ts 0.0.27 → 0.0.28

package/src/router/hooks/url.js

@@ -1,25 +1,34 @@
-/**
- * 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) =>
+export const registerUpdateUrl = (
+  transitionService,
+  stateService,
+  urlRouter,
+) => {
+  /**
+   * A [[TransitionHookFn]] which updates the URL after a successful transition
+   *
+   * Registered using `transitionService.onSuccess({}, updateUrl);`
+   */
+  const updateUrl = (transition) => {
+    const options = transition.options();
+    const $state = stateService;
+    const $urlRouter = 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.globals.params,
+        urlOptions,
+      );
+    }
+    $urlRouter.update(true);
+  };
   transitionService.onSuccess({}, updateUrl, { priority: 9999 });
+};

package/src/router/hooks/views.js

@@ -17,24 +17,25 @@ const loadEnteringViews = (transition) => {
 };
 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) =>
+
+export const registerActivateViews = (transitionService, viewService) => {
+  /**
+   * 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;
+    exitingViews.forEach((vc) => viewService.deactivateViewConfig(vc));
+    enteringViews.forEach((vc) => viewService.activateViewConfig(vc));
+    viewService.sync();
+  };
   transitionService.onSuccess({}, activateViews);
+};

package/src/router/params/param-factory.js

@@ -0,0 +1,17 @@
+import { DefType, Param } from "../params/param";
+
+export class ParamFactory {
+  constructor(urlServiceConfig) {
+    this.urlServiceConfig = urlServiceConfig;
+  }
+
+  fromConfig(id, type, state) {
+    return new Param(id, type, DefType.CONFIG, this.urlServiceConfig, state);
+  }
+  fromPath(id, type, state) {
+    return new Param(id, type, DefType.PATH, this.urlServiceConfig, state);
+  }
+  fromSearch(id, type, state) {
+    return new Param(id, type, DefType.SEARCH, this.urlServiceConfig, state);
+  }
+}

package/src/router/router.js

@@ -7,6 +7,11 @@ import { StateService } from "./state/state-service";
 import { UIRouterGlobals } from "./globals";
 import { UrlService } from "./url/url-service";
 import { trace } from "./common/trace";
+import { UrlRuleFactory } from "./url/url-rule";
+import { registerLazyLoadHook } from "./hooks/lazy-load";
+import { registerUpdateUrl } from "./hooks/url";
+import { registerActivateViews } from "./hooks/views";
+import { registerRedirectToHook } from "./hooks/redirect-to";
 
 /**
  * Router id tracker
@@ -27,33 +32,92 @@ export class UIRouter {
    * @param {angular.ILocationProvider} $locationProvider
    */
   constructor($locationProvider) {
-    /**  @type {number} */ this.$id = routerId++;
+    /**  @type {number} */
+    this.$id = routerId++;
 
     /** Enable/disable tracing to the javascript console */
     this.trace = trace;
     this.$locationProvider = $locationProvider;
+
     /** Provides services related to ui-view synchronization */
-    this.viewService = new ViewService(this);
+    this.viewService = new ViewService(routerId);
+
     /** @type {UIRouterGlobals} An object that contains global router state, such as the current state and params */
     this.globals = new UIRouterGlobals();
+
     /** @type {TransitionService}  A service that exposes global Transition Hooks */
-    this.transitionService = new TransitionService(this);
+    this.transitionService = new TransitionService(
+      this,
+      this.globals,
+      this.viewService,
+    );
+
+    /** @type {StateService} Provides services related to states */
+    this.stateService = new StateService(
+      this, // access to StateRegistry and UrlRouter
+      this.globals,
+      this.transitionService,
+    );
+    /** Provides services related to the URL */
+    let urlRuleFactory = new UrlRuleFactory(
+      this.urlMatcherFactory,
+      this.stateService,
+      this.globals,
+    );
+
+    /**
+     * @type {angular.UrlService}
+     */
+    this.urlService = new UrlService(
+      $locationProvider,
+      urlRuleFactory,
+      this.stateService,
+    );
+
     /**
      * Deprecated for public use. Use [[urlService]] instead.
      * @deprecated Use [[urlService]] instead
      */
-    this.urlMatcherFactory = new UrlMatcherFactory(this);
+    this.urlMatcherFactory = new UrlMatcherFactory(this.urlService.config);
+
     /**
      * Deprecated for public use. Use [[urlService]] instead.
      * @deprecated Use [[urlService]] instead
      */
-    this.urlRouter = new UrlRouter(this);
-    /** Provides services related to the URL */
-    this.urlService = new UrlService(this, $locationProvider);
+    this.urlRouter = new UrlRouter(
+      this.urlService,
+      urlRuleFactory,
+      $locationProvider,
+    );
+
     /** Provides a registry for states, and related registration services */
-    this.stateRegistry = new StateRegistry(this);
-    /** Provides services related to states */
-    this.stateService = new StateService(this);
+    this.stateRegistry = new StateRegistry(
+      this.urlMatcherFactory,
+      this.urlService.rules,
+    );
+
+    // Lazy load state trees
+    this.transitionService._deregisterHookFns.lazyLoad = registerLazyLoadHook(
+      this.transitionService,
+      this.stateService,
+      this.urlService,
+      this.stateRegistry,
+    );
+
+    // After globals.current is updated at priority: 10000
+    this.transitionService._deregisterHookFns.updateUrl = registerUpdateUrl(
+      this.transitionService,
+      this.stateService,
+      this.urlRouter,
+    );
+
+    // Wire up redirectTo hook
+    this.transitionService._deregisterHookFns.redirectTo =
+      registerRedirectToHook(this.transitionService, this.stateService);
+
+    this.transitionService._deregisterHookFns.activateViews =
+      registerActivateViews(this.transitionService, this.viewService);
+
     /** @internal plugin instances are registered here */
     this._plugins = {};
     this.viewService._pluginapi._rootViewContext(this.stateRegistry.root());

package/src/router/state/state-queue-manager.js

@@ -4,8 +4,9 @@ import { isString } from "../../shared/utils";
 import { StateObject } from "./state-object";
 
 export class StateQueueManager {
-  constructor(router, states, builder, listeners) {
-    this.router = router;
+  constructor(stateRegistry, urlServiceRules, states, builder, listeners) {
+    this.stateRegistry = stateRegistry;
+    this.urlServiceRules = urlServiceRules;
     this.states = states;
     this.builder = builder;
     this.listeners = listeners;
@@ -55,7 +56,7 @@ export class StateQueueManager {
         const existingFutureState = getState(name + ".**");
         if (existingFutureState) {
           // Remove future state of the same name
-          this.router.stateRegistry.deregister(existingFutureState);
+          this.stateRegistry.deregister(existingFutureState);
         }
         states[name] = state;
         this.attachRoute(state);
@@ -81,7 +82,7 @@ export class StateQueueManager {
   }
   attachRoute(state) {
     if (state.abstract || !state.url) return;
-    const rulesApi = this.router.urlService.rules;
+    const rulesApi = this.urlServiceRules;
     rulesApi.rule(rulesApi.urlRuleFactory.create(state));
   }
 }

package/src/router/state/state-registry.js

@@ -9,15 +9,16 @@ import { propEq } from "../../shared/hof";
  * This API is found at `router.stateRegistry` ([[UIRouter.stateRegistry]])
  */
 export class StateRegistry {
-  constructor(router) {
-    this.router = router;
+  constructor(urlMatcherFactory, urlServiceRules) {
     this.states = {};
+    this.urlServiceRules = urlServiceRules;
 
     this.listeners = [];
     this.matcher = new StateMatcher(this.states);
-    this.builder = new StateBuilder(this.matcher, router.urlMatcherFactory);
+    this.builder = new StateBuilder(this.matcher, urlMatcherFactory);
     this.stateQueue = new StateQueueManager(
-      router,
+      this,
+      urlServiceRules,
       this.states,
       this.builder,
       this.listeners,
@@ -114,7 +115,7 @@ export class StateRegistry {
     const children = getChildren([state]);
     const deregistered = [state].concat(children).reverse();
     deregistered.forEach((_state) => {
-      const rulesApi = this.router.urlService.rules;
+      const rulesApi = this.urlServiceRules;
       // Remove URL rule
       rulesApi
         .rules()
@@ -147,12 +148,14 @@ export class StateRegistry {
     );
     return deregisteredStates;
   }
+
   get(stateOrName, base) {
     if (arguments.length === 0)
       return Object.keys(this.states).map((name) => this.states[name].self);
     const found = this.matcher.find(stateOrName, base);
     return (found && found.self) || null;
   }
+
   /**
    * Registers a [[BuilderFunction]] for a specific [[StateObject]] property (e.g., `parent`, `url`, or `path`).
    * More than one BuilderFunction can be registered for a given property.

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

@@ -19,27 +19,21 @@ import { Glob } from "../common/glob";
 import { ResolveContext } from "../resolve/resolve-context";
 import { lazyLoadState } from "../hooks/lazy-load";
 import { not, val } from "../../shared/hof";
+import { EventBus } from "../../core/pubsub";
+
 /**
  * Provides services related to ui-router states.
  *
  * This API is located at `router.stateService` ([[UIRouter.stateService]])
  */
 export class StateService {
-  /**
-   * The [[Transition]] currently in progress (or null)
-   *
-   * @deprecated This is a passthrough through to [[UIRouterGlobals.transition]]
-   */
-  get transition() {
-    return this.router.globals.transition;
-  }
   /**
    * The latest successful state parameters
    *
    * @deprecated This is a passthrough through to [[UIRouterGlobals.params]]
    */
   get params() {
-    return this.router.globals.params;
+    return this.globals.params;
   }
   /**
    * The current [[StateDeclaration]]
@@ -47,7 +41,7 @@ export class StateService {
    * @deprecated This is a passthrough through to [[UIRouterGlobals.current]]
    */
   get current() {
-    return this.router.globals.current;
+    return this.globals.current;
   }
   /**
    * The current [[StateObject]] (an internal API)
@@ -55,13 +49,14 @@ export class StateService {
    * @deprecated This is a passthrough through to [[UIRouterGlobals.$current]]
    */
   get $current() {
-    return this.router.globals.$current;
+    return this.globals.$current;
   }
 
-  constructor(router) {
-    /** @private */
+  // Needs access to urlRouter, stateRegistry
+  constructor(router, globals, transitionService) {
     this.router = router;
-
+    this.globals = globals;
+    this.transitionService = transitionService;
     this.invalidCallbacks = [];
 
     this._defaultErrorHandler = function $defaultErrorHandler($error$) {
@@ -83,6 +78,10 @@ export class StateService {
       val(this),
       boundFns,
     );
+
+    EventBus.subscribe("$stateService:defaultErrorHandler", (err) =>
+      this.defaultErrorHandler()(err),
+    );
   }
 
   /**
@@ -101,7 +100,7 @@ export class StateService {
       this.router.stateRegistry,
       fromPath,
     );
-    const globals = this.router.globals;
+    const globals = this.globals;
     const latestThing = () => globals.transitionHistory.peekTail();
     const latest = latestThing();
     const callbackQueue = new Queue(this.invalidCallbacks.slice());
@@ -217,7 +216,7 @@ export class StateService {
    * @returns A promise representing the state of the new transition. See [[StateService.go]]
    */
   reload(reloadState) {
-    return this.transitionTo(this.current, this.params, {
+    return this.transitionTo(this.globals.current, this.globals.params, {
       reload: isDefined(reloadState) ? reloadState : true,
       inherit: false,
       notify: false,
@@ -297,7 +296,7 @@ export class StateService {
   }
 
   getCurrentPath() {
-    const globals = this.router.globals;
+    const globals = this.globals;
     const latestSuccess = globals.successfulTransitions.peekTail();
     const rootPath = () => [new PathNode(this.router.stateRegistry.root())];
     return latestSuccess ? latestSuccess.treeChanges().to : rootPath();
@@ -326,10 +325,8 @@ export class StateService {
    * @returns A promise representing the state of the new transition. See [[go]]
    */
   transitionTo(to, toParams = {}, options = {}) {
-    const router = this.router;
-    const globals = router.globals;
     options = defaults(options, defaultTransOpts);
-    const getCurrent = () => globals.transition;
+    const getCurrent = () => this.globals.transition;
     options = Object.assign(options, { current: getCurrent });
     const ref = this.target(to, toParams, options);
     const currentPath = this.getCurrentPath();
@@ -351,11 +348,11 @@ export class StateService {
      */
     const rejectedTransitionHandler = (trans) => (error) => {
       if (error instanceof Rejection) {
-        const isLatest = router.globals.lastStartedTransitionId <= trans.$id;
+        const isLatest = this.globals.lastStartedTransitionId <= trans.$id;
         if (error.type === RejectType.IGNORED) {
-          isLatest && router.urlRouter.update();
+          isLatest && this.router.urlRouter.update();
           // Consider ignored `Transition.run()` as a successful `transitionTo`
-          return services.$q.when(globals.current);
+          return services.$q.when(this.globals.current);
         }
         const detail = error.detail;
         if (
@@ -369,7 +366,7 @@ export class StateService {
           return redirect.run().catch(rejectedTransitionHandler(redirect));
         }
         if (error.type === RejectType.ABORTED) {
-          isLatest && router.urlRouter.update();
+          isLatest && this.router.urlRouter.update();
           return services.$q.reject(error);
         }
       }
@@ -377,7 +374,7 @@ export class StateService {
       errorHandler(error);
       return services.$q.reject(error);
     };
-    const transition = this.router.transitionService.create(currentPath, ref);
+    const transition = this.transitionService.create(currentPath, ref);
     const transitionToPromise = transition
       .run()
       .catch(rejectedTransitionHandler(transition));
@@ -426,7 +423,11 @@ export class StateService {
     if (this.$current !== state) return false;
     if (!params) return true;
     const schema = state.parameters({ inherit: true, matchingKeys: params });
-    return Param.equals(schema, Param.values(schema, params), this.params);
+    return Param.equals(
+      schema,
+      Param.values(schema, params),
+      this.globals.params,
+    );
   }
   /**
    * Checks if the current state *includes* the provided state
@@ -482,7 +483,11 @@ export class StateService {
     if (!isDefined(include[state.name])) return false;
     if (!params) return true;
     const schema = state.parameters({ inherit: true, matchingKeys: params });
-    return Param.equals(schema, Param.values(schema, params), this.params);
+    return Param.equals(
+      schema,
+      Param.values(schema, params),
+      this.globals.params,
+    );
   }
   /**
    * Generates a URL for a state and parameters
@@ -515,7 +520,7 @@ export class StateService {
     );
     if (!isDefined(state)) return null;
     if (options.inherit)
-      params = this.params.$inherit(params, this.$current, state);
+      params = this.globals.params.$inherit(params, this.$current, state);
     const nav = state && options.lossy ? state.navigable : state;
     if (!nav || nav.url === undefined || nav.url === null) {
       return null;
@@ -578,7 +583,7 @@ export class StateService {
       currentPath,
     );
     transition =
-      transition || this.router.transitionService.create(currentPath, target);
+      transition || this.transitionService.create(currentPath, target);
     return lazyLoadState(transition, state);
   }
 }

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

@@ -19,7 +19,7 @@ export class HookBuilder {
     this.transition = transition;
   }
   buildHooksForPhase(phase) {
-    const $transitions = this.transition.router.transitionService;
+    const $transitions = this.transition.transitionService;
     return $transitions._pluginapi
       ._getEvents(phase)
       .map((type) => this.buildHooks(type))
@@ -96,7 +96,7 @@ export class HookBuilder {
   getMatchingHooks(hookType, treeChanges, transition) {
     const isCreate = hookType.hookPhase === TransitionHookPhase.CREATE;
     // Instance and Global hook registries
-    const $transitions = this.transition.router.transitionService;
+    const $transitions = this.transition.transitionService;
     const registries = isCreate
       ? [$transitions]
       : [this.transition, $transitions];

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;

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*.
@@ -122,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() {
@@ -242,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);
@@ -254,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);
   }