@coolon/angular-ui-powerups 0.0.66 → 0.0.68

package/esm5/lib/place/route/guards/leave-place.guard.js

@@ -0,0 +1,152 @@
+/**
+ * @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 { InteractionContext } from '../../../interaction/interaction-context';
+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 "../../../interaction/interaction-context";
+import * as i4 from "@angular/common";
+var LeavePlaceGuard = /** @class */ (function () {
+    function LeavePlaceGuard(router, injector, placeRouter, interactionContext, angularLocation) {
+        this.router = router;
+        this.injector = injector;
+        this.placeRouter = placeRouter;
+        this.interactionContext = interactionContext;
+        this.angularLocation = angularLocation;
+    }
+    /**
+     * @private
+     * @param {?} nextState
+     * @param {?} placeDefinitionPath
+     * @return {?}
+     */
+    LeavePlaceGuard.prototype.isLeavingTheCurrentPlace = /**
+     * @private
+     * @param {?} nextState
+     * @param {?} placeDefinitionPath
+     * @return {?}
+     */
+    function (nextState, placeDefinitionPath) {
+        // TODO: this will break with child routes... need to examine the router states properly.
+        return !nextState.url.startsWith(placeDefinitionPath);
+    };
+    /**
+     * @param {?} component
+     * @param {?} currentRoute
+     * @param {?} currentState
+     * @param {?=} nextState
+     * @return {?}
+     */
+    LeavePlaceGuard.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 placeDefinitionPath, 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
+                        // navigation session.
+                        return [2 /*return*/, true];
+                    case 1:
+                        self_1 = this;
+                        canLeave = true;
+                        if (!this.isLeavingTheCurrentPlace(nextState, placeDefinitionPath)) 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
+                        if (this.interactionContext.isActive()) {
+                            canLeave = false;
+                            console.log('cancelling', { activity: this.interactionContext.currentActivity });
+                            this.interactionContext.currentActivity.cancel(null);
+                        }
+                        if (!canLeave) return [3 /*break*/, 3];
+                        return [4 /*yield*/, component.canDeactivate()];
+                    case 2:
+                        // TODO: Add tests: hit back -> confirm leave dialog -> hit back -> close dialog ->  hit back -> confirm leave dialog.
+                        canLeave = _a.sent();
+                        _a.label = 3;
+                    case 3: return [3 /*break*/, 5];
+                    case 4:
+                        if (this.interactionContext.isActive()) {
+                            console.log('cancelling', { activity: this.interactionContext.currentActivity });
+                            this.interactionContext.currentActivity.cancel(null);
+                            canLeave = false;
+                        }
+                        else {
+                            canLeave = true;
+                        }
+                        _a.label = 5;
+                    case 5:
+                        if (canLeave) {
+                            // We'll get called multiple times if there's any parameter sanitisation so
+                            // we remember the acceptance for the duration of the current navigation session.
+                            self_1.placeRouter.navigationSession.rememberAcceptanceOf(component);
+                        }
+                        else {
+                            // Angular doesn't preserve the url when a guard cancels the back button.
+                            // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
+                            if (this.placeRouter.navigationSession.isPopState) {
+                                console.log('cancelled during popstate');
+                                this.angularLocation.go(this.placeRouter.navigationSession.popStateReturnUrl);
+                            }
+                        }
+                        return [2 /*return*/, canLeave];
+                }
+            });
+        });
+    };
+    LeavePlaceGuard.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    LeavePlaceGuard.ctorParameters = function () { return [
+        { type: Router },
+        { type: Injector },
+        { type: PlaceRouter },
+        { type: InteractionContext },
+        { 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" });
+    return LeavePlaceGuard;
+}());
+export { LeavePlaceGuard };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    LeavePlaceGuard.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    LeavePlaceGuard.prototype.injector;
+    /**
+     * @type {?}
+     * @private
+     */
+    LeavePlaceGuard.prototype.placeRouter;
+    /** @type {?} */
+    LeavePlaceGuard.prototype.interactionContext;
+    /** @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"]}

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

@@ -0,0 +1,273 @@
+/**
+ * @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 } 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 PlaceRouteGuard = /** @class */ (function () {
+    function PlaceRouteGuard(router, placeRouter, placeHistory, injector) {
+        this.router = router;
+        this.placeRouter = placeRouter;
+        this.placeHistory = placeHistory;
+        this.injector = injector;
+    }
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    PlaceRouteGuard.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, updatedVisit, parameterCommands, 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 PlaceRouteGuard.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:
+                        updatedVisit = _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(updatedVisit);
+                        if (initialVisit.hasRoutingChangedFrom(updatedVisit)) {
+                            parameterCommands = updatedVisit.hasRouteId() ?
+                                [placeDefinition.getFormattedRouteId(updatedVisit), placeDefinition.getFormattedRouteParameters(updatedVisit)] :
+                                [placeDefinition.getFormattedRouteParameters(updatedVisit)];
+                            commands = [(activatedRoute.url[0].path)].concat(parameterCommands, this.placeRouter.getChildPath(activatedRoute));
+                            console.log('##### 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*/];
+                }
+            });
+        });
+    };
+    PlaceRouteGuard.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    PlaceRouteGuard.ctorParameters = function () { return [
+        { type: Router },
+        { type: PlaceRouter },
+        { type: PlaceHistory },
+        { type: Injector }
+    ]; };
+    /** @nocollapse */ PlaceRouteGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function PlaceRouteGuard_Factory() { return new PlaceRouteGuard(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.PlaceRouter), i0.ɵɵinject(i3.PlaceHistory), i0.ɵɵinject(i0.INJECTOR)); }, token: PlaceRouteGuard, providedIn: "root" });
+    return PlaceRouteGuard;
+}());
+export { PlaceRouteGuard };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouteGuard.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouteGuard.prototype.placeRouter;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouteGuard.prototype.placeHistory;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouteGuard.prototype.injector;
+}
+(function (PlaceRouteGuard) {
+    /**
+     * 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;
+    }());
+    PlaceRouteGuard.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;
+    }
+})(PlaceRouteGuard || (PlaceRouteGuard = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"place-route.guard.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/route/guards/place-route.guard.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  UrlTree\n} from '@angular/router';\nimport { lang, Trace } 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 PlaceRouteGuard implements CanActivate {\n\n  constructor(private readonly router: Router,\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 PlaceRouteGuard.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 updatedVisit = 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(updatedVisit);\n      if (initialVisit.hasRoutingChangedFrom(updatedVisit)) {\n        const parameterCommands = updatedVisit.hasRouteId() ?\n          [placeDefinition.getFormattedRouteId(updatedVisit), placeDefinition.getFormattedRouteParameters(updatedVisit)] :\n          [placeDefinition.getFormattedRouteParameters(updatedVisit)];\n\n        const commands = [(activatedRoute.url[0].path)].concat(parameterCommands, this.placeRouter.getChildPath(activatedRoute));\n        console.log('##### 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  // createVisitFrom(placeDef: PlaceDefinition, activatedRoute: ActivatedRouteSnapshot): Visit {\n  //   const paramMap = new ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);\n  //   const resolvedParameters = placeDef.getAllParameterDefs().map(def => RouteParameterRecord.create(def, paramMap));\n  //   return new PlaceParameterSnapshot(placeDef, resolvedParameters);\n  // }\n\n  // createRedirect(activatedRoute: ActivatedRouteSnapshot, snapshot: Visit): UrlTree | true {\n  //   // We have to save the our private state in our session the router ignores a bunch of routing extras\n  //   // when used in route guards.\n  //   // @see https://github.com/angular/angular/issues/27148\n  //   if (snapshot.hasChangedPrivateParameters()) {\n  //     this._navigationSession.value = this._navigationSession.value.mergePrivatePlaceParameters(snapshot.getPrivatePlaceParameters());\n  //   }\n  //   return snapshot.hasChangedRouteParameters(true) ?\n  //     this.router.createUrlTree(this.createRouteCommands(activatedRoute, snapshot), {\n  //       replaceUrl: snapshot.hasChangedRouteParameters(true),\n  //       skipLocationChange: snapshot.hasChangedRouteParameters(true)\n  //     }) :\n  //     true;\n// }\n\n// private createRouteCommands(activatedRoute: ActivatedRouteSnapshot, snapshot: Visit) {\n//   const urlSegments = activatedRoute.url;\n//   const weHaveARouteId = snapshot.hasRouteId() && snapshot.getFormattedRouteId();\n//   return (weHaveARouteId) ?\n//     [urlSegments[0].path, snapshot.getFormattedRouteId(), snapshot.getFormattedRouteParameters()] :\n//     [urlSegments[0].path, snapshot.getFormattedRouteParameters()];\n// }\n\n}\n\nexport namespace PlaceRouteGuard {\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/parameter-decorators.js

@@ -10,31 +10,50 @@ import { ParameterDefinition } from './parameter-definition.class';
  * @record
  * @template T
  */
-export function ParameterOptions() { }
+export function RouteIdOptions() { }
 if (false) {
     /** @type {?|undefined} */
-    ParameterOptions.prototype.as;
+    RouteIdOptions.prototype.as;
     /** @type {?|undefined} */
-    ParameterOptions.prototype.optional;
+    RouteIdOptions.prototype.optional;
     /** @type {?|undefined} */
-    ParameterOptions.prototype.remember;
+    RouteIdOptions.prototype.remember;
     /** @type {?|undefined} */
-    ParameterOptions.prototype.defaultValue;
+    RouteIdOptions.prototype.defaultValue;
 }
 /**
  * @record
  * @template T
  */
-export function ListParameterOptions() { }
+export function RouteParameterOptions() { }
 if (false) {
     /** @type {?|undefined} */
-    ListParameterOptions.prototype.as;
+    RouteParameterOptions.prototype.as;
     /** @type {?|undefined} */
-    ListParameterOptions.prototype.optional;
+    RouteParameterOptions.prototype.optional;
     /** @type {?|undefined} */
-    ListParameterOptions.prototype.remember;
+    RouteParameterOptions.prototype.remember;
     /** @type {?|undefined} */
-    ListParameterOptions.prototype.defaultValue;
+    RouteParameterOptions.prototype.defaultValue;
+    /** @type {?|undefined} */
+    RouteParameterOptions.prototype.storeInUrl;
+}
+/**
+ * @record
+ * @template T
+ */
+export function RouteListParameterOptions() { }
+if (false) {
+    /** @type {?|undefined} */
+    RouteListParameterOptions.prototype.as;
+    /** @type {?|undefined} */
+    RouteListParameterOptions.prototype.optional;
+    /** @type {?|undefined} */
+    RouteListParameterOptions.prototype.remember;
+    /** @type {?|undefined} */
+    RouteListParameterOptions.prototype.defaultValue;
+    /** @type {?|undefined} */
+    RouteListParameterOptions.prototype.storeInUrl;
 }
 /**
  * @template T
@@ -50,18 +69,17 @@ export function RouteId(type, options) {
      */
     function (prototype, propertyKey) {
         /** @type {?} */
-        var param = new ParameterDefinition.RouteId(propertyKey.toString(), type, options);
+        var param = new ParameterDefinition.RouteId(propertyKey.toString(), options, type);
         Klass.get(prototype).addToOwnMetadataList(ROUTE_PARAMETER_LIST_KEY, param);
         UseDelegate()(prototype, propertyKey);
     });
 }
 /**
  * @template T
- * @param {?} type
  * @param {?=} options
  * @return {?}
  */
-export function RouteParameter(type, options) {
+export function VisitParameter(options) {
     return (/**
      * @param {?} prototype
      * @param {?} propertyKey
@@ -69,18 +87,17 @@ export function RouteParameter(type, options) {
      */
     function (prototype, propertyKey) {
         /** @type {?} */
-        var param = new ParameterDefinition.ValueParameter(propertyKey.toString(), type, options);
+        var param = new ParameterDefinition.ValueParameter(propertyKey.toString(), options, options.storeInUrl);
         Klass.get(prototype).addToOwnMetadataList(ROUTE_PARAMETER_LIST_KEY, param);
         UseDelegate()(prototype, propertyKey);
     });
 }
 /**
  * @template E
- * @param {?} elementType
  * @param {?=} options
  * @return {?}
  */
-export function RouteParameterList(elementType, options) {
+export function VisitParameterList(options) {
     return (/**
      * @param {?} prototype
      * @param {?} propertyKey
@@ -88,9 +105,9 @@ export function RouteParameterList(elementType, options) {
      */
     function (prototype, propertyKey) {
         /** @type {?} */
-        var param = new ParameterDefinition.ArrayParameter(propertyKey.toString(), elementType, options);
+        var param = new ParameterDefinition.ArrayParameter(propertyKey.toString(), options, options.storeInUrl);
         Klass.get(prototype).addToOwnMetadataList(ROUTE_PARAMETER_LIST_KEY, param);
         UseDelegate()(prototype, propertyKey);
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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