@angular-wave/angular.ts 0.0.26 → 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/params/param-types.js

@@ -54,9 +54,6 @@ export class ParamTypes {
       new ParamType(Object.assign({ name }, definition));
     this.types = inherit(map(this.defaultTypes, makeType), {});
   }
-  dispose() {
-    this.types = {};
-  }
   /**
    * Registers a parameter type
    *

package/src/router/router.js

@@ -5,10 +5,13 @@ import { ViewService } from "./view/view";
 import { StateRegistry } from "./state/state-registry";
 import { StateService } from "./state/state-service";
 import { UIRouterGlobals } from "./globals";
-import { removeFrom } from "../shared/common";
-import { isFunction } from "../shared/utils";
 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
@@ -26,86 +29,100 @@ export class UIRouter {
   /**
    * Creates a new `UIRouter` object
    *
-   * @param {import('./location-services').Ng1LocationServices} locationService
+   * @param {angular.ILocationProvider} $locationProvider
    */
-  constructor(locationService) {
-    /**
-     * @type {import('./location-services').Ng1LocationServices}
-     */
-    this.locationService = locationService;
-    /**  @type {number} */ this.$id = routerId++;
-    /**  @type {boolean} */ this._disposed = false;
-    this._disposables = [];
+  constructor($locationProvider) {
+    /**  @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);
+    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());
     this.globals.$current = this.stateRegistry.root();
     this.globals.current = this.globals.$current.self;
-    this.disposable(this.globals);
-    this.disposable(this.stateService);
-    this.disposable(this.stateRegistry);
-    this.disposable(this.transitionService);
-    this.disposable(this.urlService);
-    this.disposable(locationService);
-  }
-
-  /**
-   * Registers an object to be notified when the router is disposed
-   * @param {Disposable} disposable
-   * @returns {void}
-   */
-  disposable(disposable) {
-    this._disposables.push(disposable);
-  }
-  /**
-   * Disposes this router instance
-   *
-   * When called, clears resources retained by the router by calling `dispose(this)` on all
-   * registered [[disposable]] objects.
-   *
-   * Or, if a `disposable` object is provided, calls `dispose(this)` on that object only.
-   *
-   * @internal
-   * @param disposable (optional) the disposable to dispose
-   */
-  dispose(disposable) {
-    if (disposable && isFunction(disposable.dispose)) {
-      disposable.dispose(this);
-      return undefined;
-    }
-    this._disposed = true;
-    this._disposables.slice().forEach((d) => {
-      try {
-        typeof d.dispose === "function" && d.dispose(this);
-        removeFrom(this._disposables, d);
-      } catch (ignored) {
-        /* empty */
-      }
-    });
   }
 
   /**
@@ -167,7 +184,6 @@ export class UIRouter {
       throw new Error(
         "Required property `name` missing on plugin: " + pluginInstance,
       );
-    this._disposables.push(pluginInstance);
     return (this._plugins[pluginInstance.name] = pluginInstance);
   }
   getPlugin(pluginName) {

package/src/router/services.js

@@ -16,7 +16,6 @@ import { UIRouter } from "./router";
 import { ng1ViewsBuilder, getNg1ViewConfigFactory } from "./state/views";
 
 import { StateProvider } from "./state-provider";
-import { Ng1LocationServices } from "./location-services";
 import { ResolveContext } from "./resolve/resolve-context";
 
 /** @type {angular.UIRouter}} */
@@ -24,9 +23,8 @@ export let router = null;
 $routerProvider.$inject = ["$locationProvider"];
 /** This angular 1 provider instantiates a Router and exposes its services via the angular injector */
 export function $routerProvider($locationProvider) {
-  const ng1LocationService = new Ng1LocationServices($locationProvider);
   // Create a new instance of the Router when the $routerProvider is initialized
-  router = this.router = new UIRouter(ng1LocationService);
+  router = this.router = new UIRouter($locationProvider);
   router.stateProvider = new StateProvider(
     router.stateRegistry,
     router.stateService,
@@ -69,7 +67,7 @@ export function $routerProvider($locationProvider) {
   router["$get"] = $get;
   $get.$inject = ["$location", "$browser", "$rootScope"];
   function $get($location, $browser, $rootScope) {
-    ng1LocationService._runtimeServices($rootScope, $location, $browser);
+    router.urlService._runtimeServices($rootScope, $location, $browser);
     return router;
   }
   return router;

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

@@ -4,16 +4,14 @@ 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;
     this.queue = [];
   }
-  dispose() {
-    this.queue = [];
-  }
   register(stateDecl) {
     const queue = this.queue;
     const state = StateObject.create(stateDecl);
@@ -58,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);
@@ -84,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,
@@ -39,11 +40,6 @@ export class StateRegistry {
     _root.navigable = null;
   }
 
-  dispose() {
-    this.stateQueue.dispose();
-    this.listeners = [];
-    this.get().forEach((state) => this.get(state) && this.deregister(state));
-  }
   /**
    * Listen for a State Registry events
    *
@@ -119,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()
@@ -152,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,12 +78,12 @@ export class StateService {
       val(this),
       boundFns,
     );
-  }
 
-  dispose() {
-    this.defaultErrorHandler(() => {});
-    this.invalidCallbacks = [];
+    EventBus.subscribe("$stateService:defaultErrorHandler", (err) =>
+      this.defaultErrorHandler()(err),
+    );
   }
+
   /**
    * Handler for when [[transitionTo]] is called with an invalid state.
    *
@@ -105,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());
@@ -221,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,
@@ -301,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();
@@ -330,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();
@@ -355,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 (
@@ -373,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);
         }
       }
@@ -381,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));
@@ -430,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
@@ -486,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
@@ -519,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;
@@ -582,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];