@angular-wave/angular.ts 0.0.16 → 0.0.17

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

@@ -17,14 +17,14 @@
  * Because of these confusing details, this service is deprecated.
  *
  * ### Instead of using the global `$stateParams` service object,
- * inject [[$uiRouterGlobals]] and use [[UIRouterGlobals.params]]
+ * inject [[$routerGlobals]] and use [[UIRouterGlobals.params]]
  *
  * ```js
- * MyService.$inject = ['$uiRouterGlobals'];
- * function MyService($uiRouterGlobals) {
+ * MyService.$inject = ['$routerGlobals'];
+ * function MyService($routerGlobals) {
  *   return {
  *     paramValues: function () {
- *       return $uiRouterGlobals.params;
+ *       return $routerGlobals.params;
  *     }
  *   }
  * }
@@ -67,7 +67,7 @@ let $stateParams;
  *
  * This object contains globals such as the current state and current parameter values.
  */
-let $uiRouterGlobals;
+let $routerGlobals;
 /**
  * The UI-Router instance
  *
@@ -76,9 +76,9 @@ let $uiRouterGlobals;
  * This object is the UI-Router singleton instance, created by angular dependency injection during application bootstrap.
  * It has references to the other UI-Router services
  *
- * #### Note: This object is also exposed as [[$uiRouterProvider]] for injection during angular config time.
+ * #### Note: This object is also exposed as [[$routerProvider]] for injection during angular config time.
  */
-let $uiRouter;
+let $router;
 /**
  * The UI-Router instance
  *
@@ -87,9 +87,9 @@ let $uiRouter;
  * This object is the UI-Router singleton instance, created by angular dependency injection during application bootstrap.
  * It has references to the other UI-Router services
  *
- * #### Note: This object is also exposed as [[$uiRouter]] for injection during runtime.
+ * #### Note: This object is also exposed as [[$router]] for injection during runtime.
  */
-let $uiRouterProvider;
+let $routerProvider;
 /**
  * Transition debug/tracing
  *

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

@@ -1,12 +1,24 @@
-/** @publicapi @module ng1 */ /** */
-import { isDefined, isObject } from "../../core/utils";
-import { val } from "../core/common/hof";
-import { createProxyFunctions, removeFrom } from "../core/common/common";
+import { isDefined, isObject } from "../shared/utils";
+import { val } from "../shared/hof";
+import { createProxyFunctions, removeFrom } from "../shared/common";
+
 /**
  * Implements UI-Router LocationServices and LocationConfig using Angular 1's $location service
  * @internalapi
  */
 export class Ng1LocationServices {
+  /**
+   *
+   * @param {angular.ILocationProvider} $locationProvider
+   */
+  constructor($locationProvider) {
+    // .onChange() registry
+    this._urlListeners = [];
+    /** @type {angular.ILocationProvider} */ this.$locationProvider =
+      $locationProvider;
+    const _lp = val($locationProvider);
+    createProxyFunctions(_lp, this, _lp, ["hashPrefix"]);
+  }
   /**
    * Applys ng1-specific path parameter encoding
    *
@@ -33,13 +45,7 @@ export class Ng1LocationServices {
         : x;
   }
   dispose() {}
-  constructor($locationProvider) {
-    // .onChange() registry
-    this._urlListeners = [];
-    this.$locationProvider = $locationProvider;
-    const _lp = val($locationProvider);
-    createProxyFunctions(_lp, this, _lp, ["hashPrefix"]);
-  }
+
   onChange(callback) {
     this._urlListeners.push(callback);
     return () => removeFrom(this._urlListeners)(callback);
@@ -62,8 +68,9 @@ export class Ng1LocationServices {
     if (state) this.$location.state(state);
     return this.$location.url();
   }
+
   _runtimeServices($rootScope, $location, $browser) {
-    this.$location = $location;
+    /** @type {angular.ILocationService} */ this.$location = $location;
     this.$browser = $browser;
     this.$window = window;
     // Bind $locationChangeSuccess to the listeners registered in LocationService.onChange

package/src/router/{core/params → params}/param.js

@@ -1,12 +1,7 @@
-import { filter, map, allTrueR, find } from "../common/common";
-import { prop } from "../common/hof";
-import {
-  isInjectable,
-  isDefined,
-  isString,
-  isArray,
-  isUndefined,
-} from "../common/predicates";
+import { filter, map, allTrueR, find } from "../../shared/common";
+import { prop } from "../../shared/hof";
+import { isInjectable } from "../../shared/predicates";
+import { isDefined, isUndefined, isString } from "../../shared/utils";
 import { services } from "../common/coreservices";
 import { ParamType } from "./paramType";
 const hasOwn = Object.prototype.hasOwnProperty;
@@ -79,7 +74,7 @@ function getReplace(config, arrayMode, isOptional, squash) {
     { from: "", to: isOptional || arrayMode ? undefined : "" },
     { from: null, to: isOptional || arrayMode ? undefined : "" },
   ];
-  const replace = isArray(config.replace) ? config.replace : [];
+  const replace = Array.isArray(config.replace) ? config.replace : [];
   if (isString(squash)) replace.push({ from: squash, to: undefined });
   const configuredKeys = map(replace, prop("from"));
   return filter(

package/src/router/{core/params → params}/paramType.js

@@ -1,5 +1,5 @@
-import { filter, map } from "../common/common";
-import { isArray, isDefined } from "../common/predicates";
+import { filter, map } from "../../shared/common";
+import { isDefined } from "../../shared/utils";
 /**
  * An internal class which implements [[ParamTypeDefinition]].
  *
@@ -86,7 +86,7 @@ export class ParamType {
 function ArrayType(type, mode) {
   // Wrap non-array value as array
   function arrayWrap(val) {
-    return isArray(val) ? val : isDefined(val) ? [val] : [];
+    return Array.isArray(val) ? val : isDefined(val) ? [val] : [];
   }
   // Unwrap array value for "auto" mode. Return undefined for empty array.
   function arrayUnwrap(val) {
@@ -102,7 +102,7 @@ function ArrayType(type, mode) {
   // Wraps type (.is/.encode/.decode) functions to operate on each value of an array
   function arrayHandler(callback, allTruthyMode) {
     return function handleArray(val) {
-      if (isArray(val) && val.length === 0) return val;
+      if (Array.isArray(val) && val.length === 0) return val;
       const arr = arrayWrap(val);
       const result = map(arr, callback);
       return allTruthyMode === true

package/src/router/{core/params → params}/paramTypes.js

@@ -6,9 +6,10 @@ import {
   inherit,
   map,
   pick,
-} from "../common/common";
-import { isDefined, isNullOrUndefined } from "../common/predicates";
-import { is } from "../common/hof";
+} from "../../shared/common";
+import { isNullOrUndefined } from "../../shared/predicates";
+import { isDefined } from "../../shared/utils";
+import { is } from "../../shared/hof";
 import { services } from "../common/coreservices";
 import { ParamType } from "./paramType";
 /**

package/src/router/{core/params → params}/stateParams.js

@@ -1,4 +1,4 @@
-import { ancestors } from "../common/common";
+import { ancestors } from "../../shared/common";
 export class StateParams {
   constructor(params = {}) {
     Object.assign(this, params);

package/src/router/{core/path → path}/pathNode.js

@@ -1,5 +1,5 @@
-import { applyPairs, find } from "../common/common";
-import { propEq } from "../common/hof";
+import { applyPairs, find } from "../../shared/common";
+import { propEq } from "../../shared/hof";
 import { Param } from "../params/param";
 /**
  * A node in a [[TreeChanges]] path

package/src/router/{core/path → path}/pathUtils.js

@@ -7,8 +7,8 @@ import {
   unnestR,
   inArray,
   arrayTuples,
-} from "../common/common";
-import { prop, propEq } from "../common/hof";
+} from "../../shared/common";
+import { prop, propEq } from "../../shared/hof";
 import { TargetState } from "../state/targetState";
 import { PathNode } from "./pathNode";
 /**
@@ -190,9 +190,15 @@ export class PathUtils {
     const elementIdx = path.indexOf(node);
     return elementIdx === -1 ? undefined : path.slice(0, elementIdx + 1);
   }
+
+  static nonDynamicParams(node) {
+    return node.state
+      .parameters({ inherit: false })
+      .filter((param) => !param.dynamic);
+  }
+
+  /** Gets the raw parameter values from a path */
+  static paramValues(path) {
+    return path.reduce((acc, node) => Object.assign(acc, node.paramValues), {});
+  }
 }
-PathUtils.nonDynamicParams = (node) =>
-  node.state.parameters({ inherit: false }).filter((param) => !param.dynamic);
-/** Gets the raw parameter values from a path */
-PathUtils.paramValues = (path) =>
-  path.reduce((acc, node) => Object.assign(acc, node.paramValues), {});

package/src/router/{core/resolve → resolve}/resolvable.js

@@ -1,9 +1,8 @@
-import { identity } from "../../../core/utils";
+import { identity, isFunction, isObject } from "../../shared/utils";
 import { services } from "../common/coreservices";
 import { trace } from "../common/trace";
-import { stringify } from "../common/strings";
-import { isFunction, isObject } from "../common/predicates";
-import { isNullOrUndefined } from "../common/predicates";
+import { stringify } from "../../shared/strings";
+import { isNullOrUndefined } from "../../shared/predicates";
 // TODO: explicitly make this user configurable
 export let defaultResolvePolicy = {
   when: "LAZY",
@@ -44,7 +43,8 @@ export class Resolvable {
     } else if (
       isObject(arg1) &&
       arg1.token &&
-      (arg1.hasOwnProperty("resolveFn") || arg1.hasOwnProperty("data"))
+      (Object.prototype.hasOwnProperty.call(arg1, "resolveFn") ||
+        Object.prototype.hasOwnProperty.call(arg1, "data"))
     ) {
       const literal = arg1;
       return new Resolvable(

package/src/router/{core/resolve → resolve}/resolveContext.js

@@ -1,12 +1,22 @@
-import { find, tail, uniqR, unnestR, inArray } from "../common/common";
-import { propEq, not } from "../common/hof";
+import { find, tail, uniqR, unnestR, inArray } from "../../shared/common";
+import { propEq, not } from "../../shared/hof";
 import { trace } from "../common/trace";
 import { services } from "../common/coreservices";
-import { resolvePolicies } from "./interface";
 import { Resolvable } from "./resolvable";
 import { PathUtils } from "../path/pathUtils";
-import { stringify } from "../common/strings";
-import { isUndefined } from "../../../core/utils";
+import { stringify } from "../../shared/strings";
+import { isUndefined } from "../../shared/utils";
+
+export let resolvePolicies = {
+  when: {
+    LAZY: "LAZY",
+    EAGER: "EAGER",
+  },
+  async: {
+    WAIT: "WAIT",
+    NOWAIT: "NOWAIT",
+  },
+};
 
 const whens = resolvePolicies.when;
 const ALL_WHENS = [whens.EAGER, whens.LAZY];
@@ -179,7 +189,7 @@ export class ResolveContext {
     return resolvable.deps.map(getDependency);
   }
 }
-/** @internal */
+
 class UIInjectorImpl {
   constructor(context) {
     this.context = context;

package/src/router/router.js

@@ -1,77 +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 () {
-      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 ($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)
-    .run(["$state", function () {}]);
-  mod_main
-    .factory("$view", function View() {
-      return router.viewService;
-    })
-    .service("$trace", function Trace() {
-      return trace;
+  /**
+   * 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) {}
     });
-  mod_main.run(watchDigests);
-  mod_util.run(["$urlMatcherFactory", function MatcherFac() {}]);
-  mod_init.run(runBlock);
+  }
+
+  /**
+   * 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;
+  };