@ecodev/natural 41.3.0 → 42.0.0

package/esm2020/lib/modules/alert/confirm.component.mjs

@@ -0,0 +1,20 @@
+import { Component, Inject } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/button";
+import * as i2 from "@angular/material/dialog";
+export class NaturalConfirmComponent {
+    constructor(data) {
+        this.data = data;
+    }
+}
+NaturalConfirmComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalConfirmComponent, deps: [{ token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component });
+NaturalConfirmComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: NaturalConfirmComponent, selector: "ng-component", ngImport: i0, template: "<h2 mat-dialog-title>{{ data.title }}</h2>\n<mat-dialog-content\n    ><p class=\"mat-body\">{{ data.message }}</p></mat-dialog-content\n>\n<mat-dialog-actions>\n    <button [mat-dialog-close]=\"false\" mat-button>{{ data.cancelText }}</button>\n    <button [mat-dialog-close]=\"true\" mat-stroked-button cdkFocusInitial>{{ data.confirmText }}</button>\n</mat-dialog-actions>\n", styles: ["mat-dialog-content{max-width:40em}mat-dialog-actions{display:flex;justify-content:flex-end}mat-dialog-actions>*{margin-left:10px}\n"], components: [{ type: i1.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }], directives: [{ type: i2.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { type: i2.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { type: i2.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]" }, { type: i2.MatDialogClose, selector: "[mat-dialog-close], [matDialogClose]", inputs: ["aria-label", "type", "mat-dialog-close", "matDialogClose"], exportAs: ["matDialogClose"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalConfirmComponent, decorators: [{
+            type: Component,
+            args: [{ template: "<h2 mat-dialog-title>{{ data.title }}</h2>\n<mat-dialog-content\n    ><p class=\"mat-body\">{{ data.message }}</p></mat-dialog-content\n>\n<mat-dialog-actions>\n    <button [mat-dialog-close]=\"false\" mat-button>{{ data.cancelText }}</button>\n    <button [mat-dialog-close]=\"true\" mat-stroked-button cdkFocusInitial>{{ data.confirmText }}</button>\n</mat-dialog-actions>\n", styles: ["mat-dialog-content{max-width:40em}mat-dialog-actions{display:flex;justify-content:flex-end}mat-dialog-actions>*{margin-left:10px}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlybS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uYXR1cmFsL3NyYy9saWIvbW9kdWxlcy9hbGVydC9jb25maXJtLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25hdHVyYWwvc3JjL2xpYi9tb2R1bGVzL2FsZXJ0L2NvbmZpcm0uY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSxNQUFNLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDaEQsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLDBCQUEwQixDQUFDOzs7O0FBYXpELE1BQU0sT0FBTyx1QkFBdUI7SUFDaEMsWUFBbUQsSUFBd0I7UUFBeEIsU0FBSSxHQUFKLElBQUksQ0FBb0I7SUFBRyxDQUFDOztvSEFEdEUsdUJBQXVCLGtCQUNMLGVBQWU7d0dBRGpDLHVCQUF1QixvRENkcEMsMFhBUUE7MkZETWEsdUJBQXVCO2tCQUpuQyxTQUFTOzs7MEJBS2MsTUFBTTsyQkFBQyxlQUFlIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDb21wb25lbnQsIEluamVjdH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge01BVF9ESUFMT0dfREFUQX0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvZGlhbG9nJztcblxuZXhwb3J0IGludGVyZmFjZSBOYXR1cmFsQ29uZmlybURhdGEge1xuICAgIHRpdGxlOiBzdHJpbmc7XG4gICAgbWVzc2FnZTogc3RyaW5nO1xuICAgIGNvbmZpcm1UZXh0OiBzdHJpbmc7XG4gICAgY2FuY2VsVGV4dDogc3RyaW5nO1xufVxuXG5AQ29tcG9uZW50KHtcbiAgICB0ZW1wbGF0ZVVybDogJy4vY29uZmlybS5jb21wb25lbnQuaHRtbCcsXG4gICAgc3R5bGVVcmxzOiBbJy4vY29uZmlybS5jb21wb25lbnQuc2NzcyddLFxufSlcbmV4cG9ydCBjbGFzcyBOYXR1cmFsQ29uZmlybUNvbXBvbmVudCB7XG4gICAgcHVibGljIGNvbnN0cnVjdG9yKEBJbmplY3QoTUFUX0RJQUxPR19EQVRBKSBwdWJsaWMgZGF0YTogTmF0dXJhbENvbmZpcm1EYXRhKSB7fVxufVxuIiwiPGgyIG1hdC1kaWFsb2ctdGl0bGU+e3sgZGF0YS50aXRsZSB9fTwvaDI+XG48bWF0LWRpYWxvZy1jb250ZW50XG4gICAgPjxwIGNsYXNzPVwibWF0LWJvZHlcIj57eyBkYXRhLm1lc3NhZ2UgfX08L3A+PC9tYXQtZGlhbG9nLWNvbnRlbnRcbj5cbjxtYXQtZGlhbG9nLWFjdGlvbnM+XG4gICAgPGJ1dHRvbiBbbWF0LWRpYWxvZy1jbG9zZV09XCJmYWxzZVwiIG1hdC1idXR0b24+e3sgZGF0YS5jYW5jZWxUZXh0IH19PC9idXR0b24+XG4gICAgPGJ1dHRvbiBbbWF0LWRpYWxvZy1jbG9zZV09XCJ0cnVlXCIgbWF0LXN0cm9rZWQtYnV0dG9uIGNka0ZvY3VzSW5pdGlhbD57eyBkYXRhLmNvbmZpcm1UZXh0IH19PC9idXR0b24+XG48L21hdC1kaWFsb2ctYWN0aW9ucz5cbiJdfQ==

package/esm2020/lib/modules/avatar/avatar.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { AvatarComponent } from './component/avatar.component';
+import * as i0 from "@angular/core";
+const declarations = [AvatarComponent];
+export class NaturalAvatarModule {
+}
+NaturalAvatarModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalAvatarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NaturalAvatarModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalAvatarModule, declarations: [AvatarComponent], imports: [CommonModule], exports: [AvatarComponent] });
+NaturalAvatarModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalAvatarModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalAvatarModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: declarations,
+                    exports: declarations,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZhdGFyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25hdHVyYWwvc3JjL2xpYi9tb2R1bGVzL2F2YXRhci9hdmF0YXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQzdDLE9BQU8sRUFBQyxlQUFlLEVBQUMsTUFBTSw4QkFBOEIsQ0FBQzs7QUFFN0QsTUFBTSxZQUFZLEdBQUcsQ0FBQyxlQUFlLENBQUMsQ0FBQztBQU92QyxNQUFNLE9BQU8sbUJBQW1COztnSEFBbkIsbUJBQW1CO2lIQUFuQixtQkFBbUIsaUJBUFYsZUFBZSxhQUd2QixZQUFZLGFBSEosZUFBZTtpSEFPeEIsbUJBQW1CLFlBSm5CLENBQUMsWUFBWSxDQUFDOzJGQUlkLG1CQUFtQjtrQkFML0IsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7b0JBQ3ZCLFlBQVksRUFBRSxZQUFZO29CQUMxQixPQUFPLEVBQUUsWUFBWTtpQkFDeEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7Q29tbW9uTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHtBdmF0YXJDb21wb25lbnR9IGZyb20gJy4vY29tcG9uZW50L2F2YXRhci5jb21wb25lbnQnO1xuXG5jb25zdCBkZWNsYXJhdGlvbnMgPSBbQXZhdGFyQ29tcG9uZW50XTtcblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbiAgICBkZWNsYXJhdGlvbnM6IGRlY2xhcmF0aW9ucyxcbiAgICBleHBvcnRzOiBkZWNsYXJhdGlvbnMsXG59KVxuZXhwb3J0IGNsYXNzIE5hdHVyYWxBdmF0YXJNb2R1bGUge31cbiJdfQ==

package/esm2020/lib/modules/avatar/component/avatar.component.mjs

@@ -0,0 +1,187 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../service/avatar.service";
+import * as i2 from "@angular/common";
+/**
+ * Show an avatar from different sources
+ */
+export class AvatarComponent {
+    constructor(avatarService) {
+        this.avatarService = avatarService;
+        this.size = 50;
+        this.textSizeRatio = 3;
+        this.fgColor = '#FFF';
+        this.borderRadius = '';
+        this.textMaximumLength = 0;
+        this.avatarSrc = null;
+        this.avatarText = null;
+        this.avatarStyle = {};
+        this.hostStyle = {};
+        this.currentIndex = -1;
+        this.sources = [];
+    }
+    /**
+     * Detect inputs change
+     */
+    ngOnChanges(changes) {
+        this.sources.length = 0;
+        for (const [propName, creator] of this.avatarService.getCreators()) {
+            if (!changes[propName]) {
+                continue;
+            }
+            const currentValue = changes[propName].currentValue;
+            if (currentValue && typeof currentValue === 'string') {
+                this.sources.push(new creator(currentValue));
+            }
+        }
+        // reinitialize the avatar component when a source property value has changed
+        // the fallback system must be re-invoked with the new values.
+        this.initializeAvatar();
+    }
+    /**
+     * Fetch avatar source
+     */
+    tryNextSource() {
+        const previousSource = this.sources[this.currentIndex];
+        if (previousSource) {
+            this.avatarService.markSourceAsFailed(previousSource);
+        }
+        const source = this.findNextSource();
+        if (!source) {
+            return;
+        }
+        if (source.isTextual()) {
+            this.buildTextAvatar(source);
+            this.avatarSrc = null;
+        }
+        else {
+            this.buildImageAvatar(source);
+        }
+    }
+    findNextSource() {
+        while (++this.currentIndex < this.sources.length) {
+            const source = this.sources[this.currentIndex];
+            if (source && !this.avatarService.sourceHasFailedBefore(source)) {
+                return source;
+            }
+        }
+        return null;
+    }
+    /**
+     * Initialize the avatar component and its fallback system
+     */
+    initializeAvatar() {
+        this.currentIndex = -1;
+        if (this.sources.length > 0) {
+            this.tryNextSource();
+            this.hostStyle = {
+                width: this.size + 'px',
+                height: this.size + 'px',
+            };
+        }
+    }
+    buildTextAvatar(avatarSource) {
+        this.avatarText = avatarSource.getAvatar(+this.textMaximumLength);
+        this.avatarStyle = this.getTextualStyle(avatarSource.getValue());
+    }
+    buildImageAvatar(avatarSource) {
+        this.avatarStyle = this.getImageStyle();
+        this.avatarSrc = avatarSource.getAvatar(+this.size);
+    }
+    /**
+     * Returns initials style
+     */
+    getTextualStyle(avatarValue) {
+        return {
+            textAlign: 'center',
+            borderRadius: this.borderRadius || '100%',
+            textTransform: 'uppercase',
+            color: this.fgColor,
+            backgroundColor: this.bgColor ? this.bgColor : this.avatarService.getRandomColor(avatarValue),
+            font: Math.floor(+this.size / this.textSizeRatio) + 'px Helvetica, Arial, sans-serif',
+            lineHeight: this.size + 'px',
+        };
+    }
+    /**
+     * Returns image style
+     */
+    getImageStyle() {
+        return {
+            maxWidth: '100%',
+            borderRadius: this.borderRadius || '100%',
+            width: this.size + 'px',
+            height: this.size + 'px',
+        };
+    }
+}
+AvatarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: AvatarComponent, deps: [{ token: i1.AvatarService }], target: i0.ɵɵFactoryTarget.Component });
+AvatarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: AvatarComponent, selector: "natural-avatar", inputs: { image: "image", initials: "initials", gravatar: "gravatar", size: "size", textSizeRatio: "textSizeRatio", bgColor: "bgColor", fgColor: "fgColor", borderRadius: "borderRadius", textMaximumLength: "textMaximumLength" }, usesOnChanges: true, ngImport: i0, template: `
+        <div class="avatar-container" [ngStyle]="hostStyle">
+            <img
+                *ngIf="avatarSrc; else textAvatar"
+                [src]="avatarSrc"
+                [width]="size"
+                [height]="size"
+                [ngStyle]="avatarStyle"
+                (error)="tryNextSource()"
+                class="avatar-content"
+                loading="lazy"
+            />
+            <ng-template #textAvatar>
+                <div *ngIf="avatarText" class="avatar-content" [ngStyle]="avatarStyle">
+                    {{ avatarText }}
+                </div>
+            </ng-template>
+        </div>
+    `, isInline: true, styles: [":host{border-radius:50%}\n"], directives: [{ type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: AvatarComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'natural-avatar',
+                    styles: [
+                        `
+            :host {
+                border-radius: 50%;
+            }
+        `,
+                    ],
+                    template: `
+        <div class="avatar-container" [ngStyle]="hostStyle">
+            <img
+                *ngIf="avatarSrc; else textAvatar"
+                [src]="avatarSrc"
+                [width]="size"
+                [height]="size"
+                [ngStyle]="avatarStyle"
+                (error)="tryNextSource()"
+                class="avatar-content"
+                loading="lazy"
+            />
+            <ng-template #textAvatar>
+                <div *ngIf="avatarText" class="avatar-content" [ngStyle]="avatarStyle">
+                    {{ avatarText }}
+                </div>
+            </ng-template>
+        </div>
+    `,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AvatarService }]; }, propDecorators: { image: [{
+                type: Input
+            }], initials: [{
+                type: Input
+            }], gravatar: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], textSizeRatio: [{
+                type: Input
+            }], bgColor: [{
+                type: Input
+            }], fgColor: [{
+                type: Input
+            }], borderRadius: [{
+                type: Input
+            }], textMaximumLength: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"avatar.component.js","sourceRoot":"","sources":["../../../../../../../projects/natural/src/lib/modules/avatar/component/avatar.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, Input, OnChanges, SimpleChanges} from '@angular/core';\n\nimport {Source} from '../sources/source';\nimport {AvatarService} from '../service/avatar.service';\n\ntype Style = Partial<CSSStyleDeclaration>;\n\n/**\n * Show an avatar from different sources\n */\n@Component({\n    selector: 'natural-avatar',\n    styles: [\n        `\n            :host {\n                border-radius: 50%;\n            }\n        `,\n    ],\n    template: `\n        <div class=\"avatar-container\" [ngStyle]=\"hostStyle\">\n            <img\n                *ngIf=\"avatarSrc; else textAvatar\"\n                [src]=\"avatarSrc\"\n                [width]=\"size\"\n                [height]=\"size\"\n                [ngStyle]=\"avatarStyle\"\n                (error)=\"tryNextSource()\"\n                class=\"avatar-content\"\n                loading=\"lazy\"\n            />\n            <ng-template #textAvatar>\n                <div *ngIf=\"avatarText\" class=\"avatar-content\" [ngStyle]=\"avatarStyle\">\n                    {{ avatarText }}\n                </div>\n            </ng-template>\n        </div>\n    `,\n})\nexport class AvatarComponent implements OnChanges {\n    @Input() public image?: string | null;\n    @Input() public initials?: string | null;\n    @Input() public gravatar?: string | null;\n\n    @Input() public size = 50;\n    @Input() public textSizeRatio = 3;\n    @Input() public bgColor: string | undefined;\n    @Input() public fgColor = '#FFF';\n    @Input() public borderRadius = '';\n    @Input() public textMaximumLength = 0;\n\n    public avatarSrc: string | null = null;\n    public avatarText: string | null = null;\n    public avatarStyle: Style = {};\n    public hostStyle: Style = {};\n\n    private currentIndex = -1;\n    private sources: Source[] = [];\n\n    public constructor(private readonly avatarService: AvatarService) {}\n\n    /**\n     * Detect inputs change\n     */\n    public ngOnChanges(changes: SimpleChanges): void {\n        this.sources.length = 0;\n        for (const [propName, creator] of this.avatarService.getCreators()) {\n            if (!changes[propName]) {\n                continue;\n            }\n\n            const currentValue = changes[propName].currentValue;\n            if (currentValue && typeof currentValue === 'string') {\n                this.sources.push(new creator(currentValue));\n            }\n        }\n\n        // reinitialize the avatar component when a source property value has changed\n        // the fallback system must be re-invoked with the new values.\n        this.initializeAvatar();\n    }\n\n    /**\n     * Fetch avatar source\n     */\n    public tryNextSource(): void {\n        const previousSource = this.sources[this.currentIndex];\n        if (previousSource) {\n            this.avatarService.markSourceAsFailed(previousSource);\n        }\n\n        const source = this.findNextSource();\n        if (!source) {\n            return;\n        }\n\n        if (source.isTextual()) {\n            this.buildTextAvatar(source);\n            this.avatarSrc = null;\n        } else {\n            this.buildImageAvatar(source);\n        }\n    }\n\n    private findNextSource(): Source | null {\n        while (++this.currentIndex < this.sources.length) {\n            const source = this.sources[this.currentIndex];\n            if (source && !this.avatarService.sourceHasFailedBefore(source)) {\n                return source;\n            }\n        }\n\n        return null;\n    }\n\n    /**\n     * Initialize the avatar component and its fallback system\n     */\n    private initializeAvatar(): void {\n        this.currentIndex = -1;\n        if (this.sources.length > 0) {\n            this.tryNextSource();\n            this.hostStyle = {\n                width: this.size + 'px',\n                height: this.size + 'px',\n            };\n        }\n    }\n\n    private buildTextAvatar(avatarSource: Source): void {\n        this.avatarText = avatarSource.getAvatar(+this.textMaximumLength);\n        this.avatarStyle = this.getTextualStyle(avatarSource.getValue());\n    }\n\n    private buildImageAvatar(avatarSource: Source): void {\n        this.avatarStyle = this.getImageStyle();\n        this.avatarSrc = avatarSource.getAvatar(+this.size);\n    }\n\n    /**\n     * Returns initials style\n     */\n    private getTextualStyle(avatarValue: string): Style {\n        return {\n            textAlign: 'center',\n            borderRadius: this.borderRadius || '100%',\n            textTransform: 'uppercase',\n            color: this.fgColor,\n            backgroundColor: this.bgColor ? this.bgColor : this.avatarService.getRandomColor(avatarValue),\n            font: Math.floor(+this.size / this.textSizeRatio) + 'px Helvetica, Arial, sans-serif',\n            lineHeight: this.size + 'px',\n        };\n    }\n\n    /**\n     * Returns image style\n     */\n    private getImageStyle(): Style {\n        return {\n            maxWidth: '100%',\n            borderRadius: this.borderRadius || '100%',\n            width: this.size + 'px',\n            height: this.size + 'px',\n        };\n    }\n}\n"]}

package/esm2020/lib/modules/avatar/service/avatar.service.mjs

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import { Gravatar } from '../sources/gravatar';
+import { Initials } from '../sources/initials';
+import { Image } from '../sources/image';
+import * as i0 from "@angular/core";
+/**
+ * Provides utilities methods related to Avatar component
+ */
+export class AvatarService {
+    constructor() {
+        /**
+         * Ordered pairs of possible sources. First in list is the highest priority.
+         * And key must match one the input of AvatarComponent.
+         */
+        this.sourceCreators = new Map([
+            ['gravatar', Gravatar],
+            ['image', Image],
+            ['initials', Initials],
+        ]);
+        this.avatarColors = [
+            '#1abc9c',
+            '#3498db',
+            '#f1c40f',
+            '#8e44ad',
+            '#e74c3c',
+            '#d35400',
+            '#2c3e50',
+            '#7f8c8d',
+        ];
+        this.failedSources = new Map();
+    }
+    getRandomColor(avatarText) {
+        if (!avatarText) {
+            return 'transparent';
+        }
+        const asciiCodeSum = this.calculateAsciiCode(avatarText);
+        return this.avatarColors[asciiCodeSum % this.avatarColors.length];
+    }
+    getCreators() {
+        return this.sourceCreators.entries();
+    }
+    getSourceKey(source) {
+        return source.constructor.name + '-' + source.getValue();
+    }
+    sourceHasFailedBefore(source) {
+        return this.failedSources.has(this.getSourceKey(source));
+    }
+    markSourceAsFailed(source) {
+        this.failedSources.set(this.getSourceKey(source), source);
+    }
+    calculateAsciiCode(value) {
+        return value
+            .split('')
+            .map(letter => letter.charCodeAt(0))
+            .reduce((previous, current) => previous + current);
+    }
+}
+AvatarService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: AvatarService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AvatarService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: AvatarService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: AvatarService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/avatar/sources/gravatar.mjs

@@ -0,0 +1,29 @@
+import { Md5 } from 'ts-md5';
+import { Source } from './source';
+function isRetina() {
+    // We cannot reasonably inject `DOCUMENT` here, but we are extra
+    // careful about usage of `window` and its possible non-existence in SSR,
+    // so we should be fine.
+    // eslint-disable-next-line no-restricted-globals
+    const myWindow = window;
+    if (myWindow?.devicePixelRatio > 1.25) {
+        return true;
+    }
+    const mediaQuery = '(-webkit-min-device-pixel-ratio: 1.25), (min--moz-device-pixel-ratio: 1.25), (-o-min-device-pixel-ratio: 5/4), (min-resolution: 1.25dppx)';
+    return !!myWindow?.matchMedia(mediaQuery).matches;
+}
+/**
+ * Return URL to Gravatar image from either an email or a MD5
+ */
+export class Gravatar extends Source {
+    getAvatar(size) {
+        const value = this.getValue();
+        const md5 = value.match('^[a-f0-9]{32}$') ? value : Md5.hashStr(value.trim().toLowerCase()).toString();
+        const avatarSize = isRetina() ? size * 2 : size;
+        return `https://secure.gravatar.com/avatar/${md5}?s=${avatarSize}&d=404`;
+    }
+    isTextual() {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/modules/avatar/sources/source.js → esm2020/lib/modules/avatar/sources/source.mjs}

@@ -12,4 +12,4 @@ export class Source {
         return this.value;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic291cmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmF0dXJhbC9zcmMvbGliL21vZHVsZXMvYXZhdGFyL3NvdXJjZXMvc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBOzs7O0dBSUc7QUFDSCxNQUFNLE9BQWdCLE1BQU07SUFDeEIsWUFBNkIsS0FBYTtRQUFiLFVBQUssR0FBTCxLQUFLLENBQVE7UUFDdEMsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7SUFDdkIsQ0FBQztJQUVNLFFBQVE7UUFDWCxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUM7SUFDdEIsQ0FBQztDQVlKIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBBIGNyZWF0b3IgaW50ZXJmYWNlIHVzZWQgdG8gaW5zdGFudGlhdGUgc291cmNlIGltcGxlbWVudGF0aW9uXG4gKi9cbmV4cG9ydCB0eXBlIFNvdXJjZUNyZWF0b3IgPSBuZXcgKHNvdXJjZVZhbHVlOiBzdHJpbmcpID0+IFNvdXJjZTtcblxuLyoqXG4gKiBDb250cmFjdCBvZiBhbGwgU291cmNlcy5cbiAqIEV2ZXJ5IHNvdXJjZSBtdXN0IGltcGxlbWVudHMgdGhlIGZldGNoIG1ldGhvZFxuICogaW4gb3JkZXIgdG8gcHJvdmlkZSB0aGUgYXZhdGFyIHNvdXJjZS5cbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIFNvdXJjZSB7XG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSB2YWx1ZTogc3RyaW5nKSB7XG4gICAgICAgIHRoaXMudmFsdWUgPSB2YWx1ZTtcbiAgICB9XG5cbiAgICBwdWJsaWMgZ2V0VmFsdWUoKTogc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIHRoaXMudmFsdWU7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogR2V0cyB0aGUgYXZhdGFyIHRoYXQgdXN1YWxseSBpcyBhIFVSTCwgYnV0LFxuICAgICAqIGZvciBleGFtcGxlIGl0IGNhbiBhbHNvIGJlIGEgc3RyaW5nIG9mIGluaXRpYWxzIGZyb20gdGhlIG5hbWUuXG4gICAgICovXG4gICAgcHVibGljIGFic3RyYWN0IGdldEF2YXRhcihzaXplOiBudW1iZXIpOiBzdHJpbmc7XG5cbiAgICAvKipcbiAgICAgKiBXaGV0aGVyIHRoZSBhdmF0YXIgaXMgcHVyZWx5IHRleHR1YWwgb3IgYW4gVVJMIGZvciBhbiBpbWFnZVxuICAgICAqL1xuICAgIHB1YmxpYyBhYnN0cmFjdCBpc1RleHR1YWwoKTogYm9vbGVhbjtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic291cmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmF0dXJhbC9zcmMvbGliL21vZHVsZXMvYXZhdGFyL3NvdXJjZXMvc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBOzs7O0dBSUc7QUFDSCxNQUFNLE9BQWdCLE1BQU07SUFDeEIsWUFBb0MsS0FBYTtRQUFiLFVBQUssR0FBTCxLQUFLLENBQVE7UUFDN0MsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7SUFDdkIsQ0FBQztJQUVNLFFBQVE7UUFDWCxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUM7SUFDdEIsQ0FBQztDQVlKIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBBIGNyZWF0b3IgaW50ZXJmYWNlIHVzZWQgdG8gaW5zdGFudGlhdGUgc291cmNlIGltcGxlbWVudGF0aW9uXG4gKi9cbmV4cG9ydCB0eXBlIFNvdXJjZUNyZWF0b3IgPSBuZXcgKHNvdXJjZVZhbHVlOiBzdHJpbmcpID0+IFNvdXJjZTtcblxuLyoqXG4gKiBDb250cmFjdCBvZiBhbGwgU291cmNlcy5cbiAqIEV2ZXJ5IHNvdXJjZSBtdXN0IGltcGxlbWVudHMgdGhlIGZldGNoIG1ldGhvZFxuICogaW4gb3JkZXIgdG8gcHJvdmlkZSB0aGUgYXZhdGFyIHNvdXJjZS5cbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIFNvdXJjZSB7XG4gICAgcHVibGljIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgdmFsdWU6IHN0cmluZykge1xuICAgICAgICB0aGlzLnZhbHVlID0gdmFsdWU7XG4gICAgfVxuXG4gICAgcHVibGljIGdldFZhbHVlKCk6IHN0cmluZyB7XG4gICAgICAgIHJldHVybiB0aGlzLnZhbHVlO1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIEdldHMgdGhlIGF2YXRhciB0aGF0IHVzdWFsbHkgaXMgYSBVUkwsIGJ1dCxcbiAgICAgKiBmb3IgZXhhbXBsZSBpdCBjYW4gYWxzbyBiZSBhIHN0cmluZyBvZiBpbml0aWFscyBmcm9tIHRoZSBuYW1lLlxuICAgICAqL1xuICAgIHB1YmxpYyBhYnN0cmFjdCBnZXRBdmF0YXIoc2l6ZTogbnVtYmVyKTogc3RyaW5nO1xuXG4gICAgLyoqXG4gICAgICogV2hldGhlciB0aGUgYXZhdGFyIGlzIHB1cmVseSB0ZXh0dWFsIG9yIGFuIFVSTCBmb3IgYW4gaW1hZ2VcbiAgICAgKi9cbiAgICBwdWJsaWMgYWJzdHJhY3QgaXNUZXh0dWFsKCk6IGJvb2xlYW47XG59XG4iXX0=

package/esm2020/lib/modules/columns-picker/columns-picker-column.directive.mjs

@@ -0,0 +1,43 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NaturalColumnsPickerColumnDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        /**
+         * Initial checked state
+         */
+        this.checked = true;
+        /**
+         * Initial visibility state
+         */
+        this.hidden = false;
+    }
+    /**
+     * This must be the column key as defined in matColumnDef
+     */
+    set naturalColumnsPickerColumn(value) {
+        this.key = value;
+    }
+    ngOnInit() {
+        // Default label to key before real label is accessible
+        this.label = this.key;
+    }
+    ngAfterViewInit() {
+        this.label = this.elementRef.nativeElement.textContent;
+    }
+}
+NaturalColumnsPickerColumnDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalColumnsPickerColumnDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+NaturalColumnsPickerColumnDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.5", type: NaturalColumnsPickerColumnDirective, selector: "[naturalColumnsPickerColumn]", inputs: { checked: "checked", hidden: "hidden", naturalColumnsPickerColumn: "naturalColumnsPickerColumn" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalColumnsPickerColumnDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[naturalColumnsPickerColumn]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { checked: [{
+                type: Input
+            }], hidden: [{
+                type: Input
+            }], naturalColumnsPickerColumn: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,84 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Input, Output, } from '@angular/core';
+import { NaturalColumnsPickerColumnDirective } from './columns-picker-column.directive';
+import { cancellableTimeout } from '../../classes/rxjs';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/menu";
+import * as i2 from "@angular/material/checkbox";
+import * as i3 from "@angular/material/button";
+import * as i4 from "../icon/icon.component";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/forms";
+import * as i7 from "@angular/material/tooltip";
+export class NaturalColumnsPickerComponent {
+    constructor(changeDetectorRef) {
+        this.changeDetectorRef = changeDetectorRef;
+        /**
+         * Emit a list of valid and selected column keys whenever the selection changes
+         */
+        this.selectionChange = new EventEmitter();
+        /**
+         * Available columns are defined by options in the template
+         */
+        this.availableColumns = null;
+        /**
+         * Displayed options in the dropdown menu
+         */
+        this.displayedColumns = [];
+        this.ngUnsubscribe = new Subject();
+    }
+    /**
+     * Set the columns that are wanted but might be unavailable.
+     *
+     * If a column is unavailable it will be ignored silently. To know what columns were actually applied
+     * you should use `selectionChange`.
+     *
+     * It is often set once on component initialization, but it can also be set again later in the lifespan of the component.
+     */
+    set selections(columns) {
+        this._selections = columns;
+        if (!columns || !this.availableColumns) {
+            return;
+        }
+        this.availableColumns?.forEach(col => {
+            col.checked = columns.includes(col.key);
+        });
+        this.updateColumns();
+    }
+    ngAfterViewInit() {
+        cancellableTimeout(this.ngUnsubscribe).subscribe(() => {
+            this.initColumns();
+            this.updateColumns();
+            this.changeDetectorRef.detectChanges();
+        });
+    }
+    initColumns() {
+        this.availableColumns?.forEach(col => {
+            col.checked = this._selections?.length ? this._selections.includes(col.key) : col.checked;
+        });
+        // Show options only for columns that are not hidden
+        this.displayedColumns = this.availableColumns?.filter(col => !col.hidden) ?? [];
+    }
+    updateColumns() {
+        const selectedColumns = this.availableColumns?.filter(col => col.checked).map(col => col.key);
+        this.selectionChange.emit(selectedColumns);
+    }
+    ngOnDestroy() {
+        this.ngUnsubscribe.next(); // unsubscribe everybody
+        this.ngUnsubscribe.complete(); // complete the stream, because we will never emit again
+    }
+}
+NaturalColumnsPickerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalColumnsPickerComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+NaturalColumnsPickerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: NaturalColumnsPickerComponent, selector: "natural-columns-picker", inputs: { selections: "selections" }, outputs: { selectionChange: "selectionChange" }, queries: [{ propertyName: "availableColumns", predicate: NaturalColumnsPickerColumnDirective }], ngImport: i0, template: "<div>\n    <mat-menu #naturalMenu=\"matMenu\">\n        <div\n            (click)=\"$event.stopPropagation(); column.checked = !column.checked; updateColumns()\"\n            *ngFor=\"let column of displayedColumns\"\n            class=\"mat-menu-item\"\n        >\n            <mat-checkbox (click)=\"$event.stopPropagation()\" (change)=\"updateColumns()\" [(ngModel)]=\"column.checked\">{{\n                column.label\n            }}</mat-checkbox>\n        </div>\n    </mat-menu>\n    <button [matMenuTriggerFor]=\"naturalMenu\" mat-icon-button i18n-matTooltip matTooltip=\"S\u00E9lectionner les colonnes\">\n        <natural-icon name=\"view_column\"></natural-icon>\n    </button>\n</div>\n", components: [{ type: i1.MatMenu, selector: "mat-menu", exportAs: ["matMenu"] }, { type: i2.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex", "aria-label", "aria-labelledby", "aria-describedby", "id", "required", "labelPosition", "name", "value", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { type: i3.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i4.NaturalIconComponent, selector: "natural-icon", inputs: ["label", "labelColor", "labelPosition", "name", "size"] }], directives: [{ type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i6.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i6.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i7.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { type: i1.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", exportAs: ["matMenuTrigger"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalColumnsPickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'natural-columns-picker', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div>\n    <mat-menu #naturalMenu=\"matMenu\">\n        <div\n            (click)=\"$event.stopPropagation(); column.checked = !column.checked; updateColumns()\"\n            *ngFor=\"let column of displayedColumns\"\n            class=\"mat-menu-item\"\n        >\n            <mat-checkbox (click)=\"$event.stopPropagation()\" (change)=\"updateColumns()\" [(ngModel)]=\"column.checked\">{{\n                column.label\n            }}</mat-checkbox>\n        </div>\n    </mat-menu>\n    <button [matMenuTriggerFor]=\"naturalMenu\" mat-icon-button i18n-matTooltip matTooltip=\"S\u00E9lectionner les colonnes\">\n        <natural-icon name=\"view_column\"></natural-icon>\n    </button>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { selections: [{
+                type: Input
+            }], selectionChange: [{
+                type: Output
+            }], availableColumns: [{
+                type: ContentChildren,
+                args: [NaturalColumnsPickerColumnDirective]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"columns-picker.component.js","sourceRoot":"","sources":["../../../../../../projects/natural/src/lib/modules/columns-picker/columns-picker.component.ts","../../../../../../projects/natural/src/lib/modules/columns-picker/columns-picker.component.html"],"names":[],"mappings":"AAAA,OAAO,EAEH,uBAAuB,EAEvB,SAAS,EACT,eAAe,EACf,YAAY,EACZ,KAAK,EAEL,MAAM,GAET,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,mCAAmC,EAAC,MAAM,mCAAmC,CAAC;AACtF,OAAO,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAC,OAAO,EAAC,MAAM,MAAM,CAAC;;;;;;;;;AAO7B,MAAM,OAAO,6BAA6B;IA4CtC,YAAoC,iBAAoC;QAApC,sBAAiB,GAAjB,iBAAiB,CAAmB;QAlBxE;;WAEG;QACuB,oBAAe,GAAG,IAAI,YAAY,EAAY,CAAC;QAEzE;;WAEG;QAEI,qBAAgB,GAA0D,IAAI,CAAC;QAEtF;;WAEG;QACI,qBAAgB,GAA0C,EAAE,CAAC;QAE5D,kBAAa,GAAG,IAAI,OAAO,EAAQ,CAAC;IAE+B,CAAC;IAzC5E;;;;;;;OAOG;IACH,IACW,UAAU,CAAC,OAA6B;QAC/C,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC;QAE3B,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;YACpC,OAAO;SACV;QAED,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE;YACjC,GAAG,CAAC,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,aAAa,EAAE,CAAC;IACzB,CAAC;IAsBM,eAAe;QAClB,kBAAkB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YAClD,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;QAC3C,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,WAAW;QACf,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE;YACjC,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC;QAC9F,CAAC,CAAC,CAAC;QAEH,oDAAoD;QACpD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACpF,CAAC;IAEM,aAAa;QAChB,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC9F,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC/C,CAAC;IAEM,WAAW;QACd,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC,wBAAwB;QACnD,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC,CAAC,wDAAwD;IAC3F,CAAC;;0HAvEQ,6BAA6B;8GAA7B,6BAA6B,sLAkCrB,mCAAmC,6BCvDxD,4rBAgBA;2FDKa,6BAA6B;kBALzC,SAAS;+BACI,wBAAwB,mBAEjB,uBAAuB,CAAC,MAAM;wGAcpC,UAAU;sBADpB,KAAK;gBAkBoB,eAAe;sBAAxC,MAAM;gBAMA,gBAAgB;sBADtB,eAAe;uBAAC,mCAAmC","sourcesContent":["import {\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ContentChildren,\n    EventEmitter,\n    Input,\n    OnDestroy,\n    Output,\n    QueryList,\n} from '@angular/core';\nimport {NaturalColumnsPickerColumnDirective} from './columns-picker-column.directive';\nimport {cancellableTimeout} from '../../classes/rxjs';\nimport {Subject} from 'rxjs';\n\n@Component({\n    selector: 'natural-columns-picker',\n    templateUrl: './columns-picker.component.html',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NaturalColumnsPickerComponent implements AfterViewInit, OnDestroy {\n    private _selections?: string[];\n\n    /**\n     * Set the columns that are wanted but might be unavailable.\n     *\n     * If a column is unavailable it will be ignored silently. To know what columns were actually applied\n     * you should use `selectionChange`.\n     *\n     * It is often set once on component initialization, but it can also be set again later in the lifespan of the component.\n     */\n    @Input()\n    public set selections(columns: string[] | undefined) {\n        this._selections = columns;\n\n        if (!columns || !this.availableColumns) {\n            return;\n        }\n\n        this.availableColumns?.forEach(col => {\n            col.checked = columns.includes(col.key);\n        });\n\n        this.updateColumns();\n    }\n\n    /**\n     * Emit a list of valid and selected column keys whenever the selection changes\n     */\n    @Output() public readonly selectionChange = new EventEmitter<string[]>();\n\n    /**\n     * Available columns are defined by options in the template\n     */\n    @ContentChildren(NaturalColumnsPickerColumnDirective)\n    public availableColumns: QueryList<NaturalColumnsPickerColumnDirective> | null = null;\n\n    /**\n     * Displayed options in the dropdown menu\n     */\n    public displayedColumns: NaturalColumnsPickerColumnDirective[] = [];\n\n    private ngUnsubscribe = new Subject<void>();\n\n    public constructor(private readonly changeDetectorRef: ChangeDetectorRef) {}\n\n    public ngAfterViewInit(): void {\n        cancellableTimeout(this.ngUnsubscribe).subscribe(() => {\n            this.initColumns();\n            this.updateColumns();\n            this.changeDetectorRef.detectChanges();\n        });\n    }\n\n    private initColumns(): void {\n        this.availableColumns?.forEach(col => {\n            col.checked = this._selections?.length ? this._selections.includes(col.key) : col.checked;\n        });\n\n        // Show options only for columns that are not hidden\n        this.displayedColumns = this.availableColumns?.filter(col => !col.hidden) ?? [];\n    }\n\n    public updateColumns(): void {\n        const selectedColumns = this.availableColumns?.filter(col => col.checked).map(col => col.key);\n        this.selectionChange.emit(selectedColumns);\n    }\n\n    public ngOnDestroy(): void {\n        this.ngUnsubscribe.next(); // unsubscribe everybody\n        this.ngUnsubscribe.complete(); // complete the stream, because we will never emit again\n    }\n}\n","<div>\n    <mat-menu #naturalMenu=\"matMenu\">\n        <div\n            (click)=\"$event.stopPropagation(); column.checked = !column.checked; updateColumns()\"\n            *ngFor=\"let column of displayedColumns\"\n            class=\"mat-menu-item\"\n        >\n            <mat-checkbox (click)=\"$event.stopPropagation()\" (change)=\"updateColumns()\" [(ngModel)]=\"column.checked\">{{\n                column.label\n            }}</mat-checkbox>\n        </div>\n    </mat-menu>\n    <button [matMenuTriggerFor]=\"naturalMenu\" mat-icon-button i18n-matTooltip matTooltip=\"Sélectionner les colonnes\">\n        <natural-icon name=\"view_column\"></natural-icon>\n    </button>\n</div>\n"]}

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.2.5", ngImport: i0, type: NaturalColumnsPickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NaturalColumnsPickerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.5", 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.2.5", ngImport: i0, type: NaturalColumnsPickerModule, imports: [[
+            CommonModule,
+            FormsModule,
+            MatMenuModule,
+            MatButtonModule,
+            MatCheckboxModule,
+            NaturalIconModule,
+            MatTooltipModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", 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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