@coolon/angular-ui-powerups 0.0.96 → 0.0.98

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

@@ -0,0 +1,113 @@
+/**
+ * @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";
+export class InteractionGuard {
+    /**
+     * @param {?} router
+     * @param {?} injector
+     * @param {?} placeRouter
+     * @param {?} angularLocation
+     * @param {?} modalInteractionService
+     */
+    constructor(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 {?}
+     */
+    canActivate(route, state) {
+        /** @type {?} */
+        const 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 {?}
+     */
+    canDeactivate(component, currentRoute, currentState, nextState) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            /** @type {?} */
+            const popstateReturnUrl = this.placeRouter.navigationSession.startingUrl;
+            if (this.modalInteractionService.isActive()) {
+                // The activity is still active so the route change was triggered by the back button.
+                /** @type {?} */
+                const activity = yield this.modalInteractionService.getCurrentActivity();
+                activity.cancel();
+                // See ModalInteractionSession#onStart() for the url updating.
+                return false;
+            }
+            return true;
+        });
+    }
+}
+InteractionGuard.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+InteractionGuard.ctorParameters = () => [
+    { 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" });
+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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