@ecodev/natural 41.3.0 → 42.0.0

package/esm2020/lib/modules/common/common-module.mjs

@@ -0,0 +1,54 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { NaturalHttpPrefixDirective } from '../../directives/http-prefix.directive';
+import { NaturalLinkableTabDirective } from './directives/linkable-tab.directive';
+import { ReactiveAsteriskDirective } from './directives/reactive-asterisk.directive';
+import { NaturalCapitalizePipe } from './pipes/capitalize.pipe';
+import { NaturalEllipsisPipe } from './pipes/ellipsis.pipe';
+import { NaturalEnumPipe } from './pipes/enum.pipe';
+import { localStorageProvider, sessionStorageProvider } from './services/memory-storage';
+import { NaturalSwissDatePipe } from './pipes/swiss-date.pipe';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { MatSelectModule } from '@angular/material/select';
+import { NaturalSrcDensityDirective } from './directives/src-density.directive';
+import * as i0 from "@angular/core";
+const declarationsToExport = [
+    NaturalCapitalizePipe,
+    NaturalEllipsisPipe,
+    NaturalEnumPipe,
+    NaturalSwissDatePipe,
+    ReactiveAsteriskDirective,
+    NaturalHttpPrefixDirective,
+    NaturalSrcDensityDirective,
+    NaturalLinkableTabDirective,
+];
+export class NaturalCommonModule {
+}
+NaturalCommonModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NaturalCommonModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalCommonModule, declarations: [NaturalCapitalizePipe,
+        NaturalEllipsisPipe,
+        NaturalEnumPipe,
+        NaturalSwissDatePipe,
+        ReactiveAsteriskDirective,
+        NaturalHttpPrefixDirective,
+        NaturalSrcDensityDirective,
+        NaturalLinkableTabDirective], imports: [CommonModule, MatFormFieldModule, MatInputModule, MatSelectModule], exports: [NaturalCapitalizePipe,
+        NaturalEllipsisPipe,
+        NaturalEnumPipe,
+        NaturalSwissDatePipe,
+        ReactiveAsteriskDirective,
+        NaturalHttpPrefixDirective,
+        NaturalSrcDensityDirective,
+        NaturalLinkableTabDirective] });
+NaturalCommonModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalCommonModule, providers: [sessionStorageProvider, localStorageProvider], imports: [[CommonModule, MatFormFieldModule, MatInputModule, MatSelectModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalCommonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [...declarationsToExport],
+                    imports: [CommonModule, MatFormFieldModule, MatInputModule, MatSelectModule],
+                    exports: [...declarationsToExport],
+                    providers: [sessionStorageProvider, localStorageProvider],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/common/directives/linkable-tab.directive.mjs

@@ -0,0 +1,79 @@
+import { Directive, Input } from '@angular/core';
+import { clone } from 'lodash-es';
+import { takeUntil } from 'rxjs/operators';
+import { NaturalAbstractController } from '../../../classes/abstract-controller';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/tabs";
+import * as i2 from "@angular/router";
+/**
+ * Returns an identifier for the tab
+ */
+function getTabId(tab) {
+    return tab.content?.viewContainerRef.element.nativeElement.id ?? '';
+}
+/**
+ * Usage :
+ *
+ * <mat-tab-group [naturalLinkableTab]="!isPanel">
+ *     <mat-tab label="Third 1">third 1</mat-tab> // First tab doesn't need id. This keeps url clean on default one
+ *     <mat-tab label="Third 2" id="third2">Third 2</mat-tab>
+ *     ...
+ * </mat-tab-group>
+ */
+export class NaturalLinkableTabDirective extends NaturalAbstractController {
+    constructor(component, route, router) {
+        super();
+        this.component = component;
+        this.route = route;
+        this.router = router;
+        /**
+         * If false, disables the persistent navigation
+         */
+        this.naturalLinkableTab = true;
+    }
+    ngAfterViewInit() {
+        if (this.naturalLinkableTab === false) {
+            return;
+        }
+        // When url params change, update the mat-tab-group selected tab
+        this.route.fragment.pipe(takeUntil(this.ngUnsubscribe)).subscribe(fragment => {
+            // Get index of tab that matches wanted name
+            const tabIndex = this.getTabIndex(fragment);
+            // If tab index is valid (>= 0) go to given fragment
+            // If there is no fragment at all, go to first tab (index is -1 in this case)
+            if (tabIndex >= 0 || !fragment) {
+                this.component.selectedIndex = tabIndex;
+            }
+        });
+        // When mat-tab-groups selected tab change, update url
+        this.component.selectedTabChange.pipe(takeUntil(this.ngUnsubscribe)).subscribe((event) => {
+            const activatedTabName = getTabId(event.tab);
+            const segments = this.route.snapshot.url;
+            if (!segments.length) {
+                // This should never happen in normal usage, because it would means there is no route at all in the app
+                throw new Error('Cannot update URL for tabs without any segments in URL');
+            }
+            // Get url matrix params (/segment;matrix=param) only without route params (segment/:id)
+            const params = clone(segments[segments.length - 1].parameters);
+            this.router.navigate(['.', params], {
+                relativeTo: this.route,
+                queryParamsHandling: 'preserve',
+                fragment: activatedTabName && activatedTabName.length ? activatedTabName : undefined,
+            });
+        });
+    }
+    getTabIndex(fragment) {
+        return this.component._tabs.toArray().findIndex(tab => fragment === getTabId(tab));
+    }
+}
+NaturalLinkableTabDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalLinkableTabDirective, deps: [{ token: i1.MatTabGroup }, { token: i2.ActivatedRoute }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Directive });
+NaturalLinkableTabDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.5", type: NaturalLinkableTabDirective, selector: "mat-tab-group[naturalLinkableTab]", inputs: { naturalLinkableTab: "naturalLinkableTab" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalLinkableTabDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'mat-tab-group[naturalLinkableTab]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatTabGroup }, { type: i2.ActivatedRoute }, { type: i2.Router }]; }, propDecorators: { naturalLinkableTab: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/common/directives/reactive-asterisk.directive.mjs

@@ -0,0 +1,33 @@
+import { Directive, Optional } from '@angular/core';
+import { MatInput } from '@angular/material/input';
+import { MatSelect } from '@angular/material/select';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/form-field";
+/**
+ * Input/Select into FormField consider Validator.required from reactive form if the [required] attribute is missing in the template
+ */
+export class ReactiveAsteriskDirective {
+    constructor(matFormField) {
+        this.matFormField = matFormField;
+    }
+    ngAfterContentChecked() {
+        const ctrl = this.matFormField?._control;
+        if (ctrl instanceof MatInput || ctrl instanceof MatSelect) {
+            // Here we cast to be able to set `required`. It should not be required and might be a bug in TypeScript ?
+            // Try to remove and see if it compiles
+            ctrl.required = ctrl.ngControl?.control?.validator?.({})?.required;
+        }
+    }
+}
+ReactiveAsteriskDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ReactiveAsteriskDirective, deps: [{ token: i1.MatFormField, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+ReactiveAsteriskDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.5", type: ReactiveAsteriskDirective, selector: "mat-form-field:has(input:not([required])), mat-form-field:has(mat-select:not([required]))", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ReactiveAsteriskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'mat-form-field:has(input:not([required])), mat-form-field:has(mat-select:not([required]))',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatFormField, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/common/directives/src-density.directive.mjs

@@ -0,0 +1,62 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NaturalSrcDensityDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    /**
+     * Automatically apply image selection based on screen density.
+     *
+     * The given URL **MUST** be the normal density URL. And it **MUST** include
+     * the size as last path segment. That size will automatically be changed
+     * for other screen densities. That means that the server **MUST** be able to
+     * serve an image of the given size.
+     *
+     * Usage:
+     *
+     * ```html
+     * <img [naturalSrcDensity]="'/api/image/123/200'" />
+     * ```
+     *
+     * Will generate something like:
+     *
+     * ```html
+     * <img
+     *     src="/api/image/123/200"
+     *     srcset="/api/image/123/200, /api/image/123/300 1.5x, /api/image/123/400 2x, /api/image/123/600 3x, /api/image/123/800 4x"
+     * />
+     * ```
+     *
+     * See https://web.dev/codelab-density-descriptors/
+     */
+    set naturalSrcDensity(src) {
+        if (!src) {
+            return;
+        }
+        const match = src.match(/^(.*\/)(\d+)$/);
+        const base = match?.[1];
+        const size = +(match?.[2] ?? 0);
+        let srcset = '';
+        if (base && size) {
+            // This should cover most common densities according to https://www.mydevice.io/#tab1
+            const size15 = Math.round(size * 1.5);
+            const size2 = size * 2;
+            const size3 = size * 3;
+            const size4 = size * 4;
+            srcset = `${base}${size}, ${base}${size15} 1.5x, ${base}${size2} 2x, ${base}${size3} 3x, ${base}${size4} 4x`;
+        }
+        this.elementRef.nativeElement.src = src;
+        this.elementRef.nativeElement.srcset = srcset;
+    }
+}
+NaturalSrcDensityDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalSrcDensityDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+NaturalSrcDensityDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.5", type: NaturalSrcDensityDirective, selector: "img[naturalSrcDensity]", inputs: { naturalSrcDensity: "naturalSrcDensity" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalSrcDensityDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'img[naturalSrcDensity]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { naturalSrcDensity: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/common/pipes/capitalize.pipe.mjs

@@ -0,0 +1,18 @@
+import { Pipe } from '@angular/core';
+import { upperCaseFirstLetter } from '../../../classes/utility';
+import * as i0 from "@angular/core";
+export class NaturalCapitalizePipe {
+    transform(value) {
+        if (value) {
+            return upperCaseFirstLetter(value);
+        }
+        return value;
+    }
+}
+NaturalCapitalizePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalCapitalizePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NaturalCapitalizePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalCapitalizePipe, name: "capitalize" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalCapitalizePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'capitalize' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FwaXRhbGl6ZS5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmF0dXJhbC9zcmMvbGliL21vZHVsZXMvY29tbW9uL3BpcGVzL2NhcGl0YWxpemUucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsSUFBSSxFQUFnQixNQUFNLGVBQWUsQ0FBQztBQUNsRCxPQUFPLEVBQUMsb0JBQW9CLEVBQUMsTUFBTSwwQkFBMEIsQ0FBQzs7QUFHOUQsTUFBTSxPQUFPLHFCQUFxQjtJQUN2QixTQUFTLENBQUMsS0FBb0I7UUFDakMsSUFBSSxLQUFLLEVBQUU7WUFDUCxPQUFPLG9CQUFvQixDQUFDLEtBQUssQ0FBQyxDQUFDO1NBQ3RDO1FBRUQsT0FBTyxLQUFLLENBQUM7SUFDakIsQ0FBQzs7a0hBUFEscUJBQXFCO2dIQUFyQixxQkFBcUI7MkZBQXJCLHFCQUFxQjtrQkFEakMsSUFBSTttQkFBQyxFQUFDLElBQUksRUFBRSxZQUFZLEVBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1BpcGUsIFBpcGVUcmFuc2Zvcm19IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHt1cHBlckNhc2VGaXJzdExldHRlcn0gZnJvbSAnLi4vLi4vLi4vY2xhc3Nlcy91dGlsaXR5JztcblxuQFBpcGUoe25hbWU6ICdjYXBpdGFsaXplJ30pXG5leHBvcnQgY2xhc3MgTmF0dXJhbENhcGl0YWxpemVQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gICAgcHVibGljIHRyYW5zZm9ybSh2YWx1ZTogc3RyaW5nIHwgbnVsbCk6IHN0cmluZyB8IG51bGwge1xuICAgICAgICBpZiAodmFsdWUpIHtcbiAgICAgICAgICAgIHJldHVybiB1cHBlckNhc2VGaXJzdExldHRlcih2YWx1ZSk7XG4gICAgICAgIH1cblxuICAgICAgICByZXR1cm4gdmFsdWU7XG4gICAgfVxufVxuIl19

package/esm2020/lib/modules/common/pipes/ellipsis.pipe.mjs

@@ -0,0 +1,14 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NaturalEllipsisPipe {
+    transform(value, limit) {
+        return value.substr(0, limit - 1) + (value.length > limit ? '…' : '');
+    }
+}
+NaturalEllipsisPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalEllipsisPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NaturalEllipsisPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalEllipsisPipe, name: "ellipsis" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalEllipsisPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'ellipsis' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxsaXBzaXMucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25hdHVyYWwvc3JjL2xpYi9tb2R1bGVzL2NvbW1vbi9waXBlcy9lbGxpcHNpcy5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxJQUFJLEVBQWdCLE1BQU0sZUFBZSxDQUFDOztBQUdsRCxNQUFNLE9BQU8sbUJBQW1CO0lBQ3JCLFNBQVMsQ0FBQyxLQUFhLEVBQUUsS0FBYTtRQUN6QyxPQUFPLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxFQUFFLEtBQUssR0FBRyxDQUFDLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxNQUFNLEdBQUcsS0FBSyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQzFFLENBQUM7O2dIQUhRLG1CQUFtQjs4R0FBbkIsbUJBQW1COzJGQUFuQixtQkFBbUI7a0JBRC9CLElBQUk7bUJBQUMsRUFBQyxJQUFJLEVBQUUsVUFBVSxFQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtQaXBlLCBQaXBlVHJhbnNmb3JtfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQFBpcGUoe25hbWU6ICdlbGxpcHNpcyd9KVxuZXhwb3J0IGNsYXNzIE5hdHVyYWxFbGxpcHNpc1BpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgICBwdWJsaWMgdHJhbnNmb3JtKHZhbHVlOiBzdHJpbmcsIGxpbWl0OiBudW1iZXIpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gdmFsdWUuc3Vic3RyKDAsIGxpbWl0IC0gMSkgKyAodmFsdWUubGVuZ3RoID4gbGltaXQgPyAn4oCmJyA6ICcnKTtcbiAgICB9XG59XG4iXX0=

package/esm2020/lib/modules/common/pipes/enum.pipe.mjs

@@ -0,0 +1,25 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/enum.service";
+/**
+ * A pipe to output an enum user-friendly name, instead of its value.
+ *
+ * Usage would be: {{ element.priority | enum: 'Priority' | async }}
+ */
+export class NaturalEnumPipe {
+    constructor(enumService) {
+        this.enumService = enumService;
+    }
+    transform(value, enumName) {
+        return this.enumService.getValueName(value, enumName);
+    }
+}
+NaturalEnumPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalEnumPipe, deps: [{ token: i1.NaturalEnumService }], target: i0.ɵɵFactoryTarget.Pipe });
+NaturalEnumPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalEnumPipe, name: "enum" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalEnumPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'enum',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NaturalEnumService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW51bS5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmF0dXJhbC9zcmMvbGliL21vZHVsZXMvY29tbW9uL3BpcGVzL2VudW0ucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsSUFBSSxFQUFnQixNQUFNLGVBQWUsQ0FBQzs7O0FBSWxEOzs7O0dBSUc7QUFJSCxNQUFNLE9BQU8sZUFBZTtJQUN4QixZQUFvQyxXQUErQjtRQUEvQixnQkFBVyxHQUFYLFdBQVcsQ0FBb0I7SUFBRyxDQUFDO0lBRWhFLFNBQVMsQ0FBQyxLQUFVLEVBQUUsUUFBZ0I7UUFDekMsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDMUQsQ0FBQzs7NEdBTFEsZUFBZTswR0FBZixlQUFlOzJGQUFmLGVBQWU7a0JBSDNCLElBQUk7bUJBQUM7b0JBQ0YsSUFBSSxFQUFFLE1BQU07aUJBQ2YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1BpcGUsIFBpcGVUcmFuc2Zvcm19IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtOYXR1cmFsRW51bVNlcnZpY2V9IGZyb20gJy4uLy4uLy4uL3NlcnZpY2VzL2VudW0uc2VydmljZSc7XG5pbXBvcnQge09ic2VydmFibGV9IGZyb20gJ3J4anMnO1xuXG4vKipcbiAqIEEgcGlwZSB0byBvdXRwdXQgYW4gZW51bSB1c2VyLWZyaWVuZGx5IG5hbWUsIGluc3RlYWQgb2YgaXRzIHZhbHVlLlxuICpcbiAqIFVzYWdlIHdvdWxkIGJlOiB7eyBlbGVtZW50LnByaW9yaXR5IHwgZW51bTogJ1ByaW9yaXR5JyB8IGFzeW5jIH19XG4gKi9cbkBQaXBlKHtcbiAgICBuYW1lOiAnZW51bScsXG59KVxuZXhwb3J0IGNsYXNzIE5hdHVyYWxFbnVtUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICAgIHB1YmxpYyBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IGVudW1TZXJ2aWNlOiBOYXR1cmFsRW51bVNlcnZpY2UpIHt9XG5cbiAgICBwdWJsaWMgdHJhbnNmb3JtKHZhbHVlOiBhbnksIGVudW1OYW1lOiBzdHJpbmcpOiBPYnNlcnZhYmxlPHN0cmluZz4ge1xuICAgICAgICByZXR1cm4gdGhpcy5lbnVtU2VydmljZS5nZXRWYWx1ZU5hbWUodmFsdWUsIGVudW1OYW1lKTtcbiAgICB9XG59XG4iXX0=

package/esm2020/lib/modules/common/pipes/swiss-date.pipe.mjs

@@ -0,0 +1,20 @@
+import { Pipe } from '@angular/core';
+import { DatePipe } from '@angular/common';
+import * as i0 from "@angular/core";
+/**
+ * A normal DatePipe but with default formatting to be '12.24.2020 23:30' to match the most common use-cases
+ */
+export class NaturalSwissDatePipe extends DatePipe {
+    transform(value, format = 'dd.MM.y HH:mm', timezone, locale) {
+        return super.transform(value, format, timezone, locale);
+    }
+}
+NaturalSwissDatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalSwissDatePipe, deps: null, target: i0.ɵɵFactoryTarget.Pipe });
+NaturalSwissDatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalSwissDatePipe, name: "swissDate" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalSwissDatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'swissDate',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dpc3MtZGF0ZS5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmF0dXJhbC9zcmMvbGliL21vZHVsZXMvY29tbW9uL3BpcGVzL3N3aXNzLWRhdGUucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsSUFBSSxFQUFnQixNQUFNLGVBQWUsQ0FBQztBQUNsRCxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0saUJBQWlCLENBQUM7O0FBRXpDOztHQUVHO0FBSUgsTUFBTSxPQUFPLG9CQUFxQixTQUFRLFFBQVE7SUFRdkMsU0FBUyxDQUNaLEtBQWdELEVBQ2hELE1BQU0sR0FBRyxlQUFlLEVBQ3hCLFFBQWlCLEVBQ2pCLE1BQWU7UUFFZixPQUFPLEtBQUssQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDNUQsQ0FBQzs7aUhBZlEsb0JBQW9COytHQUFwQixvQkFBb0I7MkZBQXBCLG9CQUFvQjtrQkFIaEMsSUFBSTttQkFBQztvQkFDRixJQUFJLEVBQUUsV0FBVztpQkFDcEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1BpcGUsIFBpcGVUcmFuc2Zvcm19IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtEYXRlUGlwZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcblxuLyoqXG4gKiBBIG5vcm1hbCBEYXRlUGlwZSBidXQgd2l0aCBkZWZhdWx0IGZvcm1hdHRpbmcgdG8gYmUgJzEyLjI0LjIwMjAgMjM6MzAnIHRvIG1hdGNoIHRoZSBtb3N0IGNvbW1vbiB1c2UtY2FzZXNcbiAqL1xuQFBpcGUoe1xuICAgIG5hbWU6ICdzd2lzc0RhdGUnLFxufSlcbmV4cG9ydCBjbGFzcyBOYXR1cmFsU3dpc3NEYXRlUGlwZSBleHRlbmRzIERhdGVQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gICAgcHVibGljIHRyYW5zZm9ybSh2YWx1ZTogbnVsbCB8IHVuZGVmaW5lZCwgZm9ybWF0Pzogc3RyaW5nLCB0aW1lem9uZT86IHN0cmluZywgbG9jYWxlPzogc3RyaW5nKTogbnVsbDtcbiAgICBwdWJsaWMgdHJhbnNmb3JtKFxuICAgICAgICB2YWx1ZTogRGF0ZSB8IHN0cmluZyB8IG51bWJlciB8IG51bGwgfCB1bmRlZmluZWQsXG4gICAgICAgIGZvcm1hdD86IHN0cmluZyxcbiAgICAgICAgdGltZXpvbmU/OiBzdHJpbmcsXG4gICAgICAgIGxvY2FsZT86IHN0cmluZyxcbiAgICApOiBzdHJpbmcgfCBudWxsO1xuICAgIHB1YmxpYyB0cmFuc2Zvcm0oXG4gICAgICAgIHZhbHVlOiBEYXRlIHwgc3RyaW5nIHwgbnVtYmVyIHwgbnVsbCB8IHVuZGVmaW5lZCxcbiAgICAgICAgZm9ybWF0ID0gJ2RkLk1NLnkgSEg6bW0nLFxuICAgICAgICB0aW1lem9uZT86IHN0cmluZyxcbiAgICAgICAgbG9jYWxlPzogc3RyaW5nLFxuICAgICk6IHN0cmluZyB8IG51bGwge1xuICAgICAgICByZXR1cm4gc3VwZXIudHJhbnNmb3JtKHZhbHVlLCBmb3JtYXQsIHRpbWV6b25lLCBsb2NhbGUpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/lib/modules/common/services/memory-storage.mjs

@@ -0,0 +1,112 @@
+import { Injectable, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export const SESSION_STORAGE = new InjectionToken('Session storage that can be shimed when running on server or in tests');
+export const LOCAL_STORAGE = new InjectionToken('Local storage that can be shimed when running on server or in tests');
+/**
+ * Memory storage to keep store volatile things in memory
+ *
+ * Should be used to shim sessionStorage when running on server or in our tests
+ */
+export class NaturalMemoryStorage {
+    constructor() {
+        this.data = new Map();
+    }
+    get length() {
+        return this.data.size;
+    }
+    clear() {
+        this.data.clear();
+    }
+    getItem(key) {
+        const value = this.data.get(key);
+        return value === undefined ? null : value;
+    }
+    key(index) {
+        let i = 0;
+        for (const key of this.data.keys()) {
+            if (i++ === index) {
+                return key;
+            }
+        }
+        return null;
+    }
+    removeItem(key) {
+        this.data.delete(key);
+    }
+    setItem(key, value) {
+        this.data.set(key, value);
+    }
+}
+NaturalMemoryStorage.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalMemoryStorage, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NaturalMemoryStorage.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalMemoryStorage, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalMemoryStorage, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+export function sessionStorageFactory() {
+    try {
+        // eslint-disable-next-line no-restricted-globals
+        if (typeof sessionStorage !== 'undefined') {
+            // eslint-disable-next-line no-restricted-globals
+            return sessionStorage;
+        }
+    }
+    catch (e) {
+        // nothing do to
+    }
+    return new NaturalMemoryStorage();
+}
+/**
+ * Standard `sessionStorage` provider that is compatible with SSR.
+ *
+ * In SSR environment, or when `sessionStorage` is not available, will return a `NaturalMemoryStorage`
+ */
+export const sessionStorageProvider = {
+    // Here we must use a factory that return directly the value, otherwise it will
+    // crash when running on server because the value does not exist (but the factory will
+    // never actually be called on server, so the server will not see the missing value)
+    provide: SESSION_STORAGE,
+    useFactory: sessionStorageFactory,
+};
+/**
+ * Provide in-memory session storage to be used only in tests or SSR
+ */
+export const memorySessionStorageProvider = {
+    provide: SESSION_STORAGE,
+    useClass: NaturalMemoryStorage,
+};
+export function localStorageFactory() {
+    try {
+        // eslint-disable-next-line no-restricted-globals
+        if (typeof localStorage !== 'undefined') {
+            // eslint-disable-next-line no-restricted-globals
+            return localStorage;
+        }
+    }
+    catch (e) {
+        // Do nothing
+    }
+    return new NaturalMemoryStorage();
+}
+/**
+ * Standard `localStorage` provider that is compatible with SSR.
+ *
+ * In SSR environment, or when `localStorage` is not available, will return a `NaturalMemoryStorage`
+ */
+export const localStorageProvider = {
+    // Here we must use a factory that return directly the value, otherwise it will
+    // crash when running on server because the value does not exist (but the factory will
+    // never actually be called on server, so the server will not see the missing value)
+    provide: LOCAL_STORAGE,
+    useFactory: localStorageFactory,
+};
+/**
+ * Provide in-memory local storage to be used only in tests or SSR
+ */
+export const memoryLocalStorageProvider = {
+    provide: LOCAL_STORAGE,
+    useClass: NaturalMemoryStorage,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory-storage.js","sourceRoot":"","sources":["../../../../../../../projects/natural/src/lib/modules/common/services/memory-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,cAAc,EAAW,MAAM,eAAe,CAAC;;AAEnE,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,cAAc,CAC7C,uEAAuE,CAC1E,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,cAAc,CAC3C,qEAAqE,CACxE,CAAC;AAOF;;;;GAIG;AAIH,MAAM,OAAO,oBAAoB;IAHjC;QAIqB,SAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;KAiCrD;IA/BG,IAAW,MAAM;QACb,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IAC1B,CAAC;IAEM,KAAK;QACR,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAEM,OAAO,CAAC,GAAW;QACtB,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjC,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;IAC9C,CAAC;IAEM,GAAG,CAAC,KAAa;QACpB,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE;YAChC,IAAI,CAAC,EAAE,KAAK,KAAK,EAAE;gBACf,OAAO,GAAG,CAAC;aACd;SACJ;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,UAAU,CAAC,GAAW;QACzB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;IAEM,OAAO,CAAC,GAAW,EAAE,KAAa;QACrC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC9B,CAAC;;iHAjCQ,oBAAoB;qHAApB,oBAAoB,cAFjB,MAAM;2FAET,oBAAoB;kBAHhC,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB;;AAqCD,MAAM,UAAU,qBAAqB;IACjC,IAAI;QACA,iDAAiD;QACjD,IAAI,OAAO,cAAc,KAAK,WAAW,EAAE;YACvC,iDAAiD;YACjD,OAAO,cAAc,CAAC;SACzB;KACJ;IAAC,OAAO,CAAC,EAAE;QACR,gBAAgB;KACnB;IAED,OAAO,IAAI,oBAAoB,EAAE,CAAC;AACtC,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAa;IAC5C,+EAA+E;IAC/E,sFAAsF;IACtF,oFAAoF;IACpF,OAAO,EAAE,eAAe;IACxB,UAAU,EAAE,qBAAqB;CACpC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAa;IAClD,OAAO,EAAE,eAAe;IACxB,QAAQ,EAAE,oBAAoB;CACjC,CAAC;AAEF,MAAM,UAAU,mBAAmB;IAC/B,IAAI;QACA,iDAAiD;QACjD,IAAI,OAAO,YAAY,KAAK,WAAW,EAAE;YACrC,iDAAiD;YACjD,OAAO,YAAY,CAAC;SACvB;KACJ;IAAC,OAAO,CAAC,EAAE;QACR,aAAa;KAChB;IAED,OAAO,IAAI,oBAAoB,EAAE,CAAC;AACtC,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAa;IAC1C,+EAA+E;IAC/E,sFAAsF;IACtF,oFAAoF;IACpF,OAAO,EAAE,aAAa;IACtB,UAAU,EAAE,mBAAmB;CAClC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAa;IAChD,OAAO,EAAE,aAAa;IACtB,QAAQ,EAAE,oBAAoB;CACjC,CAAC","sourcesContent":["import {Injectable, InjectionToken, Provider} from '@angular/core';\n\nexport const SESSION_STORAGE = new InjectionToken<NaturalStorage>(\n    'Session storage that can be shimed when running on server or in tests',\n);\n\nexport const LOCAL_STORAGE = new InjectionToken<NaturalStorage>(\n    'Local storage that can be shimed when running on server or in tests',\n);\n\n/**\n * Normal `Storage` type, but without array access\n */\nexport type NaturalStorage = Pick<Storage, 'length' | 'clear' | 'getItem' | 'key' | 'removeItem' | 'setItem'>;\n\n/**\n * Memory storage to keep store volatile things in memory\n *\n * Should be used to shim sessionStorage when running on server or in our tests\n */\n@Injectable({\n    providedIn: 'root',\n})\nexport class NaturalMemoryStorage implements NaturalStorage {\n    private readonly data = new Map<string, string>();\n\n    public get length(): number {\n        return this.data.size;\n    }\n\n    public clear(): void {\n        this.data.clear();\n    }\n\n    public getItem(key: string): string | null {\n        const value = this.data.get(key);\n        return value === undefined ? null : value;\n    }\n\n    public key(index: number): string | null {\n        let i = 0;\n        for (const key of this.data.keys()) {\n            if (i++ === index) {\n                return key;\n            }\n        }\n\n        return null;\n    }\n\n    public removeItem(key: string): void {\n        this.data.delete(key);\n    }\n\n    public setItem(key: string, value: string): void {\n        this.data.set(key, value);\n    }\n}\n\nexport function sessionStorageFactory(): NaturalStorage {\n    try {\n        // eslint-disable-next-line no-restricted-globals\n        if (typeof sessionStorage !== 'undefined') {\n            // eslint-disable-next-line no-restricted-globals\n            return sessionStorage;\n        }\n    } catch (e) {\n        // nothing do to\n    }\n\n    return new NaturalMemoryStorage();\n}\n\n/**\n * Standard `sessionStorage` provider that is compatible with SSR.\n *\n * In SSR environment, or when `sessionStorage` is not available, will return a `NaturalMemoryStorage`\n */\nexport const sessionStorageProvider: Provider = {\n    // Here we must use a factory that return directly the value, otherwise it will\n    // crash when running on server because the value does not exist (but the factory will\n    // never actually be called on server, so the server will not see the missing value)\n    provide: SESSION_STORAGE,\n    useFactory: sessionStorageFactory,\n};\n\n/**\n * Provide in-memory session storage to be used only in tests or SSR\n */\nexport const memorySessionStorageProvider: Provider = {\n    provide: SESSION_STORAGE,\n    useClass: NaturalMemoryStorage,\n};\n\nexport function localStorageFactory(): NaturalStorage {\n    try {\n        // eslint-disable-next-line no-restricted-globals\n        if (typeof localStorage !== 'undefined') {\n            // eslint-disable-next-line no-restricted-globals\n            return localStorage;\n        }\n    } catch (e) {\n        // Do nothing\n    }\n\n    return new NaturalMemoryStorage();\n}\n\n/**\n * Standard `localStorage` provider that is compatible with SSR.\n *\n * In SSR environment, or when `localStorage` is not available, will return a `NaturalMemoryStorage`\n */\nexport const localStorageProvider: Provider = {\n    // Here we must use a factory that return directly the value, otherwise it will\n    // crash when running on server because the value does not exist (but the factory will\n    // never actually be called on server, so the server will not see the missing value)\n    provide: LOCAL_STORAGE,\n    useFactory: localStorageFactory,\n};\n\n/**\n * Provide in-memory local storage to be used only in tests or SSR\n */\nexport const memoryLocalStorageProvider: Provider = {\n    provide: LOCAL_STORAGE,\n    useClass: NaturalMemoryStorage,\n};\n"]}

package/esm2020/lib/modules/common/services/seo.service.mjs

@@ -0,0 +1,114 @@
+import { Inject, Injectable, InjectionToken } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/platform-browser";
+export const NATURAL_SEO_CONFIG = new InjectionToken('Configuration for SEO service');
+export function stripTags(str) {
+    return str.replace(/<\/?[^>]+>/g, '');
+}
+/**
+ * This service is responsible to keep up to date the page title and page description according
+ * to what is configured in routing or default values.
+ *
+ * It **must** be injected in the root module of the application to have effects in all modules. And it
+ * must be provided a configuration.
+ *
+ * The full title has the following structure:
+ *
+ *     page title - extra part - app name
+ */
+export class NaturalSeoService {
+    constructor(config, router, titleService, metaTagService) {
+        this.config = config;
+        this.router = router;
+        this.titleService = titleService;
+        this.metaTagService = metaTagService;
+        this.router.events.pipe(filter(event => event instanceof NavigationEnd)).subscribe(() => {
+            this.routeData = this.getRouteData(this.router.routerState.root.snapshot);
+            const seo = this.routeData.seo ?? { title: '' };
+            const basic = this.toBasic(seo);
+            this.update(basic);
+        });
+    }
+    /**
+     * Update the SEO with given info. The extra part and app name will be appended automatically.
+     *
+     * In most cases this should not be used, and instead the SEO should be configured in the routing,
+     * possibly with the callback variant for some dynamism.
+     *
+     * But in rare cases only the Component is able to build a proper page title, after it gather everything it
+     * needed. For those cases the Component can inject this service and update the SEO directly.
+     */
+    update(seo) {
+        // Title
+        const parts = [
+            seo.title,
+            this.config.extraPart && this.routeData ? this.config.extraPart(this.routeData) : null,
+            this.config.applicationName,
+        ];
+        const title = parts.filter(s => !!s).join(' - ');
+        this.titleService.setTitle(title);
+        // Description
+        const description = seo?.description ?? this.config.defaultDescription;
+        this.updateTag('description', description);
+        // Robots
+        const robots = seo?.robots ?? this.config.defaultRobots;
+        this.updateTag('robots', robots);
+    }
+    updateTag(name, value) {
+        if (value) {
+            this.metaTagService.updateTag({
+                name: name,
+                value: stripTags(value),
+            });
+        }
+        else {
+            this.metaTagService.removeTag(`name="${name}"`);
+        }
+    }
+    /**
+     * Returns the data from the most deep/specific activated route
+     */
+    getRouteData(route) {
+        if (route.firstChild) {
+            return this.getRouteData(route.firstChild);
+        }
+        else {
+            return route.data ?? null;
+        }
+    }
+    toBasic(seo) {
+        if (!this.routeData) {
+            throw new Error('Must have some route data to get basic SEO');
+        }
+        if (typeof seo === 'function') {
+            return seo(this.routeData);
+        }
+        else if ('resolveKey' in seo) {
+            const data = this.routeData[seo.resolveKey];
+            if (!data) {
+                throw new Error('Could not find resolved data for SEO service with key: ' + seo.resolveKey);
+            }
+            return {
+                title: data.model?.fullName ?? data.model?.name ?? '',
+                description: data.model?.description,
+                robots: seo.robots,
+            };
+        }
+        return seo;
+    }
+}
+NaturalSeoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalSeoService, deps: [{ token: NATURAL_SEO_CONFIG }, { token: i1.Router }, { token: i2.Title }, { token: i2.Meta }], target: i0.ɵɵFactoryTarget.Injectable });
+NaturalSeoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalSeoService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalSeoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NATURAL_SEO_CONFIG]
+                }] }, { type: i1.Router }, { type: i2.Title }, { type: i2.Meta }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"seo.service.js","sourceRoot":"","sources":["../../../../../../../projects/natural/src/lib/modules/common/services/seo.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, InjectionToken} from '@angular/core';\nimport {Meta, Title} from '@angular/platform-browser';\nimport {ActivatedRouteSnapshot, Data, NavigationEnd, Router} from '@angular/router';\nimport {filter} from 'rxjs/operators';\n\nexport type NaturalSeo = NaturalSeoBasic | NaturalSeoCallback | NaturalSeoResolve;\n\n/**\n * Typically used for \"static\" pages where there is not a single resolved object. So\n * all pages such as \"About\", or list of objects (list of risks, etc.).\n *\n * This should be the most common used variant.\n */\nexport type NaturalSeoBasic = Robots & {\n    /**\n     * The page title, that will be concatenated with application name\n     */\n    title: string;\n    /**\n     * If given will be used as page description, otherwise fallback on default value\n     */\n    description?: string;\n};\n\n/**\n * Typically used for a \"dynamic\" page where a single object is resolved. So a detail page, such\n * as the detail of a risk and so on.\n */\nexport type NaturalSeoResolve = Robots & {\n    /**\n     * The key to be used in the resolved data to find the resolved object. The fullName\n     * or name of the object will be used for page title, and the object description, if any,\n     * will be used for page description.\n     */\n    resolveKey: string;\n};\n\n/**\n * Rarely used for a page that has very specific needs and need to build title and description in a custom way.\n * The callback back will be given the resolved data, and it is up to the callback to find whatever it needs.\n */\nexport type NaturalSeoCallback = (routeData: Data) => NaturalSeoBasic;\n\ninterface Robots {\n    /**\n     * If given will be used as robots meta tag, otherwise fallback on default value\n     */\n    robots?: string;\n}\n\nexport interface NaturalSeoConfig {\n    /**\n     * The name of the application that will always appear in the page title\n     */\n    applicationName: string;\n\n    /**\n     * Default value for description meta that is used for pages without value\n     */\n    defaultDescription?: string;\n\n    /**\n     * Default value for robots meta that is used for pages without value\n     */\n    defaultRobots?: string;\n\n    /**\n     * If given, the callback will be called for each route and must return a string that will\n     * be inserted between the page title and the application name.\n     *\n     * It should be used to complete the title with info that are often, but not necessarily always,\n     * available throughout the entire application. Typically used for the site/state in OKpilot.\n     */\n    extraPart?: (routeData: Data) => string;\n}\n\nexport const NATURAL_SEO_CONFIG = new InjectionToken<NaturalSeoConfig>('Configuration for SEO service');\n\nexport function stripTags(str: string): string {\n    return str.replace(/<\\/?[^>]+>/g, '');\n}\n\ntype ResolvedData = {\n    model?: {\n        name?: string;\n        fullName?: string;\n        description?: string;\n    };\n};\n\n/**\n * This service is responsible to keep up to date the page title and page description according\n * to what is configured in routing or default values.\n *\n * It **must** be injected in the root module of the application to have effects in all modules. And it\n * must be provided a configuration.\n *\n * The full title has the following structure:\n *\n *     page title - extra part - app name\n */\n@Injectable({\n    providedIn: 'root',\n})\nexport class NaturalSeoService {\n    private routeData?: Data;\n\n    public constructor(\n        @Inject(NATURAL_SEO_CONFIG) private readonly config: NaturalSeoConfig,\n        private readonly router: Router,\n        private readonly titleService: Title,\n        private readonly metaTagService: Meta,\n    ) {\n        this.router.events.pipe(filter(event => event instanceof NavigationEnd)).subscribe(() => {\n            this.routeData = this.getRouteData(this.router.routerState.root.snapshot);\n            const seo: NaturalSeo = this.routeData.seo ?? {title: ''};\n            const basic = this.toBasic(seo);\n\n            this.update(basic);\n        });\n    }\n\n    /**\n     * Update the SEO with given info. The extra part and app name will be appended automatically.\n     *\n     * In most cases this should not be used, and instead the SEO should be configured in the routing,\n     * possibly with the callback variant for some dynamism.\n     *\n     * But in rare cases only the Component is able to build a proper page title, after it gather everything it\n     * needed. For those cases the Component can inject this service and update the SEO directly.\n     */\n    public update(seo: NaturalSeoBasic): void {\n        // Title\n        const parts = [\n            seo.title,\n            this.config.extraPart && this.routeData ? this.config.extraPart(this.routeData) : null,\n            this.config.applicationName,\n        ];\n\n        const title = parts.filter(s => !!s).join(' - ');\n        this.titleService.setTitle(title);\n\n        // Description\n        const description = seo?.description ?? this.config.defaultDescription;\n        this.updateTag('description', description);\n\n        // Robots\n        const robots = seo?.robots ?? this.config.defaultRobots;\n        this.updateTag('robots', robots);\n    }\n\n    private updateTag(name: string, value?: string): void {\n        if (value) {\n            this.metaTagService.updateTag({\n                name: name,\n                value: stripTags(value),\n            });\n        } else {\n            this.metaTagService.removeTag(`name=\"${name}\"`);\n        }\n    }\n\n    /**\n     * Returns the data from the most deep/specific activated route\n     */\n    private getRouteData(route: ActivatedRouteSnapshot): Data {\n        if (route.firstChild) {\n            return this.getRouteData(route.firstChild);\n        } else {\n            return route.data ?? null;\n        }\n    }\n\n    private toBasic(seo: NaturalSeo): NaturalSeoBasic {\n        if (!this.routeData) {\n            throw new Error('Must have some route data to get basic SEO');\n        }\n\n        if (typeof seo === 'function') {\n            return seo(this.routeData);\n        } else if ('resolveKey' in seo) {\n            const data: ResolvedData | undefined = this.routeData[seo.resolveKey];\n            if (!data) {\n                throw new Error('Could not find resolved data for SEO service with key: ' + seo.resolveKey);\n            }\n\n            return {\n                title: data.model?.fullName ?? data.model?.name ?? '',\n                description: data.model?.description,\n                robots: seo.robots,\n            };\n        }\n\n        return seo;\n    }\n}\n"]}