@coolon/angular-ui-powerups 0.0.126 → 0.0.129

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

@@ -1,1118 +0,0 @@
-/**
- * @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();
-        this.debugPropertyKeys = [];
-    }
-    /**
-     * @return {?}
-     */
-    get name() {
-        return this.constructor.name;
-    }
-    /**
-     * @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 {?} visit
-     * @param {?} initialUrl
-     * @return {?}
-     */
-    onPlaceNavigationStart(visit, initialUrl) {
-        return this.illegalTransition('onPlaceNavigationStart');
-    }
-    /**
-     * @param {?} event
-     * @return {?}
-     */
-    onPopState(event) {
-        return this.illegalTransition(event);
-    }
-    /**
-     * @param {?} event
-     * @return {?}
-     */
-    onRouterStarted(event) {
-        return this.illegalTransition(event);
-    }
-    /**
-     * @param {?} event
-     * @return {?}
-     */
-    onRouterCancelled(event) {
-        return this.illegalTransition(event);
-    }
-    /**
-     * @param {?} event
-     * @return {?}
-     */
-    onRouterError(event) {
-        return this.illegalTransition(event);
-    }
-    /**
-     * @param {?} event
-     * @return {?}
-     */
-    onRouterEnd(event) {
-        return this.illegalTransition(event);
-    }
-    /**
-     * @param {?} newUrl
-     * @return {?}
-     */
-    onBackClickedDuringNavigationInteraction(newUrl) {
-        return this.illegalTransition('onBackClickedDuringNavigationInteraction');
-    }
-    /**
-     * @param {?} component
-     * @param {?} currentUrl
-     * @param {?} nextUrl
-     * @return {?}
-     */
-    canDeactivatePlace(component, currentUrl, nextUrl) {
-        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) {
-        /** @type {?} */
-        const popstate = event.navigationTrigger === 'popstate';
-        /** @type {?} */
-        const inInteraction = this.interactionService.isActive();
-        if (popstate) {
-            return inInteraction ?
-                new NavigationState.LeavingInteractionAfterPopStateTransition(this.context, this.currentRouterUrl(), event.url) :
-                new NavigationState.PopStateTransition(this.context, this.currentRouterUrl(), event.url);
-        }
-        else {
-            return inInteraction ?
-                new NavigationState.StartingInteractionTransition(this.context, this.currentRouterUrl()) :
-                new NavigationState.NavigationTransition(this.context, this.currentRouterUrl());
-        }
-    }
-    /**
-     * @protected
-     * @return {?}
-     */
-    createIdleState() {
-        return this.interactionService.isActive() ?
-            new NavigationState.IdleDuringInteraction(this.context, this.currentRouterUrl()) :
-            new NavigationState.Idle(this.context);
-    }
-    /**
-     * @param {?} url
-     * @param {?=} options
-     * @return {?}
-     */
-    resetBrowserLocation(url, options = { replaceCurrent: false }) {
-        this.placeRouter.resetBrowserLocation(url, options);
-    }
-    /**
-     * @param {?} event
-     * @param {?=} reason
-     * @return {?}
-     */
-    ignore(event, reason) {
-        reason = reason ? ` -> ${reason}` : '';
-        Logger.get(this).info(`Ignoring router event${reason}: ${event.constructor.name} -> ${event.url} :: ${this.toString()}`);
-        return this;
-    }
-    /**
-     * @return {?}
-     */
-    toString() {
-        return `${this.constructor.name}(${this.debugState()})`;
-    }
-    /**
-     * @protected
-     * @param {?=} properties
-     * @return {?}
-     */
-    debugState(properties) {
-        return (properties || this.debugPropertyKeys).map((/**
-         * @param {?} p
-         * @return {?}
-         */
-        p => {
-            return `${p}: ${this[p]}`;
-        })).join(', ');
-    }
-    /**
-     * @protected
-     * @param {?} url
-     * @return {?}
-     */
-    replaceBuggeredUrlAfterAngularRouterCancelled(url) {
-        // Angular calls _this.resetUrlToCurrentUrlTree() on cancelling and fucks our history.
-        // So this means that the top of the stack is the url we want to go back to, and not the one that was on
-        // it before the cancel event fired.
-        // So we need to:
-        // - replace the just inserted url with the one that used to be there.
-        // - push our actual url back onto the top of the stack.
-        this.resetBrowserLocation(url, { replaceCurrent: true });
-    }
-}
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    NavigationState.prototype._visits;
-    /** @type {?} */
-    NavigationState.prototype.isTransitional;
-    /** @type {?} */
-    NavigationState.prototype.startingUrl;
-    /** @type {?} */
-    NavigationState.prototype.isPopState;
-    /** @type {?} */
-    NavigationState.prototype.debugPropertyKeys;
-    /**
-     * @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 {?} visit
-         * @param {?} initialUrl
-         * @return {?}
-         */
-        onPlaceNavigationStart(visit, initialUrl) {
-            /** @type {?} */
-            const navigationTransition = new NavigationTransition(this.context, initialUrl);
-            navigationTransition.storeVisit(visit);
-            return navigationTransition;
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterStarted(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 StartingInteractionTransition(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 {?} startingUrl
-         */
-        constructor(context, startingUrl) {
-            super(context);
-            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 {?}
-         */
-        onRouterStarted(event) {
-            // active sessions can have many cancel start cycles due
-            // to place guard redirects
-            return this;
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterEnd(event) {
-            // navigation succeeded
-            this.context.notifySuccess(this);
-            return new Idle(this.context);
-        }
-        /**
-         * @param {?} newUrl
-         * @return {?}
-         */
-        onBackClickedDuringNavigationInteraction(newUrl) {
-            Logger.get(this).info(`back button pressed during navigation session interaction promise`);
-            // detach the interaction from the session so it doesn't get disposed until the activity has completed.
-            /** @type {?} */
-            const navigationInteraction = this.detachInteractionContext();
-            const { when } = Dsl.disposeWith(navigationInteraction);
-            // TODO: I need to make the exclusive interaction context disallow nested activities or
-            //       that would mess things up entirely. Or, can I do a context.abortAll().then(..)
-            Logger.get(this).info('cancelling current navigation activity..');
-            navigationInteraction.cancelActiveActivity().then((/**
-             * @return {?}
-             */
-            () => {
-                navigationInteraction.dispose();
-            }));
-            return this.createNavigationInteractionCancelledState(newUrl);
-        }
-        /**
-         * @param {?} component
-         * @param {?} currentUrl
-         * @param {?} nextUrl
-         * @return {?}
-         */
-        canDeactivatePlace(component, currentUrl, nextUrl) {
-            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, isPrimaryHandler);
-                    this.componentDeactivationHandlers.set(component, handler);
-                }
-                return handler.canDeactivate(currentUrl, nextUrl);
-            });
-        }
-        /**
-         * @protected
-         * @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.startingUrl;
-        /**
-         * @abstract
-         * @param {?} newUrl
-         * @return {?}
-         */
-        AbstractNavigationTransition.prototype.createNavigationInteractionCancelledState = function (newUrl) { };
-    }
-    class NavigationTransition extends AbstractNavigationTransition {
-        constructor() {
-            super(...arguments);
-            this.isPopState = false;
-            this.debugPropertyKeys = ['startingUrl'];
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterCancelled(event) {
-            return this;
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterError(event) {
-            // navigation was aborted.
-            return new Idle(this.context);
-        }
-        /**
-         * @param {?} newUrl
-         * @return {?}
-         */
-        createNavigationInteractionCancelledState(newUrl) {
-            return new LinkTriggeredNavigationInteractionCancelled(this.context, this.startingUrl, newUrl);
-        }
-    }
-    NavigationState.NavigationTransition = NavigationTransition;
-    if (false) {
-        /** @type {?} */
-        NavigationTransition.prototype.isPopState;
-        /** @type {?} */
-        NavigationTransition.prototype.debugPropertyKeys;
-    }
-    class PopStateTransition extends AbstractNavigationTransition {
-        /**
-         * @param {?} context
-         * @param {?} startingUrl
-         * @param {?} poppedHistoryUrl
-         */
-        constructor(context, startingUrl, poppedHistoryUrl) {
-            super(context, startingUrl);
-            this.poppedHistoryUrl = poppedHistoryUrl;
-            this.isPopState = true;
-            this.debugPropertyKeys = ['startingUrl', 'poppedHistoryUrl'];
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterCancelled(event) {
-            this.replaceBuggeredUrlAfterAngularRouterCancelled(this.poppedHistoryUrl);
-            // 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 {?}
-         */
-        onRouterError(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.restoreHistory([
-            //     this.poppedHistoryUrl,
-            //     this.startingUrl
-            //   ]);
-            // }
-            // return new Idle(this.context);
-            return this.illegalTransition("when do I get this???");
-        }
-        /**
-         * @param {?} locationTriggerUrl
-         * @return {?}
-         */
-        createNavigationInteractionCancelledState(locationTriggerUrl) {
-            return new PopStateTriggeredNavigationInteractionCancelled(this.context, this.startingUrl, locationTriggerUrl, this.poppedHistoryUrl);
-        }
-    }
-    NavigationState.PopStateTransition = PopStateTransition;
-    if (false) {
-        /** @type {?} */
-        PopStateTransition.prototype.isPopState;
-        /** @type {?} */
-        PopStateTransition.prototype.debugPropertyKeys;
-        /** @type {?} */
-        PopStateTransition.prototype.poppedHistoryUrl;
-    }
-    /**
-     * @abstract
-     */
-    class AbstractInteractionTransition extends AbstractNavigationTransition {
-        /**
-         * @param {?} context
-         * @param {?} startingUrl
-         */
-        constructor(context, startingUrl) {
-            super(context, startingUrl);
-            this.startingUrl = startingUrl;
-            this.isTransitional = true;
-        }
-    }
-    NavigationState.AbstractInteractionTransition = AbstractInteractionTransition;
-    if (false) {
-        /** @type {?} */
-        AbstractInteractionTransition.prototype.isTransitional;
-        /** @type {?} */
-        AbstractInteractionTransition.prototype.startingUrl;
-    }
-    // The following states exist to handle all events while any kind of navigation is in progress.  That way all other states can
-    // happily ignore interaction contexts.
-    /**
-     * This is the non transitional (i.e. rest) state that is used whenever an interaction context is active.
-     */
-    class IdleDuringInteraction extends NavigationState {
-        /**
-         * @param {?} context
-         * @param {?} startingUrl
-         */
-        constructor(context, startingUrl) {
-            super(context);
-            this.startingUrl = startingUrl;
-            this.isTransitional = false;
-            this.isPopState = false;
-            this.debugPropertyKeys = ['startingUrl'];
-        }
-        /**
-         * @param {?} visit
-         * @param {?} initialUrl
-         * @return {?}
-         */
-        onPlaceNavigationStart(visit, initialUrl) {
-            // we're in an interaction and the user clicked back
-            /** @type {?} */
-            const navigationTransition = new StartingInteractionTransition(this.context, initialUrl);
-            navigationTransition.storeVisit(visit);
-            return navigationTransition;
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterStarted(event) {
-            return new StartingInteractionTransition(this.context, event.url);
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onPopState(event) {
-            // we're in an interaction and the user clicked back
-            return new LeavingInteractionAfterPopStateTransition(this.context, event.url, event.url);
-        }
-    }
-    NavigationState.IdleDuringInteraction = IdleDuringInteraction;
-    if (false) {
-        /** @type {?} */
-        IdleDuringInteraction.prototype.isTransitional;
-        /** @type {?} */
-        IdleDuringInteraction.prototype.isPopState;
-        /** @type {?} */
-        IdleDuringInteraction.prototype.debugPropertyKeys;
-        /** @type {?} */
-        IdleDuringInteraction.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.
-     * NOTE: This state is activated when ever an interaction is started.  It might be better to split it into
-     *       different states for different scenarios, e.g. starting model, starting model during route guard etc.
-     */
-    class StartingInteractionTransition extends AbstractInteractionTransition {
-        constructor() {
-            super(...arguments);
-            this.isPopState = false;
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterCancelled(event) {
-            // TODO: this.replaceBuggeredUrlAfterAngularRouterCancells(...);???
-            if (this.context.interactionService.isActive()) {
-                /** @type {?} */
-                const interactionIds = this.interactionService.activeInteractionContextIds.value;
-                this.resetBrowserLocation(this.placeRouter.parseUrl(this.startingUrl).updateInteractionIds(interactionIds).url);
-                return new IdleDuringInteraction(this.context, this.startingUrl);
-            }
-            else {
-                return new Idle(this.context);
-            }
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterError(event) {
-            // navigation was aborted.
-            return new IdleDuringInteraction(this.context, this.startingUrl);
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterEnd(event) {
-            if (this.context.interactionService.isActive()) {
-                return new IdleDuringInteraction(this.context, this.startingUrl);
-            }
-            else {
-                return new Idle(this.context);
-            }
-        }
-        /**
-         * @param {?} locationTriggerUrl
-         * @return {?}
-         */
-        createNavigationInteractionCancelledState(locationTriggerUrl) {
-            return new LeavingInteractionTransitionCancelled(this.context, this.startingUrl, locationTriggerUrl);
-        }
-    }
-    NavigationState.StartingInteractionTransition = StartingInteractionTransition;
-    if (false) {
-        /** @type {?} */
-        StartingInteractionTransition.prototype.isPopState;
-    }
-    /**
-     * The sequence of router events are:
-     * Error -> url = url of navigation link
-     * End
-     * onPopState url = current intereaction url sans the query params
-     * Cancel url == same as above.
-     */
-    class LeavingInteractionTransitionCancelled extends NavigationState {
-        /**
-         * @param {?} context
-         * @param {?} startingUrl
-         * @param {?} locationChangeTriggerUrl
-         */
-        constructor(context, startingUrl, locationChangeTriggerUrl) {
-            super(context);
-            this.startingUrl = startingUrl;
-            this.locationChangeTriggerUrl = locationChangeTriggerUrl;
-            this.isPopState = false;
-            this.firstCancelHandled = false;
-            this.popStateHandled = false;
-            this.debugPropertyKeys = ['idle', 'startingUrl', 'poppedHistoryUrl', 'locationChangeTriggerUrl', 'popStateEventUrl', 'firstCancelHandled', 'popStateHandled'];
-        }
-        /**
-         * @return {?}
-         */
-        get isTransitional() {
-            return true;
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterStarted(event) {
-            return this.ignore(event);
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterCancelled(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');
-            if (this.interactionService.isActive()) {
-                /** @type {?} */
-                const interactionIds = this.interactionService.activeInteractionContextIds.value;
-                this.resetBrowserLocation(this.placeRouter.parseUrl(this.startingUrl).updateInteractionIds(interactionIds).url);
-            }
-            else {
-                // this.replaceBuggeredUrlAfterAngularRouterCancells(this.start)
-                this.resetBrowserLocation(this.startingUrl); // and now put our own url back in.
-            }
-            return this.createIdleState();
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterEnd(event) {
-            return this.ignore(event);
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterError(event) {
-            return this.ignore(event);
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onPopState(event) {
-            return this.ignore(event);
-        }
-        /**
-         * @param {?} component
-         * @param {?} currentUrl
-         * @param {?} nextUrl
-         * @return {?}
-         */
-        canDeactivatePlace(component, currentUrl, nextUrl) {
-            return tslib_1.__awaiter(this, void 0, void 0, function* () {
-                return false;
-            });
-        }
-    }
-    NavigationState.LeavingInteractionTransitionCancelled = LeavingInteractionTransitionCancelled;
-    if (false) {
-        /** @type {?} */
-        LeavingInteractionTransitionCancelled.prototype.isPopState;
-        /** @type {?} */
-        LeavingInteractionTransitionCancelled.prototype.firstCancelHandled;
-        /** @type {?} */
-        LeavingInteractionTransitionCancelled.prototype.popStateHandled;
-        /** @type {?} */
-        LeavingInteractionTransitionCancelled.prototype.popStateEventUrl;
-        /** @type {?} */
-        LeavingInteractionTransitionCancelled.prototype.debugPropertyKeys;
-        /** @type {?} */
-        LeavingInteractionTransitionCancelled.prototype.startingUrl;
-        /** @type {?} */
-        LeavingInteractionTransitionCancelled.prototype.locationChangeTriggerUrl;
-    }
-    /**
-     * 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 LeavingInteractionAfterPopStateTransition extends AbstractInteractionTransition {
-        /**
-         * @param {?} context
-         * @param {?} startingUrl
-         * @param {?} poppedHistoryUrl
-         */
-        constructor(context, startingUrl, poppedHistoryUrl) {
-            super(context, startingUrl);
-            this.poppedHistoryUrl = poppedHistoryUrl;
-            this.isPopState = true;
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterCancelled(event) {
-            // TODO: this.replaceBuggeredUrlAfterAngularRouterCancells(...);???
-            if (this.interactionService.isActive()) {
-                /** @type {?} */
-                const interactionIds = this.interactionService.activeInteractionContextIds.value;
-                this.resetBrowserLocation(this.placeRouter.parseUrl(this.startingUrl).updateInteractionIds(interactionIds).url);
-                return new IdleDuringInteraction(this.context, this.startingUrl);
-            }
-            else {
-                return new Idle(this.context);
-            }
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterEnd(event) {
-            if (this.context.interactionService.isActive()) {
-                return new IdleDuringInteraction(this.context, this.startingUrl);
-            }
-            else {
-                return new Idle(this.context);
-            }
-        }
-        /**
-         * @param {?} newUrl
-         * @return {?}
-         */
-        createNavigationInteractionCancelledState(newUrl) {
-            return this.illegalTransition('Leaving interaction after pop-state should\'t block so should never see a back button click');
-        }
-    }
-    NavigationState.LeavingInteractionAfterPopStateTransition = LeavingInteractionAfterPopStateTransition;
-    if (false) {
-        /** @type {?} */
-        LeavingInteractionAfterPopStateTransition.prototype.isPopState;
-        /** @type {?} */
-        LeavingInteractionAfterPopStateTransition.prototype.poppedHistoryUrl;
-    }
-    /**
-     * This state handles the scenario where a link navigation triggered an interaction and the user clicked back a to cancel it.
-     * The routing event sequence is different depending on the link that was clicked.
-     *
-     * If the link was the same as the previous history location (i.e. they've gone back via a link rather than clicking back) then the sequence is:
-     *
-     * -> Idle -> NavigationTransition
-     * -> confirm dialog shown.
-     * -> click back
-     * -> NavigationCancel -> clickedLinkUrl === cancel.url
-     * -> NavigationEnd
-     *
-     * Otherwise if the link is different from teh history location then the sequence is:
-     *
-     * -> Idle -> NavigationTransition
-     * -> confirm dialog shown.
-     * -> click back
-     * -> NavigationCancel -> clickedLinkUrl !== cancel.url
-     * -> NavigationEnd
-     * -> PopState
-     * -> NavigationCancel
-     */
-    class LinkTriggeredNavigationInteractionCancelled extends NavigationState {
-        /**
-         * @param {?} context
-         * @param {?} startingUrl
-         * @param {?} clickedLinkUrl
-         */
-        constructor(context, startingUrl, clickedLinkUrl) {
-            super(context);
-            this.startingUrl = startingUrl;
-            this.clickedLinkUrl = clickedLinkUrl;
-            this.isPopState = false;
-            this.clickedLinkMatchedBackButtonUrl = false;
-            this.debugPropertyKeys = ['idle', 'startingUrl', 'clickedLinkUrl', 'firstCancelEventUrl', 'clickedLinkMatchedBackButtonUrl', 'popStateEventUrl'];
-        }
-        /**
-         * @return {?}
-         */
-        get isTransitional() {
-            return true;
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterStarted(event) {
-            return this.ignore(event);
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterCancelled(event) {
-            // TODO: should really split this into two sub states in the first cancel event.
-            if (!this.firstCancelEventUrl) {
-                this.firstCancelEventUrl = event.url;
-                this.clickedLinkMatchedBackButtonUrl = event.url === this.clickedLinkUrl;
-                return this.ignore(event);
-            }
-            else {
-                // we wait for our popped state to come in.
-                if (!this.clickedLinkMatchedBackButtonUrl && this.popStateEventUrl) {
-                    return this.finaliseRouting();
-                }
-            }
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterEnd(event) {
-            if (this.clickedLinkMatchedBackButtonUrl) {
-                return this.finaliseRouting();
-            }
-            else {
-                return this.ignore(event);
-            }
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterError(event) {
-            return this.ignore(event);
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onPopState(event) {
-            this.popStateEventUrl = event.url;
-            return this.ignore(event);
-        }
-        /**
-         * @return {?}
-         */
-        finaliseRouting() {
-            Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
-            this.replaceBuggeredUrlAfterAngularRouterCancelled(this.clickedLinkUrl); // put the back click one back in.
-            if (this.interactionService.isActive()) {
-                /** @type {?} */
-                const interactionIds = this.interactionService.activeInteractionContextIds.value;
-                // Angular doesn't preserve the url when a guard cancels the back button.
-                // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
-                this.resetBrowserLocation(this.placeRouter.parseUrl(this.startingUrl).updateInteractionIds(interactionIds).url);
-            }
-            else {
-                this.resetBrowserLocation(this.startingUrl); // and now put our own url back in.
-            }
-            return this.createIdleState();
-        }
-        /**
-         * @param {?} component
-         * @param {?} currentUrl
-         * @param {?} nextUrl
-         * @return {?}
-         */
-        canDeactivatePlace(component, currentUrl, nextUrl) {
-            return tslib_1.__awaiter(this, void 0, void 0, function* () {
-                return false;
-            });
-        }
-    }
-    NavigationState.LinkTriggeredNavigationInteractionCancelled = LinkTriggeredNavigationInteractionCancelled;
-    if (false) {
-        /** @type {?} */
-        LinkTriggeredNavigationInteractionCancelled.prototype.isPopState;
-        /** @type {?} */
-        LinkTriggeredNavigationInteractionCancelled.prototype.firstCancelEventUrl;
-        /** @type {?} */
-        LinkTriggeredNavigationInteractionCancelled.prototype.popStateEventUrl;
-        /** @type {?} */
-        LinkTriggeredNavigationInteractionCancelled.prototype.clickedLinkMatchedBackButtonUrl;
-        /** @type {?} */
-        LinkTriggeredNavigationInteractionCancelled.prototype.debugPropertyKeys;
-        /** @type {?} */
-        LinkTriggeredNavigationInteractionCancelled.prototype.startingUrl;
-        /** @type {?} */
-        LinkTriggeredNavigationInteractionCancelled.prototype.clickedLinkUrl;
-    }
-    /**
-     * This state handles the scenario where a pop state triggered and interaction and the user clickeb back a second time to cancel it.
-     * The sequence of routing events/state transitions is as follows.
-     * -> Idle -> PopStateTransition (poppedHistoryUrl == page to go to, startingUrl = page to stay on )
-     * -> confirm dialog shown.
-     * -> click back
-     * -> PopStateTransition -> CancelledDuringBackButtonNavigationInteraction(trigger url is the page before the popped history url)
-     * -> NavigationCancel (for the previous back)
-     * -> PopState
-     * -> NavigationCancel
-     */
-    class PopStateTriggeredNavigationInteractionCancelled extends NavigationState {
-        /**
-         * @param {?} context
-         * @param {?} startingUrl
-         * @param {?} locationChangeTriggerUrl
-         * @param {?} poppedHistoryUrl
-         */
-        constructor(context, startingUrl, locationChangeTriggerUrl, poppedHistoryUrl) {
-            super(context);
-            this.startingUrl = startingUrl;
-            this.locationChangeTriggerUrl = locationChangeTriggerUrl;
-            this.poppedHistoryUrl = poppedHistoryUrl;
-            this.isPopState = false;
-            this.firstCancelHandled = false;
-            this.popStateHandled = false;
-            this.debugPropertyKeys = ['idle', 'startingUrl', 'poppedHistoryUrl', 'locationChangeTriggerUrl', 'popStateEventUrl', 'firstCancelHandled', 'popStateHandled'];
-        }
-        /**
-         * @return {?}
-         */
-        get isTransitional() {
-            return true;
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterStarted(event) {
-            return this.ignore(event);
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterCancelled(event) {
-            if (this.firstCancelHandled && this.popStateHandled) {
-                // 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');
-                // Angular calls _this.resetUrlToCurrentUrlTree() on cancelling and fucks our history.
-                // So this means that the top of the stack is the url we want to go back to, and not the one that was on
-                // it before the cancel event fired.
-                // So we need to:
-                // - replace the just inserted url with the one that used to be there.
-                // - push our actual url back onto the top of the stack.
-                this.replaceBuggeredUrlAfterAngularRouterCancelled(this.locationChangeTriggerUrl);
-                this.resetBrowserLocation(this.poppedHistoryUrl); // put the first back click one back in.
-                if (this.interactionService.isActive()) {
-                    /** @type {?} */
-                    const interactionIds = this.interactionService.activeInteractionContextIds.value;
-                    this.resetBrowserLocation(this.placeRouter.parseUrl(this.startingUrl).updateInteractionIds(interactionIds).url);
-                }
-                else {
-                    this.resetBrowserLocation(this.startingUrl); // and now put our own url back in.
-                }
-                return this.createIdleState();
-            }
-            else {
-                this.firstCancelHandled = true;
-                return this.ignore(event);
-            }
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterEnd(event) {
-            return this.ignore(event);
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onRouterError(event) {
-            return this.ignore(event);
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onPopState(event) {
-            this.popStateHandled = true;
-            this.popStateEventUrl = event.url;
-            return this.ignore(event);
-        }
-        /**
-         * @param {?} component
-         * @param {?} currentUrl
-         * @param {?} nextUrl
-         * @return {?}
-         */
-        canDeactivatePlace(component, currentUrl, nextUrl) {
-            return tslib_1.__awaiter(this, void 0, void 0, function* () {
-                return false;
-            });
-        }
-    }
-    NavigationState.PopStateTriggeredNavigationInteractionCancelled = PopStateTriggeredNavigationInteractionCancelled;
-    if (false) {
-        /** @type {?} */
-        PopStateTriggeredNavigationInteractionCancelled.prototype.isPopState;
-        /** @type {?} */
-        PopStateTriggeredNavigationInteractionCancelled.prototype.firstCancelHandled;
-        /** @type {?} */
-        PopStateTriggeredNavigationInteractionCancelled.prototype.popStateHandled;
-        /** @type {?} */
-        PopStateTriggeredNavigationInteractionCancelled.prototype.popStateEventUrl;
-        /** @type {?} */
-        PopStateTriggeredNavigationInteractionCancelled.prototype.debugPropertyKeys;
-        /** @type {?} */
-        PopStateTriggeredNavigationInteractionCancelled.prototype.startingUrl;
-        /** @type {?} */
-        PopStateTriggeredNavigationInteractionCancelled.prototype.locationChangeTriggerUrl;
-        /** @type {?} */
-        PopStateTriggeredNavigationInteractionCancelled.prototype.poppedHistoryUrl;
-    }
-})(NavigationState || (NavigationState = {}));
-//# sourceMappingURL=navigation-state.js.map