@coolon/angular-ui-powerups 0.0.96 → 0.0.98

package/esm5/lib/place/guards/interaction.guard.js

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Location } from '@angular/common';
+import { Injectable, Injector } from '@angular/core';
+import { Router } from '@angular/router';
+import { ModalInteractionService } from '../../interaction/services/modal-interaction.service';
+import { PlaceRouter } from '../place-router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../place-router";
+import * as i3 from "@angular/common";
+import * as i4 from "../../interaction/services/modal-interaction.service";
+var InteractionGuard = /** @class */ (function () {
+    function InteractionGuard(router, injector, placeRouter, angularLocation, modalInteractionService) {
+        this.router = router;
+        this.injector = injector;
+        this.placeRouter = placeRouter;
+        this.angularLocation = angularLocation;
+        this.modalInteractionService = modalInteractionService;
+    }
+    /**
+     * @param {?} route
+     * @param {?} state
+     * @return {?}
+     */
+    InteractionGuard.prototype.canActivate = /**
+     * @param {?} route
+     * @param {?} state
+     * @return {?}
+     */
+    function (route, state) {
+        /** @type {?} */
+        var url = this.router.parseUrl(state.url);
+        if (!this.modalInteractionService.isActive() && url.root.children[PlaceRouter.INTERACTION_ROUTER_OUTLET]) {
+            // 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.
+            delete url.root.children[PlaceRouter.INTERACTION_ROUTER_OUTLET];
+            return url;
+        }
+        else {
+            return true;
+        }
+    };
+    /**
+     * @param {?} component
+     * @param {?} currentRoute
+     * @param {?} currentState
+     * @param {?=} nextState
+     * @return {?}
+     */
+    InteractionGuard.prototype.canDeactivate = /**
+     * @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 popstateReturnUrl, activity;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        popstateReturnUrl = this.placeRouter.navigationSession.startingUrl;
+                        if (!this.modalInteractionService.isActive()) return [3 /*break*/, 2];
+                        // The activity is still active so the route change was triggered by the back button.
+                        return [4 /*yield*/, this.modalInteractionService.getCurrentActivity()];
+                    case 1:
+                        activity = _a.sent();
+                        activity.cancel();
+                        // See ModalInteractionSession#onStart() for the url updating.
+                        return [2 /*return*/, false];
+                    case 2: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    InteractionGuard.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    InteractionGuard.ctorParameters = function () { return [
+        { type: Router },
+        { type: Injector },
+        { type: PlaceRouter },
+        { type: Location },
+        { type: ModalInteractionService }
+    ]; };
+    /** @nocollapse */ InteractionGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function InteractionGuard_Factory() { return new InteractionGuard(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i2.PlaceRouter), i0.ɵɵinject(i3.Location), i0.ɵɵinject(i4.ModalInteractionService)); }, token: InteractionGuard, providedIn: "root" });
+    return InteractionGuard;
+}());
+export { InteractionGuard };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionGuard.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionGuard.prototype.injector;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionGuard.prototype.placeRouter;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionGuard.prototype.angularLocation;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionGuard.prototype.modalInteractionService;
+}
+//# sourceMappingURL=data:application/json;base64,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