@coolon/angular-ui-powerups 0.0.50 → 0.0.53

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

@@ -2516,6 +2516,307 @@
         PlaceRouter.prototype.router;
     }
 
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @abstract
+     * @template S, T, R
+     */
+      /**
+     * @abstract
+     * @template S, T, R
+     */
+    exports.RouteParameterValue = /** @class */ (function () {
+        function RouteParameterValue(definition, rawValue) {
+            this.definition = definition;
+            this.rawValue = rawValue;
+        }
+        /**
+         * @return {?}
+         */
+        RouteParameterValue.prototype.isRouteId = /**
+         * @return {?}
+         */
+        function () {
+            return this.definition.isRouteId;
+        };
+        /**
+         * @param {?} otherValue
+         * @return {?}
+         */
+        RouteParameterValue.prototype.hasChanged = /**
+         * @param {?} otherValue
+         * @return {?}
+         */
+        function (otherValue) {
+            return this.isEmpty() ?
+                !this.isEmptyValue(otherValue) :
+                this.isEmptyValue(otherValue) || !this.isSameValue(otherValue);
+        };
+        /**
+         * Return's true if the current value is empty.
+         */
+        /**
+         * Return's true if the current value is empty.
+         * @return {?}
+         */
+        RouteParameterValue.prototype.isEmpty = /**
+         * Return's true if the current value is empty.
+         * @return {?}
+         */
+        function () {
+            return this.isEmptyValue(this.value);
+        };
+        /**
+         * Returns true if the rawValue is undefined.  This
+         */
+        /**
+         * Returns true if the rawValue is undefined.  This
+         * @return {?}
+         */
+        RouteParameterValue.prototype.isMissing = /**
+         * Returns true if the rawValue is undefined.  This
+         * @return {?}
+         */
+        function () {
+            return ___default__default.isUndefined(this.rawValue);
+        };
+        /**
+         * @param {?} visit
+         * @param {?} injector
+         * @return {?}
+         */
+        RouteParameterValue.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.definition.getSanitiser(injector);
+                    if (sanitiser) {
+                        return [2 /*return*/, sanitiser.sanitise(this, visit)];
+                    }
+                    else {
+                        return [2 /*return*/, this.value];
+                    }
+                    return [2 /*return*/];
+                });
+            });
+        };
+        return RouteParameterValue;
+    }());
+    if (false) {
+        /** @type {?} */
+        exports.RouteParameterValue.prototype.value;
+        /** @type {?} */
+        exports.RouteParameterValue.prototype.definition;
+        /**
+         * @type {?}
+         * @protected
+         */
+        exports.RouteParameterValue.prototype.rawValue;
+        /**
+         * @abstract
+         * @param {?} otherValue
+         * @return {?}
+         */
+        exports.RouteParameterValue.prototype.isSameValue = function (otherValue) { };
+        /**
+         * @abstract
+         * @return {?}
+         */
+        exports.RouteParameterValue.prototype.formattedValue = function () { };
+        /**
+         * @abstract
+         * @param {?} value
+         * @return {?}
+         */
+        exports.RouteParameterValue.prototype.replace = function (value) { };
+        /**
+         * @abstract
+         * @param {?} value
+         * @return {?}
+         */
+        exports.RouteParameterValue.prototype.isEmptyValue = function (value) { };
+    }
+    (function (RouteParameterValue) {
+        /**
+         * @template T
+         * @param {?} def
+         * @param {?} paramMap
+         * @return {?}
+         */
+        function create(def, paramMap) {
+            // NOTE: Using undefined is important as it triggers the isMissing flag which is used by defaultValue and remember flags
+            return def.isArray ?
+                new RouteParameterValue.Array(def, paramMap.has(def.name) ? paramMap.getAll(def.name) : undefined) :
+                new RouteParameterValue.Scalar(def, paramMap.has(def.name) ? paramMap.get(def.name) : undefined);
+        }
+        RouteParameterValue.create = create;
+        /**
+         * @template T
+         */
+        var Scalar = /** @class */ (function (_super) {
+            __extends(Scalar, _super);
+            function Scalar() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            Object.defineProperty(Scalar.prototype, "value", {
+                get: /**
+                 * @return {?}
+                 */
+                function () {
+                    return this.definition.type.parse(this.rawValue);
+                },
+                enumerable: true,
+                configurable: true
+            });
+            /**
+             * @param {?} otherValue
+             * @return {?}
+             */
+            Scalar.prototype.isSameValue = /**
+             * @param {?} otherValue
+             * @return {?}
+             */
+            function (otherValue) {
+                return this.value === otherValue;
+            };
+            /**
+             * @param {?} value
+             * @return {?}
+             */
+            Scalar.prototype.replace = /**
+             * @param {?} value
+             * @return {?}
+             */
+            function (value) {
+                return new RouteParameterValue.Scalar(this.definition, this.isEmptyValue(value) ? undefined : this.definition.type.format(value));
+            };
+            /**
+             * @return {?}
+             */
+            Scalar.prototype.formattedValue = /**
+             * @return {?}
+             */
+            function () {
+                return this.isEmpty() ? undefined : this.definition.type.format(this.value);
+            };
+            /**
+             * @param {?} value
+             * @return {?}
+             */
+            Scalar.prototype.isEmptyValue = /**
+             * @param {?} value
+             * @return {?}
+             */
+            function (value) {
+                return ___default__default.isNil(value);
+            };
+            __decorate([
+                src.Memoize(),
+                __metadata("design:type", Object),
+                __metadata("design:paramtypes", [])
+            ], Scalar.prototype, "value", null);
+            return Scalar;
+        }(RouteParameterValue));
+        RouteParameterValue.Scalar = Scalar;
+        /**
+         * @template T
+         */
+        var Array = /** @class */ (function (_super) {
+            __extends(Array, _super);
+            function Array() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            Object.defineProperty(Array.prototype, "value", {
+                get: /**
+                 * @return {?}
+                 */
+                function () {
+                    var _this = this;
+                    return (this.rawValue || [])
+                        .filter((/**
+                     * @param {?} s
+                     * @return {?}
+                     */
+                    function (s) { return !___default__default.isEmpty(s); }))
+                        .map((/**
+                     * @param {?} raw
+                     * @return {?}
+                     */
+                    function (raw) { return _this.definition.type.parse(raw); }));
+                },
+                enumerable: true,
+                configurable: true
+            });
+            /**
+             * @param {?} otherValue
+             * @return {?}
+             */
+            Array.prototype.isSameValue = /**
+             * @param {?} otherValue
+             * @return {?}
+             */
+            function (otherValue) {
+                return ___default__default.isEqual(this.value, otherValue);
+            };
+            /**
+             * @param {?} value
+             * @return {?}
+             */
+            Array.prototype.replace = /**
+             * @param {?} value
+             * @return {?}
+             */
+            function (value) {
+                var _this = this;
+                return new RouteParameterValue.Array(this.definition, this.isEmptyValue(value) ? undefined : value.map((/**
+                 * @param {?} v
+                 * @return {?}
+                 */
+                function (v) { return _this.definition.type.format(v); })));
+            };
+            /**
+             * @return {?}
+             */
+            Array.prototype.formattedValue = /**
+             * @return {?}
+             */
+            function () {
+                var _this = this;
+                return this.isEmpty() ? [] : this.value.map((/**
+                 * @param {?} v
+                 * @return {?}
+                 */
+                function (v) { return _this.definition.type.format(v); }));
+            };
+            /**
+             * @param {?} value
+             * @return {?}
+             */
+            Array.prototype.isEmptyValue = /**
+             * @param {?} value
+             * @return {?}
+             */
+            function (value) {
+                return ___default__default.isNil(value) || value.length < 1;
+            };
+            __decorate([
+                src.Memoize(),
+                __metadata("design:type", Array),
+                __metadata("design:paramtypes", [])
+            ], Array.prototype, "value", null);
+            return Array;
+        }(RouteParameterValue));
+        RouteParameterValue.Array = Array;
+    })(exports.RouteParameterValue || (exports.RouteParameterValue = {}));
+
     /**
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -2674,66 +2975,38 @@
                 this.placeHistory = placeHistory;
             }
             /**
-             * @param {?} parameterDef
-             * @param {?} value
+             * @param {?} parameter
              * @param {?=} visit
              * @return {?}
              */
             DefaultParameterSanitiser.prototype.sanitise = /**
-             * @param {?} parameterDef
-             * @param {?} value
+             * @param {?} parameter
              * @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); }));
+            function (parameter, visit) {
+                /** @type {?} */
+                var value = parameter.value;
+                if (parameter.isMissing()) {
+                    /** @type {?} */
+                    var previousVisit = ___default__default.first(this.placeHistory.getHistory(visit.placeDefinition));
+                    if (this.remember && previousVisit) {
+                        value = previousVisit.getValueOf(parameter.definition);
                     }
-                    return this.isBlank(parameterDef, value) ? this.defaultValue : value;
+                    /** @type {?} */
+                    var s = parameter.isEmptyValue(value) ? this.defaultValue : value;
+                    console.log("missing -> " + parameter.definition.name + ", returning " + s);
+                    return s;
                 }
                 else {
+                    console.log("not missing -> " + parameter.definition.name);
                     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;
-            };
             __decorate([
                 pectin.Trace(),
                 __metadata("design:type", Function),
-                __metadata("design:paramtypes", [ParameterDefinition, Object, Object]),
+                __metadata("design:paramtypes", [exports.RouteParameterValue, Object]),
                 __metadata("design:returntype", Object)
             ], DefaultParameterSanitiser.prototype, "sanitise", null);
             return DefaultParameterSanitiser;
@@ -2754,9 +3027,9 @@
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
      */
     exports.ParameterSnapshot = /** @class */ (function () {
-        function ParameterSnapshot(placeDefinition, resolved) {
+        function ParameterSnapshot(placeDefinition, parameters) {
             this.placeDefinition = placeDefinition;
-            this.resolved = resolved;
+            this.parameters = parameters;
         }
         /**
          * @param {?} other
@@ -2771,18 +3044,18 @@
         function (other, debug) {
             if (debug === void 0) { debug = false; }
             /** @type {?} */
-            var changed = this.resolved.find((/**
+            var changed = this.parameters.find((/**
              * @param {?} r
              * @return {?}
              */
             function (r) {
-                return !r.isSame(other.getValueOf(r.parameterDef));
+                return r.hasChanged(other.getValueOf(r.definition));
             }));
             if (changed && debug) {
                 console.log({
-                    name: changed.parameterDef.name,
+                    name: changed.definition.name,
                     mine: changed.value,
-                    theirs: other.getValueOf(changed.parameterDef)
+                    theirs: other.getValueOf(changed.definition)
                 });
             }
             return !!changed;
@@ -2798,11 +3071,11 @@
          * @return {?}
          */
         function (parameterDef) {
-            return this.resolved.find((/**
+            return this.parameters.find((/**
              * @param {?} r
              * @return {?}
              */
-            function (r) { return r.parameterDef === parameterDef; }));
+            function (r) { return r.definition === parameterDef; }));
         };
         /**
          * @template T, S
@@ -2838,11 +3111,11 @@
          */
         function (name) {
             /** @type {?} */
-            var resolvedParameter = this.resolved.find((/**
+            var resolvedParameter = this.parameters.find((/**
              * @param {?} r
              * @return {?}
              */
-            function (r) { return r.parameterDef.name === name; }));
+            function (r) { return r.definition.name === name; }));
             return resolvedParameter ? resolvedParameter.value : null;
         };
         /**
@@ -2856,11 +3129,11 @@
         function () {
             // RouteId's are never arrays: see parameter-decorators.ts createDefinition methods. It would be nice to
             // capture this in the type system though
-            return (/** @type {?} */ (this.resolved.find((/**
+            return (/** @type {?} */ (this.parameters.find((/**
              * @param {?} p
              * @return {?}
              */
-            function (p) { return p.parameterDef.isRouteId; }))));
+            function (p) { return p.definition.isRouteId; }))));
         };
         /**
          * @private
@@ -2871,11 +3144,11 @@
          * @return {?}
          */
         function () {
-            return this.resolved.filter((/**
+            return this.parameters.filter((/**
              * @param {?} r
              * @return {?}
              */
-            function (r) { return !r.parameterDef.isRouteId; }));
+            function (r) { return !r.definition.isRouteId; }));
         };
         /**
          * @return {?}
@@ -2897,6 +3170,19 @@
             var routeIdParam = this.getRouteIdParameter();
             return routeIdParam ? routeIdParam.formattedValue() : null;
         };
+        /**
+         * @return {?}
+         */
+        ParameterSnapshot.prototype.getNonEmptyParameters = /**
+         * @return {?}
+         */
+        function () {
+            return this.parameters.filter((/**
+             * @param {?} p
+             * @return {?}
+             */
+            function (p) { return !p.isEmpty(); }));
+        };
         /**
          * @return {?}
          */
@@ -2907,35 +3193,35 @@
             /** @type {?} */
             var params = {};
             /** @type {?} */
-            var routeIdParam = this.resolved.filter((/**
+            var routeIdParam = this.getNonEmptyParameters()
+                .filter((/**
              * @param {?} p
              * @return {?}
              */
-            function (p) { return !p.parameterDef.isRouteId; })).forEach((/**
+            function (p) { return !p.definition.isRouteId; }))
+                .forEach((/**
              * @param {?} p
              * @return {?}
              */
-            function (p) {
-                params[p.parameterDef.name] = p.formattedValue();
-            }));
+            function (p) { return params[p.definition.name] = p.formattedValue(); }));
             return params;
         };
         /**
          * @return {?}
          */
-        ParameterSnapshot.prototype.getAllFormattedParameters = /**
+        ParameterSnapshot.prototype.getAllParameters = /**
          * @return {?}
          */
         function () {
             /** @type {?} */
             var params = {};
             /** @type {?} */
-            var routeIdParam = this.resolved.forEach((/**
+            var routeIdParam = this.parameters.forEach((/**
              * @param {?} p
              * @return {?}
              */
             function (p) {
-                params[p.parameterDef.name] = p.formattedValue();
+                params[p.definition.name] = p.value;
             }));
             return params;
         };
@@ -2952,12 +3238,12 @@
          * @return {?}
          */
         function (parameter, value) {
-            return new ParameterSnapshot(this.placeDefinition, this.resolved.map((/**
+            return new ParameterSnapshot(this.placeDefinition, this.parameters.map((/**
              * @param {?} p
              * @return {?}
              */
             function (p) {
-                return p.parameterDef === parameter ? p.replace(value) : p;
+                return p.definition === parameter ? p.replace(value) : p;
             })));
         };
         /**
@@ -2979,10 +3265,10 @@
                             return [4 /*yield*/, routeId.sanitise(this, injector)];
                         case 1:
                             sanitisedValue = _a.sent();
-                            if (!routeId.isSame(sanitisedValue)) {
+                            if (routeId.hasChanged(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)];
+                                return [2 /*return*/, this.replace(routeId.definition, sanitisedValue)];
                             }
                             _a.label = 2;
                         case 2:
@@ -2996,8 +3282,8 @@
                             return [4 /*yield*/, routeParameter.sanitise(this, injector)];
                         case 4:
                             sanitisedValue = _a.sent();
-                            if (!routeParameter.isSame(sanitisedValue)) {
-                                result = this.replace(routeParameter.parameterDef, sanitisedValue);
+                            if (routeParameter.hasChanged(sanitisedValue)) {
+                                result = result.replace(routeParameter.definition, sanitisedValue);
                             }
                             _a.label = 5;
                         case 5:
@@ -3008,12 +3294,12 @@
                 });
             });
         };
-        var _a, _b;
+        var _a;
         __decorate([
             src.Memoize(),
             __metadata("design:type", Function),
             __metadata("design:paramtypes", [exports.ParameterDefinition]),
-            __metadata("design:returntype", ParameterSnapshot.ResolvedParameter)
+            __metadata("design:returntype", exports.RouteParameterValue)
         ], ParameterSnapshot.prototype, "getParameter", null);
         __decorate([
             src.Memoize(),
@@ -3031,7 +3317,7 @@
             src.Memoize(),
             __metadata("design:type", Function),
             __metadata("design:paramtypes", []),
-            __metadata("design:returntype", ParameterSnapshot.ResolvedValueParameter)
+            __metadata("design:returntype", exports.RouteParameterValue.Scalar)
         ], ParameterSnapshot.prototype, "getRouteIdParameter", null);
         __decorate([
             src.Memoize(),
@@ -3042,15 +3328,9 @@
         __decorate([
             pectin.Trace(),
             __metadata("design:type", Function),
-            __metadata("design:paramtypes", [exports.ParameterDefinition, typeof (_b = typeof S !== "undefined" && S) === "function" ? _b : Object]),
-            __metadata("design:returntype", ParameterSnapshot)
-        ], ParameterSnapshot.prototype, "replace", null);
-        __decorate([
-            pectin.Trace(),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [core.Injector]),
-            __metadata("design:returntype", Promise)
-        ], ParameterSnapshot.prototype, "sanitise", null);
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], ParameterSnapshot.prototype, "getFormattedParameters", null);
         return ParameterSnapshot;
     }());
     if (false) {
@@ -3060,7 +3340,7 @@
          * @type {?}
          * @private
          */
-        exports.ParameterSnapshot.prototype.resolved;
+        exports.ParameterSnapshot.prototype.parameters;
     }
     (function (ParameterSnapshot) {
         /**
@@ -3073,31 +3353,11 @@
             /** @type {?} */
             var paramMap = new ConsolidatedParameterMap(params, urlSegments);
             /** @type {?} */
-            var resolvedParameters = placeDef.getRouteParameters()
-                .map((/**
+            var resolvedParameters = placeDef.getRouteParameters().map((/**
              * @param {?} def
              * @return {?}
              */
-            function (def) {
-                if (def.isArray) {
-                    /** @type {?} */
-                    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 {?}
-                     */
-                    function (raw) { return def.type.parse(raw); })) : null;
-                    return new ResolvedArrayParameter(def, value);
-                }
-                else {
-                    /** @type {?} */
-                    var value = paramMap.has(def.name) ? def.type.parse(paramMap.get(def.name)) : null;
-                    return new ResolvedValueParameter(def, value);
-                }
-            }));
+            function (def) { return exports.RouteParameterValue.create(def, paramMap); }));
             return new ParameterSnapshot(placeDef, resolvedParameters);
         }
         ParameterSnapshot.create = create;
@@ -3106,12 +3366,7 @@
          * 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 () {
+        var ConsolidatedParameterMap = /** @class */ (function () {
             function ConsolidatedParameterMap(paramMap, urlSegments) {
                 this.paramMaps = [paramMap].concat((urlSegments || []).map((/**
                  * @param {?} s
@@ -3168,6 +3423,26 @@
                  */
                 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
+            });
+            __decorate([
+                src.Memoize(),
+                __metadata("design:type", Array),
+                __metadata("design:paramtypes", [])
+            ], ConsolidatedParameterMap.prototype, "keys", null);
             return ConsolidatedParameterMap;
         }());
         if (false) {
@@ -3235,207 +3510,6 @@
              */
             ParamMapAdapter.prototype.params;
         }
-        /**
-         * @abstract
-         * @template T, S
-         */
-        var /**
-         * @abstract
-         * @template T, S
-         */
-        ResolvedParameter = /** @class */ (function () {
-            function ResolvedParameter(parameterDef, value) {
-                this.parameterDef = parameterDef;
-                this.value = value;
-            }
-            /**
-             * @return {?}
-             */
-            ResolvedParameter.prototype.isRouteId = /**
-             * @return {?}
-             */
-            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;
-        if (false) {
-            /** @type {?} */
-            ResolvedParameter.prototype.parameterDef;
-            /** @type {?} */
-            ResolvedParameter.prototype.value;
-            /**
-             * @abstract
-             * @param {?} dest
-             * @return {?}
-             */
-            ResolvedParameter.prototype.injectRouteParam = function (dest) { };
-            /**
-             * @abstract
-             * @param {?} otherValue
-             * @return {?}
-             */
-            ResolvedParameter.prototype.isSame = function (otherValue) { };
-            /**
-             * @abstract
-             * @return {?}
-             */
-            ResolvedParameter.prototype.formattedValue = function () { };
-            /**
-             * @abstract
-             * @param {?} value
-             * @return {?}
-             */
-            ResolvedParameter.prototype.replace = function (value) { };
-        }
-        /**
-         * @template T
-         */
-        var /**
-         * @template T
-         */
-        ResolvedValueParameter = /** @class */ (function (_super) {
-            __extends(ResolvedValueParameter, _super);
-            function ResolvedValueParameter() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            /**
-             * @param {?} otherValue
-             * @return {?}
-             */
-            ResolvedValueParameter.prototype.isSame = /**
-             * @param {?} otherValue
-             * @return {?}
-             */
-            function (otherValue) {
-                return this.value === otherValue;
-            };
-            /**
-             * @param {?} dest
-             * @return {?}
-             */
-            ResolvedValueParameter.prototype.injectRouteParam = /**
-             * @param {?} dest
-             * @return {?}
-             */
-            function (dest) {
-                dest[this.parameterDef.name] = this.parameterDef.type.format(this.value);
-            };
-            /**
-             * @param {?} value
-             * @return {?}
-             */
-            ResolvedValueParameter.prototype.replace = /**
-             * @param {?} value
-             * @return {?}
-             */
-            function (value) {
-                return new ResolvedValueParameter(this.parameterDef, value);
-            };
-            /**
-             * @return {?}
-             */
-            ResolvedValueParameter.prototype.formattedValue = /**
-             * @return {?}
-             */
-            function () {
-                return !___default__default.isNil(this.value) ? this.parameterDef.type.format(this.value) : null;
-            };
-            return ResolvedValueParameter;
-        }(ResolvedParameter));
-        ParameterSnapshot.ResolvedValueParameter = ResolvedValueParameter;
-        /**
-         * @template T
-         */
-        var /**
-         * @template T
-         */
-        ResolvedArrayParameter = /** @class */ (function (_super) {
-            __extends(ResolvedArrayParameter, _super);
-            function ResolvedArrayParameter() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            /**
-             * @param {?} otherValue
-             * @return {?}
-             */
-            ResolvedArrayParameter.prototype.isSame = /**
-             * @param {?} otherValue
-             * @return {?}
-             */
-            function (otherValue) {
-                return ___default__default.isEqual(this.value, otherValue);
-            };
-            /**
-             * @param {?} dest
-             * @return {?}
-             */
-            ResolvedArrayParameter.prototype.injectRouteParam = /**
-             * @param {?} dest
-             * @return {?}
-             */
-            function (dest) {
-                var _this = this;
-                dest[this.parameterDef.name] = this.value.map((/**
-                 * @param {?} v
-                 * @return {?}
-                 */
-                function (v) { return _this.parameterDef.type.format(v); }));
-            };
-            /**
-             * @param {?} value
-             * @return {?}
-             */
-            ResolvedArrayParameter.prototype.replace = /**
-             * @param {?} value
-             * @return {?}
-             */
-            function (value) {
-                return new ResolvedArrayParameter(this.parameterDef, value);
-            };
-            /**
-             * @return {?}
-             */
-            ResolvedArrayParameter.prototype.formattedValue = /**
-             * @return {?}
-             */
-            function () {
-                var _this = this;
-                return this.value ? this.value.map((/**
-                 * @param {?} v
-                 * @return {?}
-                 */
-                function (v) { return _this.parameterDef.type.format(v); })) : [];
-            };
-            return ResolvedArrayParameter;
-        }(ResolvedParameter));
-        ParameterSnapshot.ResolvedArrayParameter = ResolvedArrayParameter;
     })(exports.ParameterSnapshot || (exports.ParameterSnapshot = {}));
 
     /**
@@ -3561,8 +3635,8 @@
              * @return {?}
              */
             function (next, previous) {
-                _this.pushChangesToRoute(next, previous);
                 _this.placeHistory.add(next); // the above route change doesn't seem to propagate back in, so I'm add the state to the history manually for now.
+                _this.pushChangesToRoute(next, previous);
             }), {
                 unless: _this.incomingRouteChange
             });
@@ -4434,7 +4508,7 @@
                  * @return {?}
                  */
                 function (sanitised) {
-                    pectin.Logger.get(_this).info("ParameterSnapshot.sanitise", { sanitised: sanitised });
+                    pectin.Logger.get(_this).info("ParameterSnapshot.sanitise ->", sanitised.getAllParameters());
                     if (sanitised.hasChanged(snapshot_1, true)) {
                         return _this.placeRouter.getRedirectUrlTree(activatedRoute, sanitised);
                     }
@@ -4589,12 +4663,11 @@
     function ParameterSanitiser() { }
     if (false) {
         /**
-         * @param {?} parameterDef
-         * @param {?} value
+         * @param {?} paramter
          * @param {?=} visit
          * @return {?}
          */
-        ParameterSanitiser.prototype.sanitise = function (parameterDef, value, visit) { };
+        ParameterSanitiser.prototype.sanitise = function (paramter, visit) { };
     }
 
     /**
@@ -4690,431 +4763,6 @@
         ParameterType.BOOLEAN = new BooleanType();
     })(exports.ParameterType || (exports.ParameterType = {}));
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template T, S
-     */
-      /**
-     * @template T, S
-     */
-    exports.Sanitiser = /** @class */ (function () {
-        function Sanitiser(parameterDef, snapshot, sanitiser) {
-            this.parameterDef = parameterDef;
-            this.snapshot = snapshot;
-            this.sanitiser = sanitiser;
-        }
-        /**
-         * @return {?}
-         */
-        Sanitiser.prototype.isRouteId = /**
-         * @return {?}
-         */
-        function () {
-            return this.parameterDef.isRouteId;
-        };
-        Object.defineProperty(Sanitiser.prototype, "valueChanged", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                return !___default__default.isNil(this.initialValue) && this.hasChanged(this.initialValue, this.sanitisedValue);
-            },
-            enumerable: true,
-            configurable: true
-        });
-        Object.defineProperty(Sanitiser.prototype, "sanitisedValue", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                return this._sanitisedValue;
-            },
-            enumerable: true,
-            configurable: true
-        });
-        /**
-         * @protected
-         * @param {?} snapshot
-         * @return {?}
-         */
-        Sanitiser.prototype.readFrom = /**
-         * @protected
-         * @param {?} snapshot
-         * @return {?}
-         */
-        function (snapshot) {
-            return pectin.lang.abstractMethod(this.constructor);
-        };
-        /**
-         * @protected
-         * @param {?} initialValue
-         * @param {?} sanitisedValue
-         * @return {?}
-         */
-        Sanitiser.prototype.hasChanged = /**
-         * @protected
-         * @param {?} initialValue
-         * @param {?} sanitisedValue
-         * @return {?}
-         */
-        function (initialValue, sanitisedValue) {
-            return pectin.lang.abstractMethod(this.constructor);
-        };
-        /**
-         * @param {?} dest
-         * @return {?}
-         */
-        Sanitiser.prototype.injectRouteParam = /**
-         * @param {?} dest
-         * @return {?}
-         */
-        function (dest) {
-            pectin.lang.abstractMethod(this.constructor);
-        };
-        /**
-         * @return {?}
-         */
-        Sanitiser.prototype.sanitize = /**
-         * @return {?}
-         */
-        function () {
-            return __awaiter(this, void 0, void 0, function () {
-                var _a;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            if (!this.sanitiser) return [3 /*break*/, 2];
-                            this.initialValue = this.readFrom(this.snapshot);
-                            _a = this;
-                            return [4 /*yield*/, this.sanitiser.sanitise(null, this.initialValue)];
-                        case 1:
-                            _a._sanitisedValue = _b.sent();
-                            if (this.initialValue !== this._sanitisedValue) {
-                                return [2 /*return*/, false];
-                            }
-                            _b.label = 2;
-                        case 2: return [2 /*return*/, true];
-                    }
-                });
-            });
-        };
-        return Sanitiser;
-    }());
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        exports.Sanitiser.prototype.initialValue;
-        /**
-         * @type {?}
-         * @private
-         */
-        exports.Sanitiser.prototype._sanitisedValue;
-        /** @type {?} */
-        exports.Sanitiser.prototype.parameterDef;
-        /** @type {?} */
-        exports.Sanitiser.prototype.snapshot;
-        /** @type {?} */
-        exports.Sanitiser.prototype.sanitiser;
-    }
-    var RouteParameterSanitiser = /** @class */ (function () {
-        function RouteParameterSanitiser(parameterDefs, snapshot, injector) {
-            var _this = this;
-            this.parameterDefs = parameterDefs;
-            this.snapshot = snapshot;
-            this.injector = injector;
-            this.parameterSanitisers = [];
-            /** @type {?} */
-            var sanitisers = parameterDefs.map((/**
-             * @param {?} def
-             * @return {?}
-             */
-            function (def) {
-                return def.isArray ?
-                    new exports.Sanitiser.Array(def, snapshot, _this.getSanitiser(def)) :
-                    new exports.Sanitiser.Value(def, snapshot, _this.getSanitiser(def));
-            }));
-            this.routeIdSanitiser = sanitisers.find((/**
-             * @param {?} p
-             * @return {?}
-             */
-            function (p) { return p.isRouteId(); }));
-            this.parameterSanitisers = sanitisers.filter((/**
-             * @param {?} p
-             * @return {?}
-             */
-            function (p) { return !p.isRouteId(); }));
-        }
-        /**
-         * @return {?}
-         */
-        RouteParameterSanitiser.prototype.sanitise = /**
-         * @return {?}
-         */
-        function () {
-            return __awaiter(this, void 0, void 0, function () {
-                var e_1, _a, _b, _c, sanitiser, e_1_1;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            if (!this.routeIdSanitiser) return [3 /*break*/, 2];
-                            return [4 /*yield*/, this.routeIdSanitiser.sanitize()];
-                        case 1:
-                            _d.sent();
-                            if (this.routeIdSanitiser.valueChanged) {
-                                // if the route id isn't ok we redirect immediately as the query params may need to be sanitised in the
-                                // context of the route id.
-                                return [2 /*return*/, false];
-                            }
-                            _d.label = 2;
-                        case 2:
-                            _d.trys.push([2, 7, 8, 9]);
-                            _b = __values(this.parameterSanitisers), _c = _b.next();
-                            _d.label = 3;
-                        case 3:
-                            if (!!_c.done) return [3 /*break*/, 6];
-                            sanitiser = _c.value;
-                            return [4 /*yield*/, sanitiser.sanitize()];
-                        case 4:
-                            _d.sent();
-                            _d.label = 5;
-                        case 5:
-                            _c = _b.next();
-                            return [3 /*break*/, 3];
-                        case 6: return [3 /*break*/, 9];
-                        case 7:
-                            e_1_1 = _d.sent();
-                            e_1 = { error: e_1_1 };
-                            return [3 /*break*/, 9];
-                        case 8:
-                            try {
-                                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                            return [7 /*endfinally*/];
-                        case 9: return [2 /*return*/, !this.parameterSanitisers.find((/**
-                             * @param {?} s
-                             * @return {?}
-                             */
-                            function (s) { return s.valueChanged; }))];
-                    }
-                });
-            });
-        };
-        /**
-         * @private
-         * @template T, S
-         * @param {?} def
-         * @return {?}
-         */
-        RouteParameterSanitiser.prototype.getSanitiser = /**
-         * @private
-         * @template T, S
-         * @param {?} def
-         * @return {?}
-         */
-        function (def) {
-            return def.getSanitiser(this.injector);
-        };
-        /**
-         * @return {?}
-         */
-        RouteParameterSanitiser.prototype.routeIdHasChanged = /**
-         * @return {?}
-         */
-        function () {
-            pectin.assert.isTruthy(this.parameterSanitisers.length !== 0);
-            return this.routeIdSanitiser && this.routeIdSanitiser.valueChanged;
-        };
-        // @Trace()
-        // @Trace()
-        /**
-         * @return {?}
-         */
-        RouteParameterSanitiser.prototype.getRedirectParams = 
-        // @Trace()
-        /**
-         * @return {?}
-         */
-        function () {
-            if (this.routeIdHasChanged()) {
-                return [this.routeIdSanitiser.sanitisedValue];
-            }
-            else {
-                /** @type {?} */
-                var routeParams_1 = {};
-                this.parameterSanitisers.forEach((/**
-                 * @param {?} s
-                 * @return {?}
-                 */
-                function (s) { return s.injectRouteParam(routeParams_1); }));
-                return [routeParams_1];
-            }
-        };
-        /**
-         * @private
-         * @template S
-         * @param {?} value
-         * @return {?}
-         */
-        RouteParameterSanitiser.prototype.isSanitiserContructor = /**
-         * @private
-         * @template S
-         * @param {?} value
-         * @return {?}
-         */
-        function (value) {
-            return ___default__default.isFunction(value) && pectin.lang.constructorChain((/** @type {?} */ ((/** @type {?} */ (value))))).includes(exports.Sanitiser);
-        };
-        __decorate([
-            src.Memoize(),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [exports.ParameterDefinition]),
-            __metadata("design:returntype", Object)
-        ], RouteParameterSanitiser.prototype, "getSanitiser", null);
-        return RouteParameterSanitiser;
-    }());
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        RouteParameterSanitiser.prototype.routeIdSanitiser;
-        /**
-         * @type {?}
-         * @private
-         */
-        RouteParameterSanitiser.prototype.parameterSanitisers;
-        /** @type {?} */
-        RouteParameterSanitiser.prototype.parameterDefs;
-        /** @type {?} */
-        RouteParameterSanitiser.prototype.snapshot;
-        /** @type {?} */
-        RouteParameterSanitiser.prototype.injector;
-    }
-    (function (Sanitiser) {
-        /**
-         * @template T
-         */
-        var /**
-         * @template T
-         */
-        Value = /** @class */ (function (_super) {
-            __extends(Value, _super);
-            function Value() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            /**
-             * @param {?} snapshot
-             * @return {?}
-             */
-            Value.prototype.readFrom = /**
-             * @param {?} snapshot
-             * @return {?}
-             */
-            function (snapshot) {
-                /** @type {?} */
-                var rawValue = snapshot.paramMap.get(this.parameterDef.name);
-                return this.parameterDef.type.parse(rawValue);
-            };
-            /**
-             * @protected
-             * @param {?} initialValue
-             * @param {?} sanitisedValue
-             * @return {?}
-             */
-            Value.prototype.hasChanged = /**
-             * @protected
-             * @param {?} initialValue
-             * @param {?} sanitisedValue
-             * @return {?}
-             */
-            function (initialValue, sanitisedValue) {
-                return initialValue !== sanitisedValue;
-            };
-            /**
-             * @param {?} dest
-             * @return {?}
-             */
-            Value.prototype.injectRouteParam = /**
-             * @param {?} dest
-             * @return {?}
-             */
-            function (dest) {
-                dest[this.parameterDef.name] = this.parameterDef.type.format(this.sanitisedValue);
-            };
-            return Value;
-        }(Sanitiser));
-        Sanitiser.Value = Value;
-        /**
-         * @template T
-         */
-        var /**
-         * @template T
-         */
-        Array = /** @class */ (function (_super) {
-            __extends(Array, _super);
-            function Array() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            /**
-             * @param {?} snapshot
-             * @return {?}
-             */
-            Array.prototype.readFrom = /**
-             * @param {?} snapshot
-             * @return {?}
-             */
-            function (snapshot) {
-                var _this = this;
-                /** @type {?} */
-                var rawValues = snapshot.paramMap.getAll(this.parameterDef.name);
-                return rawValues.map((/**
-                 * @param {?} value
-                 * @return {?}
-                 */
-                function (value) { return _this.parameterDef.type.parse(value); }));
-            };
-            /**
-             * @protected
-             * @param {?} initialValue
-             * @param {?} sanitisedValue
-             * @return {?}
-             */
-            Array.prototype.hasChanged = /**
-             * @protected
-             * @param {?} initialValue
-             * @param {?} sanitisedValue
-             * @return {?}
-             */
-            function (initialValue, sanitisedValue) {
-                return initialValue !== sanitisedValue;
-            };
-            /**
-             * @param {?} dest
-             * @return {?}
-             */
-            Array.prototype.injectRouteParam = /**
-             * @param {?} dest
-             * @return {?}
-             */
-            function (dest) {
-                var _this = this;
-                dest[this.parameterDef.name] = this.sanitisedValue.map((/**
-                 * @param {?} v
-                 * @return {?}
-                 */
-                function (v) { return _this.parameterDef.type.format(v); }));
-            };
-            return Array;
-        }(Sanitiser));
-        Sanitiser.Array = Array;
-    })(exports.Sanitiser || (exports.Sanitiser = {}));
-
     exports.ACTIVITY_DATA = ACTIVITY_DATA;
     exports.AbstractActivity = AbstractActivity;
     exports.AbstractInputComponent = AbstractInputComponent;
@@ -5153,7 +4801,6 @@
     exports.RouteId = RouteId;
     exports.RouteParameter = RouteParameter;
     exports.RouteParameterList = RouteParameterList;
-    exports.RouteParameterSanitiser = RouteParameterSanitiser;
     exports.SelectInputComponent = SelectInputComponent;
     exports.StringInputComponent = StringInputComponent;
     exports.TabbedPlaceNavigationComponent = TabbedPlaceNavigationComponent;