@coolon/angular-ui-powerups 0.0.71 → 0.0.74

package/esm5/lib/place/route/guards/enter-place-guard.service.js

@@ -0,0 +1,319 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Injectable, Injector } from '@angular/core';
+import { Router, UrlSerializer } from '@angular/router';
+import { lang } from '@coolon/pectin';
+import { Memoize } from '@typescript-plus/fast-memoize-decorator/dist/src';
+import { PlaceComponent } from '../../place-component';
+import { PlaceHistory } from '../../place-history';
+import { PlaceRouter } from '../../place-router';
+import { Visit } from '../../visit';
+import { VisitSanitiser } from '../visit-sanitiser';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../place-router";
+import * as i3 from "../../place-history";
+var EnterPlaceGuard = /** @class */ (function () {
+    function EnterPlaceGuard(router, urlSerializer, placeRouter, placeHistory, injector) {
+        this.router = router;
+        this.urlSerializer = urlSerializer;
+        this.placeRouter = placeRouter;
+        this.placeHistory = placeHistory;
+        this.injector = injector;
+    }
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    EnterPlaceGuard.prototype.canActivate = 
+    // @Trace()
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    function (activatedRoute, state) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var placeDefinition, params, parsedParams, initialVisit, sanitiser, sanitisedVisit, routerStateUrlTree, commands;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) return [3 /*break*/, 2];
+                        placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);
+                        // Parse our route params.
+                        params = new EnterPlaceGuard.ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);
+                        parsedParams = placeDefinition.parseRouteParams(params);
+                        initialVisit = this.placeRouter.navigationSession.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);
+                        sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);
+                        return [4 /*yield*/, sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams))];
+                    case 1:
+                        sanitisedVisit = _a.sent();
+                        // 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)) {
+                            routerStateUrlTree = this.urlSerializer.parse(state.url);
+                            // Regenerate the url
+                            commands = this.createRedirectCommands(sanitisedVisit, tslib_1.__spread(routerStateUrlTree.root.children.primary.segments)).commands;
+                            console.log('##### Place Guard Redirect', commands);
+                            return [2 /*return*/, this.router.createUrlTree(commands, {
+                                    replaceUrl: true,
+                                    skipLocationChange: false
+                                })];
+                        }
+                        else {
+                            return [2 /*return*/, true];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2: return [2 /*return*/, lang.illegalState("expected component to be an instance of PlaceComponent, got " + activatedRoute.component)];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * @private
+     * @param {?} sanitisedVisit
+     * @param {?} path
+     * @return {?}
+     */
+    EnterPlaceGuard.prototype.createRedirectCommands = /**
+     * @private
+     * @param {?} sanitisedVisit
+     * @param {?} path
+     * @return {?}
+     */
+    function (sanitisedVisit, path) {
+        // Ugly, but it works for now.
+        /** @type {?} */
+        var newSegments = sanitisedVisit.getUrlSegments();
+        /** @type {?} */
+        var replaceAt = path.findIndex((/**
+         * @param {?} segment
+         * @return {?}
+         */
+        function (segment) { return segment.path === newSegments[0].path; }));
+        /** @type {?} */
+        var newPath = tslib_1.__spread(path);
+        newPath.splice.apply(newPath, tslib_1.__spread([replaceAt, newSegments.length], newSegments)); // do not use the return value, it's the items that were removed!
+        // do not use the return value, it's the items that were removed!
+        /** @type {?} */
+        var commands = [];
+        newPath.forEach((/**
+         * @param {?} s
+         * @return {?}
+         */
+        function (s) {
+            commands.push(s.path);
+            if (s.parameterMap.keys.length > 0) {
+                commands.push(s.parameters);
+            }
+        }));
+        return { newPath: newPath, commands: commands };
+    };
+    EnterPlaceGuard.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    EnterPlaceGuard.ctorParameters = function () { return [
+        { type: Router },
+        { type: UrlSerializer },
+        { type: PlaceRouter },
+        { type: PlaceHistory },
+        { type: Injector }
+    ]; };
+    /** @nocollapse */ EnterPlaceGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function EnterPlaceGuard_Factory() { return new EnterPlaceGuard(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i1.UrlSerializer), i0.ɵɵinject(i2.PlaceRouter), i0.ɵɵinject(i3.PlaceHistory), i0.ɵɵinject(i0.INJECTOR)); }, token: EnterPlaceGuard, providedIn: "root" });
+    return EnterPlaceGuard;
+}());
+export { EnterPlaceGuard };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    EnterPlaceGuard.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    EnterPlaceGuard.prototype.urlSerializer;
+    /**
+     * @type {?}
+     * @private
+     */
+    EnterPlaceGuard.prototype.placeRouter;
+    /**
+     * @type {?}
+     * @private
+     */
+    EnterPlaceGuard.prototype.placeHistory;
+    /**
+     * @type {?}
+     * @private
+     */
+    EnterPlaceGuard.prototype.injector;
+}
+(function (EnterPlaceGuard) {
+    /**
+     * 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.
+     */
+    var ConsolidatedParameterMap = /** @class */ (function () {
+        function ConsolidatedParameterMap(paramMap, urlSegments) {
+            this.paramMaps = [paramMap].concat((urlSegments || []).map((/**
+             * @param {?} s
+             * @return {?}
+             */
+            function (s) { return new ParamMapAdapter(s.parameters); }))).filter((/**
+             * @param {?} m
+             * @return {?}
+             */
+            function (m) { return !!m; })); // the activated route param map can be null
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        ConsolidatedParameterMap.prototype.get = /**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            /** @type {?} */
+            var paramMap = this.paramMaps.find((/**
+             * @param {?} m
+             * @return {?}
+             */
+            function (m) { return m.has(name); }));
+            return paramMap.get(name);
+        };
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        ConsolidatedParameterMap.prototype.getAll = /**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            /** @type {?} */
+            var paramMap = this.paramMaps.find((/**
+             * @param {?} m
+             * @return {?}
+             */
+            function (m) { return m.has(name); }));
+            return paramMap.getAll(name);
+        };
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        ConsolidatedParameterMap.prototype.has = /**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            return !!this.paramMaps.find((/**
+             * @param {?} m
+             * @return {?}
+             */
+            function (m) { return m.has(name); }));
+        };
+        Object.defineProperty(ConsolidatedParameterMap.prototype, "keys", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this.paramMaps.reduce((/**
+                 * @param {?} result
+                 * @param {?} params
+                 * @return {?}
+                 */
+                function (result, params) { return result.concat(params.keys); }), []);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        tslib_1.__decorate([
+            Memoize(),
+            tslib_1.__metadata("design:type", Array),
+            tslib_1.__metadata("design:paramtypes", [])
+        ], ConsolidatedParameterMap.prototype, "keys", null);
+        return ConsolidatedParameterMap;
+    }());
+    EnterPlaceGuard.ConsolidatedParameterMap = ConsolidatedParameterMap;
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        ConsolidatedParameterMap.prototype.paramMaps;
+    }
+    var ParamMapAdapter = /** @class */ (function () {
+        function ParamMapAdapter(params) {
+            this.params = params;
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        ParamMapAdapter.prototype.get = /**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            return this.params[name];
+        };
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        ParamMapAdapter.prototype.getAll = /**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            /** @type {?} */
+            var value = this.get(name);
+            return Array.isArray(value) ? value : [value];
+        };
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        ParamMapAdapter.prototype.has = /**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            return this.keys.includes(name);
+        };
+        Object.defineProperty(ParamMapAdapter.prototype, "keys", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return Object.keys(this.params);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return ParamMapAdapter;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        ParamMapAdapter.prototype.params;
+    }
+})(EnterPlaceGuard || (EnterPlaceGuard = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enter-place-guard.service.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/route/guards/enter-place-guard.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, 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 { PlaceComponent } from '../../place-component';\nimport { PlaceHistory } from '../../place-history';\nimport { PlaceRouter } from '../../place-router';\nimport { Visit } from '../../visit';\nimport { VisitSanitiser } from '../visit-sanitiser';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class EnterPlaceGuard implements CanActivate {\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    if (PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) {\n      const placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);\n      // Parse our route params.\n      const params = new EnterPlaceGuard.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        const routerStateUrlTree = this.urlSerializer.parse(state.url);\n\n        // Regenerate the url\n        const { commands } = this.createRedirectCommands(sanitisedVisit, [...routerStateUrlTree.root.children.primary.segments]);\n\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    } else {\n      return lang.illegalState(`expected component to be an instance of PlaceComponent, got ${activatedRoute.component}`);\n    }\n  }\n\n\n  private createRedirectCommands(sanitisedVisit, path) {\n    // Ugly, but it works for now.\n    const newSegments = sanitisedVisit.getUrlSegments();\n    const replaceAt = path.findIndex(segment => segment.path === newSegments[0].path);\n    const newPath = [...path];\n    newPath.splice(replaceAt, newSegments.length, ...newSegments); // do not use the return value, it's the items that were removed!\n\n    const commands = [];\n    newPath.forEach(s => {\n      commands.push(s.path);\n      if (s.parameterMap.keys.length > 0) {\n        commands.push(s.parameters);\n      }\n    });\n    return { newPath, commands };\n  }\n}\n\nexport namespace EnterPlaceGuard {\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/esm5/lib/place/route/guards/leave-place.guard.js

@@ -5,8 +5,10 @@
 import * as tslib_1 from "tslib";
 import { Location } from '@angular/common';
 import { Injectable, Injector } from '@angular/core';
-import { Router } from '@angular/router';
+import { Router, RouterStateSnapshot } from '@angular/router';
+import { Trace } from '@coolon/pectin';
 import { InteractionContext } from '../../../interaction/interaction-context';
+import { PlaceDefinition } from '../../place-definition';
 import { PlaceRouter } from '../../place-router';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/router";
@@ -24,17 +26,74 @@ var LeavePlaceGuard = /** @class */ (function () {
     /**
      * @private
      * @param {?} nextState
-     * @param {?} placeDefinitionPath
+     * @param {?} placeDefinition
      * @return {?}
      */
     LeavePlaceGuard.prototype.isLeavingTheCurrentPlace = /**
      * @private
      * @param {?} nextState
-     * @param {?} placeDefinitionPath
+     * @param {?} placeDefinition
      * @return {?}
      */
-    function (nextState, placeDefinitionPath) {
+    function (nextState, placeDefinition) {
         // TODO: this will break with child routes... need to examine the router states properly.
+        // console.log('canDeactivate', {
+        //   staticPath: placeDefinitionPath,
+        //   currentStateUrl: currentState.url,
+        //   nextStateUrl: nextState.url
+        //   // alreadyDeclined: this._alreadyAccepted
+        // });
+        // Example of the above when navigating to a different child route.
+        // canDeactivate {staticPath: "/hero-details",
+        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-details",
+        //    nextStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats"
+        // }
+        // TODO: this will break with child routes... need to examine the router states properly.
+        // console.log('canDeactivate', {
+        //   staticPath: placeDefinitionPath,
+        //   currentStateUrl: currentState.url,
+        //   nextStateUrl: nextState.url
+        //   // alreadyDeclined: this._alreadyAccepted
+        // });
+        // Example of the above when navigating to a different child route.
+        // canDeactivate {staticPath: "/hero-details",
+        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-details",
+        //    nextStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats"
+        // }
+        // Example clicking on router tab of the parent component (de-activates the parent due to route param changes)
+        // canDeactivate {
+        //    staticPath: "/hero-stats",
+        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
+        //    nextStateUrl: "/route-parameters/"
+        // }
+        // canDeactivate {
+        //    staticPath: "/route-parameters",
+        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
+        //    nextStateUrl: "/route-parameters/"
+        // }
+        // logger.class.js:54 ParameterSnapshot.sanitise -> {idModel: -1, pv: undefined, pl: Array(0), dv: undefined, dl: Array(0), …}
+        // parameter-snapshot.ts:20 {name: "idModel", mine: -1, theirs: null}
+        // place-router.ts:28 redirect path (3) ["route-parameters", "-1", {…}]
+        // canDeactivate {
+        //    staticPath: "/hero-stats",
+        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
+        //    nextStateUrl: "/route-parameters/-1"
+        // }
+        // canDeactivate {
+        //    staticPath: "/route-parameters",
+        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
+        //    nextStateUrl: "/route-parameters/-1"
+        // }
+        // logger.class.js:54 ParameterSnapshot.sanitise -> {idModel: -1, pv: undefined, pl: Array(0), dv: "A", dl: Array(3), …}
+        // parameter-snapshot.ts:20 {name: "dv", mine: "A", theirs: undefined}
+        // place-router.ts:28 redirect path (3) ["route-parameters", "-1", {…}]
+        // canDeactivate {
+        //    staticPath: "/hero-stats",
+        //    currentStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats",
+        //    nextStateUrl: "/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c"
+        // }
+        /** @type {?} */
+        var placeDefinitionPath = "/" + placeDefinition.path;
         return !nextState.url.startsWith(placeDefinitionPath);
     };
     /**
@@ -53,11 +112,10 @@ var LeavePlaceGuard = /** @class */ (function () {
      */
     function (component, currentRoute, currentState, nextState) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var placeDefinitionPath, self_1, canLeave;
+            var self_1, canLeave;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        placeDefinitionPath = "/" + component.placeDefinition.path;
                         if (!this.placeRouter.navigationSession.alreadyAccepted(component)) return [3 /*break*/, 1];
                         // We'll get called multiple times if there's any parameter sanitisation so
                         // we always return true if we accepted on a previous cycle of the current
@@ -66,7 +124,7 @@ var LeavePlaceGuard = /** @class */ (function () {
                     case 1:
                         self_1 = this;
                         canLeave = true;
-                        if (!this.isLeavingTheCurrentPlace(nextState, placeDefinitionPath)) return [3 /*break*/, 4];
+                        if (!this.isLeavingTheCurrentPlace(nextState, component.placeDefinition)) return [3 /*break*/, 4];
                         // we check the interaction first, so that components that don't need to check if they're in an
                         // interaction during the canDeactivate cycle.
                         // TODO: Add tests: show dialog -> hit back -> same route
@@ -125,6 +183,12 @@ var LeavePlaceGuard = /** @class */ (function () {
         { type: Location }
     ]; };
     /** @nocollapse */ LeavePlaceGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i2.PlaceRouter), i0.ɵɵinject(i3.InteractionContext), i0.ɵɵinject(i4.Location)); }, token: LeavePlaceGuard, providedIn: "root" });
+    tslib_1.__decorate([
+        Trace(),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", [RouterStateSnapshot, PlaceDefinition]),
+        tslib_1.__metadata("design:returntype", void 0)
+    ], LeavePlaceGuard.prototype, "isLeavingTheCurrentPlace", null);
     return LeavePlaceGuard;
 }());
 export { LeavePlaceGuard };
@@ -149,4 +213,4 @@ if (false) {
     /** @type {?} */
     LeavePlaceGuard.prototype.angularLocation;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"leave-place.guard.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/route/guards/leave-place.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\nimport { Injectable, Injector } from '@angular/core';\nimport { ActivatedRouteSnapshot, CanDeactivate, Router, RouterStateSnapshot } from '@angular/router';\nimport { InteractionContext } from '../../../interaction/interaction-context';\nimport { PlaceComponent } from '../../place-component';\nimport { PlaceRouter } from '../../place-router';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class LeavePlaceGuard implements CanDeactivate<PlaceComponent> {\n\n  constructor(private router: Router,\n              private injector: Injector,\n              private placeRouter: PlaceRouter,\n              readonly interactionContext: InteractionContext, readonly angularLocation: Location) {\n  }\n\n  private isLeavingTheCurrentPlace(nextState: RouterStateSnapshot, placeDefinitionPath: string) {\n    // TODO: this will break with child routes... need to examine the router states properly.\n    return !nextState.url.startsWith(placeDefinitionPath);\n  }\n\n  async canDeactivate(component: PlaceComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Promise<boolean> {\n    const placeDefinitionPath = `/${component.placeDefinition.path}`;\n    // console.log('canDeactivate', {\n    //   staticPath: placeDefinitionPath,\n    //   currentStateUrl: currentState.url,\n    //   nextStateUrl: nextState.url\n    //   // alreadyDeclined: this._alreadyAccepted\n    // });\n    // Example of the above when navigating to a different child route.\n    // canDeactivate {staticPath: \"/hero-details\",\n    //    currentStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-details\",\n    //    nextStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats\"\n    // }\n\n    // Example clicking on router tab of the parent component (de-activates the parent due to route param changes)\n    // canDeactivate {\n    //    staticPath: \"/hero-stats\",\n    //    currentStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats\",\n    //    nextStateUrl: \"/route-parameters/\"\n    // }\n    // canDeactivate {\n    //    staticPath: \"/route-parameters\",\n    //    currentStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats\",\n    //    nextStateUrl: \"/route-parameters/\"\n    // }\n    // logger.class.js:54 ParameterSnapshot.sanitise -> {idModel: -1, pv: undefined, pl: Array(0), dv: undefined, dl: Array(0), …}\n    // parameter-snapshot.ts:20 {name: \"idModel\", mine: -1, theirs: null}\n    // place-router.ts:28 redirect path (3) [\"route-parameters\", \"-1\", {…}]\n    // canDeactivate {\n    //    staticPath: \"/hero-stats\",\n    //    currentStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats\",\n    //    nextStateUrl: \"/route-parameters/-1\"\n    // }\n    // canDeactivate {\n    //    staticPath: \"/route-parameters\",\n    //    currentStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats\",\n    //    nextStateUrl: \"/route-parameters/-1\"\n    // }\n    // logger.class.js:54 ParameterSnapshot.sanitise -> {idModel: -1, pv: undefined, pl: Array(0), dv: \"A\", dl: Array(3), …}\n    // parameter-snapshot.ts:20 {name: \"dv\", mine: \"A\", theirs: undefined}\n    // place-router.ts:28 redirect path (3) [\"route-parameters\", \"-1\", {…}]\n    // canDeactivate {\n    //    staticPath: \"/hero-stats\",\n    //    currentStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats\",\n    //    nextStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c\"\n    // }\n\n\n    // TODO: Add tests\n    if (this.placeRouter.navigationSession.alreadyAccepted(component)) {\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      const self = this;\n      let canLeave = true;\n\n      if (this.isLeavingTheCurrentPlace(nextState, placeDefinitionPath)) {\n        // we check the interaction first, so that components that don't need to check if they're in an\n        // interaction during the canDeactivate cycle.\n        // TODO: Add tests: show dialog -> hit back -> same route\n        if (this.interactionContext.isActive()) {\n          canLeave = false;\n          console.log('cancelling', { activity: this.interactionContext.currentActivity });\n          this.interactionContext.currentActivity.cancel(null);\n        }\n        // No interaction in progress, so ask the component .\n        // This may start an interaction, hence checking the interaction context above. 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\n        // dialog.\n        if (canLeave) {\n          // TODO: Add tests: hit back -> confirm leave dialog -> hit back -> close dialog ->  hit back -> confirm leave dialog.\n          canLeave = await component.canDeactivate();\n        }\n\n\n        // We also block back button parameter changes while the dialog is open.\n        // NOTE: Now that I'm catching parameter changes I could possibly retry using a fragment or\n        // query parameter to track the dialog being open.  Previously I was just checking this on\n        // path changes... if that worked it'd fix the case where the back button breaks with an activity\n        // open on the first page: https://coolon.atlassian.net/browse/AUP-33\n      } else {\n        if (this.interactionContext.isActive()) {\n          console.log('cancelling', { activity: this.interactionContext.currentActivity });\n          this.interactionContext.currentActivity.cancel(null);\n          canLeave = false;\n        } else {\n          canLeave = true;\n        }\n      }\n\n      if (canLeave) {\n        // We'll get called multiple times if there's any parameter sanitisation so\n        // we remember the acceptance for the duration of the current navigation session.\n        self.placeRouter.navigationSession.rememberAcceptanceOf(component);\n      } else {\n        // Angular doesn't preserve the url when a guard cancels the back button.\n        // See https://github.com/angular/angular/issues/13586#issuecomment-432795720\n        if (this.placeRouter.navigationSession.isPopState) {\n          console.log('cancelled during popstate');\n          this.angularLocation.go(this.placeRouter.navigationSession.popStateReturnUrl);\n        }\n      }\n\n      return canLeave;\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"leave-place.guard.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/route/guards/leave-place.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\nimport { Injectable, Injector } from '@angular/core';\nimport { ActivatedRouteSnapshot, CanDeactivate, Router, RouterStateSnapshot } from '@angular/router';\nimport { Trace } from '@coolon/pectin';\nimport { InteractionContext } from '../../../interaction/interaction-context';\nimport { PlaceComponent } from '../../place-component';\nimport { PlaceDefinition } from '../../place-definition';\nimport { PlaceRouter } from '../../place-router';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class LeavePlaceGuard implements CanDeactivate<PlaceComponent> {\n\n  constructor(private router: Router,\n              private injector: Injector,\n              private placeRouter: PlaceRouter,\n              readonly interactionContext: InteractionContext,\n              readonly angularLocation: Location) {\n  }\n\n  @Trace()\n  private isLeavingTheCurrentPlace(nextState: RouterStateSnapshot, placeDefinition: PlaceDefinition) {\n    // TODO: this will break with child routes... need to examine the router states properly.\n    // console.log('canDeactivate', {\n    //   staticPath: placeDefinitionPath,\n    //   currentStateUrl: currentState.url,\n    //   nextStateUrl: nextState.url\n    //   // alreadyDeclined: this._alreadyAccepted\n    // });\n    // Example of the above when navigating to a different child route.\n    // canDeactivate {staticPath: \"/hero-details\",\n    //    currentStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-details\",\n    //    nextStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats\"\n    // }\n\n    // Example clicking on router tab of the parent component (de-activates the parent due to route param changes)\n    // canDeactivate {\n    //    staticPath: \"/hero-stats\",\n    //    currentStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats\",\n    //    nextStateUrl: \"/route-parameters/\"\n    // }\n    // canDeactivate {\n    //    staticPath: \"/route-parameters\",\n    //    currentStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats\",\n    //    nextStateUrl: \"/route-parameters/\"\n    // }\n    // logger.class.js:54 ParameterSnapshot.sanitise -> {idModel: -1, pv: undefined, pl: Array(0), dv: undefined, dl: Array(0), …}\n    // parameter-snapshot.ts:20 {name: \"idModel\", mine: -1, theirs: null}\n    // place-router.ts:28 redirect path (3) [\"route-parameters\", \"-1\", {…}]\n    // canDeactivate {\n    //    staticPath: \"/hero-stats\",\n    //    currentStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats\",\n    //    nextStateUrl: \"/route-parameters/-1\"\n    // }\n    // canDeactivate {\n    //    staticPath: \"/route-parameters\",\n    //    currentStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats\",\n    //    nextStateUrl: \"/route-parameters/-1\"\n    // }\n    // logger.class.js:54 ParameterSnapshot.sanitise -> {idModel: -1, pv: undefined, pl: Array(0), dv: \"A\", dl: Array(3), …}\n    // parameter-snapshot.ts:20 {name: \"dv\", mine: \"A\", theirs: undefined}\n    // place-router.ts:28 redirect path (3) [\"route-parameters\", \"-1\", {…}]\n    // canDeactivate {\n    //    staticPath: \"/hero-stats\",\n    //    currentStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c/hero-stats\",\n    //    nextStateUrl: \"/route-parameters/-1;dv=A;dl=a,b,c;rdv=A;rdl=a,b,c\"\n    // }\n    const placeDefinitionPath = `/${placeDefinition.path}`;\n    return !nextState.url.startsWith(placeDefinitionPath);\n  }\n\n  async canDeactivate(component: PlaceComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Promise<boolean> {\n\n    // TODO: Add tests\n    if (this.placeRouter.navigationSession.alreadyAccepted(component)) {\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      const self = this;\n      let canLeave = true;\n\n      if (this.isLeavingTheCurrentPlace(nextState, component.placeDefinition)) {\n        // we check the interaction first, so that components that don't need to check if they're in an\n        // interaction during the canDeactivate cycle.\n        // TODO: Add tests: show dialog -> hit back -> same route\n        if (this.interactionContext.isActive()) {\n          canLeave = false;\n          console.log('cancelling', { activity: this.interactionContext.currentActivity });\n          this.interactionContext.currentActivity.cancel(null);\n        }\n        // No interaction in progress, so ask the component .\n        // This may start an interaction, hence checking the interaction context above. 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\n        // dialog.\n        if (canLeave) {\n          // TODO: Add tests: hit back -> confirm leave dialog -> hit back -> close dialog ->  hit back -> confirm leave dialog.\n          canLeave = await component.canDeactivate();\n        }\n\n        // We also block back button parameter changes while the dialog is open.\n        // NOTE: Now that I'm catching parameter changes I could possibly retry using a fragment or\n        // query parameter to track the dialog being open.  Previously I was just checking this on\n        // path changes... if that worked it'd fix the case where the back button breaks with an activity\n        // open on the first page: https://coolon.atlassian.net/browse/AUP-33\n      } else {\n        if (this.interactionContext.isActive()) {\n          console.log('cancelling', { activity: this.interactionContext.currentActivity });\n          this.interactionContext.currentActivity.cancel(null);\n          canLeave = false;\n        } else {\n          canLeave = true;\n        }\n      }\n\n      if (canLeave) {\n        // We'll get called multiple times if there's any parameter sanitisation so\n        // we remember the acceptance for the duration of the current navigation session.\n        self.placeRouter.navigationSession.rememberAcceptanceOf(component);\n      } else {\n        // Angular doesn't preserve the url when a guard cancels the back button.\n        // See https://github.com/angular/angular/issues/13586#issuecomment-432795720\n        if (this.placeRouter.navigationSession.isPopState) {\n          console.log('cancelled during popstate');\n          this.angularLocation.go(this.placeRouter.navigationSession.popStateReturnUrl);\n        }\n      }\n\n      return canLeave;\n    }\n  }\n}\n"]}

package/esm5/lib/place/visit.js

@@ -3,6 +3,7 @@
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 import * as tslib_1 from "tslib";
+import { UrlSegment } from '@angular/router';
 import * as _ from 'lodash';
 /**
  * @record
@@ -159,6 +160,17 @@ var Visit = /** @class */ (function () {
         var sameNonRouteParameters = _.isEqual(this.placeDefinition.getNonRouteParameters(this), this.placeDefinition.getNonRouteParameters(other));
         return !sameNonRouteParameters || this.hasRoutingChangedFrom(other);
     };
+    /**
+     * @return {?}
+     */
+    Visit.prototype.getUrlSegments = /**
+     * @return {?}
+     */
+    function () {
+        return this.placeDefinition.hasRouteId() ?
+            [new UrlSegment(this.placeDefinition.path, {}), new UrlSegment(this.placeDefinition.getFormattedRouteId(this), this.placeDefinition.getFormattedRouteParameters(this))] :
+            [new UrlSegment(this.placeDefinition.path, this.placeDefinition.getFormattedRouteParameters(this))];
+    };
     return Visit;
 }());
 export { Visit };
@@ -171,4 +183,4 @@ if (false) {
      */
     Visit.prototype.visitParameters;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlzaXQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AY29vbG9uL2FuZ3VsYXItdWktcG93ZXJ1cHMvIiwic291cmNlcyI6WyJsaWIvcGxhY2UvdmlzaXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxLQUFLLENBQUMsTUFBTSxRQUFRLENBQUM7Ozs7QUFJNUIscUJBRUM7QUFHRDtJQUVFLGVBQXFCLGVBQWdDLEVBQW1CLGVBQTRCO1FBQTVCLGdDQUFBLEVBQUEsb0JBQTRCO1FBQS9FLG9CQUFlLEdBQWYsZUFBZSxDQUFpQjtRQUFtQixvQkFBZSxHQUFmLGVBQWUsQ0FBYTtJQUNwRyxDQUFDO0lBRUQsV0FBVzs7Ozs7SUFDWCwwQkFBVTs7Ozs7SUFBVjtRQUNFLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDbkQsQ0FBQztJQUVELFdBQVc7Ozs7O0lBQ1gsMEJBQVU7Ozs7O0lBQVY7UUFDRSxPQUFPLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQztJQUNyQyxDQUFDO0lBRUQ7Ozs7O09BS0c7Ozs7Ozs7O0lBQ0gsNEJBQVk7Ozs7Ozs7SUFBWixVQUFhLGFBQXFCO1FBQ2hDLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUM3QyxDQUFDO0lBRUQsV0FBVzs7Ozs7O0lBQ1gsNEJBQVk7Ozs7OztJQUFaLFVBQWEsYUFBcUI7UUFDaEMsT0FBTyxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQyxRQUFRLENBQUMsYUFBYSxDQUFDLENBQUM7SUFDbkUsQ0FBQzs7Ozs7OztJQUVELHVCQUFPOzs7Ozs7SUFBUCxVQUFXLFNBQXNDLEVBQUUsS0FBUTs7UUFDekQsT0FBTyxJQUFJLEtBQUssQ0FBQyxJQUFJLENBQUMsZUFBZSx1QkFBTyxJQUFJLENBQUMsZUFBZSxlQUFHLFNBQVMsQ0FBQyxJQUFJLElBQUcsS0FBSyxPQUFHLENBQUM7SUFDL0YsQ0FBQzs7Ozs7O0lBRUQsb0NBQW9COzs7OztJQUFwQixVQUF3QixXQUFpQztRQUF6RCxpQkFrQkM7OztZQWhCTyxrQkFBa0IsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQzs7WUFDN0MsTUFBTSxHQUFHLEVBQUU7UUFDakIsSUFBSSxDQUFDLGVBQWUsQ0FBQyxxQkFBcUIsRUFBRSxDQUFDLE9BQU87Ozs7UUFBQyxVQUFBLEdBQUc7WUFDdEQsSUFBSSxHQUFHLENBQUMsU0FBUyxJQUFJLEdBQUcsQ0FBQyxnQkFBZ0IsRUFBRTtnQkFDekMsSUFBSSxrQkFBa0IsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFO29CQUN6QyxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxHQUFHLFdBQVcsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7aUJBQzFDO2FBQ0Y7aUJBQU07Z0JBQ0wsOEdBQThHO2dCQUM5Ryw4Q0FBOEM7Z0JBQzlDLElBQUksS0FBSSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUU7b0JBQy9CLE1BQU0sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEdBQUcsS0FBSSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7aUJBQ2hEO2FBQ0Y7UUFDSCxDQUFDLEVBQUMsQ0FBQztRQUNILE9BQU8sSUFBSSxLQUFLLENBQUMsSUFBSSxDQUFDLGVBQWUsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNqRCxDQUFDOzs7OztJQUVELHFDQUFxQjs7OztJQUFyQixVQUFzQixLQUFZOztZQUMxQixTQUFTLEdBQUcsS0FBSyxDQUFDLGVBQWUsS0FBSyxJQUFJLENBQUMsZUFBZTs7WUFDMUQsbUJBQW1CLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FDbkMsSUFBSSxDQUFDLGVBQWUsQ0FBQywyQkFBMkIsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLEVBQzVELElBQUksQ0FBQyxlQUFlLENBQUMsMkJBQTJCLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxDQUM5RDtRQUNELE9BQU8sQ0FBQyxTQUFTLElBQUksQ0FBQyxtQkFBbUIsQ0FBQztJQUM1QyxDQUFDOzs7OztJQUVELDhCQUFjOzs7O0lBQWQsVUFBZSxLQUFZOztZQUNuQixzQkFBc0IsR0FBRyxDQUFDLENBQUMsT0FBTyxDQUN0QyxJQUFJLENBQUMsZUFBZSxDQUFDLHFCQUFxQixDQUFDLElBQUksQ0FBQyxFQUNoRCxJQUFJLENBQUMsZUFBZSxDQUFDLHFCQUFxQixDQUFDLEtBQUssQ0FBQyxDQUNsRDtRQUNELE9BQU8sQ0FBQyxzQkFBc0IsSUFBSSxJQUFJLENBQUMscUJBQXFCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDdEUsQ0FBQzs7OztJQUVELDhCQUFjOzs7SUFBZDtRQUNFLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxDQUFDO1lBQ3hDLENBQUMsSUFBSSxVQUFVLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLEVBQUUsSUFBSSxVQUFVLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsRUFBRSxJQUFJLENBQUMsZUFBZSxDQUFDLDJCQUEyQixDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3pLLENBQUMsSUFBSSxVQUFVLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLGVBQWUsQ0FBQywyQkFBMkIsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDeEcsQ0FBQztJQUNILFlBQUM7QUFBRCxDQUFDLEFBNUVELElBNEVDOzs7O0lBMUVhLGdDQUF5Qzs7Ozs7SUFBRSxnQ0FBNkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVcmxTZWdtZW50IH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCAqIGFzIF8gZnJvbSAnbG9kYXNoJztcbmltcG9ydCB7IFBsYWNlRGVmaW5pdGlvbiB9IGZyb20gJy4vcGxhY2UtZGVmaW5pdGlvbic7XG5pbXBvcnQgeyBQYXJhbWV0ZXJEZWZpbml0aW9uIH0gZnJvbSAnLi9yb3V0ZS9wYXJhbWV0ZXItZGVmaW5pdGlvbi5jbGFzcyc7XG5cbmludGVyZmFjZSBQYXJhbXMge1xuICBbcDogc3RyaW5nXTogYW55XG59XG5cblxuZXhwb3J0IGNsYXNzIFZpc2l0IHtcblxuICBjb25zdHJ1Y3RvcihyZWFkb25seSBwbGFjZURlZmluaXRpb246IFBsYWNlRGVmaW5pdGlvbiwgcHJpdmF0ZSByZWFkb25seSB2aXNpdFBhcmFtZXRlcnM6IFBhcmFtcyA9IHt9KSB7XG4gIH1cblxuICAvLyBAVHJhY2UoKVxuICBnZXRSb3V0ZUlkKCk6IGFueSB7XG4gICAgcmV0dXJuIHRoaXMucGxhY2VEZWZpbml0aW9uLmdldFJvdXRlSWRGcm9tKHRoaXMpO1xuICB9XG5cbiAgLy8gQFRyYWNlKClcbiAgaGFzUm91dGVJZCgpOiBib29sZWFuIHtcbiAgICByZXR1cm4gIV8uaXNOaWwodGhpcy5nZXRSb3V0ZUlkKCkpO1xuICB9XG5cbiAgLyoqXG4gICAqIFJldHVybnMgdGhlIHZhbHVlIG9mIHRoZSBwbGFjZSBwYXJhbWV0ZXIgd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUuICBUaGUgcGFyYW1ldGVyXG4gICAqIG5hbWUgaXMgdGFrZW4gZnJvbSB0aGUgYGFzYCBvcHRpb24sIGUuZy4ge2FzOiAnYUN1c3RvbU5hbWUnfSBvdGhlcndpc2UgaXQgaXMgdGhlXG4gICAqIHNhbWUgYXMgdGhlIHRoZSBWYWx1ZU1vZGVsIHByb3BlcnR5IG5hbWUuXG4gICAqIEBwYXJhbSBwYXJhbWV0ZXJOYW1lIHRoZSBmaWVsZCBuYW1lIG9mIHRoZSBwcm9wZXJ0eSBtb2RlbCBvciB0aGUgYGFzYCBvcHRpb24gaWYgc3BlY2lmaWVkLlxuICAgKi9cbiAgZ2V0UGFyYW1ldGVyKHBhcmFtZXRlck5hbWU6IHN0cmluZyk6IGFueSB7XG4gICAgcmV0dXJuIHRoaXMudmlzaXRQYXJhbWV0ZXJzW3BhcmFtZXRlck5hbWVdO1xuICB9XG5cbiAgLy8gQFRyYWNlKClcbiAgaGFzUGFyYW1ldGVyKHBhcmFtZXRlck5hbWU6IHN0cmluZykge1xuICAgIHJldHVybiBPYmplY3Qua2V5cyh0aGlzLnZpc2l0UGFyYW1ldGVycykuaW5jbHVkZXMocGFyYW1ldGVyTmFtZSk7XG4gIH1cblxuICByZXBsYWNlPFM+KHBhcmFtZXRlcjogUGFyYW1ldGVyRGVmaW5pdGlvbjxhbnksIFM+LCB2YWx1ZTogUyk6IFZpc2l0IHtcbiAgICByZXR1cm4gbmV3IFZpc2l0KHRoaXMucGxhY2VEZWZpbml0aW9uLCB7IC4uLnRoaXMudmlzaXRQYXJhbWV0ZXJzLCBbcGFyYW1ldGVyLm5hbWVdOiB2YWx1ZSB9KTtcbiAgfVxuXG4gIG1lcmdlUm91dGVQYXJhbWV0ZXJzPFM+KHJvdXRlUGFyYW1zOiB7IFtwOiBzdHJpbmddOiBhbnkgfSk6IFZpc2l0IHtcbiAgICAvLyB0b2RvOiB3aGl0ZWxpc3QgcGFyYW1ldGVycy5cbiAgICBjb25zdCByb3V0ZVBhcmFtZXRlcktleXMgPSBPYmplY3Qua2V5cyhyb3V0ZVBhcmFtcyk7XG4gICAgY29uc3QgcGFyYW1zID0ge307XG4gICAgdGhpcy5wbGFjZURlZmluaXRpb24uZ2V0VmlzaXRQYXJhbWV0ZXJEZWZzKCkuZm9yRWFjaChkZWYgPT4ge1xuICAgICAgaWYgKGRlZi5pc1JvdXRlSWQgfHwgZGVmLmlzUm91dGVQYXJhbWV0ZXIpIHtcbiAgICAgICAgaWYgKHJvdXRlUGFyYW1ldGVyS2V5cy5pbmNsdWRlcyhkZWYubmFtZSkpIHtcbiAgICAgICAgICBwYXJhbXNbZGVmLm5hbWVdID0gcm91dGVQYXJhbXNbZGVmLm5hbWVdO1xuICAgICAgICB9XG4gICAgICB9IGVsc2Uge1xuICAgICAgICAvLyBjb3B5IG5vbiByb3V0ZSBwYXJhbXMgYXMgaXMsIGJ1dCBvbmx5IGlmIHRoZXkgYWxyZWFkeSBleGlzdCBvdGhlcndpc2Ugd2UnbGwgaW5qZWN0IG5pbCB2YWx1ZXMgYW5kIGJyZWFrIHRoZVxuICAgICAgICAvLyBkZWZhdWx0cyBhbmQgcmVtZW1iZXIgc2FuaXRpc2F0aW9uIHByb2Nlc3MuXG4gICAgICAgIGlmICh0aGlzLmhhc1BhcmFtZXRlcihkZWYubmFtZSkpIHtcbiAgICAgICAgICBwYXJhbXNbZGVmLm5hbWVdID0gdGhpcy5nZXRQYXJhbWV0ZXIoZGVmLm5hbWUpO1xuICAgICAgICB9XG4gICAgICB9XG4gICAgfSk7XG4gICAgcmV0dXJuIG5ldyBWaXNpdCh0aGlzLnBsYWNlRGVmaW5pdGlvbiwgcGFyYW1zKTtcbiAgfVxuXG4gIGhhc1JvdXRpbmdDaGFuZ2VkRnJvbShvdGhlcjogVmlzaXQpOiBib29sZWFuIHtcbiAgICBjb25zdCBzYW1lUGxhY2UgPSBvdGhlci5wbGFjZURlZmluaXRpb24gPT09IHRoaXMucGxhY2VEZWZpbml0aW9uO1xuICAgIGNvbnN0IHNhbWVSb3V0ZVBhcmFtZXRlcnMgPSBfLmlzRXF1YWwoXG4gICAgICB0aGlzLnBsYWNlRGVmaW5pdGlvbi5nZXRGb3JtYXR0ZWRSb3V0ZVBhcmFtZXRlcnModGhpcywgdHJ1ZSksXG4gICAgICB0aGlzLnBsYWNlRGVmaW5pdGlvbi5nZXRGb3JtYXR0ZWRSb3V0ZVBhcmFtZXRlcnMob3RoZXIsIHRydWUpXG4gICAgKTtcbiAgICByZXR1cm4gIXNhbWVQbGFjZSB8fCAhc2FtZVJvdXRlUGFyYW1ldGVycztcbiAgfVxuXG4gIGhhc0NoYW5nZWRGcm9tKG90aGVyOiBWaXNpdCkge1xuICAgIGNvbnN0IHNhbWVOb25Sb3V0ZVBhcmFtZXRlcnMgPSBfLmlzRXF1YWwoXG4gICAgICB0aGlzLnBsYWNlRGVmaW5pdGlvbi5nZXROb25Sb3V0ZVBhcmFtZXRlcnModGhpcyksXG4gICAgICB0aGlzLnBsYWNlRGVmaW5pdGlvbi5nZXROb25Sb3V0ZVBhcmFtZXRlcnMob3RoZXIpXG4gICAgKTtcbiAgICByZXR1cm4gIXNhbWVOb25Sb3V0ZVBhcmFtZXRlcnMgfHwgdGhpcy5oYXNSb3V0aW5nQ2hhbmdlZEZyb20ob3RoZXIpO1xuICB9XG5cbiAgZ2V0VXJsU2VnbWVudHMoKTogVXJsU2VnbWVudFtdIHtcbiAgICByZXR1cm4gdGhpcy5wbGFjZURlZmluaXRpb24uaGFzUm91dGVJZCgpID9cbiAgICAgIFtuZXcgVXJsU2VnbWVudCh0aGlzLnBsYWNlRGVmaW5pdGlvbi5wYXRoLCB7fSksIG5ldyBVcmxTZWdtZW50KHRoaXMucGxhY2VEZWZpbml0aW9uLmdldEZvcm1hdHRlZFJvdXRlSWQodGhpcyksIHRoaXMucGxhY2VEZWZpbml0aW9uLmdldEZvcm1hdHRlZFJvdXRlUGFyYW1ldGVycyh0aGlzKSldIDpcbiAgICAgIFtuZXcgVXJsU2VnbWVudCh0aGlzLnBsYWNlRGVmaW5pdGlvbi5wYXRoLCB0aGlzLnBsYWNlRGVmaW5pdGlvbi5nZXRGb3JtYXR0ZWRSb3V0ZVBhcmFtZXRlcnModGhpcykpXTtcbiAgfVxufVxuIl19

package/esm5/public_api.js

@@ -4,8 +4,8 @@
  */
 export { AngularUiPowerupsModule } from './lib/angular-ui-powerups.module';
 export { slideDownAndUpAnimation } from './lib/animations';
-export { DisposableComponent, ResizeAwareComponent, AbstractInputComponent, NumberInputComponent, PasswordInputComponent, SelectInputComponent, StringInputComponent, NoopComponent, Bounds, Dimension, Point } from './lib/components';
-export { CommandDirective, FocusBindingDirective } from './lib/directives';
+export { ComponentsModule, DisposableComponent, ResizeAwareComponent, AbstractInputComponent, NumberInputComponent, PasswordInputComponent, SelectInputComponent, StringInputComponent, NoopComponent, Bounds, Dimension, Point } from './lib/components';
+export { CommandDirective, DirectivesModule, FocusBindingDirective } from './lib/directives';
 export { AbstractActivity, ACTIVITY_DATA, Activity, InteractionContext, InteractionModule, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, ConfirmThenDialogComponent, ConfirmationDialogComponent, InteractionOutletComponent, InteractionGuard, DIALOG_INTERACTION_SERVICE_DEFAULTS, DialogInteractionService } from './lib/interaction';
-export { NavigationSession, DEFINITION_META_DATA_KEY, ROUTE_PARAMETER_LIST_KEY, PlaceComponent, PlaceDefinition, PlaceHistory, PlaceRouter, Place, PlaceModule, Visit, AbstractPlaceNavigationComponent, BusyOverlayComponent, EmptyStateComponent, ListPlaceNavComponent, PlaceOutletComponent, leftRightPlaceAnimation, LEFT_RIGHT_PLACE_ANIMATION, TabbedPlaceNavigationComponent, Formatter, RouteId, VisitParameter, VisitParameterList, ParameterDefinition, VisitSanitiser, LeavePlaceGuard, PlaceRouteGuard } from './lib/place';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0Bjb29sb24vYW5ndWxhci11aS1wb3dlcnVwcy8iLCJzb3VyY2VzIjpbInB1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLHdDQUFjLGtDQUFrQyxDQUFDO0FBQ2pELHdDQUFjLGtCQUFrQixDQUFDO0FBQ2pDLHFOQUFjLGtCQUFrQixDQUFDO0FBQ2pDLHdEQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGtWQUFjLG1CQUFtQixDQUFDO0FBQ2xDLDJmQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2FuZ3VsYXItdWktcG93ZXJ1cHMubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2FuaW1hdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2ludGVyYWN0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BsYWNlJztcbiJdfQ==
+export { NavigationSession, DEFINITION_META_DATA_KEY, ROUTE_PARAMETER_LIST_KEY, PlaceComponent, PlaceDefinition, PlaceHistory, PlaceRouter, Place, PlaceModule, Visit, AbstractPlaceNavigationComponent, BusyOverlayComponent, EmptyStateComponent, ListPlaceNavComponent, PlaceOutletComponent, leftRightPlaceAnimation, LEFT_RIGHT_PLACE_ANIMATION, TabbedPlaceNavigationComponent, Formatter, RouteId, VisitParameter, VisitParameterList, ParameterDefinition, VisitSanitiser, EnterPlaceGuard, LeavePlaceGuard } from './lib/place';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0Bjb29sb24vYW5ndWxhci11aS1wb3dlcnVwcy8iLCJzb3VyY2VzIjpbInB1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLHdDQUFjLGtDQUFrQyxDQUFDO0FBQ2pELHdDQUFjLGtCQUFrQixDQUFDO0FBQ2pDLHVPQUFjLGtCQUFrQixDQUFDO0FBQ2pDLDBFQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGtWQUFjLG1CQUFtQixDQUFDO0FBQ2xDLDJmQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2FuZ3VsYXItdWktcG93ZXJ1cHMubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2FuaW1hdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2ludGVyYWN0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BsYWNlJztcbiJdfQ==