@angular-wave/angular.ts 0.0.28 → 0.0.29

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

@@ -47,17 +47,13 @@ export class UIRouter {
 
     /** @type {TransitionService}  A service that exposes global Transition Hooks */
     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,
-    );
+    this.stateService = new StateService(this.globals, this.transitionService);
+
     /** Provides services related to the URL */
     let urlRuleFactory = new UrlRuleFactory(
       this.urlMatcherFactory,
@@ -96,6 +92,11 @@ export class UIRouter {
       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,

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-registry.js

@@ -3,19 +3,29 @@ 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(urlMatcherFactory, urlServiceRules) {
     this.states = {};
     this.urlServiceRules = urlServiceRules;
-
+    this.$injector = undefined;
     this.listeners = [];
     this.matcher = new StateMatcher(this.states);
     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(
       this,
       urlServiceRules,
@@ -26,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: "",
@@ -169,4 +214,12 @@ export class StateRegistry {
   decorator(property, builderFunction) {
     return this.builder.builder(property, builderFunction);
   }
+
+  $get = [
+    "$injector",
+    function ($injector) {
+      this.init($injector);
+      return this;
+    },
+  ];
 }

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

@@ -53,8 +53,10 @@ export class StateService {
   }
 
   // Needs access to urlRouter, stateRegistry
-  constructor(router, globals, transitionService) {
-    this.router = router;
+  constructor(globals, transitionService) {
+    this.stateRegistry = undefined;
+    this.urlRouter = undefined;
+    this.urlService = undefined;
     this.globals = globals;
     this.transitionService = transitionService;
     this.invalidCallbacks = [];
@@ -96,10 +98,7 @@ export class StateService {
    * @internal
    */
   _handleInvalidTargetState(fromPath, toState) {
-    const fromState = PathUtils.makeTargetState(
-      this.router.stateRegistry,
-      fromPath,
-    );
+    const fromState = PathUtils.makeTargetState(this.stateRegistry, fromPath);
     const globals = this.globals;
     const latestThing = () => globals.transitionHistory.peekTail();
     const latest = latestThing();
@@ -278,7 +277,7 @@ export class StateService {
     // If we're reloading, find the state object to reload from
     if (isObject(options.reload) && !options.reload.name)
       throw new Error("Invalid reload state object");
-    const reg = this.router.stateRegistry;
+    const reg = this.stateRegistry;
     options.reloadState =
       options.reload === true
         ? reg.root()
@@ -287,18 +286,13 @@ export class StateService {
       throw new Error(
         `No such reload state '${isString(options.reload) ? options.reload : options.reload.name}'`,
       );
-    return new TargetState(
-      this.router.stateRegistry,
-      identifier,
-      params,
-      options,
-    );
+    return new TargetState(this.stateRegistry, identifier, params, options);
   }
 
   getCurrentPath() {
     const globals = this.globals;
     const latestSuccess = globals.successfulTransitions.peekTail();
-    const rootPath = () => [new PathNode(this.router.stateRegistry.root())];
+    const rootPath = () => [new PathNode(this.stateRegistry.root())];
     return latestSuccess ? latestSuccess.treeChanges().to : rootPath();
   }
   /**
@@ -350,7 +344,7 @@ export class StateService {
       if (error instanceof Rejection) {
         const isLatest = this.globals.lastStartedTransitionId <= trans.$id;
         if (error.type === RejectType.IGNORED) {
-          isLatest && this.router.urlRouter.update();
+          isLatest && EventBus.publish("urlRouter.update");
           // Consider ignored `Transition.run()` as a successful `transitionTo`
           return services.$q.when(this.globals.current);
         }
@@ -366,7 +360,7 @@ export class StateService {
           return redirect.run().catch(rejectedTransitionHandler(redirect));
         }
         if (error.type === RejectType.ABORTED) {
-          isLatest && this.router.urlRouter.update();
+          isLatest && EventBus.publish("urlRouter.update");
           return services.$q.reject(error);
         }
       }
@@ -415,7 +409,7 @@ export class StateService {
    */
   is(stateOrName, params, options) {
     options = defaults(options, { relative: this.$current });
-    const state = this.router.stateRegistry.matcher.find(
+    const state = this.stateRegistry.matcher.find(
       stateOrName,
       options.relative,
     );
@@ -474,7 +468,7 @@ export class StateService {
       if (!glob.matches(this.$current.name)) return false;
       stateOrName = this.$current.name;
     }
-    const state = this.router.stateRegistry.matcher.find(
+    const state = this.stateRegistry.matcher.find(
         stateOrName,
         options.relative,
       ),
@@ -514,7 +508,7 @@ export class StateService {
     };
     options = defaults(options, defaultHrefOpts);
     params = params || {};
-    const state = this.router.stateRegistry.matcher.find(
+    const state = this.stateRegistry.matcher.find(
       stateOrName,
       options.relative,
     );
@@ -525,7 +519,7 @@ export class StateService {
     if (!nav || nav.url === undefined || nav.url === null) {
       return null;
     }
-    return this.router.urlRouter.href(nav.url, params, {
+    return this.urlRouter.href(nav.url, params, {
       absolute: options.absolute,
     });
   }
@@ -557,7 +551,7 @@ export class StateService {
     return (this._defaultErrorHandler = handler || this._defaultErrorHandler);
   }
   get(stateOrName, base) {
-    const reg = this.router.stateRegistry;
+    const reg = this.stateRegistry;
     if (arguments.length === 0) return reg.get();
     return reg.get(stateOrName, base || this.$current);
   }
@@ -578,10 +572,7 @@ export class StateService {
     if (!state || !state.lazyLoad)
       throw new Error("Can not lazy load " + stateOrName);
     const currentPath = this.getCurrentPath();
-    const target = PathUtils.makeTargetState(
-      this.router.stateRegistry,
-      currentPath,
-    );
+    const target = PathUtils.makeTargetState(this.stateRegistry, currentPath);
     transition =
       transition || this.transitionService.create(currentPath, target);
     return lazyLoadState(transition, state);

package/src/router/state/views.js

@@ -81,8 +81,8 @@ export function ng1ViewsBuilder(state) {
       config.$context,
       config.$name,
     );
-    config.$uiViewName = normalized.uiViewName;
-    config.$uiViewContextAnchor = normalized.uiViewContextAnchor;
+    config.$ngViewName = normalized.ngViewName;
+    config.$ngViewContextAnchor = normalized.ngViewContextAnchor;
     views[name] = config;
   });
   return views;
@@ -101,10 +101,10 @@ export class Ng1ViewConfig {
 
     /** @type {Number} */ this.$id = id++;
     this.loaded = false;
-    this.getTemplate = (uiView, context) =>
+    this.getTemplate = (ngView, context) =>
       this.component
         ? this.factory.makeComponentTemplate(
-            uiView,
+            ngView,
             context,
             this.component,
             this.viewDecl.bindings,

package/src/router/state-filters.js

@@ -1,5 +1,3 @@
-/** @publicapi @module ng1 */ /** */
-
 /**
  * `isState` Filter: truthy if the current state is the parameter
  *

package/src/router/state-provider.js

@@ -1,5 +1,3 @@
-/** @publicapi @module ng1 */ /** */
-
 import { val } from "../shared/hof";
 import { createProxyFunctions } from "../shared/common";
 import { minErr } from "../shared/utils";

package/src/router/template-factory.js

@@ -172,13 +172,13 @@ export class TemplateFactory {
    * It analyses the component's bindings, then constructs a template that instantiates the component.
    * The template wires input and output bindings to resolves or from the parent component.
    *
-   * @param {angular.IAugmentedJQuery} uiView {object} The parent ui-view (for binding outputs to callbacks)
+   * @param {angular.IAugmentedJQuery} ngView {object} The parent ui-view (for binding outputs to callbacks)
    * @param {angular.ResolveContext} context The ResolveContext (for binding outputs to callbacks returned from resolves)
    * @param {string} component {string} Component's name in camel case.
    * @param {any} [bindings] An object defining the component's bindings: {foo: '<'}
    * @return {string} The template as a string: "<component-name input1='::$resolve.foo'></component-name>".
    */
-  makeComponentTemplate(uiView, context, component, bindings) {
+  makeComponentTemplate(ngView, context, component, bindings) {
     bindings = bindings || {};
     // Bind once prefix
     const prefix = "::"; //angular.version.minor >= 3 ? "::" : "";
@@ -194,8 +194,8 @@ export class TemplateFactory {
       // If the ui-view has an attribute which matches a binding on the routed component
       // then pass that attribute through to the routed component template.
       // Prefer ui-view wired mappings to resolve data, unless the resolve was explicitly bound using `bindings:`
-      if (uiView.attr(attrName) && !bindings[name])
-        return `${attrName}='${uiView.attr(attrName)}'`;
+      if (ngView.attr(attrName) && !bindings[name])
+        return `${attrName}='${ngView.attr(attrName)}'`;
       const resolveName = bindings[name] || name;
       // Pre-evaluate the expression for "@" bindings by enclosing in {{ }}
       // some-attr="{{ ::$resolve.someResolveName }}"

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

@@ -57,9 +57,9 @@ export let defaultTransOpts = {
  */
 export class TransitionService {
   /**
-   * @param {import('../router').UIRouter} router
+   * @param {import('../globals').UIRouterGlobals} globals
    */
-  constructor(router, globals, viewService) {
+  constructor(globals, viewService) {
     this._transitionCount = 0;
     /** The transition hook types, such as `onEnter`, `onStart`, etc */
     this._eventTypes = [];
@@ -67,7 +67,6 @@ export class TransitionService {
     this._registeredHooks = {};
     /** The  paths on a criteria object */
     this._criteriaPaths = {};
-    this.router = router;
     this.globals = globals;
     this.$view = viewService;
     this._deregisterHookFns = {};

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

@@ -1,3 +1,4 @@
+import { EventBus } from "../../core/pubsub";
 import { stripLastPathElement } from "../../shared/strings";
 
 function appendBasePath(url, isHtml5, absolute, baseHref) {
@@ -22,6 +23,9 @@ export class UrlRouter {
     this.urlService = urlService;
     this.urlRuleFactory = urlRuleFactory;
     this.$locationProvider = $locationProvider;
+    EventBus.subscribe("$urlRouter:update", () => {
+      this.update();
+    });
   }
 
   update(read) {