@coolon/angular-ui-powerups 12.4.9 → 13.0.1

package/esm2020/lib/place/navigation/place-component-deactivation-handler.mjs

@@ -0,0 +1,83 @@
+import { assert } from '@coolon/pectin';
+import { isEqual } from 'lodash';
+/**
+ * This class handles the logic around canDeactivate for a given router state transition.  It's core responsibilities are:
+ * 1. Ensure we only ask the component to deactivate once on a given navigation cycle (since visit sanitisation can result in multiple round trips to through the router.)
+ * 2. Ensure only the primary place component is asked when there are nested places.  The primary component is the one at the top
+ *    of the routing change tree.
+ * 3. Automatically handle standard interaction scenarios on the components behalf.
+ */
+export class PlaceComponentDeactivationHandler {
+    constructor(component, navigationSession, isPrimaryComponent) {
+        this.component = component;
+        this.navigationSession = navigationSession;
+        this.isPrimaryComponent = isPrimaryComponent;
+        assert.notNil(component);
+    }
+    get routerInteractionAdapter() {
+        return this.navigationSession.interactionServiceAdapter;
+    }
+    get urlService() {
+        return this.navigationSession.urlService;
+    }
+    get placeDefinition() {
+        return this.component.placeDefinition;
+    }
+    // @Trace()
+    async canDeactivate(currentUrl, nextState) {
+        // We'll get called multiple times if there's any parameter sanitisation so
+        // we always return true if we accepted promise from a previous cycle of the current
+        // navigation session.
+        if (!this.canDeactivatePromise) {
+            // console.log(`creating deactivate promise for -> ${this.component.constructor.name}`);
+            this.canDeactivatePromise = this.canDeactivateComponent(currentUrl, nextState);
+        }
+        return this.canDeactivatePromise;
+    }
+    // @Trace()
+    async canDeactivateComponent(currentUrl, nextState) {
+        // Automatically cancel any active activities if the navigation session was triggered by the back button.
+        // If we handled more than just the pop state then it leads to the UI ignoring clicks and just cancelling things which is deeply disconcerting.
+        if (this.navigationSession.isPopState) {
+            if (this.isPrimaryComponent && this.routerInteractionAdapter.isModalActive()) {
+                const routeIds = this.urlService.getActiveInteractionIdsFromUrl(nextState.url);
+                const currentIds = this.routerInteractionAdapter.getActiveInteractionContextIds();
+                if (!isEqual(currentIds, routeIds)) { // why am I checking this????
+                    await this.routerInteractionAdapter.cancelCurrentModalInteraction();
+                    return false;
+                }
+            }
+            else {
+                // check if the component has an in place interaction
+                if (this.routerInteractionAdapter.isComponentInteracting(this.component)) {
+                    await this.routerInteractionAdapter.cancelComponentInteraction(this.component);
+                    return false;
+                }
+            }
+        }
+        // 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.
+        if (this.isGoingToADifferentPlace(nextState)) {
+            const canLeave = await this.component._canLeavePlace(this.navigationSession.canDeactivateInteractionContext);
+            // The component has an active interaction but no deactivation hook.  Rather than guessing what to do
+            // we'll just cancel the navigation and print a warning.
+            if (canLeave && this.routerInteractionAdapter.isComponentInteracting(this.component)) {
+                console.warn('Route changed while component has active interaction, cancelling navigation');
+                return false;
+            }
+            return canLeave;
+        }
+        else {
+            // either an interaction or visit parameter change.
+            return await this.component._canChangeRouteParameters(this.navigationSession.canDeactivateInteractionContext, nextState);
+        }
+    }
+    isGoingToADifferentPlace(nextState) {
+        // Because places with a route-id cover two route segments we get asked to deactivate
+        // if the route id is added or removed.  So if our path is still present the url
+        // then we shouldn't deactivate the place.
+        return !nextState.includesPathOf(this.component.placeDefinition);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"place-component-deactivation-handler.js","sourceRoot":"","sources":["../../../../../../../libs/angular-ui-powerups/src/lib/place/navigation/place-component-deactivation-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { Trace, assert } from '@coolon/pectin';\n\nimport { isEqual } from 'lodash';\nimport { PlaceComponent } from '../place-component';\nimport { PlaceDefinition } from '../place-definition';\nimport { UrlSnapshot } from '../url-snapshot';\nimport { NavigationSession } from './session/navigation-session';\n\n/**\n * This class handles the logic around canDeactivate for a given router state transition.  It's core responsibilities are:\n * 1. Ensure we only ask the component to deactivate once on a given navigation cycle (since visit sanitisation can result in multiple round trips to through the router.)\n * 2. Ensure only the primary place component is asked when there are nested places.  The primary component is the one at the top\n *    of the routing change tree.\n * 3. Automatically handle standard interaction scenarios on the components behalf.\n */\nexport class PlaceComponentDeactivationHandler {\n\n  private canDeactivatePromise: Promise<boolean | UrlSnapshot>;\n\n  constructor(readonly component: PlaceComponent, readonly navigationSession: NavigationSession, readonly isPrimaryComponent: boolean) {\n    assert.notNil(component);\n  }\n\n  get routerInteractionAdapter() {\n    return this.navigationSession.interactionServiceAdapter;\n  }\n\n  get urlService() {\n    return this.navigationSession.urlService;\n  }\n\n  get placeDefinition():PlaceDefinition {\n    return this.component.placeDefinition;\n  }\n\n  // @Trace()\n  async canDeactivate(currentUrl: UrlSnapshot, nextState: UrlSnapshot): Promise<boolean | UrlSnapshot> {\n    // We'll get called multiple times if there's any parameter sanitisation so\n    // we always return true if we accepted promise from a previous cycle of the current\n    // navigation session.\n    if (!this.canDeactivatePromise) {\n      // console.log(`creating deactivate promise for -> ${this.component.constructor.name}`);\n      this.canDeactivatePromise = this.canDeactivateComponent(currentUrl, nextState);\n    }\n    return this.canDeactivatePromise;\n  }\n\n\n  // @Trace()\n  protected async canDeactivateComponent(currentUrl: UrlSnapshot, nextState: UrlSnapshot): Promise<UrlSnapshot | boolean> {\n    // Automatically cancel any active activities if the navigation session was triggered by the back button.\n    // If we handled more than just the pop state then it leads to the UI ignoring clicks and just cancelling things which is deeply disconcerting.\n    if (this.navigationSession.isPopState) {\n\n      if (this.isPrimaryComponent && this.routerInteractionAdapter.isModalActive()) {\n        const routeIds = this.urlService.getActiveInteractionIdsFromUrl(nextState.url);\n        const currentIds = this.routerInteractionAdapter.getActiveInteractionContextIds();\n        if (!isEqual(currentIds, routeIds)) { // why am I checking this????\n          await this.routerInteractionAdapter.cancelCurrentModalInteraction();\n          return false;\n        }\n      } else {\n        // check if the component has an in place interaction\n        if (this.routerInteractionAdapter.isComponentInteracting(this.component)) {\n          await this.routerInteractionAdapter.cancelComponentInteraction(this.component);\n          return false;\n        }\n      }\n    }\n\n    // No interaction in progress, so ask the component .\n    // This may start an interaction, hence checking the interaction context before now. I.e. if the place pops up the dialog, and\n    // the user clicks back again, we'll re-enter here and go bang when the component tries to open another dialog.\n    if (this.isGoingToADifferentPlace(nextState)) {\n      const canLeave = await this.component._canLeavePlace(this.navigationSession.canDeactivateInteractionContext);\n      // The component has an active interaction but no deactivation hook.  Rather than guessing what to do\n      // we'll just cancel the navigation and print a warning.\n      if (canLeave && this.routerInteractionAdapter.isComponentInteracting(this.component)) {\n        console.warn('Route changed while component has active interaction, cancelling navigation');\n        return false;\n      }\n\n      return canLeave;\n    } else {\n      // either an interaction or visit parameter change.\n      return await this.component._canChangeRouteParameters(this.navigationSession.canDeactivateInteractionContext, nextState);\n    }\n  }\n\n  protected isGoingToADifferentPlace(nextState: UrlSnapshot) {\n    // Because places with a route-id cover two route segments we get asked to deactivate\n    // if the route id is added or removed.  So if our path is still present the url\n    // then we shouldn't deactivate the place.\n    return !nextState.includesPathOf(this.component.placeDefinition);\n  }\n}\n"]}

package/esm2020/lib/place/navigation/session/event-cleanup/wait-until-leaving-interaction-transition-cancelled.mjs

@@ -0,0 +1,43 @@
+import { EventCleanUpSession } from './event-clean-up-session';
+/**
+ * The sequence of router events are:
+ * NavigationError -> url = url of navigation link
+ * NavigationEnd
+ * onPopState url = Our currentUrl sans and interaction query params
+ * NavigationCancel url == same as above.
+ */
+export class WaitUntilLeavingInteractionTransitionCancelled extends EventCleanUpSession {
+    constructor(context, startingUrl, locationChangeTriggerUrl) {
+        super(context, startingUrl);
+        this.locationChangeTriggerUrl = locationChangeTriggerUrl;
+        this.isPopState = false;
+        this.firstCancelHandled = false;
+        this.popStateHandled = false;
+        this.debugPropertyKeys = ['idle', 'startingUrl', 'poppedHistoryUrl', 'locationChangeTriggerUrl', 'popStateEventUrl', 'firstCancelHandled', 'popStateHandled'];
+    }
+    // @Trace()
+    onRouterStarted(event) {
+        this.ignore(event);
+    }
+    // @Trace()
+    onRouterCancelled(event) {
+        this.repairBrowserHistoryAndUrlAfterGuardCancellation(this.locationChangeTriggerUrl, this.startingUrl);
+        this.context.finishRoutingSession();
+    }
+    // @Trace()
+    onRouterEnd(event) {
+        this.ignore(event);
+    }
+    // @Trace()
+    onRouterError(event) {
+        this.ignore(event);
+    }
+    // @Trace()
+    onPopState(event) {
+        this.ignore(event);
+    }
+    async canDeactivatePlace(component, currentUrl, nextUrl) {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2FpdC11bnRpbC1sZWF2aW5nLWludGVyYWN0aW9uLXRyYW5zaXRpb24tY2FuY2VsbGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLXVpLXBvd2VydXBzL3NyYy9saWIvcGxhY2UvbmF2aWdhdGlvbi9zZXNzaW9uL2V2ZW50LWNsZWFudXAvd2FpdC11bnRpbC1sZWF2aW5nLWludGVyYWN0aW9uLXRyYW5zaXRpb24tY2FuY2VsbGVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVFBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRS9EOzs7Ozs7R0FNRztBQUNILE1BQU0sT0FBTyw4Q0FBK0MsU0FBUSxtQkFBbUI7SUFRckYsWUFBWSxPQUEwQixFQUMxQixXQUFtQixFQUNWLHdCQUFnQztRQUNuRCxLQUFLLENBQUMsT0FBTyxFQUFFLFdBQVcsQ0FBQyxDQUFDO1FBRFQsNkJBQXdCLEdBQXhCLHdCQUF3QixDQUFRO1FBUjVDLGVBQVUsR0FBRyxLQUFLLENBQUM7UUFDNUIsdUJBQWtCLEdBQUcsS0FBSyxDQUFDO1FBQzNCLG9CQUFlLEdBQUcsS0FBSyxDQUFDO1FBRXhCLHNCQUFpQixHQUFHLENBQUMsTUFBTSxFQUFFLGFBQWEsRUFBRSxrQkFBa0IsRUFBRSwwQkFBMEIsRUFBRSxrQkFBa0IsRUFBRSxvQkFBb0IsRUFBRSxpQkFBaUIsQ0FBQyxDQUFDO0lBTXpKLENBQUM7SUFFRCxXQUFXO0lBQ1gsZUFBZSxDQUFDLEtBQXNCO1FBQ3BDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDckIsQ0FBQztJQUVELFdBQVc7SUFDWCxpQkFBaUIsQ0FBQyxLQUF1QjtRQUN2QyxJQUFJLENBQUMsZ0RBQWdELENBQUMsSUFBSSxDQUFDLHdCQUF3QixFQUFFLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUN2RyxJQUFJLENBQUMsT0FBTyxDQUFDLG9CQUFvQixFQUFFLENBQUM7SUFDdEMsQ0FBQztJQUVELFdBQVc7SUFDWCxXQUFXLENBQUMsS0FBb0I7UUFDOUIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNyQixDQUFDO0lBRUQsV0FBVztJQUNYLGFBQWEsQ0FBQyxLQUFzQjtRQUNsQyxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3JCLENBQUM7SUFFRCxXQUFXO0lBQ1gsVUFBVSxDQUFDLEtBQXNCO1FBQy9CLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDckIsQ0FBQztJQUVELEtBQUssQ0FBQyxrQkFBa0IsQ0FBQyxTQUF5QixFQUFFLFVBQXVCLEVBQUUsT0FBb0I7UUFDL0YsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOYXZpZ2F0aW9uQ2FuY2VsLCBOYXZpZ2F0aW9uRW5kLCBOYXZpZ2F0aW9uRXJyb3IsIE5hdmlnYXRpb25TdGFydCB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5pbXBvcnQgeyBMb2dnZXIsIFRyYWNlIH0gZnJvbSAnQGNvb2xvbi9wZWN0aW4nO1xuaW1wb3J0IHsgUGxhY2VDb21wb25lbnQgfSBmcm9tICcuLi8uLi8uLi9wbGFjZS1jb21wb25lbnQnO1xuaW1wb3J0IHsgVXJsU25hcHNob3QgfSBmcm9tICcuLi8uLi8uLi91cmwtc25hcHNob3QnO1xuaW1wb3J0IHsgU3luY2hyb25pc2VJbnRlcmFjdGlvbkNvbnRleHRJZHNXaXRoUm91dGUgfSBmcm9tICcuLi9pbnRlcmFjdGlvbnMvc3luY2hyb25pc2UtaW50ZXJhY3Rpb24tY29udGV4dC1pZHMtd2l0aC1yb3V0ZSc7XG5pbXBvcnQgeyBOYXZpZ2F0aW9uQ29udGV4dCB9IGZyb20gJy4uL25hdmlnYXRpb24tY29udGV4dCc7XG5pbXBvcnQgeyBOYXZpZ2F0aW9uU2Vzc2lvbiB9IGZyb20gJy4uL25hdmlnYXRpb24tc2Vzc2lvbic7XG5pbXBvcnQgeyBsYW5nIH0gZnJvbSAnQGNvb2xvbi90eXBlc2NyaXB0LXV0aWxpdGllcyc7XG5pbXBvcnQgeyBFdmVudENsZWFuVXBTZXNzaW9uIH0gZnJvbSAnLi9ldmVudC1jbGVhbi11cC1zZXNzaW9uJztcblxuLyoqXG4gKiBUaGUgc2VxdWVuY2Ugb2Ygcm91dGVyIGV2ZW50cyBhcmU6XG4gKiBOYXZpZ2F0aW9uRXJyb3IgLT4gdXJsID0gdXJsIG9mIG5hdmlnYXRpb24gbGlua1xuICogTmF2aWdhdGlvbkVuZFxuICogb25Qb3BTdGF0ZSB1cmwgPSBPdXIgY3VycmVudFVybCBzYW5zIGFuZCBpbnRlcmFjdGlvbiBxdWVyeSBwYXJhbXNcbiAqIE5hdmlnYXRpb25DYW5jZWwgdXJsID09IHNhbWUgYXMgYWJvdmUuXG4gKi9cbmV4cG9ydCBjbGFzcyBXYWl0VW50aWxMZWF2aW5nSW50ZXJhY3Rpb25UcmFuc2l0aW9uQ2FuY2VsbGVkIGV4dGVuZHMgRXZlbnRDbGVhblVwU2Vzc2lvbiB7XG5cbiAgcmVhZG9ubHkgaXNQb3BTdGF0ZSA9IGZhbHNlO1xuICBmaXJzdENhbmNlbEhhbmRsZWQgPSBmYWxzZTtcbiAgcG9wU3RhdGVIYW5kbGVkID0gZmFsc2U7XG4gIHBvcFN0YXRlRXZlbnRVcmw6IHN0cmluZztcbiAgZGVidWdQcm9wZXJ0eUtleXMgPSBbJ2lkbGUnLCAnc3RhcnRpbmdVcmwnLCAncG9wcGVkSGlzdG9yeVVybCcsICdsb2NhdGlvbkNoYW5nZVRyaWdnZXJVcmwnLCAncG9wU3RhdGVFdmVudFVybCcsICdmaXJzdENhbmNlbEhhbmRsZWQnLCAncG9wU3RhdGVIYW5kbGVkJ107XG5cbiAgY29uc3RydWN0b3IoY29udGV4dDogTmF2aWdhdGlvbkNvbnRleHQsXG4gICAgICAgICAgICAgIHN0YXJ0aW5nVXJsOiBzdHJpbmcsXG4gICAgICAgICAgICAgIHJlYWRvbmx5IGxvY2F0aW9uQ2hhbmdlVHJpZ2dlclVybDogc3RyaW5nKSB7XG4gICAgc3VwZXIoY29udGV4dCwgc3RhcnRpbmdVcmwpO1xuICB9XG5cbiAgLy8gQFRyYWNlKClcbiAgb25Sb3V0ZXJTdGFydGVkKGV2ZW50OiBOYXZpZ2F0aW9uU3RhcnQpOiB2b2lkIHtcbiAgICB0aGlzLmlnbm9yZShldmVudCk7XG4gIH1cblxuICAvLyBAVHJhY2UoKVxuICBvblJvdXRlckNhbmNlbGxlZChldmVudDogTmF2aWdhdGlvbkNhbmNlbCk6IHZvaWQge1xuICAgIHRoaXMucmVwYWlyQnJvd3Nlckhpc3RvcnlBbmRVcmxBZnRlckd1YXJkQ2FuY2VsbGF0aW9uKHRoaXMubG9jYXRpb25DaGFuZ2VUcmlnZ2VyVXJsLCB0aGlzLnN0YXJ0aW5nVXJsKTtcbiAgICB0aGlzLmNvbnRleHQuZmluaXNoUm91dGluZ1Nlc3Npb24oKTtcbiAgfVxuXG4gIC8vIEBUcmFjZSgpXG4gIG9uUm91dGVyRW5kKGV2ZW50OiBOYXZpZ2F0aW9uRW5kKTogdm9pZCB7XG4gICAgdGhpcy5pZ25vcmUoZXZlbnQpO1xuICB9XG5cbiAgLy8gQFRyYWNlKClcbiAgb25Sb3V0ZXJFcnJvcihldmVudDogTmF2aWdhdGlvbkVycm9yKTogdm9pZCB7XG4gICAgdGhpcy5pZ25vcmUoZXZlbnQpO1xuICB9XG5cbiAgLy8gQFRyYWNlKClcbiAgb25Qb3BTdGF0ZShldmVudDogTmF2aWdhdGlvblN0YXJ0KTogdm9pZCB7XG4gICAgdGhpcy5pZ25vcmUoZXZlbnQpO1xuICB9XG5cbiAgYXN5bmMgY2FuRGVhY3RpdmF0ZVBsYWNlKGNvbXBvbmVudDogUGxhY2VDb21wb25lbnQsIGN1cnJlbnRVcmw6IFVybFNuYXBzaG90LCBuZXh0VXJsOiBVcmxTbmFwc2hvdCk6IFByb21pc2U8Ym9vbGVhbiB8IFVybFNuYXBzaG90PiB7XG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG59XG4iXX0=

package/esm2020/lib/place/navigation/session/event-cleanup/wait-until-link-triggered-navigation-interaction-cancelation-type-determined.mjs

@@ -0,0 +1,152 @@
+import { EventCleanUpSession } from './event-clean-up-session';
+/**
+ * This state handles the scenario where a link navigation triggered an interaction and the user clicked back a to cancel it.
+ * The routing event sequence is different depending on the link that was clicked.
+ *
+ * NOTE: In angular prior to 10 the sequence of routing events was different depending on the initial link that was clicked.
+ *       This class used have ugle if/else code to handle it and a not that it should be split into sub states.
+ *       During the update to angular 10 I did this (as the tests for this scenario were failings). After doing so
+ *       it appears that angular now behaves the same in both cases. But rather that revert the changes I've left the
+ *       sub-state handling in in case it ever comes back.
+ */
+export class WaitUntilLinkTriggeredNavigationInteractionCancellationTypeDetermined extends EventCleanUpSession {
+    constructor(context, startingUrl, clickedLinkUrl) {
+        super(context, startingUrl);
+        this.clickedLinkUrl = clickedLinkUrl;
+        this.isPopState = false;
+        this.clickedLinkMatchedBackButtonUrl = false;
+        this.debugPropertyKeys = ['idle', 'startingUrl', 'clickedLinkUrl', 'firstCancelEventUrl', 'clickedLinkMatchedBackButtonUrl', 'popStateEventUrl'];
+    }
+    // @Trace()
+    onRouterStarted(event) {
+        this.ignore(event);
+    }
+    // @Trace()
+    onRouterCancelled(event) {
+        if (event.url === this.clickedLinkUrl) {
+            this.context.transitionTo(new WaitForLinkSameAsBackToPlayOut(this.context, this.startingUrl, this.clickedLinkUrl));
+        }
+        else {
+            this.context.transitionTo(new WaitForLinkDifferentFromBackToPlayOut(this.context, this.startingUrl, this.clickedLinkUrl));
+        }
+    }
+    async canDeactivatePlace(component, currentUrl, nextUrl) {
+        return false;
+    }
+}
+class WaitForLinkSameAsBackToPlayOut extends EventCleanUpSession {
+    constructor(context, startingUrl, clickedLinkUrl) {
+        super(context, startingUrl);
+        this.clickedLinkUrl = clickedLinkUrl;
+        this.isPopState = false;
+        this.debugPropertyKeys = ['idle', 'startingUrl', 'clickedLinkUrl', 'popStateEventUrl'];
+    }
+    // @Trace()
+    onRouterEnd(event) {
+        this.ignore(event);
+    }
+    // @Trace()
+    onRouterError(event) {
+        this.ignore(event);
+    }
+    // @Trace()
+    onPopState(event) {
+        this.popStateEventUrl = event.url;
+        this.ignore(event);
+    }
+    // @Trace()
+    onRouterCancelled(event) {
+        if (this.popStateEventUrl) {
+            this.finaliseRouting();
+        }
+    }
+    // @Trace()
+    finaliseRouting() {
+        this.repairBrowserHistoryAndUrlAfterGuardCancellation(this.clickedLinkUrl, this.startingUrl);
+        return this.context.finishRoutingSession();
+    }
+    async canDeactivatePlace(component, currentUrl, nextUrl) {
+        return false;
+    }
+}
+// See the note above.  This class is identical to the previous but I've left it here in case angular decides to
+// route differently in this scenario going forward.
+class WaitForLinkDifferentFromBackToPlayOut extends EventCleanUpSession {
+    constructor(context, startingUrl, clickedLinkUrl) {
+        super(context, startingUrl);
+        this.clickedLinkUrl = clickedLinkUrl;
+        this.isPopState = false;
+        this.debugPropertyKeys = ['idle', 'startingUrl', 'clickedLinkUrl', 'popStateEventUrl'];
+    }
+    // @Trace()
+    onRouterEnd(event) {
+        this.ignore(event);
+    }
+    // @Trace()
+    onRouterError(event) {
+        this.ignore(event);
+    }
+    // @Trace()
+    onPopState(event) {
+        this.popStateEventUrl = event.url;
+        this.ignore(event);
+    }
+    // @Trace()
+    onRouterCancelled(event) {
+        if (this.popStateEventUrl) {
+            this.finaliseRouting();
+        }
+    }
+    // @Trace()
+    finaliseRouting() {
+        this.repairBrowserHistoryAndUrlAfterGuardCancellation(this.clickedLinkUrl, this.startingUrl);
+        return this.context.finishRoutingSession();
+    }
+    async canDeactivatePlace(component, currentUrl, nextUrl) {
+        return false;
+    }
+}
+//
+// ### Router State Transition: null -> Navigating(startingUrl: /activities/dialogs;l=en, urlAfterRedirects: undefined)
+//  ### ###### Router Event: NavigationStart
+//  NavigationStart(id: 6, url: '/home')
+//  NavigationStart {id: 6, url: "/home", navigationTrigger: "imperative", restoredState: null}
+// logger.js:39 Ignoring router event: NavigationStart -> /home :: Navigating(startingUrl: /activities/dialogs;l=en, urlAfterRedirects: undefined)
+//  ### ###### Router Event: RoutesRecognized
+//  RoutesRecognized(id: 6, url: '/home', urlAfterRedirects: '/home', state: Route(url:'', path:'') { Route(url:'home', path:'home') } )
+//  RoutesRecognized {id: 6, url: "/home", urlAfterRedirects: "/home", state: RouterStateSnapshot}
+//  ###### Router Event: GuardsCheckStart
+//  GuardsCheckStart(id: 6, url: '/home', urlAfterRedirects: '/home', state: Route(url:'', path:'') { Route(url:'home', path:'home') } )
+//  GuardsCheckStart {id: 6, url: "/home", urlAfterRedirects: "/home", state: RouterStateSnapshot}
+// logger.js:39 back button pressed during navigation session interaction promise
+// logger.js:39 cancelling current navigation activity..
+//   logger.js:39 ### Router State Transition: Navigating(startingUrl: /activities/dialogs;l=en, urlAfterRedirects: undefined) -> WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish(idle: undefined, startingUrl: /activities/dialogs;l=en, clickedLinkUrl: /home, firstCancelEventUrl: undefined, clickedLinkMatchedBackButtonUrl: false, popStateEventUrl: undefined)
+//  ###### Router Event: GuardsCheckEnd
+//  GuardsCheckEnd(id: 6, url: '/home', urlAfterRedirects: '/home', state: Route(url:'', path:'') { Route(url:'home', path:'home') } , shouldActivate: false)
+//  GuardsCheckEnd {id: 6, url: "/home", urlAfterRedirects: "/home", state: RouterStateSnapshot, shouldActivate: false}
+//  ###### Router Event: NavigationCancel
+//  NavigationCancel(id: 6, url: '/home')
+//  NavigationCancel {id: 6, url: "/home", reason: ""}
+// logger.js:54 WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.onRouterCancelled
+// logger.js:19 args NavigationCancel {id: 6, url: "/home", reason: ""}
+// logger.js:39 Ignoring router event: NavigationCancel -> /home :: WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish(idle: undefined, startingUrl: /activities/dialogs;l=en, clickedLinkUrl: /home, firstCancelEventUrl: /home, clickedLinkMatchedBackButtonUrl: true, popStateEventUrl: undefined)
+// logger.js:28 <-- WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.onRouterCancelled undefined
+// logger.js:54 WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.onRouterEnd
+// logger.js:19 args NavigationEnd {id: -1, url: "", urlAfterRedirects: ""}
+// logger.js:54 WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.finaliseRouting
+// logger.js:39 WORK-AROUND: Updating browser location after pop state - see angular issue #13586
+// navigation-session.ts:129 replacing /activities/dialogs;l=en with /home
+//   navigation-session.ts:131 pushing /activities/dialogs;l=en back onto the history.
+//  ????? place-router.ts:281 ### Router Session Finished (was WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish(idle: undefined, startingUrl: /activities/dialogs;l=en, clickedLinkUrl: /home, firstCancelEventUrl: /home, clickedLinkMatchedBackButtonUrl: true, popStateEventUrl: undefined))
+// logger.js:28 <-- WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.finaliseRouting undefined
+// logger.js:28 <-- WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.onRouterEnd undefined
+//  ###### Router Event: NavigationStart
+//  NavigationStart(id: 7, url: '/home')
+//  NavigationStart {id: 7, url: "/home", navigationTrigger: "popstate", restoredState: {…}}
+// logger.js:39 ### Router State Transition: null -> PopStateNavigation(startingUrl: /activities/dialogs;l=en, poppedHistoryUrl: /home)
+//  ###### Router Event: RoutesRecognized
+//  RoutesRecognized(id: 7, url: '/home', urlAfterRedirects: '/home', state: Route(url:'', path:'') { Route(url:'home', path:'home') } )
+//  RoutesRecognized {id: 7, url: "/home", urlAfterRedirects: "/home", state: RouterStateSnapshot}
+//  ###### Router Event: GuardsCheckStart
+//  GuardsCheckStart(id: 7, url: '/home', urlAfterRedirects: '/home', state: Route(url:'', path:'') { Route(url:'home', path:'home') } )
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wait-until-link-triggered-navigation-interaction-cancelation-type-determined.js","sourceRoot":"","sources":["../../../../../../../../../libs/angular-ui-powerups/src/lib/place/navigation/session/event-cleanup/wait-until-link-triggered-navigation-interaction-cancelation-type-determined.ts"],"names":[],"mappings":"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","sourcesContent":["import { NavigationCancel, NavigationEnd, NavigationError, NavigationStart } from '@angular/router';\nimport { Trace } from '@coolon/pectin';\nimport { PlaceComponent } from '../../../place-component';\nimport { UrlSnapshot } from '../../../url-snapshot';\nimport { NavigationContext } from '../navigation-context';\nimport { EventCleanUpSession } from './event-clean-up-session';\n\n/**\n * This state handles the scenario where a link navigation triggered an interaction and the user clicked back a to cancel it.\n * The routing event sequence is different depending on the link that was clicked.\n *\n * NOTE: In angular prior to 10 the sequence of routing events was different depending on the initial link that was clicked.\n *       This class used have ugle if/else code to handle it and a not that it should be split into sub states.\n *       During the update to angular 10 I did this (as the tests for this scenario were failings). After doing so\n *       it appears that angular now behaves the same in both cases. But rather that revert the changes I've left the\n *       sub-state handling in in case it ever comes back.\n */\nexport class WaitUntilLinkTriggeredNavigationInteractionCancellationTypeDetermined extends EventCleanUpSession {\n\n  readonly isPopState = false;\n  firstCancelEventUrl: string;\n  popStateEventUrl: string;\n  clickedLinkMatchedBackButtonUrl = false;\n  debugPropertyKeys = ['idle', 'startingUrl', 'clickedLinkUrl', 'firstCancelEventUrl', 'clickedLinkMatchedBackButtonUrl', 'popStateEventUrl'];\n\n  constructor(context: NavigationContext,\n              startingUrl: string,\n              readonly clickedLinkUrl: string) {\n    super(context, startingUrl);\n  }\n\n  // @Trace()\n  onRouterStarted(event: NavigationStart): void {\n    this.ignore(event);\n  }\n\n  // @Trace()\n  onRouterCancelled(event: NavigationCancel): void {\n    if (event.url === this.clickedLinkUrl) {\n      this.context.transitionTo(new WaitForLinkSameAsBackToPlayOut(this.context, this.startingUrl, this.clickedLinkUrl));\n    } else {\n      this.context.transitionTo(new WaitForLinkDifferentFromBackToPlayOut(this.context, this.startingUrl, this.clickedLinkUrl));\n    }\n  }\n\n  async canDeactivatePlace(component: PlaceComponent, currentUrl: UrlSnapshot, nextUrl: UrlSnapshot): Promise<boolean | UrlSnapshot> {\n    return false;\n  }\n}\n\nclass WaitForLinkSameAsBackToPlayOut extends EventCleanUpSession {\n  readonly isPopState = false;\n  popStateEventUrl: string;\n  debugPropertyKeys = ['idle', 'startingUrl', 'clickedLinkUrl', 'popStateEventUrl'];\n\n  constructor(context: NavigationContext,\n              startingUrl: string,\n              readonly clickedLinkUrl: string) {\n    super(context, startingUrl);\n  }\n\n  // @Trace()\n  onRouterEnd(event: NavigationEnd): void {\n    this.ignore(event);\n  }\n\n  // @Trace()\n  onRouterError(event: NavigationError): void {\n    this.ignore(event);\n  }\n\n  // @Trace()\n  onPopState(event: NavigationStart): void {\n    this.popStateEventUrl = event.url;\n    this.ignore(event);\n  }\n\n  // @Trace()\n  onRouterCancelled(event: NavigationCancel) {\n    if (this.popStateEventUrl) {\n      this.finaliseRouting();\n    }\n  }\n\n  // @Trace()\n  finaliseRouting() {\n    this.repairBrowserHistoryAndUrlAfterGuardCancellation(this.clickedLinkUrl, this.startingUrl);\n    return this.context.finishRoutingSession();\n  }\n\n\n  async canDeactivatePlace(component: PlaceComponent, currentUrl: UrlSnapshot, nextUrl: UrlSnapshot): Promise<boolean | UrlSnapshot> {\n    return false;\n  }\n\n}\n\n// See the note above.  This class is identical to the previous but I've left it here in case angular decides to\n// route differently in this scenario going forward.\nclass WaitForLinkDifferentFromBackToPlayOut extends EventCleanUpSession {\n  readonly isPopState = false;\n  popStateEventUrl: string;\n  debugPropertyKeys = ['idle', 'startingUrl', 'clickedLinkUrl', 'popStateEventUrl'];\n\n  constructor(context: NavigationContext,\n              startingUrl: string,\n              readonly clickedLinkUrl: string) {\n    super(context, startingUrl);\n  }\n\n  // @Trace()\n  onRouterEnd(event: NavigationEnd): void {\n    this.ignore(event);\n  }\n\n  // @Trace()\n  onRouterError(event: NavigationError): void {\n    this.ignore(event);\n  }\n\n  // @Trace()\n  onPopState(event: NavigationStart): void {\n    this.popStateEventUrl = event.url;\n    this.ignore(event);\n  }\n\n  // @Trace()\n  onRouterCancelled(event: NavigationCancel) {\n    if (this.popStateEventUrl) {\n      this.finaliseRouting();\n    }\n  }\n\n  // @Trace()\n  finaliseRouting() {\n    this.repairBrowserHistoryAndUrlAfterGuardCancellation(this.clickedLinkUrl, this.startingUrl);\n    return this.context.finishRoutingSession();\n  }\n\n  async canDeactivatePlace(component: PlaceComponent, currentUrl: UrlSnapshot, nextUrl: UrlSnapshot): Promise<boolean | UrlSnapshot> {\n    return false;\n  }\n}\n\n\n//\n// ### Router State Transition: null -> Navigating(startingUrl: /activities/dialogs;l=en, urlAfterRedirects: undefined)\n//  ### ###### Router Event: NavigationStart\n//  NavigationStart(id: 6, url: '/home')\n//  NavigationStart {id: 6, url: \"/home\", navigationTrigger: \"imperative\", restoredState: null}\n// logger.js:39 Ignoring router event: NavigationStart -> /home :: Navigating(startingUrl: /activities/dialogs;l=en, urlAfterRedirects: undefined)\n//  ### ###### Router Event: RoutesRecognized\n//  RoutesRecognized(id: 6, url: '/home', urlAfterRedirects: '/home', state: Route(url:'', path:'') { Route(url:'home', path:'home') } )\n//  RoutesRecognized {id: 6, url: \"/home\", urlAfterRedirects: \"/home\", state: RouterStateSnapshot}\n//  ###### Router Event: GuardsCheckStart\n//  GuardsCheckStart(id: 6, url: '/home', urlAfterRedirects: '/home', state: Route(url:'', path:'') { Route(url:'home', path:'home') } )\n//  GuardsCheckStart {id: 6, url: \"/home\", urlAfterRedirects: \"/home\", state: RouterStateSnapshot}\n// logger.js:39 back button pressed during navigation session interaction promise\n// logger.js:39 cancelling current navigation activity..\n//   logger.js:39 ### Router State Transition: Navigating(startingUrl: /activities/dialogs;l=en, urlAfterRedirects: undefined) -> WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish(idle: undefined, startingUrl: /activities/dialogs;l=en, clickedLinkUrl: /home, firstCancelEventUrl: undefined, clickedLinkMatchedBackButtonUrl: false, popStateEventUrl: undefined)\n//  ###### Router Event: GuardsCheckEnd\n//  GuardsCheckEnd(id: 6, url: '/home', urlAfterRedirects: '/home', state: Route(url:'', path:'') { Route(url:'home', path:'home') } , shouldActivate: false)\n//  GuardsCheckEnd {id: 6, url: \"/home\", urlAfterRedirects: \"/home\", state: RouterStateSnapshot, shouldActivate: false}\n//  ###### Router Event: NavigationCancel\n//  NavigationCancel(id: 6, url: '/home')\n//  NavigationCancel {id: 6, url: \"/home\", reason: \"\"}\n// logger.js:54 WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.onRouterCancelled\n// logger.js:19 args NavigationCancel {id: 6, url: \"/home\", reason: \"\"}\n// logger.js:39 Ignoring router event: NavigationCancel -> /home :: WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish(idle: undefined, startingUrl: /activities/dialogs;l=en, clickedLinkUrl: /home, firstCancelEventUrl: /home, clickedLinkMatchedBackButtonUrl: true, popStateEventUrl: undefined)\n// logger.js:28 <-- WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.onRouterCancelled undefined\n// logger.js:54 WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.onRouterEnd\n// logger.js:19 args NavigationEnd {id: -1, url: \"\", urlAfterRedirects: \"\"}\n// logger.js:54 WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.finaliseRouting\n// logger.js:39 WORK-AROUND: Updating browser location after pop state - see angular issue #13586\n// navigation-session.ts:129 replacing /activities/dialogs;l=en with /home\n//   navigation-session.ts:131 pushing /activities/dialogs;l=en back onto the history.\n//  ????? place-router.ts:281 ### Router Session Finished (was WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish(idle: undefined, startingUrl: /activities/dialogs;l=en, clickedLinkUrl: /home, firstCancelEventUrl: /home, clickedLinkMatchedBackButtonUrl: true, popStateEventUrl: undefined))\n// logger.js:28 <-- WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.finaliseRouting undefined\n// logger.js:28 <-- WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.onRouterEnd undefined\n//  ###### Router Event: NavigationStart\n//  NavigationStart(id: 7, url: '/home')\n//  NavigationStart {id: 7, url: \"/home\", navigationTrigger: \"popstate\", restoredState: {…}}\n// logger.js:39 ### Router State Transition: null -> PopStateNavigation(startingUrl: /activities/dialogs;l=en, poppedHistoryUrl: /home)\n//  ###### Router Event: RoutesRecognized\n//  RoutesRecognized(id: 7, url: '/home', urlAfterRedirects: '/home', state: Route(url:'', path:'') { Route(url:'home', path:'home') } )\n//  RoutesRecognized {id: 7, url: \"/home\", urlAfterRedirects: \"/home\", state: RouterStateSnapshot}\n//  ###### Router Event: GuardsCheckStart\n//  GuardsCheckStart(id: 7, url: '/home', urlAfterRedirects: '/home', state: Route(url:'', path:'') { Route(url:'home', path:'home') } )\n"]}

package/esm2020/lib/place/navigation/session/event-cleanup/wait-until-popstate-during-can-deactivate-transition-finishes.mjs

@@ -0,0 +1,62 @@
+import { EventCleanUpSession } from './event-clean-up-session';
+/**
+ * This state handles the scenario where a pop state triggered and interaction and the user clickeb back a second time to cancel it.
+ * The sequence of routing events/state transitions is as follows.
+ * -> Idle -> PopStateTransition (poppedHistoryUrl == page to go to, startingUrl = page to stay on )
+ * -> confirm dialog shown.
+ * -> click back
+ * -> PopStateTransition -> CancelledDuringBackButtonNavigationInteraction(trigger url is the page before the popped history url)
+ * -> NavigationCancel (for the previous back)
+ * -> PopState
+ * -> NavigationCancel
+ */
+export class WaitUntilPopStateDuringCanDeactivateInteractionFinishes extends EventCleanUpSession {
+    constructor(context, startingUrl, locationChangeTriggerUrl, poppedHistoryUrl) {
+        super(context, startingUrl);
+        this.locationChangeTriggerUrl = locationChangeTriggerUrl;
+        this.poppedHistoryUrl = poppedHistoryUrl;
+        this.isPopState = false;
+        this.firstCancelHandled = false;
+        this.popStateHandled = false;
+        this.debugPropertyKeys = ['idle', 'startingUrl', 'poppedHistoryUrl', 'locationChangeTriggerUrl', 'popStateEventUrl', 'firstCancelHandled', 'popStateHandled'];
+    }
+    // @Trace()
+    onRouterStarted(event) {
+        this.ignore(event);
+    }
+    // @Trace()
+    onRouterCancelled(event) {
+        if (!this.firstCancelHandled) {
+            this.firstCancelHandled = true;
+            this.parentPageUrl = event.url;
+            this.ignore(event);
+        }
+        else {
+            if (this.popStateHandled) {
+                const grandParentPageUrl = event.url;
+                this.repairBrowserHistoryAndUrlAfterGuardCancellation(grandParentPageUrl, this.parentPageUrl);
+                // we've had one more back click than normal so we need to add our initial url back in as well.
+                this.resetBrowserLocation(this.startingUrl, { replaceCurrent: false });
+                return this.context.finishRoutingSession();
+            }
+        }
+    }
+    // @Trace()
+    onRouterEnd(event) {
+        this.ignore(event);
+    }
+    // @Trace()
+    onRouterError(event) {
+        void this.ignore(event);
+    }
+    // @Trace()
+    onPopState(event) {
+        this.popStateHandled = true;
+        this.popStateEventUrl = event.url;
+        this.ignore(event);
+    }
+    async canDeactivatePlace(component, currentUrl, nextUrl) {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/place/navigation/session/navigation-session.mjs

@@ -0,0 +1,157 @@
+import { GarbageCollector, lang, Logger } from '@coolon/pectin';
+import { PlaceComponentDeactivationHandler } from '../place-component-deactivation-handler';
+/**
+ * Transient states
+ */
+export class NavigationSession extends GarbageCollector {
+    constructor(context, startingUrl) {
+        super();
+        this.context = context;
+        this.startingUrl = startingUrl;
+        this.debugPropertyKeys = [];
+        this._visits = new Map();
+        this.componentDeactivationHandlers = new Map();
+        // TODO: can I get away without creating one every time?
+        this._interactionContext = this.context.routerInteractionAdapter.createExclusiveInteractionContext();
+        this.onDispose(() => {
+            // the interaction context can be detached during the back button cancellation state transition
+            // as the transition is synchronous and activityCancellation isn't.  Otherwise dispose will be
+            // called before the context has been cancelled.  It might be work having the interaction context
+            // automatically cancel if the context is disposed so we don't have worry about detaching etc.
+            if (this._interactionContext) {
+                this._interactionContext.dispose(); // or do something like cancelAndDispose?
+            }
+        });
+    }
+    get name() {
+        return this.constructor.name;
+    }
+    get urlService() {
+        return this.context.urlService;
+    }
+    get interactionServiceAdapter() {
+        return this.context.routerInteractionAdapter;
+    }
+    storeVisit(visit) {
+        // console.log(`Storing visit for ${visit.placeDefinition.component.name}`, {visit});
+        this._visits.set(visit.placeDefinition, visit);
+    }
+    getVisitFor(placeDef) {
+        const visit = this._visits.get(placeDef);
+        // console.log(`Getting visit for ${placeDef.component.name}`, {visit});
+        return visit;
+    }
+    get canDeactivateInteractionContext() {
+        return this._interactionContext;
+    }
+    notifyActive() {
+        // noop.
+    }
+    onRouterStarted(event) {
+        // navigation sessions can have many cancel start cycles due to place guard redirects
+        this.ignore(event);
+    }
+    // @Trace()
+    onUrlChange(url) {
+        // Normally we just ignore these but they are the only way of detecting if the back button
+        // was clicked during a canDeactivate promise.
+        // 1. a route is in progress and awaiting a canDeactivateGuard
+        // 2. the user the clicks the back button.
+        // So to handle that scenario we need to check if we've got a can deactivate interaction in
+        // progress and the do the appropriate clean up.
+        if (this.canDeactivateInteractionContext && this.canDeactivateInteractionContext.isActive()) {
+            this.cancelCanDeactivateInteraction(url);
+        }
+    }
+    onPopState(event) {
+        return this.illegalTransition(event);
+    }
+    onRouterCancelled(event) {
+        return this.illegalTransition(event);
+    }
+    onRouterError(event) {
+        return this.illegalTransition(event);
+    }
+    onRouterEnd(event) {
+        return this.illegalTransition(event);
+    }
+    getVisits() {
+        return Array.from(this._visits.values());
+    }
+    illegalTransition(message) {
+        return lang.illegalState(`${message.toString()} not supported by ${this.toString()}`);
+    }
+    currentRouterUrl() {
+        return this.urlService.getCurrentRouterUrl();
+    }
+    resetBrowserLocation(url, options = { replaceCurrent: false }) {
+        // console.log(`---> resetting browser location to: ${url}`);
+        this.urlService.resetBrowserLocation(url, options);
+    }
+    // @Trace()
+    repairBrowserHistoryAndUrlAfterGuardCancellation(poppedHistoryToReplace, activeUrl) {
+        // Important: I tried to perform this fix at a later point int he routing cycle but it created all kinds of
+        // strangeness.
+        Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
+        // console.log(`replacing ${this.urlService.getCurrentLocationUrlSnapshot().url} with ${poppedHistoryToReplace}`);
+        this.urlService.resetBrowserLocation(poppedHistoryToReplace, { replaceCurrent: true });
+        // console.log(`pushing ${activeUrl} back onto the history.`);
+        this.urlService.resetBrowserLocation(activeUrl, { replaceCurrent: false });
+    }
+    ignore(event, reason) {
+        reason = reason ? ` -> ${reason}` : '';
+        // Logger.get(this).info(`Ignoring router event${reason}: ${event.constructor.name} -> ${event.url} :: ${this.toString()}`);
+    }
+    toString() {
+        return `${this.constructor.name}(${this.debugState()})`;
+    }
+    debugState(properties) {
+        return (properties || this.debugPropertyKeys).map(p => {
+            return `${p}: ${this[p]}`;
+        }).join(', ');
+    }
+    async canDeactivatePlace(component, currentUrl, nextUrl) {
+        // console.log(`---> canDeactivatePlace(${component.placeDefinition.path}, ${currentUrl.url} -> ${nextUrl.url})`);
+        // lookup the handler and create it if we've not seen it yet
+        let handler = this.componentDeactivationHandlers.get(component);
+        if (!handler) {
+            const isPrimaryHandler = this.componentDeactivationHandlers.size === 0; // only primary handler cancels the app model interations
+            handler = new PlaceComponentDeactivationHandler(component, this, isPrimaryHandler);
+            this.componentDeactivationHandlers.set(component, handler);
+        }
+        return handler.canDeactivate(currentUrl, nextUrl).then(result => {
+            // console.log(`<--- canDeactivatePlace(${component.placeDefinition.path}): ${result}`);
+            return result;
+        }).catch(error => {
+            throw error;
+        });
+    }
+    cancelCanDeactivateInteraction(newUrl) {
+        Logger.get(this).info(`back button pressed during navigation session interaction promise`);
+        // detach the interaction from the session so it doesn't get disposed until the activity has finished
+        // all it's things.
+        const canDeactivateInteractionContext = this.detachCanDeactivateInteractionContext();
+        // TODO: I need to make the exclusive interaction context disallow nested activities or
+        //       that would mess things up entirely. Or, can I do a context.abortAll().then(..)
+        Logger.get(this).info('cancelling current navigation activity..');
+        canDeactivateInteractionContext.cancelActiveActivity().then(() => {
+            canDeactivateInteractionContext.dispose();
+        });
+        this.handleCanDeactivateCancelledEventScenario(newUrl);
+    }
+    reinstateUrlAfterAngularChangedItOnCancellation(url) {
+        // Angular calls _this.resetUrlToCurrentUrlTree() on cancelling and fucks our history.
+        // So this means that the top of the stack is the url we want to go back to, and not the one that was on
+        // it before the cancel event fired.
+        // So we need to:
+        // - replace the just inserted url with the one that used to be there.
+        // - push our actual url back onto the top of the stack.
+        this.resetBrowserLocation(url, { replaceCurrent: true });
+    }
+    detachCanDeactivateInteractionContext() {
+        const context = this._interactionContext;
+        this._interactionContext = null;
+        return context;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigation-session.js","sourceRoot":"","sources":["../../../../../../../../libs/angular-ui-powerups/src/lib/place/navigation/session/navigation-session.ts"],"names":[],"mappings":"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","sourcesContent":["import { NavigationCancel, NavigationEnd, NavigationError, NavigationStart, RouterEvent } from '@angular/router';\nimport { Dsl, GarbageCollector, lang, Logger, Trace } from '@coolon/pectin';\nimport { InteractionContext } from '../../../interaction/interaction-context';\nimport { InteractionServiceRoutingAdapter } from '../../../interaction/services/interaction-service-routing-adapter';\nimport { PlaceComponent } from '../../place-component';\nimport { PlaceDefinition } from '../../place-definition';\nimport { UrlService } from '../../url-service';\nimport { UrlSnapshot } from '../../url-snapshot';\nimport { Visit } from '../../visit';\nimport { PlaceComponentDeactivationHandler } from '../place-component-deactivation-handler';\nimport { NavigationContext } from './navigation-context';\n\n/**\n * Transient states\n */\nexport abstract class NavigationSession extends GarbageCollector {\n\n  debugPropertyKeys: string[] = [];\n  private _visits = new Map<PlaceDefinition, Visit>();\n\n  private componentDeactivationHandlers = new Map<PlaceComponent, PlaceComponentDeactivationHandler>();\n  abstract readonly isPopState: boolean;\n\n  private _interactionContext: InteractionContext;\n\n  constructor(readonly context: NavigationContext, readonly startingUrl: string) {\n    super();\n    // TODO: can I get away without creating one every time?\n    this._interactionContext = this.context.routerInteractionAdapter.createExclusiveInteractionContext();\n    this.onDispose(() => {\n      // the interaction context can be detached during the back button cancellation state transition\n      // as the transition is synchronous and activityCancellation isn't.  Otherwise dispose will be\n      // called before the context has been cancelled.  It might be work having the interaction context\n      // automatically cancel if the context is disposed so we don't have worry about detaching etc.\n      if (this._interactionContext) {\n        this._interactionContext.dispose(); // or do something like cancelAndDispose?\n      }\n    });\n  }\n\n  get name(): string {\n    return this.constructor.name;\n  }\n\n  get urlService(): UrlService {\n    return this.context.urlService;\n  }\n\n  get interactionServiceAdapter(): InteractionServiceRoutingAdapter {\n    return this.context.routerInteractionAdapter;\n  }\n\n  storeVisit(visit: Visit) {\n    // console.log(`Storing visit for ${visit.placeDefinition.component.name}`, {visit});\n    this._visits.set(visit.placeDefinition, visit);\n  }\n\n\n  getVisitFor(placeDef: PlaceDefinition) {\n    const visit = this._visits.get(placeDef);\n    // console.log(`Getting visit for ${placeDef.component.name}`, {visit});\n    return visit;\n  }\n\n  get canDeactivateInteractionContext(): InteractionContext {\n    return this._interactionContext;\n  }\n\n  notifyActive() {\n    // noop.\n  }\n\n  onRouterStarted(event: NavigationStart): void {\n    // navigation sessions can have many cancel start cycles due to place guard redirects\n    this.ignore(event);\n  }\n\n  // @Trace()\n  onUrlChange(url: string) {\n    // Normally we just ignore these but they are the only way of detecting if the back button\n    // was clicked during a canDeactivate promise.\n    // 1. a route is in progress and awaiting a canDeactivateGuard\n    // 2. the user the clicks the back button.\n    // So to handle that scenario we need to check if we've got a can deactivate interaction in\n    // progress and the do the appropriate clean up.\n    if (this.canDeactivateInteractionContext && this.canDeactivateInteractionContext.isActive()) {\n      this.cancelCanDeactivateInteraction(url);\n    }\n  }\n\n  onPopState(event: NavigationStart): void {\n    return this.illegalTransition(event);\n  }\n\n  onRouterCancelled(event: NavigationCancel): void {\n    return this.illegalTransition(event);\n  }\n\n  onRouterError(event: NavigationError): void {\n    return this.illegalTransition(event);\n  }\n\n  onRouterEnd(event: NavigationEnd): void {\n    return this.illegalTransition(event);\n  }\n\n  getVisits(): Visit[] {\n    return Array.from(this._visits.values());\n  }\n\n  protected illegalTransition<R>(message: string | RouterEvent): R {\n    return lang.illegalState(`${message.toString()} not supported by ${this.toString()}`);\n  }\n\n  protected currentRouterUrl(): string {\n    return this.urlService.getCurrentRouterUrl();\n  }\n\n  resetBrowserLocation(url, options: { replaceCurrent: boolean } = { replaceCurrent: false }) {\n    // console.log(`---> resetting browser location to: ${url}`);\n    this.urlService.resetBrowserLocation(url, options);\n  }\n\n  // @Trace()\n  protected repairBrowserHistoryAndUrlAfterGuardCancellation(poppedHistoryToReplace: string, activeUrl:string): void {\n    // Important: I tried to perform this fix at a later point int he routing cycle but it created all kinds of\n    // strangeness.\n    Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');\n    // console.log(`replacing ${this.urlService.getCurrentLocationUrlSnapshot().url} with ${poppedHistoryToReplace}`);\n    this.urlService.resetBrowserLocation(poppedHistoryToReplace, { replaceCurrent: true });\n    // console.log(`pushing ${activeUrl} back onto the history.`);\n    this.urlService.resetBrowserLocation(activeUrl, { replaceCurrent: false });\n  }\n\n\n  ignore(event: RouterEvent, reason?: string): void {\n    reason = reason ? ` -> ${reason}` : '';\n    // Logger.get(this).info(`Ignoring router event${reason}: ${event.constructor.name} -> ${event.url} :: ${this.toString()}`);\n  }\n\n  toString(): string {\n    return `${this.constructor.name}(${this.debugState()})`;\n  }\n\n  protected debugState(properties?: string[]) {\n    return (properties || this.debugPropertyKeys).map(p => {\n      return `${p}: ${this[p]}`;\n    }).join(', ');\n  }\n\n  async canDeactivatePlace(component: PlaceComponent, currentUrl: UrlSnapshot, nextUrl: UrlSnapshot): Promise<boolean | UrlSnapshot> {\n    // console.log(`---> canDeactivatePlace(${component.placeDefinition.path}, ${currentUrl.url} -> ${nextUrl.url})`);\n    // lookup the handler and create it if we've not seen it yet\n    let handler = this.componentDeactivationHandlers.get(component);\n    if (!handler) {\n      const isPrimaryHandler = this.componentDeactivationHandlers.size === 0; // only primary handler cancels the app model interations\n      handler = new PlaceComponentDeactivationHandler(component, this, isPrimaryHandler);\n      this.componentDeactivationHandlers.set(component, handler);\n    }\n    return handler.canDeactivate(currentUrl, nextUrl).then(result => {\n      // console.log(`<--- canDeactivatePlace(${component.placeDefinition.path}): ${result}`);\n      return result;\n    }).catch(error => {\n      throw error;\n    });\n  }\n\n  cancelCanDeactivateInteraction(newUrl: string): void {\n    Logger.get(this).info(`back button pressed during navigation session interaction promise`);\n    // detach the interaction from the session so it doesn't get disposed until the activity has finished\n    // all it's things.\n    const canDeactivateInteractionContext = this.detachCanDeactivateInteractionContext();\n    // TODO: I need to make the exclusive interaction context disallow nested activities or\n    //       that would mess things up entirely. Or, can I do a context.abortAll().then(..)\n    Logger.get(this).info('cancelling current navigation activity..');\n    canDeactivateInteractionContext.cancelActiveActivity().then(() => {\n      canDeactivateInteractionContext.dispose();\n    });\n\n    this.handleCanDeactivateCancelledEventScenario(newUrl);\n  }\n\n  abstract handleCanDeactivateCancelledEventScenario(newUrl: string): void\n\n  protected reinstateUrlAfterAngularChangedItOnCancellation(url: string) {\n    // Angular calls _this.resetUrlToCurrentUrlTree() on cancelling and fucks our history.\n    // So this means that the top of the stack is the url we want to go back to, and not the one that was on\n    // it before the cancel event fired.\n    // So we need to:\n    // - replace the just inserted url with the one that used to be there.\n    // - push our actual url back onto the top of the stack.\n    this.resetBrowserLocation(url, { replaceCurrent: true });\n  }\n\n  protected detachCanDeactivateInteractionContext(): InteractionContext {\n    const context = this._interactionContext;\n    this._interactionContext = null;\n    return context;\n  }\n}\n"]}