@coolon/angular-ui-powerups 0.0.44 → 0.0.46

package/bundles/coolon-angular-ui-powerups.umd.js

@@ -2085,7 +2085,7 @@
                  * @return {?}
                  */
                 function (parameters) {
-                    return parameters.getResolvedParameterValue(parameterDef);
+                    return parameters.getValueOf(parameterDef);
                 },
                 toLeft: /**
                  * @param {?} value
@@ -2331,7 +2331,7 @@
     var PlaceHistory = /** @class */ (function () {
         function PlaceHistory(router) {
             this.router = router;
-            this._history = [];
+            this._history = new Map();
         }
         /**
          * @param {?} state
@@ -2343,131 +2343,69 @@
          */
         function (state) {
             /** @type {?} */
-            var previousState = ___default__default.last(this._history);
+            var history = this.getHistory(state.placeDefinition);
+            /** @type {?} */
+            var previousState = ___default__default.last(history);
             if (!previousState || state.hasChanged(previousState)) {
-                this._history.push(state);
-                // limit our history to 100 visits
-                this._history = this._history.slice(-100);
+                history.unshift(state); // LIFO
+                this.setHistory(state.placeDefinition, history.slice(-3)); // limit our history to 3 visits
             }
         };
-        PlaceHistory.decorators = [
-            { type: core.Injectable, args: [{
-                        providedIn: 'root'
-                    },] }
-        ];
-        /** @nocollapse */
-        PlaceHistory.ctorParameters = function () { return [
-            { type: router.Router }
-        ]; };
-        /** @nocollapse */ PlaceHistory.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function PlaceHistory_Factory() { return new PlaceHistory(core.ɵɵinject(router.Router)); }, token: PlaceHistory, providedIn: "root" });
-        return PlaceHistory;
-    }());
-    if (false) {
         /**
-         * @type {?}
-         * @private
-         */
-        PlaceHistory.prototype._history;
-        /**
-         * @type {?}
-         * @private
-         */
-        PlaceHistory.prototype.router;
-    }
-
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    var PlaceRouter = /** @class */ (function () {
-        function PlaceRouter(router) {
-            this.router = router;
-        }
-        /**
-         * @param {?} activatedRoute
-         * @param {?} previous
-         * @param {?} next
-         * @return {?}
-         */
-        PlaceRouter.prototype.pushParameterChangesToRoute = /**
-         * @param {?} activatedRoute
-         * @param {?} previous
-         * @param {?} next
-         * @return {?}
-         */
-        function (activatedRoute, previous, next) {
-            this.router.navigate(this.redirect(activatedRoute.snapshot, previous, next), {
-                relativeTo: activatedRoute
-            });
-        };
-        /**
-         * @param {?} activatedRoute
-         * @param {?} sanitised
-         * @param {?} snapshot
+         * @param {?} placeDef
          * @return {?}
          */
-        PlaceRouter.prototype.createUrlTree = /**
-         * @param {?} activatedRoute
-         * @param {?} sanitised
-         * @param {?} snapshot
+        PlaceHistory.prototype.getHistory = /**
+         * @param {?} placeDef
          * @return {?}
          */
-        function (activatedRoute, sanitised, snapshot) {
-            return this.router.createUrlTree(this.redirect(activatedRoute, snapshot, sanitised));
+        function (placeDef) {
+            /** @type {?} */
+            var history = this._history.get(placeDef);
+            if (!history) {
+                history = [];
+                this.setHistory(placeDef, history);
+            }
+            return history;
         };
         /**
-         * @protected
-         * @param {?} activatedRoute
-         * @param {?} previous
-         * @param {?} next
+         * @private
+         * @param {?} placeDef
+         * @param {?} history
          * @return {?}
          */
-        PlaceRouter.prototype.redirect = /**
-         * @protected
-         * @param {?} activatedRoute
-         * @param {?} previous
-         * @param {?} next
+        PlaceHistory.prototype.setHistory = /**
+         * @private
+         * @param {?} placeDef
+         * @param {?} history
          * @return {?}
          */
-        function (activatedRoute, previous, next) {
-            /** @type {?} */
-            var childSegments = ___default__default.flatten(activatedRoute.children.map((/**
-             * @param {?} child
-             * @return {?}
-             */
-            function (child) { return child.url; })));
-            /** @type {?} */
-            var relativePath = !!previous.hasRouteId() ? '..' : '.';
-            /** @type {?} */
-            var routeId = next.getFormattedRouteId();
-            /** @type {?} */
-            var path = routeId ?
-                [relativePath, routeId, next.getFormattedParameters()] :
-                [relativePath, next.getFormattedParameters()];
-            return path.concat(childSegments.map((/**
-             * @param {?} s
-             * @return {?}
-             */
-            function (s) { return s.path; })));
+        function (placeDef, history) {
+            this._history.set(placeDef, history);
         };
-        PlaceRouter.decorators = [
+        PlaceHistory.decorators = [
             { type: core.Injectable, args: [{
                         providedIn: 'root'
                     },] }
         ];
         /** @nocollapse */
-        PlaceRouter.ctorParameters = function () { return [
+        PlaceHistory.ctorParameters = function () { return [
             { type: router.Router }
         ]; };
-        /** @nocollapse */ PlaceRouter.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(core.ɵɵinject(router.Router)); }, token: PlaceRouter, providedIn: "root" });
-        return PlaceRouter;
+        /** @nocollapse */ PlaceHistory.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function PlaceHistory_Factory() { return new PlaceHistory(core.ɵɵinject(router.Router)); }, token: PlaceHistory, providedIn: "root" });
+        return PlaceHistory;
     }());
     if (false) {
         /**
          * @type {?}
          * @private
          */
-        PlaceRouter.prototype.router;
+        PlaceHistory.prototype._history;
+        /**
+         * @type {?}
+         * @private
+         */
+        PlaceHistory.prototype.router;
     }
 
     /**
@@ -2489,11 +2427,8 @@
             /** @type {?} */
             var opts = typescriptUtilities.Opts.get(options);
             this.name = opts.getOptional('as', propertyName);
-            // this.sanitiser = new DefaultParameterSanitiser(
-            //   this,
-            //   opts.getOptional('remember', false),
-            //   opts.getOptional('defaultValue', null)
-            // );
+            this.remember = opts.getOptional('remember', false);
+            this.defaultValue = opts.getOptional('defaultValue', null);
         }
         /**
          * @param {?} injector
@@ -2504,7 +2439,12 @@
          * @return {?}
          */
         function (injector) {
-            return this.sanitiser;
+            if (this.remember || !___default__default.isNil(this.defaultValue)) {
+                return new ParameterDefinition.DefaultParameterSanitiser(this.remember, this.defaultValue, injector.get(PlaceHistory));
+            }
+            else {
+                return null;
+            }
         };
         return ParameterDefinition;
     }());
@@ -2515,8 +2455,16 @@
         exports.ParameterDefinition.prototype.isArray;
         /** @type {?} */
         exports.ParameterDefinition.prototype.name;
-        /** @type {?} */
-        exports.ParameterDefinition.prototype.sanitiser;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.ParameterDefinition.prototype.remember;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.ParameterDefinition.prototype.defaultValue;
         /** @type {?} */
         exports.ParameterDefinition.prototype.propertyName;
         /** @type {?} */
@@ -2608,6 +2556,89 @@
             /** @type {?} */
             ArrayParameter.prototype.isArray;
         }
+        /**
+         * @template T, S
+         */
+        var /**
+         * @template T, S
+         */
+        DefaultParameterSanitiser = /** @class */ (function () {
+            function DefaultParameterSanitiser(remember, defaultValue, placeHistory) {
+                this.remember = remember;
+                this.defaultValue = defaultValue;
+                this.placeHistory = placeHistory;
+            }
+            /**
+             * @param {?} parameterDef
+             * @param {?} value
+             * @param {?=} visit
+             * @return {?}
+             */
+            DefaultParameterSanitiser.prototype.sanitise = /**
+             * @param {?} parameterDef
+             * @param {?} value
+             * @param {?=} visit
+             * @return {?}
+             */
+            function (parameterDef, value, visit) {
+                var _this = this;
+                if (this.isBlank(parameterDef, value)) {
+                    if (this.remember) {
+                        /** @type {?} */
+                        var visits = this.placeHistory.getHistory(visit.placeDefinition);
+                        value = visits.map((/**
+                         * @param {?} v
+                         * @return {?}
+                         */
+                        function (v) { return v.getValueOf(parameterDef); }))
+                            .filter((/**
+                         * @param {?} v
+                         * @return {?}
+                         */
+                        function (v) { return !___default__default.isNil(v); }))
+                            .find((/**
+                         * @param {?} v
+                         * @return {?}
+                         */
+                        function (v) { return !_this.isBlank(parameterDef, v); }));
+                    }
+                    value = this.isBlank(parameterDef, value) ? this.defaultValue : value;
+                    console.log(parameterDef.name + " is blank, returning: " + value);
+                    return value;
+                }
+                else {
+                    console.log(parameterDef.name + " is not blank");
+                    return value;
+                }
+            };
+            /**
+             * @private
+             * @param {?} def
+             * @param {?} value
+             * @return {?}
+             */
+            DefaultParameterSanitiser.prototype.isBlank = /**
+             * @private
+             * @param {?} def
+             * @param {?} value
+             * @return {?}
+             */
+            function (def, value) {
+                /** @type {?} */
+                var isNil = ___default__default.isNil(value);
+                return isNil ? true : def.isArray ? value['length'] < 1 : false;
+            };
+            return DefaultParameterSanitiser;
+        }());
+        ParameterDefinition.DefaultParameterSanitiser = DefaultParameterSanitiser;
+        if (false) {
+            /** @type {?} */
+            DefaultParameterSanitiser.prototype.remember;
+            /** @type {?} */
+            DefaultParameterSanitiser.prototype.defaultValue;
+            /** @type {?} */
+            DefaultParameterSanitiser.prototype.placeHistory;
+        }
     })(exports.ParameterDefinition || (exports.ParameterDefinition = {}));
 
     /**
@@ -2621,24 +2652,31 @@
         }
         /**
          * @param {?} other
+         * @param {?=} debug
          * @return {?}
          */
         ParameterSnapshot.prototype.hasChanged = /**
          * @param {?} other
+         * @param {?=} debug
          * @return {?}
          */
-        function (other) {
+        function (other, debug) {
+            if (debug === void 0) { debug = false; }
             /** @type {?} */
             var changed = this.resolved.find((/**
              * @param {?} r
              * @return {?}
              */
             function (r) {
-                return !r.isSame(other.getResolvedParameterValue(r.parameterDef));
+                return !r.isSame(other.getValueOf(r.parameterDef));
             }));
-            // if (changed) {
-            //   console.log({ mine: changed, theirs: other.getResolvedParameter(changed.parameterDef) });
-            // }
+            if (changed && debug) {
+                console.log({
+                    name: changed.parameterDef.name,
+                    mine: changed.value,
+                    theirs: other.getValueOf(changed.parameterDef)
+                });
+            }
             return !!changed;
         };
         /**
@@ -2646,7 +2684,7 @@
          * @param {?} parameterDef
          * @return {?}
          */
-        ParameterSnapshot.prototype.getResolvedParameter = /**
+        ParameterSnapshot.prototype.getParameter = /**
          * @template T, S
          * @param {?} parameterDef
          * @return {?}
@@ -2663,30 +2701,30 @@
          * @param {?} parameterDef
          * @return {?}
          */
-        ParameterSnapshot.prototype.getResolvedParameterValue = /**
+        ParameterSnapshot.prototype.getValueOf = /**
          * @template T, S
          * @param {?} parameterDef
          * @return {?}
          */
         function (parameterDef) {
             /** @type {?} */
-            var resolvedParameter = this.getResolvedParameter(parameterDef);
+            var resolvedParameter = this.getParameter(parameterDef);
             return resolvedParameter ? resolvedParameter.value : null;
         };
         /**
          * @return {?}
          */
-        ParameterSnapshot.prototype.getRouteId = /**
+        ParameterSnapshot.prototype.getRouteIdValue = /**
          * @return {?}
          */
         function () {
-            return this.getResolvedRouteId() ? this.getResolvedRouteId().value : null;
+            return this.getRouteIdParameter() ? this.getRouteIdParameter().value : null;
         };
         /**
          * @param {?} name
          * @return {?}
          */
-        ParameterSnapshot.prototype.getRouteParameter = /**
+        ParameterSnapshot.prototype.getParameterValue = /**
          * @param {?} name
          * @return {?}
          */
@@ -2703,7 +2741,7 @@
          * @private
          * @return {?}
          */
-        ParameterSnapshot.prototype.getResolvedRouteId = /**
+        ParameterSnapshot.prototype.getRouteIdParameter = /**
          * @private
          * @return {?}
          */
@@ -2716,6 +2754,21 @@
              */
             function (p) { return p.parameterDef.isRouteId; }))));
         };
+        /**
+         * @private
+         * @return {?}
+         */
+        ParameterSnapshot.prototype.getRouteParameters = /**
+         * @private
+         * @return {?}
+         */
+        function () {
+            return this.resolved.filter((/**
+             * @param {?} r
+             * @return {?}
+             */
+            function (r) { return !r.parameterDef.isRouteId; }));
+        };
         /**
          * @return {?}
          */
@@ -2723,7 +2776,7 @@
          * @return {?}
          */
         function () {
-            return !!this.getResolvedRouteId();
+            return !!this.getRouteIdParameter();
         };
         /**
          * @return {?}
@@ -2733,7 +2786,7 @@
          */
         function () {
             /** @type {?} */
-            var routeIdParam = this.getResolvedRouteId();
+            var routeIdParam = this.getRouteIdParameter();
             return routeIdParam ? routeIdParam.formattedValue() : null;
         };
         /**
@@ -2759,6 +2812,25 @@
             }));
             return params;
         };
+        /**
+         * @return {?}
+         */
+        ParameterSnapshot.prototype.getAllFormattedParameters = /**
+         * @return {?}
+         */
+        function () {
+            /** @type {?} */
+            var params = {};
+            /** @type {?} */
+            var routeIdParam = this.resolved.forEach((/**
+             * @param {?} p
+             * @return {?}
+             */
+            function (p) {
+                params[p.parameterDef.name] = p.formattedValue();
+            }));
+            return params;
+        };
         /**
          * @template T, S
          * @param {?} parameter
@@ -2790,8 +2862,40 @@
          */
         function (injector) {
             return __awaiter(this, void 0, void 0, function () {
+                var routeId, sanitisedValue, result, routeParameters, i, sanitisedValue;
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this];
+                    switch (_a.label) {
+                        case 0:
+                            if (!this.hasRouteId()) return [3 /*break*/, 2];
+                            routeId = this.getRouteIdParameter();
+                            return [4 /*yield*/, routeId.sanitise(this, injector)];
+                        case 1:
+                            sanitisedValue = _a.sent();
+                            if (!routeId.isSame(sanitisedValue)) {
+                                // if the route id has changed we redirect immediately as other
+                                // parameter sanitisers might use it.
+                                return [2 /*return*/, this.replace(routeId.parameterDef, sanitisedValue)];
+                            }
+                            _a.label = 2;
+                        case 2:
+                            result = this;
+                            routeParameters = this.getRouteParameters();
+                            i = 0;
+                            _a.label = 3;
+                        case 3:
+                            if (!(i < routeParameters.length)) return [3 /*break*/, 6];
+                            return [4 /*yield*/, routeParameters[i].sanitise(this, injector)];
+                        case 4:
+                            sanitisedValue = _a.sent();
+                            if (!routeParameters[i].isSame(sanitisedValue)) {
+                                result = this.replace(routeParameters[i].parameterDef, sanitisedValue);
+                            }
+                            _a.label = 5;
+                        case 5:
+                            i++;
+                            return [3 /*break*/, 3];
+                        case 6: return [2 /*return*/, result];
+                    }
                 });
             });
         };
@@ -2801,25 +2905,37 @@
             __metadata("design:type", Function),
             __metadata("design:paramtypes", [exports.ParameterDefinition]),
             __metadata("design:returntype", ParameterSnapshot.ResolvedParameter)
-        ], ParameterSnapshot.prototype, "getResolvedParameter", null);
+        ], ParameterSnapshot.prototype, "getParameter", null);
         __decorate([
             src.Memoize(),
             __metadata("design:type", Function),
             __metadata("design:paramtypes", [exports.ParameterDefinition]),
             __metadata("design:returntype", typeof (_a = typeof S !== "undefined" && S) === "function" ? _a : Object)
-        ], ParameterSnapshot.prototype, "getResolvedParameterValue", null);
+        ], ParameterSnapshot.prototype, "getValueOf", null);
         __decorate([
             src.Memoize(),
             __metadata("design:type", Function),
             __metadata("design:paramtypes", [String]),
             __metadata("design:returntype", Object)
-        ], ParameterSnapshot.prototype, "getRouteParameter", null);
+        ], ParameterSnapshot.prototype, "getParameterValue", null);
         __decorate([
             src.Memoize(),
             __metadata("design:type", Function),
             __metadata("design:paramtypes", []),
             __metadata("design:returntype", ParameterSnapshot.ResolvedValueParameter)
-        ], ParameterSnapshot.prototype, "getResolvedRouteId", null);
+        ], ParameterSnapshot.prototype, "getRouteIdParameter", null);
+        __decorate([
+            src.Memoize(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Array)
+        ], ParameterSnapshot.prototype, "getRouteParameters", null);
+        __decorate([
+            pectin.Trace(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [core.Injector]),
+            __metadata("design:returntype", Promise)
+        ], ParameterSnapshot.prototype, "sanitise", null);
         return ParameterSnapshot;
     }());
     if (false) {
@@ -2834,10 +2950,13 @@
     (function (ParameterSnapshot) {
         /**
          * @param {?} placeDef
-         * @param {?} paramMap
+         * @param {?} params
+         * @param {?} urlSegments
          * @return {?}
          */
-        function create(placeDef, paramMap) {
+        function create(placeDef, params, urlSegments) {
+            /** @type {?} */
+            var paramMap = new ConsolidatedParameterMap(params, urlSegments);
             /** @type {?} */
             var resolvedParameters = placeDef.getRouteParameters()
                 .map((/**
@@ -2847,7 +2966,11 @@
             function (def) {
                 if (def.isArray) {
                     /** @type {?} */
-                    var value = paramMap.has(def.name) ? paramMap.getAll(def.name).map((/**
+                    var value = paramMap.has(def.name) ? paramMap.getAll(def.name).filter((/**
+                     * @param {?} s
+                     * @return {?}
+                     */
+                    function (s) { return !___default__default.isEmpty(s); })).map((/**
                      * @param {?} raw
                      * @return {?}
                      */
@@ -2863,6 +2986,140 @@
             return new ParameterSnapshot(placeDef, resolvedParameters);
         }
         ParameterSnapshot.create = create;
+        /**
+         * 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 /**
+         * 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.
+         */
+        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) {
+                return this.paramMaps.find((/**
+                 * @param {?} m
+                 * @return {?}
+                 */
+                function (m) { return m.has(name); })).get(name);
+            };
+            /**
+             * @param {?} name
+             * @return {?}
+             */
+            ConsolidatedParameterMap.prototype.getAll = /**
+             * @param {?} name
+             * @return {?}
+             */
+            function (name) {
+                return this.paramMaps.find((/**
+                 * @param {?} m
+                 * @return {?}
+                 */
+                function (m) { return m.has(name); })).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); }));
+            };
+            return 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;
+        }
         /**
          * @abstract
          * @template T, S
@@ -2885,6 +3142,31 @@
             function () {
                 return this.parameterDef.isRouteId;
             };
+            /**
+             * @param {?} visit
+             * @param {?} injector
+             * @return {?}
+             */
+            ResolvedParameter.prototype.sanitise = /**
+             * @param {?} visit
+             * @param {?} injector
+             * @return {?}
+             */
+            function (visit, injector) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var sanitiser;
+                    return __generator(this, function (_a) {
+                        sanitiser = this.parameterDef.getSanitiser(injector);
+                        if (sanitiser) {
+                            return [2 /*return*/, sanitiser.sanitise(this.parameterDef, this.value, visit)];
+                        }
+                        else {
+                            return [2 /*return*/, this.value];
+                        }
+                        return [2 /*return*/];
+                    });
+                });
+            };
             return ResolvedParameter;
         }());
         ParameterSnapshot.ResolvedParameter = ResolvedParameter;
@@ -3041,6 +3323,115 @@
         ParameterSnapshot.ResolvedArrayParameter = ResolvedArrayParameter;
     })(exports.ParameterSnapshot || (exports.ParameterSnapshot = {}));
 
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var PlaceRouter = /** @class */ (function () {
+        function PlaceRouter(router) {
+            this.router = router;
+        }
+        /**
+         * @param {?} activatedRoute
+         * @param {?} previous
+         * @param {?} next
+         * @return {?}
+         */
+        PlaceRouter.prototype.pushParameterChangesToRoute = /**
+         * @param {?} activatedRoute
+         * @param {?} previous
+         * @param {?} next
+         * @return {?}
+         */
+        function (activatedRoute, previous, next) {
+            /** @type {?} */
+            var relativePath = !!previous.hasRouteId() ? '..' : '.';
+            this.router.navigate([relativePath].concat(this.createRouteParameters(next), this.getChildPath(activatedRoute.snapshot)), {
+                relativeTo: activatedRoute
+            });
+        };
+        /**
+         * @param {?} activatedRoute
+         * @param {?} sanitised
+         * @return {?}
+         */
+        PlaceRouter.prototype.getRedirectUrlTree = /**
+         * @param {?} activatedRoute
+         * @param {?} sanitised
+         * @return {?}
+         */
+        function (activatedRoute, sanitised) {
+            /** @type {?} */
+            var urlSegments = activatedRoute.url;
+            /** @type {?} */
+            var weHaveARouteId = sanitised.hasRouteId() && sanitised.getFormattedRouteId();
+            /** @type {?} */
+            var commands = (weHaveARouteId) ?
+                [urlSegments[0].path, sanitised.getFormattedRouteId(), sanitised.getFormattedParameters()] :
+                [urlSegments[0].path, sanitised.getFormattedParameters()];
+            console.log("redirect path", commands);
+            return this.router.createUrlTree(commands);
+        };
+        /**
+         * @protected
+         * @param {?} activatedRoute
+         * @return {?}
+         */
+        PlaceRouter.prototype.getChildPath = /**
+         * @protected
+         * @param {?} activatedRoute
+         * @return {?}
+         */
+        function (activatedRoute) {
+            return ___default__default.flatten(activatedRoute.children.map((/**
+             * @param {?} child
+             * @return {?}
+             */
+            function (child) { return child.url; })));
+        };
+        /**
+         * @protected
+         * @param {?} parameters
+         * @return {?}
+         */
+        PlaceRouter.prototype.createRouteParameters = /**
+         * @protected
+         * @param {?} parameters
+         * @return {?}
+         */
+        function (parameters) {
+            /** @type {?} */
+            var routeId = parameters.getFormattedRouteId();
+            return routeId ?
+                [routeId, parameters.getFormattedParameters()] :
+                [parameters.getFormattedParameters()];
+        };
+        PlaceRouter.decorators = [
+            { type: core.Injectable, args: [{
+                        providedIn: 'root'
+                    },] }
+        ];
+        /** @nocollapse */
+        PlaceRouter.ctorParameters = function () { return [
+            { type: router.Router }
+        ]; };
+        /** @nocollapse */ PlaceRouter.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(core.ɵɵinject(router.Router)); }, token: PlaceRouter, providedIn: "root" });
+        __decorate([
+            pectin.Trace(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [router.ActivatedRouteSnapshot, exports.ParameterSnapshot]),
+            __metadata("design:returntype", router.UrlTree)
+        ], PlaceRouter.prototype, "getRedirectUrlTree", null);
+        return PlaceRouter;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        PlaceRouter.prototype.router;
+    }
+
     /**
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -3128,19 +3519,25 @@
             _this._placeDefinition = new pectin.MutableValueModel();
             _this._resolvedParameters = new pectin.MutableValueModel();
             var _a = pectin.Dsl.disposeWith(_this), chain = _a.chain, valueOf = _a.valueOf, before = _a.before, when = _a.when, after = _a.after, observe = _a.observe, switchOn = _a.switchOn;
-            _this._paramMap = chain(_this._activatedRouteModel).pullObservableValue((/**
+            /** @type {?} */
+            var paramMap = chain(_this._activatedRouteModel).pullObservableValue((/**
              * @param {?} ar
              * @return {?}
              */
             function (ar) { return ar.paramMap; }));
-            _this.placeConfigured = valueOf.all(chain(_this._inOutletUpdate).isFalsey(), _this._placeDefinition, _this._paramMap).areTruthy();
-            when.valueOf(_this._paramMap).changes((/**
-             * @param {?} params
+            /** @type {?} */
+            var urls = chain(_this._activatedRouteModel).pullObservableValue((/**
+             * @param {?} ar
+             * @return {?}
+             */
+            function (ar) { return ar.url; }));
+            _this.placeConfigured = valueOf.all(chain(_this._inOutletUpdate).isFalsey(), _this._placeDefinition, paramMap, urls).areTruthy();
+            when.anyOf(paramMap, urls).changes((/**
              * @return {?}
              */
-            function (params) {
+            function () {
                 /** @type {?} */
-                var snapshot = exports.ParameterSnapshot.create(_this._placeDefinition.value, params);
+                var snapshot = exports.ParameterSnapshot.create(_this._placeDefinition.value, paramMap.value, urls.value);
                 _this._incomingRouteChange.whileTrue((/**
                  * @return {?}
                  */
@@ -3163,6 +3560,10 @@
                 unless: _this.incomingRouteChange
             });
             return _this;
+            // const txo = new TransactionObserver().onEvent(e => console.log(e.toString()));
+            // txo.observe('paramMap', paramMap);
+            // txo.observe('urls', urls);
+            // txo.observe('this._resolvedParameters', this._resolvedParameters);
         }
         Object.defineProperty(PlaceOutletComponent.prototype, "incomingRouteChange", {
             get: /**
@@ -3333,11 +3734,6 @@
          * @private
          */
         PlaceOutletComponent.prototype._placeDefinition;
-        /**
-         * @type {?}
-         * @private
-         */
-        PlaceOutletComponent.prototype._paramMap;
         /** @type {?} */
         PlaceOutletComponent.prototype._resolvedParameters;
         /**
@@ -3911,12 +4307,12 @@
         /**
          * @return {?}
          */
-        Visit.prototype.getRouteId = function () { };
+        Visit.prototype.getRouteIdValue = function () { };
         /**
          * @param {?} name
          * @return {?}
          */
-        Visit.prototype.getRouteParameter = function (name) { };
+        Visit.prototype.getParameterValue = function (name) { };
     }
 
     /**
@@ -4015,14 +4411,14 @@
                 /** @type {?} */
                 var placeDefinition = exports.PlaceComponent.getDefinition(activatedRoute.component);
                 /** @type {?} */
-                var snapshot_1 = exports.ParameterSnapshot.create(placeDefinition, activatedRoute.paramMap);
+                var snapshot_1 = exports.ParameterSnapshot.create(placeDefinition, activatedRoute.paramMap, activatedRoute.url);
                 return snapshot_1.sanitise(this.injector).then((/**
                  * @param {?} sanitised
                  * @return {?}
                  */
                 function (sanitised) {
-                    if (sanitised.hasChanged(snapshot_1)) {
-                        return _this.placeRouter.createUrlTree(activatedRoute, snapshot_1, sanitised);
+                    if (sanitised.hasChanged(snapshot_1, true)) {
+                        return _this.placeRouter.getRedirectUrlTree(activatedRoute, sanitised);
                     }
                     else {
                         return true;
@@ -4059,75 +4455,6 @@
         PlaceRouteGuard.prototype.injector;
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template T, S
-     */
-    var DefaultParameterSanitiser = /** @class */ (function () {
-        function DefaultParameterSanitiser(def, remember, defaultValue) {
-            this.def = def;
-            this.remember = remember;
-            this.defaultValue = defaultValue;
-        }
-        /**
-         * @param {?} value
-         * @param {?} visit
-         * @return {?}
-         */
-        DefaultParameterSanitiser.prototype.sanitise = /**
-         * @param {?} value
-         * @param {?} visit
-         * @return {?}
-         */
-        function (value, visit) {
-            if (this.isBlank(value)) {
-                if (this.remember) {
-                    // value = null;
-                }
-                return this.isBlank(value) && !___default__default.isNil(this.defaultValue) ? this.defaultValue : value;
-            }
-            else {
-                return value;
-            }
-        };
-        /**
-         * @private
-         * @param {?} value
-         * @return {?}
-         */
-        DefaultParameterSanitiser.prototype.isBlank = /**
-         * @private
-         * @param {?} value
-         * @return {?}
-         */
-        function (value) {
-            /** @type {?} */
-            var isNil = ___default__default.isNil(value);
-            return this.def.isArray ? !isNil || value['length'] < 1 : isNil;
-        };
-        __decorate([
-            pectin.Trace(),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Object, Object]),
-            __metadata("design:returntype", Object)
-        ], DefaultParameterSanitiser.prototype, "sanitise", null);
-        return DefaultParameterSanitiser;
-    }());
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        DefaultParameterSanitiser.prototype.def;
-        /** @type {?} */
-        DefaultParameterSanitiser.prototype.remember;
-        /** @type {?} */
-        DefaultParameterSanitiser.prototype.defaultValue;
-    }
-
     /**
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -4239,16 +4566,17 @@
      */
     /**
      * @record
-     * @template T
+     * @template S
      */
     function ParameterSanitiser() { }
     if (false) {
         /**
+         * @param {?} parameterDef
          * @param {?} value
          * @param {?=} visit
          * @return {?}
          */
-        ParameterSanitiser.prototype.sanitise = function (value, visit) { };
+        ParameterSanitiser.prototype.sanitise = function (parameterDef, value, visit) { };
     }
 
     /**
@@ -4443,7 +4771,7 @@
                             if (!this.sanitiser) return [3 /*break*/, 2];
                             this.initialValue = this.readFrom(this.snapshot);
                             _a = this;
-                            return [4 /*yield*/, this.sanitiser.sanitise(this.initialValue)];
+                            return [4 /*yield*/, this.sanitiser.sanitise(null, this.initialValue)];
                         case 1:
                             _a._sanitisedValue = _b.sent();
                             if (this.initialValue !== this._sanitisedValue) {
@@ -4783,7 +5111,6 @@
     exports.CommandDirective = CommandDirective;
     exports.ConfirmationDialogComponent = ConfirmationDialogComponent;
     exports.DEFINITION_META_DATA_KEY = DEFINITION_META_DATA_KEY;
-    exports.DefaultParameterSanitiser = DefaultParameterSanitiser;
     exports.DialogInteractionService = DialogInteractionService;
     exports.Dimension = Dimension;
     exports.DisposableComponent = DisposableComponent;