@coolon/angular-ui-powerups 0.0.90 → 0.0.92

package/bundles/coolon-angular-ui-powerups.umd.js

@@ -216,9 +216,28 @@
         function CommandDirective(elementRef) {
             var _this = _super.call(this) || this;
             _this.elementRef = elementRef;
+            _this._commandEnabled = new pectin.DelegatingValueModel().withDefault(false);
             _this._commandParameterProvided = false;
             return _this;
         }
+        Object.defineProperty(CommandDirective.prototype, "pectinCommand", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._command;
+            },
+            set: /**
+             * @param {?} command
+             * @return {?}
+             */
+            function (command) {
+                this._command = command;
+                this._commandEnabled.setDelegate(command ? command.enabled : null);
+            },
+            enumerable: true,
+            configurable: true
+        });
         Object.defineProperty(CommandDirective.prototype, "commandParameter", {
             get: /**
              * @return {?}
@@ -267,7 +286,7 @@
             // for some reason mat-buttons kills the disabled host binding.  It works on a regular button but for now
             // we need to do this.
             var chain = pectin.Dsl.disposeWith(this).chain;
-            chain(this.pectinCommand.enabled).subscribe((/**
+            chain(this._commandEnabled).subscribe((/**
              * @param {?} enabled
              * @return {?}
              */
@@ -336,8 +355,16 @@
         return CommandDirective;
     }(pectin.GarbageCollector));
     if (false) {
-        /** @type {?} */
-        CommandDirective.prototype.pectinCommand;
+        /**
+         * @type {?}
+         * @private
+         */
+        CommandDirective.prototype._command;
+        /**
+         * @type {?}
+         * @private
+         */
+        CommandDirective.prototype._commandEnabled;
         /**
          * @type {?}
          * @private
@@ -1077,51 +1104,107 @@
     InteractionContext = /** @class */ (function (_super) {
         __extends(InteractionContext, _super);
         function InteractionContext() {
-            return _super.call(this) || this;
-        }
-        Object.defineProperty(InteractionContext.prototype, "currentActivity", {
+            var _this = _super.call(this) || this;
             /**
-             * Returns the activity that is currently active.
+             * 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 pectin.DelegatingListModel();
+            var _a = pectin.Dsl.disposeWith(_this), chain = _a.chain, valueOf = _a.valueOf, before = _a.before, when = _a.when, after = _a.after, observe = _a.observe, switchOn = _a.switchOn;
+            when.listOf(_this.activityList).becomesPopulated((/**
+             * @param {?} activities
+             * @return {?}
+             */
+            function (activities) {
+                if (_this.deferredGetCurrentActivity) {
+                    _this.deferredGetCurrentActivity.resolve(___default.last(activities));
+                    _this.deferredGetCurrentActivity = null;
+                }
+            }));
+            return _this;
+        }
+        /**
+         * @protected
+         * @param {?} activityList
+         * @return {?}
+         */
+        InteractionContext.prototype.setActivityList = /**
+         * @protected
+         * @param {?} activityList
+         * @return {?}
+         */
+        function (activityList) {
+            this._activityListDelegate.setDelegate(activityList);
+        };
+        Object.defineProperty(InteractionContext.prototype, "activityList", {
             get: /**
-             * Returns the activity that is currently active.
-             * This model is only updated in the next tick after the view has been updated.
              * @return {?}
              */
             function () {
-                return ___default.last(this.activityList.value);
+                return this._activityListDelegate.readonly;
             },
             enumerable: true,
             configurable: true
         });
         /**
-         * @param {?} confirm
+         * Returns the activity that is currently active.
+         * This model is only updated in the next tick after the view has been updated.
+         */
+        /**
+         * Returns the activity that is currently active.
+         * This model is only updated in the next tick after the view has been updated.
          * @return {?}
          */
-        InteractionContext.prototype.confirm = /**
-         * @param {?} confirm
+        InteractionContext.prototype.getCurrentActivity = /**
+         * Returns the activity that is currently active.
+         * This model is only updated in the next tick after the view has been updated.
          * @return {?}
          */
-        function (confirm) {
+        function () {
             return __awaiter(this, void 0, void 0, function () {
-                var _a;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            _b.trys.push([0, 2, , 3]);
-                            return [4 /*yield*/, this.confirmOrReject(confirm)];
-                        case 1:
-                            _b.sent();
-                            return [2 /*return*/, true];
-                        case 2:
-                            _a = _b.sent();
-                            return [2 /*return*/, false];
-                        case 3: return [2 /*return*/];
+                return __generator(this, function (_a) {
+                    if (!this.isActive()) {
+                        return [2 /*return*/, Promise.reject('no activity in progress')];
+                    }
+                    else {
+                        if (this.deferredGetCurrentActivity) {
+                            // we're already waiting then just return the same promise
+                            return [2 /*return*/, this.deferredGetCurrentActivity.promise];
+                        }
+                        else {
+                            if (this.activityList.length < 1) {
+                                this.deferredGetCurrentActivity = pectin.Deferred.defer();
+                                return [2 /*return*/, this.deferredGetCurrentActivity.promise];
+                            }
+                            else {
+                                return [2 /*return*/, ___default.last(this.activityList.value)];
+                            }
+                        }
                     }
+                    return [2 /*return*/];
                 });
             });
         };
+        /**
+         * @param {?} confirm
+         * @return {?}
+         */
+        InteractionContext.prototype.confirm = /**
+         * @param {?} confirm
+         * @return {?}
+         */
+        function (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 {?}
+             */
+            function () { return true; })).catch((/**
+             * @return {?}
+             */
+            function () { return false; }));
+        };
         return InteractionContext;
     }(pectin.GarbageCollector));
     if (false) {
@@ -1129,8 +1212,14 @@
          * 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
@@ -1772,6 +1861,7 @@
              * @return {?}
              */
             function () { return _this.onNestedActivityFinished(); }));
+            _this.setActivityList(_this._activityList.readonly);
             return _this;
         }
         Object.defineProperty(ActivityContainerComponent.prototype, "initialActivityOutletContext", {
@@ -1827,16 +1917,6 @@
         function () {
             return !!this._initialActivityOutletContext;
         };
-        Object.defineProperty(ActivityContainerComponent.prototype, "activityList", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                return this._activityList.readonly;
-            },
-            enumerable: true,
-            configurable: true
-        });
         Object.defineProperty(ActivityContainerComponent.prototype, "isFinished", {
             get: /**
              * @return {?}
@@ -2154,21 +2234,12 @@
         /**
          * @return {?}
          */
-        InplaceInteractionContextComponent.prototype.ngOnInit = /**
+        InplaceInteractionContextComponent.prototype.ngAfterViewInit = /**
          * @return {?}
          */
         function () {
+            this.setActivityList(this.interactionContext.activityList);
         };
-        Object.defineProperty(InplaceInteractionContextComponent.prototype, "activityList", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                return this.interactionContext.activityList;
-            },
-            enumerable: true,
-            configurable: true
-        });
         /**
          * @return {?}
          */
@@ -2388,11 +2459,9 @@
             _this.router = router;
             _this.dialogServiceDefaults = dialogServiceDefaults;
             _this.matDialogDefaultConfig = matDialogDefaultConfig;
-            _this._activityList = new pectin.DelegatingListModel();
             _this.startingGuard = new Guard();
+            _this._inActivityPromise = new pectin.MutableValueModel(false);
             typescriptUtilities.assert.notNil(dialogService);
-            var _a = pectin.Dsl.disposeWith(_this), chain = _a.chain, valueOf = _a.valueOf, before = _a.before, when = _a.when, after = _a.after, observe = _a.observe, switchOn = _a.switchOn;
-            _this.active = chain(_this._activityList).isNotEmpty();
             return _this;
         }
         /**
@@ -2402,23 +2471,14 @@
          * @return {?}
          */
         function () {
-            return this.active.value;
-        };
-        /**
-         * @return {?}
-         */
-        DialogInteractionService.prototype.cancelActivity = /**
-         * @return {?}
-         */
-        function () {
-            this.currentActivity.cancel(null);
+            return this._inActivityPromise.value;
         };
-        Object.defineProperty(DialogInteractionService.prototype, "activityList", {
+        Object.defineProperty(DialogInteractionService.prototype, "active", {
             get: /**
              * @return {?}
              */
             function () {
-                return this._activityList.readonly;
+                return this._inActivityPromise.readonly;
             },
             enumerable: true,
             configurable: true
@@ -2469,6 +2529,7 @@
              */
             function () {
                 console.log('######  STARTING');
+                _this._inActivityPromise.value = true;
                 // this.currentActivityId = uuid.v1();
                 // this.location.go(this.router.routerState.snapshot.url, "aup");
                 /** @type {?} */
@@ -2527,6 +2588,7 @@
                  * @return {?}
                  */
                 function () {
+                    _this._inActivityPromise.value = false;
                     console.log('######  FINISHED');
                     // this.currentActivityId = null;
                     self.safelyUpdateActivityListDelegate(null);
@@ -2552,7 +2614,7 @@
             setTimeout((/**
              * @return {?}
              */
-            function () { return _this._activityList.setDelegate(delegate); }));
+            function () { return _this.setActivityList(delegate); }));
         };
         /**
          * @param {?} alert
@@ -2619,14 +2681,12 @@
          * @type {?}
          * @private
          */
-        DialogInteractionService.prototype._activityList;
+        DialogInteractionService.prototype.startingGuard;
         /**
          * @type {?}
          * @private
          */
-        DialogInteractionService.prototype.startingGuard;
-        /** @type {?} */
-        DialogInteractionService.prototype.active;
+        DialogInteractionService.prototype._inActivityPromise;
         /**
          * @type {?}
          * @private
@@ -3401,15 +3461,6 @@
             enumerable: true,
             configurable: true
         });
-        /**
-         * @return {?}
-         */
-        PlaceComponent.prototype.canDeactivate = /**
-         * @return {?}
-         */
-        function () {
-            return true;
-        };
         /**
          * @return {?}
          */
@@ -3418,36 +3469,13 @@
          */
         function () {
         };
-        /**
-         * 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.
-         */
-        // @Trace()
-        /**
-         * 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()
-        PlaceComponent.prototype.onPlaceDestroyed = /**
-         * 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()
-        function () {
-            this.dispose();
-        };
         __decorate([
             fastMemoizeDecorator.Memoize(),
             __metadata("design:type", exports.PlaceDefinition),
             __metadata("design:paramtypes", [])
         ], PlaceComponent.prototype, "placeDefinition", null);
         return PlaceComponent;
-    }(pectin.GarbageCollector));
+    }(DisposableComponent));
     if (false) {
         /**
          * @type {?}
@@ -3692,10 +3720,13 @@
      * @abstract
      */
     exports.NavigationSession = /** @class */ (function () {
-        function NavigationSession(firstNavigation) {
+        function NavigationSession(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
@@ -3719,52 +3750,36 @@
         function (placeDef) {
             return this._visits.get(placeDef);
         };
-        /**
-         * @param {?} params
-         * @return {?}
-         */
-        NavigationSession.prototype.mergePrivatePlaceParameters = /**
-         * @param {?} params
-         * @return {?}
-         */
-        function (params) {
-            return null;
-        };
-        // @Trace()
-        // @Trace()
-        /**
-         * @param {?} placeComponent
-         * @return {?}
-         */
-        NavigationSession.prototype.alreadyAccepted = 
-        // @Trace()
-        /**
-         * @param {?} placeComponent
-         * @return {?}
-         */
-        function (placeComponent) {
-            return this._alreadyAccepted.includes(placeComponent);
-        };
-        // @Trace()
-        // @Trace()
         /**
          * @param {?} component
+         * @param {?} nextState
          * @return {?}
          */
-        NavigationSession.prototype.rememberAcceptanceOf = 
-        // @Trace()
-        /**
+        NavigationSession.prototype.canDeactivate = /**
          * @param {?} component
+         * @param {?} nextState
          * @return {?}
          */
-        function (component) {
-            this._alreadyAccepted.push(component);
+        function (component, nextState) {
+            return __awaiter(this, void 0, void 0, function () {
+                var handler, isPrimaryHandler;
+                return __generator(this, function (_a) {
+                    // lookup the handler and create it if we've not seen it yet
+                    handler = this.componentDeactivationHandlers.get(component);
+                    if (!handler) {
+                        isPrimaryHandler = this.componentDeactivationHandlers.size === 0;
+                        handler = new NavigationSession.ComponentDeactivationHandler(component, this.appModalInteractionContext, isPrimaryHandler);
+                        this.componentDeactivationHandlers.set(component, handler);
+                    }
+                    return [2 /*return*/, handler.canDeactivate(nextState)];
+                });
+            });
         };
         /**
          * @param {?} url
          * @return {?}
          */
-        NavigationSession.prototype.setPopstateReturn = /**
+        NavigationSession.prototype.setPopstateReturnUrl = /**
          * @param {?} url
          * @return {?}
          */
@@ -3821,13 +3836,25 @@
         /** @type {?} */
         exports.NavigationSession.prototype.isExternal;
         /** @type {?} */
+        exports.NavigationSession.prototype.dialogOpenOnStart;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.NavigationSession.prototype.componentDeactivationHandlers;
+        /** @type {?} */
         exports.NavigationSession.prototype.firstNavigation;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.NavigationSession.prototype.appModalInteractionContext;
     }
     (function (NavigationSession) {
         var External = /** @class */ (function (_super) {
             __extends(External, _super);
-            function External(isFirstTime) {
-                var _this = _super.call(this, isFirstTime) || this;
+            function External(isFirstTime, appModelInteractionContext) {
+                var _this = _super.call(this, isFirstTime, appModelInteractionContext) || this;
                 _this.isExternal = true;
                 return _this;
             }
@@ -3839,8 +3866,8 @@
         }
         var Internal = /** @class */ (function (_super) {
             __extends(Internal, _super);
-            function Internal(visit) {
-                var _this = _super.call(this, false) || this;
+            function Internal(visit, appModelInteractionContext) {
+                var _this = _super.call(this, false, appModelInteractionContext) || this;
                 _this.isExternal = false;
                 _this.storeVisit(visit);
                 return _this;
@@ -3851,22 +3878,183 @@
             /** @type {?} */
             Internal.prototype.isExternal;
         }
-        /**
-         * @param {?} visit
-         * @return {?}
-         */
-        function createInternal(visit) {
-            return new Internal(visit);
+        var Factory = /** @class */ (function () {
+            function Factory(interactionContext) {
+                this.interactionContext = interactionContext;
+            }
+            /**
+             * @param {?} visit
+             * @return {?}
+             */
+            Factory.prototype.createInternal = /**
+             * @param {?} visit
+             * @return {?}
+             */
+            function (visit) {
+                return new Internal(visit, this.interactionContext);
+            };
+            /**
+             * @param {?} firstTimeRoute
+             * @return {?}
+             */
+            Factory.prototype.createExternal = /**
+             * @param {?} firstTimeRoute
+             * @return {?}
+             */
+            function (firstTimeRoute) {
+                return new External(firstTimeRoute, this.interactionContext);
+            };
+            return Factory;
+        }());
+        NavigationSession.Factory = Factory;
+        if (false) {
+            /** @type {?} */
+            Factory.prototype.interactionContext;
         }
-        NavigationSession.createInternal = createInternal;
-        /**
-         * @param {?} firstTimeRoute
-         * @return {?}
-         */
-        function createExternal(firstTimeRoute) {
-            return new External(firstTimeRoute);
+        var ComponentDeactivationHandler = /** @class */ (function () {
+            function ComponentDeactivationHandler(component, appModelInteractionContext, primary) {
+                this.component = component;
+                this.appModelInteractionContext = appModelInteractionContext;
+                this.primary = primary;
+                this.alreadyAccepted = false;
+                // super();
+            }
+            /**
+             * @param {?} nextState
+             * @return {?}
+             */
+            ComponentDeactivationHandler.prototype.canDeactivate = /**
+             * @param {?} nextState
+             * @return {?}
+             */
+            function (nextState) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var _a;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                console.log(this.constructor.name + ".canDeactivate", { component: this.component });
+                                if (!this.alreadyAccepted) return [3 /*break*/, 1];
+                                // 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 [2 /*return*/, true];
+                            case 1:
+                                if (!(this.primary && this.appModelInteractionContext.isActive())) return [3 /*break*/, 3];
+                                // We check the global interaction first
+                                return [4 /*yield*/, this.cancelCurrentActivityOf(this.appModelInteractionContext)];
+                            case 2:
+                                // We check the global interaction first
+                                _b.sent();
+                                return [2 /*return*/, false];
+                            case 3:
+                                _a = this;
+                                return [4 /*yield*/, this.canDeactivateComponent(nextState)];
+                            case 4:
+                                _a.alreadyAccepted = _b.sent();
+                                return [2 /*return*/, this.alreadyAccepted];
+                        }
+                    });
+                });
+            };
+            /**
+             * @protected
+             * @param {?} nextState
+             * @return {?}
+             */
+            ComponentDeactivationHandler.prototype.canDeactivateComponent = /**
+             * @protected
+             * @param {?} nextState
+             * @return {?}
+             */
+            function (nextState) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var hasCustomInteractionContext;
+                    return __generator(this, function (_a) {
+                        // check if the component has an active interaction.  This will handle
+                        // an inplace interaction contexts
+                        hasCustomInteractionContext = this.component.interactionContext &&
+                            !this.isAppModalInteractionContext(this.component.interactionContext) &&
+                            this.component.interactionContext.isActive();
+                        if (hasCustomInteractionContext) {
+                            this.cancelCurrentActivityOf(this.component.interactionContext);
+                            return [2 /*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 [2 /*return*/, this.component.canDeactivate()];
+                        }
+                        return [2 /*return*/, true];
+                    });
+                });
+            };
+            /**
+             * @param {?} interactionContext
+             * @return {?}
+             */
+            ComponentDeactivationHandler.prototype.isAppModalInteractionContext = /**
+             * @param {?} interactionContext
+             * @return {?}
+             */
+            function (interactionContext) {
+                return this.appModelInteractionContext === interactionContext;
+            };
+            /**
+             * @protected
+             * @param {?} interactionContext
+             * @return {?}
+             */
+            ComponentDeactivationHandler.prototype.cancelCurrentActivityOf = /**
+             * @protected
+             * @param {?} interactionContext
+             * @return {?}
+             */
+            function (interactionContext) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var activity;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, interactionContext.getCurrentActivity()];
+                            case 1:
+                                activity = _a.sent();
+                                console.log('cancelling', { activity: activity });
+                                activity.cancel(null);
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            };
+            /**
+             * @protected
+             * @param {?} nextState
+             * @return {?}
+             */
+            ComponentDeactivationHandler.prototype.isLeavingCurrentPlace = /**
+             * @protected
+             * @param {?} nextState
+             * @return {?}
+             */
+            function (nextState) {
+                return !nextState.includesPathOf(this.component.placeDefinition);
+            };
+            return ComponentDeactivationHandler;
+        }());
+        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;
     })(exports.NavigationSession || (exports.NavigationSession = {}));
 
     /**
@@ -3955,10 +4143,11 @@
      */
     exports.ɵt = /** @class */ (function (_super) {
         __extends(PlaceRouter, _super);
-        function PlaceRouter(router$1, urlSerializer, angularLocation, placeHistory) {
+        function PlaceRouter(router$1, urlSerializer, interactionContext, angularLocation, placeHistory) {
             var _this = _super.call(this) || this;
             _this.router = router$1;
             _this.urlSerializer = urlSerializer;
+            _this.interactionContext = interactionContext;
             _this.angularLocation = angularLocation;
             _this.placeHistory = placeHistory;
             _this.firstRoute = true;
@@ -3966,6 +4155,7 @@
             _this._activeVisits = new pectin.MutableListModel();
             var _a = pectin.Dsl.disposeWith(_this), chain = _a.chain, valueOf = _a.valueOf, before = _a.before, when = _a.when, after = _a.after, observe = _a.observe, switchOn = _a.switchOn;
             _this.activeVisitIndex = chain(_this._activeVisits).indexBy('placeDefinition');
+            _this.navigationSessionFactory = new exports.NavigationSession.Factory(interactionContext);
             angularLocation.onUrlChange((/**
              * @param {?} url
              * @return {?}
@@ -3988,8 +4178,11 @@
                 if (event instanceof router.NavigationStart) {
                     _this.onAngularRouterStarted(event);
                 }
-                if (event instanceof router.NavigationEnd || event instanceof router.NavigationError) {
-                    _this.onAngularRouterFinished();
+                if (event instanceof router.NavigationEnd) {
+                    _this.onAngularRouterFinished(false);
+                }
+                if (event instanceof router.NavigationError) {
+                    _this.onAngularRouterFinished(true);
                 }
             }));
             _this.navigationSessionActive = chain(_this.navigationSessionModel).isNotNil();
@@ -4110,7 +4303,7 @@
                              */
                             function (router) {
                                 /** @type {?} */
-                                var commands = _this.createUrlManipulator(_this.router.routerState.snapshot).createRedirectCommandsFor(next);
+                                var 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>]
@@ -4143,7 +4336,7 @@
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            this._navigationSessionModel.value = exports.NavigationSession.createInternal(visit);
+                            this._navigationSessionModel.value = this.navigationSessionFactory.createInternal(visit);
                             _a.label = 1;
                         case 1:
                             _a.trys.push([1, , 3, 4]);
@@ -4152,8 +4345,10 @@
                             _a.sent();
                             return [3 /*break*/, 4];
                         case 3:
+                            // 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);
                             }
                             return [7 /*endfinally*/];
                         case 4: return [2 /*return*/];
@@ -4196,9 +4391,9 @@
             if (!this.navigationSession) { // We been activated by an external route rather than placeRouter.go(visit)
                 console.log('navigation started', { firstTime: this.firstRoute });
                 /** @type {?} */
-                var session = exports.NavigationSession.createExternal(this.firstRoute);
+                var 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;
             }
@@ -4208,30 +4403,40 @@
         // @Trace()
         /**
          * @private
+         * @param {?} cancelled
          * @return {?}
          */
         PlaceRouter.prototype.onAngularRouterFinished = 
         // @Trace()
         /**
          * @private
+         * @param {?} cancelled
          * @return {?}
          */
-        function () {
+        function (cancelled) {
             var _this = this;
             /** @type {?} */
             var 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 {?} */
-            var visits = session.getVisits();
-            visits.forEach((/**
-             * @param {?} v
-             * @return {?}
-             */
-            function (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 {?} */
+                var visits = session.getVisits();
+                visits.forEach((/**
+                 * @param {?} v
+                 * @return {?}
+                 */
+                function (v) { return _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;
         };
         /**
@@ -4253,12 +4458,12 @@
          * @param {?} snapshot
          * @return {?}
          */
-        PlaceRouter.prototype.createUrlManipulator = /**
+        PlaceRouter.prototype.parseUrl = /**
          * @param {?} snapshot
          * @return {?}
          */
         function (snapshot) {
-            return new PlaceRouter.UrlManipulator(this.urlSerializer.parse(snapshot.url));
+            return new PlaceRouter.UrlHelper(this.urlSerializer.parse(snapshot.url));
         };
         PlaceRouter.decorators = [
             { type: core.Injectable, args: [{
@@ -4269,10 +4474,11 @@
         PlaceRouter.ctorParameters = function () { return [
             { type: router.Router },
             { type: router.UrlSerializer },
+            { type: InteractionContext },
             { type: common.Location },
             { type: PlaceHistory }
         ]; };
-        /** @nocollapse */ PlaceRouter.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(core.ɵɵinject(router.Router), core.ɵɵinject(router.UrlSerializer), core.ɵɵinject(common.Location), core.ɵɵinject(PlaceHistory)); }, token: PlaceRouter, providedIn: "root" });
+        /** @nocollapse */ PlaceRouter.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(core.ɵɵinject(router.Router), core.ɵɵinject(router.UrlSerializer), core.ɵɵinject(InteractionContext), core.ɵɵinject(common.Location), core.ɵɵinject(PlaceHistory)); }, token: PlaceRouter, providedIn: "root" });
         __decorate([
             pectin.Trace(),
             __metadata("design:type", Function),
@@ -4301,6 +4507,11 @@
         exports.ɵt.prototype.navigationSessionActive;
         /** @type {?} */
         exports.ɵt.prototype.activeVisitIndex;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.ɵt.prototype.navigationSessionFactory;
         /**
          * @type {?}
          * @private
@@ -4311,21 +4522,26 @@
          * @private
          */
         exports.ɵt.prototype.urlSerializer;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.ɵt.prototype.interactionContext;
         /** @type {?} */
         exports.ɵt.prototype.angularLocation;
         /** @type {?} */
         exports.ɵt.prototype.placeHistory;
     }
     (function (PlaceRouter) {
-        var UrlManipulator = /** @class */ (function () {
-            function UrlManipulator(urlTree) {
+        var UrlHelper = /** @class */ (function () {
+            function UrlHelper(urlTree) {
                 this.urlTree = urlTree;
                 console.log({ segments: this.urlTree.root.children.primary.segments });
             }
             /**
              * @return {?}
              */
-            UrlManipulator.prototype.cloneUrlSegmentList = /**
+            UrlHelper.prototype.cloneUrlSegmentList = /**
              * @return {?}
              */
             function () {
@@ -4335,7 +4551,7 @@
              * @param {?} visit
              * @return {?}
              */
-            UrlManipulator.prototype.updateVisitSegments = /**
+            UrlHelper.prototype.updateVisitSegments = /**
              * @param {?} visit
              * @return {?}
              */
@@ -4364,7 +4580,7 @@
              * @param {?} visit
              * @return {?}
              */
-            UrlManipulator.prototype.convertToUrlSegments = /**
+            UrlHelper.prototype.convertToUrlSegments = /**
              * Converts the visit into segments.  Please not that these segments are not e
              * @param {?} visit
              * @return {?}
@@ -4387,7 +4603,7 @@
              * @param {?} visit
              * @return {?}
              */
-            UrlManipulator.prototype.createRedirectCommandsFor = /**
+            UrlHelper.prototype.createRedirectCommandsFor = /**
              * @param {?} visit
              * @return {?}
              */
@@ -4408,21 +4624,36 @@
                 }));
                 return commands;
             };
+            /**
+             * @param {?} placeDef
+             * @return {?}
+             */
+            UrlHelper.prototype.includesPathOf = /**
+             * @param {?} placeDef
+             * @return {?}
+             */
+            function (placeDef) {
+                return this.cloneUrlSegmentList().find((/**
+                 * @param {?} s
+                 * @return {?}
+                 */
+                function (s) { return s.path === placeDef.path; }));
+            };
             __decorate([
                 pectin.Trace(),
                 __metadata("design:type", Function),
                 __metadata("design:paramtypes", [Visit]),
                 __metadata("design:returntype", Array)
-            ], UrlManipulator.prototype, "createRedirectCommandsFor", null);
-            return UrlManipulator;
+            ], UrlHelper.prototype, "createRedirectCommandsFor", null);
+            return UrlHelper;
         }());
-        PlaceRouter.UrlManipulator = UrlManipulator;
+        PlaceRouter.UrlHelper = UrlHelper;
         if (false) {
             /**
              * @type {?}
              * @private
              */
-            UrlManipulator.prototype.urlTree;
+            UrlHelper.prototype.urlTree;
         }
     })(exports.ɵt || (exports.ɵt = {}));
 
@@ -6193,7 +6424,7 @@
                             this.placeRouter.navigationSession.storeVisit(sanitisedVisit);
                             if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {
                                 // Regenerate the url
-                                commands = this.placeRouter.createUrlManipulator(state).createRedirectCommandsFor(sanitisedVisit);
+                                commands = this.placeRouter.parseUrl(state).createRedirectCommandsFor(sanitisedVisit);
                                 console.log('##### Place Guard Redirect', commands);
                                 return [2 /*return*/, this.router.createUrlTree(commands, {
                                         replaceUrl: true,
@@ -6415,90 +6646,9 @@
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
      */
     var LeavePlaceGuard = /** @class */ (function () {
-        function LeavePlaceGuard(router, injector, placeRouter, dialogInteractionContext, angularLocation) {
-            this.router = router;
-            this.injector = injector;
+        function LeavePlaceGuard(placeRouter) {
             this.placeRouter = placeRouter;
-            this.dialogInteractionContext = dialogInteractionContext;
-            this.angularLocation = angularLocation;
         }
-        // @Trace()
-        // @Trace()
-        /**
-         * @private
-         * @param {?} nextState
-         * @param {?} placeDefinition
-         * @return {?}
-         */
-        LeavePlaceGuard.prototype.isLeavingTheCurrentPlace = 
-        // @Trace()
-        /**
-         * @private
-         * @param {?} nextState
-         * @param {?} placeDefinition
-         * @return {?}
-         */
-        function (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 {?} */
-            var placeDefinitionPath = "/" + placeDefinition.path;
-            return !nextState.url.startsWith(placeDefinitionPath);
-        };
         /**
          * @param {?} component
          * @param {?} currentRoute
@@ -6515,72 +6665,8 @@
          */
         function (component, currentRoute, currentState, nextState) {
             return __awaiter(this, void 0, void 0, function () {
-                var self_1, canLeave;
                 return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!this.placeRouter.navigationSession.alreadyAccepted(component)) return [3 /*break*/, 1];
-                            // 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 [2 /*return*/, true];
-                        case 1:
-                            self_1 = this;
-                            canLeave = true;
-                            if (!this.isLeavingTheCurrentPlace(nextState, component.placeDefinition)) return [3 /*break*/, 4];
-                            // 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);
-                                }
-                            }
-                            if (!canLeave) return [3 /*break*/, 3];
-                            return [4 /*yield*/, component.canDeactivate()];
-                        case 2:
-                            // TODO: Add tests: hit back -> confirm leave dialog -> hit back -> close dialog ->  hit back -> confirm leave dialog.
-                            canLeave = _a.sent();
-                            _a.label = 3;
-                        case 3: return [3 /*break*/, 5];
-                        case 4:
-                            if (this.dialogInteractionContext.isActive()) {
-                                console.log('cancelling', { activity: this.dialogInteractionContext.currentActivity });
-                                this.dialogInteractionContext.currentActivity.cancel(null);
-                                canLeave = false;
-                            }
-                            else {
-                                canLeave = true;
-                            }
-                            _a.label = 5;
-                        case 5:
-                            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_1.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 [2 /*return*/, canLeave];
-                    }
+                    return [2 /*return*/, this.placeRouter.navigationSession.canDeactivate(component, this.placeRouter.parseUrl(nextState))];
                 });
             });
         };
@@ -6591,35 +6677,17 @@
         ];
         /** @nocollapse */
         LeavePlaceGuard.ctorParameters = function () { return [
-            { type: router.Router },
-            { type: core.Injector },
-            { type: exports.ɵt },
-            { type: InteractionContext },
-            { type: common.Location }
+            { type: exports.ɵt }
         ]; };
-        /** @nocollapse */ LeavePlaceGuard.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(core.ɵɵinject(router.Router), core.ɵɵinject(core.INJECTOR), core.ɵɵinject(exports.ɵt), core.ɵɵinject(InteractionContext), core.ɵɵinject(common.Location)); }, token: LeavePlaceGuard, providedIn: "root" });
+        /** @nocollapse */ LeavePlaceGuard.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(core.ɵɵinject(exports.ɵt)); }, token: LeavePlaceGuard, providedIn: "root" });
         return LeavePlaceGuard;
     }());
     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;
     }
 
     exports.ACTIVITY_DATA = ACTIVITY_DATA;
@@ -6676,7 +6744,7 @@
     exports.slideDownAndUpAnimation = slideDownAndUpAnimation;
     exports.ɵa = DirectivesModule;
     exports.ɵb = CommandDirective;
-    exports.ɵba = InteractionContext;
+    exports.ɵba = ActivityContainerComponent;
     exports.ɵbb = ActivityOutletComponent;
     exports.ɵbc = ConfirmationDialogComponent;
     exports.ɵbd = AbstractActivity;
@@ -6702,12 +6770,12 @@
     exports.ɵp = leftRightPlaceAnimation;
     exports.ɵq = LEFT_RIGHT_PLACE_ANIMATION;
     exports.ɵr = AUP_PLACE_CONFIG;
-    exports.ɵu = PlaceHistory;
-    exports.ɵv = TabbedPlaceNavigationComponent;
-    exports.ɵw = AbstractPlaceNavigationComponent;
-    exports.ɵx = ListPlaceNavComponent;
-    exports.ɵy = InteractionModule;
-    exports.ɵz = ActivityContainerComponent;
+    exports.ɵu = InteractionContext;
+    exports.ɵv = PlaceHistory;
+    exports.ɵw = TabbedPlaceNavigationComponent;
+    exports.ɵx = AbstractPlaceNavigationComponent;
+    exports.ɵy = ListPlaceNavComponent;
+    exports.ɵz = InteractionModule;
 
     Object.defineProperty(exports, '__esModule', { value: true });