@coolon/angular-ui-powerups 0.0.66 → 0.0.67

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

@@ -2922,6 +2922,7 @@
         function PlaceRouter(router$1, angularLocation) {
             var _this = this;
             this.router = router$1;
+            this.angularLocation = angularLocation;
             this._navigationSession = new pectin.MutableValueModel();
             angularLocation.onUrlChange((/**
              * @param {?} url
@@ -3064,6 +3065,8 @@
          * @private
          */
         PlaceRouter.prototype.router;
+        /** @type {?} */
+        PlaceRouter.prototype.angularLocation;
     }
 
     /**
@@ -5020,6 +5023,22 @@
             this.interactionContext = interactionContext;
             this.angularLocation = angularLocation;
         }
+        /**
+         * @private
+         * @param {?} nextState
+         * @param {?} placeDefinitionPath
+         * @return {?}
+         */
+        LeavePlaceGuard.prototype.isLeavingTheCurrentPlace = /**
+         * @private
+         * @param {?} nextState
+         * @param {?} placeDefinitionPath
+         * @return {?}
+         */
+        function (nextState, placeDefinitionPath) {
+            // TODO: this will break with child routes... need to examine the router states properly.
+            return !nextState.url.startsWith(placeDefinitionPath);
+        };
         /**
          * @param {?} component
          * @param {?} currentRoute
@@ -5042,23 +5061,42 @@
                         case 0:
                             placeDefinitionPath = "/" + component.placeDefinition.path;
                             if (!this.placeRouter.navigationSession.alreadyAccepted(component)) return [3 /*break*/, 1];
+                            // We'll get called multiple times if there's any parameter sanitisation so
+                            // we always return true if we accepted on a previous cycle of the current
+                            // navigation session.
                             return [2 /*return*/, true];
                         case 1:
-                            if (!!nextState.url.startsWith(placeDefinitionPath)) return [3 /*break*/, 3];
                             self_1 = this;
+                            canLeave = true;
+                            if (!this.isLeavingTheCurrentPlace(nextState, placeDefinitionPath)) return [3 /*break*/, 4];
+                            // we check the interaction first, so that components that don't need to check if they're in an
+                            // interaction during the canDeactivate cycle.
+                            if (this.interactionContext.isActive()) {
+                                canLeave = false;
+                                console.log("cancelling", { activity: this.interactionContext.currentActivity });
+                                this.interactionContext.currentActivity.cancel(null);
+                            }
+                            if (!canLeave) return [3 /*break*/, 3];
                             return [4 /*yield*/, component.canDeactivate()];
                         case 2:
                             canLeave = _a.sent();
-                            // component is happy to leave but we need to check if it's left an interaction
-                            // open.  If so we close and stay where we are.
-                            if (canLeave && this.interactionContext.isActive()) {
-                                canLeave = false;
+                            _a.label = 3;
+                        case 3: return [3 /*break*/, 5];
+                        case 4:
+                            // this is a parameter change.
+                            if (this.interactionContext.isActive()) {
                                 console.log("cancelling", { activity: this.interactionContext.currentActivity });
                                 this.interactionContext.currentActivity.cancel(null);
+                                canLeave = false;
                             }
-                            // If we're still leaving then remember it since angular will call this method multiple
-                            // times if any route parameters are changed along the way.
+                            else {
+                                canLeave = true;
+                            }
+                            _a.label = 5;
+                        case 5:
                             if (canLeave) {
+                                // We'll get called multiple times if there's any parameter sanitisation so
+                                // we remember the acceptance for the duration of the current routing session.
                                 self_1.placeRouter.navigationSession.rememberAcceptanceOf(component);
                             }
                             else {
@@ -5070,7 +5108,6 @@
                                 }
                             }
                             return [2 /*return*/, canLeave];
-                        case 3: return [2 /*return*/, true];
                     }
                 });
             });
@@ -5089,6 +5126,12 @@
             { type: common.Location }
         ]; };
         /** @nocollapse */ LeavePlaceGuard.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(core.ɵɵinject(router.Router), core.ɵɵinject(core.INJECTOR), core.ɵɵinject(PlaceRouter), core.ɵɵinject(InteractionContext), core.ɵɵinject(common.Location)); }, token: LeavePlaceGuard, providedIn: "root" });
+        __decorate([
+            pectin.Trace(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [exports.PlaceComponent, router.ActivatedRouteSnapshot, router.RouterStateSnapshot, router.RouterStateSnapshot]),
+            __metadata("design:returntype", Promise)
+        ], LeavePlaceGuard.prototype, "canDeactivate", null);
         return LeavePlaceGuard;
     }());
     if (false) {