@coolon/angular-ui-powerups 0.0.26 → 0.0.28

package/esm2015/lib/place/route/route-parameter-bindings.js

@@ -0,0 +1,294 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { ActivatedRoute, Router } from '@angular/router';
+import { Binding, Dsl, GarbageCollector, MutableValueModel, Trace, TransactionObserver } from '@coolon/pectin';
+import { Klass } from '@coolon/typescript-utilities';
+/**
+ * @record
+ * @template T
+ */
+function ResolvedParameter() { }
+if (false) {
+    /** @type {?} */
+    ResolvedParameter.prototype.parameterDef;
+    /** @type {?} */
+    ResolvedParameter.prototype.resolvedValue;
+}
+class ResolvedParameters {
+    /**
+     * @param {?} parameters
+     */
+    constructor(parameters) {
+        this.parameters = parameters;
+    }
+    /**
+     * @template T
+     * @param {?} parameter
+     * @return {?}
+     */
+    get(parameter) {
+        /** @type {?} */
+        const resolved = this.parameters.find((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => p.parameterDef === parameter));
+        return resolved ? resolved.resolvedValue : null;
+    }
+    /**
+     * @template T
+     * @param {?} parameter
+     * @param {?} value
+     * @return {?}
+     */
+    replace(parameter, value) {
+        return new ResolvedParameters(this.parameters.filter((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => p.parameterDef !== parameter)).concat({
+            parameterDef: parameter,
+            resolvedValue: value
+        }));
+    }
+    /**
+     * @protected
+     * @return {?}
+     */
+    getFormattedRouteId() {
+        /** @type {?} */
+        const routeIdParam = this.getRouteIdParam();
+        return routeIdParam ? routeIdParam.parameterDef.type.format(routeIdParam.resolvedValue) : null;
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    getRouteIdParam() {
+        return this.parameters.find((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => p.parameterDef.isRouteId));
+    }
+    /**
+     * @protected
+     * @return {?}
+     */
+    getFormattedParameters() {
+        /** @type {?} */
+        const params = {};
+        /** @type {?} */
+        const routeIdParam = this.parameters.filter((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => !p.parameterDef.isRouteId)).forEach((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => {
+            params[p.parameterDef.name] = p.parameterDef.type.format(p.resolvedValue);
+        }));
+        return params;
+    }
+    /**
+     * @return {?}
+     */
+    hasRouteId() {
+        return !!this.getRouteIdParam();
+    }
+    /**
+     * @param {?} previous
+     * @param {?} router
+     * @param {?} activatedRoute
+     * @return {?}
+     */
+    redirect(previous, router, activatedRoute) {
+        /** @type {?} */
+        const routeId = this.getFormattedRouteId();
+        /** @type {?} */
+        const relativePath = !!previous.hasRouteId() ? '..' : '.';
+        /** @type {?} */
+        const path = routeId ? [relativePath, routeId, this.getFormattedParameters()] : [relativePath, this.getFormattedParameters()];
+        router.navigate(path, {
+            relativeTo: activatedRoute
+        });
+    }
+}
+tslib_1.__decorate([
+    Trace(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
+], ResolvedParameters.prototype, "getFormattedRouteId", null);
+tslib_1.__decorate([
+    Trace(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
+], ResolvedParameters.prototype, "getFormattedParameters", null);
+tslib_1.__decorate([
+    Trace(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [ResolvedParameters, Router, ActivatedRoute]),
+    tslib_1.__metadata("design:returntype", void 0)
+], ResolvedParameters.prototype, "redirect", null);
+if (false) {
+    /** @type {?} */
+    ResolvedParameters.prototype.parameters;
+}
+export class RouteParameterBindings extends GarbageCollector {
+    /**
+     * @param {?} component
+     * @param {?} router
+     * @param {?} activatedRoute
+     */
+    constructor(component, router, activatedRoute) {
+        super();
+        this.component = component;
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+        this._incomingRouteChange = new MutableValueModel(false);
+        this.resolvedParameters = new MutableValueModel();
+        const { chain, valueOf, before, when, after, observe } = Dsl.disposeWith(this);
+        this.txo = new TransactionObserver(); //.onEvent(e => console.log(e.toString()));
+        //.onEvent(e => console.log(e.toString()));
+        /** @type {?} */
+        const routeParameterDefs = Klass.get(component).getMetadataList(RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY);
+        routeParameterDefs.forEach((/**
+         * @param {?} parameter
+         * @return {?}
+         */
+        parameter => this.installBinding(parameter)));
+        /** @type {?} */
+        const incomingResolvedRouteParameters = observe.valuesFrom(activatedRoute.paramMap)
+            .last()
+            .map((/**
+         * @param {?} params
+         * @return {?}
+         */
+        params => {
+            /** @type {?} */
+            const result = [];
+            routeParameterDefs.forEach((/**
+             * @param {?} parameterDef
+             * @return {?}
+             */
+            parameterDef => {
+                /** @type {?} */
+                let resolvedValue;
+                if (parameterDef.isArray) {
+                    resolvedValue = params.getAll(parameterDef.name).map((/**
+                     * @param {?} v
+                     * @return {?}
+                     */
+                    v => parameterDef.type.parse(v)));
+                }
+                else {
+                    resolvedValue = parameterDef.type.parse(params.get(parameterDef.name));
+                }
+                result.push({ parameterDef: parameterDef, resolvedValue: resolvedValue });
+            }));
+            return new ResolvedParameters(result);
+        }));
+        incomingResolvedRouteParameters.subscribe((/**
+         * @param {?} resolvedParameters
+         * @return {?}
+         */
+        resolvedParameters => {
+            this._incomingRouteChange.value = true;
+            this.resolvedParameters.value = resolvedParameters;
+            this._incomingRouteChange.value = false;
+        }));
+        when.valueOf(this.resolvedParameters).changes((/**
+         * @param {?} params
+         * @param {?} previous
+         * @return {?}
+         */
+        (params, previous) => {
+            params.redirect(previous, router, activatedRoute);
+        }), { unless: this.incomingRouteChange });
+        this.txo.observe('incomingResolvedRouteParameters', incomingResolvedRouteParameters);
+        this.txo.observe('this.routeIsChanging', this.incomingRouteChange);
+    }
+    /**
+     * @return {?}
+     */
+    get incomingRouteChange() {
+        return this._incomingRouteChange.readonly;
+    }
+    /**
+     * @protected
+     * @template T
+     * @param {?} parameter
+     * @return {?}
+     */
+    installBinding(parameter) {
+        /** @type {?} */
+        const model = this.getModelFor(parameter);
+        // this.txo.observe(parameter.propertyName, model);
+        this.registerDisposable(new Binding(this.resolvedParameters, model, {
+            /**
+             * @param {?} parameters
+             * @return {?}
+             */
+            toRight(parameters) {
+                return parameters.get(parameter);
+            },
+            /**
+             * @param {?} value
+             * @param {?=} currentParameters
+             * @return {?}
+             */
+            toLeft(value, currentParameters) {
+                return currentParameters.replace(parameter, value);
+            }
+        }));
+    }
+    /**
+     * @private
+     * @template T
+     * @param {?} parameter
+     * @return {?}
+     */
+    getModelFor(parameter) {
+        return this.component[parameter.propertyName];
+    }
+}
+if (false) {
+    /** @type {?} */
+    RouteParameterBindings.prototype._incomingRouteChange;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.txo;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.resolvedParameters;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.component;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.activatedRoute;
+}
+(function (RouteParameterBindings) {
+    RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY = Symbol('place:route:parameters');
+})(RouteParameterBindings || (RouteParameterBindings = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-parameter-bindings.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/route/route-parameter-bindings.ts"],"names":[],"mappings":"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","sourcesContent":["import { ActivatedRoute, Router } from '@angular/router';\nimport {\n  Binding,\n  Dsl,\n  GarbageCollector, IMutableHasValue,\n  MutableValueModel,\n  Trace,\n  TransactionObserver\n} from '@coolon/pectin';\nimport { Klass } from '@coolon/typescript-utilities';\nimport { ParameterDefinition } from './parameter-definition.class';\n\ninterface ResolvedParameter<T> {\n  parameterDef: ParameterDefinition<T>;\n  resolvedValue: T;\n}\n\nclass ResolvedParameters {\n  constructor(readonly parameters: ResolvedParameter<any>[]) {\n  }\n\n  get<T>(parameter: ParameterDefinition<T>): T {\n    const resolved = this.parameters.find(p => p.parameterDef === parameter);\n    return resolved ? resolved.resolvedValue : null;\n  }\n\n  replace<T>(parameter: ParameterDefinition<T>, value: T): ResolvedParameters {\n    return new ResolvedParameters(this.parameters.filter(p => p.parameterDef !== parameter).concat({\n      parameterDef: parameter,\n      resolvedValue: value\n    }));\n  }\n\n  @Trace()\n  protected getFormattedRouteId() {\n    const routeIdParam = this.getRouteIdParam();\n    return routeIdParam ? routeIdParam.parameterDef.type.format(routeIdParam.resolvedValue) : null;\n  }\n\n  private getRouteIdParam() {\n    return this.parameters.find(p => p.parameterDef.isRouteId);\n  }\n\n  @Trace()\n  protected getFormattedParameters() {\n    const params = {};\n    const routeIdParam = this.parameters.filter(p => !p.parameterDef.isRouteId).forEach(p => {\n      params[p.parameterDef.name] = p.parameterDef.type.format(p.resolvedValue);\n    });\n    return params;\n  }\n\n  hasRouteId() {\n    return !!this.getRouteIdParam();\n  }\n\n  @Trace()\n  redirect(previous: ResolvedParameters, router: Router, activatedRoute: ActivatedRoute) {\n    const routeId = this.getFormattedRouteId();\n    const relativePath = !!previous.hasRouteId() ? '..' : '.';\n    const path = routeId ? [relativePath, routeId, this.getFormattedParameters()] : [relativePath, this.getFormattedParameters()];\n    router.navigate(path, {\n      relativeTo: activatedRoute\n    });\n  }\n}\n\nexport class RouteParameterBindings extends GarbageCollector {\n\n  public readonly _incomingRouteChange = new MutableValueModel<boolean>(false);\n\n  private txo: TransactionObserver;\n\n  private readonly resolvedParameters = new MutableValueModel<ResolvedParameters>();\n\n  constructor(private readonly component: any, private readonly router: Router, private readonly activatedRoute: ActivatedRoute) {\n    super();\n    const { chain, valueOf, before, when, after, observe } = Dsl.disposeWith(this);\n    this.txo = new TransactionObserver();//.onEvent(e => console.log(e.toString()));\n\n    const routeParameterDefs: ParameterDefinition<any>[] = Klass.get(component).getMetadataList(RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY);\n    routeParameterDefs.forEach(parameter => this.installBinding(parameter));\n\n    const incomingResolvedRouteParameters = observe.valuesFrom(activatedRoute.paramMap)\n      .last()\n      .map(params => {\n        const result: ResolvedParameter<any>[] = [];\n        routeParameterDefs.forEach(parameterDef => {\n          let resolvedValue;\n          if (parameterDef.isArray) {\n            resolvedValue = params.getAll(parameterDef.name).map(v => parameterDef.type.parse(v));\n          } else {\n            resolvedValue = parameterDef.type.parse(params.get(parameterDef.name));\n          }\n          result.push({ parameterDef: parameterDef, resolvedValue: resolvedValue });\n\n        });\n        return new ResolvedParameters(result);\n      });\n\n    incomingResolvedRouteParameters.subscribe(resolvedParameters => {\n      this._incomingRouteChange.value = true;\n      this.resolvedParameters.value = resolvedParameters;\n      this._incomingRouteChange.value = false;\n    });\n\n    when.valueOf(this.resolvedParameters).changes((params, previous) => {\n      params.redirect(previous, router, activatedRoute);\n    }, { unless: this.incomingRouteChange });\n\n    this.txo.observe('incomingResolvedRouteParameters', incomingResolvedRouteParameters);\n    this.txo.observe('this.routeIsChanging', this.incomingRouteChange);\n  }\n\n  get incomingRouteChange() {\n    return this._incomingRouteChange.readonly;\n  }\n\n  protected installBinding<T>(parameter: ParameterDefinition<T>) {\n    const model = this.getModelFor(parameter);\n    // this.txo.observe(parameter.propertyName, model);\n    this.registerDisposable(new Binding(this.resolvedParameters, model, {\n      toRight(parameters: ResolvedParameters): T {\n        return parameters.get(parameter);\n      },\n      toLeft(value: T, currentParameters?: ResolvedParameters): ResolvedParameters {\n        return currentParameters.replace(parameter, value);\n      }\n    }));\n  }\n\n\n  private getModelFor<T>(parameter: ParameterDefinition<T>): IMutableHasValue<T> {\n    return this.component[parameter.propertyName];\n  }\n}\n\nexport namespace RouteParameterBindings {\n  export const ROUTE_PARAMETER_LIST_KEY = Symbol('place:route:parameters');\n}\n"]}

package/esm2015/lib/place/route/route-parameter-sanitiser.js

@@ -0,0 +1,280 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { assert } from '@coolon/pectin';
+import { Memoize } from '@typescript-plus/fast-memoize-decorator/dist/src';
+import * as _ from 'lodash';
+/**
+ * @abstract
+ * @template T, S
+ */
+export 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 !_.isNil(this.initialValue) && this.hasChanged(this.initialValue, this.sanitisedValue);
+    }
+    /**
+     * @return {?}
+     */
+    get sanitisedValue() {
+        return this._sanitisedValue;
+    }
+    /**
+     * @return {?}
+     */
+    sanitize() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.sanitiser) {
+                this.initialValue = this.readFrom(this.snapshot);
+                this._sanitisedValue = yield this.sanitiser.sanitise(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;
+    /**
+     * @abstract
+     * @protected
+     * @param {?} snapshot
+     * @return {?}
+     */
+    Sanitiser.prototype.readFrom = function (snapshot) { };
+    /**
+     * @abstract
+     * @protected
+     * @param {?} initialValue
+     * @param {?} sanitisedValue
+     * @return {?}
+     */
+    Sanitiser.prototype.hasChanged = function (initialValue, sanitisedValue) { };
+    /**
+     * @abstract
+     * @param {?} dest
+     * @return {?}
+     */
+    Sanitiser.prototype.injectRouteParam = function (dest) { };
+}
+export 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 tslib_1.__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));
+        });
+    }
+    /**
+     * @param {?} router
+     * @return {?}
+     */
+    redirect(router) {
+        assert.isTruthy(this.parameterSanitisers.length !== 0);
+        if (this.routeIdSanitiser.valueChanged) {
+            return router.navigate(['..', this.routeIdSanitiser.sanitisedValue]);
+        }
+        else {
+            /** @type {?} */
+            const routeParams = {};
+            this.parameterSanitisers.forEach((/**
+             * @param {?} s
+             * @return {?}
+             */
+            s => s.injectRouteParam(routeParams)));
+            return router.navigate(['.', routeParams]);
+        }
+    }
+    /**
+     * @private
+     * @template T, S
+     * @param {?} def
+     * @return {?}
+     */
+    getSanitiser(def) {
+        return def.sanitiser ? this.injector.get(def.sanitiser, new def.sanitiser()) : null;
+    }
+}
+tslib_1.__decorate([
+    Memoize(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__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 = this.parameterDef.isRouteId ?
+                snapshot.paramMap.get(this.parameterDef.name) :
+                snapshot.queryParamMap.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.queryParamMap.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 = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-parameter-sanitiser.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/route/route-parameter-sanitiser.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector } from '@angular/core';\nimport { ActivatedRouteSnapshot, Router } from '@angular/router';\nimport { assert } from '@coolon/pectin';\nimport { Memoize } from '@typescript-plus/fast-memoize-decorator/dist/src';\nimport { ParameterDefinition } from './parameter-definition.class';\nimport { ParameterSanitiser } from './parameter-sanitiser';\nimport * as _ from 'lodash';\n\nexport abstract class Sanitiser<T, S> {\n\n  private initialValue: S;\n  private _sanitisedValue: S;\n\n  constructor(readonly parameterDef: ParameterDefinition<T>, readonly snapshot:ActivatedRouteSnapshot, readonly sanitiser: ParameterSanitiser<S>) {\n  }\n\n  isRouteId(): boolean {\n    return this.parameterDef.isRouteId;\n  }\n\n  get valueChanged():boolean {\n    return !_.isNil(this.initialValue) && this.hasChanged(this.initialValue, this.sanitisedValue);\n  }\n\n  get sanitisedValue():S {\n    return this._sanitisedValue;\n  }\n\n  protected abstract readFrom(snapshot: ActivatedRouteSnapshot): S;\n  protected abstract hasChanged(initialValue:S, sanitisedValue:S): boolean;\n\n  abstract injectRouteParam(dest: {});\n\n  async sanitize(): Promise<boolean> {\n    if (this.sanitiser) {\n      this.initialValue = this.readFrom(this.snapshot);\n      this._sanitisedValue = await this.sanitiser.sanitise(this.initialValue);\n      if (this.initialValue !== this._sanitisedValue) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n\n\nexport class RouteParameterSanitiser {\n\n  private readonly routeIdSanitiser: Sanitiser<any, any>;\n  private readonly parameterSanitisers: Sanitiser<any, any>[] = [];\n\n  constructor(readonly parameterDefs: ParameterDefinition<any>[], readonly snapshot: ActivatedRouteSnapshot, readonly injector: Injector) {\n    const sanitisers = parameterDefs.map(def => {\n      return def.isArray ?\n        new Sanitiser.Array(def, snapshot, this.getSanitiser(def)) :\n        new Sanitiser.Value(def, snapshot, this.getSanitiser(def));\n    });\n    this.routeIdSanitiser = sanitisers.find(p => p.isRouteId());\n    this.parameterSanitisers = sanitisers.filter(p => !p.isRouteId());\n  }\n\n  async sanitise(): Promise<boolean> {\n    if (this.routeIdSanitiser) {\n      await this.routeIdSanitiser.sanitize();\n      if (this.routeIdSanitiser.valueChanged) {\n        // if the route id isn't ok we redirect immediately as the query params may need to be sanitised in the\n        // context of the route id.\n        return false;\n      }\n    }\n    for (const sanitiser of this.parameterSanitisers) {\n        await sanitiser.sanitize();\n    }\n    return !this.parameterSanitisers.find(s => s.valueChanged);\n  }\n\n  redirect(router: Router) {\n    assert.isTruthy(this.parameterSanitisers.length !== 0);\n    if (this.routeIdSanitiser.valueChanged) {\n      return router.navigate(['..', this.routeIdSanitiser.sanitisedValue]);\n    } else {\n      const routeParams = {};\n      this.parameterSanitisers.forEach(s => s.injectRouteParam(routeParams));\n      return router.navigate(['.', routeParams]);\n    }\n  }\n\n  @Memoize()\n  private getSanitiser<T, S>(def: ParameterDefinition<T, S>): ParameterSanitiser<S> {\n    return def.sanitiser ? this.injector.get<ParameterSanitiser<S>>(def.sanitiser, new def.sanitiser()) : null;\n  }\n}\n\nexport namespace Sanitiser {\n\n  export class Value<T> extends Sanitiser<T, T> {\n\n    readFrom(snapshot: ActivatedRouteSnapshot): T {\n      const rawValue = this.parameterDef.isRouteId ?\n        snapshot.paramMap.get(this.parameterDef.name) :\n        snapshot.queryParamMap.get(this.parameterDef.name);\n\n      return this.parameterDef.type.parse(rawValue);\n    }\n\n    protected hasChanged(initialValue: T, sanitisedValue: T): boolean {\n      return initialValue !== sanitisedValue;\n    }\n\n    injectRouteParam(dest: {}) {\n      dest[this.parameterDef.name] = this.parameterDef.type.format(this.sanitisedValue);\n    }\n\n  }\n\n  export class Array<T> extends Sanitiser<T, T[]> {\n\n    readFrom(snapshot: ActivatedRouteSnapshot): T[] {\n      const rawValues = snapshot.queryParamMap.getAll(this.parameterDef.name);\n      return rawValues.map(value => this.parameterDef.type.parse(value));\n    }\n\n    protected hasChanged(initialValue: T[], sanitisedValue: T[]): boolean {\n      return initialValue !== sanitisedValue;\n    }\n\n\n    injectRouteParam(dest: {}) {\n      dest[this.parameterDef.name] = this.sanitisedValue.map(v => this.parameterDef.type.format(v));\n    }\n\n\n  }\n\n}\n"]}

package/esm2015/public_api.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+export { AngularUiPowerupsModule } from './lib/angular-ui-powerups.module';
+export { slideDownAndUpAnimation } from './lib/animations';
+export { DisposableComponent, ResizeAwareComponent, AbstractInputComponent, NumberInputComponent, PasswordInputComponent, SelectInputComponent, StringInputComponent, Bounds, Dimension, Point } from './lib/components';
+export { CommandDirective, FocusBindingDirective } from './lib/directives';
+export { AbstractActivity, ACTIVITY_DATA, INTERACTION_CONTEXT, InteractionContext, InteractionModule, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, ConfirmationDialogComponent, DialogInteractionService } from './lib/interaction';
+export { AbstractPlaceComponent, Place, PlaceModule, PlaceService, BusyOverlayComponent, EmptyStateComponent, PlaceOutletComponent, LEFT_RIGHT_PLACE_ANIMATION, TabbedPlaceNavigationComponent, LeavePlaceGuard, PlaceRouteGuard, RouteId, QueryParameter, RouteParameter, QueryParameterList, RouteParameterList, ParameterType, RouteParameterBindings, Sanitiser, RouteParameterSanitiser } from './lib/place';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0Bjb29sb24vYW5ndWxhci11aS1wb3dlcnVwcy8iLCJzb3VyY2VzIjpbInB1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLHdDQUFjLGtDQUFrQyxDQUFDO0FBQ2pELHdDQUFjLGtCQUFrQixDQUFDO0FBQ2pDLHNNQUFjLGtCQUFrQixDQUFDO0FBQ2pDLHdEQUFjLGtCQUFrQixDQUFDO0FBQ2pDLDhPQUFjLG1CQUFtQixDQUFDO0FBQ2xDLG9ZQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2FuZ3VsYXItdWktcG93ZXJ1cHMubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2FuaW1hdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2ludGVyYWN0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BsYWNlJztcbiJdfQ==

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

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Generated bundle index. Do not edit.
+ */
+export { AngularUiPowerupsModule, slideDownAndUpAnimation, DisposableComponent, ResizeAwareComponent, AbstractInputComponent, NumberInputComponent, PasswordInputComponent, SelectInputComponent, StringInputComponent, Bounds, Dimension, Point, CommandDirective, FocusBindingDirective, AbstractActivity, ACTIVITY_DATA, INTERACTION_CONTEXT, InteractionContext, InteractionModule, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, ConfirmationDialogComponent, DialogInteractionService, AbstractPlaceComponent, Place, PlaceModule, PlaceService, BusyOverlayComponent, EmptyStateComponent, PlaceOutletComponent, LEFT_RIGHT_PLACE_ANIMATION, TabbedPlaceNavigationComponent, LeavePlaceGuard, PlaceRouteGuard, RouteId, QueryParameter, RouteParameter, QueryParameterList, RouteParameterList, ParameterType, RouteParameterBindings, Sanitiser, RouteParameterSanitiser } from './index';
+export { DisposableComponent as ɵc } from './lib/components/disposable-component';
+export { AbstractInputComponent as ɵe } from './lib/components/forms/abstract-input.component';
+export { NumberInputComponent as ɵd } from './lib/components/forms/number-input/number-input.component';
+export { PasswordInputComponent as ɵg } from './lib/components/forms/password-input/password-input.component';
+export { SelectInputComponent as ɵh } from './lib/components/forms/select-input/select-input.component';
+export { StringInputComponent as ɵf } from './lib/components/forms/string-input/string-input.component';
+export { CommandDirective as ɵa } from './lib/directives/command.directive';
+export { FocusBindingDirective as ɵb } from './lib/directives/focus-binding.directive';
+export { AbstractActivity as ɵs } from './lib/interaction/abstract-activity';
+export { ACTIVITY_DATA as ɵt } from './lib/interaction/activity';
+export { ActivityContainerComponent as ɵq } from './lib/interaction/components/activity-container/activity-container.component';
+export { ActivityOutletComponent as ɵx } from './lib/interaction/components/activity-outlet/activity-outlet.component';
+export { AlertDialogComponent as ɵv } from './lib/interaction/components/alert-dialog/alert-dialog.component';
+export { ConfirmationDialogComponent as ɵr } from './lib/interaction/components/confirmation-dialog/confirmation-dialog.component';
+export { InteractionContext as ɵz } from './lib/interaction/interaction-context';
+export { InteractionModule as ɵp } from './lib/interaction/interaction.module';
+export { DialogInteractionService as ɵy } from './lib/interaction/services/dialog-interaction.service';
+export { BusyOverlayComponent as ɵk } from './lib/place/components/busy-overlay/busy-overlay.component';
+export { EmptyStateComponent as ɵj } from './lib/place/components/empty-state/empty-state.component';
+export { PlaceOutletComponent as ɵl } from './lib/place/components/place-outlet/place-outlet.component';
+export { LEFT_RIGHT_PLACE_ANIMATION as ɵm } from './lib/place/components/place-outlet/route-animations';
+export { TabbedPlaceNavigationComponent as ɵo } from './lib/place/components/tabbed-place-navigation/tabbed-place-navigation.component';
+export { PlaceModule as ɵi } from './lib/place/place.module';
+export { PlaceService as ɵn } from './lib/place/place.service';
+//# sourceMappingURL=data:application/json;base64,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