@coolon/angular-ui-powerups 12.4.9 → 13.0.1

package/esm2020/lib/place/route/parameter-definition.mjs

@@ -0,0 +1,123 @@
+import { MutableListModel, MutableValueModel } from '@coolon/pectin';
+import { lang, Opts } from '@coolon/typescript-utilities';
+import { isEqual, isFunction, isNil, isObject } from 'lodash';
+const PARAMETER_DEFINITION_KEY = Symbol('parameterDefinition');
+export class ParameterDefinition {
+    constructor(propertyName, options, urlFormat) {
+        this.propertyName = propertyName;
+        this.urlFormat = urlFormat;
+        this.options = Opts.get(options);
+        this.remember = this.options.getOptional('remember', false);
+        this.defaultValue = this.options.getOptional('defaultValue', null);
+    }
+    get name() {
+        return this.options.getOptional('as', this.propertyName);
+    }
+    // @Trace()
+    get isRouteParameter() {
+        return !!this.urlFormat;
+    }
+    createBackingModel() {
+        const model = this.backingModelFactory();
+        model[PARAMETER_DEFINITION_KEY] = this;
+        return model;
+    }
+    getOptionValue(key) {
+        return this.options.getOptional(key, null);
+    }
+    // @Trace()
+    async sanitise(value, visit, placeHistory, injector, isPopState) {
+        // console.log(`sanitise(${this.propertyName})`)
+        value = await this.sanitiseMissing(visit, placeHistory, value);
+        value = await this.runCustomSanitiser(value, visit, placeHistory, injector, isPopState);
+        return value;
+    }
+    async runCustomSanitiser(value, visit, placeHistory, injector, isPopState) {
+        const customSanitiser = this.prepareCustomSanitiser(injector);
+        return customSanitiser ? customSanitiser.sanitise(value, visit, injector) : value;
+    }
+    sanitiseMissing(visit, placeHistory, value) {
+        if (this.isMissingFrom(visit)) {
+            const returningFromSomewhereElse = !placeHistory.lastVisitIncluded(visit.placeDefinition);
+            if (returningFromSomewhereElse) {
+                const lastKnownVisit = placeHistory.getMostRecentVisitFor(visit.placeDefinition);
+                if (this.remember && lastKnownVisit) {
+                    value = lastKnownVisit.getParameterValue(this);
+                }
+                value = this.isEmptyValue(value) ? this.defaultValue : value;
+            }
+        }
+        return value;
+    }
+    prepareCustomSanitiser(injector) {
+        const customSanitiser = this.options.getOptional('sanitiser', null);
+        if (isFunction(customSanitiser)) {
+            return injector.get(customSanitiser);
+        }
+        if (isObject(customSanitiser)) {
+            return isFunction(customSanitiser['sanitise']) ?
+                customSanitiser :
+                lang.illegalState(`expected @VisitParameter({sanitiser: ...}) for ${this.propertyName} to be a constructor or instance of ParameterSanitiser, got: ` + customSanitiser);
+        }
+        return undefined;
+    }
+    isMissingFrom(visit) {
+        return !visit.hasParameter(this);
+    }
+}
+(function (ParameterDefinition) {
+    class RouteId extends ParameterDefinition {
+        constructor() {
+            super(...arguments);
+            this.isRouteId = true;
+            this.isArray = false;
+            this.backingModelFactory = () => new MutableValueModel();
+        }
+        isEmptyValue(value) {
+            return isNil(value);
+        }
+        hasChanged(a, b) {
+            return a !== b;
+        }
+    }
+    ParameterDefinition.RouteId = RouteId;
+    class ValueParameter extends ParameterDefinition {
+        constructor() {
+            super(...arguments);
+            this.isRouteId = false;
+            this.isArray = false;
+            this.backingModelFactory = () => new MutableValueModel();
+        }
+        isEmptyValue(value) {
+            return isNil(value);
+        }
+        hasChanged(a, b) {
+            return a !== b;
+        }
+    }
+    ParameterDefinition.ValueParameter = ValueParameter;
+    class ArrayParameter extends ParameterDefinition {
+        constructor(parameterName, options, urlFormat) {
+            super(parameterName, options, urlFormat);
+            this.isRouteId = false;
+            this.isArray = true;
+            this.backingModelFactory = () => new MutableListModel();
+        }
+        isEmptyValue(value) {
+            return isNil(value) || value.length < 1;
+        }
+        hasChanged(a, b) {
+            return !isEqual(a, b);
+        }
+    }
+    ParameterDefinition.ArrayParameter = ArrayParameter;
+    function get(model) {
+        const parameterDefinition = model[PARAMETER_DEFINITION_KEY];
+        if (!parameterDefinition) {
+            lang.illegalArgument('model hasn\'t been annotated with @VisitParameter, @VisitParameterList or @RouteId');
+        }
+        return parameterDefinition;
+    }
+    ParameterDefinition.get = get;
+})(ParameterDefinition || (ParameterDefinition = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parameter-definition.js","sourceRoot":"","sources":["../../../../../../../libs/angular-ui-powerups/src/lib/place/route/parameter-definition.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector } from '@angular/core';\nimport { Constructable, HasValue, ListModel, MutableListModel, MutableValueModel, ValueModel } from '@coolon/pectin';\nimport { lang, Opts } from '@coolon/typescript-utilities';\n\nimport { isEqual, isFunction, isNil, isObject } from 'lodash';\nimport { PlaceHistory } from '../place-history';\nimport { Visit } from '../visit';\nimport { Formatter } from './formatter';\nimport { ParameterSanitiser } from './parameter-sanitiser';\n\nconst PARAMETER_DEFINITION_KEY = Symbol('parameterDefinition');\n\n\nexport abstract class ParameterDefinition<T, E = T> {\n\n  abstract readonly isRouteId: boolean;\n  abstract readonly isArray: boolean;\n\n  readonly remember: boolean;\n  readonly defaultValue: T;\n  private options: Opts<ParameterDefinition.Options<T>>;\n  protected abstract backingModelFactory: () => HasValue<T>;\n\n  constructor(readonly propertyName: string, options: ParameterDefinition.Options<T>, readonly urlFormat?: Formatter<E>) {\n    this.options = Opts.get(options);\n    this.remember = this.options.getOptional('remember', false);\n    this.defaultValue = this.options.getOptional('defaultValue', null);\n  }\n\n  get name() {\n    return this.options.getOptional('as', this.propertyName);\n  }\n\n  // @Trace()\n  get isRouteParameter(): boolean {\n    return !!this.urlFormat;\n  }\n\n  abstract isEmptyValue(value: T): boolean;\n\n  abstract hasChanged(a: any, b: any): boolean;\n\n  createBackingModel(): HasValue<T> {\n    const model = this.backingModelFactory();\n    model[PARAMETER_DEFINITION_KEY] = this;\n    return model;\n  }\n\n  protected getOptionValue<K extends keyof ParameterDefinition.Options<T>>(key: K): ParameterDefinition.Options<T>[K] {\n    return this.options.getOptional(key, null);\n  }\n\n  // @Trace()\n  async sanitise(value: T, visit: Visit, placeHistory: PlaceHistory, injector: Injector, isPopState: boolean): Promise<T> {\n    // console.log(`sanitise(${this.propertyName})`)\n    value = await this.sanitiseMissing(visit, placeHistory, value);\n    value = await this.runCustomSanitiser(value, visit, placeHistory, injector, isPopState);\n    return value;\n  }\n\n  private async runCustomSanitiser(value: T, visit: Visit, placeHistory: PlaceHistory, injector: Injector, isPopState: boolean): Promise<T> {\n    const customSanitiser = this.prepareCustomSanitiser(injector);\n    return customSanitiser ? customSanitiser.sanitise(value, visit, injector) : value;\n  }\n\n  private sanitiseMissing(visit: Visit, placeHistory: PlaceHistory, value: T) {\n    if (this.isMissingFrom(visit)) {\n      const returningFromSomewhereElse = !placeHistory.lastVisitIncluded(visit.placeDefinition);\n      if (returningFromSomewhereElse) {\n        const lastKnownVisit = placeHistory.getMostRecentVisitFor(visit.placeDefinition);\n        if (this.remember && lastKnownVisit) {\n          value = lastKnownVisit.getParameterValue(this);\n        }\n        value = this.isEmptyValue(value) ? this.defaultValue : value;\n      }\n    }\n    return value;\n  }\n\n  private prepareCustomSanitiser(injector: Injector): ParameterSanitiser<any> {\n    const customSanitiser = this.options.getOptional('sanitiser', null);\n    if (isFunction(customSanitiser)) {\n      return injector.get(customSanitiser);\n    }\n    if (isObject(customSanitiser)) {\n      return isFunction(customSanitiser['sanitise']) ?\n        customSanitiser as ParameterSanitiser<any> :\n        lang.illegalState(`expected @VisitParameter({sanitiser: ...}) for ${this.propertyName} to be a constructor or instance of ParameterSanitiser, got: ` + customSanitiser);\n    }\n    return undefined;\n  }\n\n  private isMissingFrom(visit: Visit) {\n    return !visit.hasParameter(this);\n  }\n}\n\nexport namespace ParameterDefinition {\n\n  export interface Options<T> {\n    as?: string;\n    optional?: boolean;\n    remember?: boolean;\n    defaultValue?: T;\n    sanitiser?: Constructable<ParameterSanitiser<T>> | ParameterSanitiser<T>;\n  }\n\n  export class RouteId<T> extends ParameterDefinition<T> {\n    readonly isRouteId = true;\n    readonly isArray = false;\n    protected backingModelFactory = () => new MutableValueModel<T>();\n\n    isEmptyValue(value: T): boolean {\n      return isNil(value);\n    }\n\n    hasChanged(a: any, b: any): boolean {\n      return a !== b;\n    }\n\n  }\n\n  export class ValueParameter<T> extends ParameterDefinition<T> {\n    readonly isRouteId = false;\n    readonly isArray = false;\n    protected backingModelFactory = () => new MutableValueModel<T>();\n\n    isEmptyValue(value: T): boolean {\n      return isNil(value);\n    }\n\n    hasChanged(a: any, b: any): boolean {\n      return a !== b;\n    }\n  }\n\n  export class ArrayParameter<T> extends ParameterDefinition<T[], T> {\n    readonly isRouteId = false;\n    readonly isArray = true;\n    protected backingModelFactory = () => new MutableListModel<T>();\n\n    constructor(parameterName: string, options: Options<T[]>, urlFormat: Formatter<T>) {\n      super(parameterName, options, urlFormat);\n    }\n\n    isEmptyValue(value: T[]): boolean {\n      return isNil(value) || value.length < 1;\n    }\n\n    hasChanged(a: T[], b: T[]): boolean {\n      return !isEqual(a, b);\n    }\n\n  }\n\n  export function get<T>(model: ValueModel<T>): ParameterDefinition.ValueParameter<T>\n  export function get<T>(model: ListModel<T>): ParameterDefinition.ArrayParameter<T>\n  export function get<T>(model: ValueModel<T> | ListModel<T>): ParameterDefinition.ValueParameter<T> | ParameterDefinition.ArrayParameter<T> {\n    const parameterDefinition = model[PARAMETER_DEFINITION_KEY];\n    if (!parameterDefinition) {\n      lang.illegalArgument('model hasn\\'t been annotated with @VisitParameter, @VisitParameterList or @RouteId');\n    }\n    return parameterDefinition;\n  }\n\n\n}\n"]}

package/esm2020/lib/place/route/visit-sanitiser.mjs

@@ -0,0 +1,41 @@
+export class VisitSanitiser {
+    constructor(navigationSession, activatedRoute, router, placeHistory, injector) {
+        this.navigationSession = navigationSession;
+        this.activatedRoute = activatedRoute;
+        this.router = router;
+        this.placeHistory = placeHistory;
+        this.injector = injector;
+    }
+    // @Trace()
+    async sanitise(visit) {
+        const placeDef = visit.placeDefinition;
+        if (placeDef.hasRouteId()) {
+            const routeIdDef = placeDef.getRouteIdParameterDef();
+            const routeId = visit.getRouteId();
+            const sanitisedValue = await routeIdDef.sanitise(routeId, visit, this.placeHistory, this.injector, this.navigationSession.isPopState);
+            // console.log({routeId, sanitisedValue});
+            // ###------- EARLY EXIT --------###
+            if (routeIdDef.hasChanged(routeId, sanitisedValue)) {
+                // if the route id has changed we redirect immediately as other
+                // parameter sanitisers might use it.
+                return visit.replace(routeIdDef, sanitisedValue);
+            }
+        }
+        // if we didn't replace the routeId we continue the url present parameters.
+        const parameterDefs = placeDef.getVisitParameterDefs({
+            includeRouteParameters: true,
+            includeNonRouteParameters: true
+        });
+        let sanitisedVisit = visit;
+        for (let i = 0; i < parameterDefs.length; i++) {
+            const def = parameterDefs[i];
+            const value = visit.getParameterValue(def);
+            const sanitisedValue = await def.sanitise(value, sanitisedVisit, this.placeHistory, this.injector, this.navigationSession.isPopState);
+            if (def.hasChanged(value, sanitisedValue)) {
+                sanitisedVisit = sanitisedVisit.replace(def, sanitisedValue);
+            }
+        }
+        return sanitisedVisit.hasChangedFrom(visit) ? sanitisedVisit : visit;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/place/url-service.js → esm2020/lib/place/url-service.mjs}

@@ -54,12 +54,12 @@ export class UrlService {
         this.angularLocation.back();
     }
 }
-UrlService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: UrlService, deps: [{ token: i1.Router }, { token: i2.Location }, { token: i1.UrlSerializer }], target: i0.ɵɵFactoryTarget.Injectable });
-UrlService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: UrlService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: UrlService, decorators: [{
+UrlService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: UrlService, deps: [{ token: i1.Router }, { token: i2.Location }, { token: i1.UrlSerializer }], target: i0.ɵɵFactoryTarget.Injectable });
+UrlService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: UrlService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: UrlService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.Location }, { type: i1.UrlSerializer }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXJsLXNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdWktcG93ZXJ1cHMvc3JjL2xpYi9wbGFjZS91cmwtc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDM0MsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsTUFBTSxFQUFFLGFBQWEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQzs7OztBQU03QyxNQUFNLE9BQU8sVUFBVTtJQUNyQixZQUE2QixhQUFxQixFQUFXLGVBQXlCLEVBQVcsYUFBNEI7UUFBaEcsa0JBQWEsR0FBYixhQUFhLENBQVE7UUFBVyxvQkFBZSxHQUFmLGVBQWUsQ0FBVTtRQUFXLGtCQUFhLEdBQWIsYUFBYSxDQUFlO0lBQzdILENBQUM7SUFFRCxRQUFRLENBQUMsR0FBVztRQUNsQixPQUFPLElBQUksV0FBVyxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDbEQsQ0FBQztJQUVELGlCQUFpQixDQUFDLEdBQUcsTUFBZTtRQUNsQyxNQUFNLElBQUksR0FBRyxFQUFFLENBQUM7UUFDaEIsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRTtZQUNqQixJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsZUFBZSxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDbkYsQ0FBQyxDQUFDLENBQUM7UUFDSCxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ3RDLENBQUM7SUFFRCxtQkFBbUI7UUFDakIsT0FBTyxJQUFJLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO0lBQzdGLENBQUM7SUFFRCxxQkFBcUI7UUFDbkIsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3JDLENBQUM7SUFFRDs7O09BR0c7SUFDSCw2QkFBNkI7UUFDM0IsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxxQkFBcUIsRUFBRSxDQUFDLENBQUM7SUFDckQsQ0FBQztJQUVEOzs7T0FHRztJQUNILHdCQUF3QjtRQUN0QixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLG1CQUFtQixFQUFFLENBQUMsQ0FBQztJQUNuRCxDQUFDO0lBRUQsOEJBQThCLENBQUMsR0FBVztRQUN4QyxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztJQUNoRCxDQUFDO0lBRUQscUJBQXFCLENBQUMsR0FBVztRQUMvQixPQUFPLElBQUksQ0FBQyw4QkFBOEIsQ0FBQyxHQUFHLENBQUMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDO0lBQzdELENBQUM7SUFFRCxvQkFBb0IsQ0FBQyxHQUFXLEVBQUUsT0FBb0M7UUFDcEUsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2pHLENBQUM7SUFFRCxJQUFJO1FBQ0YsSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUM5QixDQUFDOzt1R0F0RFUsVUFBVTsyR0FBVixVQUFVLGNBRlQsTUFBTTsyRkFFUCxVQUFVO2tCQUh0QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExvY2F0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJvdXRlciwgVXJsU2VyaWFsaXplciB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5pbXBvcnQgeyBVcmxTbmFwc2hvdCB9IGZyb20gJy4vdXJsLXNuYXBzaG90JztcbmltcG9ydCB7IFZpc2l0IH0gZnJvbSAnLi92aXNpdCc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIFVybFNlcnZpY2Uge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IGFuZ3VsYXJSb3V0ZXI6IFJvdXRlciwgcmVhZG9ubHkgYW5ndWxhckxvY2F0aW9uOiBMb2NhdGlvbiwgcmVhZG9ubHkgdXJsU2VyaWFsaXplcjogVXJsU2VyaWFsaXplcikge1xuICB9XG5cbiAgcGFyc2VVcmwodXJsOiBzdHJpbmcpOiBVcmxTbmFwc2hvdCB7XG4gICAgcmV0dXJuIG5ldyBVcmxTbmFwc2hvdCh0aGlzLnVybFNlcmlhbGl6ZXIsIHVybCk7XG4gIH1cblxuICBjcmVhdGVVcmxTbmFwc2hvdCguLi52aXNpdHM6IFZpc2l0W10pOiBVcmxTbmFwc2hvdCB7XG4gICAgY29uc3QgYml0cyA9IFtdO1xuICAgIHZpc2l0cy5mb3JFYWNoKHYgPT4ge1xuICAgICAgYml0cy5wdXNoKHRoaXMucGFyc2VVcmwoYCR7di5wbGFjZURlZmluaXRpb24ucGF0aH1gKS51cGRhdGVWaXNpdFNlZ21lbnRzKHYpLnVybCk7XG4gICAgfSk7XG4gICAgcmV0dXJuIHRoaXMucGFyc2VVcmwoYml0cy5qb2luKCcnKSk7XG4gIH1cblxuICBnZXRDdXJyZW50Um91dGVyVXJsKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMuYW5ndWxhclJvdXRlci5yb3V0ZXJTdGF0ZSA/IHRoaXMuYW5ndWxhclJvdXRlci5yb3V0ZXJTdGF0ZS5zbmFwc2hvdC51cmwgOiBudWxsO1xuICB9XG5cbiAgZ2V0Q3VycmVudExvY2F0aW9uVXJsKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMuYW5ndWxhckxvY2F0aW9uLnBhdGgoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZXR1cm4gdGhlIGEgVXJsU25hcHNob3QgdXNpbmcgdGhlIGJyb3dzZXJzIGN1cnJlbnQgbG9jYXRpb24uICBOb3RlIHRoaXMgbWF5IG5vdCBiZSB0aGUgc2FtZVxuICAgKiBhcyB0aGUgcm91dGVycyBjdXJyZW50IHVybC5cbiAgICovXG4gIGdldEN1cnJlbnRMb2NhdGlvblVybFNuYXBzaG90KCk6IFVybFNuYXBzaG90IHtcbiAgICByZXR1cm4gdGhpcy5wYXJzZVVybCh0aGlzLmdldEN1cnJlbnRMb2NhdGlvblVybCgpKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZXR1cm4gdGhlIGEgVXJsU25hcHNob3QgdXNpbmcgdGhlIHJvdXRlcnMgY3VycmVudCBzdGF0ZS4gIFRoaXMgbWF5IG5vdCBiZSB0aGUgc2FtZSBhc1xuICAgKiB0aGUgYnJvd3NlcnMgYWN0dWFsIHVybC5cbiAgICovXG4gIGdldEN1cnJlbnRSb3V0ZXJTbmFwc2hvdCgpOiBVcmxTbmFwc2hvdCB7XG4gICAgcmV0dXJuIHRoaXMucGFyc2VVcmwodGhpcy5nZXRDdXJyZW50Um91dGVyVXJsKCkpO1xuICB9XG5cbiAgZ2V0QWN0aXZlSW50ZXJhY3Rpb25JZHNGcm9tVXJsKHVybDogc3RyaW5nKTogc3RyaW5nW10ge1xuICAgIHJldHVybiB0aGlzLnBhcnNlVXJsKHVybCkuZ2V0SW50ZXJhY3Rpb25JZHMoKTtcbiAgfVxuXG4gIGhhc0FjdGl2ZUludGVyYWN0aW9ucyh1cmw6IHN0cmluZykge1xuICAgIHJldHVybiB0aGlzLmdldEFjdGl2ZUludGVyYWN0aW9uSWRzRnJvbVVybCh1cmwpLmxlbmd0aCA+IDA7XG4gIH1cblxuICByZXNldEJyb3dzZXJMb2NhdGlvbih1cmw6IHN0cmluZywgb3B0aW9uczogeyByZXBsYWNlQ3VycmVudDogYm9vbGVhbiB9KSB7XG4gICAgb3B0aW9ucy5yZXBsYWNlQ3VycmVudCA/IHRoaXMuYW5ndWxhckxvY2F0aW9uLnJlcGxhY2VTdGF0ZSh1cmwpIDogdGhpcy5hbmd1bGFyTG9jYXRpb24uZ28odXJsKTtcbiAgfVxuXG4gIGJhY2soKSB7XG4gICAgdGhpcy5hbmd1bGFyTG9jYXRpb24uYmFjaygpO1xuICB9XG5cblxufVxuIl19

package/esm2020/lib/place/visit.mjs

@@ -0,0 +1,69 @@
+import { isEqual, isNil, isString } from 'lodash';
+export class Visit {
+    constructor(placeDefinition, visitParameters = {}) {
+        this.placeDefinition = placeDefinition;
+        this.visitParameters = visitParameters;
+    }
+    // @Trace()
+    getRouteId() {
+        return this.placeDefinition.getRouteIdFrom(this);
+    }
+    // @Trace()
+    hasRouteId() {
+        return !isNil(this.getRouteId());
+    }
+    /**
+     * Returns the value of the place parameter with the specified name.  The parameter
+     * name is taken from the `as` option, e.g. {as: 'aCustomName'} otherwise it is the
+     * same as the the ValueModel property name.
+     * @param parameter the visit parameter definition
+     */
+    getParameterValue(parameter) {
+        return isString(parameter) ? this.visitParameters[parameter] : this.visitParameters[parameter.name];
+    }
+    // @Trace()
+    hasParameter(parameterDef) {
+        return Object.keys(this.visitParameters).includes(parameterDef.name);
+    }
+    replace(parameter, value) {
+        return new Visit(this.placeDefinition, { ...this.visitParameters, [parameter.name]: value });
+    }
+    mergeRouteParameters(routeParams) {
+        // todo: whitelist parameters.
+        const routeParameterKeys = Object.keys(routeParams);
+        const params = {};
+        this.placeDefinition.getVisitParameterDefs().forEach(def => {
+            if (def.isRouteId || def.isRouteParameter) {
+                if (routeParameterKeys.includes(def.name)) {
+                    params[def.name] = routeParams[def.name];
+                }
+            }
+            else {
+                // copy non route params as is, but only if they already exist otherwise we'll inject nil values and break the
+                // defaults and remember sanitisation process.
+                const value = this.getParameterValue(def);
+                if (this.hasParameter(def)) {
+                    params[def.name] = value;
+                }
+            }
+        });
+        return new Visit(this.placeDefinition, params);
+    }
+    // @Trace()
+    hasRoutingChangedFrom(other) {
+        const samePlace = other.placeDefinition === this.placeDefinition;
+        const currentParams = this.placeDefinition.getFormattedRouteParameters(this, true);
+        const otherParams = this.placeDefinition.getFormattedRouteParameters(other, true);
+        // console.log({currentParams, otherParams});
+        const sameRouteParameters = isEqual(currentParams, otherParams);
+        return !samePlace || !sameRouteParameters;
+    }
+    hasChangedFrom(other) {
+        const sameNonRouteParameters = isEqual(this.placeDefinition.getNonRouteParameters(this), this.placeDefinition.getNonRouteParameters(other));
+        return !sameNonRouteParameters || this.hasRoutingChangedFrom(other);
+    }
+    toDebugString() {
+        return Object.keys(this.visitParameters).map(k => `${k}=${this.visitParameters[k]}`).join(',');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/services/markdown/markdown.service.js → esm2020/lib/services/markdown/markdown.service.mjs}

@@ -15,13 +15,13 @@ export class MarkdownService {
     }
     usePillExtension(renderer) {
         marked.use({
-            extensions: [markdownPillExtension(renderer !== null && renderer !== void 0 ? renderer : (text => `<span class='aup-pill'>${text}<span>`))]
+            extensions: [markdownPillExtension(renderer ?? (text => `<span class='aup-pill'>${text}<span>`))]
         });
     }
 }
-MarkdownService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: MarkdownService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-MarkdownService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: MarkdownService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: MarkdownService, decorators: [{
+MarkdownService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: MarkdownService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MarkdownService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: MarkdownService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: MarkdownService, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFya2Rvd24uc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci11aS1wb3dlcnVwcy9zcmMvbGliL3NlcnZpY2VzL21hcmtkb3duL21hcmtkb3duLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBQ2hDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFHdEQsTUFBTSxPQUFPLGVBQWU7SUFFMUI7SUFDQSxDQUFDO0lBRUQsTUFBTSxDQUFDLE9BQWU7UUFDcEIsT0FBTyxNQUFNLENBQUMsS0FBSyxDQUFDLE9BQU8sRUFBRTtZQUMzQixVQUFVLEVBQUUsSUFBSTtTQUNqQixDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQsWUFBWSxDQUFDLE9BQWU7UUFDMUIsT0FBTyxNQUFNLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFFRCxnQkFBZ0IsQ0FBQyxRQUFzQztRQUNyRCxNQUFNLENBQUMsR0FBRyxDQUFDO1lBQ1QsVUFBVSxFQUFFLENBQUMscUJBQXFCLENBQUMsUUFBUSxhQUFSLFFBQVEsY0FBUixRQUFRLEdBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLDBCQUEwQixJQUFJLFFBQVEsQ0FBQyxDQUFDLENBQUM7U0FDbEcsQ0FBQyxDQUFDO0lBQ0wsQ0FBQzs7NkdBbkJVLGVBQWU7aUhBQWYsZUFBZTs0RkFBZixlQUFlO2tCQUQzQixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBtYXJrZWQgfSBmcm9tICdtYXJrZWQnO1xuaW1wb3J0IHsgbWFya2Rvd25QaWxsRXh0ZW5zaW9uIH0gZnJvbSAnLi9waWxsLXBsdWdpbic7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBNYXJrZG93blNlcnZpY2Uge1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICB9XG5cbiAgcmVuZGVyKGNvbnRlbnQ6IHN0cmluZykge1xuICAgIHJldHVybiBtYXJrZWQucGFyc2UoY29udGVudCwge1xuICAgICAgc21hcnRMaXN0czogdHJ1ZVxuICAgIH0pO1xuICB9XG5cbiAgcmVuZGVySW5saW5lKGNvbnRlbnQ6IHN0cmluZykge1xuICAgIHJldHVybiBtYXJrZWQucGFyc2VJbmxpbmUoY29udGVudCk7XG4gIH1cblxuICB1c2VQaWxsRXh0ZW5zaW9uKHJlbmRlcmVyPzogKGNvbnRlbnQ6IHN0cmluZykgPT4gc3RyaW5nKSB7XG4gICAgbWFya2VkLnVzZSh7XG4gICAgICBleHRlbnNpb25zOiBbbWFya2Rvd25QaWxsRXh0ZW5zaW9uKHJlbmRlcmVyID8/ICh0ZXh0ID0+IGA8c3BhbiBjbGFzcz0nYXVwLXBpbGwnPiR7dGV4dH08c3Bhbj5gKSldXG4gICAgfSk7XG4gIH1cbn1cblxuXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFya2Rvd24uc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci11aS1wb3dlcnVwcy9zcmMvbGliL3NlcnZpY2VzL21hcmtkb3duL21hcmtkb3duLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBQ2hDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFHdEQsTUFBTSxPQUFPLGVBQWU7SUFFMUI7SUFDQSxDQUFDO0lBRUQsTUFBTSxDQUFDLE9BQWU7UUFDcEIsT0FBTyxNQUFNLENBQUMsS0FBSyxDQUFDLE9BQU8sRUFBRTtZQUMzQixVQUFVLEVBQUUsSUFBSTtTQUNqQixDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQsWUFBWSxDQUFDLE9BQWU7UUFDMUIsT0FBTyxNQUFNLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFFRCxnQkFBZ0IsQ0FBQyxRQUFzQztRQUNyRCxNQUFNLENBQUMsR0FBRyxDQUFDO1lBQ1QsVUFBVSxFQUFFLENBQUMscUJBQXFCLENBQUMsUUFBUSxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQywwQkFBMEIsSUFBSSxRQUFRLENBQUMsQ0FBQyxDQUFDO1NBQ2xHLENBQUMsQ0FBQztJQUNMLENBQUM7OzRHQW5CVSxlQUFlO2dIQUFmLGVBQWU7MkZBQWYsZUFBZTtrQkFEM0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgbWFya2VkIH0gZnJvbSAnbWFya2VkJztcbmltcG9ydCB7IG1hcmtkb3duUGlsbEV4dGVuc2lvbiB9IGZyb20gJy4vcGlsbC1wbHVnaW4nO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgTWFya2Rvd25TZXJ2aWNlIHtcblxuICBjb25zdHJ1Y3RvcigpIHtcbiAgfVxuXG4gIHJlbmRlcihjb250ZW50OiBzdHJpbmcpIHtcbiAgICByZXR1cm4gbWFya2VkLnBhcnNlKGNvbnRlbnQsIHtcbiAgICAgIHNtYXJ0TGlzdHM6IHRydWVcbiAgICB9KTtcbiAgfVxuXG4gIHJlbmRlcklubGluZShjb250ZW50OiBzdHJpbmcpIHtcbiAgICByZXR1cm4gbWFya2VkLnBhcnNlSW5saW5lKGNvbnRlbnQpO1xuICB9XG5cbiAgdXNlUGlsbEV4dGVuc2lvbihyZW5kZXJlcj86IChjb250ZW50OiBzdHJpbmcpID0+IHN0cmluZykge1xuICAgIG1hcmtlZC51c2Uoe1xuICAgICAgZXh0ZW5zaW9uczogW21hcmtkb3duUGlsbEV4dGVuc2lvbihyZW5kZXJlciA/PyAodGV4dCA9PiBgPHNwYW4gY2xhc3M9J2F1cC1waWxsJz4ke3RleHR9PHNwYW4+YCkpXVxuICAgIH0pO1xuICB9XG59XG5cblxuIl19

package/esm2020/lib/services/markdown/pill-plugin.mjs

@@ -0,0 +1,37 @@
+export const markdownPillExtension = (renderPill) => {
+    return {
+        name: 'aup-pill',
+        level: 'inline',
+        start: (src) => {
+            const index = src.match(/\(\([^)]/)?.index;
+            // if (index) {
+            //     console.log({start:src})
+            // }
+            return index;
+        },
+        tokenizer: function (src) {
+            const rule = /^(\(\((([^)])+)\)\))/; // Regex for the complete token
+            const match = rule.exec(src);
+            if (match) {
+                const token = {
+                    type: 'aup-pill',
+                    raw: match[0],
+                    text: match[2].trim(), // Additional custom properties
+                    // tokens: []              // Array where child inline tokens will be generated
+                };
+                // console.log(token)
+                // this.lexer.inlineTokens(token.text, token.tokens);    // Queue this data to be processed for inline tokens
+                return token;
+            }
+            else {
+                return undefined;
+            }
+        },
+        renderer: function (token) {
+            // @ts-ignore (until typings are up to date)
+            const url = token.text;
+            return renderPill(token.text);
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/visibility-service.mjs

@@ -0,0 +1,79 @@
+// TODO: Merge various wake detection events into this class.  visibility, wake events, websocket connection, online detection.
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { Dsl, GarbageCollector, MutableValueModel } from '@coolon/pectin';
+import * as i0 from "@angular/core";
+// Taken from: https://developer.mozilla.org/en-US/docs/Web/API/Page_Visibility_API
+export class VisibilityService extends GarbageCollector {
+    // private _wakeEvents = new MutableStream<Instant>();
+    // private _throttledWakeEvents: Stream<Instant>;
+    constructor(document) {
+        super();
+        this._visible$ = new MutableValueModel();
+        this.document = document; // see https://stackoverflow.com/a/53715642
+        const { chain } = Dsl.disposeWith(this);
+        // Set the name of the hidden property and the change event for visibility
+        if (typeof this.document.hidden !== 'undefined') { // Opera 12.10 and Firefox 18 and later support
+            this.attributeName = 'hidden';
+            this.eventName = 'visibilitychange';
+        }
+        else if (typeof this.document['msHidden'] !== 'undefined') {
+            this.attributeName = 'msHidden';
+            this.eventName = 'msvisibilitychange';
+        }
+        else if (typeof this.document['webkitHidden'] !== 'undefined') {
+            this.attributeName = 'webkitHidden';
+            this.eventName = 'webkitvisibilitychange';
+        }
+        // Warn if the browser doesn't support addEventListener or the Page Visibility API
+        if (typeof this.document.addEventListener === 'undefined' || typeof document[this.attributeName] === 'undefined') {
+            console.log('This demo requires a browser, such as Google Chrome or Firefox, that supports the Page Visibility API.');
+        }
+        else {
+            // Handle page visibility change
+            const handler = () => this.updateVisibilityState();
+            this.document.addEventListener(this.eventName, handler, false);
+            this.onDispose(() => {
+                this.document.removeEventListener(this.eventName, handler);
+            });
+        }
+        this._visible$.value = this.isVisible();
+        // give the network a chance to come back or we end up with a bunch of failed requests.
+        // should probably also implement a connection service so that we can go
+        // connectionServer.ensureConnectedThen(fireWakeEvent);
+        // this._throttledWakeEvents = chain(this._wakeEvents).throttle(300);
+    }
+    // get wakeEvents(): Stream<Instant> {
+    //   return this._throttledWakeEvents;
+    // }
+    // @trace
+    updateVisibilityState() {
+        this._visible$.value = this.isVisible();
+        // this._wakeEvents.publish(Instant.now());
+    }
+    /**
+     * @deprecated use visible$ instead.
+     */
+    get visibleModel() {
+        return this._visible$.readonly;
+    }
+    get visible$() {
+        return this._visible$.readonly;
+    }
+    isHidden() {
+        return !!this.document[this.attributeName];
+    }
+    isVisible() {
+        return !this.isHidden();
+    }
+}
+VisibilityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: VisibilityService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+VisibilityService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: VisibilityService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: VisibilityService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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