@coolon/angular-ui-powerups 0.0.89 → 0.0.91

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

@@ -4,10 +4,10 @@ import { FormsModule } from '@angular/forms';
 import { MatInputModule, MatFormFieldModule, MatSelectModule, MatDialog, MatButtonModule, MatDialogModule, MatTabsModule as MatTabsModule$1, MatProgressSpinnerModule } from '@angular/material';
 import { MatTabsModule } from '@angular/material/tabs';
 import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
-import { GarbageCollector, assert, UnaryCommand, lang, Dsl, Logger, DelegatingFormValueModel, UseDelegate, ValueModel, ListModel, StoreInListModel, DelegatingValueModel, MutableStream, MutableListModel, DelegatingListModel, Binding, MutableValueModel, Trace, Guard as Guard$1, Command, StoreInValueModel, OptionsHelper, ValueHolder } from '@coolon/pectin';
+import { GarbageCollector, DelegatingValueModel, assert, UnaryCommand, lang, Dsl, Logger, DelegatingFormValueModel, UseDelegate, ValueModel, ListModel, StoreInListModel, DelegatingListModel, Deferred, MutableStream, MutableListModel, MutableValueModel, Binding, Trace, Guard as Guard$1, Command, StoreInValueModel, OptionsHelper, ValueHolder } from '@coolon/pectin';
 import { __decorate, __metadata, __awaiter } from 'tslib';
 import { PortalModule } from '@angular/cdk/portal';
-import { Router, RouterModule, UrlSegment, NavigationStart, NavigationEnd, NavigationError, ActivatedRouteSnapshot, RouterStateSnapshot, UrlSerializer } from '@angular/router';
+import { Router, RouterModule, NavigationStart, NavigationEnd, NavigationError, UrlSerializer, UrlSegment, 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, MAT_DIALOG_DEFAULT_OPTIONS, MatDialog as MatDialog$1 } from '@angular/material/dialog';
@@ -34,8 +34,23 @@ class CommandDirective extends GarbageCollector {
     constructor(elementRef) {
         super();
         this.elementRef = elementRef;
+        this._commandEnabled = new DelegatingValueModel().withDefault(false);
         this._commandParameterProvided = false;
     }
+    /**
+     * @param {?} command
+     * @return {?}
+     */
+    set pectinCommand(command) {
+        this._command = command;
+        this._commandEnabled.setDelegate(command ? command.enabled : null);
+    }
+    /**
+     * @return {?}
+     */
+    get pectinCommand() {
+        return this._command;
+    }
     /**
      * @param {?} value
      * @return {?}
@@ -73,7 +88,7 @@ class CommandDirective extends GarbageCollector {
         // for some reason mat-buttons kills the disabled host binding.  It works on a regular button but for now
         // we need to do this.
         const { chain } = Dsl.disposeWith(this);
-        chain(this.pectinCommand.enabled).subscribe((/**
+        chain(this._commandEnabled).subscribe((/**
          * @param {?} enabled
          * @return {?}
          */
@@ -134,8 +149,16 @@ CommandDirective.propDecorators = {
     notifyClick: [{ type: HostListener, args: ['click', ['$event'],] }]
 };
 if (false) {
-    /** @type {?} */
-    CommandDirective.prototype.pectinCommand;
+    /**
+     * @type {?}
+     * @private
+     */
+    CommandDirective.prototype._command;
+    /**
+     * @type {?}
+     * @private
+     */
+    CommandDirective.prototype._commandEnabled;
     /**
      * @type {?}
      * @private
@@ -741,14 +764,79 @@ class InteractionContext extends GarbageCollector {
      */
     constructor() {
         super();
+        /**
+         * 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.
+         */
+        this._activityListDelegate = new DelegatingListModel();
+        const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
+        when.listOf(this.activityList).becomesPopulated((/**
+         * @param {?} activities
+         * @return {?}
+         */
+        (activities) => {
+            if (this.deferredGetCurrentActivity) {
+                this.deferredGetCurrentActivity.resolve(last(activities));
+                this.deferredGetCurrentActivity = null;
+            }
+        }));
+    }
+    /**
+     * @protected
+     * @param {?} activityList
+     * @return {?}
+     */
+    setActivityList(activityList) {
+        this._activityListDelegate.setDelegate(activityList);
+    }
+    /**
+     * @return {?}
+     */
+    get activityList() {
+        return this._activityListDelegate.readonly;
     }
     /**
      * Returns the activity that is currently active.
      * This model is only updated in the next tick after the view has been updated.
      * @return {?}
      */
-    get currentActivity() {
-        return last(this.activityList.value);
+    getCurrentActivity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isActive()) {
+                return Promise.reject('no activity in progress');
+            }
+            else {
+                if (this.deferredGetCurrentActivity) {
+                    // we're already waiting then just return the same promise
+                    return this.deferredGetCurrentActivity.promise;
+                }
+                else {
+                    if (this.activityList.length < 1) {
+                        this.deferredGetCurrentActivity = Deferred.defer();
+                        return this.deferredGetCurrentActivity.promise;
+                    }
+                    else {
+                        return last(this.activityList.value);
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * @param {?} confirm
+     * @return {?}
+     */
+    confirm(confirm) {
+        // Important: we have to implement confirmOrReject as the main entry point
+        // as the canDeactivation guards need to be able to cancel an interaction
+        // without caring about returning a value.
+        return this.confirmOrReject(confirm).then((/**
+         * @return {?}
+         */
+        () => true)).catch((/**
+         * @return {?}
+         */
+        () => false));
     }
 }
 if (false) {
@@ -756,8 +844,14 @@ 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.
      * @type {?}
+     * @private
+     */
+    InteractionContext.prototype._activityListDelegate;
+    /**
+     * @type {?}
+     * @private
      */
-    InteractionContext.prototype.activityList;
+    InteractionContext.prototype.deferredGetCurrentActivity;
     /**
      * Returns true if an activity is currently running.
      * @abstract
@@ -777,7 +871,7 @@ if (false) {
      * @param {?} confirm
      * @return {?}
      */
-    InteractionContext.prototype.confirm = function (confirm) { };
+    InteractionContext.prototype.confirmOrReject = function (confirm) { };
     /**
      * Presents the confirmation to the user and runs the activity only if the user confirms.
      * @abstract
@@ -1290,6 +1384,7 @@ class ActivityContainerComponent extends InteractionContext {
          * @return {?}
          */
         () => this.onNestedActivityFinished()));
+        this.setActivityList(this._activityList.readonly);
     }
     /**
      * @param {?} initialContext
@@ -1337,12 +1432,6 @@ class ActivityContainerComponent extends InteractionContext {
     isActive() {
         return !!this._initialActivityOutletContext;
     }
-    /**
-     * @return {?}
-     */
-    get activityList() {
-        return this._activityList.readonly;
-    }
     /**
      * @return {?}
      */
@@ -1422,7 +1511,7 @@ class ActivityContainerComponent extends InteractionContext {
      * @param {?} confirm
      * @return {?}
      */
-    confirm(confirm) {
+    confirmOrReject(confirm) {
         return this.startActivity(ConfirmationDialogComponent, confirm);
     }
     /**
@@ -1581,13 +1670,8 @@ class InplaceInteractionContextComponent extends InteractionContext {
     /**
      * @return {?}
      */
-    ngOnInit() {
-    }
-    /**
-     * @return {?}
-     */
-    get activityList() {
-        return this.interactionContext.activityList;
+    ngAfterViewInit() {
+        this.setActivityList(this.interactionContext.activityList);
     }
     /**
      * @return {?}
@@ -1607,7 +1691,7 @@ class InplaceInteractionContextComponent extends InteractionContext {
      * @param {?} confirm
      * @return {?}
      */
-    confirm(confirm) {
+    confirmOrReject(confirm) {
         return this._startActivity(ConfirmationDialogComponent, confirm);
     }
     /**
@@ -1762,29 +1846,21 @@ class DialogInteractionService extends InteractionContext {
         this.router = router;
         this.dialogServiceDefaults = dialogServiceDefaults;
         this.matDialogDefaultConfig = matDialogDefaultConfig;
-        this._activityList = new DelegatingListModel();
         this.startingGuard = new Guard();
+        this._inActivityPromise = new MutableValueModel(false);
         assert$1.notNil(dialogService);
-        const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
-        this.active = chain(this._activityList).isNotEmpty();
     }
     /**
      * @return {?}
      */
     isActive() {
-        return this.active.value;
-    }
-    /**
-     * @return {?}
-     */
-    cancelActivity() {
-        this.currentActivity.cancel(null);
+        return this._inActivityPromise.value;
     }
     /**
      * @return {?}
      */
-    get activityList() {
-        return this._activityList.readonly;
+    get active() {
+        return this._inActivityPromise.readonly;
     }
     /**
      * @template D, R, E
@@ -1816,6 +1892,7 @@ class DialogInteractionService extends InteractionContext {
          */
         () => {
             console.log('######  STARTING');
+            this._inActivityPromise.value = true;
             // this.currentActivityId = uuid.v1();
             // this.location.go(this.router.routerState.snapshot.url, "aup");
             /** @type {?} */
@@ -1874,6 +1951,7 @@ class DialogInteractionService extends InteractionContext {
              * @return {?}
              */
             () => {
+                this._inActivityPromise.value = false;
                 console.log('######  FINISHED');
                 // this.currentActivityId = null;
                 self.safelyUpdateActivityListDelegate(null);
@@ -1889,7 +1967,7 @@ class DialogInteractionService extends InteractionContext {
         setTimeout((/**
          * @return {?}
          */
-        () => this._activityList.setDelegate(delegate)));
+        () => this.setActivityList(delegate)));
     }
     /**
      * @param {?} alert
@@ -1903,7 +1981,7 @@ class DialogInteractionService extends InteractionContext {
      * @param {?} confirm
      * @return {?}
      */
-    confirm(confirm) {
+    confirmOrReject(confirm) {
         return this._startActivity(ConfirmationDialogComponent, confirm, true);
     }
     /**
@@ -1940,14 +2018,12 @@ if (false) {
      * @type {?}
      * @private
      */
-    DialogInteractionService.prototype._activityList;
+    DialogInteractionService.prototype.startingGuard;
     /**
      * @type {?}
      * @private
      */
-    DialogInteractionService.prototype.startingGuard;
-    /** @type {?} */
-    DialogInteractionService.prototype.active;
+    DialogInteractionService.prototype._inActivityPromise;
     /**
      * @type {?}
      * @private
@@ -2343,20 +2419,15 @@ class PlaceDefinition {
         return routeIdParameterDef ? visit.getParameter(routeIdParameterDef.name) : null;
     }
     /**
-     * Returns angular router commands that specify the route id and any route parameters.  The result does
-     * not include any path information.
      * @param {?} visit
      * @return {?}
      */
-    // getFormattedRouterCommands(visit: Visit): any[] {
-    //   return this.hasRouteId() ?
-    //     [this.getFormattedRouteId(visit), this.getFormattedRouteParameters(visit)] :
-    //     [this.getFormattedRouteParameters(visit)];
-    // }
     getFormattedRouteId(visit) {
-        return visit.hasRouteId() ? this.getRouteIdParameterDef().urlFormat.format(visit.getRouteId()) : null;
+        // Note: RouteIds are always present in the url and are just empty strings when not defined.  This is
+        // mandated by the fact that redirects from <path> to <path>/:id always include the id parameter as
+        // an empty string.
+        return visit.hasRouteId() ? this.getRouteIdParameterDef().urlFormat.format(visit.getRouteId()) : "";
     }
-    // @Trace()
     /**
      * @param {?} visit
      * @param {?=} includeRouteId
@@ -2441,15 +2512,17 @@ class PlaceDefinition {
                 }
                 else {
                     /** @type {?} */
-                    const value = def.urlFormat.parse(params.get(def.name));
-                    // because our id routes redirect if the id isn't pressent we always have a id
-                    // parameter in our params.  This will bugger our remember and defaultvalue sanitisation
-                    // as it'll see that the id is present (event thought its null).  The sanitisation can't
-                    // check for null as that's a valid value for the id.
-                    /** @type {?} */
-                    const isEmptyRouteId = def.isRouteId && def.isEmptyValue(value);
-                    if (!isEmptyRouteId) {
-                        result[def.name] = value;
+                    const value = params.get(def.name);
+                    if (def.isRouteId) { // TODO: Move this to parameter def so it's a strategy pattern
+                        // because our id routes redirect if the id isn't present we always have a id
+                        // parameter in our params.  This will bugger our remember and defaultvalue sanitisation
+                        // as it'll see that the id is present (event thought its a blank string).
+                        if (!___default.isEmpty(value)) {
+                            result[def.name] = def.urlFormat.parse(value);
+                        }
+                    }
+                    else {
+                        result[def.name] = def.urlFormat.parse(value);
                     }
                 }
             }
@@ -2515,7 +2588,7 @@ const DEFINITION_META_DATA_KEY = 'PLACE_DEFINITION_OPTIONS';
 // this one seems ok.
 /** @type {?} */
 const ROUTE_PARAMETER_LIST_KEY = Symbol('place:route:parameters');
-class PlaceComponent extends GarbageCollector {
+class PlaceComponent extends DisposableComponent {
     constructor() {
         super();
     }
@@ -2582,27 +2655,11 @@ class PlaceComponent extends GarbageCollector {
          */
         d => d.component));
     }
-    /**
-     * @return {?}
-     */
-    canDeactivate() {
-        return true;
-    }
     /**
      * @return {?}
      */
     onPlaceReady() {
     }
-    /**
-     * Called by the place outlet after all animations have finished.  We need this instead of ngOnDestroy
-     * to avoid the fact that the angular router calls it before the animations have run causing the component
-     * to loose any pectin bindings.
-     * @return {?}
-     */
-    // @Trace()
-    onPlaceDestroyed() {
-        this.dispose();
-    }
 }
 __decorate([
     Memoize$1(),
@@ -2736,8 +2793,10 @@ class Visit {
             else {
                 // copy non route params as is, but only if they already exist otherwise we'll inject nil values and break the
                 // defaults and remember sanitisation process.
+                /** @type {?} */
+                const value = this.getParameter(def.name);
                 if (this.hasParameter(def.name)) {
-                    params[def.name] = this.getParameter(def.name);
+                    params[def.name] = value;
                 }
             }
         }));
@@ -2763,14 +2822,6 @@ class Visit {
         const sameNonRouteParameters = isEqual(this.placeDefinition.getNonRouteParameters(this), this.placeDefinition.getNonRouteParameters(other));
         return !sameNonRouteParameters || this.hasRoutingChangedFrom(other);
     }
-    /**
-     * @return {?}
-     */
-    getUrlSegments() {
-        return this.placeDefinition.hasRouteId() ?
-            [new UrlSegment(this.placeDefinition.path, {}), new UrlSegment(this.placeDefinition.getFormattedRouteId(this), this.placeDefinition.getFormattedRouteParameters(this))] :
-            [new UrlSegment(this.placeDefinition.path, this.placeDefinition.getFormattedRouteParameters(this))];
-    }
 }
 if (false) {
     /** @type {?} */
@@ -2808,11 +2859,15 @@ class NavigationSession {
     /**
      * @protected
      * @param {?} firstNavigation
+     * @param {?} appModalInteractionContext
      */
-    constructor(firstNavigation) {
+    constructor(firstNavigation, appModalInteractionContext) {
         this.firstNavigation = firstNavigation;
+        this.appModalInteractionContext = appModalInteractionContext;
         this._alreadyAccepted = [];
         this._visits = new Map();
+        this.componentDeactivationHandlers = new Map();
+        this.dialogOpenOnStart = this.appModalInteractionContext.isActive();
     }
     /**
      * @param {?} visit
@@ -2828,34 +2883,30 @@ class NavigationSession {
     getVisitFor(placeDef) {
         return this._visits.get(placeDef);
     }
-    /**
-     * @param {?} params
-     * @return {?}
-     */
-    mergePrivatePlaceParameters(params) {
-        return null;
-    }
-    // @Trace()
-    /**
-     * @param {?} placeComponent
-     * @return {?}
-     */
-    alreadyAccepted(placeComponent) {
-        return this._alreadyAccepted.includes(placeComponent);
-    }
-    // @Trace()
     /**
      * @param {?} component
+     * @param {?} nextState
      * @return {?}
      */
-    rememberAcceptanceOf(component) {
-        this._alreadyAccepted.push(component);
+    canDeactivate(component, nextState) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // lookup the handler and create it if we've not seen it yet
+            /** @type {?} */
+            let handler = this.componentDeactivationHandlers.get(component);
+            if (!handler) {
+                /** @type {?} */
+                const isPrimaryHandler = this.componentDeactivationHandlers.size === 0;
+                handler = new NavigationSession.ComponentDeactivationHandler(component, this.appModalInteractionContext, isPrimaryHandler);
+                this.componentDeactivationHandlers.set(component, handler);
+            }
+            return handler.canDeactivate(nextState);
+        });
     }
     /**
      * @param {?} url
      * @return {?}
      */
-    setPopstateReturn(url) {
+    setPopstateReturnUrl(url) {
         this._popStateReturnUrl = url;
     }
     /**
@@ -2896,15 +2947,28 @@ if (false) {
     /** @type {?} */
     NavigationSession.prototype.isExternal;
     /** @type {?} */
+    NavigationSession.prototype.dialogOpenOnStart;
+    /**
+     * @type {?}
+     * @private
+     */
+    NavigationSession.prototype.componentDeactivationHandlers;
+    /** @type {?} */
     NavigationSession.prototype.firstNavigation;
+    /**
+     * @type {?}
+     * @private
+     */
+    NavigationSession.prototype.appModalInteractionContext;
 }
 (function (NavigationSession) {
     class External extends NavigationSession {
         /**
          * @param {?} isFirstTime
+         * @param {?} appModelInteractionContext
          */
-        constructor(isFirstTime) {
-            super(isFirstTime);
+        constructor(isFirstTime, appModelInteractionContext) {
+            super(isFirstTime, appModelInteractionContext);
             this.isExternal = true;
         }
     }
@@ -2915,9 +2979,10 @@ if (false) {
     class Internal extends NavigationSession {
         /**
          * @param {?} visit
+         * @param {?} appModelInteractionContext
          */
-        constructor(visit) {
-            super(false);
+        constructor(visit, appModelInteractionContext) {
+            super(false, appModelInteractionContext);
             this.isExternal = false;
             this.storeVisit(visit);
         }
@@ -2926,22 +2991,148 @@ if (false) {
         /** @type {?} */
         Internal.prototype.isExternal;
     }
-    /**
-     * @param {?} visit
-     * @return {?}
-     */
-    function createInternal(visit) {
-        return new Internal(visit);
+    class Factory {
+        /**
+         * @param {?} appModelInteractionContext
+         */
+        constructor(appModelInteractionContext) {
+            this.appModelInteractionContext = appModelInteractionContext;
+        }
+        /**
+         * @param {?} visit
+         * @return {?}
+         */
+        createInternal(visit) {
+            return new Internal(visit, this.appModelInteractionContext);
+        }
+        /**
+         * @param {?} firstTimeRoute
+         * @return {?}
+         */
+        createExternal(firstTimeRoute) {
+            return new External(firstTimeRoute, this.appModelInteractionContext);
+        }
     }
-    NavigationSession.createInternal = createInternal;
-    /**
-     * @param {?} firstTimeRoute
-     * @return {?}
-     */
-    function createExternal(firstTimeRoute) {
-        return new External(firstTimeRoute);
+    Factory.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] },
+    ];
+    /** @nocollapse */
+    Factory.ctorParameters = () => [
+        { type: InteractionContext }
+    ];
+    NavigationSession.Factory = Factory;
+    if (false) {
+        /** @type {?} */
+        Factory.prototype.appModelInteractionContext;
+    }
+    class ComponentDeactivationHandler {
+        /**
+         * @param {?} component
+         * @param {?} appModelInteractionContext
+         * @param {?} primary
+         */
+        constructor(component, appModelInteractionContext, primary) {
+            this.component = component;
+            this.appModelInteractionContext = appModelInteractionContext;
+            this.primary = primary;
+            this.alreadyAccepted = false;
+            // super();
+        }
+        /**
+         * @param {?} nextState
+         * @return {?}
+         */
+        canDeactivate(nextState) {
+            return __awaiter(this, void 0, void 0, function* () {
+                console.log(`${this.constructor.name}.canDeactivate`, { component: this.component });
+                if (this.alreadyAccepted) {
+                    // We'll get called multiple times if there's any parameter sanitisation so
+                    // we always return true if we accepted on a previous cycle of the current
+                    // navigation session.
+                    return true;
+                }
+                else {
+                    if (this.primary && this.appModelInteractionContext.isActive()) {
+                        // We check the global interaction first
+                        yield this.cancelCurrentActivityOf(this.appModelInteractionContext);
+                        return false;
+                    }
+                    this.alreadyAccepted = yield this.canDeactivateComponent(nextState);
+                    return this.alreadyAccepted;
+                }
+            });
+        }
+        /**
+         * @protected
+         * @param {?} nextState
+         * @return {?}
+         */
+        canDeactivateComponent(nextState) {
+            return __awaiter(this, void 0, void 0, function* () {
+                // check if the component has an active interaction.  This will handle
+                // an inplace interaction contexts
+                /** @type {?} */
+                const hasCustomInteractionContext = this.component.interactionContext &&
+                    !this.isAppModalInteractionContext(this.component.interactionContext) &&
+                    this.component.interactionContext.isActive();
+                if (hasCustomInteractionContext) {
+                    this.cancelCurrentActivityOf(this.component.interactionContext);
+                    return false;
+                }
+                if (this.isLeavingCurrentPlace(nextState) && this.component.canDeactivate) {
+                    // No interaction in progress, so ask the component .
+                    // This may start an interaction, hence checking the interaction context before now. I.e. if the place pops up the dialog, and
+                    // the user clicks back again, we'll re-enter here and go bang when the component tries to open another dialog.
+                    return this.component.canDeactivate();
+                }
+                return true;
+            });
+        }
+        /**
+         * @param {?} interactionContext
+         * @return {?}
+         */
+        isAppModalInteractionContext(interactionContext) {
+            return this.appModelInteractionContext === interactionContext;
+        }
+        /**
+         * @protected
+         * @param {?} interactionContext
+         * @return {?}
+         */
+        cancelCurrentActivityOf(interactionContext) {
+            return __awaiter(this, void 0, void 0, function* () {
+                /** @type {?} */
+                const activity = yield interactionContext.getCurrentActivity();
+                console.log('cancelling', { activity });
+                activity.cancel(null);
+            });
+        }
+        /**
+         * @protected
+         * @param {?} nextState
+         * @return {?}
+         */
+        isLeavingCurrentPlace(nextState) {
+            return !nextState.includesPathOf(this.component.placeDefinition);
+        }
+    }
+    NavigationSession.ComponentDeactivationHandler = ComponentDeactivationHandler;
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        ComponentDeactivationHandler.prototype.alreadyAccepted;
+        /** @type {?} */
+        ComponentDeactivationHandler.prototype.component;
+        /** @type {?} */
+        ComponentDeactivationHandler.prototype.appModelInteractionContext;
+        /** @type {?} */
+        ComponentDeactivationHandler.prototype.primary;
     }
-    NavigationSession.createExternal = createExternal;
 })(NavigationSession || (NavigationSession = {}));
 
 /**
@@ -3013,12 +3204,16 @@ if (false) {
 class PlaceRouter extends GarbageCollector {
     /**
      * @param {?} router
+     * @param {?} urlSerializer
+     * @param {?} navigationSessionFactory
      * @param {?} angularLocation
      * @param {?} placeHistory
      */
-    constructor(router, angularLocation, placeHistory) {
+    constructor(router, urlSerializer, navigationSessionFactory, angularLocation, placeHistory) {
         super();
         this.router = router;
+        this.urlSerializer = urlSerializer;
+        this.navigationSessionFactory = navigationSessionFactory;
         this.angularLocation = angularLocation;
         this.placeHistory = placeHistory;
         this.firstRoute = true;
@@ -3048,8 +3243,11 @@ class PlaceRouter extends GarbageCollector {
             if (event instanceof NavigationStart) {
                 this.onAngularRouterStarted(event);
             }
-            if (event instanceof NavigationEnd || event instanceof NavigationError) {
-                this.onAngularRouterFinished();
+            if (event instanceof NavigationEnd) {
+                this.onAngularRouterFinished(false);
+            }
+            if (event instanceof NavigationError) {
+                this.onAngularRouterFinished(true);
             }
         }));
         this.navigationSessionActive = chain(this.navigationSessionModel).isNotNil();
@@ -3124,21 +3322,19 @@ class PlaceRouter extends GarbageCollector {
                  * @return {?}
                  */
                 router => {
-                    // we have to to use the definition for route id as our redirection always includes
-                    // the id in the url segements (but leaves it blank when there's no id). I.e. in the
-                    // no id case we're doing the following redirect [<placePath>, ""] -> ["..", <id>]
-                    /** @type {?} */
-                    const relativePath = !!previous.placeDefinition.hasRouteId() ? '..' : '.';
                     /** @type {?} */
-                    const commands = [
-                        relativePath,
-                        ...this.createRouteParameters(next),
-                        ...this.extractChildPath(activatedRoute.snapshot)
-                    ];
-                    console.log('### Push Changes to route Redirect', { commands, relativeTo: activatedRoute.snapshot.url });
-                    return router.navigate(commands, {
-                        relativeTo: activatedRoute
-                    });
+                    const commands = this.parseUrl(this.router.routerState.snapshot).createRedirectCommandsFor(next);
+                    // // we have to to use the definition for route id as our redirection always includes
+                    // // the id in the url segements (but leaves it blank when there's no id). I.e. in the
+                    // // no id case we're doing the following redirect [<placePath>, ""] -> ["..", <id>]
+                    // const relativePath = !!previous.placeDefinition.hasRouteId() ? '..' : '.';
+                    // const commands = [
+                    //   relativePath,
+                    //   ...this.createRouteParameters(next),
+                    //   ...this.extractChildPath(activatedRoute.snapshot)
+                    // ];
+                    console.log('### Push Changes to route Redirect', { commands });
+                    return router.navigate(commands);
                 }));
             }
         });
@@ -3150,13 +3346,15 @@ class PlaceRouter extends GarbageCollector {
      */
     doNavigation(visit, customNavigation) {
         return __awaiter(this, void 0, void 0, function* () {
-            this._navigationSessionModel.value = NavigationSession.createInternal(visit);
+            this._navigationSessionModel.value = this.navigationSessionFactory.createInternal(visit);
             try {
                 yield customNavigation(this.router);
             }
             finally {
+                // Router has finished (since there was no router change required) so we
+                // need to end the navigation session.
                 if (this.navigationSession && !this.router.getCurrentNavigation()) {
-                    this.onAngularRouterFinished();
+                    this.onAngularRouterFinished(false);
                 }
             }
         });
@@ -3183,9 +3381,9 @@ class PlaceRouter extends GarbageCollector {
         if (!this.navigationSession) { // We been activated by an external route rather than placeRouter.go(visit)
             console.log('navigation started', { firstTime: this.firstRoute });
             /** @type {?} */
-            const session = NavigationSession.createExternal(this.firstRoute);
+            const session = this.navigationSessionFactory.createExternal(this.firstRoute);
             if (event.navigationTrigger === 'popstate') {
-                session.setPopstateReturn(this.router.routerState.snapshot.url);
+                session.setPopstateReturnUrl(this.router.routerState.snapshot.url);
             }
             this._navigationSessionModel.value = session;
         }
@@ -3194,23 +3392,32 @@ class PlaceRouter extends GarbageCollector {
     // @Trace()
     /**
      * @private
+     * @param {?} cancelled
      * @return {?}
      */
-    onAngularRouterFinished() {
+    onAngularRouterFinished(cancelled) {
         /** @type {?} */
         const session = this._navigationSessionModel.value;
-        // Update visits before we end the navigation session.  This allows the place out let to
-        // gate ignore changes that occur while the visit is active
-        /** @type {?} */
-        const visits = session.getVisits();
-        visits.forEach((/**
-         * @param {?} v
-         * @return {?}
-         */
-        v => {
-            this.placeHistory.add(v);
-        }));
-        this._activeVisits.value = visits;
+        if (!cancelled) {
+            // Update visits before we end the navigation session.  This allows the placeOutets to
+            // ignore visit changes that occur while the navigation is in progress
+            /** @type {?} */
+            const visits = session.getVisits();
+            visits.forEach((/**
+             * @param {?} v
+             * @return {?}
+             */
+            v => this.placeHistory.add(v)));
+            this._activeVisits.value = visits;
+        }
+        else {
+            // Angular doesn't preserve the url when a guard cancels the back button.
+            // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
+            if (session.isPopState) {
+                console.log('cancelled during popstate');
+                this.angularLocation.go(session.popStateReturnUrl);
+            }
+        }
         this._navigationSessionModel.value = null;
     }
     /**
@@ -3224,6 +3431,13 @@ class PlaceRouter extends GarbageCollector {
          */
         child => child.url)));
     }
+    /**
+     * @param {?} snapshot
+     * @return {?}
+     */
+    parseUrl(snapshot) {
+        return new PlaceRouter.UrlHelper(this.urlSerializer.parse(snapshot.url));
+    }
 }
 PlaceRouter.decorators = [
     { type: Injectable, args: [{
@@ -3233,10 +3447,12 @@ PlaceRouter.decorators = [
 /** @nocollapse */
 PlaceRouter.ctorParameters = () => [
     { type: Router },
+    { type: UrlSerializer },
+    { type: NavigationSession.Factory },
     { type: Location },
     { type: PlaceHistory }
 ];
-/** @nocollapse */ PlaceRouter.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(ɵɵinject(Router), ɵɵinject(Location), ɵɵinject(PlaceHistory)); }, token: PlaceRouter, providedIn: "root" });
+/** @nocollapse */ PlaceRouter.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(ɵɵinject(Router), ɵɵinject(UrlSerializer), ɵɵinject(NavigationSession.Factory), ɵɵinject(Location), ɵɵinject(PlaceHistory)); }, token: PlaceRouter, providedIn: "root" });
 __decorate([
     Trace(),
     __metadata("design:type", Function),
@@ -3268,11 +3484,123 @@ if (false) {
      * @private
      */
     PlaceRouter.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouter.prototype.urlSerializer;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouter.prototype.navigationSessionFactory;
     /** @type {?} */
     PlaceRouter.prototype.angularLocation;
     /** @type {?} */
     PlaceRouter.prototype.placeHistory;
 }
+(function (PlaceRouter) {
+    class UrlHelper {
+        /**
+         * @param {?} urlTree
+         */
+        constructor(urlTree) {
+            this.urlTree = urlTree;
+            console.log({ segments: this.urlTree.root.children.primary.segments });
+        }
+        /**
+         * @return {?}
+         */
+        cloneUrlSegmentList() {
+            return [...this.urlTree.root.children.primary.segments];
+        }
+        /**
+         * @param {?} visit
+         * @return {?}
+         */
+        updateVisitSegments(visit) {
+            // Ugly, but it works for now.
+            /** @type {?} */
+            const segments = this.cloneUrlSegmentList();
+            /** @type {?} */
+            const visitSegments = this.convertToUrlSegments(visit);
+            /** @type {?} */
+            const replaceAt = segments.findIndex((/**
+             * @param {?} segment
+             * @return {?}
+             */
+            segment => segment.path === visitSegments[0].path));
+            // do not use the return value, it's the items that were removed!
+            segments.splice(replaceAt, visitSegments.length, ...visitSegments);
+            return segments;
+        }
+        /**
+         * Converts the visit into segments.  Please not that these segments are not e
+         * @param {?} visit
+         * @return {?}
+         */
+        convertToUrlSegments(visit) {
+            return visit.placeDefinition.hasRouteId() ?
+                [
+                    // NOTE:
+                    // It's important to attach the params to the root path and not the id.  If we attach them
+                    // to an empty id then the angular router won't match the pattern.
+                    new UrlSegment(visit.placeDefinition.path, visit.placeDefinition.getFormattedRouteParameters(visit)),
+                    new UrlSegment(visit.placeDefinition.getFormattedRouteId(visit), {})
+                ]
+                :
+                    [
+                        new UrlSegment(visit.placeDefinition.path, visit.placeDefinition.getFormattedRouteParameters(visit))
+                    ];
+        }
+        /**
+         * @param {?} visit
+         * @return {?}
+         */
+        createRedirectCommandsFor(visit) {
+            /** @type {?} */
+            const segments = this.updateVisitSegments(visit);
+            /** @type {?} */
+            const commands = [];
+            segments.forEach((/**
+             * @param {?} s
+             * @return {?}
+             */
+            s => {
+                commands.push(s.path);
+                if (s.parameterMap.keys.length > 0) {
+                    commands.push(s.parameters);
+                }
+            }));
+            return commands;
+        }
+        /**
+         * @param {?} placeDef
+         * @return {?}
+         */
+        includesPathOf(placeDef) {
+            return this.cloneUrlSegmentList().find((/**
+             * @param {?} s
+             * @return {?}
+             */
+            s => s.path === placeDef.path));
+        }
+    }
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Visit]),
+        __metadata("design:returntype", Array)
+    ], UrlHelper.prototype, "createRedirectCommandsFor", null);
+    PlaceRouter.UrlHelper = UrlHelper;
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        UrlHelper.prototype.urlTree;
+    }
+})(PlaceRouter || (PlaceRouter = {}));
 
 /**
  * @fileoverview added by tsickle
@@ -4851,10 +5179,9 @@ class EnterPlaceGuard {
                 // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters
                 this.placeRouter.navigationSession.storeVisit(sanitisedVisit);
                 if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {
-                    /** @type {?} */
-                    const routerStateUrlTree = this.urlSerializer.parse(state.url);
                     // Regenerate the url
-                    const { commands } = this.createRedirectCommands(sanitisedVisit, [...routerStateUrlTree.root.children.primary.segments]);
+                    /** @type {?} */
+                    const commands = this.placeRouter.parseUrl(state).createRedirectCommandsFor(sanitisedVisit);
                     console.log('##### Place Guard Redirect', commands);
                     return this.router.createUrlTree(commands, {
                         replaceUrl: true,
@@ -4870,40 +5197,6 @@ class EnterPlaceGuard {
             }
         });
     }
-    /**
-     * @private
-     * @param {?} sanitisedVisit
-     * @param {?} path
-     * @return {?}
-     */
-    createRedirectCommands(sanitisedVisit, path) {
-        // Ugly, but it works for now.
-        /** @type {?} */
-        const newSegments = sanitisedVisit.getUrlSegments();
-        /** @type {?} */
-        const replaceAt = path.findIndex((/**
-         * @param {?} segment
-         * @return {?}
-         */
-        segment => segment.path === newSegments[0].path));
-        /** @type {?} */
-        const newPath = [...path];
-        newPath.splice(replaceAt, newSegments.length, ...newSegments); // do not use the return value, it's the items that were removed!
-        // do not use the return value, it's the items that were removed!
-        /** @type {?} */
-        const commands = [];
-        newPath.forEach((/**
-         * @param {?} s
-         * @return {?}
-         */
-        s => {
-            commands.push(s.path);
-            if (s.parameterMap.keys.length > 0) {
-                commands.push(s.parameters);
-            }
-        }));
-        return { newPath, commands };
-    }
 }
 EnterPlaceGuard.decorators = [
     { type: Injectable, args: [{
@@ -5082,86 +5375,10 @@ if (false) {
  */
 class LeavePlaceGuard {
     /**
-     * @param {?} router
-     * @param {?} injector
      * @param {?} placeRouter
-     * @param {?} dialogInteractionContext
-     * @param {?} angularLocation
      */
-    constructor(router, injector, placeRouter, dialogInteractionContext, angularLocation) {
-        this.router = router;
-        this.injector = injector;
+    constructor(placeRouter) {
         this.placeRouter = placeRouter;
-        this.dialogInteractionContext = dialogInteractionContext;
-        this.angularLocation = angularLocation;
-    }
-    // @Trace()
-    /**
-     * @private
-     * @param {?} nextState
-     * @param {?} placeDefinition
-     * @return {?}
-     */
-    isLeavingTheCurrentPlace(nextState, placeDefinition) {
-        // TODO: this will break with child routes... need to examine the router states properly.
-        // 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"
-        // }
-        // TODO: this will break with child routes... need to examine the router states properly.
-        // 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"
-        // }
-        /** @type {?} */
-        const placeDefinitionPath = `/${placeDefinition.path}`;
-        return !nextState.url.startsWith(placeDefinitionPath);
     }
     /**
      * @param {?} component
@@ -5172,77 +5389,7 @@ class LeavePlaceGuard {
      */
     canDeactivate(component, currentRoute, currentState, nextState) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.placeRouter.navigationSession.alreadyAccepted(component)) {
-                // We'll get called multiple times if there's any parameter sanitisation so
-                // we always return true if we accepted on a previous cycle of the current
-                // navigation session.
-                return true;
-            }
-            else {
-                /** @type {?} */
-                const self = this;
-                /** @type {?} */
-                let canLeave = true;
-                if (this.isLeavingTheCurrentPlace(nextState, component.placeDefinition)) {
-                    // we check the dialog interaction first, so that components that don't need to check if they're in an
-                    // interaction during the canDeactivate cycle.
-                    // TODO: Add tests: show dialog -> hit back -> same route
-                    if (this.dialogInteractionContext.isActive()) {
-                        console.log('cancelling', { activity: this.dialogInteractionContext.currentActivity });
-                        this.dialogInteractionContext.currentActivity.cancel(null);
-                        canLeave = false;
-                    }
-                    else {
-                        canLeave = true;
-                    }
-                    if (canLeave) {
-                        // now check if the component has an active interaction.  This will handle
-                        // an inplace interaction contexts
-                        if (component.interactionContext && component.interactionContext.isActive()) {
-                            canLeave = false;
-                            console.log('cancelling', { activity: component.interactionContext.currentActivity });
-                            component.interactionContext.currentActivity.cancel(null);
-                        }
-                    }
-                    // No interaction in progress, so ask the component .
-                    // This may start an interaction, hence checking the interaction context above. I.e. if the place pops up the dialog, and
-                    // the user clicks back again, we'll re-enter here and go bang when the component tries to open another
-                    // dialog.
-                    if (canLeave) {
-                        // TODO: Add tests: hit back -> confirm leave dialog -> hit back -> close dialog ->  hit back -> confirm leave dialog.
-                        canLeave = yield component.canDeactivate();
-                    }
-                    // We also block back button parameter changes while the dialog is open.
-                    // NOTE: Now that I'm catching parameter changes I could possibly retry using a fragment or
-                    // query parameter to track the dialog being open.  Previously I was just checking this on
-                    // path changes... if that worked it'd fix the case where the back button breaks with an activity
-                    // open on the first page: https://coolon.atlassian.net/browse/AUP-33
-                }
-                else {
-                    if (this.dialogInteractionContext.isActive()) {
-                        console.log('cancelling', { activity: this.dialogInteractionContext.currentActivity });
-                        this.dialogInteractionContext.currentActivity.cancel(null);
-                        canLeave = false;
-                    }
-                    else {
-                        canLeave = true;
-                    }
-                }
-                if (canLeave) {
-                    // We'll get called multiple times if there's any parameter sanitisation so
-                    // we remember the acceptance for the duration of the current navigation session.
-                    self.placeRouter.navigationSession.rememberAcceptanceOf(component);
-                }
-                else {
-                    // 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.popStateReturnUrl);
-                    }
-                }
-                return canLeave;
-            }
+            return this.placeRouter.navigationSession.canDeactivate(component, this.placeRouter.parseUrl(nextState));
         });
     }
 }
@@ -5253,33 +5400,15 @@ LeavePlaceGuard.decorators = [
 ];
 /** @nocollapse */
 LeavePlaceGuard.ctorParameters = () => [
-    { type: Router },
-    { type: Injector },
-    { type: PlaceRouter },
-    { type: InteractionContext },
-    { type: Location }
+    { type: PlaceRouter }
 ];
-/** @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" });
+/** @nocollapse */ LeavePlaceGuard.ngInjectableDef = ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(ɵɵinject(PlaceRouter)); }, token: LeavePlaceGuard, providedIn: "root" });
 if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    LeavePlaceGuard.prototype.router;
-    /**
-     * @type {?}
-     * @private
-     */
-    LeavePlaceGuard.prototype.injector;
     /**
      * @type {?}
      * @private
      */
     LeavePlaceGuard.prototype.placeRouter;
-    /** @type {?} */
-    LeavePlaceGuard.prototype.dialogInteractionContext;
-    /** @type {?} */
-    LeavePlaceGuard.prototype.angularLocation;
 }
 
 /**
@@ -5302,5 +5431,5 @@ if (false) {
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
-export { ACTIVITY_DATA, AUP_PLACE_CONFIG, AbstractActivity, AbstractInputComponent, AbstractPlaceNavigationComponent, Activity, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, AngularUiPowerupsModule, Bounds, BusyOverlayComponent, CommandDirective, ComponentsModule, ConfirmThenDialogComponent, ConfirmationDialogComponent, DEFINITION_META_DATA_KEY, DIALOG_INTERACTION_SERVICE_DEFAULTS, DialogInteractionService, Dimension, DirectivesModule, DisposableComponent, EmptyStateComponent, EnterPlaceGuard, FocusBindingDirective, Formatter, InplaceInteractionContextComponent, InteractionContext, InteractionGuard, InteractionModule, InteractionOutletComponent, LEFT_RIGHT_PLACE_ANIMATION, LeavePlaceGuard, ListPlaceNavComponent, NavigationSession, NoopComponent, NumberInputComponent, ParameterDefinition, PasswordInputComponent, Place, PlaceComponent, PlaceDefinition, PlaceHistory, PlaceModule, PlaceOutletComponent, PlaceRouter, Point, ROUTE_PARAMETER_LIST_KEY, ResizeAwareComponent, RouteId, SelectInputComponent, StringInputComponent, TabbedPlaceNavigationComponent, Visit, VisitParameter, VisitParameterList, VisitSanitiser, leftRightPlaceAnimation, slideDownAndUpAnimation, DirectivesModule as ɵa, CommandDirective as ɵb, InteractionContext as ɵba, ActivityOutletComponent as ɵbb, ConfirmationDialogComponent as ɵbc, AbstractActivity as ɵbd, ACTIVITY_DATA as ɵbe, Activity as ɵbf, ConfirmThenDialogComponent as ɵbh, AlertDialogComponent as ɵbi, InteractionOutletComponent as ɵbk, InplaceInteractionContextComponent as ɵbl, DIALOG_INTERACTION_SERVICE_DEFAULTS as ɵbm, DialogInteractionService as ɵbn, FocusBindingDirective as ɵc, DisposableComponent as ɵd, ComponentsModule as ɵe, NumberInputComponent as ɵf, AbstractInputComponent as ɵg, StringInputComponent as ɵh, PasswordInputComponent as ɵi, SelectInputComponent as ɵj, NoopComponent as ɵk, PlaceModule as ɵl, EmptyStateComponent as ɵm, BusyOverlayComponent as ɵn, PlaceOutletComponent as ɵo, leftRightPlaceAnimation as ɵp, LEFT_RIGHT_PLACE_ANIMATION as ɵq, AUP_PLACE_CONFIG as ɵr, PlaceRouter as ɵt, PlaceHistory as ɵu, TabbedPlaceNavigationComponent as ɵv, AbstractPlaceNavigationComponent as ɵw, ListPlaceNavComponent as ɵx, InteractionModule as ɵy, ActivityContainerComponent as ɵz };
+export { ACTIVITY_DATA, AUP_PLACE_CONFIG, AbstractActivity, AbstractInputComponent, AbstractPlaceNavigationComponent, Activity, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, AngularUiPowerupsModule, Bounds, BusyOverlayComponent, CommandDirective, ComponentsModule, ConfirmThenDialogComponent, ConfirmationDialogComponent, DEFINITION_META_DATA_KEY, DIALOG_INTERACTION_SERVICE_DEFAULTS, DialogInteractionService, Dimension, DirectivesModule, DisposableComponent, EmptyStateComponent, EnterPlaceGuard, FocusBindingDirective, Formatter, InplaceInteractionContextComponent, InteractionContext, InteractionGuard, InteractionModule, InteractionOutletComponent, LEFT_RIGHT_PLACE_ANIMATION, LeavePlaceGuard, ListPlaceNavComponent, NavigationSession, NoopComponent, NumberInputComponent, ParameterDefinition, PasswordInputComponent, Place, PlaceComponent, PlaceDefinition, PlaceHistory, PlaceModule, PlaceOutletComponent, PlaceRouter, Point, ROUTE_PARAMETER_LIST_KEY, ResizeAwareComponent, RouteId, SelectInputComponent, StringInputComponent, TabbedPlaceNavigationComponent, Visit, VisitParameter, VisitParameterList, VisitSanitiser, leftRightPlaceAnimation, slideDownAndUpAnimation, DirectivesModule as ɵa, CommandDirective as ɵb, InteractionModule as ɵba, ActivityContainerComponent as ɵbb, ActivityOutletComponent as ɵbc, ConfirmationDialogComponent as ɵbd, AbstractActivity as ɵbe, ACTIVITY_DATA as ɵbf, Activity as ɵbg, ConfirmThenDialogComponent as ɵbi, AlertDialogComponent as ɵbj, InteractionOutletComponent as ɵbl, InplaceInteractionContextComponent as ɵbm, DIALOG_INTERACTION_SERVICE_DEFAULTS as ɵbn, DialogInteractionService 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, NavigationSession as ɵu, InteractionContext as ɵv, PlaceHistory as ɵw, TabbedPlaceNavigationComponent as ɵx, AbstractPlaceNavigationComponent as ɵy, ListPlaceNavComponent as ɵz };
 //# sourceMappingURL=coolon-angular-ui-powerups.js.map