@coolon/angular-ui-powerups 0.0.44 → 0.0.46

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

@@ -13,7 +13,7 @@ import { MatDialog as MatDialog$1 } from '@angular/material/dialog';
 import { MatIconModule } from '@angular/material/icon';
 import { MatListModule } from '@angular/material/list';
 import { MatTooltipModule } from '@angular/material/tooltip';
-import { Router, RouterModule } from '@angular/router';
+import { Router, ActivatedRouteSnapshot, UrlTree, RouterModule } from '@angular/router';
 import { Memoize as Memoize$1 } from '@typescript-plus/fast-memoize-decorator/dist/src';
 import { Memoize } from '@typescript-plus/fast-memoize-decorator';
 import 'reflect-metadata';
@@ -1578,7 +1578,7 @@ class PlaceComponent extends DisposableComponent {
              * @return {?}
              */
             toRight(parameters) {
-                return parameters.getResolvedParameterValue(parameterDef);
+                return parameters.getValueOf(parameterDef);
             },
             /**
              * @param {?} value
@@ -1790,7 +1790,7 @@ class PlaceHistory {
      */
     constructor(router) {
         this.router = router;
-        this._history = [];
+        this._history = new Map();
     }
     /**
      * @param {?} state
@@ -1798,12 +1798,35 @@ class PlaceHistory {
      */
     add(state) {
         /** @type {?} */
-        const previousState = ___default.last(this._history);
+        const history = this.getHistory(state.placeDefinition);
+        /** @type {?} */
+        const previousState = ___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 {?}
+     */
+    getHistory(placeDef) {
+        /** @type {?} */
+        let history = this._history.get(placeDef);
+        if (!history) {
+            history = [];
+            this.setHistory(placeDef, history);
         }
+        return history;
+    }
+    /**
+     * @private
+     * @param {?} placeDef
+     * @param {?} history
+     * @return {?}
+     */
+    setHistory(placeDef, history) {
+        this._history.set(placeDef, history);
     }
 }
 PlaceHistory.decorators = [
@@ -1829,84 +1852,6 @@ if (false) {
     PlaceHistory.prototype.router;
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class PlaceRouter {
-    /**
-     * @param {?} router
-     */
-    constructor(router) {
-        this.router = router;
-    }
-    /**
-     * @param {?} activatedRoute
-     * @param {?} previous
-     * @param {?} next
-     * @return {?}
-     */
-    pushParameterChangesToRoute(activatedRoute, previous, next) {
-        this.router.navigate(this.redirect(activatedRoute.snapshot, previous, next), {
-            relativeTo: activatedRoute
-        });
-    }
-    /**
-     * @param {?} activatedRoute
-     * @param {?} sanitised
-     * @param {?} snapshot
-     * @return {?}
-     */
-    createUrlTree(activatedRoute, sanitised, snapshot) {
-        return this.router.createUrlTree(this.redirect(activatedRoute, snapshot, sanitised));
-    }
-    /**
-     * @protected
-     * @param {?} activatedRoute
-     * @param {?} previous
-     * @param {?} next
-     * @return {?}
-     */
-    redirect(activatedRoute, previous, next) {
-        /** @type {?} */
-        const childSegments = ___default.flatten(activatedRoute.children.map((/**
-         * @param {?} child
-         * @return {?}
-         */
-        child => child.url)));
-        /** @type {?} */
-        const relativePath = !!previous.hasRouteId() ? '..' : '.';
-        /** @type {?} */
-        const routeId = next.getFormattedRouteId();
-        /** @type {?} */
-        const path = routeId ?
-            [relativePath, routeId, next.getFormattedParameters()] :
-            [relativePath, next.getFormattedParameters()];
-        return path.concat(childSegments.map((/**
-         * @param {?} s
-         * @return {?}
-         */
-        s => s.path)));
-    }
-}
-PlaceRouter.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
-/** @nocollapse */
-PlaceRouter.ctorParameters = () => [
-    { type: Router }
-];
-/** @nocollapse */ PlaceRouter.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(ɵɵinject(Router)); }, token: PlaceRouter, providedIn: "root" });
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    PlaceRouter.prototype.router;
-}
-
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -1927,18 +1872,20 @@ class ParameterDefinition {
         /** @type {?} */
         const opts = 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
      * @return {?}
      */
     getSanitiser(injector) {
-        return this.sanitiser;
+        if (this.remember || !___default.isNil(this.defaultValue)) {
+            return new ParameterDefinition.DefaultParameterSanitiser(this.remember, this.defaultValue, injector.get(PlaceHistory));
+        }
+        else {
+            return null;
+        }
     }
 }
 if (false) {
@@ -1948,8 +1895,16 @@ if (false) {
     ParameterDefinition.prototype.isArray;
     /** @type {?} */
     ParameterDefinition.prototype.name;
-    /** @type {?} */
-    ParameterDefinition.prototype.sanitiser;
+    /**
+     * @type {?}
+     * @private
+     */
+    ParameterDefinition.prototype.remember;
+    /**
+     * @type {?}
+     * @private
+     */
+    ParameterDefinition.prototype.defaultValue;
     /** @type {?} */
     ParameterDefinition.prototype.propertyName;
     /** @type {?} */
@@ -2023,6 +1978,77 @@ if (false) {
         /** @type {?} */
         ArrayParameter.prototype.isArray;
     }
+    /**
+     * @template T, S
+     */
+    class DefaultParameterSanitiser {
+        /**
+         * @param {?} remember
+         * @param {?} defaultValue
+         * @param {?} placeHistory
+         */
+        constructor(remember, defaultValue, placeHistory) {
+            this.remember = remember;
+            this.defaultValue = defaultValue;
+            this.placeHistory = placeHistory;
+        }
+        /**
+         * @param {?} parameterDef
+         * @param {?} value
+         * @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)));
+                }
+                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 {?}
+         */
+        isBlank(def, value) {
+            /** @type {?} */
+            const isNil = ___default.isNil(value);
+            return isNil ? true : def.isArray ? value['length'] < 1 : false;
+        }
+    }
+    ParameterDefinition.DefaultParameterSanitiser = DefaultParameterSanitiser;
+    if (false) {
+        /** @type {?} */
+        DefaultParameterSanitiser.prototype.remember;
+        /** @type {?} */
+        DefaultParameterSanitiser.prototype.defaultValue;
+        /** @type {?} */
+        DefaultParameterSanitiser.prototype.placeHistory;
+    }
 })(ParameterDefinition || (ParameterDefinition = {}));
 
 var _a;
@@ -2037,20 +2063,25 @@ class ParameterSnapshot {
     }
     /**
      * @param {?} other
+     * @param {?=} debug
      * @return {?}
      */
-    hasChanged(other) {
+    hasChanged(other, debug = false) {
         /** @type {?} */
         const changed = this.resolved.find((/**
          * @param {?} r
          * @return {?}
          */
         (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;
     }
     /**
@@ -2058,7 +2089,7 @@ class ParameterSnapshot {
      * @param {?} parameterDef
      * @return {?}
      */
-    getResolvedParameter(parameterDef) {
+    getParameter(parameterDef) {
         return this.resolved.find((/**
          * @param {?} r
          * @return {?}
@@ -2070,22 +2101,22 @@ class ParameterSnapshot {
      * @param {?} parameterDef
      * @return {?}
      */
-    getResolvedParameterValue(parameterDef) {
+    getValueOf(parameterDef) {
         /** @type {?} */
-        const resolvedParameter = this.getResolvedParameter(parameterDef);
+        const resolvedParameter = this.getParameter(parameterDef);
         return resolvedParameter ? resolvedParameter.value : null;
     }
     /**
      * @return {?}
      */
-    getRouteId() {
-        return this.getResolvedRouteId() ? this.getResolvedRouteId().value : null;
+    getRouteIdValue() {
+        return this.getRouteIdParameter() ? this.getRouteIdParameter().value : null;
     }
     /**
      * @param {?} name
      * @return {?}
      */
-    getRouteParameter(name) {
+    getParameterValue(name) {
         /** @type {?} */
         const resolvedParameter = this.resolved.find((/**
          * @param {?} r
@@ -2098,7 +2129,7 @@ class ParameterSnapshot {
      * @private
      * @return {?}
      */
-    getResolvedRouteId() {
+    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((/**
@@ -2107,18 +2138,29 @@ class ParameterSnapshot {
          */
         p => p.parameterDef.isRouteId))));
     }
+    /**
+     * @private
+     * @return {?}
+     */
+    getRouteParameters() {
+        return this.resolved.filter((/**
+         * @param {?} r
+         * @return {?}
+         */
+        r => !r.parameterDef.isRouteId));
+    }
     /**
      * @return {?}
      */
     hasRouteId() {
-        return !!this.getResolvedRouteId();
+        return !!this.getRouteIdParameter();
     }
     /**
      * @return {?}
      */
     getFormattedRouteId() {
         /** @type {?} */
-        const routeIdParam = this.getResolvedRouteId();
+        const routeIdParam = this.getRouteIdParameter();
         return routeIdParam ? routeIdParam.formattedValue() : null;
     }
     /**
@@ -2141,6 +2183,22 @@ class ParameterSnapshot {
         }));
         return params;
     }
+    /**
+     * @return {?}
+     */
+    getAllFormattedParameters() {
+        /** @type {?} */
+        const params = {};
+        /** @type {?} */
+        const routeIdParam = this.resolved.forEach((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => {
+            params[p.parameterDef.name] = p.formattedValue();
+        }));
+        return params;
+    }
     /**
      * @template T, S
      * @param {?} parameter
@@ -2162,7 +2220,29 @@ class ParameterSnapshot {
      */
     sanitise(injector) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this;
+            if (this.hasRouteId()) {
+                /** @type {?} */
+                const routeId = this.getRouteIdParameter();
+                /** @type {?} */
+                const sanitisedValue = yield routeId.sanitise(this, injector);
+                if (!routeId.isSame(sanitisedValue)) {
+                    // if the route id has changed we redirect immediately as other
+                    // parameter sanitisers might use it.
+                    return this.replace(routeId.parameterDef, sanitisedValue);
+                }
+            }
+            /** @type {?} */
+            let result = this;
+            /** @type {?} */
+            const routeParameters = this.getRouteParameters();
+            for (let i = 0; i < routeParameters.length; i++) {
+                /** @type {?} */
+                const sanitisedValue = yield routeParameters[i].sanitise(this, injector);
+                if (!routeParameters[i].isSame(sanitisedValue)) {
+                    result = this.replace(routeParameters[i].parameterDef, sanitisedValue);
+                }
+            }
+            return result;
         });
     }
 }
@@ -2171,25 +2251,37 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [ParameterDefinition]),
     __metadata("design:returntype", ParameterSnapshot.ResolvedParameter)
-], ParameterSnapshot.prototype, "getResolvedParameter", null);
+], ParameterSnapshot.prototype, "getParameter", null);
 __decorate([
     Memoize$1(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [ParameterDefinition]),
     __metadata("design:returntype", typeof (_a = typeof S !== "undefined" && S) === "function" ? _a : Object)
-], ParameterSnapshot.prototype, "getResolvedParameterValue", null);
+], ParameterSnapshot.prototype, "getValueOf", null);
 __decorate([
     Memoize$1(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Object)
-], ParameterSnapshot.prototype, "getRouteParameter", null);
+], ParameterSnapshot.prototype, "getParameterValue", null);
 __decorate([
     Memoize$1(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", ParameterSnapshot.ResolvedValueParameter)
-], ParameterSnapshot.prototype, "getResolvedRouteId", null);
+], ParameterSnapshot.prototype, "getRouteIdParameter", null);
+__decorate([
+    Memoize$1(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Array)
+], ParameterSnapshot.prototype, "getRouteParameters", null);
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Injector]),
+    __metadata("design:returntype", Promise)
+], ParameterSnapshot.prototype, "sanitise", null);
 if (false) {
     /** @type {?} */
     ParameterSnapshot.prototype.placeDefinition;
@@ -2202,10 +2294,13 @@ if (false) {
 (function (ParameterSnapshot) {
     /**
      * @param {?} placeDef
-     * @param {?} paramMap
+     * @param {?} params
+     * @param {?} urlSegments
      * @return {?}
      */
-    function create(placeDef, paramMap) {
+    function create(placeDef, params, urlSegments) {
+        /** @type {?} */
+        const paramMap = new ConsolidatedParameterMap(params, urlSegments);
         /** @type {?} */
         const resolvedParameters = placeDef.getRouteParameters()
             .map((/**
@@ -2215,7 +2310,11 @@ if (false) {
         def => {
             if (def.isArray) {
                 /** @type {?} */
-                const value = paramMap.has(def.name) ? paramMap.getAll(def.name).map((/**
+                const value = paramMap.has(def.name) ? paramMap.getAll(def.name).filter((/**
+                 * @param {?} s
+                 * @return {?}
+                 */
+                s => !___default.isEmpty(s))).map((/**
                  * @param {?} raw
                  * @return {?}
                  */
@@ -2231,6 +2330,112 @@ if (false) {
         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.
+     */
+    class ConsolidatedParameterMap {
+        /**
+         * @param {?} paramMap
+         * @param {?} urlSegments
+         */
+        constructor(paramMap, urlSegments) {
+            this.paramMaps = [paramMap].concat((urlSegments || []).map((/**
+             * @param {?} s
+             * @return {?}
+             */
+            s => new ParamMapAdapter(s.parameters)))).filter((/**
+             * @param {?} m
+             * @return {?}
+             */
+            m => !!m)); // the activated route param map can be null
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        get(name) {
+            return this.paramMaps.find((/**
+             * @param {?} m
+             * @return {?}
+             */
+            m => m.has(name))).get(name);
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        getAll(name) {
+            return this.paramMaps.find((/**
+             * @param {?} m
+             * @return {?}
+             */
+            m => m.has(name))).getAll(name);
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        has(name) {
+            return !!this.paramMaps.find((/**
+             * @param {?} m
+             * @return {?}
+             */
+            m => m.has(name)));
+        }
+    }
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        ConsolidatedParameterMap.prototype.paramMaps;
+    }
+    class ParamMapAdapter {
+        /**
+         * @param {?} params
+         */
+        constructor(params) {
+            this.params = params;
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        get(name) {
+            return this.params[name];
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        getAll(name) {
+            /** @type {?} */
+            const value = this.get(name);
+            return Array.isArray(value) ? value : [value];
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        has(name) {
+            return this.keys.includes(name);
+        }
+        /**
+         * @return {?}
+         */
+        get keys() {
+            return Object.keys(this.params);
+        }
+    }
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        ParamMapAdapter.prototype.params;
+    }
     /**
      * @abstract
      * @template T, S
@@ -2250,6 +2455,23 @@ if (false) {
         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) {
@@ -2357,6 +2579,96 @@ if (false) {
     ParameterSnapshot.ResolvedArrayParameter = ResolvedArrayParameter;
 })(ParameterSnapshot || (ParameterSnapshot = {}));
 
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class PlaceRouter {
+    /**
+     * @param {?} router
+     */
+    constructor(router) {
+        this.router = router;
+    }
+    /**
+     * @param {?} activatedRoute
+     * @param {?} previous
+     * @param {?} next
+     * @return {?}
+     */
+    pushParameterChangesToRoute(activatedRoute, previous, next) {
+        /** @type {?} */
+        const relativePath = !!previous.hasRouteId() ? '..' : '.';
+        this.router.navigate([relativePath].concat(this.createRouteParameters(next), this.getChildPath(activatedRoute.snapshot)), {
+            relativeTo: activatedRoute
+        });
+    }
+    /**
+     * @param {?} activatedRoute
+     * @param {?} sanitised
+     * @return {?}
+     */
+    getRedirectUrlTree(activatedRoute, sanitised) {
+        /** @type {?} */
+        const urlSegments = activatedRoute.url;
+        /** @type {?} */
+        const weHaveARouteId = sanitised.hasRouteId() && sanitised.getFormattedRouteId();
+        /** @type {?} */
+        const commands = (weHaveARouteId) ?
+            [urlSegments[0].path, sanitised.getFormattedRouteId(), sanitised.getFormattedParameters()] :
+            [urlSegments[0].path, sanitised.getFormattedParameters()];
+        console.log("redirect path", commands);
+        return this.router.createUrlTree(commands);
+    }
+    /**
+     * @protected
+     * @param {?} activatedRoute
+     * @return {?}
+     */
+    getChildPath(activatedRoute) {
+        return ___default.flatten(activatedRoute.children.map((/**
+         * @param {?} child
+         * @return {?}
+         */
+        child => child.url)));
+    }
+    /**
+     * @protected
+     * @param {?} parameters
+     * @return {?}
+     */
+    createRouteParameters(parameters) {
+        /** @type {?} */
+        const routeId = parameters.getFormattedRouteId();
+        return routeId ?
+            [routeId, parameters.getFormattedParameters()] :
+            [parameters.getFormattedParameters()];
+    }
+}
+PlaceRouter.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+PlaceRouter.ctorParameters = () => [
+    { type: Router }
+];
+/** @nocollapse */ PlaceRouter.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(ɵɵinject(Router)); }, token: PlaceRouter, providedIn: "root" });
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ActivatedRouteSnapshot, ParameterSnapshot]),
+    __metadata("design:returntype", UrlTree)
+], PlaceRouter.prototype, "getRedirectUrlTree", null);
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouter.prototype.router;
+}
+
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -2447,19 +2759,25 @@ class PlaceOutletComponent extends DisposableComponent {
         this._placeDefinition = new MutableValueModel();
         this._resolvedParameters = new MutableValueModel();
         const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
-        this._paramMap = chain(this._activatedRouteModel).pullObservableValue((/**
+        /** @type {?} */
+        const paramMap = chain(this._activatedRouteModel).pullObservableValue((/**
          * @param {?} ar
          * @return {?}
          */
         ar => ar.paramMap));
-        this.placeConfigured = valueOf.all(chain(this._inOutletUpdate).isFalsey(), this._placeDefinition, this._paramMap).areTruthy();
-        when.valueOf(this._paramMap).changes((/**
-         * @param {?} params
+        /** @type {?} */
+        const urls = chain(this._activatedRouteModel).pullObservableValue((/**
+         * @param {?} ar
          * @return {?}
          */
-        (params) => {
+        ar => ar.url));
+        this.placeConfigured = valueOf.all(chain(this._inOutletUpdate).isFalsey(), this._placeDefinition, paramMap, urls).areTruthy();
+        when.anyOf(paramMap, urls).changes((/**
+         * @return {?}
+         */
+        () => {
             /** @type {?} */
-            const snapshot = ParameterSnapshot.create(this._placeDefinition.value, params);
+            const snapshot = ParameterSnapshot.create(this._placeDefinition.value, paramMap.value, urls.value);
             this._incomingRouteChange.whileTrue((/**
              * @return {?}
              */
@@ -2481,6 +2799,10 @@ class PlaceOutletComponent extends DisposableComponent {
         }), {
             unless: this.incomingRouteChange
         });
+        // const txo = new TransactionObserver().onEvent(e => console.log(e.toString()));
+        // txo.observe('paramMap', paramMap);
+        // txo.observe('urls', urls);
+        // txo.observe('this._resolvedParameters', this._resolvedParameters);
     }
     /**
      * @return {?}
@@ -2614,11 +2936,6 @@ if (false) {
      * @private
      */
     PlaceOutletComponent.prototype._placeDefinition;
-    /**
-     * @type {?}
-     * @private
-     */
-    PlaceOutletComponent.prototype._paramMap;
     /** @type {?} */
     PlaceOutletComponent.prototype._resolvedParameters;
     /**
@@ -3154,12 +3471,12 @@ if (false) {
     /**
      * @return {?}
      */
-    Visit.prototype.getRouteId = function () { };
+    Visit.prototype.getRouteIdValue = function () { };
     /**
      * @param {?} name
      * @return {?}
      */
-    Visit.prototype.getRouteParameter = function (name) { };
+    Visit.prototype.getParameterValue = function (name) { };
 }
 
 /**
@@ -3252,14 +3569,14 @@ class PlaceRouteGuard {
             /** @type {?} */
             const placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);
             /** @type {?} */
-            const snapshot = ParameterSnapshot.create(placeDefinition, activatedRoute.paramMap);
+            const snapshot = ParameterSnapshot.create(placeDefinition, activatedRoute.paramMap, activatedRoute.url);
             return snapshot.sanitise(this.injector).then((/**
              * @param {?} sanitised
              * @return {?}
              */
             sanitised => {
-                if (sanitised.hasChanged(snapshot)) {
-                    return this.placeRouter.createUrlTree(activatedRoute, snapshot, sanitised);
+                if (sanitised.hasChanged(snapshot, true)) {
+                    return this.placeRouter.getRedirectUrlTree(activatedRoute, sanitised);
                 }
                 else {
                     return true;
@@ -3295,69 +3612,6 @@ if (false) {
     PlaceRouteGuard.prototype.injector;
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T, S
- */
-class DefaultParameterSanitiser {
-    /**
-     * @param {?} def
-     * @param {?} remember
-     * @param {?} defaultValue
-     */
-    constructor(def, remember, defaultValue) {
-        this.def = def;
-        this.remember = remember;
-        this.defaultValue = defaultValue;
-    }
-    /**
-     * @param {?} value
-     * @param {?} visit
-     * @return {?}
-     */
-    sanitise(value, visit) {
-        if (this.isBlank(value)) {
-            if (this.remember) {
-                // value = null;
-            }
-            return this.isBlank(value) && !___default.isNil(this.defaultValue) ? this.defaultValue : value;
-        }
-        else {
-            return value;
-        }
-    }
-    /**
-     * @private
-     * @param {?} value
-     * @return {?}
-     */
-    isBlank(value) {
-        /** @type {?} */
-        const isNil = ___default.isNil(value);
-        return this.def.isArray ? !isNil || value['length'] < 1 : isNil;
-    }
-}
-__decorate([
-    Trace(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Object)
-], DefaultParameterSanitiser.prototype, "sanitise", null);
-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
@@ -3469,16 +3723,17 @@ function RouteParameterList(elementType, options) {
  */
 /**
  * @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) { };
 }
 
 /**
@@ -3608,7 +3863,7 @@ class Sanitiser {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.sanitiser) {
                 this.initialValue = this.readFrom(this.snapshot);
-                this._sanitisedValue = yield this.sanitiser.sanitise(this.initialValue);
+                this._sanitisedValue = yield this.sanitiser.sanitise(null, this.initialValue);
                 if (this.initialValue !== this._sanitisedValue) {
                     return false;
                 }
@@ -3857,5 +4112,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, DefaultParameterSanitiser, 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, 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 };
 //# sourceMappingURL=coolon-angular-ui-powerups.js.map