@coolon/angular-ui-powerups 0.0.101 → 0.0.102

package/esm5/lib/place/guards/place-component-deactivation-handler.js

@@ -3,68 +3,112 @@
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 import * as tslib_1 from "tslib";
+import * as _ from 'lodash';
 var PlaceComponentDeactivationHandler = /** @class */ (function () {
-    function PlaceComponentDeactivationHandler(component, navigationSession) {
+    function PlaceComponentDeactivationHandler(component, navigationState, isPrimaryComponent) {
         this.component = component;
-        this.navigationSession = navigationSession;
+        this.navigationState = navigationState;
+        this.isPrimaryComponent = isPrimaryComponent;
     }
+    Object.defineProperty(PlaceComponentDeactivationHandler.prototype, "interactionService", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this.navigationState.interactionService;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PlaceComponentDeactivationHandler.prototype, "placeRouter", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this.navigationState.placeRouter;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /**
+     * @param {?} currentUrl
      * @param {?} nextState
      * @return {?}
      */
     PlaceComponentDeactivationHandler.prototype.canDeactivate = /**
+     * @param {?} currentUrl
      * @param {?} nextState
      * @return {?}
      */
-    function (nextState) {
+    function (currentUrl, nextState) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {
                 // 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) {
-                    this.canDeactivatePromise = this.canDeactivateComponent(nextState);
+                    console.log("creating deactivate promise for -> " + this.component.constructor.name);
+                    this.canDeactivatePromise = this.canDeactivateComponent(currentUrl, nextState);
                 }
                 return [2 /*return*/, this.canDeactivatePromise];
             });
         });
     };
+    // @Trace()
+    // @Trace()
     /**
      * @protected
+     * @param {?} currentUrl
      * @param {?} nextState
      * @return {?}
      */
-    PlaceComponentDeactivationHandler.prototype.canDeactivateComponent = /**
+    PlaceComponentDeactivationHandler.prototype.canDeactivateComponent = 
+    // @Trace()
+    /**
      * @protected
+     * @param {?} currentUrl
      * @param {?} nextState
      * @return {?}
      */
-    function (nextState) {
+    function (currentUrl, nextState) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var activity;
+            var routeIds, currentIds;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!(this.navigationSession.isPopState && this.component.interactionContext && this.component.interactionContext.isActive())) return [3 /*break*/, 2];
-                        // Note: Modal interactions are run in a different router outlet so we never get place deactivating while
-                        // a model interaction is active. This is because:
-                        // 1. the user can't click anything to navigate away
-                        // 2. clicking the back button will only change the outlet route portion of the URL. This
-                        //    is all handled by the InteractionGuard and so the component guards will never run.
-                        //
-                        // Now we just cancel the current activity...
-                        return [4 /*yield*/, this.component.interactionContext.getCurrentActivity()];
+                        console.log(this.navigationState.toString());
+                        if (!this.navigationState.isPopState) return [3 /*break*/, 5];
+                        if (!(this.isPrimaryComponent && this.interactionService.isModalActive())) return [3 /*break*/, 3];
+                        routeIds = this.placeRouter.getActiveInteractionIdsFromUrl(nextState.url);
+                        currentIds = this.interactionService.activeInteractionContextIds.value;
+                        if (!!_.isEqual(currentIds, routeIds)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.interactionService.getActiveContext().cancelCurrentActivity()];
                     case 1:
-                        activity = _a.sent();
-                        activity.cancel(null);
-                        return [2 /*return*/, false]; // ..and stay where we are.
-                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, currentUrl.updateInteractionIds(this.interactionService.activeInteractionContextIds.value)];
+                    case 2: return [3 /*break*/, 5];
+                    case 3:
+                        if (!(this.component.interactionContext && this.component.interactionContext.isActive())) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.component.interactionContext.cancelCurrentActivity()];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/, currentUrl
+                                .updateInteractionIds(this.interactionService.activeInteractionContextIds.value)];
+                    case 5:
                         // Ok, so now we're really leaving, so we ask the component if we should.;
-                        if (this.isNotJustAChangeInRouteId(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(this.navigationSession.interactionContext)];
+                        if (this.isNotJustAChangeInRouteId(nextState)) {
+                            if (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(this.navigationState.interactionContext)];
+                            }
+                            // 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 (this.component.interactionContext && this.component.interactionContext.isActive()) {
+                                console.warn('Route changed while component has active interaction, cancelling navigation');
+                                return [2 /*return*/, false];
+                            }
                         }
                         return [2 /*return*/, true];
                 }
@@ -99,6 +143,8 @@ if (false) {
     /** @type {?} */
     PlaceComponentDeactivationHandler.prototype.component;
     /** @type {?} */
-    PlaceComponentDeactivationHandler.prototype.navigationSession;
+    PlaceComponentDeactivationHandler.prototype.navigationState;
+    /** @type {?} */
+    PlaceComponentDeactivationHandler.prototype.isPrimaryComponent;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhY2UtY29tcG9uZW50LWRlYWN0aXZhdGlvbi1oYW5kbGVyLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGNvb2xvbi9hbmd1bGFyLXVpLXBvd2VydXBzLyIsInNvdXJjZXMiOlsibGliL3BsYWNlL2d1YXJkcy9wbGFjZS1jb21wb25lbnQtZGVhY3RpdmF0aW9uLWhhbmRsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFLQTtJQUlFLDJDQUFxQixTQUF5QixFQUFXLGlCQUFrQztRQUF0RSxjQUFTLEdBQVQsU0FBUyxDQUFnQjtRQUFXLHNCQUFpQixHQUFqQixpQkFBaUIsQ0FBaUI7SUFDM0YsQ0FBQzs7Ozs7SUFFSyx5REFBYTs7OztJQUFuQixVQUFvQixTQUFzQjs7O2dCQUN4QywyRUFBMkU7Z0JBQzNFLG9GQUFvRjtnQkFDcEYsc0JBQXNCO2dCQUN0QixJQUFJLENBQUMsSUFBSSxDQUFDLG9CQUFvQixFQUFFO29CQUM5QixJQUFJLENBQUMsb0JBQW9CLEdBQUcsSUFBSSxDQUFDLHNCQUFzQixDQUFDLFNBQVMsQ0FBQyxDQUFDO2lCQUNwRTtnQkFDRCxzQkFBTyxJQUFJLENBQUMsb0JBQW9CLEVBQUM7OztLQUNsQzs7Ozs7O0lBRWUsa0VBQXNCOzs7OztJQUF0QyxVQUF1QyxTQUFzQjs7Ozs7OzZCQUt2RCxDQUFBLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxVQUFVLElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxrQkFBa0IsSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLGtCQUFrQixDQUFDLFFBQVEsRUFBRSxDQUFBLEVBQXRILHdCQUFzSDs7Ozs7Ozs7d0JBUXZHLHFCQUFNLElBQUksQ0FBQyxTQUFTLENBQUMsa0JBQWtCLENBQUMsa0JBQWtCLEVBQUUsRUFBQTs7d0JBQXZFLFFBQVEsR0FBRyxTQUE0RDt3QkFDN0UsUUFBUSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQzt3QkFDdEIsc0JBQU8sS0FBSyxFQUFDLENBQUMsMkJBQTJCOzt3QkFHM0MsMEVBQTBFO3dCQUMxRSxJQUFJLElBQUksQ0FBQyx5QkFBeUIsQ0FBQyxTQUFTLENBQUMsSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLGFBQWEsRUFBRTs0QkFDN0UscURBQXFEOzRCQUNyRCw4SEFBOEg7NEJBQzlILCtHQUErRzs0QkFDL0csc0JBQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLGtCQUFrQixDQUFDLEVBQUM7eUJBQ2hGO3dCQUNELHNCQUFPLElBQUksRUFBQzs7OztLQUNiOzs7Ozs7SUFFUyxxRUFBeUI7Ozs7O0lBQW5DLFVBQW9DLFNBQXNCO1FBQ3hELHFGQUFxRjtRQUNyRixnRkFBZ0Y7UUFDaEYsMENBQTBDO1FBQzFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsZUFBZSxDQUFDLENBQUM7SUFDbkUsQ0FBQztJQUNILHdDQUFDO0FBQUQsQ0FBQyxBQW5ERCxJQW1EQzs7Ozs7OztJQWpEQyxpRUFBK0M7O0lBRW5DLHNEQUFrQzs7SUFBRSw4REFBMkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbnRlcmFjdGlvbkNvbnRleHQgfSBmcm9tICcuLi8uLi9pbnRlcmFjdGlvbi9pbnRlcmFjdGlvbi1jb250ZXh0JztcbmltcG9ydCB7IFBsYWNlQ29tcG9uZW50IH0gZnJvbSAnLi4vcGxhY2UtY29tcG9uZW50JztcbmltcG9ydCB7IFVybFNuYXBzaG90IH0gZnJvbSAnLi4vdXJsLXNuYXBzaG90JztcbmltcG9ydCB7IE5hdmlnYXRpb25TdGF0ZSB9IGZyb20gJy4vbmF2aWdhdGlvbi1zdGF0ZSc7XG5cbmV4cG9ydCBjbGFzcyBQbGFjZUNvbXBvbmVudERlYWN0aXZhdGlvbkhhbmRsZXIge1xuXG4gIHByaXZhdGUgY2FuRGVhY3RpdmF0ZVByb21pc2U6IFByb21pc2U8Ym9vbGVhbj47XG5cbiAgY29uc3RydWN0b3IocmVhZG9ubHkgY29tcG9uZW50OiBQbGFjZUNvbXBvbmVudCwgcmVhZG9ubHkgbmF2aWdhdGlvblNlc3Npb246IE5hdmlnYXRpb25TdGF0ZSkge1xuICB9XG5cbiAgYXN5bmMgY2FuRGVhY3RpdmF0ZShuZXh0U3RhdGU6IFVybFNuYXBzaG90KTogUHJvbWlzZTxib29sZWFuPiB7XG4gICAgLy8gV2UnbGwgZ2V0IGNhbGxlZCBtdWx0aXBsZSB0aW1lcyBpZiB0aGVyZSdzIGFueSBwYXJhbWV0ZXIgc2FuaXRpc2F0aW9uIHNvXG4gICAgLy8gd2UgYWx3YXlzIHJldHVybiB0cnVlIGlmIHdlIGFjY2VwdGVkIHByb21pc2UgZnJvbSBhIHByZXZpb3VzIGN5Y2xlIG9mIHRoZSBjdXJyZW50XG4gICAgLy8gbmF2aWdhdGlvbiBzZXNzaW9uLlxuICAgIGlmICghdGhpcy5jYW5EZWFjdGl2YXRlUHJvbWlzZSkge1xuICAgICAgdGhpcy5jYW5EZWFjdGl2YXRlUHJvbWlzZSA9IHRoaXMuY2FuRGVhY3RpdmF0ZUNvbXBvbmVudChuZXh0U3RhdGUpO1xuICAgIH1cbiAgICByZXR1cm4gdGhpcy5jYW5EZWFjdGl2YXRlUHJvbWlzZTtcbiAgfVxuXG4gIHByb3RlY3RlZCBhc3luYyBjYW5EZWFjdGl2YXRlQ29tcG9uZW50KG5leHRTdGF0ZTogVXJsU25hcHNob3QpIHtcbiAgICAvLyBBdXRvbWF0aWNhbGx5IGNhbmNlbCBhbnkgYWN0aXZlIGFjdGl2aXRpZXMgaWYgdGhlIG5hdmlnYXRpb24gc2Vzc2lvbiB3YXMgdHJpZ2dlcmVkIGJ5IHRoZSBiYWNrIGJ1dHRvbi5cbiAgICAvLyBhbnkgb3RoZXIgbmF2aWdhdGlvbnMgKHN1Y2ggYXMgdGhlIHVzZXIgY2xpY2tpbmcgYSBkaWZmZXJudCBwbGFjZSkgbXVzdCBiZSBoYW5kbGVkIGJ5IHRoZSBjb21wb25lbnQgaXRzZWxmXG4gICAgLy8gZHVyaW5nIHRoZSBjYW5EZWF0aXZhdGUgbWV0aG9kLiAgSWYgd2UgaGFuZGxlZCBtb3JlIHRoYW4ganVzdCB0aGUgcG9wIHN0YXRlIHRoZW4gaXQgbGVhZHMgdG8gdGhlIFVJIGlnbm9yaW5nXG4gICAgLy8gY2xpY2tzIGFuZCBqdXN0IGNhbmNlbGxpbmcgdGhpbmdzIHdoaWNoIGlzIGRlZXBseSBkaXNjb25jZXJ0aW5nLlxuICAgIGlmICh0aGlzLm5hdmlnYXRpb25TZXNzaW9uLmlzUG9wU3RhdGUgJiYgdGhpcy5jb21wb25lbnQuaW50ZXJhY3Rpb25Db250ZXh0ICYmIHRoaXMuY29tcG9uZW50LmludGVyYWN0aW9uQ29udGV4dC5pc0FjdGl2ZSgpKSB7XG4gICAgICAvLyBOb3RlOiBNb2RhbCBpbnRlcmFjdGlvbnMgYXJlIHJ1biBpbiBhIGRpZmZlcmVudCByb3V0ZXIgb3V0bGV0IHNvIHdlIG5ldmVyIGdldCBwbGFjZSBkZWFjdGl2YXRpbmcgd2hpbGVcbiAgICAgIC8vIGEgbW9kZWwgaW50ZXJhY3Rpb24gaXMgYWN0aXZlLiBUaGlzIGlzIGJlY2F1c2U6XG4gICAgICAvLyAxLiB0aGUgdXNlciBjYW4ndCBjbGljayBhbnl0aGluZyB0byBuYXZpZ2F0ZSBhd2F5XG4gICAgICAvLyAyLiBjbGlja2luZyB0aGUgYmFjayBidXR0b24gd2lsbCBvbmx5IGNoYW5nZSB0aGUgb3V0bGV0IHJvdXRlIHBvcnRpb24gb2YgdGhlIFVSTC4gVGhpc1xuICAgICAgLy8gICAgaXMgYWxsIGhhbmRsZWQgYnkgdGhlIEludGVyYWN0aW9uR3VhcmQgYW5kIHNvIHRoZSBjb21wb25lbnQgZ3VhcmRzIHdpbGwgbmV2ZXIgcnVuLlxuICAgICAgLy9cbiAgICAgIC8vIE5vdyB3ZSBqdXN0IGNhbmNlbCB0aGUgY3VycmVudCBhY3Rpdml0eS4uLlxuICAgICAgY29uc3QgYWN0aXZpdHkgPSBhd2FpdCB0aGlzLmNvbXBvbmVudC5pbnRlcmFjdGlvbkNvbnRleHQuZ2V0Q3VycmVudEFjdGl2aXR5KCk7XG4gICAgICBhY3Rpdml0eS5jYW5jZWwobnVsbCk7XG4gICAgICByZXR1cm4gZmFsc2U7IC8vIC4uYW5kIHN0YXkgd2hlcmUgd2UgYXJlLlxuICAgIH1cblxuICAgIC8vIE9rLCBzbyBub3cgd2UncmUgcmVhbGx5IGxlYXZpbmcsIHNvIHdlIGFzayB0aGUgY29tcG9uZW50IGlmIHdlIHNob3VsZC47XG4gICAgaWYgKHRoaXMuaXNOb3RKdXN0QUNoYW5nZUluUm91dGVJZChuZXh0U3RhdGUpICYmIHRoaXMuY29tcG9uZW50LmNhbkRlYWN0aXZhdGUpIHtcbiAgICAgIC8vIE5vIGludGVyYWN0aW9uIGluIHByb2dyZXNzLCBzbyBhc2sgdGhlIGNvbXBvbmVudCAuXG4gICAgICAvLyBUaGlzIG1heSBzdGFydCBhbiBpbnRlcmFjdGlvbiwgaGVuY2UgY2hlY2tpbmcgdGhlIGludGVyYWN0aW9uIGNvbnRleHQgYmVmb3JlIG5vdy4gSS5lLiBpZiB0aGUgcGxhY2UgcG9wcyB1cCB0aGUgZGlhbG9nLCBhbmRcbiAgICAgIC8vIHRoZSB1c2VyIGNsaWNrcyBiYWNrIGFnYWluLCB3ZSdsbCByZS1lbnRlciBoZXJlIGFuZCBnbyBiYW5nIHdoZW4gdGhlIGNvbXBvbmVudCB0cmllcyB0byBvcGVuIGFub3RoZXIgZGlhbG9nLlxuICAgICAgcmV0dXJuIHRoaXMuY29tcG9uZW50LmNhbkRlYWN0aXZhdGUodGhpcy5uYXZpZ2F0aW9uU2Vzc2lvbi5pbnRlcmFjdGlvbkNvbnRleHQpO1xuICAgIH1cbiAgICByZXR1cm4gdHJ1ZTtcbiAgfVxuXG4gIHByb3RlY3RlZCBpc05vdEp1c3RBQ2hhbmdlSW5Sb3V0ZUlkKG5leHRTdGF0ZTogVXJsU25hcHNob3QpIHtcbiAgICAvLyBCZWNhdXNlIHBsYWNlcyB3aXRoIGEgcm91dGUtaWQgY292ZXIgdHdvIHJvdXRlIHNlZ21lbnRzIHdlIGdldCBhc2tlZCB0byBkZWFjdGl2YXRlXG4gICAgLy8gaWYgdGhlIHJvdXRlIGlkIGlzIGFkZGVkIG9yIHJlbW92ZWQuICBTbyBpZiBvdXIgcGF0aCBpcyBzdGlsbCBwcmVzZW50IHRoZSB1cmxcbiAgICAvLyB0aGVuIHdlIHNob3VsZG4ndCBkZWFjdGl2YXRlIHRoZSBwbGFjZS5cbiAgICByZXR1cm4gIW5leHRTdGF0ZS5pbmNsdWRlc1BhdGhPZih0aGlzLmNvbXBvbmVudC5wbGFjZURlZmluaXRpb24pO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"place-component-deactivation-handler.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/guards/place-component-deactivation-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { Trace } from '@coolon/pectin';\nimport * as _ from 'lodash';\nimport { PlaceComponent } from '../place-component';\nimport { UrlSnapshot } from '../url-snapshot';\nimport { NavigationState } from './navigation-state';\n\nexport class PlaceComponentDeactivationHandler {\n\n  private canDeactivatePromise: Promise<boolean | UrlSnapshot>;\n\n  constructor(readonly component: PlaceComponent, readonly navigationState: NavigationState, readonly isPrimaryComponent: boolean) {\n  }\n\n  get interactionService() {\n    return this.navigationState.interactionService;\n  }\n\n  get placeRouter() {\n    return this.navigationState.placeRouter;\n  }\n\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    console.log(this.navigationState.toString());\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.navigationState.isPopState) {\n      if (this.isPrimaryComponent && this.interactionService.isModalActive()) {\n        const routeIds = this.placeRouter.getActiveInteractionIdsFromUrl(nextState.url);\n        const currentIds = this.interactionService.activeInteractionContextIds.value;\n\n        if (!_.isEqual(currentIds, routeIds)) {\n          await this.interactionService.getActiveContext().cancelCurrentActivity();\n          return currentUrl.updateInteractionIds(this.interactionService.activeInteractionContextIds.value);\n        }\n      } else {\n        // check if the component has an in place interaction\n        if (this.component.interactionContext && this.component.interactionContext.isActive()) {\n          await this.component.interactionContext.cancelCurrentActivity();\n          return currentUrl\n            .updateInteractionIds(this.interactionService.activeInteractionContextIds.value)\n        }\n      }\n    }\n\n    // Ok, so now we're really leaving, so we ask the component if we should.;\n    if (this.isNotJustAChangeInRouteId(nextState)) {\n\n      if (this.component.canDeactivate) {\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        return this.component.canDeactivate(this.navigationState.interactionContext);\n      }\n\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 (this.component.interactionContext && this.component.interactionContext.isActive()) {\n        console.warn('Route changed while component has active interaction, cancelling navigation');\n        return false;\n      }\n\n    }\n    return true;\n  }\n\n  protected isNotJustAChangeInRouteId(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/esm5/lib/place/guards/place.guard.js

@@ -0,0 +1,300 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { lang } from '@coolon/pectin';
+import { Observable } from 'rxjs';
+import { PlaceComponent } from '../place-component';
+import { VisitSanitiser } from '../route/visit-sanitiser';
+import { UrlSnapshot } from '../url-snapshot';
+import { Visit } from '../visit';
+import { ConsolidatedParameterMap } from './consolidated-param-map';
+/**
+ * @abstract
+ */
+var /**
+ * @abstract
+ */
+PlaceGuard = /** @class */ (function () {
+    function PlaceGuard(router, urlSerializer, placeRouter, placeHistory, interactionService, injector) {
+        this.router = router;
+        this.urlSerializer = urlSerializer;
+        this.placeRouter = placeRouter;
+        this.placeHistory = placeHistory;
+        this.interactionService = interactionService;
+        this.injector = injector;
+    }
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    PlaceGuard.prototype.canActivate = 
+    // @Trace()
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    function (activatedRoute, state) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                // TODO: this is ugly now that I'm return UrlSnapshots and not UrlTrees.  It'd be better if the functions
+                //        weren't nested or if I implemented a handler chain.
+                return [2 /*return*/, this.authorisePlaceThen(activatedRoute, state, (/**
+                     * @param {?} placeDefinition
+                     * @return {?}
+                     */
+                    function (placeDefinition) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        var result;
+                        var _this = this;
+                        return tslib_1.__generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, this.cleanInteractionState(activatedRoute, state, (/**
+                                     * @return {?}
+                                     */
+                                    function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                        var params, parsedParams, initialVisit, sanitiser, sanitisedVisit, urlSnapshot;
+                                        return tslib_1.__generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0:
+                                                    // Parse our route params.
+                                                    params = new ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);
+                                                    parsedParams = placeDefinition.parseRouteParams(params);
+                                                    initialVisit = this.placeRouter.navigationState.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);
+                                                    sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);
+                                                    return [4 /*yield*/, sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams))];
+                                                case 1:
+                                                    sanitisedVisit = _a.sent();
+                                                    // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters
+                                                    this.placeRouter.navigationState.storeVisit(sanitisedVisit);
+                                                    if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {
+                                                        // Regenerate the url
+                                                        urlSnapshot = this.placeRouter.parseUrl(state.url).updateVisitSegments(sanitisedVisit);
+                                                        console.log('##### Place Guard Redirect', urlSnapshot);
+                                                        return [2 /*return*/, urlSnapshot];
+                                                    }
+                                                    else {
+                                                        return [2 /*return*/, true];
+                                                    }
+                                                    return [2 /*return*/];
+                                            }
+                                        });
+                                    }); }))];
+                                case 1:
+                                    result = _a.sent();
+                                    return [2 /*return*/, this.handleGuardResult(result)];
+                            }
+                        });
+                    }); }))];
+            });
+        });
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} component
+     * @param {?} currentRoute
+     * @param {?} currentState
+     * @param {?=} nextState
+     * @return {?}
+     */
+    PlaceGuard.prototype.canDeactivate = 
+    // @Trace()
+    /**
+     * @param {?} component
+     * @param {?} currentRoute
+     * @param {?} currentState
+     * @param {?=} nextState
+     * @return {?}
+     */
+    function (component, currentRoute, currentState, nextState) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var currentUrl, nextUrl, result;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        currentUrl = this.placeRouter.parseUrl(currentState.url);
+                        nextUrl = this.placeRouter.parseUrl(nextState.url);
+                        return [4 /*yield*/, this.placeRouter.navigationState.canDeactivatePlace(component, currentUrl, nextUrl)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, this.handleGuardResult(result)];
+                }
+            });
+        });
+    };
+    /**
+     * @private
+     * @param {?} result
+     * @return {?}
+     */
+    PlaceGuard.prototype.handleGuardResult = /**
+     * @private
+     * @param {?} result
+     * @return {?}
+     */
+    function (result) {
+        if (result instanceof UrlSnapshot) {
+            return result.urlTree;
+        }
+        else {
+            return result;
+        }
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @protected
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @param {?} runPlaceGuards
+     * @return {?}
+     */
+    PlaceGuard.prototype.authorisePlaceThen = 
+    // @Trace()
+    /**
+     * @protected
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @param {?} runPlaceGuards
+     * @return {?}
+     */
+    function (activatedRoute, state, runPlaceGuards) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var placeDefinition, authoriseResult, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) return [3 /*break*/, 4];
+                        placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);
+                        if (!placeDefinition.authenticate) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.isAuthorised(activatedRoute, state)];
+                    case 1:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = true;
+                        _b.label = 3;
+                    case 3:
+                        authoriseResult = _a;
+                        if (authoriseResult === true) {
+                            // we're authorised, now run the place guards.
+                            return [2 /*return*/, runPlaceGuards(placeDefinition)];
+                        }
+                        else {
+                            console.log('not authorised result', authoriseResult);
+                            return [2 /*return*/, authoriseResult];
+                        }
+                        return [3 /*break*/, 5];
+                    case 4: return [2 /*return*/, lang.illegalState("expected component to be an instance of PlaceComponent, got " + activatedRoute.component)];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    PlaceGuard.prototype.isAuthorised = 
+    // @Trace()
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    function (activatedRoute, state) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var authorised;
+            return tslib_1.__generator(this, function (_a) {
+                authorised = this.getAuthGuard(this.injector).canActivate(activatedRoute, state);
+                return [2 /*return*/, (authorised instanceof Observable) ? authorised.toPromise() : authorised];
+            });
+        });
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} route
+     * @param {?} state
+     * @param {?} then
+     * @return {?}
+     */
+    PlaceGuard.prototype.cleanInteractionState = 
+    // @Trace()
+    /**
+     * @param {?} route
+     * @param {?} state
+     * @param {?} then
+     * @return {?}
+     */
+    function (route, state, then) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var url;
+            return tslib_1.__generator(this, function (_a) {
+                url = this.placeRouter.parseUrl(state.url);
+                if (!this.interactionService.isActive() && url.hasInteractionIds()) {
+                    // This happens if we reload the page or the url was pasted as the route should only be activated
+                    // after the interaction context has become active.
+                    return [2 /*return*/, url.removeInteractionIds()];
+                }
+                else {
+                    return [2 /*return*/, then()];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return PlaceGuard;
+}());
+/**
+ * @abstract
+ */
+export { PlaceGuard };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.urlSerializer;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.placeRouter;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.placeHistory;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.interactionService;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.injector;
+    /**
+     * @abstract
+     * @param {?} injector
+     * @return {?}
+     */
+    PlaceGuard.prototype.getAuthGuard = function (injector) { };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"place.guard.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/guards/place.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector } from '@angular/core';\nimport {\n  ActivatedRouteSnapshot,\n  CanActivate,\n  CanDeactivate,\n  Router,\n  RouterStateSnapshot,\n  UrlSerializer,\n  UrlTree\n} from '@angular/router';\nimport { lang, Trace } from '@coolon/pectin';\nimport { Observable } from 'rxjs';\nimport { InteractionService } from '../../interaction/services/interaction.service';\nimport { PlaceComponent } from '../place-component';\nimport { PlaceDefinition } from '../place-definition';\nimport { PlaceHistory } from '../place-history';\nimport { PlaceRouter } from '../place-router';\nimport { VisitSanitiser } from '../route/visit-sanitiser';\nimport { UrlSnapshot } from '../url-snapshot';\nimport { Visit } from '../visit';\nimport { ConsolidatedParameterMap } from './consolidated-param-map';\n\n\nexport abstract class PlaceGuard implements CanActivate, CanDeactivate<PlaceComponent> {\n\n\n  constructor(private readonly router: Router,\n              private urlSerializer: UrlSerializer,\n              private readonly placeRouter: PlaceRouter,\n              private readonly placeHistory: PlaceHistory,\n              private readonly interactionService: InteractionService,\n              private readonly injector: Injector) {\n  }\n\n  // @Trace()\n  async canActivate(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree> {\n\n     // TODO: this is ugly now that I'm return UrlSnapshots and not UrlTrees.  It'd be better if the functions\n    //        weren't nested or if I implemented a handler chain.\n    return this.authorisePlaceThen(activatedRoute, state, async (placeDefinition) => {\n\n      const result = await this.cleanInteractionState(activatedRoute, state, async () => {\n        // Parse our route params.\n        const params = new ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);\n        const parsedParams = placeDefinition.parseRouteParams(params);\n\n        const initialVisit = this.placeRouter.navigationState.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);\n        const sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);\n        const sanitisedVisit = await sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams));\n\n        // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters\n        this.placeRouter.navigationState.storeVisit(sanitisedVisit);\n        if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {\n          // Regenerate the url\n          const urlSnapshot = this.placeRouter.parseUrl(state.url).updateVisitSegments(sanitisedVisit);\n          console.log('##### Place Guard Redirect', urlSnapshot);\n          return urlSnapshot;\n        } else {\n          return true;\n        }\n      });\n      return this.handleGuardResult(result);\n\n    });\n  }\n\n  // @Trace()\n  async canDeactivate(component: PlaceComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Promise<boolean | UrlTree> {\n    const currentUrl = this.placeRouter.parseUrl(currentState.url);\n    const nextUrl = this.placeRouter.parseUrl(nextState.url);\n    const result = await this.placeRouter.navigationState.canDeactivatePlace(component, currentUrl, nextUrl);\n    return this.handleGuardResult(result);\n  }\n\n  private handleGuardResult(result) {\n    if (result instanceof UrlSnapshot) {\n      return result.urlTree;\n    } else {\n      return result;\n    }\n  }\n\n// @Trace()\n  protected async authorisePlaceThen(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot, runPlaceGuards: (placeDefinition: PlaceDefinition) => Promise<boolean | UrlTree>) {\n    if (PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) {\n      const placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);\n      const authoriseResult = placeDefinition.authenticate ? await this.isAuthorised(activatedRoute, state) : true;\n      if (authoriseResult === true) {\n        // we're authorised, now run the place guards.\n        return runPlaceGuards(placeDefinition);\n      } else {\n        console.log('not authorised result', authoriseResult);\n        return authoriseResult;\n      }\n    } else {\n      return lang.illegalState(`expected component to be an instance of PlaceComponent, got ${activatedRoute.component}`);\n    }\n  }\n\n  // @Trace()\n  async isAuthorised(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree> {\n    const authorised = this.getAuthGuard(this.injector).canActivate(activatedRoute, state);\n    return (authorised instanceof Observable) ? authorised.toPromise() : authorised;\n  }\n\n  abstract getAuthGuard(injector: Injector): CanActivate;\n\n  // @Trace()\n  async cleanInteractionState(route: ActivatedRouteSnapshot, state: RouterStateSnapshot, then: () => Promise<boolean | UrlSnapshot>): Promise<boolean | UrlSnapshot> {\n    const url = this.placeRouter.parseUrl(state.url);\n    if (!this.interactionService.isActive() && url.hasInteractionIds()) {\n      // This happens if we reload the page or the url was pasted as the route should only be activated\n      // after the interaction context has become active.\n      return url.removeInteractionIds();\n    } else {\n      return then();\n    }\n  }\n\n}\n"]}

package/esm5/lib/place/index.js

@@ -22,12 +22,11 @@ export { ListPlaceNavComponent } from "./components/list-place-nav/list-place-na
 export { PlaceOutletComponent } from "./components/place-outlet/place-outlet.component";
 export { leftRightPlaceAnimation, LEFT_RIGHT_PLACE_ANIMATION } from "./components/place-outlet/route-animations";
 export { TabbedPlaceNavigationComponent } from "./components/tabbed-place-navigation/tabbed-place-navigation.component";
-export { AbstractPlaceGuard } from "./guards/abstract-place.guard";
 export { ConsolidatedParameterMap } from "./guards/consolidated-param-map";
-export { InteractionGuard } from "./guards/interaction.guard";
 export { NavigationState } from "./guards/navigation-state";
 export { NoopAuthGuard } from "./guards/noop-auth-guard.service";
 export { PlaceComponentDeactivationHandler } from "./guards/place-component-deactivation-handler";
+export { PlaceGuard } from "./guards/place.guard";
 export { Formatter } from "./route/formatter";
 export {} from "./route/json-types";
 export { RouteId, VisitParameter, VisitParameterList } from "./route/parameter-decorators";
@@ -35,4 +34,4 @@ export { ParameterDefinition } from "./route/parameter-definition.class";
 export {} from "./route/parameter-sanitiser";
 export {} from "./route/parameter-snapshot";
 export { VisitSanitiser } from "./route/visit-sanitiser";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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