@coolon/angular-ui-powerups 0.0.63 → 0.0.65

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

@@ -5,18 +5,19 @@ import { MatDialog, MatButtonModule, MatDialogModule, MatTabsModule, MatProgress
 import { MatTabsModule as MatTabsModule$1 } from '@angular/material/tabs';
 import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
 import { __decorate, __metadata, __awaiter } from 'tslib';
-import { GarbageCollector, DelegatingFormValueModel, UseDelegate, ValueModel, ListModel, StoreInListModel, assert, UnaryCommand, lang, Dsl, Logger, DelegatingValueModel, MutableListModel, DelegatingListModel, StoreInValueModel, Binding, MutableValueModel, Guard, OptionsHelper, ValueHolder, Trace } from '@coolon/pectin';
+import { GarbageCollector, DelegatingFormValueModel, UseDelegate, ValueModel, ListModel, StoreInListModel, assert, UnaryCommand, lang, Dsl, Logger, DelegatingValueModel, MutableStream, MutableListModel, DelegatingListModel, StoreInValueModel, Binding, MutableValueModel, Guard as Guard$1, OptionsHelper, ValueHolder } from '@coolon/pectin';
 import { PortalModule } from '@angular/cdk/portal';
+import ___default, { last, isNil } from 'lodash';
 import { assert as assert$1, Klass, Opts } from '@coolon/typescript-utilities';
 import { MatDialogConfig, MAT_DIALOG_DEFAULT_OPTIONS, MatDialog as MatDialog$1 } from '@angular/material/dialog';
-import { Router, RouterModule, NavigationEnd, NavigationError } from '@angular/router';
+import { v1 } from 'uuid';
 import { MatIconModule } from '@angular/material/icon';
 import { MatListModule } from '@angular/material/list';
 import { MatTooltipModule } from '@angular/material/tooltip';
+import { Router, NavigationStart, NavigationEnd, NavigationError, RouterModule } from '@angular/router';
 import { Memoize as Memoize$1 } from '@typescript-plus/fast-memoize-decorator/dist/src';
 import { Memoize } from '@typescript-plus/fast-memoize-decorator';
 import 'reflect-metadata';
-import ___default, { isNil } from 'lodash';
 import { style, query, group, animate, trigger, transition } from '@angular/animations';
 import ResizeObserver from 'resize-observer-polyfill';
 
@@ -655,17 +656,22 @@ if (false) {
  * @abstract
  */
 class InteractionContext extends GarbageCollector {
+    /**
+     * @protected
+     */
     constructor() {
         super();
     }
-}
-if (false) {
     /**
      * Returns the activity that is currently active.
      * This model is only updated in the next tick after the view has been updated.
-     * @type {?}
+     * @return {?}
      */
-    InteractionContext.prototype.currentActivity;
+    get currentActivity() {
+        return last(this.activityList.value);
+    }
+}
+if (false) {
     /**
      * Returns the current list of activities that are in progress.
      * This model is only updated in the next tick after the view has been updated.
@@ -717,29 +723,87 @@ if (false) {
 /** @type {?} */
 const ACTIVITY_DATA = new InjectionToken('InteractionActivityData');
 /**
- * @record
+ * @abstract
  * @template D, R, E
  */
-function Activity() { }
-if (false) {
-    /** @type {?} */
-    Activity.prototype.busy;
+class Activity {
+    constructor() {
+        this._busyModel = new DelegatingValueModel().withDefault(false);
+    }
     /**
      * @param {?} activityContext
      * @return {?}
      */
-    Activity.prototype.initialise = function (activityContext) { };
+    initialise(activityContext) {
+        assert$1.isNil(this._activityContext);
+        this._activityContext = activityContext;
+    }
     /**
-     * @param {?} result
+     * @param {?=} result
+     * @return {?}
+     */
+    done(result) {
+        return this._activityContext.onDone(result);
+    }
+    /**
+     * @param {?=} error
      * @return {?}
      */
-    Activity.prototype.done = function (result) { };
+    cancel(error) {
+        this._activityContext.onCancel(error);
+    }
+    // @Trace()
+    /**
+     * @return {?}
+     */
+    onActivityReady() {
+    }
     /**
-     * @param {?} e
      * @return {?}
      */
-    Activity.prototype.cancel = function (e) { };
+    get busy() {
+        return this._busyModel.readonly;
+    }
+    /**
+     * @param {?} busyModel
+     * @return {?}
+     */
+    busyWhile(busyModel) {
+        this._busyModel.setDelegate(busyModel);
+    }
+    /**
+     * @return {?}
+     */
+    isBusy() {
+        return this._busyModel.value;
+    }
+}
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    Activity.prototype._busyModel;
+    /**
+     * @type {?}
+     * @private
+     */
+    Activity.prototype._activityContext;
 }
+(function (Activity) {
+    /**
+     * @record
+     * @template R, E
+     */
+    function Callbacks() { }
+    Activity.Callbacks = Callbacks;
+    if (false) {
+        /** @type {?} */
+        Callbacks.prototype.onDone;
+        /** @type {?} */
+        Callbacks.prototype.onCancel;
+    }
+})(Activity || (Activity = {}));
 
 /**
  * @fileoverview added by tsickle
@@ -769,9 +833,17 @@ class ActivityOutletComponent {
      * @return {?}
      */
     set activityContext(activityContext) {
+        assert.isNil(this._activityContext);
+        this._activityContext = activityContext;
         this.loadActivity(activityContext);
     }
     ;
+    /**
+     * @return {?}
+     */
+    get activityContext() {
+        return this._activityContext;
+    }
     /**
      * @return {?}
      */
@@ -787,7 +859,7 @@ class ActivityOutletComponent {
             providers: [
                 {
                     provide: InteractionContext,
-                    useValue: this
+                    useValue: this.interactionContext
                 },
                 { provide: ACTIVITY_DATA, useValue: activityContext.activityData }
             ],
@@ -798,6 +870,9 @@ class ActivityOutletComponent {
         this.viewContainerRef.clear();
         this.activityComponentRef = this.viewContainerRef.createComponent(componentFactory, 0, injector);
         this.activityComponentRef.instance.initialise(activityContext);
+        if (this.activityContext.componentReady) {
+            this.activityContext.componentReady(this.component);
+        }
     }
     /**
      * @return {?}
@@ -805,47 +880,6 @@ class ActivityOutletComponent {
     get component() {
         return this.activityComponentRef.instance;
     }
-    /**
-     * @param {?} alert
-     * @return {?}
-     */
-    alert(alert) {
-        return this.interactionContext.alert(alert);
-    }
-    /**
-     * @param {?} confirm
-     * @return {?}
-     */
-    confirm(confirm) {
-        return this.interactionContext.confirm(confirm);
-    }
-    /**
-     * @template D1, R1, E1
-     * @param {?} confirm
-     * @param {?} activityType
-     * @param {?=} data
-     * @return {?}
-     */
-    confirmThen(confirm, activityType, data) {
-        return this.interactionContext.confirmThen(confirm, activityType, data);
-    }
-    /**
-     * @template D1, R1, E1
-     * @param {?} activityType
-     * @param {?=} data
-     * @return {?}
-     */
-    startActivity(activityType, data) {
-        return this.interactionContext.startActivity(activityType, data);
-    }
-    /**
-     * @return {?}
-     */
-    notifyReady() {
-        if (this.activityComponentRef.instance['onActivityReady']) {
-            this.activityComponentRef.instance['onActivityReady']();
-        }
-    }
 }
 ActivityOutletComponent.decorators = [
     { type: Component, args: [{
@@ -867,6 +901,11 @@ ActivityOutletComponent.propDecorators = {
 if (false) {
     /** @type {?} */
     ActivityOutletComponent.prototype.interactionContext;
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityOutletComponent.prototype._activityContext;
     /**
      * @type {?}
      * @private
@@ -895,72 +934,11 @@ if (false) {
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
+ * Deprecated. You can now extend the Activity class directly.
+ * @abstract
  * @template D, R, E
  */
-class AbstractActivity extends DisposableComponent {
-    constructor() {
-        super(...arguments);
-        this._busyModel = new DelegatingValueModel().withDefault(false);
-    }
-    /**
-     * @param {?} activityContext
-     * @return {?}
-     */
-    initialise(activityContext) {
-        assert$1.isNil(this.activityContext);
-        this.activityContext = activityContext;
-    }
-    /**
-     * @param {?=} result
-     * @return {?}
-     */
-    done(result) {
-        return this.activityContext.onDone(result);
-    }
-    /**
-     * @param {?=} error
-     * @return {?}
-     */
-    cancel(error) {
-        this.activityContext.onCancel(error);
-    }
-    // @Trace()
-    /**
-     * @return {?}
-     */
-    onActivityReady() {
-    }
-    /**
-     * @return {?}
-     */
-    get busy() {
-        return this._busyModel.readonly;
-    }
-    /**
-     * @param {?} busyModel
-     * @return {?}
-     */
-    busyWhile(busyModel) {
-        this._busyModel.setDelegate(busyModel);
-    }
-    /**
-     * @return {?}
-     */
-    isBusy() {
-        return this._busyModel.value;
-    }
-}
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    AbstractActivity.prototype._busyModel;
-    /**
-     * @type {?}
-     * @private
-     */
-    AbstractActivity.prototype.activityContext;
+class AbstractActivity extends Activity {
 }
 
 /**
@@ -1129,101 +1107,175 @@ if (false) {
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
-class ActivityContainerComponent extends DisposableComponent {
-    constructor() {
-        super();
-        this.activityOutletTabs = new MutableListModel();
-        this.obsoleteTabs = [];
-        this.finished = false;
-        this._activityList = new MutableListModel();
+/**
+ * Note: this class is mutable and is stored in a list model.  This is normally a big no no but
+ *  we're manually deriving other models from the list after view state changes.  I.e. we not
+ *  using pectin chains on any of the mutable fields.
+ * @template D, R, E
+ */
+class TabContext {
+    /**
+     * @param {?} activityData
+     * @param {?} activityClass
+     * @param {?} interactionContext
+     * @param {?} activityCallbacks
+     */
+    constructor(activityData, activityClass, interactionContext, activityCallbacks) {
+        this.activityData = activityData;
+        this.activityClass = activityClass;
+        this.interactionContext = interactionContext;
+        this.activityCallbacks = activityCallbacks;
+        this._complete = false;
     }
     /**
      * @return {?}
      */
-    isActive() {
-        return this.parentInteractionContext.isActive();
+    isComponentRealised() {
+        return !!this._component;
     }
     /**
      * @return {?}
      */
-    get activityList() {
-        return this._activityList.readonly;
+    isComplete() {
+        return this._complete;
     }
     /**
+     * @param {?} component
      * @return {?}
      */
-    ngOnInit() {
+    componentReady(component) {
+        assert.isNil(this._component);
+        this._component = component;
     }
     /**
      * @return {?}
      */
-    ngAfterViewInit() {
-        const { observe } = Dsl.disposeWith(this);
-        this._activityList.value = this.outlets.toArray().map((/**
-         * @param {?} c
-         * @return {?}
-         */
-        c => c.component));
-        observe.valuesFrom(this.outlets.changes).subscribe((/**
-         * @param {?} change
-         * @return {?}
-         */
-        (change) => {
-            this.safelyUpdateActivityList(change.map((/**
-             * @param {?} c
-             * @return {?}
-             */
-            c => c.component)));
-        }));
-        observe.valuesFrom(this.tabs.animationDone).subscribe((/**
-         * @return {?}
-         */
-        () => this.onAnimationFinished()));
+    get component() {
+        return this._component;
     }
+    // @Trace()
     /**
-     * Update in the next tick to avoid changing state in the current change detection cycle.
-     * @private
-     * @param {?} activities
+     * @param {?} result
      * @return {?}
      */
-    safelyUpdateActivityList(activities) {
-        setTimeout((/**
+    onDone(result) {
+        this._complete = true;
+        this.activityCallbacks.onDone(result);
+    }
+    // @Trace()
+    /**
+     * @param {?} error
+     * @return {?}
+     */
+    onCancel(error) {
+        this._complete = true;
+        this.activityCallbacks.onCancel(error);
+    }
+}
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    TabContext.prototype._complete;
+    /**
+     * @type {?}
+     * @private
+     */
+    TabContext.prototype._component;
+    /** @type {?} */
+    TabContext.prototype.activityData;
+    /** @type {?} */
+    TabContext.prototype.activityClass;
+    /** @type {?} */
+    TabContext.prototype.interactionContext;
+    /** @type {?} */
+    TabContext.prototype.activityCallbacks;
+}
+/**
+ * @template D, R, E
+ */
+class ActivityContainerComponent extends InteractionContext {
+    constructor() {
+        super();
+        this.activityFinishedEvents = new MutableStream();
+        this.activityTabs = new MutableListModel();
+        this.finished = false;
+        this._activityList = new MutableListModel();
+        const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
+        chain(this.activityFinishedEvents).throttle(50).subscribe((/**
          * @return {?}
          */
-        () => this._activityList.value = activities));
+        () => this.onActivityFinished()));
     }
     /**
-     * @template D, R, E
      * @param {?} initialContext
      * @return {?}
      */
-    initialise(initialContext) {
-        /** @type {?} */
-        const self = this;
-        this.initialActivityOutletContext = {
-            activityClass: initialContext.activityClass,
-            activityData: initialContext.activityData,
+    set initialActivityOutletContext(initialContext) {
+        assert.isNil(this.initialActivityOutletContext);
+        this.activityTabs.push(new TabContext(initialContext.activityData, initialContext.activityClass, this, {
             onDone: (/**
              * @param {?} result
              * @return {?}
              */
-            function (result) {
-                self.finished = true;
+            (result) => {
+                this.finished = true;
                 return initialContext.onDone(result);
             }),
             onCancel: (/**
              * @param {?} error
              * @return {?}
              */
-            function (error) {
-                self.finished = true;
+            (error) => {
+                this.finished = true;
                 return initialContext.onCancel(error);
-            }),
-            interactionContext: this
-        };
+            })
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    get initialActivityOutletContext() {
+        return this.activityTabs.length > 0 ? this.activityTabs.value[0] : null;
+    }
+    /**
+     * @return {?}
+     */
+    isActive() {
+        return this.parentInteractionContext.isActive();
+    }
+    /**
+     * @return {?}
+     */
+    get activityList() {
+        return this._activityList.readonly;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        const { chain, observe } = Dsl.disposeWith(this);
+        observe.valuesFrom(this.outlets.changes).subscribe((/**
+         * @return {?}
+         */
+        () => setTimeout((/**
+         * @return {?}
+         */
+        () => this.updateActivityList()))));
+        observe.valuesFrom(this.tabs.animationDone).subscribe((/**
+         * @return {?}
+         */
+        () => this.onAnimationFinished()));
+        this.updateActivityList();
     }
     /**
-     * @template D, R, E
+     * @template D1, R1, E1
      * @param {?} activityType
      * @param {?=} data
      * @return {?}
@@ -1238,41 +1290,26 @@ class ActivityContainerComponent extends DisposableComponent {
          */
         (resolve, reject) => {
             /** @type {?} */
-            const context = {
-                interactionContext: self,
-                activityClass: activityType,
-                activityData: data,
+            const context = new TabContext(data, activityType, self, {
                 onDone: (/**
                  * @param {?} result
                  * @return {?}
                  */
                 function (result) {
-                    self.obsoleteTabs.push(context);
-                    // animating on the next tick gives chained done's a chance to
-                    // finished before we start an animations
                     resolve(result);
-                    setTimeout((/**
-                     * @return {?}
-                     */
-                    () => self.animateTabs()));
+                    self.activityFinishedEvents.publish({});
                 }),
                 onCancel: (/**
                  * @param {?} error
                  * @return {?}
                  */
                 function (error) {
-                    self.obsoleteTabs.push(context);
-                    // finished before we start an animations
                     reject(error);
-                    // animating on the next tick gives chained done's a chance to complete before we animate
-                    setTimeout((/**
-                     * @return {?}
-                     */
-                    () => self.animateTabs()));
+                    self.activityFinishedEvents.publish({});
                 })
-            };
-            self.activityOutletTabs.push(context);
-            self.tabs.selectedIndex = this.activityOutletTabs.length;
+            });
+            self.activityTabs.push(context);
+            self.tabs.selectedIndex = this.activityTabs.length;
         }));
     }
     /**
@@ -1290,7 +1327,7 @@ class ActivityContainerComponent extends DisposableComponent {
         return this.startActivity(ConfirmationDialogComponent, confirm);
     }
     /**
-     * @template D, R, E
+     * @template D1, R1, E1
      * @param {?} confirm
      * @param {?} activityType
      * @param {?=} data
@@ -1303,35 +1340,92 @@ class ActivityContainerComponent extends DisposableComponent {
             data: data
         });
     }
+    // @Trace()
+    /**
+     * @private
+     * @return {?}
+     */
+    onActivityFinished() {
+        // don't do anything if job already queued up.
+        if (!this.finished) {
+            if (this.synchroniseSelectedTabIndex()) {
+                this.cleanupStaleActivities();
+            }
+            this.updateActivityList();
+        }
+    }
+    // @Trace()
+    /**
+     * @private
+     * @return {?}
+     */
+    cleanupStaleActivities() {
+        // clean up old tabs
+        if (this.tabs.selectedIndex < this.activityTabs.length - 1) {
+            this.activityTabs.runInTransaction((/**
+             * @param {?} draft
+             * @return {?}
+             */
+            draft => {
+                draft.value = draft.value.slice(0, 1 + this.tabs.selectedIndex);
+            }));
+        }
+    }
+    /**
+     * Synchronises the selected tab index.  Returns true if there was no change to the selected index.
+     * @private
+     * @return {?}
+     */
+    // @Trace()
+    synchroniseSelectedTabIndex() {
+        /** @type {?} */
+        const previousIndex = this.tabs.selectedIndex;
+        /** @type {?} */
+        const newIndex = this.activityTabs.query().findIndex((/**
+         * @param {?} t
+         * @return {?}
+         */
+        t => t.isComplete())) - 1;
+        this.tabs.selectedIndex = newIndex;
+        return previousIndex === newIndex;
+    }
+    // @Trace()
     /**
      * @private
      * @return {?}
      */
     onAnimationFinished() {
-        this.activityOutletTabs.value = this.activityOutletTabs.value.filter((/**
-         * @param {?} tab
+        this.getSelectedOutlet().component.onActivityReady();
+        this.cleanupStaleActivities();
+        this.updateActivityList();
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    updateActivityList() {
+        this._activityList.value = this.activityTabs.value.filter((/**
+         * @param {?} t
          * @return {?}
          */
-        tab => {
-            return !this.obsoleteTabs.includes(tab);
-        }));
-        this.obsoleteTabs = [];
-        this.outlets.toArray()[this.tabs.selectedIndex].notifyReady();
+        t => !t.isComplete() && t.isComponentRealised())).map((/**
+         * @param {?} t
+         * @return {?}
+         */
+        t => t.component));
     }
     /**
      * @private
      * @return {?}
      */
-    animateTabs() {
-        if (!this.finished) {
-            this.tabs.selectedIndex = this.activityOutletTabs.length - this.obsoleteTabs.length;
-        }
+    getSelectedOutlet() {
+        return this.outlets.toArray()[this.tabs.selectedIndex];
     }
 }
 ActivityContainerComponent.decorators = [
     { type: Component, args: [{
                 selector: 'angular-ui-powerups-activity-container',
-                template: "<mat-tab-group #tabs no-tab-header [dynamicHeight]=\"true\">\n  <mat-tab>\n    <angular-ui-powerups-activity-outlet [interactionContext]=\"this\"\n                                         [activityContext]=\"initialActivityOutletContext\"></angular-ui-powerups-activity-outlet>\n  </mat-tab>\n  <mat-tab *ngFor=\"let tab of activityOutletTabs.value\">\n    <angular-ui-powerups-activity-outlet [interactionContext]=\"this\"\n                                         [activityContext]=\"tab\"></angular-ui-powerups-activity-outlet>\n  </mat-tab>\n</mat-tab-group>\n",
+                template: "<mat-tab-group #tabs no-tab-header [dynamicHeight]=\"true\">\n  <mat-tab *ngFor=\"let tab of activityTabs.value\">\n    <angular-ui-powerups-activity-outlet [interactionContext]=\"this\"\n                                         [activityContext]=\"tab\"></angular-ui-powerups-activity-outlet>\n  </mat-tab>\n</mat-tab-group>\n",
                 styles: [":host{display:block}"]
             }] }
 ];
@@ -1344,23 +1438,19 @@ ActivityContainerComponent.propDecorators = {
     outlets: [{ type: ViewChildren, args: [ActivityOutletComponent,] }]
 };
 if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityContainerComponent.prototype.activityFinishedEvents;
     /** @type {?} */
     ActivityContainerComponent.prototype.parentInteractionContext;
     /** @type {?} */
-    ActivityContainerComponent.prototype.initialActivityOutletContext;
-    /** @type {?} */
-    ActivityContainerComponent.prototype.currentActivity;
-    /** @type {?} */
     ActivityContainerComponent.prototype.tabs;
     /** @type {?} */
     ActivityContainerComponent.prototype.outlets;
     /** @type {?} */
-    ActivityContainerComponent.prototype.activityOutletTabs;
-    /**
-     * @type {?}
-     * @private
-     */
-    ActivityContainerComponent.prototype.obsoleteTabs;
+    ActivityContainerComponent.prototype.activityTabs;
     /**
      * @type {?}
      * @private
@@ -1372,24 +1462,6 @@ if (false) {
      */
     ActivityContainerComponent.prototype._activityList;
 }
-(function (ActivityContainerComponent) {
-    /**
-     * @record
-     * @template D, R, E
-     */
-    function ActivityContext() { }
-    ActivityContainerComponent.ActivityContext = ActivityContext;
-    if (false) {
-        /** @type {?} */
-        ActivityContext.prototype.activityClass;
-        /** @type {?} */
-        ActivityContext.prototype.activityData;
-        /** @type {?} */
-        ActivityContext.prototype.onDone;
-        /** @type {?} */
-        ActivityContext.prototype.onCancel;
-    }
-})(ActivityContainerComponent || (ActivityContainerComponent = {}));
 
 /**
  * @fileoverview added by tsickle
@@ -1397,36 +1469,66 @@ if (false) {
  */
 /** @type {?} */
 const DIALOG_INTERACTION_SERVICE_DEFAULTS = new InjectionToken('DIALOG_INTERACTION_SERVICE_DEFAULTS');
+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;
+    }
+}
 class DialogInteractionService extends InteractionContext {
     /**
      * @param {?} dialogService
-     * @param {?} router
      * @param {?} dialogServiceDefaults
      * @param {?} matDialogDefaultConfig
      */
-    constructor(dialogService, router, dialogServiceDefaults, matDialogDefaultConfig) {
+    constructor(dialogService, dialogServiceDefaults, matDialogDefaultConfig) {
         super();
         this.dialogService = dialogService;
-        this.router = router;
         this.dialogServiceDefaults = dialogServiceDefaults;
         this.matDialogDefaultConfig = matDialogDefaultConfig;
         this._activityList = new DelegatingListModel();
-        this._active = false;
+        this.startingGuard = new Guard();
         assert$1.notNil(dialogService);
-        const { chain, observe } = Dsl.disposeWith(this);
-        this.currentActivity = chain(this.activityList).last();
     }
     /**
      * @return {?}
      */
     isActive() {
-        return this._active;
+        return !!this.currentActivityId;
     }
     /**
      * @return {?}
      */
     cancelActivity() {
-        this.currentActivity.value.cancel(null);
+        this.currentActivity.cancel(null);
     }
     /**
      * @return {?}
@@ -1459,56 +1561,59 @@ class DialogInteractionService extends InteractionContext {
              */
             a => a.constructor.name)).join(', ')}`);
         }
-        this._active = true;
-        /** @type {?} */
-        const self = this;
-        /** @type {?} */
-        const config = Object.assign({ autoFocus: false, hasBackdrop: true, closeOnNavigation: false }, this.matDialogDefaultConfig, this.dialogServiceDefaults, {
-            data,
-            disableClose,
-            panelClass: 'dialog-interaction-service'
-        });
-        /** @type {?} */
-        const matDialogRef = (/** @type {?} */ (this.dialogService.open(ActivityContainerComponent, config)));
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
+        return this.startingGuard.whileTrue((/**
          * @return {?}
          */
-        (resolve, reject) => {
+        () => {
+            this.currentActivityId = v1();
             /** @type {?} */
-            const activityContainer = matDialogRef.componentInstance;
-            activityContainer.parentInteractionContext = this;
-            self.safelyUpdateActivityListDelegate(activityContainer.activityList);
-            activityContainer.initialise({
-                activityClass: activityType,
-                activityData: data,
-                /**
-                 * @param {?} result
-                 * @return {?}
-                 */
-                onDone(result) {
-                    // TODO: should I be calling resolve after close?
-                    resolve(result);
-                    matDialogRef.close(result);
-                },
-                /**
-                 * @param {?} error
-                 * @return {?}
-                 */
-                onCancel(error) {
-                    // TODO: should I be calling reject after close?
-                    reject(error);
-                    matDialogRef.close(error);
-                }
+            const self = this;
+            /** @type {?} */
+            const config = Object.assign({ autoFocus: false, hasBackdrop: true, closeOnNavigation: false }, this.matDialogDefaultConfig, this.dialogServiceDefaults, {
+                data,
+                disableClose,
+                panelClass: 'dialog-interaction-service'
             });
-            matDialogRef.updateSize();
-        })).finally((/**
-         * @return {?}
-         */
-        () => {
-            self.safelyUpdateActivityListDelegate(null);
-            self._active = false;
+            /** @type {?} */
+            const matDialogRef = (/** @type {?} */ (this.dialogService.open(ActivityContainerComponent, config)));
+            return new Promise((/**
+             * @param {?} resolve
+             * @param {?} reject
+             * @return {?}
+             */
+            (resolve, reject) => {
+                /** @type {?} */
+                const activityContainer = matDialogRef.componentInstance;
+                activityContainer.parentInteractionContext = this;
+                self.safelyUpdateActivityListDelegate(activityContainer.activityList);
+                activityContainer.initialActivityOutletContext = {
+                    activityClass: activityType,
+                    activityData: data,
+                    /**
+                     * @param {?} result
+                     * @return {?}
+                     */
+                    onDone(result) {
+                        resolve(result);
+                        matDialogRef.close(result);
+                    },
+                    /**
+                     * @param {?} error
+                     * @return {?}
+                     */
+                    onCancel(error) {
+                        reject(error);
+                        matDialogRef.close(error);
+                    }
+                };
+                matDialogRef.updateSize();
+            })).finally((/**
+             * @return {?}
+             */
+            () => {
+                this.currentActivityId = null;
+                self.safelyUpdateActivityListDelegate(null);
+            }));
         }));
     }
     /**
@@ -1559,14 +1664,11 @@ DialogInteractionService.decorators = [
 /** @nocollapse */
 DialogInteractionService.ctorParameters = () => [
     { type: MatDialog },
-    { type: Router },
     { 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(Router), ɵɵinject(DIALOG_INTERACTION_SERVICE_DEFAULTS, 8), ɵɵinject(MAT_DIALOG_DEFAULT_OPTIONS, 8)); }, token: DialogInteractionService, providedIn: "root" });
+/** @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 {?} */
-    DialogInteractionService.prototype.currentActivity;
     /**
      * @type {?}
      * @private
@@ -1576,17 +1678,17 @@ if (false) {
      * @type {?}
      * @private
      */
-    DialogInteractionService.prototype._active;
+    DialogInteractionService.prototype.startingGuard;
     /**
      * @type {?}
      * @private
      */
-    DialogInteractionService.prototype.dialogService;
+    DialogInteractionService.prototype.currentActivityId;
     /**
      * @type {?}
      * @private
      */
-    DialogInteractionService.prototype.router;
+    DialogInteractionService.prototype.dialogService;
     /** @type {?} */
     DialogInteractionService.prototype.dialogServiceDefaults;
     /** @type {?} */
@@ -2100,12 +2202,85 @@ if (false) {
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
+class NavigationSession {
+    /**
+     * @param {?} isPopState
+     * @param {?} initialUrl
+     */
+    constructor(isPopState, initialUrl) {
+        this.isPopState = isPopState;
+        this.initialUrl = initialUrl;
+        this._alreadyAccepted = [];
+        console.log('NavigationSession', { isPopState, initialUrl });
+    }
+    /**
+     * @param {?} placeComponent
+     * @return {?}
+     */
+    alreadyAccepted(placeComponent) {
+        return this._alreadyAccepted.includes(placeComponent);
+    }
+    /**
+     * @param {?} component
+     * @return {?}
+     */
+    rememberAcceptanceOf(component) {
+        this._alreadyAccepted.push(component);
+    }
+}
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    NavigationSession.prototype._alreadyAccepted;
+    /** @type {?} */
+    NavigationSession.prototype.isPopState;
+    /** @type {?} */
+    NavigationSession.prototype.initialUrl;
+}
 class PlaceRouter {
     /**
      * @param {?} router
+     * @param {?} angularLocation
      */
-    constructor(router) {
+    constructor(router, angularLocation) {
         this.router = router;
+        this._navigationSession = new MutableValueModel();
+        angularLocation.onUrlChange((/**
+         * @param {?} url
+         * @return {?}
+         */
+        url => {
+            console.log(`### ${url}`);
+        }));
+        this.router.events.subscribe((/**
+         * @param {?} event
+         * @return {?}
+         */
+        event => {
+            // console.log(`${event.constructor.name}`, location.pathname, angularLocation.getState());
+            // NavigationStart -> .... -> NavigationCancel === redirect (so don't ask again)
+            // NavigationStart -> .... -> NavigationEnd === navigated (so ask next time)
+            // NavigationStart -> .... -> NavigationError === canceled (guard cancelled so ask next time)
+            if (event instanceof NavigationStart && !this.navigationSession) {
+                this._navigationSession.value = new NavigationSession(event.navigationTrigger === 'popstate', this.router.routerState.snapshot.url);
+            }
+            if (event instanceof NavigationEnd) {
+                console.log('navigation ended');
+                this._navigationSession.value = null;
+            }
+            if (event instanceof NavigationError) {
+                console.log('navigation errored');
+                this._navigationSession.value = null;
+            }
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    get navigationSession() {
+        return this._navigationSession.value;
     }
     /**
      * @param {?} activatedRoute
@@ -2135,7 +2310,6 @@ class PlaceRouter {
         const commands = (weHaveARouteId) ?
             [urlSegments[0].path, sanitised.getFormattedRouteId(), sanitised.getFormattedParameters()] :
             [urlSegments[0].path, sanitised.getFormattedParameters()];
-        console.log("redirect path", commands);
         return this.router.createUrlTree(commands);
     }
     /**
@@ -2170,10 +2344,16 @@ PlaceRouter.decorators = [
 ];
 /** @nocollapse */
 PlaceRouter.ctorParameters = () => [
-    { type: Router }
+    { type: Router },
+    { type: Location }
 ];
-/** @nocollapse */ PlaceRouter.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(ɵɵinject(Router)); }, token: PlaceRouter, providedIn: "root" });
+/** @nocollapse */ PlaceRouter.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(ɵɵinject(Router), ɵɵinject(Location)); }, token: PlaceRouter, providedIn: "root" });
 if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouter.prototype._navigationSession;
     /**
      * @type {?}
      * @private
@@ -3054,8 +3234,8 @@ class PlaceOutletComponent extends DisposableComponent {
         this.placeHistory = placeHistory;
         this.animate = true;
         this._activePlace = new MutableValueModel();
-        this._incomingRouteChange = new Guard();
-        this._inOutletUpdate = new Guard();
+        this._incomingRouteChange = new Guard$1();
+        this._inOutletUpdate = new Guard$1();
         this._activatedRouteModel = new MutableValueModel();
         this._placeDefinition = new MutableValueModel();
         this._resolvedParameters = new MutableValueModel();
@@ -3678,16 +3858,15 @@ function Result() { }
  */
 function ActivityOutletContext() { }
 if (false) {
-    /** @type {?} */
-    ActivityOutletContext.prototype.interactionContext;
     /** @type {?} */
     ActivityOutletContext.prototype.activityClass;
     /** @type {?} */
     ActivityOutletContext.prototype.activityData;
-    /** @type {?} */
-    ActivityOutletContext.prototype.onDone;
-    /** @type {?} */
-    ActivityOutletContext.prototype.onCancel;
+    /**
+     * @param {?} component
+     * @return {?}
+     */
+    ActivityOutletContext.prototype.componentReady = function (component) { };
 }
 
 /**
@@ -3850,36 +4029,16 @@ class LeavePlaceGuard {
     /**
      * @param {?} router
      * @param {?} injector
+     * @param {?} placeRouter
      * @param {?} interactionContext
-     * @param {?} location
+     * @param {?} angularLocation
      */
-    constructor(router, injector, interactionContext, location) {
+    constructor(router, injector, placeRouter, interactionContext, angularLocation) {
         this.router = router;
         this.injector = injector;
+        this.placeRouter = placeRouter;
         this.interactionContext = interactionContext;
-        this.location = location;
-        // TODO: should probably replace this with a RouteTracker thingy.
-        this._alreadyAccepted = [];
-        console.log('***** Created new guard ******');
-        /** @type {?} */
-        const self = this;
-        this.router.events.subscribe((/**
-         * @param {?} event
-         * @return {?}
-         */
-        event => {
-            // NavigationStart -> .... -> NavigationCancel === redirect (so don't ask again)
-            // NavigationStart -> .... -> NavigationEnd === navigated (so ask next time)
-            // NavigationStart -> .... -> NavigationError === canceled (guard cancelled so ask next time)
-            if (event instanceof NavigationEnd) {
-                console.log('navigation ended');
-                self._alreadyAccepted = [];
-            }
-            if (event instanceof NavigationError) {
-                console.log('navigation errored');
-                self._alreadyAccepted = [];
-            }
-        }));
+        this.angularLocation = angularLocation;
     }
     /**
      * @param {?} component
@@ -3889,100 +4048,89 @@ class LeavePlaceGuard {
      * @return {?}
      */
     canDeactivate(component, currentRoute, currentState, nextState) {
-        /** @type {?} */
-        const placeDefinitionPath = `/${component.placeDefinition.path}`;
-        console.log('canDeactivate', {
-            staticPath: placeDefinitionPath,
-            currentStateUrl: currentState.url,
-            nextStateUrl: nextState.url,
-            alreadyDeclined: this._alreadyAccepted
-        });
-        // Example of the above when navigating to a different child route.
-        // canDeactivate {staticPath: "/hero-details",
-        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-details",
-        //    nextStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats"
-        // }
-        // Example clicking on router tab of the parent component (de-activates the parent due to route param changes)
-        // canDeactivate {
-        //    staticPath: "/hero-stats",
-        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
-        //    nextStateUrl: "/route-parameters/"
-        // }
-        // canDeactivate {
-        //    staticPath: "/route-parameters",
-        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
-        //    nextStateUrl: "/route-parameters/"
-        // }
-        // logger.class.js:54 ParameterSnapshot.sanitise -> {idModel: -1, pv: undefined, pl: Array(0), dv: undefined, dl: Array(0), …}
-        // parameter-snapshot.ts:20 {name: "idModel", mine: -1, theirs: null}
-        // place-router.ts:28 redirect path (3) ["route-parameters", "-1", {…}]
-        // canDeactivate {
-        //    staticPath: "/hero-stats",
-        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
-        //    nextStateUrl: "/route-parameters/-1"
-        // }
-        // canDeactivate {
-        //    staticPath: "/route-parameters",
-        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
-        //    nextStateUrl: "/route-parameters/-1"
-        // }
-        // logger.class.js:54 ParameterSnapshot.sanitise -> {idModel: -1, pv: undefined, pl: Array(0), dv: "A", dl: Array(3), …}
-        // parameter-snapshot.ts:20 {name: "dv", mine: "A", theirs: undefined}
-        // place-router.ts:28 redirect path (3) ["route-parameters", "-1", {…}]
-        // canDeactivate {
-        //    staticPath: "/hero-stats",
-        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
-        //    nextStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c"
-        // }
-        // HACK: this will break with child routes...
-        if (this.alreadyAccepted(component)) {
-            return true;
-        }
-        else {
-            if (!nextState.url.startsWith(placeDefinitionPath)) {
-                /** @type {?} */
-                const self = this;
-                return Promise.resolve(component.canDeactivate())
-                    .then((/**
-                 * @param {?} canLeave
-                 * @return {?}
-                 */
-                canLeave => {
-                    if (!canLeave) {
-                        // Angular doesn't preserve the url when a guard cancels the back button.
-                        // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
-                        this.location.go(currentState.url);
-                        return false;
+        return __awaiter(this, void 0, void 0, function* () {
+            /** @type {?} */
+            const placeDefinitionPath = `/${component.placeDefinition.path}`;
+            // console.log('canDeactivate', {
+            //   staticPath: placeDefinitionPath,
+            //   currentStateUrl: currentState.url,
+            //   nextStateUrl: nextState.url
+            //   // alreadyDeclined: this._alreadyAccepted
+            // });
+            // Example of the above when navigating to a different child route.
+            // canDeactivate {staticPath: "/hero-details",
+            //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-details",
+            //    nextStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats"
+            // }
+            // Example clicking on router tab of the parent component (de-activates the parent due to route param changes)
+            // canDeactivate {
+            //    staticPath: "/hero-stats",
+            //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
+            //    nextStateUrl: "/route-parameters/"
+            // }
+            // canDeactivate {
+            //    staticPath: "/route-parameters",
+            //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
+            //    nextStateUrl: "/route-parameters/"
+            // }
+            // logger.class.js:54 ParameterSnapshot.sanitise -> {idModel: -1, pv: undefined, pl: Array(0), dv: undefined, dl: Array(0), …}
+            // parameter-snapshot.ts:20 {name: "idModel", mine: -1, theirs: null}
+            // place-router.ts:28 redirect path (3) ["route-parameters", "-1", {…}]
+            // canDeactivate {
+            //    staticPath: "/hero-stats",
+            //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
+            //    nextStateUrl: "/route-parameters/-1"
+            // }
+            // canDeactivate {
+            //    staticPath: "/route-parameters",
+            //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
+            //    nextStateUrl: "/route-parameters/-1"
+            // }
+            // logger.class.js:54 ParameterSnapshot.sanitise -> {idModel: -1, pv: undefined, pl: Array(0), dv: "A", dl: Array(3), …}
+            // parameter-snapshot.ts:20 {name: "dv", mine: "A", theirs: undefined}
+            // place-router.ts:28 redirect path (3) ["route-parameters", "-1", {…}]
+            // canDeactivate {
+            //    staticPath: "/hero-stats",
+            //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
+            //    nextStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c"
+            // }
+            if (this.placeRouter.navigationSession.alreadyAccepted(component)) {
+                return true;
+            }
+            else {
+                // TODO: this will break with child routes... need to examine the router states properly.
+                if (!nextState.url.startsWith(placeDefinitionPath)) {
+                    /** @type {?} */
+                    const self = this;
+                    /** @type {?} */
+                    let canLeave = yield component.canDeactivate();
+                    // component is happy to leave but we need to check if it's left an interaction
+                    // open.  If so we close and stay where we are.
+                    if (canLeave && this.interactionContext.isActive()) {
+                        canLeave = false;
+                        console.log("cancelling", { activity: this.interactionContext.currentActivity });
+                        this.interactionContext.currentActivity.cancel(null);
+                    }
+                    // If we're still leaving then remember it since angular will call this method multiple
+                    // times if any route parameters are changed along the way.
+                    if (canLeave) {
+                        self.placeRouter.navigationSession.rememberAcceptanceOf(component);
                     }
                     else {
-                        if (this.interactionContext.isActive()) {
-                            this.interactionContext.currentActivity.value.cancel(null);
-                            return false;
-                        }
-                        else {
-                            return true;
+                        // Angular doesn't preserve the url when a guard cancels the back button.
+                        // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
+                        if (this.placeRouter.navigationSession.isPopState) {
+                            console.log('cancelled during popstate');
+                            this.angularLocation.go(this.placeRouter.navigationSession.initialUrl);
                         }
                     }
-                })).then((/**
-                 * @param {?} canDeactivate
-                 * @return {?}
-                 */
-                canDeactivate => {
-                    if (canDeactivate) {
-                        self._alreadyAccepted.push(component);
-                    }
-                    return canDeactivate;
-                }));
+                    return canLeave;
+                }
+                else {
+                    return true;
+                }
             }
-            return true;
-        }
-    }
-    /**
-     * @param {?} placeComponent
-     * @return {?}
-     */
-    alreadyAccepted(placeComponent) {
-        return this._alreadyAccepted.includes(placeComponent);
+        });
     }
 }
 LeavePlaceGuard.decorators = [
@@ -3994,36 +4142,31 @@ LeavePlaceGuard.decorators = [
 LeavePlaceGuard.ctorParameters = () => [
     { type: Router },
     { type: Injector },
+    { type: PlaceRouter },
     { type: InteractionContext },
     { type: Location }
 ];
-/** @nocollapse */ LeavePlaceGuard.ngInjectableDef = ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(ɵɵinject(Router), ɵɵinject(INJECTOR), ɵɵinject(InteractionContext), ɵɵinject(Location)); }, token: LeavePlaceGuard, providedIn: "root" });
-__decorate([
-    Trace(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [PlaceComponent]),
-    __metadata("design:returntype", Boolean)
-], LeavePlaceGuard.prototype, "alreadyAccepted", null);
+/** @nocollapse */ LeavePlaceGuard.ngInjectableDef = ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(ɵɵinject(Router), ɵɵinject(INJECTOR), ɵɵinject(PlaceRouter), ɵɵinject(InteractionContext), ɵɵinject(Location)); }, token: LeavePlaceGuard, providedIn: "root" });
 if (false) {
     /**
      * @type {?}
      * @private
      */
-    LeavePlaceGuard.prototype._alreadyAccepted;
+    LeavePlaceGuard.prototype.router;
     /**
      * @type {?}
      * @private
      */
-    LeavePlaceGuard.prototype.router;
+    LeavePlaceGuard.prototype.injector;
     /**
      * @type {?}
      * @private
      */
-    LeavePlaceGuard.prototype.injector;
+    LeavePlaceGuard.prototype.placeRouter;
     /** @type {?} */
     LeavePlaceGuard.prototype.interactionContext;
     /** @type {?} */
-    LeavePlaceGuard.prototype.location;
+    LeavePlaceGuard.prototype.angularLocation;
 }
 
 /**
@@ -4296,5 +4439,5 @@ var ParameterType;
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
-export { ACTIVITY_DATA, AbstractActivity, AbstractInputComponent, AbstractPlaceNavigationComponent, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, AngularUiPowerupsModule, Bounds, BusyOverlayComponent, CloseInteractionGuard, CommandDirective, ConfirmThenDialogComponent, ConfirmationDialogComponent, DEFINITION_META_DATA_KEY, DIALOG_INTERACTION_SERVICE_DEFAULTS, DialogInteractionService, Dimension, DisposableComponent, EmptyStateComponent, FocusBindingDirective, InteractionContext, InteractionModule, LEFT_RIGHT_PLACE_ANIMATION, LeavePlaceGuard, ListPlaceNavComponent, NumberInputComponent, ParameterDefinition, ParameterSnapshot, ParameterType, PasswordInputComponent, Place, PlaceComponent, PlaceDefinition, PlaceHistory, PlaceModule, PlaceOutletComponent, PlaceRouteGuard, PlaceRouter, Point, ROUTE_PARAMETER_LIST_KEY, ResizeAwareComponent, RouteId, RouteParameter, RouteParameterList, RouteParameterValue, SelectInputComponent, StringInputComponent, TabbedPlaceNavigationComponent, leftRightPlaceAnimation, slideDownAndUpAnimation, CommandDirective as ɵa, FocusBindingDirective as ɵb, ConfirmThenDialogComponent as ɵba, InteractionContext as ɵbb, AlertDialogComponent as ɵbc, DIALOG_INTERACTION_SERVICE_DEFAULTS as ɵbe, DialogInteractionService as ɵbf, DisposableComponent as ɵc, NumberInputComponent as ɵd, AbstractInputComponent as ɵe, StringInputComponent as ɵf, PasswordInputComponent as ɵg, SelectInputComponent as ɵh, PlaceModule as ɵi, EmptyStateComponent as ɵj, BusyOverlayComponent as ɵk, PlaceOutletComponent as ɵl, leftRightPlaceAnimation as ɵm, LEFT_RIGHT_PLACE_ANIMATION as ɵn, PlaceRouter as ɵo, PlaceHistory as ɵp, TabbedPlaceNavigationComponent as ɵq, AbstractPlaceNavigationComponent as ɵr, ListPlaceNavComponent as ɵs, InteractionModule as ɵt, ActivityContainerComponent as ɵu, ActivityOutletComponent as ɵv, ConfirmationDialogComponent as ɵw, AbstractActivity as ɵx, ACTIVITY_DATA as ɵy };
+export { ACTIVITY_DATA, AbstractActivity, AbstractInputComponent, AbstractPlaceNavigationComponent, Activity, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, AngularUiPowerupsModule, Bounds, BusyOverlayComponent, CloseInteractionGuard, CommandDirective, ConfirmThenDialogComponent, ConfirmationDialogComponent, DEFINITION_META_DATA_KEY, DIALOG_INTERACTION_SERVICE_DEFAULTS, DialogInteractionService, Dimension, DisposableComponent, EmptyStateComponent, FocusBindingDirective, InteractionContext, InteractionModule, LEFT_RIGHT_PLACE_ANIMATION, LeavePlaceGuard, ListPlaceNavComponent, NumberInputComponent, ParameterDefinition, ParameterSnapshot, ParameterType, PasswordInputComponent, Place, PlaceComponent, PlaceDefinition, PlaceHistory, PlaceModule, PlaceOutletComponent, PlaceRouteGuard, PlaceRouter, Point, ROUTE_PARAMETER_LIST_KEY, ResizeAwareComponent, RouteId, RouteParameter, RouteParameterList, RouteParameterValue, SelectInputComponent, StringInputComponent, TabbedPlaceNavigationComponent, leftRightPlaceAnimation, slideDownAndUpAnimation, CommandDirective as ɵa, FocusBindingDirective as ɵb, Activity as ɵba, ConfirmThenDialogComponent as ɵbc, AlertDialogComponent as ɵbd, DIALOG_INTERACTION_SERVICE_DEFAULTS as ɵbf, DialogInteractionService as ɵbg, DisposableComponent as ɵc, NumberInputComponent as ɵd, AbstractInputComponent as ɵe, StringInputComponent as ɵf, PasswordInputComponent as ɵg, SelectInputComponent as ɵh, PlaceModule as ɵi, EmptyStateComponent as ɵj, BusyOverlayComponent as ɵk, PlaceOutletComponent as ɵl, leftRightPlaceAnimation as ɵm, LEFT_RIGHT_PLACE_ANIMATION as ɵn, PlaceRouter as ɵo, PlaceHistory as ɵp, TabbedPlaceNavigationComponent as ɵq, AbstractPlaceNavigationComponent as ɵr, ListPlaceNavComponent as ɵs, InteractionModule as ɵt, ActivityContainerComponent as ɵu, InteractionContext as ɵv, ActivityOutletComponent as ɵw, ConfirmationDialogComponent as ɵx, AbstractActivity as ɵy, ACTIVITY_DATA as ɵz };
 //# sourceMappingURL=coolon-angular-ui-powerups.js.map