@coolon/angular-ui-powerups 0.0.98 → 0.0.101

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

@@ -1,16 +1,15 @@
 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 { FormsModule } from '@angular/forms';
-import { MatInputModule, MatFormFieldModule, MatSelectModule, MatDialog, MatButtonModule, MatDialogModule, MatTabsModule as MatTabsModule$1, MatProgressSpinnerModule } from '@angular/material';
+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, EventListenerList, DelegatingListModel, Deferred, MutableStream, MutableValueModel, MutableListModel, Binding, Trace, Guard as Guard$1, StoreInValueModel, Command, OptionsHelper, ValueHolder } from '@coolon/pectin';
+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 { __decorate, __metadata, __awaiter } from 'tslib';
 import { PortalModule } from '@angular/cdk/portal';
-import { RouterModule, NavigationStart, NavigationCancel, NavigationError, NavigationEnd, UrlSegment, Router, UrlSerializer, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { RouterModule, UrlSegment, UrlSegmentGroup, NavigationStart, NavigationEnd, NavigationError, NavigationCancel, Router, UrlSerializer, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
 import ___default, { last, isNil, isEqual } from 'lodash';
 import { assert as assert$1, Opts, Klass } from '@coolon/typescript-utilities';
-import { MatDialogConfig, MatDialog as MatDialog$1, MAT_DIALOG_DEFAULT_OPTIONS } from '@angular/material/dialog';
 import { MatIconModule } from '@angular/material/icon';
 import { MatListModule } from '@angular/material/list';
 import { MatTooltipModule } from '@angular/material/tooltip';
@@ -19,6 +18,7 @@ import { Memoize as Memoize$1 } from '@typescript-plus/fast-memoize-decorator';
 import 'reflect-metadata';
 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';
 import { Observable } from 'rxjs';
 
 /**
@@ -896,10 +896,6 @@ if (false) {
  * @abstract
  */
 class InteractionContext extends GarbageCollector {
-    constructor() {
-        super(...arguments);
-        this.activityListeners = new EventListenerList();
-    }
     /**
      * Returns true if an activity is currently running.
      * @return {?}
@@ -908,41 +904,16 @@ class InteractionContext extends GarbageCollector {
         return this.active.value;
     }
     /**
-     * @param {?} listener
-     * @return {?}
-     */
-    addActivityListener(listener) {
-        return this.activityListeners.add(listener);
-    }
-    /**
-     * @protected
-     * @return {?}
-     */
-    notifyActivityStarted() {
-        this.activityListeners.fire((/**
-         * @param {?} l
-         * @return {?}
-         */
-        l => l.onActivityStarted()));
-    }
-    /**
-     * @protected
      * @return {?}
      */
-    notifyActivityFinished() {
-        this.activityListeners.fire((/**
-         * @param {?} l
-         * @return {?}
-         */
-        l => l.onActivityFinished()));
+    dispose() {
+        // TODO: think about auto cancelling any outstanding activity on dispose.
+        //       See NavigationState.Navigating for a use-case.
+        assert.isFalsey(this.isActive());
+        super.dispose();
     }
 }
 if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    InteractionContext.prototype.activityListeners;
     /** @type {?} */
     InteractionContext.prototype.activityList;
     /** @type {?} */
@@ -991,23 +962,6 @@ if (false) {
      */
     InteractionContext.prototype.confirmThen = function (confirm, activityType, data) { };
 }
-(function (InteractionContext) {
-    /**
-     * @record
-     */
-    function Listener() { }
-    InteractionContext.Listener = Listener;
-    if (false) {
-        /**
-         * @return {?}
-         */
-        Listener.prototype.onActivityStarted = function () { };
-        /**
-         * @return {?}
-         */
-        Listener.prototype.onActivityFinished = function () { };
-    }
-})(InteractionContext || (InteractionContext = {}));
 
 /**
  * @fileoverview added by tsickle
@@ -1480,6 +1434,12 @@ class TabContext {
         this._complete = true;
         this.activityCallbacks.onCancel(error);
     }
+    /**
+     * @return {?}
+     */
+    dispose() {
+        this.component.dispose();
+    }
 }
 if (false) {
     /**
@@ -1562,9 +1522,6 @@ class ActivityContainerComponent extends InteractionContextBase {
     get initialActivityOutletContext() {
         return this._initialActivityOutletContext.value;
     }
-    // get isFinished() {
-    //   return !this._initialActivityOutletContext;
-    // }
     /**
      * @return {?}
      */
@@ -1651,12 +1608,23 @@ class ActivityContainerComponent extends InteractionContextBase {
      */
     cleanupStaleNestedActivities() {
         if (this.tabs.selectedIndex < this.activityTabs.length - 1) {
+            /** @type {?} */
+            const tabs = this.activityTabs.value;
+            /** @type {?} */
+            const remainingActivities = tabs.slice(0, 1 + this.tabs.selectedIndex);
+            /** @type {?} */
+            const finishedActivityTabs = tabs.slice(1 + this.tabs.selectedIndex);
+            finishedActivityTabs.forEach((/**
+             * @param {?} a
+             * @return {?}
+             */
+            a => a.dispose()));
             this.activityTabs.runInTransaction((/**
              * @param {?} draft
              * @return {?}
              */
             draft => {
-                draft.value = draft.value.slice(0, 1 + this.tabs.selectedIndex);
+                draft.value = remainingActivities;
             }));
         }
     }
@@ -1757,6 +1725,244 @@ if (false) {
     ActivityContainerComponent.prototype._activityList;
 }
 
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @abstract
+ */
+class ModalInteractionContextFactory {
+}
+if (false) {
+    /**
+     * @abstract
+     * @return {?}
+     */
+    ModalInteractionContextFactory.prototype.createInteractionContext = function () { };
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @type {?} */
+let inplaceMonitorCount = 0;
+class InteractionService {
+    /**
+     * @param {?} modelInteractionContextFactory
+     */
+    constructor(modelInteractionContextFactory) {
+        this.modelInteractionContextFactory = modelInteractionContextFactory;
+        this.garbage = new GarbageCollector();
+        this.exclusiveContext = new MutableValueModel();
+        this._activeModalInteractionContextModel = new MutableValueModel();
+        this._activeInlineInteractionContextModel = new MutableValueModel();
+        const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this.garbage);
+        this._activeInteractionContext = chain(this._activeModalInteractionContextModel)
+            .otherwise(this._activeInlineInteractionContextModel)
+            .pluck('interactionContext');
+        this.active = chain(this._activeInteractionContext).isNotNil();
+        this.modelInteractionActive = chain(this._activeModalInteractionContextModel).isNotNil();
+        this.inlineInteractionActive = chain(this._activeInlineInteractionContextModel).isNotNil();
+        // TODO: chain.concat(listOrValueModels) would be nice.
+        this.activeInteractionContextIds = chain(new MutableListModel())
+            .append(this._activeInlineInteractionContextModel)
+            .append(this._activeModalInteractionContextModel)
+            .rejectNil()
+            .pluck('id');
+    }
+    /**
+     * @return {?}
+     */
+    isActive() {
+        return this.active.value;
+    }
+    /**
+     * @param {?} disposable
+     * @return {?}
+     */
+    createModalInteractionContextFor(disposable) {
+        /** @type {?} */
+        const context = this.modelInteractionContextFactory.createInteractionContext();
+        disposable.registerDisposable(new InteractionService.Monitor('modal', context, this._activeModalInteractionContextModel, this.exclusiveContext));
+        return context;
+    }
+    /**
+     * @param {?} interactionContext
+     * @return {?}
+     */
+    _registerInplaceInteractionContext(interactionContext) {
+        interactionContext.registerDisposable(new InteractionService.Monitor(`ip${++inplaceMonitorCount}`, interactionContext, this._activeInlineInteractionContextModel, this.exclusiveContext));
+    }
+    /**
+     * @return {?}
+     */
+    getCurrentActivity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert$1.isTruthy(this.isActive());
+            return this._activeInteractionContext.value.getCurrentActivity();
+        });
+    }
+    /**
+     * Creates an interaction context that will prevent any other contexts from starting an
+     * activity until it is disposed.  This is intended for use by the router for passing
+     * to PlaceComponent.canDeactivate(interactionContext).  This ensures components don't
+     * try and interact in a way that we can't track and synchronise with the browser back
+     * button.
+     * @return {?}
+     */
+    _createExclusiveModalInteractionContext() {
+        this.exclusiveContext.value = this.modelInteractionContextFactory.createInteractionContext();
+        /** @type {?} */
+        const self = this;
+        this.exclusiveContext.value.registerDisposable({
+            /**
+             * @return {?}
+             */
+            dispose() {
+                self.exclusiveContext.value = null;
+            }
+        });
+        return this.exclusiveContext.value;
+    }
+}
+InteractionService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+InteractionService.ctorParameters = () => [
+    { type: ModalInteractionContextFactory }
+];
+/** @nocollapse */ InteractionService.ngInjectableDef = ɵɵdefineInjectable({ factory: function InteractionService_Factory() { return new InteractionService(ɵɵinject(ModalInteractionContextFactory)); }, token: InteractionService, providedIn: "root" });
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionService.prototype.garbage;
+    /** @type {?} */
+    InteractionService.prototype.active;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionService.prototype.exclusiveContext;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionService.prototype._activeModalInteractionContextModel;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionService.prototype._activeInlineInteractionContextModel;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionService.prototype._activeInteractionContext;
+    /** @type {?} */
+    InteractionService.prototype.activeInteractionContextIds;
+    /** @type {?} */
+    InteractionService.prototype.modelInteractionActive;
+    /** @type {?} */
+    InteractionService.prototype.inlineInteractionActive;
+    /** @type {?} */
+    InteractionService.prototype.modelInteractionContextFactory;
+}
+(function (InteractionService) {
+    /**
+     * @record
+     */
+    function Callback() { }
+    InteractionService.Callback = Callback;
+    if (false) {
+        /**
+         * @param {?} monitor
+         * @return {?}
+         */
+        Callback.prototype.onStarted = function (monitor) { };
+        /**
+         * @param {?} monitor
+         * @return {?}
+         */
+        Callback.prototype.onFinished = function (monitor) { };
+    }
+    class Monitor extends GarbageCollector {
+        /**
+         * @param {?} id
+         * @param {?} interactionContext
+         * @param {?} currentActiveMonitor
+         * @param {?} exclusiveContext
+         */
+        constructor(id, interactionContext, currentActiveMonitor, exclusiveContext) {
+            super();
+            this.id = id;
+            this.interactionContext = interactionContext;
+            this.currentActiveMonitor = currentActiveMonitor;
+            this.exclusiveContext = exclusiveContext;
+            const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
+            when.valueOf(interactionContext.active).becomesTruthy((/**
+             * @return {?}
+             */
+            () => this.onStarted()));
+            when.valueOf(interactionContext.active).becomesFalsey((/**
+             * @return {?}
+             */
+            () => this.onFinished()));
+            interactionContext.registerDisposable(this);
+        }
+        /**
+         * @protected
+         * @return {?}
+         */
+        onStarted() {
+            this.assertCanStart();
+            this.currentActiveMonitor.value = this;
+        }
+        /**
+         * @private
+         * @return {?}
+         */
+        assertCanStart() {
+            assert$1.isFalsey(this.currentActiveMonitor.value);
+            if (this.exclusiveContext.value && this.interactionContext !== this.exclusiveContext.value) {
+                lang.illegalState('Interaction started while exclusive lock active.  This is usually because you using a different context during place.canDeactivate(interactionContext)');
+            }
+        }
+        /**
+         * @protected
+         * @return {?}
+         */
+        onFinished() {
+            this.assertCurrentlyActive();
+            this.currentActiveMonitor.value = null;
+        }
+        /**
+         * @private
+         * @return {?}
+         */
+        assertCurrentlyActive() {
+            assert$1.isTruthy(this.currentActiveMonitor.value === this);
+        }
+    }
+    InteractionService.Monitor = Monitor;
+    if (false) {
+        /** @type {?} */
+        Monitor.prototype.id;
+        /** @type {?} */
+        Monitor.prototype.interactionContext;
+        /** @type {?} */
+        Monitor.prototype.currentActiveMonitor;
+        /** @type {?} */
+        Monitor.prototype.exclusiveContext;
+    }
+})(InteractionService || (InteractionService = {}));
+
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -1765,9 +1971,14 @@ if (false) {
  * @template D, R, E
  */
 class InplaceInteractionContextComponent extends InteractionContextBase {
-    constructor() {
+    /**
+     * @param {?} interactionService
+     */
+    constructor(interactionService) {
         super();
+        this.interactionService = interactionService;
         this._active = new MutableValueModel(false);
+        this.interactionService._registerInplaceInteractionContext(this);
     }
     /**
      * @return {?}
@@ -1829,7 +2040,9 @@ InplaceInteractionContextComponent.decorators = [
             }] }
 ];
 /** @nocollapse */
-InplaceInteractionContextComponent.ctorParameters = () => [];
+InplaceInteractionContextComponent.ctorParameters = () => [
+    { type: InteractionService }
+];
 InplaceInteractionContextComponent.propDecorators = {
     interactionContext: [{ type: ViewChild, args: ['activityContainer', { static: true },] }]
 };
@@ -1843,6 +2056,8 @@ if (false) {
      * @private
      */
     InplaceInteractionContextComponent.prototype._active;
+    /** @type {?} */
+    InplaceInteractionContextComponent.prototype.interactionService;
 }
 
 /**
@@ -1867,461 +2082,58 @@ InteractionOutletComponent.ctorParameters = () => [];
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
-class DialogInteractionContext extends InteractionContextBase {
-    /**
-     * @param {?} dialogService
-     * @param {?} config
-     */
-    constructor(dialogService, config) {
-        super();
-        this.dialogService = dialogService;
-        this.config = config;
-        this._activeModel = new MutableValueModel(false);
-        assert$1.notNil(dialogService);
-        this.onDispose((/**
-         * @return {?}
-         */
-        () => {
-            if (this.isActive()) {
-                lang.illegalState('Dispose called while active.');
-            }
-        }));
-    }
+class InteractionModule {
+}
+InteractionModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    MatButtonModule,
+                    MatDialogModule,
+                    MatTabsModule$1,
+                    PortalModule,
+                    RouterModule
+                ],
+                declarations: [
+                    ActivityContainerComponent,
+                    ConfirmationDialogComponent,
+                    ConfirmThenDialogComponent,
+                    AlertDialogComponent,
+                    ActivityOutletComponent,
+                    InteractionOutletComponent,
+                    InplaceInteractionContextComponent
+                ],
+                exports: [
+                    ActivityContainerComponent,
+                    ActivityOutletComponent,
+                    InteractionOutletComponent,
+                    InplaceInteractionContextComponent
+                ],
+                entryComponents: [
+                    ActivityContainerComponent,
+                    ConfirmationDialogComponent,
+                    ConfirmThenDialogComponent,
+                    AlertDialogComponent
+                ],
+                providers: [
+                    InteractionService,
+                ]
+            },] }
+];
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @abstract
+ * @template T, E
+ */
+class ParameterDefinition {
     /**
-     * @return {?}
-     */
-    get active() {
-        return this._activeModel.readonly;
-    }
-    /**
-     * @protected
-     * @template D, R, E
-     * @param {?} activityType
-     * @param {?} data
-     * @param {?=} disableClose
-     * @return {?}
-     */
-    _startActivity(activityType, data, disableClose = true) {
-        if (this.isActive()) {
-            lang.illegalState(`Activity already in progress: ${this.activityList.value.map((/**
-             * @param {?} a
-             * @return {?}
-             */
-            a => a.constructor.name)).join(', ')}`);
-        }
-        this._activeModel.value = true;
-        this.notifyActivityStarted();
-        /** @type {?} */
-        const config = Object.assign({}, this.config, {
-            data,
-            disableClose,
-            panelClass: 'dialog-interaction-service'
-        });
-        /** @type {?} */
-        const self = this;
-        /** @type {?} */
-        const matDialogRef = (/** @type {?} */ (this.dialogService.open(ActivityContainerComponent, config)));
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        (resolve, reject) => {
-            /** @type {?} */
-            const activityContainer = matDialogRef.componentInstance;
-            self.safelyUpdateActivityListDelegate(activityContainer.activityList);
-            activityContainer.initialActivityOutletContext = {
-                activityClass: activityType,
-                activityData: data,
-                /**
-                 * @param {?} result
-                 * @return {?}
-                 */
-                onDone(result) {
-                    resolve(result);
-                    matDialogRef.close(true); // return true to let the after close listener know we've already handled it.
-                },
-                /**
-                 * @param {?} error
-                 * @return {?}
-                 */
-                onCancel(error) {
-                    reject(error);
-                    matDialogRef.close(true); // return true to let the after close listener know we've already handled it.
-                }
-            };
-            // we need to check if our onDone/onCancel methods above we called or if we were
-            // closed by the user clicking the backdrop.  If the later then we need to reject
-            // our promise.
-            matDialogRef.afterClosed().subscribe((/**
-             * @param {?} promiseAlreadyFinished
-             * @return {?}
-             */
-            promiseAlreadyFinished => {
-                if (!promiseAlreadyFinished) {
-                    reject('auto-closed');
-                }
-            }));
-            matDialogRef.updateSize();
-            matDialogRef.afterOpened().subscribe((/**
-             * @param {?} promiseAlreadyFinished
-             * @return {?}
-             */
-            promiseAlreadyFinished => {
-                matDialogRef.updateSize();
-            }));
-        })).finally((/**
-         * @return {?}
-         */
-        () => {
-            this._activeModel.value = false;
-            this.notifyActivityFinished();
-            self.safelyUpdateActivityListDelegate(null);
-        }));
-    }
-    /**
-     * Updates teh delegate on the next tick to avoid modifying state during the current change detection cycle.
-     * @param {?} delegate
-     * @return {?}
-     */
-    safelyUpdateActivityListDelegate(delegate) {
-        setTimeout((/**
-         * @return {?}
-         */
-        () => this.setActivityList(delegate)));
-    }
-}
-DialogInteractionContext.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
-/** @nocollapse */
-DialogInteractionContext.ctorParameters = () => [
-    { type: MatDialog },
-    { type: MatDialogConfig }
-];
-/** @nocollapse */ DialogInteractionContext.ngInjectableDef = ɵɵdefineInjectable({ factory: function DialogInteractionContext_Factory() { return new DialogInteractionContext(ɵɵinject(MatDialog$1), ɵɵinject(MatDialogConfig)); }, token: DialogInteractionContext, providedIn: "root" });
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    DialogInteractionContext.prototype._activeModel;
-    /**
-     * @type {?}
-     * @private
-     */
-    DialogInteractionContext.prototype.dialogService;
-    /** @type {?} */
-    DialogInteractionContext.prototype.config;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class Guard extends ValueModel {
-    constructor() {
-        super({ initialValue: false });
-    }
-    /**
-     * @return {?}
-     */
-    get value() {
-        return this.store.read();
-    }
-    /**
-     * @template R
-     * @param {?} fun
-     * @return {?}
-     */
-    whileTrue(fun) {
-        this.startTransaction().commit(true);
-        try {
-            return fun();
-        }
-        finally {
-            this.startTransaction().commit(false);
-        }
-    }
-    /**
-     * @template R
-     * @param {?} fun
-     * @param {?=} defaultValue
-     * @return {?}
-     */
-    runIfFalse(fun, defaultValue = null) {
-        return !this.value ? fun() : defaultValue;
-    }
-}
-/**
- * @abstract
- */
-class ModalInteractionService extends GarbageCollector {
-    constructor() {
-        super();
-        this._activityListeners = new EventListenerList();
-    }
-    /**
-     * @return {?}
-     */
-    isActive() {
-        return this.active.value;
-    }
-    /**
-     * @param {?} listener
-     * @return {?}
-     */
-    addActivityListener(listener) {
-        return this._activityListeners.add(listener);
-    }
-    /**
-     * @protected
-     * @return {?}
-     */
-    notifyActivityStarted() {
-        this._activityListeners.fire((/**
-         * @param {?} l
-         * @return {?}
-         */
-        l => l.onActivityStarted()));
-    }
-    /**
-     * @protected
-     * @return {?}
-     */
-    notifyActivityFinished() {
-        this._activityListeners.fire((/**
-         * @param {?} l
-         * @return {?}
-         */
-        l => l.onActivityFinished()));
-    }
-}
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    ModalInteractionService.prototype._activityListeners;
-    /** @type {?} */
-    ModalInteractionService.prototype.active;
-    /**
-     * @abstract
-     * @param {?} disposable
-     * @return {?}
-     */
-    ModalInteractionService.prototype.createInteractionContextFor = function (disposable) { };
-    /**
-     * @abstract
-     * @return {?}
-     */
-    ModalInteractionService.prototype.createExclusiveInteractionContext = function () { };
-    /**
-     * @abstract
-     * @return {?}
-     */
-    ModalInteractionService.prototype.getCurrentActivity = function () { };
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
-const DIALOG_INTERACTION_SERVICE_DEFAULTS = new InjectionToken('DIALOG_INTERACTION_SERVICE_DEFAULTS');
-class DialogInteractionService extends ModalInteractionService {
-    /**
-     * @param {?} dialogService
-     * @param {?} dialogServiceDefaults
-     * @param {?} matDialogDefaultConfig
-     */
-    constructor(dialogService, dialogServiceDefaults, matDialogDefaultConfig) {
-        super();
-        this.dialogService = dialogService;
-        this.dialogServiceDefaults = dialogServiceDefaults;
-        this.matDialogDefaultConfig = matDialogDefaultConfig;
-        this._activeInteractionContextModel = new MutableValueModel();
-        assert$1.notNil(dialogService);
-        const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
-        this.active = chain(this._activeInteractionContextModel).isNotNil();
-    }
-    /**
-     * @param {?} disposable
-     * @return {?}
-     */
-    createInteractionContextFor(disposable) {
-        return disposable.registerDisposable(this._createInteractionContext());
-    }
-    /**
-     * @return {?}
-     */
-    _createInteractionContext() {
-        /** @type {?} */
-        const config = Object.assign({ autoFocus: false, hasBackdrop: true, closeOnNavigation: false }, this.matDialogDefaultConfig, this.dialogServiceDefaults);
-        /** @type {?} */
-        const self = this;
-        /** @type {?} */
-        const dialogInteractionContext = new DialogInteractionContext(this.dialogService, config);
-        dialogInteractionContext.registerDisposable(dialogInteractionContext.addActivityListener({
-            /**
-             * @return {?}
-             */
-            onActivityStarted() {
-                self.onActivityStarted(dialogInteractionContext);
-            },
-            /**
-             * @return {?}
-             */
-            onActivityFinished() {
-                self.onActivityFinished(dialogInteractionContext);
-            }
-        }));
-        return dialogInteractionContext;
-    }
-    /**
-     * @return {?}
-     */
-    createExclusiveInteractionContext() {
-        this.exclusiveContext = this._createInteractionContext();
-        /** @type {?} */
-        const self = this;
-        this.exclusiveContext.registerDisposable({
-            /**
-             * @return {?}
-             */
-            dispose() {
-                self.exclusiveContext = null;
-            }
-        });
-        return this.exclusiveContext;
-    }
-    // @Trace()
-    /**
-     * @param {?} dialogInteractionContext
-     * @return {?}
-     */
-    onActivityStarted(dialogInteractionContext) {
-        assert$1.isFalsey(this.isActive());
-        if (this.exclusiveContext && dialogInteractionContext !== this.exclusiveContext) {
-            lang.illegalState("Interaction started while exclusive lock active.  This is usually because you using a different context during place.canDeactivate(interactionContext)");
-        }
-        this._activeInteractionContextModel.value = dialogInteractionContext;
-        this.notifyActivityStarted();
-    }
-    // @Trace()
-    /**
-     * @param {?} dialogInteractionContext
-     * @return {?}
-     */
-    onActivityFinished(dialogInteractionContext) {
-        assert$1.isTruthy(this._activeInteractionContextModel.value === dialogInteractionContext);
-        this._activeInteractionContextModel.value = null;
-        this.notifyActivityFinished();
-    }
-    /**
-     * @return {?}
-     */
-    getCurrentActivity() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert$1.isTruthy(this.isActive());
-            return this._activeInteractionContextModel.value.getCurrentActivity();
-        });
-    }
-}
-DialogInteractionService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
-/** @nocollapse */
-DialogInteractionService.ctorParameters = () => [
-    { type: MatDialog },
-    { type: MatDialogConfig, decorators: [{ type: Optional }, { type: Inject, args: [DIALOG_INTERACTION_SERVICE_DEFAULTS,] }] },
-    { type: MatDialogConfig, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DIALOG_DEFAULT_OPTIONS,] }] }
-];
-/** @nocollapse */ DialogInteractionService.ngInjectableDef = ɵɵdefineInjectable({ factory: function DialogInteractionService_Factory() { return new DialogInteractionService(ɵɵinject(MatDialog$1), ɵɵinject(DIALOG_INTERACTION_SERVICE_DEFAULTS, 8), ɵɵinject(MAT_DIALOG_DEFAULT_OPTIONS, 8)); }, token: DialogInteractionService, providedIn: "root" });
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    DialogInteractionService.prototype._activeInteractionContextModel;
-    /** @type {?} */
-    DialogInteractionService.prototype.active;
-    /**
-     * @type {?}
-     * @private
-     */
-    DialogInteractionService.prototype.exclusiveContext;
-    /**
-     * @type {?}
-     * @private
-     */
-    DialogInteractionService.prototype.dialogService;
-    /** @type {?} */
-    DialogInteractionService.prototype.dialogServiceDefaults;
-    /** @type {?} */
-    DialogInteractionService.prototype.matDialogDefaultConfig;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class InteractionModule {
-}
-InteractionModule.decorators = [
-    { type: NgModule, args: [{
-                imports: [
-                    CommonModule,
-                    MatButtonModule,
-                    MatDialogModule,
-                    MatTabsModule$1,
-                    PortalModule,
-                    RouterModule
-                ],
-                declarations: [
-                    ActivityContainerComponent,
-                    ConfirmationDialogComponent,
-                    ConfirmThenDialogComponent,
-                    AlertDialogComponent,
-                    ActivityOutletComponent,
-                    InteractionOutletComponent,
-                    InplaceInteractionContextComponent
-                ],
-                exports: [
-                    ActivityContainerComponent,
-                    ActivityOutletComponent,
-                    InteractionOutletComponent,
-                    InplaceInteractionContextComponent
-                ],
-                entryComponents: [
-                    ActivityContainerComponent,
-                    ConfirmationDialogComponent,
-                    ConfirmThenDialogComponent,
-                    AlertDialogComponent
-                ],
-                providers: [
-                    DialogInteractionService,
-                ]
-            },] }
-];
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @abstract
- * @template T, E
- */
-class ParameterDefinition {
-    /**
-     * @param {?} propertyName
-     * @param {?} options
-     * @param {?=} urlFormat
+     * @param {?} propertyName
+     * @param {?} options
+     * @param {?=} urlFormat
      */
     constructor(propertyName, options, urlFormat) {
         this.propertyName = propertyName;
@@ -3177,6 +2989,24 @@ class NavigationState extends GarbageCollector {
         this.context = context;
         this._visits = new Map();
     }
+    /**
+     * @return {?}
+     */
+    get idle() {
+        return !this.isTransitional;
+    }
+    /**
+     * @return {?}
+     */
+    get placeRouter() {
+        return this.context.placeRouter;
+    }
+    /**
+     * @return {?}
+     */
+    get interactionService() {
+        return this.context.interactionService;
+    }
     /**
      * @return {?}
      */
@@ -3197,6 +3027,41 @@ class NavigationState extends GarbageCollector {
     getVisitFor(placeDef) {
         return this._visits.get(placeDef);
     }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onPopState(event) {
+        return this.illegalTransition(event);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onStart(event) {
+        return this.illegalTransition(event);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onCancel(event) {
+        return this.illegalTransition(event);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onError(event) {
+        return this.illegalTransition(event);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onEnd(event) {
+        return this.illegalTransition(event);
+    }
     /**
      * @param {?} newUrl
      * @return {?}
@@ -3204,6 +3069,16 @@ class NavigationState extends GarbageCollector {
     onBackClickedDuringNavigationInteraction(newUrl) {
         return this.illegalTransition('onBackClickedDuringNavigationInteraction');
     }
+    /**
+     * @param {?} component
+     * @param {?} nextState
+     * @return {?}
+     */
+    canDeactivatePlace(component, nextState) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.illegalTransition('canDeactivatePlace');
+        });
+    }
     /**
      * @return {?}
      */
@@ -3224,24 +3099,31 @@ class NavigationState extends GarbageCollector {
      * @return {?}
      */
     currentRouterUrl() {
-        return this.context.router.routerState ? this.context.router.routerState.snapshot.url : null;
+        return this.placeRouter.getCurrentRouterUrl();
     }
     /**
      * @protected
      * @param {?} event
      * @return {?}
      */
-    createActiveSession(event) {
+    createTransitionStateFor(event) {
         // TODO: check if the event is purely for interaction context changes.
-        return new NavigationState.Active(this.context, event.navigationTrigger === 'popstate', this.currentRouterUrl());
+        /** @type {?} */
+        const popstate = event.navigationTrigger === 'popstate';
+        return popstate ?
+            new NavigationState.NavigationBackTransition(this.context, popstate, this.currentRouterUrl()) :
+            new NavigationState.NavigationTransition(this.context, popstate, this.currentRouterUrl());
     }
     /**
-     * @protected
      * @param {?} url
      * @return {?}
      */
-    updateLocation(url) {
-        this.context.angularLocation.go(url);
+    resetBrowserLocation(url) {
+        // TODO: Should this be a navigate operation to avoid confusing the router...??
+        setTimeout((/**
+         * @return {?}
+         */
+        () => this.placeRouter.resetBrowserLocation(url)));
     }
     /**
      * @return {?}
@@ -3250,12 +3132,6 @@ class NavigationState extends GarbageCollector {
         return this.constructor.name;
     }
 }
-__decorate([
-    Trace(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", void 0)
-], NavigationState.prototype, "updateLocation", null);
 if (false) {
     /**
      * @type {?}
@@ -3263,71 +3139,36 @@ if (false) {
      */
     NavigationState.prototype._visits;
     /** @type {?} */
-    NavigationState.prototype.isPopState;
-    /** @type {?} */
-    NavigationState.prototype.active;
+    NavigationState.prototype.isTransitional;
     /** @type {?} */
     NavigationState.prototype.startingUrl;
+    /** @type {?} */
+    NavigationState.prototype.isPopState;
     /**
      * @type {?}
      * @protected
      */
     NavigationState.prototype.context;
-    /**
-     * @abstract
-     * @param {?} event
-     * @return {?}
-     */
-    NavigationState.prototype.onStart = function (event) { };
-    /**
-     * @abstract
-     * @param {?} event
-     * @return {?}
-     */
-    NavigationState.prototype.onCancel = function (event) { };
-    /**
-     * @abstract
-     * @param {?} event
-     * @return {?}
-     */
-    NavigationState.prototype.onError = function (event) { };
-    /**
-     * @abstract
-     * @param {?} event
-     * @return {?}
-     */
-    NavigationState.prototype.onEnd = function (event) { };
-    /**
-     * @abstract
-     * @param {?} component
-     * @param {?} nextState
-     * @return {?}
-     */
-    NavigationState.prototype.canDeactivatePlace = function (component, nextState) { };
 }
 (function (NavigationState) {
     class Context {
         /**
-         * @param {?} router
-         * @param {?} modalInteractionService
-         * @param {?} angularLocation
+         * @param {?} placeRouter
+         * @param {?} interactionService
          * @param {?} notifySuccess
          */
-        constructor(router, modalInteractionService, angularLocation, notifySuccess) {
-            this.router = router;
-            this.modalInteractionService = modalInteractionService;
-            this.angularLocation = angularLocation;
+        constructor(placeRouter, interactionService, notifySuccess) {
+            this.placeRouter = placeRouter;
+            this.interactionService = interactionService;
             this.notifySuccess = notifySuccess;
         }
     }
     NavigationState.Context = Context;
     if (false) {
         /** @type {?} */
-        Context.prototype.router;
-        /** @type {?} */
-        Context.prototype.modalInteractionService;
+        Context.prototype.placeRouter;
         /** @type {?} */
-        Context.prototype.angularLocation;
+        Context.prototype.interactionService;
         /** @type {?} */
         Context.prototype.notifySuccess;
     }
@@ -3337,18 +3178,9 @@ if (false) {
          */
         constructor(context) {
             super(context);
-            this.active = false;
+            this.isTransitional = false;
             this.startingUrl = null;
-        }
-        /**
-         * @param {?} component
-         * @param {?} nextState
-         * @return {?}
-         */
-        canDeactivatePlace(component, nextState) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return this.illegalTransition('canDeactivatePlace');
-            });
+            this.isPopState = false;
         }
         /**
          * @param {?} event
@@ -3360,44 +3192,35 @@ if (false) {
                 Logger.get(this).info(`navigation started to same url -> ${event.url}`);
                 return this;
             }
-            if (event.url === (`${this.currentRouterUrl()}(aup-interaction:modal)`)) {
+            if (this.placeRouter.hasActiveInteractionIds(event.url)) {
                 Logger.get(this).info(`navigation started with interaction outlet -> ${event.url}`);
-                return new ModalInteractionSession(this.context, event.url);
+                return new InteractionTransition(this.context, event.url);
+            }
+            else {
+                return this.createTransitionStateFor(event);
             }
-            return this.createActiveSession(event);
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onCancel(event) {
-            return this.illegalTransition(event);
         }
         /**
          * @param {?} event
          * @return {?}
          */
-        onEnd(event) {
-            return this.illegalTransition(event);
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onError(event) {
-            return this.illegalTransition(event);
+        onPopState(event) {
+            return this.createTransitionStateFor(event);
         }
     }
     NavigationState.Idle = Idle;
     if (false) {
         /** @type {?} */
-        Idle.prototype.isPopState;
-        /** @type {?} */
-        Idle.prototype.active;
+        Idle.prototype.isTransitional;
         /** @type {?} */
         Idle.prototype.startingUrl;
+        /** @type {?} */
+        Idle.prototype.isPopState;
     }
-    class Active extends NavigationState {
+    /**
+     * @abstract
+     */
+    class AbstractNavigationTransition extends NavigationState {
         /**
          * @param {?} context
          * @param {?} isPopState
@@ -3407,9 +3230,9 @@ if (false) {
             super(context);
             this.isPopState = isPopState;
             this.startingUrl = startingUrl;
-            this.active = true;
+            this.isTransitional = true;
             this.componentDeactivationHandlers = new Map();
-            this._interactionContext = this.context.modalInteractionService.createExclusiveInteractionContext();
+            this._interactionContext = this.interactionService._createExclusiveModalInteractionContext();
             this.onDispose((/**
              * @return {?}
              */
@@ -3417,9 +3240,9 @@ if (false) {
                 // 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.
+                // automatically cancel if the context is disposed so we don't have worry about detaching etc.
                 if (this._interactionContext) {
-                    this._interactionContext.dispose();
+                    this._interactionContext.dispose(); // or do something like cancelAndDispose?
                 }
             }));
         }
@@ -3434,7 +3257,8 @@ if (false) {
          * @return {?}
          */
         onStart(event) {
-            // active sessions can have many cancel start cycles.
+            // active sessions can have many cancel start cycles due
+            // to place guard redirects
             return this;
         }
         /**
@@ -3446,58 +3270,27 @@ if (false) {
             this.context.notifySuccess(this);
             return new Idle(this.context);
         }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onCancel(event) {
-            if (this.isPopState) { // back button clicked and a guard cancelled
-                // 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.updateLocation(this.startingUrl);
-            }
-            return this.isPopState ? new Idle(this.context) : this;
-        }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onError(event) {
-            // navigation was aborted.
-            if (this.isPopState && 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.updateLocation(this.startingUrl);
-            }
-            return new Idle(this.context);
-        }
         /**
          * @param {?} locationTriggerUrl
          * @return {?}
          */
         onBackClickedDuringNavigationInteraction(locationTriggerUrl) {
+            // detach the interactoin from the session so it doesn't get disposed until the activity
+            // has completed.
             /** @type {?} */
             const context = this.detachInteractionContext();
+            const { when } = Dsl.disposeWith(context);
+            // TODO: I need to make the exclusive interaction context disallow nested activities or
+            //       that would mess things up entirely.
             context.getCurrentActivity().then((/**
              * @param {?} activity
              * @return {?}
              */
             activity => {
-                context.addActivityListener({
-                    /**
-                     * @return {?}
-                     */
-                    onActivityFinished() {
-                        context.dispose();
-                    },
-                    /**
-                     * @return {?}
-                     */
-                    onActivityStarted() {
-                    }
-                });
+                when.valueOf(context.active).becomesFalsey((/**
+                 * @return {?}
+                 */
+                () => context.dispose()), { once: true });
                 activity.cancel(null);
             }));
             return new CancelledDuringNavigationInteraction(this.context, this.startingUrl, locationTriggerUrl);
@@ -3531,51 +3324,116 @@ if (false) {
             this._interactionContext = null;
             return context;
         }
-        /**
-         * @return {?}
-         */
-        toString() {
-            return `${this.constructor.name}(startingUrl: ${this.startingUrl}, isPopState:${this.isPopState})`;
-        }
     }
-    __decorate([
-        Trace(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [NavigationStart]),
-        __metadata("design:returntype", NavigationState)
-    ], Active.prototype, "onStart", null);
-    __decorate([
-        Trace(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [NavigationCancel]),
-        __metadata("design:returntype", NavigationState)
-    ], Active.prototype, "onCancel", null);
-    __decorate([
-        Trace(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [NavigationError]),
-        __metadata("design:returntype", NavigationState)
-    ], Active.prototype, "onError", null);
-    NavigationState.Active = Active;
+    NavigationState.AbstractNavigationTransition = AbstractNavigationTransition;
     if (false) {
         /** @type {?} */
-        Active.prototype.active;
+        AbstractNavigationTransition.prototype.isTransitional;
         /**
          * @type {?}
          * @private
          */
-        Active.prototype.componentDeactivationHandlers;
+        AbstractNavigationTransition.prototype.componentDeactivationHandlers;
         /**
          * @type {?}
          * @private
          */
-        Active.prototype._interactionContext;
+        AbstractNavigationTransition.prototype._interactionContext;
+        /** @type {?} */
+        AbstractNavigationTransition.prototype.isPopState;
+        /** @type {?} */
+        AbstractNavigationTransition.prototype.startingUrl;
+    }
+    class NavigationTransition extends AbstractNavigationTransition {
+        constructor() {
+            super(...arguments);
+            this.isPopState = false;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onStart(event) {
+            // active sessions can have many cancel start cycles due
+            // to place guard redirects
+            return this;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onEnd(event) {
+            // navigation succeeded
+            this.context.notifySuccess(this);
+            return new Idle(this.context);
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onCancel(event) {
+            return new Idle(this.context);
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onError(event) {
+            // navigation was aborted.
+            return new Idle(this.context);
+        }
+        /**
+         * @return {?}
+         */
+        toString() {
+            return `${this.constructor.name}(startingUrl: ${this.startingUrl})`;
+        }
+    }
+    NavigationState.NavigationTransition = NavigationTransition;
+    if (false) {
         /** @type {?} */
-        Active.prototype.isPopState;
+        NavigationTransition.prototype.isPopState;
+    }
+    class NavigationBackTransition extends AbstractNavigationTransition {
+        constructor() {
+            super(...arguments);
+            this.isPopState = true;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onCancel(event) {
+            // Angular doesn't preserve the url when a guard cancels the back button.
+            // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
+            Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
+            this.resetBrowserLocation(this.startingUrl);
+            return new Idle(this.context);
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onError(event) {
+            // navigation was aborted.
+            if (this.currentRouterUrl() !== this.startingUrl) {
+                // Angular doesn't preserve the url when a guard cancels the back button.
+                // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
+                Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
+                this.resetBrowserLocation(this.startingUrl);
+            }
+            return new Idle(this.context);
+        }
+    }
+    NavigationState.NavigationBackTransition = NavigationBackTransition;
+    if (false) {
         /** @type {?} */
-        Active.prototype.startingUrl;
+        NavigationBackTransition.prototype.isPopState;
     }
-    class ModalInteractionSession extends NavigationState {
+    /**
+     * @abstract
+     */
+    class AbstractInteractionTransition extends NavigationState {
         /**
          * @param {?} context
          * @param {?} startingUrl
@@ -3583,98 +3441,117 @@ if (false) {
         constructor(context, startingUrl) {
             super(context);
             this.startingUrl = startingUrl;
-            this.active = false;
-            this.isPopState = false;
+            this.isTransitional = true;
         }
         /**
-         * @param {?} url
+         * @protected
          * @return {?}
          */
-        static hasInteraction(url) {
-            return url.endsWith('(aup-interaction:modal)');
+        reinstateInteractionRoute() {
+            console.log(this.startingUrl);
+            setTimeout((/**
+             * @return {?}
+             */
+            () => this.placeRouter.syncInteractionIdsWithRouter()));
+        }
+    }
+    NavigationState.AbstractInteractionTransition = AbstractInteractionTransition;
+    if (false) {
+        /** @type {?} */
+        AbstractInteractionTransition.prototype.isTransitional;
+        /** @type {?} */
+        AbstractInteractionTransition.prototype.startingUrl;
+    }
+    /**
+     * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
+     * happily ignore interaction contexts.
+     */
+    class InteractionTransition extends AbstractInteractionTransition {
+        constructor() {
+            super(...arguments);
+            this.isPopState = false;
         }
         /**
          * @param {?} event
          * @return {?}
          */
-        onStart(event) {
-            // VERY VERY IMPORTANT BACK BUTTON NOTE:
-            // When the back button is clicked we'll enter here first, and push the url
-            // back to the browser.  Angular seems to ignore it from a routing perspective
-            // and then the InteractionGuard will cancel the navigation.  This process seems
-            // to keep the brower history in a sane state.
-            if (this.context.modalInteractionService.isActive()) {
-                if (!ModalInteractionSession.hasInteraction(event.url)) {
-                    // this capture the case where
-                    this.updateLocation(this.startingUrl);
-                }
+        onEnd(event) {
+            if (this.context.interactionService.isActive()) {
+                this.reinstateInteractionRoute();
+                return new IdleDuringInteraction(this.context, this.startingUrl);
+            }
+            else {
+                return new Idle(this.context);
             }
-            return this;
         }
-        /**
-         * @param {?} event
-         * @return {?}
-         */
-        onCancel(event) {
-            // this.updateLocation(this.startingUrl);
-            return this;
+    }
+    NavigationState.InteractionTransition = InteractionTransition;
+    if (false) {
+        /** @type {?} */
+        InteractionTransition.prototype.isPopState;
+    }
+    /**
+     * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
+     * happily ignore interaction contexts.
+     */
+    class InteractionBackTransition extends AbstractInteractionTransition {
+        constructor() {
+            super(...arguments);
+            this.isPopState = true;
         }
         /**
          * @param {?} event
          * @return {?}
          */
         onEnd(event) {
-            if (this.context.modalInteractionService.isActive()) {
-                return this;
+            if (this.interactionService.isActive()) {
+                this.reinstateInteractionRoute();
+                return new IdleDuringInteraction(this.context, this.startingUrl);
             }
             else {
                 return new Idle(this.context);
             }
         }
+    }
+    NavigationState.InteractionBackTransition = InteractionBackTransition;
+    if (false) {
+        /** @type {?} */
+        InteractionBackTransition.prototype.isPopState;
+    }
+    class IdleDuringInteraction extends NavigationState {
+        /**
+         * @param {?} context
+         * @param {?} startingUrl
+         */
+        constructor(context, startingUrl) {
+            super(context);
+            this.startingUrl = startingUrl;
+            this.isTransitional = false;
+            this.isPopState = false;
+        }
         /**
          * @param {?} event
          * @return {?}
          */
-        onError(event) {
-            return this.illegalTransition(event);
+        onStart(event) {
+            return new InteractionTransition(this.context, event.url);
         }
         /**
-         * @param {?} component
-         * @param {?} nextState
+         * @param {?} event
          * @return {?}
          */
-        canDeactivatePlace(component, nextState) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return true;
-            });
+        onPopState(event) {
+            return new InteractionBackTransition(this.context, event.url);
         }
     }
-    __decorate([
-        Trace(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [NavigationStart]),
-        __metadata("design:returntype", NavigationState)
-    ], ModalInteractionSession.prototype, "onStart", null);
-    __decorate([
-        Trace(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [NavigationCancel]),
-        __metadata("design:returntype", NavigationState)
-    ], ModalInteractionSession.prototype, "onCancel", null);
-    __decorate([
-        Trace(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [NavigationEnd]),
-        __metadata("design:returntype", NavigationState)
-    ], ModalInteractionSession.prototype, "onEnd", null);
-    NavigationState.ModalInteractionSession = ModalInteractionSession;
+    NavigationState.IdleDuringInteraction = IdleDuringInteraction;
     if (false) {
         /** @type {?} */
-        ModalInteractionSession.prototype.active;
+        IdleDuringInteraction.prototype.isTransitional;
         /** @type {?} */
-        ModalInteractionSession.prototype.isPopState;
+        IdleDuringInteraction.prototype.isPopState;
         /** @type {?} */
-        ModalInteractionSession.prototype.startingUrl;
+        IdleDuringInteraction.prototype.startingUrl;
     }
     class CancelledDuringNavigationInteraction extends NavigationState {
         /**
@@ -3686,20 +3563,27 @@ if (false) {
             super(context);
             this.startingUrl = startingUrl;
             this.locationChangeTriggerUrl = locationChangeTriggerUrl;
-            this.active = false;
+            this.isPopState = false;
             this.capturedFauxRouterStart = false;
-            // This will trigger a return to the route we originally started with.
-            // this.angularLocation.go(this.startingUrl);
         }
         /**
-         * @param {?} component
-         * @param {?} nextState
          * @return {?}
          */
-        canDeactivatePlace(component, nextState) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return false;
-            });
+        get isTransitional() {
+            return !this.capturedFauxRouterStart;
+        }
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        onStart(event) {
+            if (event.url === this.locationChangeTriggerUrl && !this.capturedFauxRouterStart) {
+                this.capturedFauxRouterStart = true;
+                return this.ignore(event, 'url matched back button location change');
+            }
+            else {
+                return this.createTransitionStateFor(event);
+            }
         }
         /**
          * @param {?} event
@@ -3726,14 +3610,8 @@ if (false) {
          * @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.createActiveSession(event);
-            }
+        onPopState(event) {
+            return this.createTransitionStateFor(event);
         }
         /**
          * @param {?} event
@@ -3754,8 +3632,6 @@ if (false) {
     }
     NavigationState.CancelledDuringNavigationInteraction = CancelledDuringNavigationInteraction;
     if (false) {
-        /** @type {?} */
-        CancelledDuringNavigationInteraction.prototype.active;
         /** @type {?} */
         CancelledDuringNavigationInteraction.prototype.isPopState;
         /**
@@ -3837,29 +3713,27 @@ if (false) {
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 class UrlSnapshot {
+    // TODO: Update this accept a url Parser so it can be immutable and generate new trees on mutation using toString() are parseUrl.
     /**
-     * @param {?} urlTree
-     */
-    constructor(urlTree) {
-        this.urlTree = urlTree;
-        // console.log({ segments: this.urlTree.root.children.primary.segments });
-    }
-    /**
-     * @return {?}
+     * @param {?} urlSerializer
+     * @param {?} url
      */
-    cloneUrlSegmentList() {
-        return [...this.urlTree.root.children.primary.segments];
+    constructor(urlSerializer, url) {
+        this.urlSerializer = urlSerializer;
+        this.url = url;
+        this.urlTree = urlSerializer.parse(url);
     }
     /**
+     * @protected
      * @param {?} visit
      * @return {?}
      */
-    updateVisitSegments(visit) {
+    replaceExistingVisitSegmentsWith(visit) {
         // Ugly, but it works for now.
         /** @type {?} */
-        const segments = this.cloneUrlSegmentList();
+        const segments = [...this.getPrimarySegments()];
         /** @type {?} */
-        const visitSegments = this.convertToUrlSegments(visit);
+        const visitSegments = this.getSegmentsFor(visit);
         /** @type {?} */
         const replaceAt = segments.findIndex((/**
          * @param {?} segment
@@ -3870,12 +3744,20 @@ class UrlSnapshot {
         segments.splice(replaceAt, visitSegments.length, ...visitSegments);
         return segments;
     }
+    /**
+     * @private
+     * @return {?}
+     */
+    getPrimarySegments() {
+        return this.urlTree.root.children.primary.segments;
+    }
     /**
      * Converts the visit into segments.  Please not that these segments are not e
+     * @protected
      * @param {?} visit
      * @return {?}
      */
-    convertToUrlSegments(visit) {
+    getSegmentsFor(visit) {
         return visit.placeDefinition.hasRouteId() ?
             [
                 // NOTE:
@@ -3895,7 +3777,7 @@ class UrlSnapshot {
      */
     createRedirectCommandsFor(visit) {
         /** @type {?} */
-        const segments = this.updateVisitSegments(visit);
+        const segments = this.replaceExistingVisitSegmentsWith(visit);
         /** @type {?} */
         const commands = [];
         segments.forEach((/**
@@ -3915,17 +3797,82 @@ class UrlSnapshot {
      * @return {?}
      */
     includesPathOf(placeDef) {
-        return this.cloneUrlSegmentList().find((/**
+        return this.getPrimarySegments().find((/**
          * @param {?} s
          * @return {?}
          */
         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);
+        }
+        else {
+            return [];
+        }
+    }
+    // @Trace()
+    /**
+     * @param {?} ids
+     * @return {?}
+     */
+    addOrReplaceInteractionIds(ids) {
+        /** @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 (false) {
-    /** @type {?} */
+    /**
+     * @type {?}
+     * @private
+     */
     UrlSnapshot.prototype.urlTree;
+    /** @type {?} */
+    UrlSnapshot.prototype.urlSerializer;
+    /** @type {?} */
+    UrlSnapshot.prototype.url;
 }
+(function (UrlSnapshot) {
+    UrlSnapshot.INTERACTION_ROUTER_OUTLET = 'aup-interactions';
+    UrlSnapshot.INTERACTION_ROUTER_PATH = 'active';
+    UrlSnapshot.INTERACTION_ID_SEPARATOR = '--';
+    /**
+     * @param {?} path
+     * @return {?}
+     */
+    function parseInteractionIds(path) {
+        return path.split(UrlSnapshot.INTERACTION_ID_SEPARATOR);
+    }
+    UrlSnapshot.parseInteractionIds = parseInteractionIds;
+    /**
+     * @param {?} interactionIds
+     * @return {?}
+     */
+    function createPathIdFor(interactionIds) {
+        return interactionIds.join(UrlSnapshot.INTERACTION_ID_SEPARATOR);
+    }
+    UrlSnapshot.createPathIdFor = createPathIdFor;
+    /**
+     * @param {?} interactionIds
+     * @return {?}
+     */
+    function createInteractionOutletRouterCommands(interactionIds) {
+        return [UrlSnapshot.INTERACTION_ROUTER_PATH, createPathIdFor(interactionIds)];
+    }
+    UrlSnapshot.createInteractionOutletRouterCommands = createInteractionOutletRouterCommands;
+})(UrlSnapshot || (UrlSnapshot = {}));
 
 /**
  * @fileoverview added by tsickle
@@ -3937,29 +3884,33 @@ class PlaceRouter extends GarbageCollector {
      * @param {?} urlSerializer
      * @param {?} angularLocation
      * @param {?} placeHistory
-     * @param {?} modalInteractionService
+     * @param {?} interactionService
      */
-    constructor(router, urlSerializer, angularLocation, placeHistory, modalInteractionService) {
+    constructor(router, urlSerializer, angularLocation, placeHistory, interactionService) {
         super();
         this.router = router;
         this.urlSerializer = urlSerializer;
         this.angularLocation = angularLocation;
         this.placeHistory = placeHistory;
-        this.modalInteractionService = modalInteractionService;
-        this.firstRoute = true;
-        this._navigationSessionModel = new MutableValueModel();
+        this.interactionService = interactionService;
+        this._navigationStateModel = new MutableValueModel();
         this._activeVisits = new MutableListModel();
         const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
         this.activeVisitIndex = chain(this._activeVisits).indexBy('placeDefinition');
-        this.navigationSessionActive = chain(this.navigationSessionModel).pluck('active');
-        this._navigationSessionContext = new NavigationState.Context(this.router, this.modalInteractionService, this.angularLocation, (/**
+        this.navigationInProgress = chain(this.navigationStateModel).pluck('isTransitional');
+        this._navigationSessionContext = new NavigationState.Context(this, this.interactionService, (/**
          * @param {?} session
          * @return {?}
          */
         session => {
             this.processNavigationSuccess(session);
         }));
-        this._navigationSessionModel.value = new NavigationState.Idle(this._navigationSessionContext);
+        this._navigationStateModel.value = new NavigationState.Idle(this._navigationSessionContext);
+        this._navigationStateTypeModel = chain(this._navigationStateModel).map((/**
+         * @param {?} state
+         * @return {?}
+         */
+        state => (/** @type {?} */ (state.constructor))));
         // TODO: make setup the callbacks in during module initiation to make this testable.
         this.router.events.subscribe((/**
          * @param {?} event
@@ -3973,53 +3924,85 @@ class PlaceRouter extends GarbageCollector {
             // NavigationStart -> .... -> NavigationError --> navigation aborted, end session.
             // =======================
             if (event instanceof NavigationStart) {
-                this.runStateTransition((/**
-                 * @param {?} session
-                 * @return {?}
-                 */
-                session => session.onStart(event)));
+                console.log(event);
+                if (event.navigationTrigger === 'popstate') {
+                    this.runStateTransition((/**
+                     * @param {?} state
+                     * @return {?}
+                     */
+                    state => state.onPopState(event)));
+                }
+                else {
+                    this.runStateTransition((/**
+                     * @param {?} state
+                     * @return {?}
+                     */
+                    state => state.onStart(event)));
+                }
             }
             if (event instanceof NavigationEnd) {
+                console.log(event);
                 this.runStateTransition((/**
-                 * @param {?} session
+                 * @param {?} state
                  * @return {?}
                  */
-                session => session.onEnd(event)));
+                state => state.onEnd(event)));
             }
             if (event instanceof NavigationError) {
+                console.log(event);
                 this.runStateTransition((/**
-                 * @param {?} session
+                 * @param {?} state
                  * @return {?}
                  */
-                session => session.onError(event)));
+                state => state.onError(event)));
             }
             if (event instanceof NavigationCancel) {
+                console.log(event);
                 this.runStateTransition((/**
-                 * @param {?} session
+                 * @param {?} state
                  * @return {?}
                  */
-                session => session.onCancel(event)));
+                state => state.onCancel(event)));
             }
         }));
         // Push dialog state to the url so we can capture the back button.
-        this.modalInteractionService.addActivityListener(new PlaceRouter.InteractionRouteMediator(this.navigationSessionActive, this.router));
+        when.listOf(this.interactionService.activeInteractionContextIds).changes((/**
+         * @param {?} ids
+         * @param {?} previous
+         * @return {?}
+         */
+        (ids, previous) => {
+            this.syncInteractionIdsWithRouter();
+        }), { unless: this.navigationInProgress }); // TODO: I think the exclusive interaction prevents interactions starting while it's active so we might not need this.
+        // TODO: I think the exclusive interaction prevents interactions starting while it's active so we might not need this.
+        /** @type {?} */
+        const urlChanges = new MutableStream();
         // The angular router doesn't always fire router events when the back button is pushed while a navigation
         // session is in progress.  Sometimes we only know about it from the url change.
+        // IMPORTANT ORDER DEPENDENCY
+        // This only works because we're notified of the change after the router has started reacting to it.  This
+        // we can can use our navigationState to determine things.
         angularLocation.onUrlChange((/**
          * @param {?} url
          * @return {?}
          */
         url => {
-            console.log(`#### url changed ->`, { url, navIsActive: this.navigationSessionActive.value });
             /** @type {?} */
-            const interactionContext = this.navigationSessionActive.value && this.navigationSession.interactionContext;
-            if (interactionContext && interactionContext.isActive()) {
-                Logger.get(this).info(`back button pressed during navigation session interaction`);
-                this.runStateTransition((/**
-                 * @param {?} navigationSession
-                 * @return {?}
-                 */
-                navigationSession => navigationSession.onBackClickedDuringNavigationInteraction(url)));
+            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) {
+                /** @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 {?}
+                     */
+                    state => state.onBackClickedDuringNavigationInteraction(url)));
+                }
             }
         }));
     }
@@ -4031,7 +4014,7 @@ class PlaceRouter extends GarbageCollector {
     processNavigationSuccess(session) {
         // We need to update the visits before the session finishes.  This allows the placeOutets to ignore visit
         // changes that occur while routerNavigationActive is true.
-        assert.isTruthy(this.navigationSessionActive.value);
+        assert.isTruthy(this.navigationInProgress.value);
         /** @type {?} */
         const visits = session.getVisits();
         visits.forEach((/**
@@ -4044,14 +4027,14 @@ class PlaceRouter extends GarbageCollector {
     /**
      * @return {?}
      */
-    get navigationSession() {
-        return this._navigationSessionModel.value;
+    get navigationState() {
+        return this._navigationStateModel.value;
     }
     /**
      * @return {?}
      */
-    get navigationSessionModel() {
-        return this._navigationSessionModel.readonly;
+    get navigationStateModel() {
+        return this._navigationStateModel.readonly;
     }
     /**
      * @return {?}
@@ -4103,7 +4086,7 @@ class PlaceRouter extends GarbageCollector {
                  */
                 router => {
                     /** @type {?} */
-                    const commands = this.parseUrl(this.router.routerState.snapshot).createRedirectCommandsFor(next);
+                    const commands = this.parseUrl(this.router.routerState.snapshot.url).createRedirectCommandsFor(next);
                     console.log('### Push Changes to route Redirect', { commands });
                     return router.navigate(commands);
                 }));
@@ -4117,7 +4100,7 @@ class PlaceRouter extends GarbageCollector {
      */
     doNavigation(visit, runNavigationCommands) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.navigationSessionActive.value) {
+            if (this.navigationInProgress.value) {
                 lang.illegalState('Navigation already in progress');
             }
             this.runStateTransition((/**
@@ -4126,7 +4109,7 @@ class PlaceRouter extends GarbageCollector {
              */
             current => {
                 /** @type {?} */
-                const session = new NavigationState.Active(this._navigationSessionContext, false, this.router.routerState.snapshot.url);
+                const session = new NavigationState.NavigationTransition(this._navigationSessionContext, false, this.router.routerState.snapshot.url);
                 session.storeVisit(visit);
                 return session;
             }));
@@ -4136,7 +4119,7 @@ class PlaceRouter extends GarbageCollector {
             finally {
                 // Router has finished (since there was no router change required) so we
                 // need to end the navigation session.
-                if (this.navigationSession.active && !this.router.getCurrentNavigation()) {
+                if (this.navigationState.isTransitional && !this.router.getCurrentNavigation()) {
                     this.runStateTransition((/**
                      * @param {?} session
                      * @return {?}
@@ -4153,10 +4136,10 @@ class PlaceRouter extends GarbageCollector {
      */
     runStateTransition(transition) {
         /** @type {?} */
-        const previous = this._navigationSessionModel.value;
+        const previous = this._navigationStateModel.value;
         /** @type {?} */
-        const next = transition(this.navigationSession);
-        this._navigationSessionModel.value = next;
+        const next = transition(this.navigationState);
+        this._navigationStateModel.value = next;
         if (next !== previous) {
             previous.dispose();
             Logger.get(this).info(`Router State Transition: ${previous.toString()} -> ${next.toString()}`);
@@ -4186,11 +4169,71 @@ class PlaceRouter extends GarbageCollector {
         child => child.url)));
     }
     /**
-     * @param {?} snapshot
+     * @param {?} url
+     * @return {?}
+     */
+    parseUrl(url) {
+        return new UrlSnapshot(this.urlSerializer, url);
+    }
+    /**
+     * @param {?} url
+     * @return {?}
+     */
+    resetBrowserLocation(url) {
+        this.angularLocation.go(url);
+    }
+    /**
+     * @return {?}
+     */
+    getCurrentRouterUrl() {
+        return this.router.routerState ? this.router.routerState.snapshot.url : null;
+    }
+    /**
+     * @param {?} url
+     * @return {?}
+     */
+    getActiveInteractionIdsFromUrl(url) {
+        return this.parseUrl(url).getInteractionIds();
+    }
+    // @Trace()
+    /**
+     * @param {?} url
+     * @return {?}
+     */
+    hasActiveInteractionIds(url) {
+        return this.getActiveInteractionIdsFromUrl(url).length > 0;
+    }
+    /**
      * @return {?}
      */
-    parseUrl(snapshot) {
-        return new UrlSnapshot(this.urlSerializer.parse(snapshot.url));
+    syncInteractionIdsWithRouter() {
+        assert.isFalsey(this.navigationInProgress.value); // Updating interaction routes during an existing navigation breaks all the things.
+        // Updating interaction routes during an existing navigation breaks all the things.
+        /** @type {?} */
+        const currentIds = this.interactionService.activeInteractionContextIds.value;
+        if (___default.isEqual(currentIds, this.getActiveInteractionIdsFromUrl(this.getCurrentRouterUrl()))) {
+            console.log('activity ids were the same, skipping');
+        }
+        else {
+            if (currentIds.length < 1) {
+                this.router.navigate(['.', {
+                        outlets: {
+                            [UrlSnapshot.INTERACTION_ROUTER_OUTLET]: null
+                        }
+                    }], {
+                    replaceUrl: true // remove the interaction from the history.
+                });
+            }
+            else {
+                /** @type {?} */
+                const urlSnapshot = this.parseUrl(this.getCurrentRouterUrl());
+                this.router.navigate(['.', {
+                        outlets: {
+                            [UrlSnapshot.INTERACTION_ROUTER_OUTLET]: UrlSnapshot.createInteractionOutletRouterCommands(currentIds)
+                        }
+                    }]);
+            }
+        }
     }
 }
 PlaceRouter.decorators = [
@@ -4204,27 +4247,28 @@ PlaceRouter.ctorParameters = () => [
     { type: UrlSerializer },
     { type: Location },
     { type: PlaceHistory },
-    { type: ModalInteractionService }
+    { type: InteractionService }
 ];
-/** @nocollapse */ PlaceRouter.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(ɵɵinject(Router), ɵɵinject(UrlSerializer), ɵɵinject(Location), ɵɵinject(PlaceHistory), ɵɵinject(ModalInteractionService)); }, token: PlaceRouter, providedIn: "root" });
+/** @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 {?}
      * @private
      */
-    PlaceRouter.prototype.firstRoute;
-    /**
-     * @type {?}
-     * @private
-     */
-    PlaceRouter.prototype._navigationSessionModel;
+    PlaceRouter.prototype._navigationStateModel;
     /**
      * @type {?}
      * @private
      */
     PlaceRouter.prototype._activeVisits;
     /** @type {?} */
-    PlaceRouter.prototype.navigationSessionActive;
+    PlaceRouter.prototype.navigationInProgress;
     /** @type {?} */
     PlaceRouter.prototype.activeVisitIndex;
     /**
@@ -4232,6 +4276,11 @@ if (false) {
      * @private
      */
     PlaceRouter.prototype._navigationSessionContext;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouter.prototype._navigationStateTypeModel;
     /**
      * @type {?}
      * @private
@@ -4256,65 +4305,8 @@ if (false) {
      * @type {?}
      * @private
      */
-    PlaceRouter.prototype.modalInteractionService;
+    PlaceRouter.prototype.interactionService;
 }
-(function (PlaceRouter) {
-    PlaceRouter.INTERACTION_ROUTER_OUTLET = 'aup-interaction';
-    class InteractionRouteMediator {
-        /**
-         * @param {?} navigationSessionModelActive
-         * @param {?} router
-         */
-        constructor(navigationSessionModelActive, router) {
-            this.navigationSessionModelActive = navigationSessionModelActive;
-            this.router = router;
-        }
-        /**
-         * @return {?}
-         */
-        get isNavigating() {
-            return this.navigationSessionModelActive.value;
-        }
-        // If we're not in a navigation we push
-        // @Trace()
-        /**
-         * @return {?}
-         */
-        onActivityStarted() {
-            if (!this.isNavigating) {
-                this.router.navigate(['.', {
-                        outlets: {
-                            [PlaceRouter.INTERACTION_ROUTER_OUTLET]: ['modal'] // "open" must be a valid route for this outlet.
-                        }
-                    }], {
-                    replaceUrl: false
-                });
-            }
-        }
-        // @Trace()
-        /**
-         * @return {?}
-         */
-        onActivityFinished() {
-            if (!this.isNavigating) {
-                this.router.navigate(['.', {
-                        outlets: {
-                            [PlaceRouter.INTERACTION_ROUTER_OUTLET]: null
-                        }
-                    }], {
-                    replaceUrl: true // remove the interaction from the history.
-                });
-            }
-        }
-    }
-    PlaceRouter.InteractionRouteMediator = InteractionRouteMediator;
-    if (false) {
-        /** @type {?} */
-        InteractionRouteMediator.prototype.navigationSessionModelActive;
-        /** @type {?} */
-        InteractionRouteMediator.prototype.router;
-    }
-})(PlaceRouter || (PlaceRouter = {}));
 
 /**
  * @fileoverview added by tsickle
@@ -4408,9 +4400,9 @@ class PlaceOutletComponent extends DisposableComponent {
         this.placeChanged = new EventEmitter();
         this._activePlace = new MutableValueModel();
         this._activePlaceVisitModel = new DelegatingValueModel();
-        this._inOutletActivation = new Guard$1();
-        this._inOutletDeactivation = new Guard$1();
-        this._inRouteVisitUpdate = new Guard$1();
+        this._inOutletActivation = new Guard();
+        this._inOutletDeactivation = new Guard();
+        this._inRouteVisitUpdate = new Guard();
         this._activatedRouteModel = new MutableValueModel();
         this._placeDefinition = new MutableValueModel();
         this.initialPlaceIndex = null;
@@ -4470,10 +4462,10 @@ class PlaceOutletComponent extends DisposableComponent {
         (next, previous) => {
             this.pushVisitChangesToRoute(next, previous);
         }), {
-            unless: this.placeRouter.navigationSessionActive
+            unless: this.placeRouter.navigationInProgress
         });
         chain(this._activePlace)
-            .postponeWhile(placeRouter.navigationSessionActive)
+            .postponeWhile(placeRouter.navigationInProgress)
             .subscribe((/**
          * @param {?} place
          * @return {?}
@@ -5393,6 +5385,201 @@ if (false) {
     ActivityOutletContext.prototype.componentReady = function (component) { };
 }
 
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class DialogInteractionContext extends InteractionContextBase {
+    /**
+     * @param {?} dialogService
+     * @param {?} config
+     */
+    constructor(dialogService, config) {
+        super();
+        this.dialogService = dialogService;
+        this.config = config;
+        this._activeModel = new MutableValueModel(false);
+        assert$1.notNil(dialogService);
+        this.onDispose((/**
+         * @return {?}
+         */
+        () => {
+            if (this.isActive()) {
+                lang.illegalState('Dispose called while active.');
+            }
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    get active() {
+        return this._activeModel.readonly;
+    }
+    /**
+     * @protected
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?} data
+     * @param {?=} disableClose
+     * @return {?}
+     */
+    _startActivity(activityType, data, disableClose = true) {
+        if (this.isActive()) {
+            lang.illegalState(`Activity already in progress: ${this.activityList.value.map((/**
+             * @param {?} a
+             * @return {?}
+             */
+            a => a.constructor.name)).join(', ')}`);
+        }
+        this._activeModel.value = true;
+        /** @type {?} */
+        const config = Object.assign({}, this.config, {
+            data,
+            disableClose,
+            panelClass: 'dialog-interaction-context'
+        });
+        /** @type {?} */
+        const self = this;
+        /** @type {?} */
+        const matDialogRef = (/** @type {?} */ (this.dialogService.open(ActivityContainerComponent, config)));
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            /** @type {?} */
+            const activityContainer = matDialogRef.componentInstance;
+            self.safelyUpdateActivityListDelegate(activityContainer.activityList);
+            activityContainer.initialActivityOutletContext = {
+                activityClass: activityType,
+                activityData: data,
+                /**
+                 * @param {?} result
+                 * @return {?}
+                 */
+                onDone(result) {
+                    resolve(result);
+                    matDialogRef.close(true); // return true to let the after close listener know we've already handled it.
+                },
+                /**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                onCancel(error) {
+                    reject(error);
+                    matDialogRef.close(true); // return true to let the after close listener know we've already handled it.
+                }
+            };
+            // we need to check if our onDone/onCancel methods above we called or if we were
+            // closed by the user clicking the backdrop.  If the later then we need to reject
+            // our promise.
+            matDialogRef.afterClosed().subscribe((/**
+             * @param {?} promiseAlreadyFinished
+             * @return {?}
+             */
+            promiseAlreadyFinished => {
+                if (!promiseAlreadyFinished) {
+                    reject('auto-closed');
+                }
+            }));
+            matDialogRef.updateSize();
+            matDialogRef.afterOpened().subscribe((/**
+             * @param {?} promiseAlreadyFinished
+             * @return {?}
+             */
+            promiseAlreadyFinished => {
+                matDialogRef.updateSize();
+            }));
+        })).finally((/**
+         * @return {?}
+         */
+        () => {
+            self.safelyUpdateActivityListDelegate(null);
+            this._activeModel.value = false;
+        }));
+    }
+    /**
+     * Updates teh delegate on the next tick to avoid modifying state during the current change detection cycle.
+     * @param {?} delegate
+     * @return {?}
+     */
+    safelyUpdateActivityListDelegate(delegate) {
+        setTimeout((/**
+         * @return {?}
+         */
+        () => this.setActivityList(delegate)));
+    }
+}
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    DialogInteractionContext.prototype._activeModel;
+    /**
+     * @type {?}
+     * @private
+     */
+    DialogInteractionContext.prototype.dialogService;
+    /** @type {?} */
+    DialogInteractionContext.prototype.config;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @type {?} */
+const DIALOG_INTERACTION_SERVICE_DEFAULTS = new InjectionToken('DIALOG_INTERACTION_SERVICE_DEFAULTS');
+class DialogInteractionContextFactory extends ModalInteractionContextFactory {
+    /**
+     * @param {?} dialogService
+     * @param {?} dialogServiceDefaults
+     * @param {?} matDialogDefaultConfig
+     */
+    constructor(dialogService, dialogServiceDefaults, matDialogDefaultConfig) {
+        super();
+        this.dialogService = dialogService;
+        this.dialogServiceDefaults = dialogServiceDefaults;
+        this.matDialogDefaultConfig = matDialogDefaultConfig;
+        assert$1.notNil(dialogService);
+    }
+    /**
+     * @return {?}
+     */
+    createInteractionContext() {
+        /** @type {?} */
+        const config = Object.assign({ autoFocus: false, hasBackdrop: true, closeOnNavigation: false }, this.matDialogDefaultConfig, this.dialogServiceDefaults);
+        return new DialogInteractionContext(this.dialogService, config);
+    }
+}
+DialogInteractionContextFactory.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+DialogInteractionContextFactory.ctorParameters = () => [
+    { type: MatDialog },
+    { type: MatDialogConfig, decorators: [{ type: Optional }, { type: Inject, args: [DIALOG_INTERACTION_SERVICE_DEFAULTS,] }] },
+    { type: MatDialogConfig, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DIALOG_DEFAULT_OPTIONS,] }] }
+];
+/** @nocollapse */ DialogInteractionContextFactory.ngInjectableDef = ɵɵdefineInjectable({ factory: function DialogInteractionContextFactory_Factory() { return new DialogInteractionContextFactory(ɵɵinject(MatDialog$1), ɵɵinject(DIALOG_INTERACTION_SERVICE_DEFAULTS, 8), ɵɵinject(MAT_DIALOG_DEFAULT_OPTIONS, 8)); }, token: DialogInteractionContextFactory, providedIn: "root" });
+if (false) {
+    /** @type {?} */
+    DialogInteractionContextFactory.prototype.active;
+    /**
+     * @type {?}
+     * @private
+     */
+    DialogInteractionContextFactory.prototype.dialogService;
+    /** @type {?} */
+    DialogInteractionContextFactory.prototype.dialogServiceDefaults;
+    /** @type {?} */
+    DialogInteractionContextFactory.prototype.matDialogDefaultConfig;
+}
+
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -5726,17 +5913,17 @@ class AbstractPlaceGuard {
                 /** @type {?} */
                 const parsedParams = placeDefinition.parseRouteParams(params);
                 /** @type {?} */
-                const initialVisit = this.placeRouter.navigationSession.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);
+                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.navigationSession.storeVisit(sanitisedVisit);
+                this.placeRouter.navigationState.storeVisit(sanitisedVisit);
                 if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {
                     // Regenerate the url
                     /** @type {?} */
-                    const commands = this.placeRouter.parseUrl(state).createRedirectCommandsFor(sanitisedVisit);
+                    const commands = this.placeRouter.parseUrl(state.url).createRedirectCommandsFor(sanitisedVisit);
                     console.log('##### Place Guard Redirect', commands);
                     return this.router.createUrlTree(commands, {
                         replaceUrl: true,
@@ -5758,7 +5945,7 @@ class AbstractPlaceGuard {
      */
     canDeactivate(component, currentRoute, currentState, nextState) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.placeRouter.navigationSession.canDeactivatePlace(component, this.placeRouter.parseUrl(nextState));
+            return this.placeRouter.navigationState.canDeactivatePlace(component, this.placeRouter.parseUrl(nextState.url));
         });
     }
     // @Trace()
@@ -5766,22 +5953,23 @@ class AbstractPlaceGuard {
      * @protected
      * @param {?} activatedRoute
      * @param {?} state
-     * @param {?} canActivate
+     * @param {?} runPlaceGuards
      * @return {?}
      */
-    authorisePlaceThen(activatedRoute, state, canActivate) {
+    authorisePlaceThen(activatedRoute, state, runPlaceGuards) {
         return __awaiter(this, void 0, void 0, function* () {
             if (PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) {
                 /** @type {?} */
                 const placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);
                 /** @type {?} */
-                const authorised = placeDefinition.authenticate ? yield this.isAuthorised(activatedRoute, state) : true;
-                if (authorised === true) {
-                    return canActivate(placeDefinition);
+                const authoriseResult = placeDefinition.authenticate ? yield this.isAuthorised(activatedRoute, state) : true;
+                if (authoriseResult === true) {
+                    // we're authorised, now run the place guards.
+                    return runPlaceGuards(placeDefinition);
                 }
                 else {
-                    console.log('not authorised result', authorised);
-                    return authorised;
+                    console.log('not authorised result', authoriseResult);
+                    return authoriseResult;
                 }
             }
             else {
@@ -5852,14 +6040,14 @@ class InteractionGuard {
      * @param {?} injector
      * @param {?} placeRouter
      * @param {?} angularLocation
-     * @param {?} modalInteractionService
+     * @param {?} interactionService
      */
-    constructor(router, injector, placeRouter, angularLocation, modalInteractionService) {
+    constructor(router, injector, placeRouter, angularLocation, interactionService) {
         this.router = router;
         this.injector = injector;
         this.placeRouter = placeRouter;
         this.angularLocation = angularLocation;
-        this.modalInteractionService = modalInteractionService;
+        this.interactionService = interactionService;
     }
     /**
      * @param {?} route
@@ -5869,10 +6057,10 @@ class InteractionGuard {
     canActivate(route, state) {
         /** @type {?} */
         const url = this.router.parseUrl(state.url);
-        if (!this.modalInteractionService.isActive() && url.root.children[PlaceRouter.INTERACTION_ROUTER_OUTLET]) {
+        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[PlaceRouter.INTERACTION_ROUTER_OUTLET];
+            delete url.root.children[UrlSnapshot.INTERACTION_ROUTER_OUTLET];
             return url;
         }
         else {
@@ -5888,16 +6076,22 @@ class InteractionGuard {
      */
     canDeactivate(component, currentRoute, currentState, nextState) {
         return __awaiter(this, void 0, void 0, function* () {
-            /** @type {?} */
-            const popstateReturnUrl = this.placeRouter.navigationSession.startingUrl;
-            if (this.modalInteractionService.isActive()) {
-                // The activity is still active so the route change was triggered by the back button.
+            if (this.interactionService.isActive()) {
+                /** @type {?} */
+                const currentIds = this.interactionService.activeInteractionContextIds.value;
                 /** @type {?} */
-                const activity = yield this.modalInteractionService.getCurrentActivity();
-                activity.cancel();
-                // See ModalInteractionSession#onStart() for the url updating.
-                return false;
+                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();
+                }
             }
+            // 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;
         });
     }
@@ -5913,9 +6107,9 @@ InteractionGuard.ctorParameters = () => [
     { type: Injector },
     { type: PlaceRouter },
     { type: Location },
-    { type: ModalInteractionService }
+    { type: InteractionService }
 ];
-/** @nocollapse */ InteractionGuard.ngInjectableDef = ɵɵdefineInjectable({ factory: function InteractionGuard_Factory() { return new InteractionGuard(ɵɵinject(Router), ɵɵinject(INJECTOR), ɵɵinject(PlaceRouter), ɵɵinject(Location), ɵɵinject(ModalInteractionService)); }, token: InteractionGuard, providedIn: "root" });
+/** @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 {?}
@@ -5941,7 +6135,7 @@ if (false) {
      * @type {?}
      * @private
      */
-    InteractionGuard.prototype.modalInteractionService;
+    InteractionGuard.prototype.interactionService;
 }
 
 /**
@@ -6218,5 +6412,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, DialogInteractionService, Dimension, DirectivesModule, DisposableComponent, EmptyStateComponent, FocusBindingDirective, Formatter, InplaceInteractionContextComponent, InteractionContext, InteractionContextBase, InteractionGuard, InteractionModule, InteractionOutletComponent, LEFT_RIGHT_PLACE_ANIMATION, ListPlaceNavComponent, ModalInteractionService, 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, ActivityContainerComponent as ɵba, InteractionContextBase as ɵbb, InteractionContext as ɵbc, ActivityOutletComponent as ɵbd, ConfirmationDialogComponent as ɵbe, AbstractActivity as ɵbf, ACTIVITY_DATA as ɵbg, Activity as ɵbh, ConfirmThenDialogComponent as ɵbj, AlertDialogComponent as ɵbk, InteractionOutletComponent as ɵbm, InplaceInteractionContextComponent as ɵbn, DIALOG_INTERACTION_SERVICE_DEFAULTS as ɵbo, DialogInteractionService as ɵbp, 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, ModalInteractionService as ɵv, TabbedPlaceNavigationComponent as ɵw, AbstractPlaceNavigationComponent as ɵx, ListPlaceNavComponent as ɵy, InteractionModule as ɵz };
+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 };
 //# sourceMappingURL=coolon-angular-ui-powerups.js.map