@coolon/angular-ui-powerups 0.0.101 → 0.0.103

package/fesm2015/coolon-angular-ui-powerups.js

@@ -1,14 +1,13 @@
 import { DOCUMENT, CommonModule, Location } from '@angular/common';
-import { Directive, ElementRef, Inject, Input, HostListener, NgZone, NgModule, EventEmitter, Output, Component, InjectionToken, Injector, ComponentFactoryResolver, ViewContainerRef, ViewChild, ViewChildren, Injectable, ɵɵdefineInjectable, ɵɵinject, Optional, SkipSelf, HostBinding, INJECTOR } from '@angular/core';
+import { Directive, ElementRef, Inject, Input, HostListener, NgZone, NgModule, EventEmitter, Output, Component, InjectionToken, Injector, ComponentFactoryResolver, ViewContainerRef, ViewChild, ViewChildren, Injectable, ɵɵdefineInjectable, ɵɵinject, Optional, SkipSelf, HostBinding } from '@angular/core';
 import { FormsModule } from '@angular/forms';
 import { MatInputModule, MatFormFieldModule, MatSelectModule, MatButtonModule, MatDialogModule, MatTabsModule as MatTabsModule$1, MatProgressSpinnerModule, MatDialog } from '@angular/material';
 import { MatTabsModule } from '@angular/material/tabs';
 import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
-import { GarbageCollector, DelegatingValueModel, assert, UnaryCommand, lang, Dsl, Logger, DelegatingFormValueModel, UseDelegate, ValueModel, ListModel, StoreInListModel, DelegatingListModel, Deferred, MutableStream, MutableValueModel, MutableListModel, Binding, Trace, Guard, StoreInValueModel, Command, OptionsHelper, ValueHolder } from '@coolon/pectin';
+import { GarbageCollector, DelegatingValueModel, assert, UnaryCommand, lang, Dsl, Logger, DelegatingFormValueModel, UseDelegate, ValueModel, ListModel, StoreInListModel, Trace, DelegatingListModel, Deferred, MutableStream, MutableValueModel, MutableListModel, Binding, Guard, StoreInValueModel, Command, OptionsHelper, ValueHolder } from '@coolon/pectin';
 import { __decorate, __metadata, __awaiter } from 'tslib';
 import { PortalModule } from '@angular/cdk/portal';
-import { RouterModule, UrlSegment, UrlSegmentGroup, NavigationStart, NavigationEnd, NavigationError, NavigationCancel, Router, UrlSerializer, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
-import ___default, { last, isNil, isEqual } from 'lodash';
+import { RouterModule, NavigationStart, NavigationCancel, UrlSegment, NavigationEnd, NavigationError, Router, UrlSerializer } from '@angular/router';
 import { assert as assert$1, Opts, Klass } from '@coolon/typescript-utilities';
 import { MatIconModule } from '@angular/material/icon';
 import { MatListModule } from '@angular/material/list';
@@ -16,6 +15,7 @@ import { MatTooltipModule } from '@angular/material/tooltip';
 import { Memoize } from '@typescript-plus/fast-memoize-decorator/dist/src';
 import { Memoize as Memoize$1 } from '@typescript-plus/fast-memoize-decorator';
 import 'reflect-metadata';
+import ___default, { isNil, isEqual } from 'lodash';
 import { style, query, group, animate, trigger, transition } from '@angular/animations';
 import ResizeObserver from 'resize-observer-polyfill';
 import { MatDialogConfig, MAT_DIALOG_DEFAULT_OPTIONS, MatDialog as MatDialog$1 } from '@angular/material/dialog';
@@ -912,16 +912,68 @@ class InteractionContext extends GarbageCollector {
         assert.isFalsey(this.isActive());
         super.dispose();
     }
+    /**
+     * Cancels the current activity and returns true the context is no longer active, false if
+     * there is still another activity running.
+     * @return {?}
+     */
+    cancelCurrentActivity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { when } = Dsl.disposeWith(this);
+            /** @type {?} */
+            const activity = yield this.getCurrentActivity();
+            return new Promise((/**
+             * @param {?} resolve
+             * @return {?}
+             */
+            resolve => {
+                when.valueOf(this.activeActivity)
+                    .changes((/**
+                 * @param {?} nextActivity
+                 * @return {?}
+                 */
+                nextActivity => {
+                    resolve(!nextActivity);
+                }), { once: true });
+                activity.cancel();
+            }));
+        });
+    }
+    /**
+     * @return {?}
+     */
+    abort() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isTruthy(this.isActive());
+            /** @type {?} */
+            let count = 1;
+            yield this.cancelCurrentActivity();
+            console.log(`aborted -> ${count++}`);
+            while (this.isActive()) {
+                yield this.cancelCurrentActivity();
+                console.log(`aborted -> ${count++}`);
+            }
+        });
+    }
 }
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], InteractionContext.prototype, "abort", null);
 if (false) {
+    /** @type {?} */
+    InteractionContext.prototype.active;
     /** @type {?} */
     InteractionContext.prototype.activityList;
     /** @type {?} */
-    InteractionContext.prototype.active;
+    InteractionContext.prototype.activeActivity;
     /**
      * Returns the activity that is currently active.
      * This model is only updated in the next tick after the view has been updated.
      * @abstract
+     * @protected
      * @return {?}
      */
     InteractionContext.prototype.getCurrentActivity = function () { };
@@ -1110,13 +1162,14 @@ class InteractionContextBase extends InteractionContext {
          */
         this._activityListDelegate = new DelegatingListModel();
         const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
-        when.listOf(this.activityList).becomesPopulated((/**
-         * @param {?} activities
+        this._currentActivity = chain(this.activityList).last();
+        when.valueOf(this._currentActivity).becomesTruthy((/**
+         * @param {?} activity
          * @return {?}
          */
-        (activities) => {
+        (activity) => {
             if (this.deferredGetCurrentActivity) {
-                this.deferredGetCurrentActivity.resolve(last(activities));
+                this.deferredGetCurrentActivity.resolve(activity);
                 this.deferredGetCurrentActivity = null;
             }
         }));
@@ -1135,6 +1188,12 @@ class InteractionContextBase extends InteractionContext {
     get activityList() {
         return this._activityListDelegate.readonly;
     }
+    /**
+     * @return {?}
+     */
+    get activeActivity() {
+        return this._currentActivity;
+    }
     /**
      * Returns the activity that is currently active.
      * This model is only updated in the next tick after the view has been updated.
@@ -1151,12 +1210,14 @@ class InteractionContextBase extends InteractionContext {
                     return this.deferredGetCurrentActivity.promise;
                 }
                 else {
-                    if (this.activityList.length < 1) {
+                    if (!this._currentActivity.value) {
+                        // we'be been asked before we've got any activities, create a deferred promise
+                        // that we resolve when the list populates.
                         this.deferredGetCurrentActivity = Deferred.defer();
                         return this.deferredGetCurrentActivity.promise;
                     }
                     else {
-                        return last(this.activityList.value);
+                        return this._currentActivity.value;
                     }
                 }
             }
@@ -1230,6 +1291,11 @@ if (false) {
      * @private
      */
     InteractionContextBase.prototype.deferredGetCurrentActivity;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionContextBase.prototype._currentActivity;
     /**
      * @abstract
      * @protected
@@ -1589,6 +1655,7 @@ class ActivityContainerComponent extends InteractionContextBase {
      * @return {?}
      */
     finishInitialActivity() {
+        this.updateActivityList();
         this._initialActivityOutletContext.value = null;
         this.initialActivityOutletContextEvent.emit(null);
     }
@@ -1778,6 +1845,12 @@ class InteractionService {
     isActive() {
         return this.active.value;
     }
+    /**
+     * @return {?}
+     */
+    isModalActive() {
+        return this.modelInteractionActive.value;
+    }
     /**
      * @param {?} disposable
      * @return {?}
@@ -1795,14 +1868,13 @@ class InteractionService {
     _registerInplaceInteractionContext(interactionContext) {
         interactionContext.registerDisposable(new InteractionService.Monitor(`ip${++inplaceMonitorCount}`, interactionContext, this._activeInlineInteractionContextModel, this.exclusiveContext));
     }
+    // @Trace()
     /**
      * @return {?}
      */
-    getCurrentActivity() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert$1.isTruthy(this.isActive());
-            return this._activeInteractionContext.value.getCurrentActivity();
-        });
+    getActiveContext() {
+        assert$1.isTruthy(this.isActive());
+        return this._activeInteractionContext.value;
     }
     /**
      * Creates an interaction context that will prevent any other contexts from starting an
@@ -2060,24 +2132,6 @@ if (false) {
     InplaceInteractionContextComponent.prototype.interactionService;
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class InteractionOutletComponent {
-    constructor() {
-    }
-}
-InteractionOutletComponent.decorators = [
-    { type: Component, args: [{
-                selector: 'aup-interaction-outlet',
-                template: "<router-outlet name=\"interaction-context\"></router-outlet>\n",
-                styles: [":host{display:block}"]
-            }] }
-];
-/** @nocollapse */
-InteractionOutletComponent.ctorParameters = () => [];
-
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -2100,13 +2154,11 @@ InteractionModule.decorators = [
                     ConfirmThenDialogComponent,
                     AlertDialogComponent,
                     ActivityOutletComponent,
-                    InteractionOutletComponent,
                     InplaceInteractionContextComponent
                 ],
                 exports: [
                     ActivityContainerComponent,
                     ActivityOutletComponent,
-                    InteractionOutletComponent,
                     InplaceInteractionContextComponent
                 ],
                 entryComponents: [
@@ -2894,57 +2946,89 @@ if (false) {
 class PlaceComponentDeactivationHandler {
     /**
      * @param {?} component
-     * @param {?} navigationSession
+     * @param {?} navigationState
+     * @param {?} isPrimaryComponent
      */
-    constructor(component, navigationSession) {
+    constructor(component, navigationState, isPrimaryComponent) {
         this.component = component;
-        this.navigationSession = navigationSession;
+        this.navigationState = navigationState;
+        this.isPrimaryComponent = isPrimaryComponent;
+    }
+    /**
+     * @return {?}
+     */
+    get interactionService() {
+        return this.navigationState.interactionService;
     }
     /**
+     * @return {?}
+     */
+    get placeRouter() {
+        return this.navigationState.placeRouter;
+    }
+    /**
+     * @param {?} currentUrl
      * @param {?} nextState
      * @return {?}
      */
-    canDeactivate(nextState) {
+    canDeactivate(currentUrl, nextState) {
         return __awaiter(this, void 0, void 0, function* () {
             // We'll get called multiple times if there's any parameter sanitisation so
             // we always return true if we accepted promise from a previous cycle of the current
             // navigation session.
             if (!this.canDeactivatePromise) {
-                this.canDeactivatePromise = this.canDeactivateComponent(nextState);
+                console.log(`creating deactivate promise for -> ${this.component.constructor.name}`);
+                this.canDeactivatePromise = this.canDeactivateComponent(currentUrl, nextState);
             }
             return this.canDeactivatePromise;
         });
     }
+    // @Trace()
     /**
      * @protected
+     * @param {?} currentUrl
      * @param {?} nextState
      * @return {?}
      */
-    canDeactivateComponent(nextState) {
+    canDeactivateComponent(currentUrl, nextState) {
         return __awaiter(this, void 0, void 0, function* () {
+            console.log(this.navigationState.toString());
             // Automatically cancel any active activities if the navigation session was triggered by the back button.
-            // any other navigations (such as the user clicking a differnt place) must be handled by the component itself
-            // during the canDeativate method.  If we handled more than just the pop state then it leads to the UI ignoring
-            // clicks and just cancelling things which is deeply disconcerting.
-            if (this.navigationSession.isPopState && this.component.interactionContext && this.component.interactionContext.isActive()) {
-                // Note: Modal interactions are run in a different router outlet so we never get place deactivating while
-                // a model interaction is active. This is because:
-                // 1. the user can't click anything to navigate away
-                // 2. clicking the back button will only change the outlet route portion of the URL. This
-                //    is all handled by the InteractionGuard and so the component guards will never run.
-                //
-                // Now we just cancel the current activity...
-                /** @type {?} */
-                const activity = yield this.component.interactionContext.getCurrentActivity();
-                activity.cancel(null);
-                return false; // ..and stay where we are.
+            // If we handled more than just the pop state then it leads to the UI ignoring clicks and just cancelling things which is deeply disconcerting.
+            if (this.navigationState.isPopState) {
+                if (this.isPrimaryComponent && this.interactionService.isModalActive()) {
+                    /** @type {?} */
+                    const routeIds = this.placeRouter.getActiveInteractionIdsFromUrl(nextState.url);
+                    /** @type {?} */
+                    const currentIds = this.interactionService.activeInteractionContextIds.value;
+                    if (!isEqual(currentIds, routeIds)) {
+                        yield this.interactionService.getActiveContext().cancelCurrentActivity();
+                        return currentUrl.updateInteractionIds(this.interactionService.activeInteractionContextIds.value);
+                    }
+                }
+                else {
+                    // check if the component has an in place interaction
+                    if (this.component.interactionContext && this.component.interactionContext.isActive()) {
+                        yield this.component.interactionContext.cancelCurrentActivity();
+                        return currentUrl
+                            .updateInteractionIds(this.interactionService.activeInteractionContextIds.value);
+                    }
+                }
             }
             // Ok, so now we're really leaving, so we ask the component if we should.;
-            if (this.isNotJustAChangeInRouteId(nextState) && this.component.canDeactivate) {
-                // No interaction in progress, so ask the component .
-                // This may start an interaction, hence checking the interaction context before now. I.e. if the place pops up the dialog, and
-                // the user clicks back again, we'll re-enter here and go bang when the component tries to open another dialog.
-                return this.component.canDeactivate(this.navigationSession.interactionContext);
+            if (this.isNotJustAChangeInRouteId(nextState)) {
+                if (this.component.canDeactivate) {
+                    // No interaction in progress, so ask the component .
+                    // This may start an interaction, hence checking the interaction context before now. I.e. if the place pops up the dialog, and
+                    // the user clicks back again, we'll re-enter here and go bang when the component tries to open another dialog.
+                    return this.component.canDeactivate(this.navigationState.interactionContext);
+                }
+                // The component has an active interaction but no deactivation hook.  Rather than guessing what to do
+                // we'll just cancel the navigation and print a warning.
+                if (this.component.interactionContext && this.component.interactionContext.isActive()) {
+                    console.warn('Route changed while component has active interaction, cancelling navigation');
+                    return false;
+                }
             }
             return true;
         });
@@ -2970,7 +3054,9 @@ if (false) {
     /** @type {?} */
     PlaceComponentDeactivationHandler.prototype.component;
     /** @type {?} */
-    PlaceComponentDeactivationHandler.prototype.navigationSession;
+    PlaceComponentDeactivationHandler.prototype.navigationState;
+    /** @type {?} */
+    PlaceComponentDeactivationHandler.prototype.isPrimaryComponent;
 }
 
 /**
@@ -2989,6 +3075,12 @@ class NavigationState extends GarbageCollector {
         this.context = context;
         this._visits = new Map();
     }
+    /**
+     * @return {?}
+     */
+    get name() {
+        return this.constructor.name;
+    }
     /**
      * @return {?}
      */
@@ -3027,6 +3119,14 @@ class NavigationState extends GarbageCollector {
     getVisitFor(placeDef) {
         return this._visits.get(placeDef);
     }
+    /**
+     * @param {?} visit
+     * @param {?} initialUrl
+     * @return {?}
+     */
+    onPlaceNavigationStart(visit, initialUrl) {
+        return this.illegalTransition('onPlaceNavigationStart');
+    }
     /**
      * @param {?} event
      * @return {?}
@@ -3038,28 +3138,28 @@ class NavigationState extends GarbageCollector {
      * @param {?} event
      * @return {?}
      */
-    onStart(event) {
+    onRouterStarted(event) {
         return this.illegalTransition(event);
     }
     /**
      * @param {?} event
      * @return {?}
      */
-    onCancel(event) {
+    onRouterCancelled(event) {
         return this.illegalTransition(event);
     }
     /**
      * @param {?} event
      * @return {?}
      */
-    onError(event) {
+    onRouterError(event) {
         return this.illegalTransition(event);
     }
     /**
      * @param {?} event
      * @return {?}
      */
-    onEnd(event) {
+    onRouterEnd(event) {
         return this.illegalTransition(event);
     }
     /**
@@ -3071,10 +3171,11 @@ class NavigationState extends GarbageCollector {
     }
     /**
      * @param {?} component
-     * @param {?} nextState
+     * @param {?} currentUrl
+     * @param {?} nextUrl
      * @return {?}
      */
-    canDeactivatePlace(component, nextState) {
+    canDeactivatePlace(component, currentUrl, nextUrl) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.illegalTransition('canDeactivatePlace');
         });
@@ -3107,23 +3208,32 @@ class NavigationState extends GarbageCollector {
      * @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());
+            this.interactionService.isActive() ?
+                new NavigationState.InteractionPopStateTransition(this.context, this.currentRouterUrl()) :
+                new NavigationState.PopStateTransition(this.context, this.currentRouterUrl())
+            :
+                this.interactionService.isActive() ?
+                    new NavigationState.InteractionTransition(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
      * @return {?}
      */
     resetBrowserLocation(url) {
-        // TODO: Should this be a navigate operation to avoid confusing the router...??
-        setTimeout((/**
-         * @return {?}
-         */
-        () => this.placeRouter.resetBrowserLocation(url)));
+        this.placeRouter.resetBrowserLocation(url);
     }
     /**
      * @return {?}
@@ -3182,11 +3292,22 @@ if (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 {?}
          */
-        onStart(event) {
+        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}`);
@@ -3223,12 +3344,10 @@ if (false) {
     class AbstractNavigationTransition extends NavigationState {
         /**
          * @param {?} context
-         * @param {?} isPopState
          * @param {?} startingUrl
          */
-        constructor(context, isPopState, startingUrl) {
+        constructor(context, startingUrl) {
             super(context);
-            this.isPopState = isPopState;
             this.startingUrl = startingUrl;
             this.isTransitional = true;
             this.componentDeactivationHandlers = new Map();
@@ -3256,7 +3375,7 @@ if (false) {
          * @param {?} event
          * @return {?}
          */
-        onStart(event) {
+        onRouterStarted(event) {
             // active sessions can have many cancel start cycles due
             // to place guard redirects
             return this;
@@ -3265,7 +3384,7 @@ if (false) {
          * @param {?} event
          * @return {?}
          */
-        onEnd(event) {
+        onRouterEnd(event) {
             // navigation succeeded
             this.context.notifySuccess(this);
             return new Idle(this.context);
@@ -3275,32 +3394,29 @@ if (false) {
          * @return {?}
          */
         onBackClickedDuringNavigationInteraction(locationTriggerUrl) {
-            // detach the interactoin from the session so it doesn't get disposed until the activity
-            // has completed.
+            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 context = this.detachInteractionContext();
-            const { when } = Dsl.disposeWith(context);
+            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.
-            context.getCurrentActivity().then((/**
-             * @param {?} activity
+            //       that would mess things up entirely. Or, can I do a context.abortAll().then(..)
+            navigationInteraction.cancelCurrentActivity().then((/**
              * @return {?}
              */
-            activity => {
-                when.valueOf(context.active).becomesFalsey((/**
-                 * @return {?}
-                 */
-                () => context.dispose()), { once: true });
-                activity.cancel(null);
+            () => {
+                navigationInteraction.dispose();
             }));
-            return new CancelledDuringNavigationInteraction(this.context, this.startingUrl, locationTriggerUrl);
+            return new CancelledDuringNavigationInteraction(this.context, this.startingUrl, this.isPopState, locationTriggerUrl);
         }
+        // @Trace()
         /**
          * @param {?} component
-         * @param {?} nextState
+         * @param {?} currentUrl
+         * @param {?} nextUrl
          * @return {?}
          */
-        canDeactivatePlace(component, nextState) {
+        canDeactivatePlace(component, currentUrl, nextUrl) {
             return __awaiter(this, void 0, void 0, function* () {
                 // lookup the handler and create it if we've not seen it yet
                 /** @type {?} */
@@ -3308,10 +3424,10 @@ if (false) {
                 if (!handler) {
                     /** @type {?} */
                     const isPrimaryHandler = this.componentDeactivationHandlers.size === 0;
-                    handler = new PlaceComponentDeactivationHandler(component, this);
+                    handler = new PlaceComponentDeactivationHandler(component, this, isPrimaryHandler);
                     this.componentDeactivationHandlers.set(component, handler);
                 }
-                return handler.canDeactivate(nextState);
+                return handler.canDeactivate(currentUrl, nextUrl);
             });
         }
         /**
@@ -3340,8 +3456,6 @@ if (false) {
          */
         AbstractNavigationTransition.prototype._interactionContext;
         /** @type {?} */
-        AbstractNavigationTransition.prototype.isPopState;
-        /** @type {?} */
         AbstractNavigationTransition.prototype.startingUrl;
     }
     class NavigationTransition extends AbstractNavigationTransition {
@@ -3353,32 +3467,14 @@ if (false) {
          * @param {?} event
          * @return {?}
          */
-        onStart(event) {
-            // active sessions can have many cancel start cycles due
-            // to place guard redirects
+        onRouterCancelled(event) {
             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) {
+        onRouterError(event) {
             // navigation was aborted.
             return new Idle(this.context);
         }
@@ -3394,7 +3490,7 @@ if (false) {
         /** @type {?} */
         NavigationTransition.prototype.isPopState;
     }
-    class NavigationBackTransition extends AbstractNavigationTransition {
+    class PopStateTransition extends AbstractNavigationTransition {
         constructor() {
             super(...arguments);
             this.isPopState = true;
@@ -3403,7 +3499,7 @@ if (false) {
          * @param {?} event
          * @return {?}
          */
-        onCancel(event) {
+        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');
@@ -3414,7 +3510,7 @@ if (false) {
          * @param {?} event
          * @return {?}
          */
-        onError(event) {
+        onRouterError(event) {
             // navigation was aborted.
             if (this.currentRouterUrl() !== this.startingUrl) {
                 // Angular doesn't preserve the url when a guard cancels the back button.
@@ -3425,15 +3521,12 @@ if (false) {
             return new Idle(this.context);
         }
     }
-    NavigationState.NavigationBackTransition = NavigationBackTransition;
+    NavigationState.PopStateTransition = PopStateTransition;
     if (false) {
         /** @type {?} */
-        NavigationBackTransition.prototype.isPopState;
+        PopStateTransition.prototype.isPopState;
     }
-    /**
-     * @abstract
-     */
-    class AbstractInteractionTransition extends NavigationState {
+    class IdleDuringInteraction extends NavigationState {
         /**
          * @param {?} context
          * @param {?} startingUrl
@@ -3441,18 +3534,68 @@ if (false) {
         constructor(context, startingUrl) {
             super(context);
             this.startingUrl = startingUrl;
-            this.isTransitional = true;
+            this.isTransitional = false;
+            this.isPopState = false;
         }
         /**
-         * @protected
+         * @param {?} visit
+         * @param {?} initialUrl
          * @return {?}
          */
-        reinstateInteractionRoute() {
-            console.log(this.startingUrl);
-            setTimeout((/**
-             * @return {?}
-             */
-            () => this.placeRouter.syncInteractionIdsWithRouter()));
+        onPlaceNavigationStart(visit, initialUrl) {
+            /** @type {?} */
+            const navigationTransition = new InteractionTransition(this.context, initialUrl);
+            navigationTransition.storeVisit(visit);
+            return navigationTransition;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onRouterStarted(event) {
+            return new InteractionTransition(this.context, event.url);
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onPopState(event) {
+            return new InteractionPopStateTransition(this.context, event.url);
+        }
+    }
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [NavigationStart]),
+        __metadata("design:returntype", NavigationState)
+    ], IdleDuringInteraction.prototype, "onRouterStarted", null);
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [NavigationStart]),
+        __metadata("design:returntype", NavigationState)
+    ], IdleDuringInteraction.prototype, "onPopState", null);
+    NavigationState.IdleDuringInteraction = IdleDuringInteraction;
+    if (false) {
+        /** @type {?} */
+        IdleDuringInteraction.prototype.isTransitional;
+        /** @type {?} */
+        IdleDuringInteraction.prototype.isPopState;
+        /** @type {?} */
+        IdleDuringInteraction.prototype.startingUrl;
+    }
+    /**
+     * @abstract
+     */
+    class AbstractInteractionTransition extends AbstractNavigationTransition {
+        /**
+         * @param {?} context
+         * @param {?} startingUrl
+         */
+        constructor(context, startingUrl) {
+            super(context, startingUrl);
+            this.startingUrl = startingUrl;
+            this.isTransitional = true;
         }
     }
     NavigationState.AbstractInteractionTransition = AbstractInteractionTransition;
@@ -3475,9 +3618,31 @@ if (false) {
          * @param {?} event
          * @return {?}
          */
-        onEnd(event) {
+        onRouterCancelled(event) {
+            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()) {
-                this.reinstateInteractionRoute();
                 return new IdleDuringInteraction(this.context, this.startingUrl);
             }
             else {
@@ -3494,7 +3659,7 @@ if (false) {
      * 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 {
+    class InteractionPopStateTransition extends AbstractInteractionTransition {
         constructor() {
             super(...arguments);
             this.isPopState = true;
@@ -3503,107 +3668,87 @@ if (false) {
          * @param {?} event
          * @return {?}
          */
-        onEnd(event) {
+        onRouterCancelled(event) {
             if (this.interactionService.isActive()) {
-                this.reinstateInteractionRoute();
+                /** @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);
             }
         }
-    }
-    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);
+        onRouterEnd(event) {
+            if (this.context.interactionService.isActive()) {
+                return new IdleDuringInteraction(this.context, this.startingUrl);
+            }
+            else {
+                return new Idle(this.context);
+            }
         }
     }
-    NavigationState.IdleDuringInteraction = IdleDuringInteraction;
+    NavigationState.InteractionPopStateTransition = InteractionPopStateTransition;
     if (false) {
         /** @type {?} */
-        IdleDuringInteraction.prototype.isTransitional;
-        /** @type {?} */
-        IdleDuringInteraction.prototype.isPopState;
-        /** @type {?} */
-        IdleDuringInteraction.prototype.startingUrl;
+        InteractionPopStateTransition.prototype.isPopState;
     }
     class CancelledDuringNavigationInteraction extends NavigationState {
         /**
          * @param {?} context
          * @param {?} startingUrl
+         * @param {?} startingEventWasAPopState
          * @param {?} locationChangeTriggerUrl
          */
-        constructor(context, startingUrl, locationChangeTriggerUrl) {
+        constructor(context, startingUrl, startingEventWasAPopState, locationChangeTriggerUrl) {
             super(context);
             this.startingUrl = startingUrl;
+            this.startingEventWasAPopState = startingEventWasAPopState;
             this.locationChangeTriggerUrl = locationChangeTriggerUrl;
             this.isPopState = false;
-            this.capturedFauxRouterStart = false;
+            this.gotPopStateWithLeavingUrl = false;
         }
         /**
          * @return {?}
          */
         get isTransitional() {
-            return !this.capturedFauxRouterStart;
+            return true;
         }
         /**
          * @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);
-            }
+        onRouterStarted(event) {
+            return this.ignore(event);
         }
         /**
          * @param {?} event
          * @return {?}
          */
-        onCancel(event) {
-            return this.ignore(event);
+        onRouterCancelled(event) {
+            // Depending on the state of the router and what was done we get a different
+            // sequence of events.  I.e.  If they just clicked a link we'll get a cancel
+            // with the locationChangeTriggerUrl as the final event. However the user
+            // started the initial navigation with a pop state then we'll get one of
+            // those with the locationChangeTriggerUrl but no cancel event with it.
+            return this.gotPopStateWithLeavingUrl || this.locationChangeTriggerUrl === event.url ? this.createIdleState() : this.ignore(event);
         }
         /**
          * @param {?} event
          * @return {?}
          */
-        onEnd(event) {
+        onRouterEnd(event) {
             return this.ignore(event);
         }
         /**
          * @param {?} event
          * @return {?}
          */
-        onError(event) {
+        onRouterError(event) {
             return this.ignore(event);
         }
         /**
@@ -3611,7 +3756,20 @@ if (false) {
          * @return {?}
          */
         onPopState(event) {
-            return this.createTransitionStateFor(event);
+            this.gotPopStateWithLeavingUrl = this.gotPopStateWithLeavingUrl || event.url === this.locationChangeTriggerUrl;
+            return this.ignore(event);
+        }
+        // @Trace()
+        /**
+         * @param {?} component
+         * @param {?} currentUrl
+         * @param {?} nextUrl
+         * @return {?}
+         */
+        canDeactivatePlace(component, currentUrl, nextUrl) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return false;
+            });
         }
         /**
          * @param {?} event
@@ -3619,7 +3777,7 @@ if (false) {
          * @return {?}
          */
         ignore(event, reason) {
-            reason = reason ? ` (${reason})` : '';
+            reason = reason ? ` -> ${reason}` : '';
             Logger.get(this).info(`ignoring router event${reason}: ${event.constructor.name} -> ${event.url}`);
             return this;
         }
@@ -3627,9 +3785,15 @@ if (false) {
          * @return {?}
          */
         toString() {
-            return `${this.constructor.name}(startingUrl: ${this.startingUrl}, locationChangeTriggerUrl:${this.locationChangeTriggerUrl})`;
+            return `${this.constructor.name}(isIdl: ${this.idle}, startingUrl: ${this.startingUrl}, locationChangeTriggerUrl:${this.locationChangeTriggerUrl})`;
         }
     }
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [NavigationCancel]),
+        __metadata("design:returntype", NavigationState)
+    ], CancelledDuringNavigationInteraction.prototype, "onRouterCancelled", null);
     NavigationState.CancelledDuringNavigationInteraction = CancelledDuringNavigationInteraction;
     if (false) {
         /** @type {?} */
@@ -3638,10 +3802,12 @@ if (false) {
          * @type {?}
          * @private
          */
-        CancelledDuringNavigationInteraction.prototype.capturedFauxRouterStart;
+        CancelledDuringNavigationInteraction.prototype.gotPopStateWithLeavingUrl;
         /** @type {?} */
         CancelledDuringNavigationInteraction.prototype.startingUrl;
         /** @type {?} */
+        CancelledDuringNavigationInteraction.prototype.startingEventWasAPopState;
+        /** @type {?} */
         CancelledDuringNavigationInteraction.prototype.locationChangeTriggerUrl;
     }
 })(NavigationState || (NavigationState = {}));
@@ -3717,21 +3883,24 @@ class UrlSnapshot {
     /**
      * @param {?} urlSerializer
      * @param {?} url
+     * @param {?} options
      */
-    constructor(urlSerializer, url) {
+    constructor(urlSerializer, url, options) {
         this.urlSerializer = urlSerializer;
         this.url = url;
+        this.options = options;
         this.urlTree = urlSerializer.parse(url);
     }
     /**
-     * @protected
      * @param {?} visit
      * @return {?}
      */
-    replaceExistingVisitSegmentsWith(visit) {
+    updateVisitSegments(visit) {
+        /** @type {?} */
+        const urlTree = this.urlSerializer.parse(this.url);
         // Ugly, but it works for now.
         /** @type {?} */
-        const segments = [...this.getPrimarySegments()];
+        const segments = [...this.getPrimarySegments(urlTree)];
         /** @type {?} */
         const visitSegments = this.getSegmentsFor(visit);
         /** @type {?} */
@@ -3742,13 +3911,15 @@ class UrlSnapshot {
         segment => segment.path === visitSegments[0].path));
         // do not use the return value, it's the items that were removed!
         segments.splice(replaceAt, visitSegments.length, ...visitSegments);
-        return segments;
+        urlTree.root.children.primary.segments = segments;
+        return new UrlSnapshot(this.urlSerializer, urlTree.toString(), this.options);
     }
     /**
      * @private
+     * @param {?} urlTree
      * @return {?}
      */
-    getPrimarySegments() {
+    getPrimarySegments(urlTree) {
         return this.urlTree.root.children.primary.segments;
     }
     /**
@@ -3772,81 +3943,92 @@ class UrlSnapshot {
                 ];
     }
     /**
-     * @param {?} visit
+     * @param {?} placeDef
      * @return {?}
      */
-    createRedirectCommandsFor(visit) {
-        /** @type {?} */
-        const segments = this.replaceExistingVisitSegmentsWith(visit);
-        /** @type {?} */
-        const commands = [];
-        segments.forEach((/**
+    includesPathOf(placeDef) {
+        return this.getPrimarySegments(this.urlTree).find((/**
          * @param {?} s
          * @return {?}
          */
-        s => {
-            commands.push(s.path);
-            if (s.parameterMap.keys.length > 0) {
-                commands.push(s.parameters);
-            }
-        }));
-        return commands;
-    }
-    /**
-     * @param {?} placeDef
-     * @return {?}
-     */
-    includesPathOf(placeDef) {
-        return this.getPrimarySegments().find((/**
-         * @param {?} s
-         * @return {?}
-         */
-        s => s.path === placeDef.path));
+        s => s.path === placeDef.path));
     }
     /**
      * @return {?}
      */
     getInteractionIds() {
         /** @type {?} */
-        const interactionOutlet = this.urlTree.root.children[UrlSnapshot.INTERACTION_ROUTER_OUTLET];
-        if (interactionOutlet) {
-            assert.isTruthy(interactionOutlet.segments.length === 2);
-            assert.isTruthy(interactionOutlet.segments[0].path === UrlSnapshot.INTERACTION_ROUTER_PATH);
-            return UrlSnapshot.parseInteractionIds(interactionOutlet.segments[1].path);
+        const queryParam = this.urlTree.queryParams[UrlSnapshot.INTERACTION_QUERY_PARAM];
+        if (queryParam) {
+            return UrlSnapshot.parseInteractionIds(queryParam);
         }
         else {
             return [];
         }
     }
+    /**
+     * @return {?}
+     */
+    hasInteractionIds() {
+        return this.getInteractionIds().length > 0;
+    }
     // @Trace()
     /**
      * @param {?} ids
      * @return {?}
      */
-    addOrReplaceInteractionIds(ids) {
+    updateInteractionIds(ids) {
+        if (ids.length === 0) {
+            return this.removeInteractionIds();
+        }
+        else {
+            /** @type {?} */
+            const urlTree = this.urlSerializer.parse(this.url);
+            urlTree.queryParams[UrlSnapshot.INTERACTION_QUERY_PARAM] = UrlSnapshot.createPathIdFor(ids);
+            return new UrlSnapshot(this.urlSerializer, urlTree.toString(), this.options);
+        }
+    }
+    // @Trace()
+    /**
+     * @return {?}
+     */
+    removeInteractionIds() {
         /** @type {?} */
         const urlTree = this.urlSerializer.parse(this.url);
-        urlTree.root.children[UrlSnapshot.INTERACTION_ROUTER_OUTLET] = new UrlSegmentGroup([
-            new UrlSegment(UrlSnapshot.INTERACTION_ROUTER_PATH, {}),
-            new UrlSegment(UrlSnapshot.createPathIdFor(ids), {})
-        ], {});
-        return new UrlSnapshot(this.urlSerializer, urlTree.toString());
+        if (urlTree.queryParams && urlTree.queryParams[UrlSnapshot.INTERACTION_QUERY_PARAM]) {
+            urlTree.queryParams = {}; //[UrlSnapshot.INTERACTION_ROUTER_OUTLET]
+        }
+        return new UrlSnapshot(this.urlSerializer, urlTree.toString(), this.options);
     }
-}
-if (false) {
     /**
-     * @type {?}
-     * @private
+     * @param {?} options
+     * @return {?}
      */
+    withOptions(options) {
+        return new UrlSnapshot(this.urlSerializer, this.url, options);
+    }
+    /**
+     * @return {?}
+     */
+    getNavigationExtras() {
+        return this.options;
+    }
+}
+if (false) {
+    /** @type {?} */
     UrlSnapshot.prototype.urlTree;
     /** @type {?} */
     UrlSnapshot.prototype.urlSerializer;
     /** @type {?} */
     UrlSnapshot.prototype.url;
+    /**
+     * @type {?}
+     * @private
+     */
+    UrlSnapshot.prototype.options;
 }
 (function (UrlSnapshot) {
-    UrlSnapshot.INTERACTION_ROUTER_OUTLET = 'aup-interactions';
-    UrlSnapshot.INTERACTION_ROUTER_PATH = 'active';
+    UrlSnapshot.INTERACTION_QUERY_PARAM = 'aup-interactions';
     UrlSnapshot.INTERACTION_ID_SEPARATOR = '--';
     /**
      * @param {?} path
@@ -3865,13 +4047,14 @@ if (false) {
     }
     UrlSnapshot.createPathIdFor = createPathIdFor;
     /**
-     * @param {?} interactionIds
-     * @return {?}
+     * @record
      */
-    function createInteractionOutletRouterCommands(interactionIds) {
-        return [UrlSnapshot.INTERACTION_ROUTER_PATH, createPathIdFor(interactionIds)];
+    function NavigationOptions() { }
+    UrlSnapshot.NavigationOptions = NavigationOptions;
+    if (false) {
+        /** @type {?|undefined} */
+        NavigationOptions.prototype.replaceUrl;
     }
-    UrlSnapshot.createInteractionOutletRouterCommands = createInteractionOutletRouterCommands;
 })(UrlSnapshot || (UrlSnapshot = {}));
 
 /**
@@ -3924,7 +4107,6 @@ class PlaceRouter extends GarbageCollector {
             // NavigationStart -> .... -> NavigationError --> navigation aborted, end session.
             // =======================
             if (event instanceof NavigationStart) {
-                console.log(event);
                 if (event.navigationTrigger === 'popstate') {
                     this.runStateTransition((/**
                      * @param {?} state
@@ -3937,7 +4119,7 @@ class PlaceRouter extends GarbageCollector {
                      * @param {?} state
                      * @return {?}
                      */
-                    state => state.onStart(event)));
+                    state => state.onRouterStarted(event)));
                 }
             }
             if (event instanceof NavigationEnd) {
@@ -3946,7 +4128,7 @@ class PlaceRouter extends GarbageCollector {
                  * @param {?} state
                  * @return {?}
                  */
-                state => state.onEnd(event)));
+                state => state.onRouterEnd(event)));
             }
             if (event instanceof NavigationError) {
                 console.log(event);
@@ -3954,7 +4136,7 @@ class PlaceRouter extends GarbageCollector {
                  * @param {?} state
                  * @return {?}
                  */
-                state => state.onError(event)));
+                state => state.onRouterError(event)));
             }
             if (event instanceof NavigationCancel) {
                 console.log(event);
@@ -3962,7 +4144,7 @@ class PlaceRouter extends GarbageCollector {
                  * @param {?} state
                  * @return {?}
                  */
-                state => state.onCancel(event)));
+                state => state.onRouterCancelled(event)));
             }
         }));
         // Push dialog state to the url so we can capture the back button.
@@ -3991,12 +4173,11 @@ class PlaceRouter extends GarbageCollector {
             const navigationState = this._navigationStateModel.value;
             console.log(`URLChange -> ${url}`, { state: navigationState });
             urlChanges.publish({ url, state: navigationState });
-            // We've entered a navigation transition
-            if (navigationState instanceof NavigationState.NavigationTransition) {
+            // The url has changed while we're in a transitional state
+            if (navigationState.isTransitional) {
                 /** @type {?} */
                 const navigationInteraction = this.navigationState.interactionContext;
                 if (navigationInteraction && navigationInteraction.isActive()) {
-                    Logger.get(this).info(`back button pressed during navigation session interaction promise`);
                     this.runStateTransition((/**
                      * @param {?} state
                      * @return {?}
@@ -4086,9 +4267,9 @@ class PlaceRouter extends GarbageCollector {
                  */
                 router => {
                     /** @type {?} */
-                    const commands = this.parseUrl(this.router.routerState.snapshot.url).createRedirectCommandsFor(next);
-                    console.log('### Push Changes to route Redirect', { commands });
-                    return router.navigate(commands);
+                    const urlSnapshot = this.parseUrl(this.router.routerState.snapshot.url).updateVisitSegments(next);
+                    console.log('### Push Changes to route Redirect', { commands: urlSnapshot.url });
+                    return this.navigateByUrl(urlSnapshot);
                 }));
             }
         });
@@ -4109,7 +4290,7 @@ class PlaceRouter extends GarbageCollector {
              */
             current => {
                 /** @type {?} */
-                const session = new NavigationState.NavigationTransition(this._navigationSessionContext, false, this.router.routerState.snapshot.url);
+                const session = this.navigationState.onPlaceNavigationStart(visit, this.getCurrentRouterUrl());
                 session.storeVisit(visit);
                 return session;
             }));
@@ -4124,11 +4305,12 @@ class PlaceRouter extends GarbageCollector {
                      * @param {?} session
                      * @return {?}
                      */
-                    session => session.onEnd(new NavigationEnd(-1, '', ''))));
+                    session => session.onRouterEnd(new NavigationEnd(-1, '', ''))));
                 }
             }
         });
     }
+    // @Trace()
     /**
      * @protected
      * @param {?} transition
@@ -4173,7 +4355,7 @@ class PlaceRouter extends GarbageCollector {
      * @return {?}
      */
     parseUrl(url) {
-        return new UrlSnapshot(this.urlSerializer, url);
+        return new UrlSnapshot(this.urlSerializer, url, {});
     }
     /**
      * @param {?} url
@@ -4188,6 +4370,12 @@ class PlaceRouter extends GarbageCollector {
     getCurrentRouterUrl() {
         return this.router.routerState ? this.router.routerState.snapshot.url : null;
     }
+    /**
+     * @return {?}
+     */
+    getCurrentRouteSnapshot() {
+        return this.parseUrl(this.getCurrentRouterUrl());
+    }
     /**
      * @param {?} url
      * @return {?}
@@ -4203,6 +4391,15 @@ class PlaceRouter extends GarbageCollector {
     hasActiveInteractionIds(url) {
         return this.getActiveInteractionIdsFromUrl(url).length > 0;
     }
+    // @Trace()
+    /**
+     * @param {?} urlSnapshot
+     * @return {?}
+     */
+    navigateByUrl(urlSnapshot) {
+        this.router.navigateByUrl(urlSnapshot.urlTree, urlSnapshot.getNavigationExtras());
+    }
+    // @Trace()
     /**
      * @return {?}
      */
@@ -4216,22 +4413,12 @@ class PlaceRouter extends GarbageCollector {
         }
         else {
             if (currentIds.length < 1) {
-                this.router.navigate(['.', {
-                        outlets: {
-                            [UrlSnapshot.INTERACTION_ROUTER_OUTLET]: null
-                        }
-                    }], {
-                    replaceUrl: true // remove the interaction from the history.
-                });
+                // no more interactions to remove from history.
+                this.navigateByUrl(this.getCurrentRouteSnapshot().removeInteractionIds());
             }
             else {
-                /** @type {?} */
-                const urlSnapshot = this.parseUrl(this.getCurrentRouterUrl());
-                this.router.navigate(['.', {
-                        outlets: {
-                            [UrlSnapshot.INTERACTION_ROUTER_OUTLET]: UrlSnapshot.createInteractionOutletRouterCommands(currentIds)
-                        }
-                    }]);
+                // todo was or is...
+                this.navigateByUrl(this.getCurrentRouteSnapshot().updateInteractionIds(currentIds));
             }
         }
     }
@@ -4250,12 +4437,6 @@ PlaceRouter.ctorParameters = () => [
     { type: InteractionService }
 ];
 /** @nocollapse */ PlaceRouter.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(ɵɵinject(Router), ɵɵinject(UrlSerializer), ɵɵinject(Location), ɵɵinject(PlaceHistory), ɵɵinject(InteractionService)); }, token: PlaceRouter, providedIn: "root" });
-__decorate([
-    Trace(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], PlaceRouter.prototype, "syncInteractionIdsWithRouter", null);
 if (false) {
     /**
      * @type {?}
@@ -5623,7 +5804,7 @@ function Place(options) {
      */
     (target) => {
         if (PlaceComponent.isPlaceComponentConstructor(target)) {
-            PlaceComponent.injectDefinition(target, new PlaceDefinition(target, options.path, isNil(options.authenticate) ? false : options.authenticate, options.data, PlaceComponent.getRouteParameters(target), (options.children || []).map((/**
+            PlaceComponent.injectDefinition(target, new PlaceDefinition(target, options.path, isNil(options.authenticate) ? true : options.authenticate, options.data, PlaceComponent.getRouteParameters(target), (options.children || []).map((/**
              * @param {?} c
              * @return {?}
              */
@@ -5654,93 +5835,6 @@ function Place(options) {
     }
 })(Place || (Place = {}));
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class VisitSanitiser {
-    /**
-     * @param {?} activatedRoute
-     * @param {?} router
-     * @param {?} placeHistory
-     * @param {?} injector
-     */
-    constructor(activatedRoute, router, placeHistory, injector) {
-        this.activatedRoute = activatedRoute;
-        this.router = router;
-        this.placeHistory = placeHistory;
-        this.injector = injector;
-    }
-    // @Trace()
-    /**
-     * @param {?} visit
-     * @return {?}
-     */
-    sanitise(visit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            /** @type {?} */
-            const placeDef = visit.placeDefinition;
-            if (placeDef.hasRouteId()) {
-                /** @type {?} */
-                const routeIdDef = placeDef.getRouteIdParameterDef();
-                /** @type {?} */
-                const routeId = visit.getRouteId();
-                /** @type {?} */
-                const sanitisedValue = yield routeIdDef.sanitise(routeId, visit, this.placeHistory, this.injector);
-                // console.log({routeId, sanitisedValue});
-                // ###------- EARLY EXIT --------###
-                if (routeIdDef.hasChanged(routeId, sanitisedValue)) {
-                    // if the route id has changed we redirect immediately as other
-                    // parameter sanitisers might use it.
-                    return visit.replace(routeIdDef, sanitisedValue);
-                }
-            }
-            // if we didn't replace the routeId we continue the url present parameters.
-            /** @type {?} */
-            const parameterDefs = placeDef.getVisitParameterDefs({
-                includeRouteParameters: true,
-                includeNonRouteParameters: true
-            });
-            /** @type {?} */
-            let sanitisedVisit = visit;
-            for (let i = 0; i < parameterDefs.length; i++) {
-                /** @type {?} */
-                const def = parameterDefs[i];
-                /** @type {?} */
-                const value = visit.getParameter(def.name);
-                /** @type {?} */
-                const sanitisedValue = yield def.sanitise(value, sanitisedVisit, this.placeHistory, this.injector);
-                if (def.hasChanged(value, sanitisedValue)) {
-                    sanitisedVisit = sanitisedVisit.replace(def, sanitisedValue);
-                }
-            }
-            return sanitisedVisit.hasChangedFrom(visit) ? sanitisedVisit : visit;
-        });
-    }
-}
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    VisitSanitiser.prototype.activatedRoute;
-    /**
-     * @type {?}
-     * @private
-     */
-    VisitSanitiser.prototype.router;
-    /**
-     * @type {?}
-     * @private
-     */
-    VisitSanitiser.prototype.placeHistory;
-    /**
-     * @type {?}
-     * @private
-     */
-    VisitSanitiser.prototype.injector;
-}
-
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -5872,6 +5966,120 @@ if (false) {
     ParamMapAdapter.prototype.params;
 }
 
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class NoopAuthGuard {
+    constructor() {
+    }
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    canActivate(activatedRoute, state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+NoopAuthGuard.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+NoopAuthGuard.ctorParameters = () => [];
+/** @nocollapse */ NoopAuthGuard.ngInjectableDef = ɵɵdefineInjectable({ factory: function NoopAuthGuard_Factory() { return new NoopAuthGuard(); }, token: NoopAuthGuard, providedIn: "root" });
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class VisitSanitiser {
+    /**
+     * @param {?} activatedRoute
+     * @param {?} router
+     * @param {?} placeHistory
+     * @param {?} injector
+     */
+    constructor(activatedRoute, router, placeHistory, injector) {
+        this.activatedRoute = activatedRoute;
+        this.router = router;
+        this.placeHistory = placeHistory;
+        this.injector = injector;
+    }
+    // @Trace()
+    /**
+     * @param {?} visit
+     * @return {?}
+     */
+    sanitise(visit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            /** @type {?} */
+            const placeDef = visit.placeDefinition;
+            if (placeDef.hasRouteId()) {
+                /** @type {?} */
+                const routeIdDef = placeDef.getRouteIdParameterDef();
+                /** @type {?} */
+                const routeId = visit.getRouteId();
+                /** @type {?} */
+                const sanitisedValue = yield routeIdDef.sanitise(routeId, visit, this.placeHistory, this.injector);
+                // console.log({routeId, sanitisedValue});
+                // ###------- EARLY EXIT --------###
+                if (routeIdDef.hasChanged(routeId, sanitisedValue)) {
+                    // if the route id has changed we redirect immediately as other
+                    // parameter sanitisers might use it.
+                    return visit.replace(routeIdDef, sanitisedValue);
+                }
+            }
+            // if we didn't replace the routeId we continue the url present parameters.
+            /** @type {?} */
+            const parameterDefs = placeDef.getVisitParameterDefs({
+                includeRouteParameters: true,
+                includeNonRouteParameters: true
+            });
+            /** @type {?} */
+            let sanitisedVisit = visit;
+            for (let i = 0; i < parameterDefs.length; i++) {
+                /** @type {?} */
+                const def = parameterDefs[i];
+                /** @type {?} */
+                const value = visit.getParameter(def.name);
+                /** @type {?} */
+                const sanitisedValue = yield def.sanitise(value, sanitisedVisit, this.placeHistory, this.injector);
+                if (def.hasChanged(value, sanitisedValue)) {
+                    sanitisedVisit = sanitisedVisit.replace(def, sanitisedValue);
+                }
+            }
+            return sanitisedVisit.hasChangedFrom(visit) ? sanitisedVisit : visit;
+        });
+    }
+}
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    VisitSanitiser.prototype.activatedRoute;
+    /**
+     * @type {?}
+     * @private
+     */
+    VisitSanitiser.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    VisitSanitiser.prototype.placeHistory;
+    /**
+     * @type {?}
+     * @private
+     */
+    VisitSanitiser.prototype.injector;
+}
+
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -5879,19 +6087,21 @@ if (false) {
 /**
  * @abstract
  */
-class AbstractPlaceGuard {
+class PlaceGuard {
     /**
      * @param {?} router
      * @param {?} urlSerializer
      * @param {?} placeRouter
      * @param {?} placeHistory
+     * @param {?} interactionService
      * @param {?} injector
      */
-    constructor(router, urlSerializer, placeRouter, placeHistory, injector) {
+    constructor(router, urlSerializer, placeRouter, placeHistory, interactionService, injector) {
         this.router = router;
         this.urlSerializer = urlSerializer;
         this.placeRouter = placeRouter;
         this.placeHistory = placeHistory;
+        this.interactionService = interactionService;
         this.injector = injector;
     }
     // @Trace()
@@ -5902,40 +6112,47 @@ class AbstractPlaceGuard {
      */
     canActivate(activatedRoute, state) {
         return __awaiter(this, void 0, void 0, function* () {
+            // TODO: this is ugly now that I'm return UrlSnapshots and not UrlTrees.  It'd be better if the functions
+            //        weren't nested or if I implemented a handler chain.
             return this.authorisePlaceThen(activatedRoute, state, (/**
              * @param {?} placeDefinition
              * @return {?}
              */
             (placeDefinition) => __awaiter(this, void 0, void 0, function* () {
-                // Parse our route params.
-                /** @type {?} */
-                const params = new ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);
-                /** @type {?} */
-                const parsedParams = placeDefinition.parseRouteParams(params);
-                /** @type {?} */
-                const initialVisit = this.placeRouter.navigationState.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);
                 /** @type {?} */
-                const sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);
-                /** @type {?} */
-                const sanitisedVisit = yield sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams));
-                // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters
-                this.placeRouter.navigationState.storeVisit(sanitisedVisit);
-                if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {
-                    // Regenerate the url
+                const result = yield this.cleanInteractionState(activatedRoute, state, (/**
+                 * @return {?}
+                 */
+                () => __awaiter(this, void 0, void 0, function* () {
+                    // Parse our route params.
                     /** @type {?} */
-                    const commands = this.placeRouter.parseUrl(state.url).createRedirectCommandsFor(sanitisedVisit);
-                    console.log('##### Place Guard Redirect', commands);
-                    return this.router.createUrlTree(commands, {
-                        replaceUrl: true,
-                        skipLocationChange: false
-                    });
-                }
-                else {
-                    return true;
-                }
+                    const params = new ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);
+                    /** @type {?} */
+                    const parsedParams = placeDefinition.parseRouteParams(params);
+                    /** @type {?} */
+                    const initialVisit = this.placeRouter.navigationState.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);
+                    /** @type {?} */
+                    const sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);
+                    /** @type {?} */
+                    const sanitisedVisit = yield sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams));
+                    // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters
+                    this.placeRouter.navigationState.storeVisit(sanitisedVisit);
+                    if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {
+                        // Regenerate the url
+                        /** @type {?} */
+                        const urlSnapshot = this.placeRouter.parseUrl(state.url).updateVisitSegments(sanitisedVisit);
+                        console.log('##### Place Guard Redirect', urlSnapshot);
+                        return urlSnapshot;
+                    }
+                    else {
+                        return true;
+                    }
+                })));
+                return this.handleGuardResult(result);
             })));
         });
     }
+    // @Trace()
     /**
      * @param {?} component
      * @param {?} currentRoute
@@ -5945,9 +6162,28 @@ class AbstractPlaceGuard {
      */
     canDeactivate(component, currentRoute, currentState, nextState) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.placeRouter.navigationState.canDeactivatePlace(component, this.placeRouter.parseUrl(nextState.url));
+            /** @type {?} */
+            const currentUrl = this.placeRouter.parseUrl(currentState.url);
+            /** @type {?} */
+            const nextUrl = this.placeRouter.parseUrl(nextState.url);
+            /** @type {?} */
+            const result = yield this.placeRouter.navigationState.canDeactivatePlace(component, currentUrl, nextUrl);
+            return this.handleGuardResult(result);
         });
     }
+    /**
+     * @private
+     * @param {?} result
+     * @return {?}
+     */
+    handleGuardResult(result) {
+        if (result instanceof UrlSnapshot) {
+            return result.urlTree;
+        }
+        else {
+            return result;
+        }
+    }
     // @Trace()
     /**
      * @protected
@@ -5977,6 +6213,7 @@ class AbstractPlaceGuard {
             }
         });
     }
+    // @Trace()
     /**
      * @param {?} activatedRoute
      * @param {?} state
@@ -5989,181 +6226,66 @@ class AbstractPlaceGuard {
             return (authorised instanceof Observable) ? authorised.toPromise() : authorised;
         });
     }
-}
-__decorate([
-    Trace(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [ActivatedRouteSnapshot, RouterStateSnapshot]),
-    __metadata("design:returntype", Promise)
-], AbstractPlaceGuard.prototype, "isAuthorised", null);
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    AbstractPlaceGuard.prototype.router;
-    /**
-     * @type {?}
-     * @private
-     */
-    AbstractPlaceGuard.prototype.urlSerializer;
-    /**
-     * @type {?}
-     * @private
-     */
-    AbstractPlaceGuard.prototype.placeRouter;
-    /**
-     * @type {?}
-     * @private
-     */
-    AbstractPlaceGuard.prototype.placeHistory;
-    /**
-     * @type {?}
-     * @private
-     */
-    AbstractPlaceGuard.prototype.injector;
-    /**
-     * @abstract
-     * @param {?} injector
-     * @return {?}
-     */
-    AbstractPlaceGuard.prototype.getAuthGuard = function (injector) { };
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class InteractionGuard {
-    /**
-     * @param {?} router
-     * @param {?} injector
-     * @param {?} placeRouter
-     * @param {?} angularLocation
-     * @param {?} interactionService
-     */
-    constructor(router, injector, placeRouter, angularLocation, interactionService) {
-        this.router = router;
-        this.injector = injector;
-        this.placeRouter = placeRouter;
-        this.angularLocation = angularLocation;
-        this.interactionService = interactionService;
-    }
+    // @Trace()
     /**
      * @param {?} route
      * @param {?} state
+     * @param {?} then
      * @return {?}
      */
-    canActivate(route, state) {
-        /** @type {?} */
-        const url = this.router.parseUrl(state.url);
-        if (!this.interactionService.isActive() && url.root.children[UrlSnapshot.INTERACTION_ROUTER_OUTLET]) {
-            // This happens if we reload the page or the url was pasted as the route should only be activated
-            // after the interaction context has become active.
-            delete url.root.children[UrlSnapshot.INTERACTION_ROUTER_OUTLET];
-            return url;
-        }
-        else {
-            return true;
-        }
-    }
-    /**
-     * @param {?} component
-     * @param {?} currentRoute
-     * @param {?} currentState
-     * @param {?=} nextState
-     * @return {?}
-     */
-    canDeactivate(component, currentRoute, currentState, nextState) {
+    cleanInteractionState(route, state, then) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.interactionService.isActive()) {
-                /** @type {?} */
-                const currentIds = this.interactionService.activeInteractionContextIds.value;
-                /** @type {?} */
-                const routeIds = this.placeRouter.getActiveInteractionIdsFromUrl(nextState.url);
-                if (!isEqual(currentIds, routeIds)) {
-                    // The activity is still active so the route change was triggered by the back button.
-                    /** @type {?} */
-                    const activity = yield this.interactionService.getCurrentActivity();
-                    activity.cancel();
-                }
+            /** @type {?} */
+            const url = this.placeRouter.parseUrl(state.url);
+            if (!this.interactionService.isActive() && url.hasInteractionIds()) {
+                // This happens if we reload the page or the url was pasted as the route should only be activated
+                // after the interaction context has become active.
+                return url.removeInteractionIds();
+            }
+            else {
+                return then();
             }
-            // IMPORTANT:
-            // We always return true, the router state engine will redirect as required.  Return false
-            // during the guard causes all kinds of grief.  It might be worth trying a redirect here
-            // again now that our state engine is more thorough.
-            return true;
         });
     }
 }
-InteractionGuard.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
-/** @nocollapse */
-InteractionGuard.ctorParameters = () => [
-    { type: Router },
-    { type: Injector },
-    { type: PlaceRouter },
-    { type: Location },
-    { type: InteractionService }
-];
-/** @nocollapse */ InteractionGuard.ngInjectableDef = ɵɵdefineInjectable({ factory: function InteractionGuard_Factory() { return new InteractionGuard(ɵɵinject(Router), ɵɵinject(INJECTOR), ɵɵinject(PlaceRouter), ɵɵinject(Location), ɵɵinject(InteractionService)); }, token: InteractionGuard, providedIn: "root" });
 if (false) {
     /**
      * @type {?}
      * @private
      */
-    InteractionGuard.prototype.router;
+    PlaceGuard.prototype.router;
     /**
      * @type {?}
      * @private
      */
-    InteractionGuard.prototype.injector;
+    PlaceGuard.prototype.urlSerializer;
     /**
      * @type {?}
      * @private
      */
-    InteractionGuard.prototype.placeRouter;
+    PlaceGuard.prototype.placeRouter;
     /**
      * @type {?}
      * @private
      */
-    InteractionGuard.prototype.angularLocation;
+    PlaceGuard.prototype.placeHistory;
     /**
      * @type {?}
      * @private
      */
-    InteractionGuard.prototype.interactionService;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class NoopAuthGuard {
-    constructor() {
-    }
+    PlaceGuard.prototype.interactionService;
     /**
-     * @param {?} activatedRoute
-     * @param {?} state
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.injector;
+    /**
+     * @abstract
+     * @param {?} injector
      * @return {?}
      */
-    canActivate(activatedRoute, state) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return true;
-        });
-    }
+    PlaceGuard.prototype.getAuthGuard = function (injector) { };
 }
-NoopAuthGuard.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
-/** @nocollapse */
-NoopAuthGuard.ctorParameters = () => [];
-/** @nocollapse */ NoopAuthGuard.ngInjectableDef = ɵɵdefineInjectable({ factory: function NoopAuthGuard_Factory() { return new NoopAuthGuard(); }, token: NoopAuthGuard, providedIn: "root" });
 
 /**
  * @fileoverview added by tsickle
@@ -6412,5 +6534,5 @@ if (false) {
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
-export { ACTIVITY_DATA, AUP_PLACE_CONFIG, AbstractActivity, AbstractInputComponent, AbstractPlaceGuard, AbstractPlaceNavigationComponent, Activity, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, AngularUiPowerupsModule, Bounds, BusyOverlayComponent, CommandDirective, ComponentsModule, ConfirmThenDialogComponent, ConfirmationDialogComponent, ConsolidatedParameterMap, DEFINITION_META_DATA_KEY, DIALOG_INTERACTION_SERVICE_DEFAULTS, DialogInteractionContext, DialogInteractionContextFactory, Dimension, DirectivesModule, DisposableComponent, EmptyStateComponent, FocusBindingDirective, Formatter, InplaceInteractionContextComponent, InteractionContext, InteractionContextBase, InteractionGuard, InteractionModule, InteractionOutletComponent, InteractionService, LEFT_RIGHT_PLACE_ANIMATION, ListPlaceNavComponent, ModalInteractionContextFactory, NavigationState, NoopAuthGuard, NoopComponent, NumberInputComponent, ParameterDefinition, PasswordInputComponent, Place, PlaceComponent, PlaceComponentDeactivationHandler, PlaceDefinition, PlaceHistory, PlaceModule, PlaceOutletComponent, PlaceRouter, Point, ROUTE_PARAMETER_LIST_KEY, ResizeAwareComponent, RouteId, SelectInputComponent, StringInputComponent, TabbedPlaceNavigationComponent, UrlSnapshot, Visit, VisitParameter, VisitParameterList, VisitSanitiser, leftRightPlaceAnimation, slideDownAndUpAnimation, DirectivesModule as ɵa, CommandDirective as ɵb, InteractionModule as ɵba, ActivityContainerComponent as ɵbb, InteractionContextBase as ɵbc, InteractionContext as ɵbd, ActivityOutletComponent as ɵbe, ConfirmationDialogComponent as ɵbf, AbstractActivity as ɵbg, ACTIVITY_DATA as ɵbh, Activity as ɵbi, ConfirmThenDialogComponent as ɵbk, AlertDialogComponent as ɵbl, InteractionOutletComponent as ɵbn, InplaceInteractionContextComponent as ɵbo, FocusBindingDirective as ɵc, DisposableComponent as ɵd, ComponentsModule as ɵe, NumberInputComponent as ɵf, AbstractInputComponent as ɵg, StringInputComponent as ɵh, PasswordInputComponent as ɵi, SelectInputComponent as ɵj, NoopComponent as ɵk, PlaceModule as ɵl, EmptyStateComponent as ɵm, BusyOverlayComponent as ɵn, PlaceOutletComponent as ɵo, leftRightPlaceAnimation as ɵp, LEFT_RIGHT_PLACE_ANIMATION as ɵq, AUP_PLACE_CONFIG as ɵr, PlaceRouter as ɵt, PlaceHistory as ɵu, InteractionService as ɵv, ModalInteractionContextFactory as ɵw, TabbedPlaceNavigationComponent as ɵx, AbstractPlaceNavigationComponent as ɵy, ListPlaceNavComponent as ɵz };
+export { ACTIVITY_DATA, AUP_PLACE_CONFIG, AbstractActivity, AbstractInputComponent, AbstractPlaceNavigationComponent, Activity, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, AngularUiPowerupsModule, Bounds, BusyOverlayComponent, CommandDirective, ComponentsModule, ConfirmThenDialogComponent, ConfirmationDialogComponent, ConsolidatedParameterMap, DEFINITION_META_DATA_KEY, DIALOG_INTERACTION_SERVICE_DEFAULTS, DialogInteractionContext, DialogInteractionContextFactory, Dimension, DirectivesModule, DisposableComponent, EmptyStateComponent, FocusBindingDirective, Formatter, InplaceInteractionContextComponent, InteractionContext, InteractionContextBase, InteractionModule, InteractionService, LEFT_RIGHT_PLACE_ANIMATION, ListPlaceNavComponent, ModalInteractionContextFactory, NavigationState, NoopAuthGuard, NoopComponent, NumberInputComponent, ParameterDefinition, PasswordInputComponent, Place, PlaceComponent, PlaceComponentDeactivationHandler, PlaceDefinition, PlaceGuard, PlaceHistory, PlaceModule, PlaceOutletComponent, PlaceRouter, Point, ROUTE_PARAMETER_LIST_KEY, ResizeAwareComponent, RouteId, SelectInputComponent, StringInputComponent, TabbedPlaceNavigationComponent, UrlSnapshot, Visit, VisitParameter, VisitParameterList, VisitSanitiser, leftRightPlaceAnimation, slideDownAndUpAnimation, DirectivesModule as ɵa, CommandDirective as ɵb, InteractionModule as ɵba, ActivityContainerComponent as ɵbb, InteractionContextBase as ɵbc, InteractionContext as ɵbd, ActivityOutletComponent as ɵbe, ConfirmationDialogComponent as ɵbf, AbstractActivity as ɵbg, ACTIVITY_DATA as ɵbh, Activity as ɵbi, ConfirmThenDialogComponent as ɵbk, AlertDialogComponent as ɵbl, InplaceInteractionContextComponent as ɵbn, FocusBindingDirective as ɵc, DisposableComponent as ɵd, ComponentsModule as ɵe, NumberInputComponent as ɵf, AbstractInputComponent as ɵg, StringInputComponent as ɵh, PasswordInputComponent as ɵi, SelectInputComponent as ɵj, NoopComponent as ɵk, PlaceModule as ɵl, EmptyStateComponent as ɵm, BusyOverlayComponent as ɵn, PlaceOutletComponent as ɵo, leftRightPlaceAnimation as ɵp, LEFT_RIGHT_PLACE_ANIMATION as ɵq, AUP_PLACE_CONFIG as ɵr, PlaceRouter as ɵt, PlaceHistory as ɵu, InteractionService as ɵv, ModalInteractionContextFactory as ɵw, TabbedPlaceNavigationComponent as ɵx, AbstractPlaceNavigationComponent as ɵy, ListPlaceNavComponent as ɵz };
 //# sourceMappingURL=coolon-angular-ui-powerups.js.map