refactor(TransitionHooks): Use TransitionService for built-in hooks, not Transition instance hooks

Author: christopherthielen

src/hooks/onEnterExitRetain.ts

@@ -0,0 +1,10 @@
+/** @module state */ /** for typedoc */
+import {TransitionStateHookFn} from "../transition/interface";
+import {UIRInjector} from "../common/interface";
+import {State} from "../state/stateObject";
+import {Transition} from "../transition/transition";
+
+export function makeEnterExitRetainHook(hookName: string): TransitionStateHookFn {
+    return (transition: Transition, injector: UIRInjector, state: State) =>
+        state[hookName](transition, injector, state);
+}

src/hooks/redirectTo.ts

@@ -0,0 +1,14 @@
+/** @module state */ /** for typedoc */
+import {noop} from "../common/common";
+import {Transition} from "../transition/transition";
+import {State} from "../state/stateObject";
+import {ResolveContext} from "../resolve/resolveContext";
+
+/** A function which resolves all EAGER Resolvables in the To Path */
+export const $eagerResolvePath = (trans: Transition) =>
+    new ResolveContext(trans.treeChanges().to).resolvePath("EAGER", trans).then(noop);
+
+/** A function which resolves all LAZY Resolvables for the state (and all ancestors) in the To Path */
+export const $lazyResolveState = (trans: Transition, injector, state: State) =>
+    new ResolveContext(trans.treeChanges().to).subContext(state).resolvePath("LAZY", trans).then(noop);
+

src/hooks/resolve.ts

@@ -0,0 +1,76 @@
+/** @module state */ /** for typedoc */
+import {Transition} from "../transition/transition";
+import {Rejection, RejectType} from "../transition/rejectFactory";
+
+import {StateDeclaration} from "../state/interface";
+import {StateService} from "../state/stateService";
+import {TargetState} from "../state/targetState";
+import {UrlRouter} from "../url/urlRouter";
+import {services} from "../common/coreservices";
+import {Globals} from "../globals";
+import {ViewService} from "../view/view";
+import {TransitionService} from "../transition/transitionService";
+
+/**
+ * Adds the built-in UI-Router hooks to a [[Transition]]
+ *
+ * * Takes a blank transition object and adds all the hooks necessary for it to behave like a state transition.
+ *
+ * * Runs the transition, returning a chained promise which:
+ *   * transforms the resolved Transition.promise to the final destination state.
+ *   * manages the rejected Transition.promise, checking for Dynamic or Redirected transitions
+ *
+ * * Registers a handler to update global $state data such as "active transitions" and "current state/params"
+ *
+ * * Registers view hooks, which maintain the list of active view configs and sync with/update the ui-views
+ *
+ * * Registers onEnter/onRetain/onExit hooks which delegate to the state's hooks of the same name, at the appropriate time
+ *
+ * * Registers eager and lazy resolve hooks
+ */
+export class TransitionManager {
+  private $q;
+  private getRedirectedMgr: (redirect: Transition) => TransitionManager;
+
+  constructor(
+      private transition: Transition,
+      private $transitions: TransitionService,
+      private $urlRouter: UrlRouter,
+      $view: ViewService,
+      private $state: StateService,
+      private globals: Globals
+  ) {
+    this.$q = services.$q;
+    this.getRedirectedMgr = (redirect: Transition) =>
+        new TransitionManager(redirect, $transitions, $urlRouter, $view, $state, globals);
+  }
+
+  runTransition(): Promise<any> {
+    this.globals.transitionHistory.enqueue(this.transition);
+    return this.transition.run()
+        .then((trans: Transition) => trans.to()) // resolve to the final state (TODO: good? bad?)
+        .catch(error => this.transRejected(error)); // if rejected, handle dynamic and redirect
+  }
+
+  transRejected(error): (StateDeclaration|Promise<any>) {
+    // Handle redirect and abort
+    if (error instanceof Rejection) {
+      if (error.type === RejectType.IGNORED) {
+        this.$urlRouter.update();
+        return this.$state.current;
+      }
+
+      if (error.type === RejectType.SUPERSEDED && error.redirected && error.detail instanceof TargetState) {
+        return this.getRedirectedMgr(this.transition.redirect(error.detail)).runTransition();
+      }
+
+      if (error.type === RejectType.ABORTED) {
+        this.$urlRouter.update();
+      }
+    }
+
+    this.$transitions.defaultErrorHandler()(error);
+
+    return this.$q.reject(error);
+  }
+}

src/hooks/transitionManager.ts

@@ -0,0 +1,19 @@
+import {UrlRouter} from "../url/urlRouter";
+import {StateService} from "../state/stateService";
+import {Transition} from "../transition/transition";
+import {UIRInjector} from "../common/interface";
+import {UiRouter} from "../router";
+
+export function updateUrl(transition: Transition, injector: UIRInjector) {
+  let options = transition.options();
+  var router: UiRouter = injector.get(UiRouter);
+  let $state: StateService = router.stateService;
+  let $urlRouter: UrlRouter = router.urlRouter;
+
+  if (options.location && $state.$current.navigable) {
+    var urlOptions = {replace: options.location === 'replace'};
+    $urlRouter.push($state.$current.navigable.url, $state.params, urlOptions);
+  }
+
+  $urlRouter.update(true);
+}

src/hooks/url.ts

@@ -0,0 +1,30 @@
+/** @module state */ /** for typedoc */
+import {noop} from "../common/common";
+import {services} from "../common/coreservices";
+import {Transition} from "../transition/transition";
+import {ViewService} from "../view/view";
+import {ViewConfig} from "../view/interface";
+import {TransitionService} from "../transition/transitionService";
+import {UIRInjector} from "../common/interface";
+import {UiRouter} from "../router";
+
+
+/** Allows the views to do async work [.load()] before the transition continues */
+export function loadEnteringViews(transition) {
+  let enteringViews = transition.views("entering");
+  if (!enteringViews.length) return;
+  return services.$q.all(enteringViews.map(view => view.load())).then(noop);
+}
+
+export function activateViews(transition: Transition, injector: UIRInjector) {
+  let enteringViews = transition.views("entering");
+  let exitingViews = transition.views("exiting");
+  if (!enteringViews.length && !exitingViews.length) return;
+
+  let $view: ViewService = injector.get(UiRouter).viewService;
+
+  exitingViews.forEach((vc: ViewConfig) => $view.deactivateViewConfig(vc));
+  enteringViews.forEach((vc: ViewConfig) => $view.activateViewConfig(vc));
+
+  $view.sync();
+}

src/hooks/views.ts

@@ -6,6 +6,7 @@ import IInjectorService = angular.auto.IInjectorService;
 import {services} from "../../common/coreservices";
 import {getLocals} from "../services";
 import {ResolveContext} from "../../resolve/resolveContext";
+import {extend} from "../../common/common";
 
 /**
  * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
@@ -17,9 +18,9 @@ import {ResolveContext} from "../../resolve/resolveContext";
 export const getStateHookBuilder = (hookName) =>
 function stateHookBuilder(state: State, parentFn): TransitionStateHookFn {
   let hook = state[hookName];
-  function decoratedNg1Hook(trans: Transition, inj: IInjectorService): HookResult {
+  function decoratedNg1Hook(trans: Transition, inj: IInjectorService, state): HookResult {
     let resolveContext = new ResolveContext(trans.treeChanges().to);
-    return services.$injector.invoke(hook, this, getLocals(resolveContext));
+    return services.$injector.invoke(hook, this, extend({ $state$: state }, getLocals(resolveContext)));
   }
 
   return hook ? decoratedNg1Hook : undefined;

src/ng1/statebuilders/onEnterExitRetain.ts

@@ -21,7 +21,7 @@ import {UiRouterGlobals, Globals} from "./globals";
 export class UiRouter {
   viewService = new ViewService();
 
-  transitionService: TransitionService = new TransitionService(this.viewService);
+  transitionService: TransitionService = new TransitionService(this);
 
   globals: UiRouterGlobals = new Globals(this.transitionService);