@coolon/angular-ui-powerups 0.0.91 → 0.0.93

package/esm2015/lib/place/guards/abstract-enter-place.guard.js

@@ -0,0 +1,296 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { lang } from '@coolon/pectin';
+import { Memoize } from '@typescript-plus/fast-memoize-decorator/dist/src';
+import { Observable } from 'rxjs';
+import { PlaceComponent } from '../place-component';
+import { VisitSanitiser } from '../route/visit-sanitiser';
+import { Visit } from '../visit';
+/**
+ * @abstract
+ */
+export class AbstractEnterPlaceGuard {
+    /**
+     * @param {?} router
+     * @param {?} urlSerializer
+     * @param {?} placeRouter
+     * @param {?} placeHistory
+     * @param {?} injector
+     */
+    constructor(router, urlSerializer, placeRouter, placeHistory, injector) {
+        this.router = router;
+        this.urlSerializer = urlSerializer;
+        this.placeRouter = placeRouter;
+        this.placeHistory = placeHistory;
+        this.injector = injector;
+    }
+    // @Trace()
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    canActivate(activatedRoute, state) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return this.interceptInitialRouteOtherwise(activatedRoute, state, (/**
+             * @return {?}
+             */
+            () => {
+                return this.authorisePlaceThen(activatedRoute, state, (/**
+                 * @param {?} placeDefinition
+                 * @return {?}
+                 */
+                (placeDefinition) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    // Parse our route params.
+                    /** @type {?} */
+                    const params = new AbstractEnterPlaceGuard.ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);
+                    /** @type {?} */
+                    const parsedParams = placeDefinition.parseRouteParams(params);
+                    /** @type {?} */
+                    const initialVisit = this.placeRouter.navigationSession.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);
+                    /** @type {?} */
+                    const sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);
+                    /** @type {?} */
+                    const sanitisedVisit = yield sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams));
+                    // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters
+                    this.placeRouter.navigationSession.storeVisit(sanitisedVisit);
+                    if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {
+                        // Regenerate the url
+                        /** @type {?} */
+                        const commands = this.placeRouter.parseUrl(state).createRedirectCommandsFor(sanitisedVisit);
+                        console.log('##### Place Guard Redirect', commands);
+                        return this.router.createUrlTree(commands, {
+                            replaceUrl: true,
+                            skipLocationChange: false
+                        });
+                    }
+                    else {
+                        return true;
+                    }
+                })));
+            }));
+        });
+    }
+    /**
+     * @protected
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @param {?} canActivate
+     * @return {?}
+     */
+    authorisePlaceThen(activatedRoute, state, canActivate) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) {
+                /** @type {?} */
+                const placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);
+                /** @type {?} */
+                const authorised = placeDefinition.authenticate ? yield this.isAuthorised(activatedRoute, state) : true;
+                return authorised === true ? canActivate(placeDefinition) : authorised;
+            }
+            else {
+                return lang.illegalState(`expected component to be an instance of PlaceComponent, got ${activatedRoute.component}`);
+            }
+        });
+    }
+    /**
+     * @protected
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @param {?} canActivate
+     * @return {?}
+     */
+    interceptInitialRouteOtherwise(activatedRoute, state, canActivate) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // TODO: this all only sort of works.  Opening dialogs and clicking back multiple times breaks things.
+            // TODO: next stage is to investigate tracking dialog state in a different placeoutlet and keeping those
+            // TODO: urls out of the history.
+            if (this.placeRouter.isInitialNavigation()) {
+                // This is the very first entry into our app so we redirect to a dummy place so we can get bump our
+                // history by one.  This ensures that we can capture back button presses on the initial page without
+                // leaving our app.
+                return this.placeRouter.performInitialNavigationIntercept(activatedRoute, state);
+            }
+            else {
+                return canActivate();
+            }
+        });
+    }
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    isAuthorised(activatedRoute, state) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            /** @type {?} */
+            const authorised = this.getAuthGuard(this.injector).canActivate(activatedRoute, state);
+            return (authorised instanceof Observable) ? authorised.toPromise() : authorised;
+        });
+    }
+}
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractEnterPlaceGuard.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractEnterPlaceGuard.prototype.urlSerializer;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractEnterPlaceGuard.prototype.placeRouter;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractEnterPlaceGuard.prototype.placeHistory;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractEnterPlaceGuard.prototype.injector;
+    /**
+     * @abstract
+     * @param {?} injector
+     * @return {?}
+     */
+    AbstractEnterPlaceGuard.prototype.getAuthGuard = function (injector) { };
+}
+(function (AbstractEnterPlaceGuard) {
+    /**
+     * This a work around for the fact that an activated route with multiple segments doesn't
+     * include the segment params in the paramMap as well as each segment returns an empty
+     * param map even when `parameter`s has content.
+     */
+    class ConsolidatedParameterMap {
+        /**
+         * @param {?} paramMap
+         * @param {?} urlSegments
+         */
+        constructor(paramMap, urlSegments) {
+            this.paramMaps = [paramMap].concat((urlSegments || []).map((/**
+             * @param {?} s
+             * @return {?}
+             */
+            s => new ParamMapAdapter(s.parameters)))).filter((/**
+             * @param {?} m
+             * @return {?}
+             */
+            m => !!m)); // the activated route param map can be null
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        get(name) {
+            /** @type {?} */
+            const paramMap = this.paramMaps.find((/**
+             * @param {?} m
+             * @return {?}
+             */
+            m => m.has(name)));
+            return paramMap.get(name);
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        getAll(name) {
+            /** @type {?} */
+            const paramMap = this.paramMaps.find((/**
+             * @param {?} m
+             * @return {?}
+             */
+            m => m.has(name)));
+            return paramMap.getAll(name);
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        has(name) {
+            return !!this.paramMaps.find((/**
+             * @param {?} m
+             * @return {?}
+             */
+            m => m.has(name)));
+        }
+        /**
+         * @return {?}
+         */
+        get keys() {
+            return this.paramMaps.reduce((/**
+             * @param {?} result
+             * @param {?} params
+             * @return {?}
+             */
+            (result, params) => result.concat(params.keys)), []);
+        }
+    }
+    tslib_1.__decorate([
+        Memoize(),
+        tslib_1.__metadata("design:type", Array),
+        tslib_1.__metadata("design:paramtypes", [])
+    ], ConsolidatedParameterMap.prototype, "keys", null);
+    AbstractEnterPlaceGuard.ConsolidatedParameterMap = ConsolidatedParameterMap;
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        ConsolidatedParameterMap.prototype.paramMaps;
+    }
+    class ParamMapAdapter {
+        /**
+         * @param {?} params
+         */
+        constructor(params) {
+            this.params = params;
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        get(name) {
+            return this.params[name];
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        getAll(name) {
+            /** @type {?} */
+            const value = this.get(name);
+            return Array.isArray(value) ? value : [value];
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        has(name) {
+            return this.keys.includes(name);
+        }
+        /**
+         * @return {?}
+         */
+        get keys() {
+            return Object.keys(this.params);
+        }
+    }
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        ParamMapAdapter.prototype.params;
+    }
+})(AbstractEnterPlaceGuard || (AbstractEnterPlaceGuard = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-enter-place.guard.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/guards/abstract-enter-place.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector } from '@angular/core';\nimport {\n  ActivatedRouteSnapshot,\n  CanActivate,\n  ParamMap,\n  Router,\n  RouterStateSnapshot,\n  UrlSegment,\n  UrlSerializer,\n  UrlTree\n} from '@angular/router';\nimport { lang } from '@coolon/pectin';\nimport { Memoize } from '@typescript-plus/fast-memoize-decorator/dist/src';\nimport { Observable } from 'rxjs';\nimport { PlaceComponent } from '../place-component';\nimport { PlaceDefinition } from '../place-definition';\nimport { PlaceHistory } from '../place-history';\nimport { PlaceRouter } from '../place-router';\nimport { NoopGatewayPlace } from '../places/noop-gateway-place.component';\nimport { VisitSanitiser } from '../route/visit-sanitiser';\nimport { Visit } from '../visit';\n\n\nexport abstract class AbstractEnterPlaceGuard implements CanActivate {\n\n\n  constructor(private readonly router: Router,\n              private urlSerializer: UrlSerializer,\n              private readonly placeRouter: PlaceRouter,\n              private readonly placeHistory: PlaceHistory,\n              private readonly injector: Injector) {\n  }\n\n  // @Trace()\n  async canActivate(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree> {\n\n    return this.interceptInitialRouteOtherwise(activatedRoute, state, () => {\n\n      return this.authorisePlaceThen(activatedRoute, state, async placeDefinition => {\n\n        // Parse our route params.\n        const params = new AbstractEnterPlaceGuard.ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);\n        const parsedParams = placeDefinition.parseRouteParams(params);\n\n        const initialVisit = this.placeRouter.navigationSession.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);\n        const sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);\n        const sanitisedVisit = await sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams));\n\n        // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters\n        this.placeRouter.navigationSession.storeVisit(sanitisedVisit);\n        if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {\n          // Regenerate the url\n          const commands = this.placeRouter.parseUrl(state).createRedirectCommandsFor(sanitisedVisit);\n          console.log('##### Place Guard Redirect', commands);\n          return this.router.createUrlTree(commands, {\n            replaceUrl: true,\n            skipLocationChange: false\n          });\n        } else {\n          return true;\n        }\n      });\n\n    });\n  }\n\n  protected async authorisePlaceThen(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot, canActivate: (placeDefinition: PlaceDefinition) => Promise<boolean | UrlTree>) {\n    if (PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) {\n      const placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);\n      const authorised = placeDefinition.authenticate ? await this.isAuthorised(activatedRoute, state) : true;\n      return authorised === true ? canActivate(placeDefinition) : authorised;\n    } else {\n      return lang.illegalState(`expected component to be an instance of PlaceComponent, got ${activatedRoute.component}`);\n    }\n  }\n\n  protected async interceptInitialRouteOtherwise(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot, canActivate: () => Promise<boolean | UrlTree>) {\n    // TODO: this all only sort of works.  Opening dialogs and clicking back multiple times breaks things.\n    // TODO: next stage is to investigate tracking dialog state in a different placeoutlet and keeping those\n    // TODO: urls out of the history.\n    if (this.placeRouter.isInitialNavigation()) {\n      // This is the very first entry into our app so we redirect to a dummy place so we can get bump our\n      // history by one.  This ensures that we can capture back button presses on the initial page without\n      // leaving our app.\n      return this.placeRouter.performInitialNavigationIntercept(activatedRoute, state);\n    } else {\n      return canActivate();\n    }\n  }\n\n  async isAuthorised(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree> {\n    const authorised = this.getAuthGuard(this.injector).canActivate(activatedRoute, state);\n    return (authorised instanceof Observable) ? authorised.toPromise() : authorised;\n  }\n\n  abstract getAuthGuard(injector: Injector): CanActivate;\n}\n\nexport namespace AbstractEnterPlaceGuard {\n  /**\n   * This a work around for the fact that an activated route with multiple segments doesn't\n   * include the segment params in the paramMap as well as each segment returns an empty\n   * param map even when `parameter`s has content.\n   */\n  export class ConsolidatedParameterMap implements ParamMap {\n\n    private paramMaps: ParamMap[];\n\n    constructor(paramMap: ParamMap, urlSegments: UrlSegment[]) {\n      this.paramMaps = [paramMap].concat(\n        (urlSegments || []).map(s => new ParamMapAdapter(s.parameters))\n      ).filter(m => !!m); // the activated route param map can be null\n    }\n\n    get(name: string): string | null {\n      const paramMap = this.paramMaps.find(m => m.has(name));\n      return paramMap.get(name);\n    }\n\n    getAll(name: string): string[] {\n      const paramMap = this.paramMaps.find(m => m.has(name));\n      return paramMap.getAll(name);\n    }\n\n    has(name: string): boolean {\n      return !!this.paramMaps.find(m => m.has(name));\n    }\n\n    @Memoize()\n    get keys(): string[] {\n      return this.paramMaps.reduce((result, params) => result.concat(params.keys), []);\n    }\n  }\n\n  class ParamMapAdapter implements ParamMap {\n    constructor(private readonly params: { [p: string]: string }) {\n    }\n\n    get(name: string): string | null {\n      return this.params[name];\n    }\n\n    getAll(name: string): string[] {\n      const value = this.get(name);\n      return Array.isArray(value) ? value : [value];\n    }\n\n    has(name: string): boolean {\n      return this.keys.includes(name);\n    }\n\n    get keys(): string[] {\n      return Object.keys(this.params);\n    }\n\n  }\n}\n"]}

package/esm2015/lib/place/guards/leave-place.guard.js

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import { PlaceRouter } from '../place-router';
+import * as i0 from "@angular/core";
+import * as i1 from "../place-router";
+export class LeavePlaceGuard {
+    /**
+     * @param {?} placeRouter
+     */
+    constructor(placeRouter) {
+        this.placeRouter = placeRouter;
+    }
+    /**
+     * @param {?} component
+     * @param {?} currentRoute
+     * @param {?} currentState
+     * @param {?=} nextState
+     * @return {?}
+     */
+    canDeactivate(component, currentRoute, currentState, nextState) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return this.placeRouter.navigationSession.canDeactivate(component, this.placeRouter.parseUrl(nextState));
+        });
+    }
+}
+LeavePlaceGuard.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+LeavePlaceGuard.ctorParameters = () => [
+    { type: PlaceRouter }
+];
+/** @nocollapse */ LeavePlaceGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(i0.ɵɵinject(i1.PlaceRouter)); }, token: LeavePlaceGuard, providedIn: "root" });
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    LeavePlaceGuard.prototype.placeRouter;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/place/guards/noop-auth-guard.service.js

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NoopAuthGuard {
+    constructor() {
+    }
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    canActivate(activatedRoute, state) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+NoopAuthGuard.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+NoopAuthGuard.ctorParameters = () => [];
+/** @nocollapse */ NoopAuthGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function NoopAuthGuard_Factory() { return new NoopAuthGuard(); }, token: NoopAuthGuard, providedIn: "root" });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9vcC1hdXRoLWd1YXJkLnNlcnZpY2UuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AY29vbG9uL2FuZ3VsYXItdWktcG93ZXJ1cHMvIiwic291cmNlcyI6WyJsaWIvcGxhY2UvZ3VhcmRzL25vb3AtYXV0aC1ndWFyZC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFNM0MsTUFBTSxPQUFPLGFBQWE7SUFFeEI7SUFDQSxDQUFDOzs7Ozs7SUFFSyxXQUFXLENBQUMsY0FBc0MsRUFBRSxLQUEwQjs7WUFDbEYsT0FBTyxJQUFJLENBQUM7UUFDZCxDQUFDO0tBQUE7OztZQVZGLFVBQVUsU0FBQztnQkFDVixVQUFVLEVBQUUsTUFBTTthQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsIENhbkFjdGl2YXRlLCBSb3V0ZXJTdGF0ZVNuYXBzaG90LCBVcmxUcmVlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgTm9vcEF1dGhHdWFyZCBpbXBsZW1lbnRzIENhbkFjdGl2YXRlIHtcblxuICBjb25zdHJ1Y3RvcigpIHtcbiAgfVxuXG4gIGFzeW5jIGNhbkFjdGl2YXRlKGFjdGl2YXRlZFJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCBzdGF0ZTogUm91dGVyU3RhdGVTbmFwc2hvdCk6IFByb21pc2U8Ym9vbGVhbiB8IFVybFRyZWU+IHtcbiAgICByZXR1cm4gdHJ1ZTtcbiAgfVxufVxuIl19

package/esm2015/lib/place/index.js

@@ -22,6 +22,10 @@ export { ListPlaceNavComponent } from "./components/list-place-nav/list-place-na
 export { PlaceOutletComponent } from "./components/place-outlet/place-outlet.component";
 export { leftRightPlaceAnimation, LEFT_RIGHT_PLACE_ANIMATION } from "./components/place-outlet/route-animations";
 export { TabbedPlaceNavigationComponent } from "./components/tabbed-place-navigation/tabbed-place-navigation.component";
+export { AbstractEnterPlaceGuard } from "./guards/abstract-enter-place.guard";
+export { LeavePlaceGuard } from "./guards/leave-place.guard";
+export { NoopAuthGuard } from "./guards/noop-auth-guard.service";
+export { NoopGatewayPlace } from "./places/noop-gateway-place.component";
 export { Formatter } from "./route/formatter";
 export {} from "./route/json-types";
 export { RouteId, VisitParameter, VisitParameterList } from "./route/parameter-decorators";
@@ -29,6 +33,4 @@ export { ParameterDefinition } from "./route/parameter-definition.class";
 export {} from "./route/parameter-sanitiser";
 export {} from "./route/parameter-snapshot";
 export { VisitSanitiser } from "./route/visit-sanitiser";
-export { EnterPlaceGuard } from "./route/guards/enter-place-guard.service";
-export { LeavePlaceGuard } from "./route/guards/leave-place.guard";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/place/navigation-session.js

@@ -3,8 +3,6 @@
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 import * as tslib_1 from "tslib";
-import { Injectable } from '@angular/core';
-import { InteractionContext } from '../interaction/interaction-context';
 /**
  * @abstract
  */
@@ -146,39 +144,30 @@ if (false) {
     }
     class Factory {
         /**
-         * @param {?} appModelInteractionContext
+         * @param {?} interactionContext
          */
-        constructor(appModelInteractionContext) {
-            this.appModelInteractionContext = appModelInteractionContext;
+        constructor(interactionContext) {
+            this.interactionContext = interactionContext;
         }
         /**
          * @param {?} visit
          * @return {?}
          */
         createInternal(visit) {
-            return new Internal(visit, this.appModelInteractionContext);
+            return new Internal(visit, this.interactionContext);
         }
         /**
          * @param {?} firstTimeRoute
          * @return {?}
          */
         createExternal(firstTimeRoute) {
-            return new External(firstTimeRoute, this.appModelInteractionContext);
+            return new External(firstTimeRoute, this.interactionContext);
         }
     }
-    Factory.decorators = [
-        { type: Injectable, args: [{
-                    providedIn: 'root'
-                },] },
-    ];
-    /** @nocollapse */
-    Factory.ctorParameters = () => [
-        { type: InteractionContext }
-    ];
     NavigationSession.Factory = Factory;
     if (false) {
         /** @type {?} */
-        Factory.prototype.appModelInteractionContext;
+        Factory.prototype.interactionContext;
     }
     class ComponentDeactivationHandler {
         /**
@@ -287,4 +276,4 @@ if (false) {
         ComponentDeactivationHandler.prototype.primary;
     }
 })(NavigationSession || (NavigationSession = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigation-session.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/navigation-session.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Disposable } from '@coolon/pectin';\nimport { InteractionContext } from '../interaction/interaction-context';\nimport { PlaceComponent } from './place-component';\nimport { PlaceDefinition } from './place-definition';\nimport { PlaceRouter } from './place-router';\nimport { Visit } from './visit';\n\nexport abstract class NavigationSession {\n\n  private _alreadyAccepted: PlaceComponent[] = [];\n\n  private _visits = new Map<PlaceDefinition, Visit>();\n  private _popStateReturnUrl: string;\n\n  abstract readonly isExternal: boolean;\n  readonly dialogOpenOnStart: boolean;\n  private componentDeactivationHandlers = new Map<PlaceComponent, NavigationSession.ComponentDeactivationHandler>();\n\n  protected constructor(readonly firstNavigation: boolean, private readonly appModalInteractionContext: InteractionContext) {\n    this.dialogOpenOnStart = this.appModalInteractionContext.isActive();\n  }\n\n  storeVisit(visit: Visit) {\n    this._visits.set(visit.placeDefinition, visit);\n  }\n\n  getVisitFor(placeDef: PlaceDefinition) {\n    return this._visits.get(placeDef);\n  }\n\n  async canDeactivate(component: PlaceComponent, nextState: PlaceRouter.UrlHelper): Promise<boolean> {\n    // lookup the handler and create it if we've not seen it yet\n    let handler = this.componentDeactivationHandlers.get(component);\n    if (!handler) {\n      const isPrimaryHandler = this.componentDeactivationHandlers.size === 0; // only primary handler cancele the app model interations\n      handler = new NavigationSession.ComponentDeactivationHandler(component, this.appModalInteractionContext, isPrimaryHandler);\n      this.componentDeactivationHandlers.set(component, handler);\n    }\n    return handler.canDeactivate(nextState);\n  }\n\n  setPopstateReturnUrl(url: string) {\n    this._popStateReturnUrl = url;\n  }\n\n  get isPopState(): boolean {\n    return !!this._popStateReturnUrl;\n  }\n\n  get popStateReturnUrl() {\n    return this._popStateReturnUrl;\n  }\n\n  getVisits(): Visit[] {\n    return Array.from(this._visits.values());\n  }\n}\n\nexport namespace NavigationSession {\n\n  class External extends NavigationSession {\n    readonly isExternal = true;\n\n    constructor(isFirstTime: boolean, appModelInteractionContext: InteractionContext) {\n      super(isFirstTime, appModelInteractionContext);\n    }\n  }\n\n  class Internal extends NavigationSession {\n    readonly isExternal = false;\n\n    constructor(visit: Visit, appModelInteractionContext: InteractionContext) {\n      super(false, appModelInteractionContext);\n      this.storeVisit(visit);\n    }\n  }\n\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class Factory {\n    constructor(readonly appModelInteractionContext: InteractionContext) {\n    }\n\n    createInternal(visit: Visit): NavigationSession {\n      return new Internal(visit, this.appModelInteractionContext);\n    }\n\n    createExternal(firstTimeRoute: boolean): NavigationSession {\n      return new External(firstTimeRoute, this.appModelInteractionContext);\n    }\n  }\n\n  export class ComponentDeactivationHandler {\n\n    private alreadyAccepted = false;\n\n    constructor(readonly component: PlaceComponent, readonly appModelInteractionContext: InteractionContext, readonly primary:boolean) {\n      // super();\n    }\n\n    async canDeactivate(nextState: PlaceRouter.UrlHelper): Promise<boolean> {\n      console.log(`${this.constructor.name}.canDeactivate`, {component:this.component});\n      if (this.alreadyAccepted) {\n        // We'll get called multiple times if there's any parameter sanitisation so\n        // we always return true if we accepted on a previous cycle of the current\n        // navigation session.\n        return true;\n      } else {\n\n        if (this.primary && this.appModelInteractionContext.isActive()) {\n          // We check the global interaction first\n          await this.cancelCurrentActivityOf(this.appModelInteractionContext);\n          return false;\n        }\n\n        this.alreadyAccepted = await this.canDeactivateComponent(nextState);\n\n        return this.alreadyAccepted;\n      }\n    }\n\n    protected async canDeactivateComponent(nextState: PlaceRouter.UrlHelper) {\n\n      // check if the component has an active interaction.  This will handle\n      // an inplace interaction contexts\n      const hasCustomInteractionContext = this.component.interactionContext &&\n        !this.isAppModalInteractionContext(this.component.interactionContext) &&\n        this.component.interactionContext.isActive();\n\n      if (hasCustomInteractionContext) {\n       this.cancelCurrentActivityOf(this.component.interactionContext);\n        return false;\n      }\n\n      if (this.isLeavingCurrentPlace(nextState) && this.component.canDeactivate) {\n        // No interaction in progress, so ask the component .\n        // This may start an interaction, hence checking the interaction context before now. I.e. if the place pops up the dialog, and\n        // the user clicks back again, we'll re-enter here and go bang when the component tries to open another dialog.\n        return this.component.canDeactivate();\n      }\n      return true;\n    }\n\n    isAppModalInteractionContext(interactionContext: InteractionContext) {\n      return this.appModelInteractionContext === interactionContext;\n    }\n\n    protected async cancelCurrentActivityOf(interactionContext: InteractionContext) {\n      const activity = await interactionContext.getCurrentActivity();\n      console.log('cancelling', { activity });\n      activity.cancel(null);\n    }\n\n\n    protected isLeavingCurrentPlace(nextState: PlaceRouter.UrlHelper) {\n      return !nextState.includesPathOf(this.component.placeDefinition);\n    }\n  }\n\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigation-session.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/navigation-session.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { InteractionContext } from '../interaction/interaction-context';\nimport { PlaceComponent } from './place-component';\nimport { PlaceDefinition } from './place-definition';\nimport { PlaceRouter } from './place-router';\nimport { Visit } from './visit';\n\nexport abstract class NavigationSession {\n\n  private _alreadyAccepted: PlaceComponent[] = [];\n\n  private _visits = new Map<PlaceDefinition, Visit>();\n  private _popStateReturnUrl: string;\n\n  abstract readonly isExternal: boolean;\n  readonly dialogOpenOnStart: boolean;\n  private componentDeactivationHandlers = new Map<PlaceComponent, NavigationSession.ComponentDeactivationHandler>();\n\n  protected constructor(readonly firstNavigation: boolean, private readonly appModalInteractionContext: InteractionContext) {\n    this.dialogOpenOnStart = this.appModalInteractionContext.isActive();\n  }\n\n  storeVisit(visit: Visit) {\n    this._visits.set(visit.placeDefinition, visit);\n  }\n\n  getVisitFor(placeDef: PlaceDefinition) {\n    return this._visits.get(placeDef);\n  }\n\n  async canDeactivate(component: PlaceComponent, nextState: PlaceRouter.UrlHelper): Promise<boolean> {\n    // lookup the handler and create it if we've not seen it yet\n    let handler = this.componentDeactivationHandlers.get(component);\n    if (!handler) {\n      const isPrimaryHandler = this.componentDeactivationHandlers.size === 0; // only primary handler cancele the app model interations\n      handler = new NavigationSession.ComponentDeactivationHandler(component, this.appModalInteractionContext, isPrimaryHandler);\n      this.componentDeactivationHandlers.set(component, handler);\n    }\n    return handler.canDeactivate(nextState);\n  }\n\n  setPopstateReturnUrl(url: string) {\n    this._popStateReturnUrl = url;\n  }\n\n  get isPopState(): boolean {\n    return !!this._popStateReturnUrl;\n  }\n\n  get popStateReturnUrl() {\n    return this._popStateReturnUrl;\n  }\n\n  getVisits(): Visit[] {\n    return Array.from(this._visits.values());\n  }\n}\n\nexport namespace NavigationSession {\n\n  class External extends NavigationSession {\n    readonly isExternal = true;\n\n    constructor(isFirstTime: boolean, appModelInteractionContext: InteractionContext) {\n      super(isFirstTime, appModelInteractionContext);\n    }\n  }\n\n  class Internal extends NavigationSession {\n    readonly isExternal = false;\n\n    constructor(visit: Visit, appModelInteractionContext: InteractionContext) {\n      super(false, appModelInteractionContext);\n      this.storeVisit(visit);\n    }\n  }\n\n  export class Factory {\n    constructor(readonly interactionContext: InteractionContext) {\n    }\n\n    createInternal(visit: Visit): NavigationSession {\n      return new Internal(visit, this.interactionContext);\n    }\n\n    createExternal(firstTimeRoute: boolean): NavigationSession {\n      return new External(firstTimeRoute, this.interactionContext);\n    }\n  }\n\n  export class ComponentDeactivationHandler {\n\n    private alreadyAccepted = false;\n\n    constructor(readonly component: PlaceComponent, readonly appModelInteractionContext: InteractionContext, readonly primary: boolean) {\n      // super();\n    }\n\n    async canDeactivate(nextState: PlaceRouter.UrlHelper): Promise<boolean> {\n      console.log(`${this.constructor.name}.canDeactivate`, { component: this.component });\n      if (this.alreadyAccepted) {\n        // We'll get called multiple times if there's any parameter sanitisation so\n        // we always return true if we accepted on a previous cycle of the current\n        // navigation session.\n        return true;\n      } else {\n\n        if (this.primary && this.appModelInteractionContext.isActive()) {\n          // We check the global interaction first\n          await this.cancelCurrentActivityOf(this.appModelInteractionContext);\n          return false;\n        }\n\n        this.alreadyAccepted = await this.canDeactivateComponent(nextState);\n\n        return this.alreadyAccepted;\n      }\n    }\n\n    protected async canDeactivateComponent(nextState: PlaceRouter.UrlHelper) {\n\n      // check if the component has an active interaction.  This will handle\n      // an inplace interaction contexts\n      const hasCustomInteractionContext = this.component.interactionContext &&\n        !this.isAppModalInteractionContext(this.component.interactionContext) &&\n        this.component.interactionContext.isActive();\n\n      if (hasCustomInteractionContext) {\n        this.cancelCurrentActivityOf(this.component.interactionContext);\n        return false;\n      }\n\n      if (this.isLeavingCurrentPlace(nextState) && this.component.canDeactivate) {\n        // No interaction in progress, so ask the component .\n        // This may start an interaction, hence checking the interaction context before now. I.e. if the place pops up the dialog, and\n        // the user clicks back again, we'll re-enter here and go bang when the component tries to open another dialog.\n        return this.component.canDeactivate();\n      }\n      return true;\n    }\n\n    isAppModalInteractionContext(interactionContext: InteractionContext) {\n      return this.appModelInteractionContext === interactionContext;\n    }\n\n    protected async cancelCurrentActivityOf(interactionContext: InteractionContext) {\n      const activity = await interactionContext.getCurrentActivity();\n      console.log('cancelling', { activity });\n      activity.cancel(null);\n    }\n\n\n    protected isLeavingCurrentPlace(nextState: PlaceRouter.UrlHelper) {\n      return !nextState.includesPathOf(this.component.placeDefinition);\n    }\n  }\n\n}\n\n"]}