@coolon/angular-ui-powerups 0.0.50 → 0.0.53

package/fesm2015/coolon-angular-ui-powerups.js

@@ -1932,6 +1932,226 @@ if (false) {
     PlaceRouter.prototype.router;
 }
 
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @abstract
+ * @template S, T, R
+ */
+class RouteParameterValue {
+    /**
+     * @param {?} definition
+     * @param {?} rawValue
+     */
+    constructor(definition, rawValue) {
+        this.definition = definition;
+        this.rawValue = rawValue;
+    }
+    /**
+     * @return {?}
+     */
+    isRouteId() {
+        return this.definition.isRouteId;
+    }
+    /**
+     * @param {?} otherValue
+     * @return {?}
+     */
+    hasChanged(otherValue) {
+        return this.isEmpty() ?
+            !this.isEmptyValue(otherValue) :
+            this.isEmptyValue(otherValue) || !this.isSameValue(otherValue);
+    }
+    /**
+     * Return's true if the current value is empty.
+     * @return {?}
+     */
+    isEmpty() {
+        return this.isEmptyValue(this.value);
+    }
+    /**
+     * Returns true if the rawValue is undefined.  This
+     * @return {?}
+     */
+    isMissing() {
+        return ___default.isUndefined(this.rawValue);
+    }
+    /**
+     * @param {?} visit
+     * @param {?} injector
+     * @return {?}
+     */
+    sanitise(visit, injector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            /** @type {?} */
+            const sanitiser = this.definition.getSanitiser(injector);
+            if (sanitiser) {
+                return sanitiser.sanitise(this, visit);
+            }
+            else {
+                return this.value;
+            }
+        });
+    }
+}
+if (false) {
+    /** @type {?} */
+    RouteParameterValue.prototype.value;
+    /** @type {?} */
+    RouteParameterValue.prototype.definition;
+    /**
+     * @type {?}
+     * @protected
+     */
+    RouteParameterValue.prototype.rawValue;
+    /**
+     * @abstract
+     * @param {?} otherValue
+     * @return {?}
+     */
+    RouteParameterValue.prototype.isSameValue = function (otherValue) { };
+    /**
+     * @abstract
+     * @return {?}
+     */
+    RouteParameterValue.prototype.formattedValue = function () { };
+    /**
+     * @abstract
+     * @param {?} value
+     * @return {?}
+     */
+    RouteParameterValue.prototype.replace = function (value) { };
+    /**
+     * @abstract
+     * @param {?} value
+     * @return {?}
+     */
+    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
+     */
+    class Scalar extends RouteParameterValue {
+        /**
+         * @return {?}
+         */
+        get value() {
+            return this.definition.type.parse(this.rawValue);
+        }
+        /**
+         * @param {?} otherValue
+         * @return {?}
+         */
+        isSameValue(otherValue) {
+            return this.value === otherValue;
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        replace(value) {
+            return new RouteParameterValue.Scalar(this.definition, this.isEmptyValue(value) ? undefined : this.definition.type.format(value));
+        }
+        /**
+         * @return {?}
+         */
+        formattedValue() {
+            return this.isEmpty() ? undefined : this.definition.type.format(this.value);
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        isEmptyValue(value) {
+            return ___default.isNil(value);
+        }
+    }
+    __decorate([
+        Memoize$1(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [])
+    ], Scalar.prototype, "value", null);
+    RouteParameterValue.Scalar = Scalar;
+    /**
+     * @template T
+     */
+    class Array extends RouteParameterValue {
+        /**
+         * @return {?}
+         */
+        get value() {
+            return (this.rawValue || [])
+                .filter((/**
+             * @param {?} s
+             * @return {?}
+             */
+            s => !___default.isEmpty(s)))
+                .map((/**
+             * @param {?} raw
+             * @return {?}
+             */
+            raw => this.definition.type.parse(raw)));
+        }
+        /**
+         * @param {?} otherValue
+         * @return {?}
+         */
+        isSameValue(otherValue) {
+            return ___default.isEqual(this.value, otherValue);
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        replace(value) {
+            return new RouteParameterValue.Array(this.definition, this.isEmptyValue(value) ? undefined : value.map((/**
+             * @param {?} v
+             * @return {?}
+             */
+            v => this.definition.type.format(v))));
+        }
+        /**
+         * @return {?}
+         */
+        formattedValue() {
+            return this.isEmpty() ? [] : this.value.map((/**
+             * @param {?} v
+             * @return {?}
+             */
+            v => this.definition.type.format(v)));
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        isEmptyValue(value) {
+            return ___default.isNil(value) || value.length < 1;
+        }
+    }
+    __decorate([
+        Memoize$1(),
+        __metadata("design:type", Array),
+        __metadata("design:paramtypes", [])
+    ], Array.prototype, "value", null);
+    RouteParameterValue.Array = Array;
+})(RouteParameterValue || (RouteParameterValue = {}));
+
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -2073,54 +2293,34 @@ if (false) {
             this.placeHistory = placeHistory;
         }
         /**
-         * @param {?} parameterDef
-         * @param {?} value
+         * @param {?} parameter
          * @param {?=} visit
          * @return {?}
          */
-        sanitise(parameterDef, value, visit) {
-            if (this.isBlank(parameterDef, value)) {
-                if (this.remember) {
-                    /** @type {?} */
-                    const visits = this.placeHistory.getHistory(visit.placeDefinition);
-                    value = visits.map((/**
-                     * @param {?} v
-                     * @return {?}
-                     */
-                    v => v.getValueOf(parameterDef)))
-                        .filter((/**
-                     * @param {?} v
-                     * @return {?}
-                     */
-                    v => !___default.isNil(v)))
-                        .find((/**
-                     * @param {?} v
-                     * @return {?}
-                     */
-                    v => !this.isBlank(parameterDef, v)));
+        sanitise(parameter, visit) {
+            /** @type {?} */
+            let value = parameter.value;
+            if (parameter.isMissing()) {
+                /** @type {?} */
+                const previousVisit = ___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 {?} */
+                const 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 {?}
-         */
-        isBlank(def, value) {
-            /** @type {?} */
-            const isNil = ___default.isNil(value);
-            return isNil ? true : def.isArray ? value['length'] < 1 : false;
-        }
     }
     __decorate([
         Trace(),
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [ParameterDefinition, Object, Object]),
+        __metadata("design:paramtypes", [RouteParameterValue, Object]),
         __metadata("design:returntype", Object)
     ], DefaultParameterSanitiser.prototype, "sanitise", null);
     ParameterDefinition.DefaultParameterSanitiser = DefaultParameterSanitiser;
@@ -2134,15 +2334,15 @@ if (false) {
     }
 })(ParameterDefinition || (ParameterDefinition = {}));
 
-var _a, _b;
+var _a;
 class ParameterSnapshot {
     /**
      * @param {?} placeDefinition
-     * @param {?} resolved
+     * @param {?} parameters
      */
-    constructor(placeDefinition, resolved) {
+    constructor(placeDefinition, parameters) {
         this.placeDefinition = placeDefinition;
-        this.resolved = resolved;
+        this.parameters = parameters;
     }
     /**
      * @param {?} other
@@ -2151,18 +2351,18 @@ class ParameterSnapshot {
      */
     hasChanged(other, debug = false) {
         /** @type {?} */
-        const changed = this.resolved.find((/**
+        const changed = this.parameters.find((/**
          * @param {?} r
          * @return {?}
          */
         (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;
@@ -2173,11 +2373,11 @@ class ParameterSnapshot {
      * @return {?}
      */
     getParameter(parameterDef) {
-        return this.resolved.find((/**
+        return this.parameters.find((/**
          * @param {?} r
          * @return {?}
          */
-        r => r.parameterDef === parameterDef));
+        r => r.definition === parameterDef));
     }
     /**
      * @template T, S
@@ -2201,11 +2401,11 @@ class ParameterSnapshot {
      */
     getParameterValue(name) {
         /** @type {?} */
-        const resolvedParameter = this.resolved.find((/**
+        const resolvedParameter = this.parameters.find((/**
          * @param {?} r
          * @return {?}
          */
-        r => r.parameterDef.name === name));
+        r => r.definition.name === name));
         return resolvedParameter ? resolvedParameter.value : null;
     }
     /**
@@ -2215,22 +2415,22 @@ class ParameterSnapshot {
     getRouteIdParameter() {
         // 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 {?}
          */
-        p => p.parameterDef.isRouteId))));
+        p => p.definition.isRouteId))));
     }
     /**
      * @private
      * @return {?}
      */
     getRouteParameters() {
-        return this.resolved.filter((/**
+        return this.parameters.filter((/**
          * @param {?} r
          * @return {?}
          */
-        r => !r.parameterDef.isRouteId));
+        r => !r.definition.isRouteId));
     }
     /**
      * @return {?}
@@ -2246,6 +2446,16 @@ class ParameterSnapshot {
         const routeIdParam = this.getRouteIdParameter();
         return routeIdParam ? routeIdParam.formattedValue() : null;
     }
+    /**
+     * @return {?}
+     */
+    getNonEmptyParameters() {
+        return this.parameters.filter((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => !p.isEmpty()));
+    }
     /**
      * @return {?}
      */
@@ -2253,32 +2463,32 @@ class ParameterSnapshot {
         /** @type {?} */
         const params = {};
         /** @type {?} */
-        const routeIdParam = this.resolved.filter((/**
+        const routeIdParam = this.getNonEmptyParameters()
+            .filter((/**
          * @param {?} p
          * @return {?}
          */
-        p => !p.parameterDef.isRouteId)).forEach((/**
+        p => !p.definition.isRouteId))
+            .forEach((/**
          * @param {?} p
          * @return {?}
          */
-        p => {
-            params[p.parameterDef.name] = p.formattedValue();
-        }));
+        p => params[p.definition.name] = p.formattedValue()));
         return params;
     }
     /**
      * @return {?}
      */
-    getAllFormattedParameters() {
+    getAllParameters() {
         /** @type {?} */
         const params = {};
         /** @type {?} */
-        const routeIdParam = this.resolved.forEach((/**
+        const routeIdParam = this.parameters.forEach((/**
          * @param {?} p
          * @return {?}
          */
         p => {
-            params[p.parameterDef.name] = p.formattedValue();
+            params[p.definition.name] = p.value;
         }));
         return params;
     }
@@ -2289,12 +2499,12 @@ class ParameterSnapshot {
      * @return {?}
      */
     replace(parameter, value) {
-        return new ParameterSnapshot(this.placeDefinition, this.resolved.map((/**
+        return new ParameterSnapshot(this.placeDefinition, this.parameters.map((/**
          * @param {?} p
          * @return {?}
          */
         p => {
-            return p.parameterDef === parameter ? p.replace(value) : p;
+            return p.definition === parameter ? p.replace(value) : p;
         })));
     }
     /**
@@ -2308,10 +2518,10 @@ class ParameterSnapshot {
                 const routeId = this.getRouteIdParameter();
                 /** @type {?} */
                 const sanitisedValue = yield routeId.sanitise(this, injector);
-                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 this.replace(routeId.parameterDef, sanitisedValue);
+                    return this.replace(routeId.definition, sanitisedValue);
                 }
             }
             /** @type {?} */
@@ -2323,8 +2533,8 @@ class ParameterSnapshot {
                 const routeParameter = routeParameters[i];
                 /** @type {?} */
                 const sanitisedValue = yield routeParameter.sanitise(this, injector);
-                if (!routeParameter.isSame(sanitisedValue)) {
-                    result = this.replace(routeParameter.parameterDef, sanitisedValue);
+                if (routeParameter.hasChanged(sanitisedValue)) {
+                    result = result.replace(routeParameter.definition, sanitisedValue);
                 }
             }
             return result;
@@ -2335,7 +2545,7 @@ __decorate([
     Memoize$1(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [ParameterDefinition]),
-    __metadata("design:returntype", ParameterSnapshot.ResolvedParameter)
+    __metadata("design:returntype", RouteParameterValue)
 ], ParameterSnapshot.prototype, "getParameter", null);
 __decorate([
     Memoize$1(),
@@ -2353,7 +2563,7 @@ __decorate([
     Memoize$1(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
-    __metadata("design:returntype", ParameterSnapshot.ResolvedValueParameter)
+    __metadata("design:returntype", RouteParameterValue.Scalar)
 ], ParameterSnapshot.prototype, "getRouteIdParameter", null);
 __decorate([
     Memoize$1(),
@@ -2364,15 +2574,9 @@ __decorate([
 __decorate([
     Trace(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [ParameterDefinition, typeof (_b = typeof S !== "undefined" && S) === "function" ? _b : Object]),
-    __metadata("design:returntype", ParameterSnapshot)
-], ParameterSnapshot.prototype, "replace", null);
-__decorate([
-    Trace(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Injector]),
-    __metadata("design:returntype", Promise)
-], ParameterSnapshot.prototype, "sanitise", null);
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ParameterSnapshot.prototype, "getFormattedParameters", null);
 if (false) {
     /** @type {?} */
     ParameterSnapshot.prototype.placeDefinition;
@@ -2380,7 +2584,7 @@ if (false) {
      * @type {?}
      * @private
      */
-    ParameterSnapshot.prototype.resolved;
+    ParameterSnapshot.prototype.parameters;
 }
 (function (ParameterSnapshot) {
     /**
@@ -2393,31 +2597,11 @@ if (false) {
         /** @type {?} */
         const paramMap = new ConsolidatedParameterMap(params, urlSegments);
         /** @type {?} */
-        const resolvedParameters = placeDef.getRouteParameters()
-            .map((/**
+        const resolvedParameters = placeDef.getRouteParameters().map((/**
          * @param {?} def
          * @return {?}
          */
-        def => {
-            if (def.isArray) {
-                /** @type {?} */
-                const value = paramMap.has(def.name) ? paramMap.getAll(def.name).filter((/**
-                 * @param {?} s
-                 * @return {?}
-                 */
-                s => !___default.isEmpty(s))).map((/**
-                 * @param {?} raw
-                 * @return {?}
-                 */
-                raw => def.type.parse(raw))) : null;
-                return new ResolvedArrayParameter(def, value);
-            }
-            else {
-                /** @type {?} */
-                const value = paramMap.has(def.name) ? def.type.parse(paramMap.get(def.name)) : null;
-                return new ResolvedValueParameter(def, value);
-            }
-        }));
+        def => RouteParameterValue.create(def, paramMap)));
         return new ParameterSnapshot(placeDef, resolvedParameters);
     }
     ParameterSnapshot.create = create;
@@ -2475,7 +2659,23 @@ if (false) {
              */
             m => m.has(name)));
         }
+        /**
+         * @return {?}
+         */
+        get keys() {
+            return this.paramMaps.reduce((/**
+             * @param {?} result
+             * @param {?} params
+             * @return {?}
+             */
+            (result, params) => result.concat(params.keys)), []);
+        }
     }
+    __decorate([
+        Memoize$1(),
+        __metadata("design:type", Array),
+        __metadata("design:paramtypes", [])
+    ], ConsolidatedParameterMap.prototype, "keys", null);
     if (false) {
         /**
          * @type {?}
@@ -2527,147 +2727,6 @@ if (false) {
          */
         ParamMapAdapter.prototype.params;
     }
-    /**
-     * @abstract
-     * @template T, S
-     */
-    class ResolvedParameter {
-        /**
-         * @param {?} parameterDef
-         * @param {?} value
-         */
-        constructor(parameterDef, value) {
-            this.parameterDef = parameterDef;
-            this.value = value;
-        }
-        /**
-         * @return {?}
-         */
-        isRouteId() {
-            return this.parameterDef.isRouteId;
-        }
-        /**
-         * @param {?} visit
-         * @param {?} injector
-         * @return {?}
-         */
-        sanitise(visit, injector) {
-            return __awaiter(this, void 0, void 0, function* () {
-                /** @type {?} */
-                const sanitiser = this.parameterDef.getSanitiser(injector);
-                if (sanitiser) {
-                    return sanitiser.sanitise(this.parameterDef, this.value, visit);
-                }
-                else {
-                    return this.value;
-                }
-            });
-        }
-    }
-    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
-     */
-    class ResolvedValueParameter extends ResolvedParameter {
-        /**
-         * @param {?} otherValue
-         * @return {?}
-         */
-        isSame(otherValue) {
-            return this.value === otherValue;
-        }
-        /**
-         * @param {?} dest
-         * @return {?}
-         */
-        injectRouteParam(dest) {
-            dest[this.parameterDef.name] = this.parameterDef.type.format(this.value);
-        }
-        /**
-         * @param {?} value
-         * @return {?}
-         */
-        replace(value) {
-            return new ResolvedValueParameter(this.parameterDef, value);
-        }
-        /**
-         * @return {?}
-         */
-        formattedValue() {
-            return !___default.isNil(this.value) ? this.parameterDef.type.format(this.value) : null;
-        }
-    }
-    ParameterSnapshot.ResolvedValueParameter = ResolvedValueParameter;
-    /**
-     * @template T
-     */
-    class ResolvedArrayParameter extends ResolvedParameter {
-        /**
-         * @param {?} otherValue
-         * @return {?}
-         */
-        isSame(otherValue) {
-            return ___default.isEqual(this.value, otherValue);
-        }
-        /**
-         * @param {?} dest
-         * @return {?}
-         */
-        injectRouteParam(dest) {
-            dest[this.parameterDef.name] = this.value.map((/**
-             * @param {?} v
-             * @return {?}
-             */
-            v => this.parameterDef.type.format(v)));
-        }
-        /**
-         * @param {?} value
-         * @return {?}
-         */
-        replace(value) {
-            return new ResolvedArrayParameter(this.parameterDef, value);
-        }
-        /**
-         * @return {?}
-         */
-        formattedValue() {
-            return this.value ? this.value.map((/**
-             * @param {?} v
-             * @return {?}
-             */
-            v => this.parameterDef.type.format(v))) : [];
-        }
-    }
-    ParameterSnapshot.ResolvedArrayParameter = ResolvedArrayParameter;
 })(ParameterSnapshot || (ParameterSnapshot = {}));
 
 /**
@@ -2796,8 +2855,8 @@ class PlaceOutletComponent extends DisposableComponent {
          * @return {?}
          */
         (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
         });
@@ -3583,7 +3642,7 @@ class PlaceRouteGuard {
              * @return {?}
              */
             sanitised => {
-                Logger.get(this).info("ParameterSnapshot.sanitise", { sanitised });
+                Logger.get(this).info("ParameterSnapshot.sanitise ->", sanitised.getAllParameters());
                 if (sanitised.hasChanged(snapshot, true)) {
                     return this.placeRouter.getRedirectUrlTree(activatedRoute, sanitised);
                 }
@@ -3737,12 +3796,11 @@ function RouteParameterList(elementType, options) {
 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) { };
 }
 
 /**
@@ -3805,297 +3863,6 @@ var ParameterType;
     ParameterType.BOOLEAN = new BooleanType();
 })(ParameterType || (ParameterType = {}));
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T, S
- */
-class Sanitiser {
-    /**
-     * @param {?} parameterDef
-     * @param {?} snapshot
-     * @param {?} sanitiser
-     */
-    constructor(parameterDef, snapshot, sanitiser) {
-        this.parameterDef = parameterDef;
-        this.snapshot = snapshot;
-        this.sanitiser = sanitiser;
-    }
-    /**
-     * @return {?}
-     */
-    isRouteId() {
-        return this.parameterDef.isRouteId;
-    }
-    /**
-     * @return {?}
-     */
-    get valueChanged() {
-        return !___default.isNil(this.initialValue) && this.hasChanged(this.initialValue, this.sanitisedValue);
-    }
-    /**
-     * @return {?}
-     */
-    get sanitisedValue() {
-        return this._sanitisedValue;
-    }
-    /**
-     * @protected
-     * @param {?} snapshot
-     * @return {?}
-     */
-    readFrom(snapshot) {
-        return lang.abstractMethod(this.constructor);
-    }
-    /**
-     * @protected
-     * @param {?} initialValue
-     * @param {?} sanitisedValue
-     * @return {?}
-     */
-    hasChanged(initialValue, sanitisedValue) {
-        return lang.abstractMethod(this.constructor);
-    }
-    /**
-     * @param {?} dest
-     * @return {?}
-     */
-    injectRouteParam(dest) {
-        lang.abstractMethod(this.constructor);
-    }
-    /**
-     * @return {?}
-     */
-    sanitize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.sanitiser) {
-                this.initialValue = this.readFrom(this.snapshot);
-                this._sanitisedValue = yield this.sanitiser.sanitise(null, this.initialValue);
-                if (this.initialValue !== this._sanitisedValue) {
-                    return false;
-                }
-            }
-            return true;
-        });
-    }
-}
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    Sanitiser.prototype.initialValue;
-    /**
-     * @type {?}
-     * @private
-     */
-    Sanitiser.prototype._sanitisedValue;
-    /** @type {?} */
-    Sanitiser.prototype.parameterDef;
-    /** @type {?} */
-    Sanitiser.prototype.snapshot;
-    /** @type {?} */
-    Sanitiser.prototype.sanitiser;
-}
-class RouteParameterSanitiser {
-    /**
-     * @param {?} parameterDefs
-     * @param {?} snapshot
-     * @param {?} injector
-     */
-    constructor(parameterDefs, snapshot, injector) {
-        this.parameterDefs = parameterDefs;
-        this.snapshot = snapshot;
-        this.injector = injector;
-        this.parameterSanitisers = [];
-        /** @type {?} */
-        const sanitisers = parameterDefs.map((/**
-         * @param {?} def
-         * @return {?}
-         */
-        def => {
-            return def.isArray ?
-                new Sanitiser.Array(def, snapshot, this.getSanitiser(def)) :
-                new Sanitiser.Value(def, snapshot, this.getSanitiser(def));
-        }));
-        this.routeIdSanitiser = sanitisers.find((/**
-         * @param {?} p
-         * @return {?}
-         */
-        p => p.isRouteId()));
-        this.parameterSanitisers = sanitisers.filter((/**
-         * @param {?} p
-         * @return {?}
-         */
-        p => !p.isRouteId()));
-    }
-    /**
-     * @return {?}
-     */
-    sanitise() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.routeIdSanitiser) {
-                yield this.routeIdSanitiser.sanitize();
-                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 false;
-                }
-            }
-            for (const sanitiser of this.parameterSanitisers) {
-                yield sanitiser.sanitize();
-            }
-            return !this.parameterSanitisers.find((/**
-             * @param {?} s
-             * @return {?}
-             */
-            s => s.valueChanged));
-        });
-    }
-    /**
-     * @private
-     * @template T, S
-     * @param {?} def
-     * @return {?}
-     */
-    getSanitiser(def) {
-        return def.getSanitiser(this.injector);
-    }
-    /**
-     * @return {?}
-     */
-    routeIdHasChanged() {
-        assert.isTruthy(this.parameterSanitisers.length !== 0);
-        return this.routeIdSanitiser && this.routeIdSanitiser.valueChanged;
-    }
-    // @Trace()
-    /**
-     * @return {?}
-     */
-    getRedirectParams() {
-        if (this.routeIdHasChanged()) {
-            return [this.routeIdSanitiser.sanitisedValue];
-        }
-        else {
-            /** @type {?} */
-            const routeParams = {};
-            this.parameterSanitisers.forEach((/**
-             * @param {?} s
-             * @return {?}
-             */
-            s => s.injectRouteParam(routeParams)));
-            return [routeParams];
-        }
-    }
-    /**
-     * @private
-     * @template S
-     * @param {?} value
-     * @return {?}
-     */
-    isSanitiserContructor(value) {
-        return ___default.isFunction(value) && lang.constructorChain((/** @type {?} */ ((/** @type {?} */ (value))))).includes(Sanitiser);
-    }
-}
-__decorate([
-    Memoize$1(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [ParameterDefinition]),
-    __metadata("design:returntype", Object)
-], RouteParameterSanitiser.prototype, "getSanitiser", null);
-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
-     */
-    class Value extends Sanitiser {
-        /**
-         * @param {?} snapshot
-         * @return {?}
-         */
-        readFrom(snapshot) {
-            /** @type {?} */
-            const rawValue = snapshot.paramMap.get(this.parameterDef.name);
-            return this.parameterDef.type.parse(rawValue);
-        }
-        /**
-         * @protected
-         * @param {?} initialValue
-         * @param {?} sanitisedValue
-         * @return {?}
-         */
-        hasChanged(initialValue, sanitisedValue) {
-            return initialValue !== sanitisedValue;
-        }
-        /**
-         * @param {?} dest
-         * @return {?}
-         */
-        injectRouteParam(dest) {
-            dest[this.parameterDef.name] = this.parameterDef.type.format(this.sanitisedValue);
-        }
-    }
-    Sanitiser.Value = Value;
-    /**
-     * @template T
-     */
-    class Array extends Sanitiser {
-        /**
-         * @param {?} snapshot
-         * @return {?}
-         */
-        readFrom(snapshot) {
-            /** @type {?} */
-            const rawValues = snapshot.paramMap.getAll(this.parameterDef.name);
-            return rawValues.map((/**
-             * @param {?} value
-             * @return {?}
-             */
-            value => this.parameterDef.type.parse(value)));
-        }
-        /**
-         * @protected
-         * @param {?} initialValue
-         * @param {?} sanitisedValue
-         * @return {?}
-         */
-        hasChanged(initialValue, sanitisedValue) {
-            return initialValue !== sanitisedValue;
-        }
-        /**
-         * @param {?} dest
-         * @return {?}
-         */
-        injectRouteParam(dest) {
-            dest[this.parameterDef.name] = this.sanitisedValue.map((/**
-             * @param {?} v
-             * @return {?}
-             */
-            v => this.parameterDef.type.format(v)));
-        }
-    }
-    Sanitiser.Array = Array;
-})(Sanitiser || (Sanitiser = {}));
-
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -4116,5 +3883,5 @@ if (false) {
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
-export { ACTIVITY_DATA, AbstractActivity, AbstractInputComponent, AbstractPlaceNavigationComponent, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, AngularUiPowerupsModule, Bounds, BusyOverlayComponent, CommandDirective, ConfirmationDialogComponent, DEFINITION_META_DATA_KEY, DialogInteractionService, Dimension, DisposableComponent, EmptyStateComponent, FocusBindingDirective, INTERACTION_CONTEXT, InteractionContext, InteractionModule, LEFT_RIGHT_PLACE_ANIMATION, LeavePlaceGuard, ListPlaceNavComponent, NumberInputComponent, ParameterDefinition, ParameterSnapshot, ParameterType, PasswordInputComponent, Place, PlaceComponent, PlaceDefinition, PlaceHistory, PlaceModule, PlaceOutletComponent, PlaceRouteGuard, PlaceRouter, Point, ROUTE_PARAMETER_LIST_KEY, ResizeAwareComponent, RouteId, RouteParameter, RouteParameterList, RouteParameterSanitiser, Sanitiser, SelectInputComponent, StringInputComponent, TabbedPlaceNavigationComponent, leftRightPlaceAnimation, slideDownAndUpAnimation, CommandDirective as ɵa, FocusBindingDirective as ɵb, AlertDialogComponent as ɵba, DialogInteractionService as ɵbc, InteractionContext as ɵbd, DisposableComponent as ɵc, NumberInputComponent as ɵd, AbstractInputComponent as ɵe, StringInputComponent as ɵf, PasswordInputComponent as ɵg, SelectInputComponent as ɵh, PlaceModule as ɵi, EmptyStateComponent as ɵj, BusyOverlayComponent as ɵk, PlaceOutletComponent as ɵl, leftRightPlaceAnimation as ɵm, LEFT_RIGHT_PLACE_ANIMATION as ɵn, PlaceRouter as ɵo, PlaceHistory as ɵp, TabbedPlaceNavigationComponent as ɵq, AbstractPlaceNavigationComponent as ɵr, ListPlaceNavComponent as ɵs, InteractionModule as ɵt, ActivityContainerComponent as ɵu, ActivityOutletComponent as ɵv, ConfirmationDialogComponent as ɵw, AbstractActivity as ɵx, ACTIVITY_DATA as ɵy };
+export { ACTIVITY_DATA, AbstractActivity, AbstractInputComponent, AbstractPlaceNavigationComponent, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, AngularUiPowerupsModule, Bounds, BusyOverlayComponent, CommandDirective, ConfirmationDialogComponent, DEFINITION_META_DATA_KEY, DialogInteractionService, Dimension, DisposableComponent, EmptyStateComponent, FocusBindingDirective, INTERACTION_CONTEXT, InteractionContext, InteractionModule, LEFT_RIGHT_PLACE_ANIMATION, LeavePlaceGuard, ListPlaceNavComponent, NumberInputComponent, ParameterDefinition, ParameterSnapshot, ParameterType, PasswordInputComponent, Place, PlaceComponent, PlaceDefinition, PlaceHistory, PlaceModule, PlaceOutletComponent, PlaceRouteGuard, PlaceRouter, Point, ROUTE_PARAMETER_LIST_KEY, ResizeAwareComponent, RouteId, RouteParameter, RouteParameterList, RouteParameterValue, SelectInputComponent, StringInputComponent, TabbedPlaceNavigationComponent, leftRightPlaceAnimation, slideDownAndUpAnimation, CommandDirective as ɵa, FocusBindingDirective as ɵb, AlertDialogComponent as ɵba, DialogInteractionService as ɵbc, InteractionContext as ɵbd, DisposableComponent as ɵc, NumberInputComponent as ɵd, AbstractInputComponent as ɵe, StringInputComponent as ɵf, PasswordInputComponent as ɵg, SelectInputComponent as ɵh, PlaceModule as ɵi, EmptyStateComponent as ɵj, BusyOverlayComponent as ɵk, PlaceOutletComponent as ɵl, leftRightPlaceAnimation as ɵm, LEFT_RIGHT_PLACE_ANIMATION as ɵn, PlaceRouter as ɵo, PlaceHistory as ɵp, TabbedPlaceNavigationComponent as ɵq, AbstractPlaceNavigationComponent as ɵr, ListPlaceNavComponent as ɵs, InteractionModule as ɵt, ActivityContainerComponent as ɵu, ActivityOutletComponent as ɵv, ConfirmationDialogComponent as ɵw, AbstractActivity as ɵx, ACTIVITY_DATA as ɵy };
 //# sourceMappingURL=coolon-angular-ui-powerups.js.map