@coolon/angular-ui-powerups 0.0.97 → 0.0.101

package/esm2015/lib/place/guards/navigation-state.js

@@ -0,0 +1,676 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Dsl, GarbageCollector, lang, Logger } from '@coolon/pectin';
+import { PlaceComponentDeactivationHandler } from './place-component-deactivation-handler';
+/**
+ * @abstract
+ */
+export class NavigationState extends GarbageCollector {
+    /**
+     * @param {?} context
+     */
+    constructor(context) {
+        super();
+        this.context = context;
+        this._visits = new Map();
+    }
+    /**
+     * @return {?}
+     */
+    get idle() {
+        return !this.isTransitional;
+    }
+    /**
+     * @return {?}
+     */
+    get placeRouter() {
+        return this.context.placeRouter;
+    }
+    /**
+     * @return {?}
+     */
+    get interactionService() {
+        return this.context.interactionService;
+    }
+    /**
+     * @return {?}
+     */
+    get interactionContext() {
+        return null;
+    }
+    /**
+     * @param {?} visit
+     * @return {?}
+     */
+    storeVisit(visit) {
+        this._visits.set(visit.placeDefinition, visit);
+    }
+    /**
+     * @param {?} placeDef
+     * @return {?}
+     */
+    getVisitFor(placeDef) {
+        return this._visits.get(placeDef);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onPopState(event) {
+        return this.illegalTransition(event);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onStart(event) {
+        return this.illegalTransition(event);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onCancel(event) {
+        return this.illegalTransition(event);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onError(event) {
+        return this.illegalTransition(event);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onEnd(event) {
+        return this.illegalTransition(event);
+    }
+    /**
+     * @param {?} newUrl
+     * @return {?}
+     */
+    onBackClickedDuringNavigationInteraction(newUrl) {
+        return this.illegalTransition('onBackClickedDuringNavigationInteraction');
+    }
+    /**
+     * @param {?} component
+     * @param {?} nextState
+     * @return {?}
+     */
+    canDeactivatePlace(component, nextState) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return this.illegalTransition('canDeactivatePlace');
+        });
+    }
+    /**
+     * @return {?}
+     */
+    getVisits() {
+        return Array.from(this._visits.values());
+    }
+    /**
+     * @protected
+     * @template R
+     * @param {?} message
+     * @return {?}
+     */
+    illegalTransition(message) {
+        return lang.illegalState(`${message.toString()} not supported by ${this.toString()}`);
+    }
+    /**
+     * @protected
+     * @return {?}
+     */
+    currentRouterUrl() {
+        return this.placeRouter.getCurrentRouterUrl();
+    }
+    /**
+     * @protected
+     * @param {?} event
+     * @return {?}
+     */
+    createTransitionStateFor(event) {
+        // TODO: check if the event is purely for interaction context changes.
+        /** @type {?} */
+        const popstate = event.navigationTrigger === 'popstate';
+        return popstate ?
+            new NavigationState.NavigationBackTransition(this.context, popstate, this.currentRouterUrl()) :
+            new NavigationState.NavigationTransition(this.context, popstate, this.currentRouterUrl());
+    }
+    /**
+     * @param {?} url
+     * @return {?}
+     */
+    resetBrowserLocation(url) {
+        // TODO: Should this be a navigate operation to avoid confusing the router...??
+        setTimeout((/**
+         * @return {?}
+         */
+        () => this.placeRouter.resetBrowserLocation(url)));
+    }
+    /**
+     * @return {?}
+     */
+    toString() {
+        return this.constructor.name;
+    }
+}
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    NavigationState.prototype._visits;
+    /** @type {?} */
+    NavigationState.prototype.isTransitional;
+    /** @type {?} */
+    NavigationState.prototype.startingUrl;
+    /** @type {?} */
+    NavigationState.prototype.isPopState;
+    /**
+     * @type {?}
+     * @protected
+     */
+    NavigationState.prototype.context;
+}
+(function (NavigationState) {
+    class Context {
+        /**
+         * @param {?} placeRouter
+         * @param {?} interactionService
+         * @param {?} notifySuccess
+         */
+        constructor(placeRouter, interactionService, notifySuccess) {
+            this.placeRouter = placeRouter;
+            this.interactionService = interactionService;
+            this.notifySuccess = notifySuccess;
+        }
+    }
+    NavigationState.Context = Context;
+    if (false) {
+        /** @type {?} */
+        Context.prototype.placeRouter;
+        /** @type {?} */
+        Context.prototype.interactionService;
+        /** @type {?} */
+        Context.prototype.notifySuccess;
+    }
+    class Idle extends NavigationState {
+        /**
+         * @param {?} context
+         */
+        constructor(context) {
+            super(context);
+            this.isTransitional = false;
+            this.startingUrl = null;
+            this.isPopState = false;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onStart(event) {
+            // calling angularLocation.go() to clear back state can trigger router cycles to the current url if we don't ignore them
+            if (event.url === this.currentRouterUrl()) {
+                Logger.get(this).info(`navigation started to same url -> ${event.url}`);
+                return this;
+            }
+            if (this.placeRouter.hasActiveInteractionIds(event.url)) {
+                Logger.get(this).info(`navigation started with interaction outlet -> ${event.url}`);
+                return new InteractionTransition(this.context, event.url);
+            }
+            else {
+                return this.createTransitionStateFor(event);
+            }
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onPopState(event) {
+            return this.createTransitionStateFor(event);
+        }
+    }
+    NavigationState.Idle = Idle;
+    if (false) {
+        /** @type {?} */
+        Idle.prototype.isTransitional;
+        /** @type {?} */
+        Idle.prototype.startingUrl;
+        /** @type {?} */
+        Idle.prototype.isPopState;
+    }
+    /**
+     * @abstract
+     */
+    class AbstractNavigationTransition extends NavigationState {
+        /**
+         * @param {?} context
+         * @param {?} isPopState
+         * @param {?} startingUrl
+         */
+        constructor(context, isPopState, startingUrl) {
+            super(context);
+            this.isPopState = isPopState;
+            this.startingUrl = startingUrl;
+            this.isTransitional = true;
+            this.componentDeactivationHandlers = new Map();
+            this._interactionContext = this.interactionService._createExclusiveModalInteractionContext();
+            this.onDispose((/**
+             * @return {?}
+             */
+            () => {
+                // the interaction context can be detached during the back button cancellation state transition
+                // as the transition is synchronous and activityCancellation isn't.  Otherwise dispose will be
+                // called before the context has been cancelled.  It might be work having the interaction context
+                // automatically cancel if the context is disposed so we don't have worry about detaching etc.
+                if (this._interactionContext) {
+                    this._interactionContext.dispose(); // or do something like cancelAndDispose?
+                }
+            }));
+        }
+        /**
+         * @return {?}
+         */
+        get interactionContext() {
+            return this._interactionContext;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onStart(event) {
+            // active sessions can have many cancel start cycles due
+            // to place guard redirects
+            return this;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onEnd(event) {
+            // navigation succeeded
+            this.context.notifySuccess(this);
+            return new Idle(this.context);
+        }
+        /**
+         * @param {?} locationTriggerUrl
+         * @return {?}
+         */
+        onBackClickedDuringNavigationInteraction(locationTriggerUrl) {
+            // detach the interactoin from the session so it doesn't get disposed until the activity
+            // has completed.
+            /** @type {?} */
+            const context = this.detachInteractionContext();
+            const { when } = Dsl.disposeWith(context);
+            // TODO: I need to make the exclusive interaction context disallow nested activities or
+            //       that would mess things up entirely.
+            context.getCurrentActivity().then((/**
+             * @param {?} activity
+             * @return {?}
+             */
+            activity => {
+                when.valueOf(context.active).becomesFalsey((/**
+                 * @return {?}
+                 */
+                () => context.dispose()), { once: true });
+                activity.cancel(null);
+            }));
+            return new CancelledDuringNavigationInteraction(this.context, this.startingUrl, locationTriggerUrl);
+        }
+        /**
+         * @param {?} component
+         * @param {?} nextState
+         * @return {?}
+         */
+        canDeactivatePlace(component, nextState) {
+            return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                // lookup the handler and create it if we've not seen it yet
+                /** @type {?} */
+                let handler = this.componentDeactivationHandlers.get(component);
+                if (!handler) {
+                    /** @type {?} */
+                    const isPrimaryHandler = this.componentDeactivationHandlers.size === 0;
+                    handler = new PlaceComponentDeactivationHandler(component, this);
+                    this.componentDeactivationHandlers.set(component, handler);
+                }
+                return handler.canDeactivate(nextState);
+            });
+        }
+        /**
+         * @private
+         * @return {?}
+         */
+        detachInteractionContext() {
+            /** @type {?} */
+            const context = this._interactionContext;
+            this._interactionContext = null;
+            return context;
+        }
+    }
+    NavigationState.AbstractNavigationTransition = AbstractNavigationTransition;
+    if (false) {
+        /** @type {?} */
+        AbstractNavigationTransition.prototype.isTransitional;
+        /**
+         * @type {?}
+         * @private
+         */
+        AbstractNavigationTransition.prototype.componentDeactivationHandlers;
+        /**
+         * @type {?}
+         * @private
+         */
+        AbstractNavigationTransition.prototype._interactionContext;
+        /** @type {?} */
+        AbstractNavigationTransition.prototype.isPopState;
+        /** @type {?} */
+        AbstractNavigationTransition.prototype.startingUrl;
+    }
+    class NavigationTransition extends AbstractNavigationTransition {
+        constructor() {
+            super(...arguments);
+            this.isPopState = false;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onStart(event) {
+            // active sessions can have many cancel start cycles due
+            // to place guard redirects
+            return this;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onEnd(event) {
+            // navigation succeeded
+            this.context.notifySuccess(this);
+            return new Idle(this.context);
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onCancel(event) {
+            return new Idle(this.context);
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onError(event) {
+            // navigation was aborted.
+            return new Idle(this.context);
+        }
+        /**
+         * @return {?}
+         */
+        toString() {
+            return `${this.constructor.name}(startingUrl: ${this.startingUrl})`;
+        }
+    }
+    NavigationState.NavigationTransition = NavigationTransition;
+    if (false) {
+        /** @type {?} */
+        NavigationTransition.prototype.isPopState;
+    }
+    class NavigationBackTransition extends AbstractNavigationTransition {
+        constructor() {
+            super(...arguments);
+            this.isPopState = true;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onCancel(event) {
+            // Angular doesn't preserve the url when a guard cancels the back button.
+            // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
+            Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
+            this.resetBrowserLocation(this.startingUrl);
+            return new Idle(this.context);
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onError(event) {
+            // navigation was aborted.
+            if (this.currentRouterUrl() !== this.startingUrl) {
+                // Angular doesn't preserve the url when a guard cancels the back button.
+                // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
+                Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
+                this.resetBrowserLocation(this.startingUrl);
+            }
+            return new Idle(this.context);
+        }
+    }
+    NavigationState.NavigationBackTransition = NavigationBackTransition;
+    if (false) {
+        /** @type {?} */
+        NavigationBackTransition.prototype.isPopState;
+    }
+    /**
+     * @abstract
+     */
+    class AbstractInteractionTransition extends NavigationState {
+        /**
+         * @param {?} context
+         * @param {?} startingUrl
+         */
+        constructor(context, startingUrl) {
+            super(context);
+            this.startingUrl = startingUrl;
+            this.isTransitional = true;
+        }
+        /**
+         * @protected
+         * @return {?}
+         */
+        reinstateInteractionRoute() {
+            console.log(this.startingUrl);
+            setTimeout((/**
+             * @return {?}
+             */
+            () => this.placeRouter.syncInteractionIdsWithRouter()));
+        }
+    }
+    NavigationState.AbstractInteractionTransition = AbstractInteractionTransition;
+    if (false) {
+        /** @type {?} */
+        AbstractInteractionTransition.prototype.isTransitional;
+        /** @type {?} */
+        AbstractInteractionTransition.prototype.startingUrl;
+    }
+    /**
+     * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
+     * happily ignore interaction contexts.
+     */
+    class InteractionTransition extends AbstractInteractionTransition {
+        constructor() {
+            super(...arguments);
+            this.isPopState = false;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onEnd(event) {
+            if (this.context.interactionService.isActive()) {
+                this.reinstateInteractionRoute();
+                return new IdleDuringInteraction(this.context, this.startingUrl);
+            }
+            else {
+                return new Idle(this.context);
+            }
+        }
+    }
+    NavigationState.InteractionTransition = InteractionTransition;
+    if (false) {
+        /** @type {?} */
+        InteractionTransition.prototype.isPopState;
+    }
+    /**
+     * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
+     * happily ignore interaction contexts.
+     */
+    class InteractionBackTransition extends AbstractInteractionTransition {
+        constructor() {
+            super(...arguments);
+            this.isPopState = true;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onEnd(event) {
+            if (this.interactionService.isActive()) {
+                this.reinstateInteractionRoute();
+                return new IdleDuringInteraction(this.context, this.startingUrl);
+            }
+            else {
+                return new Idle(this.context);
+            }
+        }
+    }
+    NavigationState.InteractionBackTransition = InteractionBackTransition;
+    if (false) {
+        /** @type {?} */
+        InteractionBackTransition.prototype.isPopState;
+    }
+    class IdleDuringInteraction extends NavigationState {
+        /**
+         * @param {?} context
+         * @param {?} startingUrl
+         */
+        constructor(context, startingUrl) {
+            super(context);
+            this.startingUrl = startingUrl;
+            this.isTransitional = false;
+            this.isPopState = false;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onStart(event) {
+            return new InteractionTransition(this.context, event.url);
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onPopState(event) {
+            return new InteractionBackTransition(this.context, event.url);
+        }
+    }
+    NavigationState.IdleDuringInteraction = IdleDuringInteraction;
+    if (false) {
+        /** @type {?} */
+        IdleDuringInteraction.prototype.isTransitional;
+        /** @type {?} */
+        IdleDuringInteraction.prototype.isPopState;
+        /** @type {?} */
+        IdleDuringInteraction.prototype.startingUrl;
+    }
+    class CancelledDuringNavigationInteraction extends NavigationState {
+        /**
+         * @param {?} context
+         * @param {?} startingUrl
+         * @param {?} locationChangeTriggerUrl
+         */
+        constructor(context, startingUrl, locationChangeTriggerUrl) {
+            super(context);
+            this.startingUrl = startingUrl;
+            this.locationChangeTriggerUrl = locationChangeTriggerUrl;
+            this.isPopState = false;
+            this.capturedFauxRouterStart = false;
+        }
+        /**
+         * @return {?}
+         */
+        get isTransitional() {
+            return !this.capturedFauxRouterStart;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onStart(event) {
+            if (event.url === this.locationChangeTriggerUrl && !this.capturedFauxRouterStart) {
+                this.capturedFauxRouterStart = true;
+                return this.ignore(event, 'url matched back button location change');
+            }
+            else {
+                return this.createTransitionStateFor(event);
+            }
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onCancel(event) {
+            return this.ignore(event);
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onEnd(event) {
+            return this.ignore(event);
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onError(event) {
+            return this.ignore(event);
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onPopState(event) {
+            return this.createTransitionStateFor(event);
+        }
+        /**
+         * @param {?} event
+         * @param {?=} reason
+         * @return {?}
+         */
+        ignore(event, reason) {
+            reason = reason ? ` (${reason})` : '';
+            Logger.get(this).info(`ignoring router event${reason}: ${event.constructor.name} -> ${event.url}`);
+            return this;
+        }
+        /**
+         * @return {?}
+         */
+        toString() {
+            return `${this.constructor.name}(startingUrl: ${this.startingUrl}, locationChangeTriggerUrl:${this.locationChangeTriggerUrl})`;
+        }
+    }
+    NavigationState.CancelledDuringNavigationInteraction = CancelledDuringNavigationInteraction;
+    if (false) {
+        /** @type {?} */
+        CancelledDuringNavigationInteraction.prototype.isPopState;
+        /**
+         * @type {?}
+         * @private
+         */
+        CancelledDuringNavigationInteraction.prototype.capturedFauxRouterStart;
+        /** @type {?} */
+        CancelledDuringNavigationInteraction.prototype.startingUrl;
+        /** @type {?} */
+        CancelledDuringNavigationInteraction.prototype.locationChangeTriggerUrl;
+    }
+})(NavigationState || (NavigationState = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigation-state.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/guards/navigation-state.ts"],"names":[],"mappings":"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","sourcesContent":["import { NavigationCancel, NavigationEnd, NavigationError, NavigationStart, RouterEvent } from '@angular/router';\nimport { Dsl, GarbageCollector, lang, Logger } from '@coolon/pectin';\nimport { InteractionContext } from '../../interaction/interaction-context';\nimport { InteractionService } from '../../interaction/services/interaction.service';\nimport { PlaceComponent } from '../place-component';\nimport { PlaceDefinition } from '../place-definition';\nimport { PlaceRouter } from '../place-router';\nimport { UrlSnapshot } from '../url-snapshot';\nimport { Visit } from '../visit';\nimport { PlaceComponentDeactivationHandler } from './place-component-deactivation-handler';\n\nexport abstract class NavigationState extends GarbageCollector {\n\n  private _visits = new Map<PlaceDefinition, Visit>();\n\n  abstract readonly isTransitional: boolean;\n  abstract readonly startingUrl: string;\n  abstract readonly isPopState: boolean;\n\n  constructor(protected readonly context: NavigationState.Context) {\n    super();\n  }\n\n  get idle() {\n    return !this.isTransitional;\n  }\n\n  get placeRouter(): PlaceRouter {\n    return this.context.placeRouter;\n  }\n\n  get interactionService(): InteractionService {\n    return this.context.interactionService;\n  }\n\n  get interactionContext(): InteractionContext {\n    return null;\n  }\n\n  storeVisit(visit: Visit) {\n    this._visits.set(visit.placeDefinition, visit);\n  }\n\n  getVisitFor(placeDef: PlaceDefinition) {\n    return this._visits.get(placeDef);\n  }\n\n  onPopState(event: NavigationStart): NavigationState {\n    return this.illegalTransition(event);\n  }\n\n  onStart(event: NavigationStart): NavigationState {\n    return this.illegalTransition(event);\n  }\n\n  onCancel(event: NavigationCancel): NavigationState {\n    return this.illegalTransition(event);\n  }\n\n  onError(event: NavigationError): NavigationState {\n    return this.illegalTransition(event);\n  }\n\n  onEnd(event: NavigationEnd): NavigationState {\n    return this.illegalTransition(event);\n  }\n\n  onBackClickedDuringNavigationInteraction(newUrl: string): NavigationState {\n    return this.illegalTransition('onBackClickedDuringNavigationInteraction');\n  }\n\n  async canDeactivatePlace(component: PlaceComponent, nextState: UrlSnapshot): Promise<boolean> {\n    return this.illegalTransition('canDeactivatePlace');\n  }\n\n  getVisits(): Visit[] {\n    return Array.from(this._visits.values());\n  }\n\n  protected illegalTransition<R>(message: string | RouterEvent): R {\n    return lang.illegalState(`${message.toString()} not supported by ${this.toString()}`);\n  }\n\n  protected currentRouterUrl(): string {\n    return this.placeRouter.getCurrentRouterUrl();\n  }\n\n  protected createTransitionStateFor(event: NavigationStart) {\n    // TODO: check if the event is purely for interaction context changes.\n    const popstate = event.navigationTrigger === 'popstate';\n    return popstate ?\n      new NavigationState.NavigationBackTransition(this.context, popstate, this.currentRouterUrl()) :\n      new NavigationState.NavigationTransition(this.context, popstate, this.currentRouterUrl());\n  }\n\n  resetBrowserLocation(url) {\n    // TODO: Should this be a navigate operation to avoid confusing the router...??\n    setTimeout(() => this.placeRouter.resetBrowserLocation(url));\n  }\n\n  toString(): string {\n    return this.constructor.name;\n  }\n\n}\n\nexport namespace NavigationState {\n\n  export class Context {\n    constructor(\n      readonly placeRouter: PlaceRouter,\n      readonly interactionService: InteractionService,\n      readonly notifySuccess: (success: NavigationState) => void) {\n    }\n  }\n\n  export class Idle extends NavigationState {\n    readonly isTransitional = false;\n    readonly startingUrl = null;\n    readonly isPopState = false;\n\n    constructor(context: Context) {\n      super(context);\n    }\n\n    onStart(event: NavigationStart): NavigationState {\n\n      // calling angularLocation.go() to clear back state can trigger router cycles to the current url if we don't ignore them\n      if (event.url === this.currentRouterUrl()) {\n        Logger.get(this).info(`navigation started to same url -> ${event.url}`);\n        return this;\n      }\n\n      if (this.placeRouter.hasActiveInteractionIds(event.url)) {\n        Logger.get(this).info(`navigation started with interaction outlet -> ${event.url}`);\n        return new InteractionTransition(this.context, event.url);\n      } else {\n        return this.createTransitionStateFor(event);\n      }\n    }\n\n    onPopState(event: NavigationStart): NavigationState {\n      return this.createTransitionStateFor(event);\n    }\n  }\n\n  export abstract class AbstractNavigationTransition extends NavigationState {\n    readonly isTransitional = true;\n    private componentDeactivationHandlers = new Map<PlaceComponent, PlaceComponentDeactivationHandler>();\n    private _interactionContext: InteractionContext;\n\n    constructor(context: Context, readonly isPopState: boolean, readonly startingUrl: string) {\n      super(context);\n      this._interactionContext = this.interactionService._createExclusiveModalInteractionContext();\n      this.onDispose(() => {\n        // the interaction context can be detached during the back button cancellation state transition\n        // as the transition is synchronous and activityCancellation isn't.  Otherwise dispose will be\n        // called before the context has been cancelled.  It might be work having the interaction context\n        // automatically cancel if the context is disposed so we don't have worry about detaching etc.\n        if (this._interactionContext) {\n          this._interactionContext.dispose(); // or do something like cancelAndDispose?\n        }\n      });\n    }\n\n    get interactionContext(): InteractionContext {\n      return this._interactionContext;\n    }\n\n    onStart(event: NavigationStart): NavigationState {\n      // active sessions can have many cancel start cycles due\n      // to place guard redirects\n      return this;\n    }\n\n    onEnd(event: NavigationEnd): NavigationState {\n      // navigation succeeded\n      this.context.notifySuccess(this);\n      return new Idle(this.context);\n    }\n\n\n    onBackClickedDuringNavigationInteraction(locationTriggerUrl: string): NavigationState {\n      // detach the interactoin from the session so it doesn't get disposed until the activity\n      // has completed.\n      const context = this.detachInteractionContext();\n      const { when } = Dsl.disposeWith(context);\n      // TODO: I need to make the exclusive interaction context disallow nested activities or\n      //       that would mess things up entirely.\n      context.getCurrentActivity().then(activity => {\n        when.valueOf(context.active).becomesFalsey(() => context.dispose(), { once: true });\n        activity.cancel(null);\n      });\n      return new CancelledDuringNavigationInteraction(this.context,\n        this.startingUrl,\n        locationTriggerUrl);\n    }\n\n    async canDeactivatePlace(component: PlaceComponent, nextState: UrlSnapshot): Promise<boolean> {\n      // lookup the handler and create it if we've not seen it yet\n      let handler = this.componentDeactivationHandlers.get(component);\n      if (!handler) {\n        const isPrimaryHandler = this.componentDeactivationHandlers.size === 0; // only primary handler cancele the app model interations\n        handler = new PlaceComponentDeactivationHandler(component, this);\n        this.componentDeactivationHandlers.set(component, handler);\n      }\n      return handler.canDeactivate(nextState);\n    }\n\n    private detachInteractionContext(): InteractionContext {\n      const context = this._interactionContext;\n      this._interactionContext = null;\n      return context;\n    }\n  }\n\n  export class NavigationTransition extends AbstractNavigationTransition {\n    readonly isPopState = false;\n\n    onStart(event: NavigationStart): NavigationState {\n      // active sessions can have many cancel start cycles due\n      // to place guard redirects\n      return this;\n    }\n\n    onEnd(event: NavigationEnd): NavigationState {\n      // navigation succeeded\n      this.context.notifySuccess(this);\n      return new Idle(this.context);\n    }\n\n    onCancel(event: NavigationCancel): NavigationState {\n      return new Idle(this.context);\n    }\n\n    onError(event: NavigationError): NavigationState {\n      // navigation was aborted.\n      return new Idle(this.context);\n    }\n\n    toString(): string {\n      return `${this.constructor.name}(startingUrl: ${this.startingUrl})`;\n    }\n  }\n\n  export class NavigationBackTransition extends AbstractNavigationTransition {\n    readonly isPopState = true;\n\n    onCancel(event: NavigationCancel): NavigationState {\n      // Angular doesn't preserve the url when a guard cancels the back button.\n      // See https://github.com/angular/angular/issues/13586#issuecomment-432795720\n      Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');\n      this.resetBrowserLocation(this.startingUrl);\n      return new Idle(this.context);\n    }\n\n    onError(event: NavigationError): NavigationState {\n      // navigation was aborted.\n      if (this.currentRouterUrl() !== this.startingUrl) {\n        // Angular doesn't preserve the url when a guard cancels the back button.\n        // See https://github.com/angular/angular/issues/13586#issuecomment-432795720\n        Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');\n        this.resetBrowserLocation(this.startingUrl);\n      }\n      return new Idle(this.context);\n    }\n\n  }\n\n  export abstract class AbstractInteractionTransition extends NavigationState {\n    readonly isTransitional = true;\n\n    constructor(context: Context, readonly startingUrl: string) {\n      super(context);\n    }\n\n    protected reinstateInteractionRoute() {\n      console.log(this.startingUrl);\n      setTimeout(() => this.placeRouter.syncInteractionIdsWithRouter());\n    }\n  }\n\n  /**\n   * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can\n   * happily ignore interaction contexts.\n   */\n  export class InteractionTransition extends AbstractInteractionTransition {\n    readonly isPopState = false;\n\n    onEnd(event: NavigationEnd): NavigationState {\n      if (this.context.interactionService.isActive()) {\n        this.reinstateInteractionRoute();\n        return new IdleDuringInteraction(this.context, this.startingUrl);\n      } else {\n        return new Idle(this.context);\n      }\n    }\n  }\n\n  /**\n   * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can\n   * happily ignore interaction contexts.\n   */\n  export class InteractionBackTransition extends AbstractInteractionTransition {\n    readonly isPopState = true;\n\n    onEnd(event: NavigationEnd): NavigationState {\n      if (this.interactionService.isActive()) {\n        this.reinstateInteractionRoute();\n        return new IdleDuringInteraction(this.context, this.startingUrl);\n      } else {\n        return new Idle(this.context);\n      }\n    }\n  }\n\n  export class IdleDuringInteraction extends NavigationState {\n    readonly isTransitional = false;\n    readonly isPopState = false;\n\n    constructor(context: Context, readonly startingUrl: string) {\n      super(context);\n    }\n\n    onStart(event: NavigationStart): NavigationState {\n      return new InteractionTransition(this.context, event.url);\n    }\n\n    onPopState(event: NavigationStart): NavigationState {\n      return new InteractionBackTransition(this.context, event.url);\n    }\n  }\n\n\n  export class CancelledDuringNavigationInteraction extends NavigationState {\n\n    readonly isPopState = false;\n    private capturedFauxRouterStart = false;\n\n    constructor(context: Context,\n                readonly startingUrl: string,\n                readonly locationChangeTriggerUrl: string) {\n      super(context);\n    }\n\n    get isTransitional() {\n      return !this.capturedFauxRouterStart;\n    }\n\n    onStart(event: NavigationStart): NavigationState {\n      if (event.url === this.locationChangeTriggerUrl && !this.capturedFauxRouterStart) {\n        this.capturedFauxRouterStart = true;\n        return this.ignore(event, 'url matched back button location change');\n      } else {\n        return this.createTransitionStateFor(event);\n      }\n    }\n\n    onCancel(event: NavigationCancel): NavigationState {\n      return this.ignore(event);\n    }\n\n    onEnd(event: NavigationEnd): NavigationState {\n      return this.ignore(event);\n    }\n\n    onError(event: NavigationError): NavigationState {\n      return this.ignore(event);\n    }\n\n    onPopState(event: NavigationStart): NavigationState {\n      return this.createTransitionStateFor(event);\n    }\n\n    ignore(event: RouterEvent, reason?: string): NavigationState {\n      reason = reason ? ` (${reason})` : '';\n      Logger.get(this).info(`ignoring router event${reason}: ${event.constructor.name} -> ${event.url}`);\n      return this;\n    }\n\n    toString(): string {\n      return `${this.constructor.name}(startingUrl: ${this.startingUrl}, locationChangeTriggerUrl:${this.locationChangeTriggerUrl})`;\n    }\n\n  }\n}\n"]}