@coolon/angular-ui-powerups 0.0.106 → 0.0.108

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

@@ -7,7 +7,7 @@ import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
 import { GarbageCollector, DelegatingValueModel, assert, UnaryCommand, lang, Dsl, Logger, DelegatingFormValueModel, UseDelegate, ValueModel, ListModel, StoreInListModel, DelegatingListModel, Deferred, MutableStream, MutableValueModel, MutableListModel, Binding, Trace, Guard, StoreInValueModel, Command, OptionsHelper, ValueHolder } from '@coolon/pectin';
 import { __decorate, __metadata, __awaiter } from 'tslib';
 import { PortalModule } from '@angular/cdk/portal';
-import { RouterModule, NavigationStart, NavigationCancel, UrlSegment, NavigationEnd, NavigationError, Router, UrlSerializer } from '@angular/router';
+import { RouterModule, NavigationStart, NavigationCancel, NavigationError, NavigationEnd, UrlSegment, Router, UrlSerializer } from '@angular/router';
 import { assert as assert$1, Opts, Klass } from '@coolon/typescript-utilities';
 import { MatIconModule } from '@angular/material/icon';
 import { MatListModule } from '@angular/material/list';
@@ -2963,7 +2963,7 @@ class PlaceComponentDeactivationHandler {
             // 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}`);
+                // console.log(`creating deactivate promise for -> ${this.component.constructor.name}`);
                 this.canDeactivatePromise = this.canDeactivateComponent(currentUrl, nextState);
             }
             return this.canDeactivatePromise;
@@ -2978,7 +2978,7 @@ class PlaceComponentDeactivationHandler {
      */
     canDeactivateComponent(currentUrl, nextState) {
         return __awaiter(this, void 0, void 0, function* () {
-            console.log(this.navigationState.toString());
+            // console.log(this.navigationState.toString());
             // 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.navigationState.isPopState) {
@@ -3534,6 +3534,7 @@ if (false) {
             navigationTransition.storeVisit(visit);
             return navigationTransition;
         }
+        // @Trace()
         /**
          * @param {?} event
          * @return {?}
@@ -3549,12 +3550,6 @@ if (false) {
             return new InteractionPopStateTransition(this.context, event.url);
         }
     }
-    __decorate([
-        Trace(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [NavigationStart]),
-        __metadata("design:returntype", NavigationState)
-    ], IdleDuringInteraction.prototype, "onRouterStarted", null);
     __decorate([
         Trace(),
         __metadata("design:type", Function),
@@ -3636,6 +3631,24 @@ if (false) {
             }
         }
     }
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [NavigationCancel]),
+        __metadata("design:returntype", NavigationState)
+    ], InteractionTransition.prototype, "onRouterCancelled", null);
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [NavigationError]),
+        __metadata("design:returntype", NavigationState)
+    ], InteractionTransition.prototype, "onRouterError", null);
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [NavigationEnd]),
+        __metadata("design:returntype", NavigationState)
+    ], InteractionTransition.prototype, "onRouterEnd", null);
     NavigationState.InteractionTransition = InteractionTransition;
     if (false) {
         /** @type {?} */
@@ -3678,6 +3691,18 @@ if (false) {
             }
         }
     }
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [NavigationCancel]),
+        __metadata("design:returntype", NavigationState)
+    ], InteractionPopStateTransition.prototype, "onRouterCancelled", null);
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [NavigationEnd]),
+        __metadata("design:returntype", NavigationState)
+    ], InteractionPopStateTransition.prototype, "onRouterEnd", null);
     NavigationState.InteractionPopStateTransition = InteractionPopStateTransition;
     if (false) {
         /** @type {?} */
@@ -3717,10 +3742,14 @@ if (false) {
          */
         onRouterCancelled(event) {
             // Depending on the state of the router and what was done we get a different
-            // sequence of events.  I.e.  If they just clicked a link we'll get a cancel
-            // with the locationChangeTriggerUrl as the final event. However the user
-            // started the initial navigation with a pop state then we'll get one of
-            // those with the locationChangeTriggerUrl but no cancel event with it.
+            // sequence of events.
+            // If the navigation change was triggered by clicking a link we'll get a cancel with the locationChangeTriggerUrl as the final event.
+            // If the navigation change was triggered with a pop state then we'll get an onPopState with the locationChangeTriggerUrl but no cancel event with it.
+            if (this.gotPopStateWithLeavingUrl && this.interactionService.isActive()) {
+                /** @type {?} */
+                const interactionIds = this.interactionService.activeInteractionContextIds.value;
+                this.resetBrowserLocation(this.placeRouter.parseUrl(this.startingUrl).updateInteractionIds(interactionIds).url);
+            }
             return this.gotPopStateWithLeavingUrl || this.locationChangeTriggerUrl === event.url ? this.createIdleState() : this.ignore(event);
         }
         /**
@@ -3869,12 +3898,10 @@ class UrlSnapshot {
     /**
      * @param {?} urlSerializer
      * @param {?} url
-     * @param {?} options
      */
-    constructor(urlSerializer, url, options) {
+    constructor(urlSerializer, url) {
         this.urlSerializer = urlSerializer;
         this.url = url;
-        this.options = options;
         this.urlTree = urlSerializer.parse(url);
     }
     /**
@@ -3898,7 +3925,7 @@ class UrlSnapshot {
         // do not use the return value, it's the items that were removed!
         segments.splice(replaceAt, visitSegments.length, ...visitSegments);
         urlTree.root.children.primary.segments = segments;
-        return new UrlSnapshot(this.urlSerializer, urlTree.toString(), this.options);
+        return new UrlSnapshot(this.urlSerializer, urlTree.toString());
     }
     /**
      * @private
@@ -3971,7 +3998,7 @@ class UrlSnapshot {
             /** @type {?} */
             const urlTree = this.urlSerializer.parse(this.url);
             urlTree.queryParams[UrlSnapshot.INTERACTION_QUERY_PARAM] = UrlSnapshot.createPathIdFor(ids);
-            return new UrlSnapshot(this.urlSerializer, urlTree.toString(), this.options);
+            return new UrlSnapshot(this.urlSerializer, urlTree.toString());
         }
     }
     // @Trace()
@@ -3984,20 +4011,7 @@ class UrlSnapshot {
         if (urlTree.queryParams && urlTree.queryParams[UrlSnapshot.INTERACTION_QUERY_PARAM]) {
             urlTree.queryParams = {}; //[UrlSnapshot.INTERACTION_ROUTER_OUTLET]
         }
-        return new UrlSnapshot(this.urlSerializer, urlTree.toString(), this.options);
-    }
-    /**
-     * @param {?} options
-     * @return {?}
-     */
-    withOptions(options) {
-        return new UrlSnapshot(this.urlSerializer, this.url, options);
-    }
-    /**
-     * @return {?}
-     */
-    getNavigationExtras() {
-        return this.options;
+        return new UrlSnapshot(this.urlSerializer, urlTree.toString());
     }
 }
 if (false) {
@@ -4007,11 +4021,6 @@ if (false) {
     UrlSnapshot.prototype.urlSerializer;
     /** @type {?} */
     UrlSnapshot.prototype.url;
-    /**
-     * @type {?}
-     * @private
-     */
-    UrlSnapshot.prototype.options;
 }
 (function (UrlSnapshot) {
     UrlSnapshot.INTERACTION_QUERY_PARAM = 'aup-interactions';
@@ -4140,7 +4149,7 @@ class PlaceRouter extends GarbageCollector {
          * @return {?}
          */
         (ids, previous) => {
-            this.syncInteractionIdsWithRouter();
+            this.syncInteractionIdsWithRouter(ids, previous);
         }), { unless: this.navigationInProgress }); // TODO: I think the exclusive interaction prevents interactions starting while it's active so we might not need this.
         // TODO: I think the exclusive interaction prevents interactions starting while it's active so we might not need this.
         /** @type {?} */
@@ -4341,7 +4350,7 @@ class PlaceRouter extends GarbageCollector {
      * @return {?}
      */
     parseUrl(url) {
-        return new UrlSnapshot(this.urlSerializer, url, {});
+        return new UrlSnapshot(this.urlSerializer, url);
     }
     /**
      * @param {?} url
@@ -4393,34 +4402,63 @@ class PlaceRouter extends GarbageCollector {
     hasActiveInteractionIds(url) {
         return this.getActiveInteractionIdsFromUrl(url).length > 0;
     }
-    // @Trace()
     /**
      * @param {?} urlSnapshot
+     * @param {?=} navigationExtras
      * @return {?}
      */
-    navigateByUrl(urlSnapshot) {
-        this.router.navigateByUrl(urlSnapshot.urlTree, urlSnapshot.getNavigationExtras());
+    navigateByUrl(urlSnapshot, navigationExtras) {
+        return this.router.navigateByUrl(urlSnapshot.urlTree, navigationExtras);
     }
-    // @Trace()
+    // TODO: Should this be moved to the navigation states?
     /**
+     * @param {?} currentIds
+     * @param {?} previous
      * @return {?}
      */
-    syncInteractionIdsWithRouter() {
+    syncInteractionIdsWithRouter(currentIds, previous) {
         assert.isFalsey(this.navigationInProgress.value); // Updating interaction routes during an existing navigation breaks all the things.
-        // Updating interaction routes during an existing navigation breaks all the things.
-        /** @type {?} */
-        const currentIds = this.interactionService.activeInteractionContextIds.value;
-        if (___default.isEqual(currentIds, this.getActiveInteractionIdsFromUrl(this.getCurrentRouterUrl()))) {
+        console.log({
+            startingActivity: currentIds.length > previous.length,
+            wasBackButton: this.navigationState.isPopState
+        });
+        if (___default.isEqual(currentIds, previous)) {
             console.log('activity ids were the same, skipping');
         }
         else {
-            if (currentIds.length < 1) {
-                // no more interactions to remove from history.
-                this.navigateByUrl(this.getCurrentRouteSnapshot().removeInteractionIds());
+            // OMG, this is nuts.
+            /** @type {?} */
+            const addingActivity = currentIds.length > previous.length;
+            /** @type {?} */
+            const isFirstActivity = addingActivity && previous.length < 1;
+            /** @type {?} */
+            const removingLastActivity = currentIds.length < 1;
+            if (addingActivity) { // we're starting a new activity, push the change to the history and update the url
+                console.log('adding activity');
+                this.navigateByUrl(this.getCurrentRouteSnapshot().updateInteractionIds(currentIds), {
+                    replaceUrl: !isFirstActivity // we don't let the history pile up
+                });
             }
             else {
-                // todo was or is...
-                this.navigateByUrl(this.getCurrentRouteSnapshot().updateInteractionIds(currentIds));
+                /** @type {?} */
+                const urlSnapshot = this.getCurrentRouteSnapshot().updateInteractionIds(currentIds);
+                if (removingLastActivity) {
+                    this.navigateByUrl(urlSnapshot, {
+                        replaceUrl: true
+                    }).then((/**
+                     * @return {?}
+                     */
+                    () => {
+                        // for some reason we need to pop the last history off the stack when leaving the
+                        // active activity state.
+                        this.angularLocation.back();
+                    }));
+                }
+                else {
+                    this.navigateByUrl(urlSnapshot, {
+                        replaceUrl: true
+                    });
+                }
             }
         }
     }
@@ -4439,6 +4477,12 @@ PlaceRouter.ctorParameters = () => [
     { type: InteractionService }
 ];
 /** @nocollapse */ PlaceRouter.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(ɵɵinject(Router), ɵɵinject(UrlSerializer), ɵɵinject(Location), ɵɵinject(PlaceHistory), ɵɵinject(InteractionService)); }, token: PlaceRouter, providedIn: "root" });
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UrlSnapshot, Object]),
+    __metadata("design:returntype", Promise)
+], PlaceRouter.prototype, "navigateByUrl", null);
 if (false) {
     /**
      * @type {?}