@coolon/angular-ui-powerups 0.0.126 → 0.0.128

package/esm5/lib/place/navigation/session/event-cleanup/wait-until-link-triggered-interaction-cancelation-finishes.js

@@ -0,0 +1,221 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+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.
+ *
+ * If the link was the same as the previous history location (i.e. they've gone back via a link rather than clicking back) then the sequence is:
+ *
+ * -> Idle -> NavigationTransition
+ * -> confirm dialog shown.
+ * -> click back
+ * -> NavigationCancel -> clickedLinkUrl === cancel.url
+ * -> NavigationEnd
+ *
+ * Otherwise if the link is different from teh history location then the sequence is:
+ *
+ * -> Idle -> NavigationTransition
+ * -> confirm dialog shown.
+ * -> click back
+ * -> NavigationCancel -> clickedLinkUrl !== cancel.url
+ * -> NavigationEnd
+ * -> PopState
+ * -> NavigationCancel
+ */
+var /**
+ * 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.
+ *
+ * If the link was the same as the previous history location (i.e. they've gone back via a link rather than clicking back) then the sequence is:
+ *
+ * -> Idle -> NavigationTransition
+ * -> confirm dialog shown.
+ * -> click back
+ * -> NavigationCancel -> clickedLinkUrl === cancel.url
+ * -> NavigationEnd
+ *
+ * Otherwise if the link is different from teh history location then the sequence is:
+ *
+ * -> Idle -> NavigationTransition
+ * -> confirm dialog shown.
+ * -> click back
+ * -> NavigationCancel -> clickedLinkUrl !== cancel.url
+ * -> NavigationEnd
+ * -> PopState
+ * -> NavigationCancel
+ */
+WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish = /** @class */ (function (_super) {
+    tslib_1.__extends(WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish, _super);
+    function WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish(context, startingUrl, clickedLinkUrl) {
+        var _this = _super.call(this, context, startingUrl) || this;
+        _this.clickedLinkUrl = clickedLinkUrl;
+        _this.isPopState = false;
+        _this.clickedLinkMatchedBackButtonUrl = false;
+        _this.debugPropertyKeys = ['idle', 'startingUrl', 'clickedLinkUrl', 'firstCancelEventUrl', 'clickedLinkMatchedBackButtonUrl', 'popStateEventUrl'];
+        return _this;
+    }
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.onRouterStarted = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.ignore(event);
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.onRouterCancelled = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        // TODO: should really split this into two sub states in the first cancel event.
+        if (!this.firstCancelEventUrl) {
+            this.firstCancelEventUrl = event.url;
+            this.clickedLinkMatchedBackButtonUrl = event.url === this.clickedLinkUrl;
+            this.ignore(event);
+        }
+        else {
+            // we wait for our popped state to come in.
+            if (!this.clickedLinkMatchedBackButtonUrl && this.popStateEventUrl) {
+                this.finaliseRouting();
+            }
+        }
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.onRouterEnd = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        if (this.clickedLinkMatchedBackButtonUrl) {
+            this.finaliseRouting();
+        }
+        else {
+            this.ignore(event);
+        }
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.onRouterError = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.ignore(event);
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.onPopState = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.popStateEventUrl = event.url;
+        this.ignore(event);
+    };
+    /**
+     * @return {?}
+     */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.finaliseRouting = /**
+     * @return {?}
+     */
+    function () {
+        this.repairBrowserHistoryAndUrlAfterGuardCancellation(this.clickedLinkUrl, this.startingUrl);
+        return this.context.finishRoutingSession();
+    };
+    /**
+     * @param {?} component
+     * @param {?} currentUrl
+     * @param {?} nextUrl
+     * @return {?}
+     */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.canDeactivatePlace = /**
+     * @param {?} component
+     * @param {?} currentUrl
+     * @param {?} nextUrl
+     * @return {?}
+     */
+    function (component, currentUrl, nextUrl) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, false];
+            });
+        });
+    };
+    return WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish;
+}(EventCleanUpSession));
+/**
+ * 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.
+ *
+ * If the link was the same as the previous history location (i.e. they've gone back via a link rather than clicking back) then the sequence is:
+ *
+ * -> Idle -> NavigationTransition
+ * -> confirm dialog shown.
+ * -> click back
+ * -> NavigationCancel -> clickedLinkUrl === cancel.url
+ * -> NavigationEnd
+ *
+ * Otherwise if the link is different from teh history location then the sequence is:
+ *
+ * -> Idle -> NavigationTransition
+ * -> confirm dialog shown.
+ * -> click back
+ * -> NavigationCancel -> clickedLinkUrl !== cancel.url
+ * -> NavigationEnd
+ * -> PopState
+ * -> NavigationCancel
+ */
+export { WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish };
+if (false) {
+    /** @type {?} */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.isPopState;
+    /** @type {?} */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.firstCancelEventUrl;
+    /** @type {?} */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.popStateEventUrl;
+    /** @type {?} */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.clickedLinkMatchedBackButtonUrl;
+    /** @type {?} */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.debugPropertyKeys;
+    /** @type {?} */
+    WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish.prototype.clickedLinkUrl;
+}
+//# sourceMappingURL=wait-until-link-triggered-interaction-cancelation-finishes.js.map

package/esm5/lib/place/navigation/session/event-cleanup/wait-until-link-triggered-interaction-cancelation-finishes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-until-link-triggered-interaction-cancelation-finishes.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/navigation/session/event-cleanup/wait-until-link-triggered-interaction-cancelation-finishes.ts"],"names":[],"mappings":";;;;;AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;;;;;;AAyB/D;;;;;;;;;;;;;;;;;;;;;;;IAAyF,+FAAmB;IAQ1G,6EAAY,OAA0B,EAC1B,WAAmB,EACV,cAAsB;QAF3C,YAGE,kBAAM,OAAO,EAAE,WAAW,CAAC,SAC5B;QAFoB,oBAAc,GAAd,cAAc,CAAQ;QARlC,gBAAU,GAAG,KAAK,CAAC;QAG5B,qCAA+B,GAAG,KAAK,CAAC;QACxC,uBAAiB,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,kBAAkB,CAAC,CAAC;;IAM5I,CAAC;IAED,WAAW;;;;;;IACX,6FAAe;;;;;;IAAf,UAAgB,KAAsB;QACpC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;IAED,WAAW;;;;;;IACX,+FAAiB;;;;;;IAAjB,UAAkB,KAAuB;QACvC,gFAAgF;QAChF,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE;YAC7B,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC,GAAG,CAAC;YACrC,IAAI,CAAC,+BAA+B,GAAG,KAAK,CAAC,GAAG,KAAK,IAAI,CAAC,cAAc,CAAC;YACzE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;SACpB;aAAM;YACL,2CAA2C;YAC3C,IAAI,CAAC,IAAI,CAAC,+BAA+B,IAAI,IAAI,CAAC,gBAAgB,EAAE;gBAClE,IAAI,CAAC,eAAe,EAAE,CAAC;aACxB;SACF;IACH,CAAC;IAED,WAAW;;;;;;IACX,yFAAW;;;;;;IAAX,UAAY,KAAoB;QAC9B,IAAI,IAAI,CAAC,+BAA+B,EAAE;YACxC,IAAI,CAAC,eAAe,EAAE,CAAC;SACxB;aAAM;YACL,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;SACpB;IACH,CAAC;IAED,WAAW;;;;;;IACX,2FAAa;;;;;;IAAb,UAAc,KAAsB;QAClC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;IAED,WAAW;;;;;;IACX,wFAAU;;;;;;IAAV,UAAW,KAAsB;QAC/B,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,GAAG,CAAC;QAClC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;;;;IAED,6FAAe;;;IAAf;QACE,IAAI,CAAC,gDAAgD,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC7F,OAAO,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,CAAC;IAC7C,CAAC;;;;;;;IAEK,gGAAkB;;;;;;IAAxB,UAAyB,SAAyB,EAAE,UAAuB,EAAE,OAAoB;;;gBAC/F,sBAAO,KAAK,EAAC;;;KACd;IACH,0EAAC;AAAD,CAAC,AA9DD,CAAyF,mBAAmB,GA8D3G;;;;;;;;;;;;;;;;;;;;;;;;;;IA5DC,yFAA4B;;IAC5B,kGAA4B;;IAC5B,+FAAyB;;IACzB,8GAAwC;;IACxC,gGAA4I;;IAIhI,6FAA+B","sourcesContent":["import { NavigationCancel, NavigationEnd, NavigationError, NavigationStart } from '@angular/router';\nimport { Logger, Trace } from '@coolon/pectin';\nimport { PlaceComponent } from '../../../place-component';\nimport { UrlSnapshot } from '../../../url-snapshot';\nimport { EventCleanUpSession } from './event-clean-up-session';\nimport { NavigationContext } from '../navigation-context';\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 * If the link was the same as the previous history location (i.e. they've gone back via a link rather than clicking back) then the sequence is:\n *\n * -> Idle -> NavigationTransition\n * -> confirm dialog shown.\n * -> click back\n * -> NavigationCancel -> clickedLinkUrl === cancel.url\n * -> NavigationEnd\n *\n * Otherwise if the link is different from teh history location then the sequence is:\n *\n * -> Idle -> NavigationTransition\n * -> confirm dialog shown.\n * -> click back\n * -> NavigationCancel -> clickedLinkUrl !== cancel.url\n * -> NavigationEnd\n * -> PopState\n * -> NavigationCancel\n */\nexport class WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish 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    // TODO: should really split this into two sub states in the first cancel event.\n    if (!this.firstCancelEventUrl) {\n      this.firstCancelEventUrl = event.url;\n      this.clickedLinkMatchedBackButtonUrl = event.url === this.clickedLinkUrl;\n      this.ignore(event);\n    } else {\n      // we wait for our popped state to come in.\n      if (!this.clickedLinkMatchedBackButtonUrl && this.popStateEventUrl) {\n        this.finaliseRouting();\n      }\n    }\n  }\n\n  // @Trace()\n  onRouterEnd(event: NavigationEnd): void {\n    if (this.clickedLinkMatchedBackButtonUrl) {\n      this.finaliseRouting();\n    } else {\n      this.ignore(event);\n    }\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  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"]}

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

@@ -0,0 +1,186 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+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
+ */
+var /**
+ * 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
+ */
+WaitUntilPopStateDuringCanDeactivateInteractionFinishes = /** @class */ (function (_super) {
+    tslib_1.__extends(WaitUntilPopStateDuringCanDeactivateInteractionFinishes, _super);
+    function WaitUntilPopStateDuringCanDeactivateInteractionFinishes(context, startingUrl, locationChangeTriggerUrl, poppedHistoryUrl) {
+        var _this = _super.call(this, context, startingUrl) || this;
+        _this.locationChangeTriggerUrl = locationChangeTriggerUrl;
+        _this.poppedHistoryUrl = poppedHistoryUrl;
+        _this.isPopState = false;
+        _this.firstCancelHandled = false;
+        _this.popStateHandled = false;
+        _this.debugPropertyKeys = ['idle', 'startingUrl', 'poppedHistoryUrl', 'locationChangeTriggerUrl', 'popStateEventUrl', 'firstCancelHandled', 'popStateHandled'];
+        return _this;
+    }
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.onRouterStarted = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.ignore(event);
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.onRouterCancelled = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        if (!this.firstCancelHandled) {
+            this.firstCancelHandled = true;
+            this.parentPageUrl = event.url;
+            this.ignore(event);
+        }
+        else {
+            if (this.popStateHandled) {
+                /** @type {?} */
+                var 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()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.onRouterEnd = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.ignore(event);
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.onRouterError = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        void this.ignore(event);
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.onPopState = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.popStateHandled = true;
+        this.popStateEventUrl = event.url;
+        this.ignore(event);
+    };
+    /**
+     * @param {?} component
+     * @param {?} currentUrl
+     * @param {?} nextUrl
+     * @return {?}
+     */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.canDeactivatePlace = /**
+     * @param {?} component
+     * @param {?} currentUrl
+     * @param {?} nextUrl
+     * @return {?}
+     */
+    function (component, currentUrl, nextUrl) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, false];
+            });
+        });
+    };
+    return WaitUntilPopStateDuringCanDeactivateInteractionFinishes;
+}(EventCleanUpSession));
+/**
+ * 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 { WaitUntilPopStateDuringCanDeactivateInteractionFinishes };
+if (false) {
+    /** @type {?} */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.isPopState;
+    /** @type {?} */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.firstCancelHandled;
+    /** @type {?} */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.popStateHandled;
+    /** @type {?} */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.popStateEventUrl;
+    /** @type {?} */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.debugPropertyKeys;
+    /**
+     * @type {?}
+     * @private
+     */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.parentPageUrl;
+    /** @type {?} */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.locationChangeTriggerUrl;
+    /** @type {?} */
+    WaitUntilPopStateDuringCanDeactivateInteractionFinishes.prototype.poppedHistoryUrl;
+}
+//# sourceMappingURL=wait-until-popstate-during-can-deactivate-transition-finishes.js.map

package/esm5/lib/place/navigation/session/event-cleanup/wait-until-popstate-during-can-deactivate-transition-finishes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-until-popstate-during-can-deactivate-transition-finishes.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/navigation/session/event-cleanup/wait-until-popstate-during-can-deactivate-transition-finishes.ts"],"names":[],"mappings":";;;;;AAKA,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;;;;;;;;;;;;AAa/D;;;;;;;;;;;;IAA6E,mFAAmB;IAS9F,iEAAY,OAA0B,EAC1B,WAAmB,EACV,wBAAgC,EAChC,gBAAwB;QAH7C,YAIE,kBAAM,OAAO,EAAE,WAAW,CAAC,SAC5B;QAHoB,8BAAwB,GAAxB,wBAAwB,CAAQ;QAChC,sBAAgB,GAAhB,gBAAgB,CAAQ;QAVpC,gBAAU,GAAG,KAAK,CAAC;QAC5B,wBAAkB,GAAG,KAAK,CAAC;QAC3B,qBAAe,GAAG,KAAK,CAAC;QAExB,uBAAiB,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,kBAAkB,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,iBAAiB,CAAC,CAAC;;IAQzJ,CAAC;IAED,WAAW;;;;;;IACX,iFAAe;;;;;;IAAf,UAAgB,KAAsB;QACpC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;IAED,WAAW;;;;;;IACX,mFAAiB;;;;;;IAAjB,UAAkB,KAAuB;QACvC,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE;YAC5B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;YAC/B,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,GAAG,CAAC;YAC/B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;SACpB;aAAM;YACL,IAAI,IAAI,CAAC,eAAe,EAAE;;oBAClB,kBAAkB,GAAG,KAAK,CAAC,GAAG;gBACpC,IAAI,CAAC,gDAAgD,CAAC,kBAAkB,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;gBAC9F,+FAA+F;gBAC/F,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,WAAW,EAAE,EAAC,cAAc,EAAE,KAAK,EAAC,CAAC,CAAC;gBACrE,OAAO,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,CAAC;aAC5C;SACF;IACH,CAAC;IAED,WAAW;;;;;;IACX,6EAAW;;;;;;IAAX,UAAY,KAAoB;QAC9B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;IAED,WAAW;;;;;;IACX,+EAAa;;;;;;IAAb,UAAc,KAAsB;QAClC,KAAK,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;IAED,WAAW;;;;;;IACX,4EAAU;;;;;;IAAV,UAAW,KAAsB;QAC/B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,GAAG,CAAC;QAClC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;;;;;;;IAEK,oFAAkB;;;;;;IAAxB,UAAyB,SAAyB,EAAE,UAAuB,EAAE,OAAoB;;;gBAC/F,sBAAO,KAAK,EAAC;;;KACd;IACH,8DAAC;AAAD,CAAC,AA1DD,CAA6E,mBAAmB,GA0D/F;;;;;;;;;;;;;;;IAxDC,6EAA4B;;IAC5B,qFAA2B;;IAC3B,kFAAwB;;IACxB,mFAAyB;;IACzB,oFAAyJ;;;;;IACzJ,gFAA8B;;IAIlB,2FAAyC;;IACzC,mFAAiC","sourcesContent":["import { NavigationCancel, NavigationEnd, NavigationError, NavigationStart } from '@angular/router';\nimport { Logger, 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 pop state triggered and interaction and the user clickeb back a second time to cancel it.\n * The sequence of routing events/state transitions is as follows.\n * -> Idle -> PopStateTransition (poppedHistoryUrl == page to go to, startingUrl = page to stay on )\n * -> confirm dialog shown.\n * -> click back\n * -> PopStateTransition -> CancelledDuringBackButtonNavigationInteraction(trigger url is the page before the popped history url)\n * -> NavigationCancel (for the previous back)\n * -> PopState\n * -> NavigationCancel\n */\nexport class WaitUntilPopStateDuringCanDeactivateInteractionFinishes extends EventCleanUpSession {\n\n  readonly isPopState = false;\n  firstCancelHandled = false;\n  popStateHandled = false;\n  popStateEventUrl: string;\n  debugPropertyKeys = ['idle', 'startingUrl', 'poppedHistoryUrl', 'locationChangeTriggerUrl', 'popStateEventUrl', 'firstCancelHandled', 'popStateHandled'];\n  private parentPageUrl: string;\n\n  constructor(context: NavigationContext,\n              startingUrl: string,\n              readonly locationChangeTriggerUrl: string,\n              readonly poppedHistoryUrl: 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 (!this.firstCancelHandled) {\n      this.firstCancelHandled = true;\n      this.parentPageUrl = event.url;\n      this.ignore(event);\n    } else {\n      if (this.popStateHandled) {\n        const grandParentPageUrl = event.url;\n        this.repairBrowserHistoryAndUrlAfterGuardCancellation(grandParentPageUrl, this.parentPageUrl);\n        // we've had one more back click than normal so we need to add our initial url back in as well.\n        this.resetBrowserLocation(this.startingUrl, {replaceCurrent: false});\n        return this.context.finishRoutingSession();\n      }\n    }\n  }\n\n  // @Trace()\n  onRouterEnd(event: NavigationEnd): void {\n    this.ignore(event);\n  }\n\n  // @Trace()\n  onRouterError(event: NavigationError): void {\n    void this.ignore(event);\n  }\n\n  // @Trace()\n  onPopState(event: NavigationStart): void {\n    this.popStateHandled = true;\n    this.popStateEventUrl = event.url;\n    this.ignore(event);\n  }\n\n  async canDeactivatePlace(component: PlaceComponent, currentUrl: UrlSnapshot, nextUrl: UrlSnapshot): Promise<boolean | UrlSnapshot> {\n    return false;\n  }\n}\n"]}

package/esm5/lib/place/navigation/session/interactions/navigating-during-interaction.js

@@ -0,0 +1,107 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { NavigationSession } from '../navigation-session';
+import { WaitUntilLeavingInteractionTransitionCancelled } from '../event-cleanup/wait-until-leaving-interaction-transition-cancelled';
+import { SynchroniseInteractionContextIdsWithRoute } from './synchronise-interaction-context-ids-with-route';
+/**
+ * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
+ * happily ignore interaction contexts.
+ * NOTE: This state is activated when ever an interaction is started.  It might be better to split it into
+ *       different states for different scenarios, e.g. starting model, starting model during route guard etc.
+ */
+var /**
+ * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
+ * happily ignore interaction contexts.
+ * NOTE: This state is activated when ever an interaction is started.  It might be better to split it into
+ *       different states for different scenarios, e.g. starting model, starting model during route guard etc.
+ */
+NavigatingDuringInteraction = /** @class */ (function (_super) {
+    tslib_1.__extends(NavigatingDuringInteraction, _super);
+    function NavigatingDuringInteraction() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.isPopState = false;
+        return _this;
+    }
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    NavigatingDuringInteraction.prototype.onRouterCancelled = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.context.finishRoutingSession();
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    NavigatingDuringInteraction.prototype.onRouterError = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        // navigation was aborted.
+        this.context.finishRoutingSession();
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    NavigatingDuringInteraction.prototype.onRouterEnd = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        if (this.context.routerInteractionAdapter.isActive()) {
+            this.context.transitionTo(new SynchroniseInteractionContextIdsWithRoute(this.context, this.startingUrl, false));
+        }
+        else {
+            this.context.finishRoutingSession(this.getVisits());
+        }
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} locationTriggerUrl
+     * @return {?}
+     */
+    NavigatingDuringInteraction.prototype.handleCanDeactivateCancelledEventScenario = 
+    // @Trace()
+    /**
+     * @param {?} locationTriggerUrl
+     * @return {?}
+     */
+    function (locationTriggerUrl) {
+        this.context.transitionTo(new WaitUntilLeavingInteractionTransitionCancelled(this.context, this.startingUrl, locationTriggerUrl));
+    };
+    return NavigatingDuringInteraction;
+}(NavigationSession));
+/**
+ * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
+ * happily ignore interaction contexts.
+ * NOTE: This state is activated when ever an interaction is started.  It might be better to split it into
+ *       different states for different scenarios, e.g. starting model, starting model during route guard etc.
+ */
+export { NavigatingDuringInteraction };
+if (false) {
+    /** @type {?} */
+    NavigatingDuringInteraction.prototype.isPopState;
+}
+//# sourceMappingURL=navigating-during-interaction.js.map

package/esm5/lib/place/navigation/session/interactions/navigating-during-interaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigating-during-interaction.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/navigation/session/interactions/navigating-during-interaction.ts"],"names":[],"mappings":";;;;;AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,8CAA8C,EAAE,MAAM,sEAAsE,CAAC;AACtI,OAAO,EAAE,yCAAyC,EAAE,MAAM,kDAAkD,CAAC;;;;;;;AAQ7G;;;;;;;IAAiD,uDAAiB;IAAlE;QAAA,qEA8BC;QA7BU,gBAAU,GAAG,KAAK,CAAC;;IA6B9B,CAAC;IA3BC,WAAW;;;;;;IACX,uDAAiB;;;;;;IAAjB,UAAkB,KAAuB;QACvC,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,CAAC;IACtC,CAAC;IAED,WAAW;;;;;;IACX,mDAAa;;;;;;IAAb,UAAc,KAAsB;QAClC,0BAA0B;QAC1B,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,CAAC;IACtC,CAAC;IAED,WAAW;;;;;;IACX,iDAAW;;;;;;IAAX,UAAY,KAAoB;QAC9B,IAAI,IAAI,CAAC,OAAO,CAAC,wBAAwB,CAAC,QAAQ,EAAE,EAAE;YACpD,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,yCAAyC,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAA;SAChH;aAAM;YACL,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;SACrD;IACH,CAAC;IAED,WAAW;;;;;;IACX,+EAAyC;;;;;;IAAzC,UAA0C,kBAA0B;QAClE,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,8CAA8C,CAAC,IAAI,CAAC,OAAO,EACvF,IAAI,CAAC,WAAW,EAChB,kBAAkB,CAAC,CAAC,CAAC;IACzB,CAAC;IAEH,kCAAC;AAAD,CAAC,AA9BD,CAAiD,iBAAiB,GA8BjE;;;;;;;;;;IA7BC,iDAA4B","sourcesContent":["import { NavigationCancel, NavigationEnd, NavigationError } from '@angular/router';\nimport { Trace } from '@coolon/pectin';\nimport { NavigationSession } from '../navigation-session';\n\nimport { WaitUntilLeavingInteractionTransitionCancelled } from '../event-cleanup/wait-until-leaving-interaction-transition-cancelled';\nimport { SynchroniseInteractionContextIdsWithRoute } from './synchronise-interaction-context-ids-with-route';\n\n/**\n * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can\n * happily ignore interaction contexts.\n * NOTE: This state is activated when ever an interaction is started.  It might be better to split it into\n *       different states for different scenarios, e.g. starting model, starting model during route guard etc.\n */\nexport class NavigatingDuringInteraction extends NavigationSession {\n  readonly isPopState = false;\n\n  // @Trace()\n  onRouterCancelled(event: NavigationCancel): void {\n    this.context.finishRoutingSession();\n  }\n\n  // @Trace()\n  onRouterError(event: NavigationError): void {\n    // navigation was aborted.\n    this.context.finishRoutingSession();\n  }\n\n  // @Trace()\n  onRouterEnd(event: NavigationEnd): void {\n    if (this.context.routerInteractionAdapter.isActive()) {\n      this.context.transitionTo(new SynchroniseInteractionContextIdsWithRoute(this.context, this.startingUrl, false))\n    } else {\n      this.context.finishRoutingSession(this.getVisits());\n    }\n  }\n\n  // @Trace()\n  handleCanDeactivateCancelledEventScenario(locationTriggerUrl: string): void {\n    this.context.transitionTo(new WaitUntilLeavingInteractionTransitionCancelled(this.context,\n      this.startingUrl,\n      locationTriggerUrl));\n  }\n\n}\n"]}

package/esm5/lib/place/navigation/session/interactions/pop-state-during-interaction-navigation.js

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { AbstractPopStateNavigation } from '../abstract-pop-state-navigation';
+import { SynchroniseInteractionContextIdsWithRoute } from './synchronise-interaction-context-ids-with-route';
+/**
+ * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
+ * happily ignore interaction contexts.
+ */
+var /**
+ * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
+ * happily ignore interaction contexts.
+ */
+PopStateDuringInteractionNavigation = /** @class */ (function (_super) {
+    tslib_1.__extends(PopStateDuringInteractionNavigation, _super);
+    function PopStateDuringInteractionNavigation(context, startingUrl, poppedHistoryUrl) {
+        return _super.call(this, context, startingUrl, poppedHistoryUrl) || this;
+    }
+    /**
+     * Invoked when the place refuses to deactivate because of an unfinished interaction.
+     * @param event
+     */
+    // @Trace()
+    /**
+     * Invoked when the place refuses to deactivate because of an unfinished interaction.
+     * @param {?} event
+     * @return {?}
+     */
+    // @Trace()
+    PopStateDuringInteractionNavigation.prototype.onRouterCancelled = /**
+     * Invoked when the place refuses to deactivate because of an unfinished interaction.
+     * @param {?} event
+     * @return {?}
+     */
+    // @Trace()
+    function (event) {
+        this.repairBrowserHistoryAndUrlAfterGuardCancellation();
+        // NOTE: for now we need to wasTriggeredByPopState=false because we're resetting the url and history in the previous line.
+        this.context.transitionTo(new SynchroniseInteractionContextIdsWithRoute(this.context, this.poppedHistoryUrl, false));
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    PopStateDuringInteractionNavigation.prototype.onRouterEnd = 
+    // @Trace()
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        // this.context.transitionTo(new SynchroniseInteractionContextIdsWithRoute(this.context, this.poppedHistoryUrl, false));
+        this.context.finishRoutingSession();
+    };
+    /**
+     * @param {?} newUrl
+     * @return {?}
+     */
+    PopStateDuringInteractionNavigation.prototype.handleCanDeactivateCancelledEventScenario = /**
+     * @param {?} newUrl
+     * @return {?}
+     */
+    function (newUrl) {
+        this.illegalTransition('Leaving interaction after pop-state should\'t block so should never see a back button click');
+    };
+    return PopStateDuringInteractionNavigation;
+}(AbstractPopStateNavigation));
+/**
+ * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
+ * happily ignore interaction contexts.
+ */
+export { PopStateDuringInteractionNavigation };
+//# sourceMappingURL=pop-state-during-interaction-navigation.js.map

package/esm5/lib/place/navigation/session/interactions/pop-state-during-interaction-navigation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pop-state-during-interaction-navigation.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/navigation/session/interactions/pop-state-during-interaction-navigation.ts"],"names":[],"mappings":";;;;;AAEA,OAAO,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAC;AAE9E,OAAO,EAAE,yCAAyC,EAAE,MAAM,kDAAkD,CAAC;;;;;AAM7G;;;;;IAAyD,+DAA0B;IAEjF,6CAAY,OAA0B,EAAE,WAAmB,EAAE,gBAAwB;eACnF,kBAAM,OAAO,EAAE,WAAW,EAAE,gBAAgB,CAAC;IAC/C,CAAC;IAED;;;OAGG;IACH,WAAW;;;;;;;IACX,+DAAiB;;;;;;IAAjB,UAAkB,KAAuB;QACvC,IAAI,CAAC,gDAAgD,EAAE,CAAC;QACxD,0HAA0H;QAC1H,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,yCAAyC,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC,CAAC;IACvH,CAAC;IAED,WAAW;;;;;;IACX,yDAAW;;;;;;IAAX,UAAY,KAAoB;QAC9B,wHAAwH;QACxH,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,CAAC;IACtC,CAAC;;;;;IAED,uFAAyC;;;;IAAzC,UAA0C,MAAc;QACtD,IAAI,CAAC,iBAAiB,CAAC,6FAA6F,CAAC,CAAC;IACxH,CAAC;IAEH,0CAAC;AAAD,CAAC,AA3BD,CAAyD,0BAA0B,GA2BlF","sourcesContent":["import { NavigationCancel, NavigationEnd } from '@angular/router';\nimport { Trace } from '@coolon/pectin';\nimport { AbstractPopStateNavigation } from '../abstract-pop-state-navigation';\nimport { NavigationContext } from '../navigation-context';\nimport { SynchroniseInteractionContextIdsWithRoute } from './synchronise-interaction-context-ids-with-route';\n\n/**\n * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can\n * happily ignore interaction contexts.\n */\nexport class PopStateDuringInteractionNavigation extends AbstractPopStateNavigation {\n\n  constructor(context: NavigationContext, startingUrl: string, poppedHistoryUrl: string) {\n    super(context, startingUrl, poppedHistoryUrl);\n  }\n\n  /**\n   * Invoked when the place refuses to deactivate because of an unfinished interaction.\n   * @param event\n   */\n  // @Trace()\n  onRouterCancelled(event: NavigationCancel): void {\n    this.repairBrowserHistoryAndUrlAfterGuardCancellation();\n    // NOTE: for now we need to wasTriggeredByPopState=false because we're resetting the url and history in the previous line.\n    this.context.transitionTo(new SynchroniseInteractionContextIdsWithRoute(this.context, this.poppedHistoryUrl, false));\n  }\n\n  // @Trace()\n  onRouterEnd(event: NavigationEnd): void {\n    // this.context.transitionTo(new SynchroniseInteractionContextIdsWithRoute(this.context, this.poppedHistoryUrl, false));\n    this.context.finishRoutingSession();\n  }\n\n  handleCanDeactivateCancelledEventScenario(newUrl: string): void {\n    this.illegalTransition('Leaving interaction after pop-state should\\'t block so should never see a back button click');\n  }\n\n}\n"]}