@coolon/angular-ui-powerups 0.0.44 → 0.0.47

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

@@ -1266,7 +1266,10 @@
     /**
      * @template D, R, E
      */
-    var AbstractActivity = /** @class */ (function (_super) {
+    var   /**
+     * @template D, R, E
+     */
+    AbstractActivity = /** @class */ (function (_super) {
         __extends(AbstractActivity, _super);
         function AbstractActivity() {
             var _this = _super !== null && _super.apply(this, arguments) || this;
@@ -1340,10 +1343,14 @@
              */
             function () { return _this.finalizeAndDispose(); }));
         };
+        // @Trace()
+        // @Trace()
         /**
          * @return {?}
          */
-        AbstractActivity.prototype.onActivityReady = /**
+        AbstractActivity.prototype.onActivityReady = 
+        // @Trace()
+        /**
          * @return {?}
          */
         function () {
@@ -1405,12 +1412,6 @@
         function () {
             return this._busyModel.value;
         };
-        __decorate([
-            pectin.Trace(),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", []),
-            __metadata("design:returntype", void 0)
-        ], AbstractActivity.prototype, "onActivityReady", null);
         return AbstractActivity;
     }(DisposableComponent));
     if (false) {
@@ -2085,7 +2086,7 @@
                  * @return {?}
                  */
                 function (parameters) {
-                    return parameters.getResolvedParameterValue(parameterDef);
+                    return parameters.getValueOf(parameterDef);
                 },
                 toLeft: /**
                  * @param {?} value
@@ -2331,7 +2332,7 @@
     var PlaceHistory = /** @class */ (function () {
         function PlaceHistory(router) {
             this.router = router;
-            this._history = [];
+            this._history = new Map();
         }
         /**
          * @param {?} state
@@ -2343,12 +2344,45 @@
          */
         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
+            }
+        };
+        /**
+         * @param {?} placeDef
+         * @return {?}
+         */
+        PlaceHistory.prototype.getHistory = /**
+         * @param {?} placeDef
+         * @return {?}
+         */
+        function (placeDef) {
+            /** @type {?} */
+            var history = this._history.get(placeDef);
+            if (!history) {
+                history = [];
+                this.setHistory(placeDef, history);
             }
+            return history;
+        };
+        /**
+         * @private
+         * @param {?} placeDef
+         * @param {?} history
+         * @return {?}
+         */
+        PlaceHistory.prototype.setHistory = /**
+         * @private
+         * @param {?} placeDef
+         * @param {?} history
+         * @return {?}
+         */
+        function (placeDef, history) {
+            this._history.set(placeDef, history);
         };
         PlaceHistory.decorators = [
             { type: core.Injectable, args: [{
@@ -2396,59 +2430,71 @@
          * @return {?}
          */
         function (activatedRoute, previous, next) {
-            this.router.navigate(this.redirect(activatedRoute.snapshot, previous, next), {
+            /** @type {?} */
+            var relativePath = !!previous.hasRouteId() ? '..' : '.';
+            this.router.navigate([relativePath].concat(this.createRouteParameters(next), this.getChildPath(activatedRoute.snapshot)), {
                 relativeTo: activatedRoute
             });
         };
+        // @Trace()
+        // @Trace()
         /**
          * @param {?} activatedRoute
          * @param {?} sanitised
-         * @param {?} snapshot
          * @return {?}
          */
-        PlaceRouter.prototype.createUrlTree = /**
+        PlaceRouter.prototype.getRedirectUrlTree = 
+        // @Trace()
+        /**
          * @param {?} activatedRoute
          * @param {?} sanitised
-         * @param {?} snapshot
          * @return {?}
          */
-        function (activatedRoute, sanitised, snapshot) {
-            return this.router.createUrlTree(this.redirect(activatedRoute, snapshot, sanitised));
+        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
-         * @param {?} previous
-         * @param {?} next
          * @return {?}
          */
-        PlaceRouter.prototype.redirect = /**
+        PlaceRouter.prototype.getChildPath = /**
          * @protected
          * @param {?} activatedRoute
-         * @param {?} previous
-         * @param {?} next
          * @return {?}
          */
-        function (activatedRoute, previous, next) {
-            /** @type {?} */
-            var childSegments = ___default__default.flatten(activatedRoute.children.map((/**
+        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 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; })));
+            var routeId = parameters.getFormattedRouteId();
+            return routeId ?
+                [routeId, parameters.getFormattedParameters()] :
+                [parameters.getFormattedParameters()];
         };
         PlaceRouter.decorators = [
             { type: core.Injectable, args: [{
@@ -2489,11 +2535,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 +2547,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 +2563,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 +2664,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 +2760,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 +2792,7 @@
          * @param {?} parameterDef
          * @return {?}
          */
-        ParameterSnapshot.prototype.getResolvedParameter = /**
+        ParameterSnapshot.prototype.getParameter = /**
          * @template T, S
          * @param {?} parameterDef
          * @return {?}
@@ -2663,30 +2809,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 +2849,7 @@
          * @private
          * @return {?}
          */
-        ParameterSnapshot.prototype.getResolvedRouteId = /**
+        ParameterSnapshot.prototype.getRouteIdParameter = /**
          * @private
          * @return {?}
          */
@@ -2716,6 +2862,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 +2884,7 @@
          * @return {?}
          */
         function () {
-            return !!this.getResolvedRouteId();
+            return !!this.getRouteIdParameter();
         };
         /**
          * @return {?}
@@ -2733,7 +2894,7 @@
          */
         function () {
             /** @type {?} */
-            var routeIdParam = this.getResolvedRouteId();
+            var routeIdParam = this.getRouteIdParameter();
             return routeIdParam ? routeIdParam.formattedValue() : null;
         };
         /**
@@ -2759,6 +2920,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
@@ -2780,18 +2960,54 @@
                 return p.parameterDef === parameter ? p.replace(value) : p;
             })));
         };
+        // @Trace()
+        // @Trace()
         /**
          * @param {?} injector
          * @return {?}
          */
-        ParameterSnapshot.prototype.sanitise = /**
+        ParameterSnapshot.prototype.sanitise = 
+        // @Trace()
+        /**
          * @param {?} injector
          * @return {?}
          */
         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 +3017,31 @@
             __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);
         return ParameterSnapshot;
     }());
     if (false) {
@@ -2834,10 +3056,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 +3072,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 +3092,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 +3248,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;
@@ -3128,19 +3516,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 (params) {
+            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 () {
                 /** @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 +3557,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 +3731,6 @@
          * @private
          */
         PlaceOutletComponent.prototype._placeDefinition;
-        /**
-         * @type {?}
-         * @private
-         */
-        PlaceOutletComponent.prototype._paramMap;
         /** @type {?} */
         PlaceOutletComponent.prototype._resolvedParameters;
         /**
@@ -3911,12 +4304,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 +4408,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 +4452,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 +4563,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 +4768,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) {
@@ -4584,10 +4909,14 @@
             pectin.assert.isTruthy(this.parameterSanitisers.length !== 0);
             return this.routeIdSanitiser && this.routeIdSanitiser.valueChanged;
         };
+        // @Trace()
+        // @Trace()
         /**
          * @return {?}
          */
-        RouteParameterSanitiser.prototype.getRedirectParams = /**
+        RouteParameterSanitiser.prototype.getRedirectParams = 
+        // @Trace()
+        /**
          * @return {?}
          */
         function () {
@@ -4626,12 +4955,6 @@
             __metadata("design:paramtypes", [exports.ParameterDefinition]),
             __metadata("design:returntype", Object)
         ], RouteParameterSanitiser.prototype, "getSanitiser", null);
-        __decorate([
-            pectin.Trace(),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", []),
-            __metadata("design:returntype", Array)
-        ], RouteParameterSanitiser.prototype, "getRedirectParams", null);
         return RouteParameterSanitiser;
     }());
     if (false) {
@@ -4783,7 +5106,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;