@angular-wave/angular.ts 0.0.27 → 0.0.29

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

@@ -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

@@ -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();

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/index.js

@@ -11,15 +11,15 @@ import { trace } from "./common/trace";
 import { $ViewScrollProvider } from "./view-scroll";
 import { $IsStateFilter, $IncludedByStateFilter } from "./state-filters";
 import {
-  uiSrefActiveDirective,
-  uiStateDirective,
-  uiSrefDirective,
+  ngSrefActiveDirective,
+  ngStateDirective,
+  ngSrefDirective,
 } from "./directives/state-directives";
-import { uiView, $ViewDirectiveFill } from "./directives/view-directive";
+import { ngView, $ViewDirectiveFill } from "./directives/view-directive";
 
 export function initRouter() {
   window.angular
-    .module("ui.router", ["ng"])
+    .module("ng.router", ["ng"])
     .provider("$router", $routerProvider)
     .provider("$urlService", getProviderFor("urlService"))
     .provider("$urlMatcherFactory", [
@@ -33,7 +33,7 @@ export function initRouter() {
     .provider("$routerGlobals", getProviderFor("globals"))
     .provider("$transitions", getProviderFor("transitionService"))
     .provider("$state", ["$routerProvider", getStateProvider])
-    .provider("$uiViewScroll", $ViewScrollProvider)
+    .provider("$ngViewScroll", $ViewScrollProvider)
     .factory("$stateParams", [
       "$router",
       function ($router) {
@@ -46,12 +46,12 @@ export function initRouter() {
     .value("$trace", trace)
     .filter("isState", $IsStateFilter)
     .filter("includedByState", $IncludedByStateFilter)
-    .directive("uiSref", uiSrefDirective)
-    .directive("uiSrefActive", uiSrefActiveDirective)
-    .directive("uiSrefActiveEq", uiSrefActiveDirective)
-    .directive("uiState", uiStateDirective)
-    .directive("uiView", uiView)
-    .directive("uiView", $ViewDirectiveFill)
+    .directive("ngSref", ngSrefDirective)
+    .directive("ngSrefActive", ngSrefActiveDirective)
+    .directive("ngSrefActiveEq", ngSrefActiveDirective)
+    .directive("ngState", ngStateDirective)
+    .directive("ngView", ngView)
+    .directive("ngView", $ViewDirectiveFill)
 
     .run(watchDigests)
     .run(runBlock);

package/src/router/injectables.js

@@ -195,7 +195,7 @@ let $stateRegistryProvider;
  * This angular service exposes the [[UIViewScrollProvider]] singleton and is
  * used to disable UI-Router's scroll behavior.
  */
-let $uiViewScrollProvider;
+let $ngViewScrollProvider;
 /**
  * The View Scroll function
  *
@@ -207,9 +207,9 @@ let $uiViewScrollProvider;
  * If you prefer to rely on `$anchorScroll` to scroll the view to the anchor,
  * this can be enabled by calling [[UIViewScrollProvider.useAnchorScroll]].
  *
- * Note: this function is used by the [[directives.uiView]] when the `autoscroll` expression evaluates to true.
+ * Note: this function is used by the [[directives.ngView]] when the `autoscroll` expression evaluates to true.
  */
-let $uiViewScroll;
+let $ngViewScroll;
 /**
  * The StateProvider
  *

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,93 @@ 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.globals,
+      this.viewService,
+    );
+
+    /** @type {StateService} Provides services related to states */
+    this.stateService = new StateService(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,
+    );
+
+    // Manual wiring ideally we would want to do this at runtime
+    this.stateService.stateRegistry = this.stateRegistry;
+    this.stateService.urlRouter = this.urlRouter;
+    this.stateService.urlService = this.urlService; // <-- NOTE: circular dependency
+
+    // 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/services.js

@@ -13,7 +13,7 @@ import { applyPairs, unnestR } from "../shared/common";
 import { isString } from "../shared/utils";
 import { trace } from "./common/trace";
 import { UIRouter } from "./router";
-import { ng1ViewsBuilder, getNg1ViewConfigFactory } from "./state/views";
+import { getNg1ViewConfigFactory } from "./state/views";
 
 import { StateProvider } from "./state-provider";
 import { ResolveContext } from "./resolve/resolve-context";
@@ -29,11 +29,6 @@ export function $routerProvider($locationProvider) {
     router.stateRegistry,
     router.stateService,
   );
-  // Apply ng1 specific StateBuilder code for `views`, `resolve`, and `onExit/Retain/Enter` properties
-  router.stateRegistry.decorator("views", ng1ViewsBuilder);
-  router.stateRegistry.decorator("onExit", getStateHookBuilder("onExit"));
-  router.stateRegistry.decorator("onRetain", getStateHookBuilder("onRetain"));
-  router.stateRegistry.decorator("onEnter", getStateHookBuilder("onEnter"));
   router.viewService._pluginapi._viewConfigFactory(
     "ng1",
     getNg1ViewConfigFactory(),
@@ -65,8 +60,9 @@ export function $routerProvider($locationProvider) {
   // backwards compat: also expose router instance as $routerProvider.router
   router["router"] = router;
   router["$get"] = $get;
-  $get.$inject = ["$location", "$browser", "$rootScope"];
-  function $get($location, $browser, $rootScope) {
+  $get.$inject = ["$location", "$browser", "$rootScope", "$injector"];
+  function $get($location, $browser, $rootScope, $injector) {
+    router.stateRegistry.init($injector);
     router.urlService._runtimeServices($rootScope, $location, $browser);
     return router;
   }

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

@@ -240,6 +240,7 @@ export function resolvablesBuilder(state) {
 export class StateBuilder {
   constructor(matcher, urlMatcherFactory) {
     this.matcher = matcher;
+    this.$injector = undefined;
     const self = this;
     const root = () => matcher.find("");
     const isRoot = (state) => state.name === "";

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

@@ -3,21 +3,32 @@ import { StateBuilder } from "./state-builder";
 import { StateQueueManager } from "./state-queue-manager";
 import { removeFrom } from "../../shared/common";
 import { propEq } from "../../shared/hof";
+import { ResolveContext } from "../resolve/resolve-context";
+import { getLocals } from "../services";
+import { ng1ViewsBuilder } from "./views";
 /**
  * A registry for all of the application's [[StateDeclaration]]s
  *
- * This API is found at `router.stateRegistry` ([[UIRouter.stateRegistry]])
+ * This API is found at `$stateRegistry` ([[UIRouter.stateRegistry]])
  */
 export class StateRegistry {
-  constructor(router) {
-    this.router = router;
+  constructor(urlMatcherFactory, urlServiceRules) {
     this.states = {};
-
+    this.urlServiceRules = urlServiceRules;
+    this.$injector = undefined;
     this.listeners = [];
     this.matcher = new StateMatcher(this.states);
-    this.builder = new StateBuilder(this.matcher, router.urlMatcherFactory);
+    this.builder = new StateBuilder(this.matcher, urlMatcherFactory);
+    // Apply ng1 specific StateBuilder code for `views`, `resolve`, and `onExit/Retain/Enter` properties
+    // TODO we can probably move this inside buildr
+    this.builder.builder("views", ng1ViewsBuilder);
+    this.builder.builder("onExit", this.getStateHookBuilder("onExit"));
+    this.builder.builder("onRetain", this.getStateHookBuilder("onRetain"));
+    this.builder.builder("onEnter", this.getStateHookBuilder("onEnter"));
+
     this.stateQueue = new StateQueueManager(
-      router,
+      this,
+      urlServiceRules,
       this.states,
       this.builder,
       this.listeners,
@@ -25,6 +36,41 @@ export class StateRegistry {
     this._registerRoot();
   }
 
+  /**
+   * @param {angular.$InjectorLike} $injector
+   */
+  init($injector) {
+    this.$injector = $injector;
+    this.builder.$injector = $injector;
+  }
+
+  /**
+   * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
+   * `onRetain` callback hooks on a [[Ng1StateDeclaration]].
+   *
+   * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder
+   * ensures that those hooks are injectable for @uirouter/angularjs (ng1).
+   *
+   * @internalapi
+   */
+  getStateHookBuilder(hookName) {
+    let that = this;
+    return function stateHookBuilder(stateObject) {
+      const hook = stateObject[hookName];
+      const pathname = hookName === "onExit" ? "from" : "to";
+      function decoratedNg1Hook(trans, state) {
+        const resolveContext = new ResolveContext(trans.treeChanges(pathname));
+        const subContext = resolveContext.subContext(state.$$state());
+        const locals = Object.assign(getLocals(subContext), {
+          $state$: state,
+          $transition$: trans,
+        });
+        return that.$injector.invoke(hook, this, locals);
+      }
+      return hook ? decoratedNg1Hook : undefined;
+    };
+  }
+
   _registerRoot() {
     const rootStateDef = {
       name: "",
@@ -114,7 +160,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 +193,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.
@@ -166,4 +214,12 @@ export class StateRegistry {
   decorator(property, builderFunction) {
     return this.builder.builder(property, builderFunction);
   }
+
+  $get = [
+    "$injector",
+    function ($injector) {
+      this.init($injector);
+      return this;
+    },
+  ];
 }