@angular-wave/angular.ts 0.0.15 → 0.0.17

package/src/router/router.js

@@ -1,76 +1,176 @@
-import {
-  $uiRouterProvider,
-  getProviderFor,
-  getStateProvider,
-  router,
-  runBlock,
-  watchDigests,
-} from "./adapter/services";
-import { TemplateFactory } from "./adapter/templateFactory";
-import { trace } from "./core/common/trace";
-import { $ViewScrollProvider } from "./adapter/viewScroll";
-import { $IsStateFilter, $IncludedByStateFilter } from "./adapter/stateFilters";
-import {
-  uiSrefActiveDirective,
-  uiStateDirective,
-  uiSrefDirective,
-} from "./adapter/directives/stateDirectives";
-import { uiView, $ViewDirectiveFill } from "./adapter/directives/viewDirective";
+import { UrlMatcherFactory } from "./url/urlMatcherFactory";
+import { UrlRouter } from "./url/urlRouter";
+import { TransitionService } from "./transition/transitionService";
+import { ViewService } from "./view/view";
+import { StateRegistry } from "./state/stateRegistry";
+import { StateService } from "./state/stateService";
+import { UIRouterGlobals } from "./globals";
+import { removeFrom } from "../shared/common";
+import { isFunction } from "../shared/utils";
+import { UrlService } from "./url/urlService";
+import { trace } from "./common/trace";
 
-export function initRouter() {
-  window.angular.module("ui.router.angular1", []);
-  const mod_init = window.angular.module("ui.router.init", ["ng"]);
-  const mod_util = window.angular.module("ui.router.util", ["ui.router.init"]);
-  const mod_state = window.angular.module("ui.router.state", [
-    "ui.router.util",
-    "ui.router.angular1",
-  ]);
+/**
+ * Router id tracker
+ * @type {number}
+ */
+let routerId = 0;
 
-  const mod_main = window.angular.module("ui.router", [
-    "ui.router.init",
-    "ui.router.state",
-    "ui.router.angular1",
-  ]);
+/**
+ * An instance of UI-Router.
+ * @class
+ *
+ * This object contains references to service APIs which define your application's routing behavior.
+ */
+export class UIRouter {
+  /**
+   * Creates a new `UIRouter` object
+   *
+   * @param {import('./locationServices').Ng1LocationServices} locationService
+   */
+  constructor(locationService) {
+    /**
+     * @type {import('./locationServices').Ng1LocationServices}
+     */
+    this.locationService = locationService;
+    /**  @type {number} */ this.$id = routerId++;
+    /**  @type {boolean} */ this._disposed = false;
+    this._disposables = [];
+    /** Enable/disable tracing to the javascript console */
+    this.trace = trace;
+    /** Provides services related to ui-view synchronization */
+    this.viewService = new ViewService(this);
+    /** @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);
+    /**
+     * Deprecated for public use. Use [[urlService]] instead.
+     * @deprecated Use [[urlService]] instead
+     */
+    this.urlMatcherFactory = new UrlMatcherFactory(this);
+    /**
+     * 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);
+    /** Provides a registry for states, and related registration services */
+    this.stateRegistry = new StateRegistry(this);
+    /** Provides services related to states */
+    this.stateService = new StateService(this);
+    /** @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);
+  }
 
-  mod_init.provider("$uiRouter", $uiRouterProvider);
-  mod_util.provider("$urlService", getProviderFor("urlService"));
-  mod_util.provider("$urlMatcherFactory", [
-    "$uiRouterProvider",
-    function RouterProvide() {
-      return router.urlMatcherFactory;
-    },
-  ]);
-  mod_util.provider("$templateFactory", function () {
-    return new TemplateFactory();
-  });
-  mod_state
-    .provider("$stateRegistry", getProviderFor("stateRegistry"))
-    .provider("$uiRouterGlobals", getProviderFor("globals"))
-    .provider("$transitions", getProviderFor("transitionService"))
-    .provider("$state", ["$uiRouterProvider", getStateProvider])
-    .provider("$uiViewScroll", $ViewScrollProvider)
-    .factory("$stateParams", [
-      "$uiRouter",
-      function StateParamse($uiRouter) {
-        return $uiRouter.globals.params;
-      },
-    ])
-    .filter("isState", $IsStateFilter)
-    .filter("includedByState", $IncludedByStateFilter)
-    .directive("uiSref", uiSrefDirective)
-    .directive("uiSrefActive", uiSrefActiveDirective)
-    .directive("uiSrefActiveEq", uiSrefActiveDirective)
-    .directive("uiState", uiStateDirective)
-    .directive("uiView", uiView)
-    .directive("uiView", $ViewDirectiveFill);
-  mod_main.factory("$view", function View() {
-    return router.viewService;
-  });
-  mod_main.service("$trace", function Trace() {
-    return trace;
-  });
-  mod_main.run(watchDigests);
-  mod_util.run(["$urlMatcherFactory", function MatcherFac() {}]);
-  mod_state.run(["$state", function State() {}]);
-  mod_init.run(runBlock);
+  /**
+   * 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) {}
+    });
+  }
+
+  /**
+   * Adds a plugin to UI-Router
+   *
+   * This method adds a UI-Router Plugin.
+   * A plugin can enhance or change UI-Router behavior using any public API.
+   *
+   * #### Example:
+   * ```js
+   * import { MyCoolPlugin } from "ui-router-cool-plugin";
+   *
+   * var plugin = router.addPlugin(MyCoolPlugin);
+   * ```
+   *
+   * ### Plugin authoring
+   *
+   * A plugin is simply a class (or constructor function) which accepts a [[UIRouter]] instance and (optionally) an options object.
+   *
+   * The plugin can implement its functionality using any of the public APIs of [[UIRouter]].
+   * For example, it may configure router options or add a Transition Hook.
+   *
+   * The plugin can then be published as a separate module.
+   *
+   * #### Example:
+   * ```js
+   * export class MyAuthPlugin implements UIRouterPlugin {
+   *   constructor(router: UIRouter, options: any) {
+   *     this.name = "MyAuthPlugin";
+   *     let $transitions = router.transitionService;
+   *     let $state = router.stateService;
+   *
+   *     let authCriteria = {
+   *       to: (state) => state.data && state.data.requiresAuth
+   *     };
+   *
+   *     function authHook(transition: Transition) {
+   *       let authService = transition.injector().get('AuthService');
+   *       if (!authService.isAuthenticated()) {
+   *         return $state.target('login');
+   *       }
+   *     }
+   *
+   *     $transitions.onStart(authCriteria, authHook);
+   *   }
+   * }
+   * ```
+   *
+   * @param plugin one of:
+   *        - a plugin class which implements [[UIRouterPlugin]]
+   *        - a constructor function for a [[UIRouterPlugin]] which accepts a [[UIRouter]] instance
+   *        - a factory function which accepts a [[UIRouter]] instance and returns a [[UIRouterPlugin]] instance
+   * @param options options to pass to the plugin class/factory
+   * @returns the registered plugin instance
+   */
+  plugin(plugin, options = {}) {
+    const pluginInstance = new plugin(this, options);
+    if (!pluginInstance.name)
+      throw new Error(
+        "Required property `name` missing on plugin: " + pluginInstance,
+      );
+    this._disposables.push(pluginInstance);
+    return (this._plugins[pluginInstance.name] = pluginInstance);
+  }
+  getPlugin(pluginName) {
+    return pluginName
+      ? this._plugins[pluginName]
+      : Object.values(this._plugins);
+  }
 }

package/src/router/{adapter/services.js → services.js}

@@ -8,26 +8,24 @@
  *
  * @preferred @publicapi @module ng1
  */
-import { services } from "../core/common/coreservices";
-import { applyPairs, unnestR } from "../core/common/common";
-import { isString } from "../../core/utils";
-import { trace } from "../core/common/trace";
-import { UIRouter } from "../core/router";
-import {
-  ng1ViewsBuilder,
-  getNg1ViewConfigFactory,
-} from "./statebuilders/views";
+import { services } from "./common/coreservices";
+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 { StateProvider } from "./stateProvider";
-import { getStateHookBuilder } from "./statebuilders/onEnterExitRetain";
 import { Ng1LocationServices } from "./locationServices";
+import { ResolveContext } from "./resolve/resolveContext";
 
 export let router = null;
-$uiRouterProvider.$inject = ["$locationProvider"];
+$routerProvider.$inject = ["$locationProvider"];
 /** This angular 1 provider instantiates a Router and exposes its services via the angular injector */
-export function $uiRouterProvider($locationProvider) {
-  // Create a new instance of the Router when the $uiRouterProvider is initialized
-  router = this.router = new UIRouter();
+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.stateProvider = new StateProvider(
     router.stateRegistry,
     router.stateService,
@@ -43,47 +41,42 @@ export function $uiRouterProvider($locationProvider) {
   );
   // Disable decoding of params by UrlMatcherFactory because $location already handles this
   router.urlService.config._decodeParams = false;
-  const ng1LocationService =
-    (router.locationService =
-    router.locationConfig =
-      new Ng1LocationServices($locationProvider));
+
   Ng1LocationServices.monkeyPatchPathParameterType(router);
-  // backwards compat: also expose router instance as $uiRouterProvider.router
+  // 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) {
     ng1LocationService._runtimeServices($rootScope, $location, $browser);
-    delete router["router"];
-    delete router["$get"];
     return router;
   }
   return router;
 }
 export const getProviderFor = (serviceName) => [
-  "$uiRouterProvider",
+  "$routerProvider",
   function UrlServiceProvider($urp) {
     const service = $urp.router[serviceName];
     service["$get"] = () => service;
     return service;
   },
 ];
-// This effectively calls $get() on `$uiRouterProvider` to trigger init (when ng enters runtime)
-runBlock.$inject = ["$injector", "$q", "$uiRouter"];
-export function runBlock($injector, $q, $uiRouter) {
+// This effectively calls $get() on `$routerProvider` to trigger init (when ng enters runtime)
+runBlock.$inject = ["$injector", "$q", "$router"];
+export function runBlock($injector, $q, $router) {
   services.$injector = $injector;
   services.$q = $q;
   // https://github.com/angular-ui/ui-router/issues/3678
   if (!Object.prototype.hasOwnProperty.call($injector, "strictDi")) {
     try {
-      $injector.invoke(function (checkStrictDi) {});
+      $injector.invoke(() => {});
     } catch (error) {
       $injector.strictDi = !!/strict mode/.exec(error && error.toString());
     }
   }
   // The $injector is now available.
   // Find any resolvables that had dependency annotation deferred
-  $uiRouter.stateRegistry
+  $router.stateRegistry
     .get()
     .map((x) => x.$$state().resolvables)
     .reduce(unnestR, [])
@@ -95,6 +88,8 @@ export function runBlock($injector, $q, $uiRouter) {
           $injector.strictDi,
         )),
     );
+  // TODO: Is this the best place for this?
+  $router.urlService.listen();
 }
 
 // $state service and $stateProvider
@@ -125,3 +120,28 @@ export const getLocals = (ctx) => {
   });
   return tuples.reduce(applyPairs, {});
 };
+
+/**
+ * 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
+ */
+const getStateHookBuilder = (hookName) =>
+  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 services.$injector.invoke(hook, this, locals);
+    }
+    return hook ? decoratedNg1Hook : undefined;
+  };

package/src/router/{core/state → state}/stateBuilder.js

@@ -3,14 +3,13 @@ import {
   identity,
   inherit,
   mapObj,
-  noop,
   omit,
   tail,
   copy,
-} from "../common/common";
-import { isArray, isDefined, isFunction, isString } from "../common/predicates";
-import { stringify } from "../common/strings";
-import { is, pattern, pipe, prop, val } from "../common/hof";
+} from "../../shared/common";
+import { isDefined, isFunction, isString } from "../../shared/utils";
+import { stringify } from "../../shared/strings";
+import { is, pattern, pipe, prop, val } from "../../shared/hof";
 import { Resolvable } from "../resolve/resolvable";
 import { services } from "../common/coreservices";
 const parseUrl = (url) => {
@@ -85,7 +84,11 @@ const getParamsBuilder = (paramFactory) =>
       .reduce(applyPairs, {});
   };
 function pathBuilder(state) {
-  return state.parent ? state.parent.path.concat(state) : /*root*/ [state];
+  if (state.parent && !state.abstract) {
+    return state.parent.path.concat(state);
+  } else {
+    return [state];
+  }
 }
 function includesBuilder(state) {
   const includes = state.parent ? Object.assign({}, state.parent.includes) : {};
@@ -167,7 +170,7 @@ export function resolvablesBuilder(state) {
     !!(
       obj &&
       obj.val &&
-      (isString(obj.val) || isArray(obj.val) || isFunction(obj.val))
+      (isString(obj.val) || Array.isArray(obj.val) || isFunction(obj.val))
     );
   /** extracts the token from a Provider or provide literal */
   const getToken = (p) => p.provide || p.token;
@@ -204,7 +207,7 @@ export function resolvablesBuilder(state) {
   // prettier-ignore
   const tuple2Resolvable = pattern([
         [pipe(prop('val'), isString), (tuple) => new Resolvable(tuple.token, identity, [tuple.val], tuple.policy)],
-        [pipe(prop('val'), isArray), (tuple) => new Resolvable(tuple.token, tail(tuple.val), tuple.val.slice(0, -1), tuple.policy)],
+        [pipe(prop('val'), Array.isArray), (tuple) => new Resolvable(tuple.token, tail(tuple.val), tuple.val.slice(0, -1), tuple.policy)],
         [pipe(prop('val'), isFunction), (tuple) => new Resolvable(tuple.token, tuple.val, annotate(tuple.val), tuple.policy)],
     ]);
   // prettier-ignore
@@ -218,7 +221,7 @@ export function resolvablesBuilder(state) {
   // If resolveBlock is already an array, use it as-is.
   // Otherwise, assume it's an object and convert to an Array of tuples
   const decl = state.resolve;
-  const items = isArray(decl)
+  const items = Array.isArray(decl)
     ? decl
     : objects2Tuples(decl, state.resolvePolicy || {});
   return items.map(item2Resolvable);
@@ -293,12 +296,13 @@ export class StateBuilder {
       if (!Object.prototype.hasOwnProperty.call(builders, key)) continue;
       const chain = builders[key].reduce(
         (parentFn, step) => (_state) => step(_state, parentFn),
-        noop,
+        () => {},
       );
       state[key] = chain(state);
     }
     return state;
   }
+
   parentName(state) {
     // name = 'foo.bar.baz.**'
     const name = state.name || "";

package/src/router/{core/state → state}/stateMatcher.js

@@ -1,5 +1,4 @@
-import { isString } from "../common/predicates";
-import { safeConsole } from "../common/safeConsole";
+import { isString } from "../../shared/utils";
 export class StateMatcher {
   constructor(_states) {
     this._states = _states;
@@ -28,7 +27,7 @@ export class StateMatcher {
           _state.__stateObjectCache.nameGlob.matches(name),
       );
       if (matches.length > 1) {
-        safeConsole.error(
+        console.error(
           `stateMatcher.find: Found multiple matches for ${name} using glob: `,
           matches.map((match) => match.name),
         );

package/src/router/{core/state → state}/stateObject.js

@@ -1,7 +1,7 @@
-import { defaults, find } from "../common/common";
-import { propEq } from "../common/hof";
+import { defaults, find } from "../../shared/common";
+import { propEq } from "../../shared/hof";
 import { Glob } from "../common/glob";
-import { isObject, isFunction } from "../common/predicates";
+import { isFunction, isObject } from "../../shared/utils";
 /**
  * Internal representation of a UI-Router state.
  *
@@ -22,10 +22,12 @@ export class StateObject {
    * @returns {StateObject} an internal State object
    */
   static create(stateDecl) {
-    stateDecl = StateObject.isStateClass(stateDecl)
+    const state = StateObject.isStateClass(stateDecl)
       ? new stateDecl()
-      : stateDecl;
-    const state = Object.setPrototypeOf(stateDecl, StateObject.prototype);
+      : Object.setPrototypeOf(
+          Object.assign({}, stateDecl),
+          StateObject.prototype,
+        );
     stateDecl.$$state = () => state;
     state.self = stateDecl;
     state.__stateObjectCache = {

package/src/router/{core/state → state}/stateQueueManager.js

@@ -1,6 +1,6 @@
-import { inArray } from "../common/common";
-import { prop } from "../common/hof";
-import { isString } from "../common/predicates";
+import { inArray } from "../../shared/common";
+import { prop } from "../../shared/hof";
+import { isString } from "../../shared/utils";
 import { StateObject } from "./stateObject";
 export class StateQueueManager {
   constructor(router, states, builder, listeners) {

package/src/router/{core/state → state}/stateRegistry.js

@@ -1,19 +1,18 @@
 import { StateMatcher } from "./stateMatcher";
 import { StateBuilder } from "./stateBuilder";
 import { StateQueueManager } from "./stateQueueManager";
-import { removeFrom } from "../common/common";
-import { propEq } from "../common/hof";
+import { removeFrom } from "../../shared/common";
+import { propEq } from "../../shared/hof";
 /**
  * A registry for all of the application's [[StateDeclaration]]s
  *
  * This API is found at `router.stateRegistry` ([[UIRouter.stateRegistry]])
  */
 export class StateRegistry {
-  /** @internal */
   constructor(router) {
     this.router = router;
     this.states = {};
-    /** @internal */
+
     this.listeners = [];
     this.matcher = new StateMatcher(this.states);
     this.builder = new StateBuilder(this.matcher, router.urlMatcherFactory);
@@ -25,7 +24,7 @@ export class StateRegistry {
     );
     this._registerRoot();
   }
-  /** @internal */
+
   _registerRoot() {
     const rootStateDef = {
       name: "",
@@ -39,7 +38,7 @@ export class StateRegistry {
     const _root = (this._root = this.stateQueue.register(rootStateDef));
     _root.navigable = null;
   }
-  /** @internal */
+
   dispose() {
     this.stateQueue.dispose();
     this.listeners = [];
@@ -108,7 +107,7 @@ export class StateRegistry {
   register(stateDefinition) {
     return this.stateQueue.register(stateDefinition);
   }
-  /** @internal */
+
   _deregisterTree(state) {
     const all = this.get().map((s) => s.$$state());
     const getChildren = (states) => {

package/src/router/{core/state → state}/stateService.js

@@ -6,8 +6,8 @@ import {
   removeFrom,
   silenceUncaughtInPromise,
   silentRejection,
-} from "../common/common";
-import { isDefined, isObject, isString } from "../common/predicates";
+} from "../../shared/common";
+import { isDefined, isObject, isString } from "../../shared/utils";
 import { Queue } from "../common/queue";
 import { services } from "../common/coreservices";
 import { PathUtils } from "../path/pathUtils";
@@ -19,7 +19,7 @@ import { Param } from "../params/param";
 import { Glob } from "../common/glob";
 import { ResolveContext } from "../resolve/resolveContext";
 import { lazyLoadState } from "../hooks/lazyLoad";
-import { not, val } from "../common/hof";
+import { not, val } from "../../shared/hof";
 /**
  * Provides services related to ui-router states.
  *
@@ -58,22 +58,19 @@ export class StateService {
   get $current() {
     return this.router.globals.$current;
   }
-  /** @internal */
-  constructor(/** @internal */ router) {
+
+  constructor(router) {
     this.router = router;
-    /** @internal */
+
     this.invalidCallbacks = [];
-    /** @internal */
+
     this._defaultErrorHandler = function $defaultErrorHandler($error$) {
       if ($error$ instanceof Error && $error$.stack) {
-        console.error($error$);
-        console.error($error$.stack);
+        throw $error$;
       } else if ($error$ instanceof Rejection) {
-        console.error($error$.toString());
-        if ($error$.detail && $error$.detail.stack)
-          console.error($error$.detail.stack);
+        throw new Error($error$.toString());
       } else {
-        console.error($error$);
+        throw new Error($error$);
       }
     };
     const getters = ["current", "$current", "params", "transition"];
@@ -87,7 +84,7 @@ export class StateService {
       boundFns,
     );
   }
-  /** @internal */
+
   dispose() {
     this.defaultErrorHandler(noop);
     this.invalidCallbacks = [];
@@ -302,7 +299,7 @@ export class StateService {
       options,
     );
   }
-  /** @internal */
+
   getCurrentPath() {
     const globals = this.router.globals;
     const latestSuccess = globals.successfulTransitions.peekTail();

package/src/router/{core/state → state}/targetState.js

@@ -1,5 +1,5 @@
-import { isObject, isString } from "../common/predicates";
-import { stringify } from "../common/strings";
+import { isObject, isString } from "../../shared/utils";
+import { stringify } from "../../shared/strings";
 /**
  * Encapsulate the target (destination) state/params/options of a [[Transition]].
  *