@ecodev/natural 41.3.0 → 42.2.0

package/esm2020/lib/modules/columns-picker/columns-picker.module.mjs

@@ -0,0 +1,47 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatMenuModule } from '@angular/material/menu';
+import { NaturalIconModule } from '../icon/icon.module';
+import { NaturalColumnsPickerColumnDirective } from './columns-picker-column.directive';
+import { NaturalColumnsPickerComponent } from './columns-picker.component';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import * as i0 from "@angular/core";
+export class NaturalColumnsPickerModule {
+}
+NaturalColumnsPickerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalColumnsPickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NaturalColumnsPickerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalColumnsPickerModule, declarations: [NaturalColumnsPickerColumnDirective, NaturalColumnsPickerComponent], imports: [CommonModule,
+        FormsModule,
+        MatMenuModule,
+        MatButtonModule,
+        MatCheckboxModule,
+        NaturalIconModule,
+        MatTooltipModule], exports: [NaturalColumnsPickerColumnDirective, NaturalColumnsPickerComponent] });
+NaturalColumnsPickerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalColumnsPickerModule, imports: [[
+            CommonModule,
+            FormsModule,
+            MatMenuModule,
+            MatButtonModule,
+            MatCheckboxModule,
+            NaturalIconModule,
+            MatTooltipModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalColumnsPickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [NaturalColumnsPickerColumnDirective, NaturalColumnsPickerComponent],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        MatMenuModule,
+                        MatButtonModule,
+                        MatCheckboxModule,
+                        NaturalIconModule,
+                        MatTooltipModule,
+                    ],
+                    exports: [NaturalColumnsPickerColumnDirective, NaturalColumnsPickerComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,50 @@
+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 { 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,
+    NaturalHttpPrefixDirective,
+    NaturalSrcDensityDirective,
+    NaturalLinkableTabDirective,
+];
+export class NaturalCommonModule {
+}
+NaturalCommonModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NaturalCommonModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalCommonModule, declarations: [NaturalCapitalizePipe,
+        NaturalEllipsisPipe,
+        NaturalEnumPipe,
+        NaturalSwissDatePipe,
+        NaturalHttpPrefixDirective,
+        NaturalSrcDensityDirective,
+        NaturalLinkableTabDirective], imports: [CommonModule, MatFormFieldModule, MatInputModule, MatSelectModule], exports: [NaturalCapitalizePipe,
+        NaturalEllipsisPipe,
+        NaturalEnumPipe,
+        NaturalSwissDatePipe,
+        NaturalHttpPrefixDirective,
+        NaturalSrcDensityDirective,
+        NaturalLinkableTabDirective] });
+NaturalCommonModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalCommonModule, providers: [sessionStorageProvider, localStorageProvider], imports: [[CommonModule, MatFormFieldModule, MatInputModule, MatSelectModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", 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.3.0", 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.3.0", type: NaturalLinkableTabDirective, selector: "mat-tab-group[naturalLinkableTab]", inputs: { naturalLinkableTab: "naturalLinkableTab" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", 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/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.3.0", ngImport: i0, type: NaturalSrcDensityDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+NaturalSrcDensityDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: NaturalSrcDensityDirective, selector: "img[naturalSrcDensity]", inputs: { naturalSrcDensity: "naturalSrcDensity" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", 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.3.0", ngImport: i0, type: NaturalCapitalizePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NaturalCapitalizePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalCapitalizePipe, name: "capitalize" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", 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.3.0", ngImport: i0, type: NaturalEllipsisPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NaturalEllipsisPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalEllipsisPipe, name: "ellipsis" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", 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.3.0", ngImport: i0, type: NaturalEnumPipe, deps: [{ token: i1.NaturalEnumService }], target: i0.ɵɵFactoryTarget.Pipe });
+NaturalEnumPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalEnumPipe, name: "enum" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", 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.3.0", ngImport: i0, type: NaturalSwissDatePipe, deps: null, target: i0.ɵɵFactoryTarget.Pipe });
+NaturalSwissDatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalSwissDatePipe, name: "swissDate" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalSwissDatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'swissDate',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dpc3MtZGF0ZS5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmF0dXJhbC9zcmMvbGliL21vZHVsZXMvY29tbW9uL3BpcGVzL3N3aXNzLWRhdGUucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsSUFBSSxFQUFnQixNQUFNLGVBQWUsQ0FBQztBQUNsRCxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0saUJBQWlCLENBQUM7O0FBRXpDOztHQUVHO0FBSUgsTUFBTSxPQUFPLG9CQUFxQixTQUFRLFFBQVE7SUFRdkMsU0FBUyxDQUNaLEtBQWdELEVBQ2hELE1BQU0sR0FBRyxlQUFlLEVBQ3hCLFFBQWlCLEVBQ2pCLE1BQWU7UUFFZixPQUFPLEtBQUssQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDNUQsQ0FBQzs7aUhBZlEsb0JBQW9COytHQUFwQixvQkFBb0I7MkZBQXBCLG9CQUFvQjtrQkFIaEMsSUFBSTttQkFBQztvQkFDRixJQUFJLEVBQUUsV0FBVztpQkFDcEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1BpcGUsIFBpcGVUcmFuc2Zvcm19IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtEYXRlUGlwZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcblxuLyoqXG4gKiBBIG5vcm1hbCBEYXRlUGlwZSBidXQgd2l0aCBkZWZhdWx0IGZvcm1hdHRpbmcgdG8gYmUgJzEyLjI0LjIwMjAgMjM6MzAnIHRvIG1hdGNoIHRoZSBtb3N0IGNvbW1vbiB1c2UtY2FzZXNcbiAqL1xuQFBpcGUoe1xuICAgIG5hbWU6ICdzd2lzc0RhdGUnLFxufSlcbmV4cG9ydCBjbGFzcyBOYXR1cmFsU3dpc3NEYXRlUGlwZSBleHRlbmRzIERhdGVQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gICAgcHVibGljIHRyYW5zZm9ybSh2YWx1ZTogbnVsbCB8IHVuZGVmaW5lZCwgZm9ybWF0Pzogc3RyaW5nLCB0aW1lem9uZT86IHN0cmluZywgbG9jYWxlPzogc3RyaW5nKTogbnVsbDtcbiAgICBwdWJsaWMgdHJhbnNmb3JtKFxuICAgICAgICB2YWx1ZTogRGF0ZSB8IHN0cmluZyB8IG51bWJlciB8IG51bGwgfCB1bmRlZmluZWQsXG4gICAgICAgIGZvcm1hdD86IHN0cmluZyxcbiAgICAgICAgdGltZXpvbmU/OiBzdHJpbmcsXG4gICAgICAgIGxvY2FsZT86IHN0cmluZyxcbiAgICApOiBzdHJpbmcgfCBudWxsO1xuICAgIHB1YmxpYyB0cmFuc2Zvcm0oXG4gICAgICAgIHZhbHVlOiBEYXRlIHwgc3RyaW5nIHwgbnVtYmVyIHwgbnVsbCB8IHVuZGVmaW5lZCxcbiAgICAgICAgZm9ybWF0ID0gJ2RkLk1NLnkgSEg6bW0nLFxuICAgICAgICB0aW1lem9uZT86IHN0cmluZyxcbiAgICAgICAgbG9jYWxlPzogc3RyaW5nLFxuICAgICk6IHN0cmluZyB8IG51bGwge1xuICAgICAgICByZXR1cm4gc3VwZXIudHJhbnNmb3JtKHZhbHVlLCBmb3JtYXQsIHRpbWV6b25lLCBsb2NhbGUpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/lib/modules/common/public-api.mjs

@@ -0,0 +1,13 @@
+/*
+ * Public API Surface of natural
+ */
+export * from './common-module';
+export * from './directives/linkable-tab.directive';
+export * from './pipes/capitalize.pipe';
+export * from './pipes/ellipsis.pipe';
+export * from './pipes/enum.pipe';
+export * from './pipes/swiss-date.pipe';
+export * from './services/memory-storage';
+export { NaturalSrcDensityDirective } from './directives/src-density.directive';
+export { NATURAL_SEO_CONFIG, NaturalSeoService, } from './services/seo.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25hdHVyYWwvc3JjL2xpYi9tb2R1bGVzL2NvbW1vbi9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxPQUFPLEVBQUMsMEJBQTBCLEVBQUMsTUFBTSxvQ0FBb0MsQ0FBQztBQUM5RSxPQUFPLEVBQ0gsa0JBQWtCLEVBRWxCLGlCQUFpQixHQUtwQixNQUFNLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuYXR1cmFsXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9jb21tb24tbW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcy9saW5rYWJsZS10YWIuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vcGlwZXMvY2FwaXRhbGl6ZS5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vcGlwZXMvZWxsaXBzaXMucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3BpcGVzL2VudW0ucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3BpcGVzL3N3aXNzLWRhdGUucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL21lbW9yeS1zdG9yYWdlJztcbmV4cG9ydCB7TmF0dXJhbFNyY0RlbnNpdHlEaXJlY3RpdmV9IGZyb20gJy4vZGlyZWN0aXZlcy9zcmMtZGVuc2l0eS5kaXJlY3RpdmUnO1xuZXhwb3J0IHtcbiAgICBOQVRVUkFMX1NFT19DT05GSUcsXG4gICAgTmF0dXJhbFNlb0NvbmZpZyxcbiAgICBOYXR1cmFsU2VvU2VydmljZSxcbiAgICBOYXR1cmFsU2VvLFxuICAgIE5hdHVyYWxTZW9CYXNpYyxcbiAgICBOYXR1cmFsU2VvUmVzb2x2ZSxcbiAgICBOYXR1cmFsU2VvQ2FsbGJhY2ssXG59IGZyb20gJy4vc2VydmljZXMvc2VvLnNlcnZpY2UnO1xuIl19

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.3.0", ngImport: i0, type: NaturalMemoryStorage, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NaturalMemoryStorage.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalMemoryStorage, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", 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"]}