@angular-wave/angular.ts 0.0.27 → 0.0.29

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,16 @@ 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 */
-    this.router = router;
-
+  // Needs access to urlRouter, stateRegistry
+  constructor(globals, transitionService) {
+    this.stateRegistry = undefined;
+    this.urlRouter = undefined;
+    this.urlService = undefined;
+    this.globals = globals;
+    this.transitionService = transitionService;
     this.invalidCallbacks = [];
 
     this._defaultErrorHandler = function $defaultErrorHandler($error$) {
@@ -83,6 +80,10 @@ export class StateService {
       val(this),
       boundFns,
     );
+
+    EventBus.subscribe("$stateService:defaultErrorHandler", (err) =>
+      this.defaultErrorHandler()(err),
+    );
   }
 
   /**
@@ -97,11 +98,8 @@ export class StateService {
    * @internal
    */
   _handleInvalidTargetState(fromPath, toState) {
-    const fromState = PathUtils.makeTargetState(
-      this.router.stateRegistry,
-      fromPath,
-    );
-    const globals = this.router.globals;
+    const fromState = PathUtils.makeTargetState(this.stateRegistry, fromPath);
+    const globals = this.globals;
     const latestThing = () => globals.transitionHistory.peekTail();
     const latest = latestThing();
     const callbackQueue = new Queue(this.invalidCallbacks.slice());
@@ -217,7 +215,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,
@@ -279,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()
@@ -288,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.router.globals;
+    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();
   }
   /**
@@ -326,10 +319,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 +342,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 && EventBus.publish("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 +360,7 @@ export class StateService {
           return redirect.run().catch(rejectedTransitionHandler(redirect));
         }
         if (error.type === RejectType.ABORTED) {
-          isLatest && router.urlRouter.update();
+          isLatest && EventBus.publish("urlRouter.update");
           return services.$q.reject(error);
         }
       }
@@ -377,7 +368,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));
@@ -418,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,
     );
@@ -426,7 +417,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
@@ -473,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,
       ),
@@ -482,7 +477,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
@@ -509,18 +508,18 @@ 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,
     );
     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;
     }
-    return this.router.urlRouter.href(nav.url, params, {
+    return this.urlRouter.href(nav.url, params, {
       absolute: options.absolute,
     });
   }
@@ -552,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);
   }
@@ -573,12 +572,9 @@ 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.router.transitionService.create(currentPath, target);
+      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/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('../globals').UIRouterGlobals} globals
    */
-  constructor(_router) {
+  constructor(globals, viewService) {
     this._transitionCount = 0;
     /** The transition hook types, such as `onEnter`, `onStart`, etc */
     this._eventTypes = [];
@@ -71,8 +67,8 @@ export class TransitionService {
     this._registeredHooks = {};
     /** The  paths on a criteria object */
     this._criteriaPaths = {};
-    this._router = _router;
-    this.$view = _router.viewService;
+    this.globals = globals;
+    this.$view = viewService;
     this._deregisterHookFns = {};
     this._pluginapi = createProxyFunctions(val(this), {}, val(this), [
       "_definePathType",
@@ -84,7 +80,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 +118,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 +238,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 +249,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;
-
-    // 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.urlService.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.$locationProvider.hashPrefix(newprefix);
-    /**
-     * Gets the host, e.g., `localhost`
-     *
-     * @return {string} the protocol
-     */
-    this.host = () => this.router.urlService.$location.host();
-    /**
-     * Returns true when running in pushstate mode
-     *
-     * @return {boolean} true when running in html5 mode (pushstate mode).
-     */
-    this.html5Mode = () => this.router.urlService.html5Mode();
-    /**
-     * Gets the port, e.g., `80`
-     *
-     * @return {number} the port number
-     */
-    this.port = () => this.router.urlService.$location.port();
-    /**
-     * Gets the protocol, e.g., `http`
-     *
-     * @return {string} the protocol
-     */
-    this.protocol = () => this.router.urlService.$location.protocol();
   }
   /**
    * Defines whether URL matching should be case sensitive (the default behavior), or not.