@coolon/angular-ui-powerups 0.0.66 → 0.0.67

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

@@ -5,7 +5,7 @@ import { MatDialog, MatButtonModule, MatDialogModule, MatTabsModule, MatProgress
 import { MatTabsModule as MatTabsModule$1 } from '@angular/material/tabs';
 import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
 import { __extends, __decorate, __metadata, __assign, __awaiter, __generator } from 'tslib';
-import { GarbageCollector, DelegatingFormValueModel, UseDelegate, ValueModel, ListModel, StoreInListModel, assert, UnaryCommand, lang, Dsl, Logger, DelegatingValueModel, MutableStream, MutableListModel, DelegatingListModel, StoreInValueModel, Binding, MutableValueModel, Guard as Guard$1, OptionsHelper, ValueHolder } from '@coolon/pectin';
+import { GarbageCollector, DelegatingFormValueModel, UseDelegate, ValueModel, ListModel, StoreInListModel, assert, UnaryCommand, lang, Dsl, Logger, DelegatingValueModel, MutableStream, MutableListModel, DelegatingListModel, StoreInValueModel, Binding, MutableValueModel, Guard as Guard$1, OptionsHelper, ValueHolder, Trace } from '@coolon/pectin';
 import { PortalModule } from '@angular/cdk/portal';
 import ___default, { last, isNil } from 'lodash';
 import { assert as assert$1, Klass, Opts } from '@coolon/typescript-utilities';
@@ -14,7 +14,7 @@ import { v1 } from 'uuid';
 import { MatIconModule } from '@angular/material/icon';
 import { MatListModule } from '@angular/material/list';
 import { MatTooltipModule } from '@angular/material/tooltip';
-import { Router, NavigationStart, NavigationEnd, NavigationError, RouterModule } from '@angular/router';
+import { Router, NavigationStart, NavigationEnd, NavigationError, RouterModule, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
 import { Memoize as Memoize$1 } from '@typescript-plus/fast-memoize-decorator/dist/src';
 import { Memoize } from '@typescript-plus/fast-memoize-decorator';
 import 'reflect-metadata';
@@ -2739,6 +2739,7 @@ var PlaceRouter = /** @class */ (function () {
     function PlaceRouter(router, angularLocation) {
         var _this = this;
         this.router = router;
+        this.angularLocation = angularLocation;
         this._navigationSession = new MutableValueModel();
         angularLocation.onUrlChange((/**
          * @param {?} url
@@ -2881,6 +2882,8 @@ if (false) {
      * @private
      */
     PlaceRouter.prototype.router;
+    /** @type {?} */
+    PlaceRouter.prototype.angularLocation;
 }
 
 /**
@@ -4837,6 +4840,22 @@ var LeavePlaceGuard = /** @class */ (function () {
         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
@@ -4859,23 +4878,42 @@ var LeavePlaceGuard = /** @class */ (function () {
                     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 {
@@ -4887,7 +4925,6 @@ var LeavePlaceGuard = /** @class */ (function () {
                             }
                         }
                         return [2 /*return*/, canLeave];
-                    case 3: return [2 /*return*/, true];
                 }
             });
         });
@@ -4906,6 +4943,12 @@ var LeavePlaceGuard = /** @class */ (function () {
         { type: Location }
     ]; };
     /** @nocollapse */ LeavePlaceGuard.ngInjectableDef = ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(ɵɵinject(Router), ɵɵinject(INJECTOR), ɵɵinject(PlaceRouter), ɵɵinject(InteractionContext), ɵɵinject(Location)); }, token: LeavePlaceGuard, providedIn: "root" });
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [PlaceComponent, ActivatedRouteSnapshot, RouterStateSnapshot, RouterStateSnapshot]),
+        __metadata("design:returntype", Promise)
+    ], LeavePlaceGuard.prototype, "canDeactivate", null);
     return LeavePlaceGuard;
 }());
 if (false) {