@one-paragon/angular-utilities 1.2.12 → 1.2.13

package/esm2022/table-builder/services/link-creator.service.mjs

@@ -0,0 +1,50 @@
+import { get } from "lodash";
+import { FieldType } from "../interfaces/report-def";
+export function createLinkCreatorDict(metaDatas) {
+    return metaDatas.reduce((acc, md) => {
+        if (md.fieldType === FieldType.Link) {
+            acc[md.key] = createLinkCreator(md);
+        }
+        return acc;
+    }, {});
+}
+export function createLinkCreator(metaData) {
+    const target = metaData.additional?.link?.target || '_blank';
+    const useRouterLink = metaData.additional?.link?.useRouterLink || false;
+    const hasRoute = !!metaData.additional?.link?.interpolatedRoute;
+    const routerLinkOptions = useRouterLink ? {
+        queryParams: (element) => metaData.additional.link.routerLinkOptions?.queryParams?.reduce((map, [key, value]) => {
+            map[key] = parseInterpolated(value, element);
+            return map;
+        }, {}) ?? null,
+        fragment: metaData.additional.link?.routerLinkOptions?.fragment,
+        preserveFragment: metaData.additional.link.routerLinkOptions?.preserveFragment ?? false,
+        queryParamsHandling: metaData.additional.link.routerLinkOptions?.queryParamsHandling ?? '',
+    }
+        : undefined;
+    if (hasRoute) {
+        return ({
+            link: (element) => parseInterpolated(metaData.additional.link.interpolatedRoute, element),
+            target,
+            useRouterLink,
+            routerLinkOptions,
+        });
+    }
+    else {
+        const slashIfNeeded = !metaData.additional?.link?.base?.endsWith('/') ? '/' : '';
+        const base = metaData.additional.link?.base;
+        const getKey = key(metaData);
+        return ({
+            link: (element) => `${base}${slashIfNeeded}${getKey(element)}`,
+            target,
+            useRouterLink,
+            routerLinkOptions,
+        });
+    }
+}
+const key = (metaData) => metaData.additional.link?.urlKey ?
+    (element) => get(element, metaData.additional.link.urlKey)
+    :
+        (element) => get(element, metaData.key);
+const parseInterpolated = (interpolatedString, element) => interpolatedString.replace(/{([^}]+)}/g, (_, key) => get(element, key));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/table-builder/services/table-template-service.mjs

@@ -0,0 +1,60 @@
+import { EnvironmentInjector, createComponent, inject } from "@angular/core";
+import { Injectable } from "@angular/core";
+import { ArrayStyle, FieldType } from "../interfaces/report-def";
+import { InitializationComponent } from "../components/initialization-component/initialization-component";
+import { TableBuilderConfigToken } from "../classes/TableBuilderConfig";
+import * as i0 from "@angular/core";
+export class TableTemplateService {
+    instance;
+    templates;
+    initTemplates() {
+        this.templates = {};
+        this.templates[FieldType.Array] = this.instance.arrayNewLineTemplate;
+        this.templates[FieldType.Array + .5] = this.instance.arrayCommaTemplate;
+        this.templates[FieldType.Boolean] = this.instance.defaultWithIcon;
+        this.templates[FieldType.Currency] = this.instance.defaultTemplate;
+        this.templates[FieldType.Date] = this.instance.defaultTemplate;
+        this.templates[FieldType.DateTime] = this.instance.defaultTemplate;
+        this.templates[FieldType.Expression] = this.instance.defaultTemplate;
+        this.templates[FieldType.NotMapped] = this.instance.defaultTemplate;
+        this.templates[FieldType.ImageUrl] = this.instance.imageUrlTemplate;
+        this.templates[FieldType.Link] = this.instance.linkTemplate;
+        this.templates[FieldType.Link + .5] = this.instance.routerLinkTemplate;
+        this.templates[FieldType.Number] = this.instance.defaultTemplate;
+        this.templates[FieldType.PhoneNumber] = this.instance.defaultTemplate;
+        this.templates[FieldType.String] = this.instance.defaultTemplate;
+        this.templates[FieldType.Unknown] = this.instance.defaultTemplate;
+        this.templates[FieldType.Enum] = this.instance.defaultTemplate;
+    }
+    getTemplate(metaData) {
+        let tmp = metaData.fieldType === FieldType.Link && metaData.additional?.link?.useRouterLink
+            ? this.templates[FieldType.Link + .5]
+            :
+                metaData.fieldType === FieldType.Array && (metaData.additional?.arrayStyle === ArrayStyle.CommaDelimited || this.tableConfig?.arrayInfo?.arrayStyle === ArrayStyle.CommaDelimited)
+                    ? this.templates[FieldType.Array + .5]
+                    :
+                        this.templates[metaData.fieldType];
+        if (metaData.useIcon) {
+            if (tmp === this.instance.defaultTemplate) {
+                tmp = this.instance.defaultWithIcon;
+            }
+        }
+        return tmp;
+    }
+    constructor() {
+        const ei = inject(EnvironmentInjector);
+        const c = createComponent(InitializationComponent, {
+            environmentInjector: ei,
+        });
+        this.instance = c.instance;
+        this.initTemplates();
+    }
+    tableConfig = inject(TableBuilderConfigToken);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TableTemplateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TableTemplateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TableTemplateService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtdGVtcGxhdGUtc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdXRpbGl0aWVzL3NyYy90YWJsZS1idWlsZGVyL3NlcnZpY2VzL3RhYmxlLXRlbXBsYXRlLXNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFZLGVBQWUsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDdkYsT0FBTyxFQUFFLFVBQVUsRUFBZSxNQUFNLGVBQWUsQ0FBQztBQUN4RCxPQUFPLEVBQW1CLFVBQVUsRUFBRSxTQUFTLEVBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUM1RixPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxpRUFBaUUsQ0FBQztBQUMxRyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQzs7QUFHeEUsTUFBTSxPQUFPLG9CQUFvQjtJQUMvQixRQUFRLENBQTJCO0lBQ25DLFNBQVMsQ0FBQztJQUVWLGFBQWE7UUFDWCxJQUFJLENBQUMsU0FBUyxHQUFHLEVBQUcsQ0FBQztRQUNyQixJQUFJLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLG9CQUFvQixDQUFDO1FBQ3JFLElBQUksQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLEtBQUssR0FBRyxFQUFFLENBQUMsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLGtCQUFrQixDQUFDO1FBQ3hFLElBQUksQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDO1FBQ2xFLElBQUksQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDO1FBQ25FLElBQUksQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDO1FBQy9ELElBQUksQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDO1FBQ25FLElBQUksQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDO1FBQ3JFLElBQUksQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDO1FBQ3BFLElBQUksQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsZ0JBQWdCLENBQUM7UUFDcEUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxZQUFZLENBQUM7UUFDNUQsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsSUFBSSxHQUFHLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsa0JBQWtCLENBQUM7UUFDdkUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQUM7UUFDakUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsV0FBVyxDQUFDLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQUM7UUFDdEUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQUM7UUFDakUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQUM7UUFDbEUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQUM7SUFDakUsQ0FBQztJQUNELFdBQVcsQ0FBQyxRQUFrQjtRQUU1QixJQUFJLEdBQUcsR0FBRyxRQUFRLENBQUMsU0FBUyxLQUFLLFNBQVMsQ0FBQyxJQUFJLElBQUksUUFBUSxDQUFDLFVBQVUsRUFBRSxJQUFJLEVBQUUsYUFBYTtZQUN6RixDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsSUFBSSxHQUFHLEVBQUUsQ0FBQztZQUNyQyxDQUFDO2dCQUNELFFBQVEsQ0FBQyxTQUFTLEtBQUssU0FBUyxDQUFDLEtBQUssSUFBSSxDQUFFLFFBQVEsQ0FBQyxVQUE4QixFQUFFLFVBQVUsS0FBSyxVQUFVLENBQUMsY0FBYyxJQUFJLElBQUksQ0FBQyxXQUFXLEVBQUUsU0FBUyxFQUFFLFVBQVUsS0FBSyxVQUFVLENBQUMsY0FBYyxDQUFDO29CQUN2TSxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsS0FBSyxHQUFHLEVBQUUsQ0FBQztvQkFDdEMsQ0FBQzt3QkFDRCxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUNyQyxJQUFHLFFBQVEsQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNwQixJQUFHLEdBQUcsS0FBSyxJQUFJLENBQUMsUUFBUSxDQUFDLGVBQWUsRUFBRSxDQUFDO2dCQUN6QyxHQUFHLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQUM7WUFDdEMsQ0FBQztRQUNILENBQUM7UUFDRCxPQUFPLEdBQUcsQ0FBQztJQUNiLENBQUM7SUFFRDtRQUNFLE1BQU0sRUFBRSxHQUFHLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO1FBRXZDLE1BQU0sQ0FBQyxHQUFHLGVBQWUsQ0FBQyx1QkFBdUIsRUFBRTtZQUNqRCxtQkFBbUIsRUFBRSxFQUFFO1NBQ3hCLENBQUMsQ0FBQztRQUNILElBQUksQ0FBQyxRQUFRLEdBQUcsQ0FBQyxDQUFDLFFBQVEsQ0FBQztRQUMzQixJQUFJLENBQUMsYUFBYSxFQUFFLENBQUM7SUFDdkIsQ0FBQztJQUVELFdBQVcsR0FBRyxNQUFNLENBQUMsdUJBQXVCLENBQUMsQ0FBQzt1R0FsRG5DLG9CQUFvQjsyR0FBcEIsb0JBQW9CLGNBRFIsTUFBTTs7MkZBQ2xCLG9CQUFvQjtrQkFEaEMsVUFBVTttQkFBQyxFQUFDLFVBQVUsRUFBRSxNQUFNLEVBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbnZpcm9ubWVudEluamVjdG9yLCBJbmplY3RvciwgY3JlYXRlQ29tcG9uZW50LCBpbmplY3QgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQgeyBJbmplY3RhYmxlLCBUZW1wbGF0ZVJlZiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IEFycmF5QWRkaXRpb25hbCwgQXJyYXlTdHlsZSwgRmllbGRUeXBlLCBNZXRhRGF0YSB9IGZyb20gXCIuLi9pbnRlcmZhY2VzL3JlcG9ydC1kZWZcIjtcclxuaW1wb3J0IHsgSW5pdGlhbGl6YXRpb25Db21wb25lbnQgfSBmcm9tIFwiLi4vY29tcG9uZW50cy9pbml0aWFsaXphdGlvbi1jb21wb25lbnQvaW5pdGlhbGl6YXRpb24tY29tcG9uZW50XCI7XHJcbmltcG9ydCB7IFRhYmxlQnVpbGRlckNvbmZpZ1Rva2VuIH0gZnJvbSBcIi4uL2NsYXNzZXMvVGFibGVCdWlsZGVyQ29uZmlnXCI7XHJcblxyXG5ASW5qZWN0YWJsZSh7cHJvdmlkZWRJbjogJ3Jvb3QnfSlcclxuZXhwb3J0IGNsYXNzIFRhYmxlVGVtcGxhdGVTZXJ2aWNlIHtcclxuICBpbnN0YW5jZSE6IEluaXRpYWxpemF0aW9uQ29tcG9uZW50O1xyXG4gIHRlbXBsYXRlcztcclxuXHJcbiAgaW5pdFRlbXBsYXRlcygpIHtcclxuICAgIHRoaXMudGVtcGxhdGVzID0geyB9O1xyXG4gICAgdGhpcy50ZW1wbGF0ZXNbRmllbGRUeXBlLkFycmF5XSA9IHRoaXMuaW5zdGFuY2UuYXJyYXlOZXdMaW5lVGVtcGxhdGU7XHJcbiAgICB0aGlzLnRlbXBsYXRlc1tGaWVsZFR5cGUuQXJyYXkgKyAuNV0gPSB0aGlzLmluc3RhbmNlLmFycmF5Q29tbWFUZW1wbGF0ZTtcclxuICAgIHRoaXMudGVtcGxhdGVzW0ZpZWxkVHlwZS5Cb29sZWFuXSA9IHRoaXMuaW5zdGFuY2UuZGVmYXVsdFdpdGhJY29uO1xyXG4gICAgdGhpcy50ZW1wbGF0ZXNbRmllbGRUeXBlLkN1cnJlbmN5XSA9IHRoaXMuaW5zdGFuY2UuZGVmYXVsdFRlbXBsYXRlO1xyXG4gICAgdGhpcy50ZW1wbGF0ZXNbRmllbGRUeXBlLkRhdGVdID0gdGhpcy5pbnN0YW5jZS5kZWZhdWx0VGVtcGxhdGU7XHJcbiAgICB0aGlzLnRlbXBsYXRlc1tGaWVsZFR5cGUuRGF0ZVRpbWVdID0gdGhpcy5pbnN0YW5jZS5kZWZhdWx0VGVtcGxhdGU7XHJcbiAgICB0aGlzLnRlbXBsYXRlc1tGaWVsZFR5cGUuRXhwcmVzc2lvbl0gPSB0aGlzLmluc3RhbmNlLmRlZmF1bHRUZW1wbGF0ZTtcclxuICAgIHRoaXMudGVtcGxhdGVzW0ZpZWxkVHlwZS5Ob3RNYXBwZWRdID0gdGhpcy5pbnN0YW5jZS5kZWZhdWx0VGVtcGxhdGU7XHJcbiAgICB0aGlzLnRlbXBsYXRlc1tGaWVsZFR5cGUuSW1hZ2VVcmxdID0gdGhpcy5pbnN0YW5jZS5pbWFnZVVybFRlbXBsYXRlO1xyXG4gICAgdGhpcy50ZW1wbGF0ZXNbRmllbGRUeXBlLkxpbmtdID0gdGhpcy5pbnN0YW5jZS5saW5rVGVtcGxhdGU7XHJcbiAgICB0aGlzLnRlbXBsYXRlc1tGaWVsZFR5cGUuTGluayArIC41XSA9IHRoaXMuaW5zdGFuY2Uucm91dGVyTGlua1RlbXBsYXRlO1xyXG4gICAgdGhpcy50ZW1wbGF0ZXNbRmllbGRUeXBlLk51bWJlcl0gPSB0aGlzLmluc3RhbmNlLmRlZmF1bHRUZW1wbGF0ZTtcclxuICAgIHRoaXMudGVtcGxhdGVzW0ZpZWxkVHlwZS5QaG9uZU51bWJlcl0gPSB0aGlzLmluc3RhbmNlLmRlZmF1bHRUZW1wbGF0ZTtcclxuICAgIHRoaXMudGVtcGxhdGVzW0ZpZWxkVHlwZS5TdHJpbmddID0gdGhpcy5pbnN0YW5jZS5kZWZhdWx0VGVtcGxhdGU7XHJcbiAgICB0aGlzLnRlbXBsYXRlc1tGaWVsZFR5cGUuVW5rbm93bl0gPSB0aGlzLmluc3RhbmNlLmRlZmF1bHRUZW1wbGF0ZTtcclxuICAgIHRoaXMudGVtcGxhdGVzW0ZpZWxkVHlwZS5FbnVtXSA9IHRoaXMuaW5zdGFuY2UuZGVmYXVsdFRlbXBsYXRlO1xyXG4gIH1cclxuICBnZXRUZW1wbGF0ZShtZXRhRGF0YTogTWV0YURhdGEpIDogVGVtcGxhdGVSZWY8YW55PiB7XHJcblxyXG4gICAgbGV0IHRtcCA9IG1ldGFEYXRhLmZpZWxkVHlwZSA9PT0gRmllbGRUeXBlLkxpbmsgJiYgbWV0YURhdGEuYWRkaXRpb25hbD8ubGluaz8udXNlUm91dGVyTGlua1xyXG4gICAgICA/IHRoaXMudGVtcGxhdGVzW0ZpZWxkVHlwZS5MaW5rICsgLjVdIFxyXG4gICAgICA6IFxyXG4gICAgICBtZXRhRGF0YS5maWVsZFR5cGUgPT09IEZpZWxkVHlwZS5BcnJheSAmJiAoKG1ldGFEYXRhLmFkZGl0aW9uYWwgYXMgQXJyYXlBZGRpdGlvbmFsKT8uYXJyYXlTdHlsZSA9PT0gQXJyYXlTdHlsZS5Db21tYURlbGltaXRlZCB8fCB0aGlzLnRhYmxlQ29uZmlnPy5hcnJheUluZm8/LmFycmF5U3R5bGUgPT09IEFycmF5U3R5bGUuQ29tbWFEZWxpbWl0ZWQpXHJcbiAgICAgID8gdGhpcy50ZW1wbGF0ZXNbRmllbGRUeXBlLkFycmF5ICsgLjVdIFxyXG4gICAgICA6XHJcbiAgICAgIHRoaXMudGVtcGxhdGVzW21ldGFEYXRhLmZpZWxkVHlwZV07XHJcbiAgICBpZihtZXRhRGF0YS51c2VJY29uKSB7XHJcbiAgICAgIGlmKHRtcCA9PT0gdGhpcy5pbnN0YW5jZS5kZWZhdWx0VGVtcGxhdGUpIHtcclxuICAgICAgICB0bXAgPSB0aGlzLmluc3RhbmNlLmRlZmF1bHRXaXRoSWNvbjtcclxuICAgICAgfVxyXG4gICAgfVxyXG4gICAgcmV0dXJuIHRtcDtcclxuICB9XHJcblxyXG4gIGNvbnN0cnVjdG9yKCkge1xyXG4gICAgY29uc3QgZWkgPSBpbmplY3QoRW52aXJvbm1lbnRJbmplY3Rvcik7XHJcblxyXG4gICAgY29uc3QgYyA9IGNyZWF0ZUNvbXBvbmVudChJbml0aWFsaXphdGlvbkNvbXBvbmVudCwge1xyXG4gICAgICBlbnZpcm9ubWVudEluamVjdG9yOiBlaSxcclxuICAgIH0pO1xyXG4gICAgdGhpcy5pbnN0YW5jZSA9IGMuaW5zdGFuY2U7XHJcbiAgICB0aGlzLmluaXRUZW1wbGF0ZXMoKTtcclxuICB9XHJcblxyXG4gIHRhYmxlQ29uZmlnID0gaW5qZWN0KFRhYmxlQnVpbGRlckNvbmZpZ1Rva2VuKTtcclxufVxyXG4iXX0=

package/esm2022/table-builder/services/transform-creator.mjs

@@ -0,0 +1,100 @@
+import { Injectable, inject } from '@angular/core';
+import { FieldType } from '../interfaces/report-def';
+import { DatePipe, CurrencyPipe } from '@angular/common';
+import { PhoneNumberPipe } from '../../utilities/pipes/phone.pipe';
+import { TableBuilderConfigToken } from '../classes/TableBuilderConfig';
+import { SpaceCasePipe } from '../../utilities';
+import { get } from 'lodash';
+import * as i0 from "@angular/core";
+export function isPipe(o) {
+    return typeof (o.transform) === 'function';
+}
+export class TransformCreator {
+    datePipe = inject(DatePipe);
+    currencyPipe = inject(CurrencyPipe);
+    phonePipe = inject(PhoneNumberPipe);
+    casePipe = inject(SpaceCasePipe);
+    config = inject(TableBuilderConfigToken);
+    createTransformer(metaData, noIcons = false) {
+        const nested = metaData.key.includes('.');
+        const defaultFunc = nested ? (value) => get(value, metaData.key) : (value) => value[metaData.key];
+        if (metaData.map) {
+            return (value) => {
+                return metaData.map(value);
+            };
+        }
+        if (metaData.transform) {
+            if (isPipe(metaData.transform)) {
+                return (value) => metaData.transform.transform(defaultFunc(value));
+            }
+            return metaData.fieldType === FieldType.Expression ? metaData.transform : (value) => metaData.transform(defaultFunc(value), value);
+        }
+        if (this.config.transformers && this.config.transformers[metaData.fieldType]) {
+            var transformer = this.config.transformers[metaData.fieldType];
+            return (value) => transformer(defaultFunc(value));
+        }
+        const defaultDateFormat = this.config.defaultSettings?.dateFormat ?? 'shortDate';
+        const defaultDateTimeFormat = this.config.defaultSettings?.dateTimeFormat ?? 'short';
+        switch (metaData.fieldType) {
+            case FieldType.Date:
+                const dateFormat = metaData.additional?.dateFormat ?? defaultDateFormat;
+                return (value) => this.datePipe.transform(defaultFunc(value), dateFormat);
+            case FieldType.DateTime:
+                const dateTimeFormat = metaData.additional?.dateTimeOptions?.format ?? defaultDateTimeFormat;
+                return (value) => this.datePipe.transform(defaultFunc(value), dateTimeFormat);
+            case FieldType.Currency:
+                return (value) => this.currencyPipe.transform(defaultFunc(value));
+            case FieldType.PhoneNumber:
+                return (value) => this.phonePipe.transform(defaultFunc(value));
+            case FieldType.Enum:
+                return (value) => this.casePipe.transform(metaData.additional?.enumMap[defaultFunc(value)]);
+            case FieldType.Boolean:
+                if (noIcons) {
+                    return defaultFunc;
+                }
+                let forTrue = 'check';
+                let forFalse = '';
+                if (metaData.additional?.boolean?.forTrue) {
+                    forTrue = metaData?.additional.boolean.forTrue.icon;
+                }
+                if (metaData.additional?.boolean?.showForFalse === true) {
+                    forFalse = 'clear';
+                }
+                else if (metaData.additional?.boolean?.showForFalse?.icon) {
+                    forFalse = metaData.additional?.boolean?.showForFalse?.icon;
+                }
+                return (value) => defaultFunc(value) ? forTrue : forFalse;
+        }
+        return defaultFunc;
+    }
+    createItemTransformer = (metaData, noIcons = false, mutate = false) => {
+        const transform = this.createTransformer(metaData, noIcons);
+        return (t) => {
+            if (!mutate) {
+                t = { ...t };
+            }
+            t[metaData.key] = transform(t);
+        };
+    };
+    createItemTransformers = (metaDatas, noIcons = false, mutate = false) => {
+        const transformers = metaDatas.map(meta => this.createItemTransformer(meta, noIcons, true));
+        return (t) => {
+            if (!t)
+                return t;
+            if (!mutate) {
+                t = { ...t };
+            }
+            transformers.forEach(m => m(t));
+            return t;
+        };
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TransformCreator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TransformCreator, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TransformCreator, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transform-creator.js","sourceRoot":"","sources":["../../../../../projects/angular-utilities/src/table-builder/services/transform-creator.ts"],"names":[],"mappings":"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","sourcesContent":["import { PipeTransform, Injectable, inject } from '@angular/core';\r\nimport { FieldType, MetaData } from '../interfaces/report-def';\r\nimport { DatePipe, CurrencyPipe } from '@angular/common';\r\nimport { PhoneNumberPipe } from '../../utilities/pipes/phone.pipe';\r\nimport { TableBuilderConfigToken } from '../classes/TableBuilderConfig';\r\nimport { SpaceCasePipe } from '../../utilities';\r\nimport { get } from 'lodash';\r\nexport function isPipe(o : any ): o is PipeTransform {\r\n  return typeof ((o as PipeTransform).transform ) === 'function';\r\n}\r\n\r\n@Injectable({\r\n  providedIn:  'root',\r\n})\r\nexport class TransformCreator {\r\n  private datePipe = inject(DatePipe);\r\n  private currencyPipe = inject(CurrencyPipe);\r\n  private phonePipe = inject(PhoneNumberPipe);\r\n  private casePipe = inject(SpaceCasePipe);\r\n  private config = inject(TableBuilderConfigToken);\r\n\r\n  createTransformer(metaData: MetaData<any, any>, noIcons = false): ((value: any, ...args: any[]) => any)  {\r\n    const nested = metaData.key.includes('.');\r\n    const defaultFunc = nested ?  (value: any) => get( value, metaData.key) : (value: any) =>  value[metaData.key];\r\n    if(metaData.map){\r\n      return (value: any) => { \r\n        return metaData.map!(value)};\r\n    }\r\n    if( metaData.transform) {\r\n      if(isPipe(metaData.transform)){\r\n        return (value: any) =>  (metaData!.transform as PipeTransform).transform(defaultFunc(value));\r\n      }\r\n      return metaData.fieldType === FieldType.Expression ? metaData.transform : (value: any) => (metaData.transform as (a:any,b:any)=>any)(defaultFunc(value),value);\r\n    }\r\n    if (this.config.transformers && this.config.transformers[metaData.fieldType]) {\r\n      var transformer =  this.config.transformers![metaData.fieldType]!;\r\n      return (value: any) => transformer(defaultFunc(value));\r\n    }\r\n    const defaultDateFormat = this.config.defaultSettings?.dateFormat ?? 'shortDate';\r\n    const defaultDateTimeFormat = this.config.defaultSettings?.dateTimeFormat ?? 'short';\r\n    switch(metaData.fieldType) {\r\n      case FieldType.Date:\r\n        const dateFormat = metaData.additional?.dateFormat ?? defaultDateFormat;\r\n        return (value: any) => this.datePipe.transform(defaultFunc(value), dateFormat);\r\n      case FieldType.DateTime:\r\n        const dateTimeFormat = metaData.additional?.dateTimeOptions?.format ?? defaultDateTimeFormat;\r\n        return (value: any) => this.datePipe.transform(defaultFunc(value), dateTimeFormat);\r\n      case FieldType.Currency:\r\n          return (value: any) =>  this.currencyPipe.transform(defaultFunc(value));\r\n      case FieldType.PhoneNumber:\r\n        return  (value: any) =>  this.phonePipe.transform(defaultFunc(value));\r\n      case FieldType.Enum:\r\n        return (value: any) =>  this.casePipe.transform(metaData.additional?.enumMap![defaultFunc(value)] as string) ;\r\n      case FieldType.Boolean:\r\n        if(noIcons) {\r\n          return defaultFunc\r\n        }\r\n        let forTrue = 'check'\r\n        let forFalse = '';\r\n        if(metaData.additional?.boolean?.forTrue) {\r\n          forTrue = metaData?.additional.boolean.forTrue.icon;\r\n        }\r\n        if(metaData.additional?.boolean?.showForFalse === true) {\r\n          forFalse = 'clear';\r\n        } else if (metaData.additional?.boolean?.showForFalse?.icon) {\r\n          forFalse = metaData.additional?.boolean?.showForFalse?.icon;\r\n        }\r\n        return (value: any) => defaultFunc(value) ? forTrue : forFalse ;\r\n    }\r\n      return defaultFunc;\r\n  }\r\n\r\n  createItemTransformer = <T = any, AdditionalFields extends string[] = []>(metaData: MetaData<T ,AdditionalFields>, noIcons = false, mutate = false) => {\r\n    const transform = this.createTransformer(metaData, noIcons);\r\n    return (t: T) => {\r\n      if(!mutate){\r\n        t = { ...t }\r\n      }\r\n      t[metaData.key as string] = transform(t)\r\n    }\r\n  }\r\n\r\n  createItemTransformers = <T = any, AdditionalFields extends string[] = []>(metaDatas: MetaData<T, AdditionalFields>[], noIcons = false, mutate = false) => {\r\n    const transformers = metaDatas.map(meta => this.createItemTransformer(meta ,noIcons, true));\r\n    return (t: T) => {\r\n      if(!t) return t;\r\n      if(!mutate){\r\n        t = { ... t}\r\n      }\r\n      transformers.forEach(m => m(t));\r\n      return t;\r\n    }\r\n  }\r\n\r\n}\r\n"]}

package/esm2022/table-builder/table-builder.module.mjs

@@ -0,0 +1,124 @@
+import { NgModule } from '@angular/core';
+import { CommonModule, DatePipe, CurrencyPipe } from '@angular/common';
+import { SpaceCasePipe } from '../utilities/pipes/space-case.pipes';
+import { MultiSortDirective } from './directives/multi-sort.directive';
+import { TableBuilderConfigToken } from './classes/TableBuilderConfig';
+import { PhoneNumberPipe } from '../utilities/pipes/phone.pipe';
+import { RouterModule } from '@angular/router';
+import { FilterComponent, GenericTableComponent, TableContainerComponent } from './components';
+import { CustomCellDirective, MatSlideToggleTbFilterDirective, MatRadioButtonTbFilterDirective, MatOptionTbFilterDirective, MatCheckboxTbFilterDirective, MatButtonToggleFilterDirective, TableFilterDirective, TableFilterStringContainsDirective, TableWrapperDirective, ResizeColumnDirective } from './directives';
+import { UtilitiesModule } from '../utilities';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatNativeDateModule } from '@angular/material/core';
+import { TableBuilderStateStore } from './ngrx/tableBuilderStateStore';
+import * as i0 from "@angular/core";
+export class TableBuilderModule {
+    static forRoot(config) {
+        return {
+            ngModule: TableBuilderModule,
+            providers: [
+                { provide: TableBuilderConfigToken, useValue: config }
+            ]
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TableBuilderModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.2", ngImport: i0, type: TableBuilderModule, imports: [CommonModule,
+            MatDialogModule,
+            MatNativeDateModule,
+            RouterModule,
+            TableContainerComponent,
+            GenericTableComponent,
+            TableContainerComponent,
+            CustomCellDirective,
+            FilterComponent,
+            MatSlideToggleTbFilterDirective,
+            MatRadioButtonTbFilterDirective,
+            MatOptionTbFilterDirective,
+            MatCheckboxTbFilterDirective,
+            MatButtonToggleFilterDirective,
+            TableFilterDirective,
+            TableFilterStringContainsDirective,
+            TableWrapperDirective,
+            ResizeColumnDirective,
+            UtilitiesModule], exports: [GenericTableComponent,
+            TableContainerComponent,
+            CustomCellDirective,
+            FilterComponent,
+            MatSlideToggleTbFilterDirective,
+            MatRadioButtonTbFilterDirective,
+            MatOptionTbFilterDirective,
+            MatCheckboxTbFilterDirective,
+            MatButtonToggleFilterDirective,
+            TableFilterDirective,
+            TableFilterStringContainsDirective,
+            TableWrapperDirective,
+            ResizeColumnDirective,
+            UtilitiesModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TableBuilderModule, providers: [
+            SpaceCasePipe,
+            DatePipe,
+            CurrencyPipe,
+            PhoneNumberPipe,
+            MultiSortDirective,
+            TableBuilderStateStore,
+        ], imports: [CommonModule,
+            MatDialogModule,
+            MatNativeDateModule,
+            RouterModule,
+            TableContainerComponent,
+            GenericTableComponent,
+            TableContainerComponent,
+            FilterComponent,
+            UtilitiesModule, UtilitiesModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TableBuilderModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        MatDialogModule,
+                        MatNativeDateModule,
+                        RouterModule,
+                        TableContainerComponent,
+                        GenericTableComponent,
+                        TableContainerComponent,
+                        CustomCellDirective,
+                        FilterComponent,
+                        MatSlideToggleTbFilterDirective,
+                        MatRadioButtonTbFilterDirective,
+                        MatOptionTbFilterDirective,
+                        MatCheckboxTbFilterDirective,
+                        MatButtonToggleFilterDirective,
+                        TableFilterDirective,
+                        TableFilterStringContainsDirective,
+                        TableWrapperDirective,
+                        ResizeColumnDirective,
+                        UtilitiesModule,
+                    ],
+                    exports: [
+                        GenericTableComponent,
+                        TableContainerComponent,
+                        CustomCellDirective,
+                        FilterComponent,
+                        MatSlideToggleTbFilterDirective,
+                        MatRadioButtonTbFilterDirective,
+                        MatOptionTbFilterDirective,
+                        MatCheckboxTbFilterDirective,
+                        MatButtonToggleFilterDirective,
+                        TableFilterDirective,
+                        TableFilterStringContainsDirective,
+                        TableWrapperDirective,
+                        ResizeColumnDirective,
+                        UtilitiesModule,
+                    ],
+                    providers: [
+                        SpaceCasePipe,
+                        DatePipe,
+                        CurrencyPipe,
+                        PhoneNumberPipe,
+                        MultiSortDirective,
+                        TableBuilderStateStore,
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtYnVpbGRlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXV0aWxpdGllcy9zcmMvdGFibGUtYnVpbGRlci90YWJsZS1idWlsZGVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxZQUFZLEVBQUUsUUFBUSxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUNwRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUV2RSxPQUFPLEVBQXNCLHVCQUF1QixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDM0YsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ2hFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsZUFBZSxFQUFFLHFCQUFxQixFQUFFLHVCQUF1QixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQy9GLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSwrQkFBK0IsRUFBRSwrQkFBK0IsRUFBRSwwQkFBMEIsRUFBRSw0QkFBNEIsRUFBRSw4QkFBOEIsRUFBRSxvQkFBb0IsRUFBRSxrQ0FBa0MsRUFBRSxxQkFBcUIsRUFBRSxxQkFBcUIsRUFBOEIsTUFBTSxjQUFjLENBQUM7QUFDblYsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUMvQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDM0QsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDN0QsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sK0JBQStCLENBQUM7O0FBaUR2RSxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBMEI7UUFDdkMsT0FBTztZQUNMLFFBQVEsRUFBRSxrQkFBa0I7WUFDNUIsU0FBUyxFQUFFO2dCQUNULEVBQUUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUU7YUFDdkQ7U0FDRixDQUFDO0lBQ0osQ0FBQzt1R0FSVSxrQkFBa0I7d0dBQWxCLGtCQUFrQixZQTdDM0IsWUFBWTtZQUNaLGVBQWU7WUFDZixtQkFBbUI7WUFDbkIsWUFBWTtZQUNaLHVCQUF1QjtZQUN2QixxQkFBcUI7WUFDckIsdUJBQXVCO1lBQ3ZCLG1CQUFtQjtZQUNuQixlQUFlO1lBQ2YsK0JBQStCO1lBQy9CLCtCQUErQjtZQUMvQiwwQkFBMEI7WUFDMUIsNEJBQTRCO1lBQzVCLDhCQUE4QjtZQUM5QixvQkFBb0I7WUFDcEIsa0NBQWtDO1lBQ2xDLHFCQUFxQjtZQUNyQixxQkFBcUI7WUFDckIsZUFBZSxhQUdmLHFCQUFxQjtZQUNyQix1QkFBdUI7WUFDdkIsbUJBQW1CO1lBQ25CLGVBQWU7WUFDZiwrQkFBK0I7WUFDL0IsK0JBQStCO1lBQy9CLDBCQUEwQjtZQUMxQiw0QkFBNEI7WUFDNUIsOEJBQThCO1lBQzlCLG9CQUFvQjtZQUNwQixrQ0FBa0M7WUFDbEMscUJBQXFCO1lBQ3JCLHFCQUFxQjtZQUNyQixlQUFlO3dHQVdOLGtCQUFrQixhQVRsQjtZQUNULGFBQWE7WUFDYixRQUFRO1lBQ1IsWUFBWTtZQUNaLGVBQWU7WUFDZixrQkFBa0I7WUFDbEIsc0JBQXNCO1NBQ3ZCLFlBM0NDLFlBQVk7WUFDWixlQUFlO1lBQ2YsbUJBQW1CO1lBQ25CLFlBQVk7WUFDWix1QkFBdUI7WUFDdkIscUJBQXFCO1lBQ3JCLHVCQUF1QjtZQUV2QixlQUFlO1lBVWYsZUFBZSxFQWdCZixlQUFlOzsyRkFXTixrQkFBa0I7a0JBL0M5QixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRTt3QkFDUCxZQUFZO3dCQUNaLGVBQWU7d0JBQ2YsbUJBQW1CO3dCQUNuQixZQUFZO3dCQUNaLHVCQUF1Qjt3QkFDdkIscUJBQXFCO3dCQUNyQix1QkFBdUI7d0JBQ3ZCLG1CQUFtQjt3QkFDbkIsZUFBZTt3QkFDZiwrQkFBK0I7d0JBQy9CLCtCQUErQjt3QkFDL0IsMEJBQTBCO3dCQUMxQiw0QkFBNEI7d0JBQzVCLDhCQUE4Qjt3QkFDOUIsb0JBQW9CO3dCQUNwQixrQ0FBa0M7d0JBQ2xDLHFCQUFxQjt3QkFDckIscUJBQXFCO3dCQUNyQixlQUFlO3FCQUNoQjtvQkFDRCxPQUFPLEVBQUU7d0JBQ1AscUJBQXFCO3dCQUNyQix1QkFBdUI7d0JBQ3ZCLG1CQUFtQjt3QkFDbkIsZUFBZTt3QkFDZiwrQkFBK0I7d0JBQy9CLCtCQUErQjt3QkFDL0IsMEJBQTBCO3dCQUMxQiw0QkFBNEI7d0JBQzVCLDhCQUE4Qjt3QkFDOUIsb0JBQW9CO3dCQUNwQixrQ0FBa0M7d0JBQ2xDLHFCQUFxQjt3QkFDckIscUJBQXFCO3dCQUNyQixlQUFlO3FCQUNoQjtvQkFDRCxTQUFTLEVBQUU7d0JBQ1QsYUFBYTt3QkFDYixRQUFRO3dCQUNSLFlBQVk7d0JBQ1osZUFBZTt3QkFDZixrQkFBa0I7d0JBQ2xCLHNCQUFzQjtxQkFDdkI7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJcclxuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQ29tbW9uTW9kdWxlLCBEYXRlUGlwZSwgQ3VycmVuY3lQaXBlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcclxuaW1wb3J0IHsgU3BhY2VDYXNlUGlwZSB9IGZyb20gJy4uL3V0aWxpdGllcy9waXBlcy9zcGFjZS1jYXNlLnBpcGVzJztcclxuaW1wb3J0IHsgTXVsdGlTb3J0RGlyZWN0aXZlIH0gZnJvbSAnLi9kaXJlY3RpdmVzL211bHRpLXNvcnQuZGlyZWN0aXZlJztcclxuaW1wb3J0IHsgTW9kdWxlV2l0aFByb3ZpZGVycyB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBUYWJsZUJ1aWxkZXJDb25maWcsIFRhYmxlQnVpbGRlckNvbmZpZ1Rva2VuIH0gZnJvbSAnLi9jbGFzc2VzL1RhYmxlQnVpbGRlckNvbmZpZyc7XHJcbmltcG9ydCB7IFBob25lTnVtYmVyUGlwZSB9IGZyb20gJy4uL3V0aWxpdGllcy9waXBlcy9waG9uZS5waXBlJztcclxuaW1wb3J0IHsgUm91dGVyTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcclxuaW1wb3J0IHsgRmlsdGVyQ29tcG9uZW50LCBHZW5lcmljVGFibGVDb21wb25lbnQsIFRhYmxlQ29udGFpbmVyQ29tcG9uZW50IH0gZnJvbSAnLi9jb21wb25lbnRzJztcclxuaW1wb3J0IHsgQ3VzdG9tQ2VsbERpcmVjdGl2ZSwgTWF0U2xpZGVUb2dnbGVUYkZpbHRlckRpcmVjdGl2ZSwgTWF0UmFkaW9CdXR0b25UYkZpbHRlckRpcmVjdGl2ZSwgTWF0T3B0aW9uVGJGaWx0ZXJEaXJlY3RpdmUsIE1hdENoZWNrYm94VGJGaWx0ZXJEaXJlY3RpdmUsIE1hdEJ1dHRvblRvZ2dsZUZpbHRlckRpcmVjdGl2ZSwgVGFibGVGaWx0ZXJEaXJlY3RpdmUsIFRhYmxlRmlsdGVyU3RyaW5nQ29udGFpbnNEaXJlY3RpdmUsIFRhYmxlV3JhcHBlckRpcmVjdGl2ZSwgUmVzaXplQ29sdW1uRGlyZWN0aXZlLCBUYWJsZUN1c3RvbUZpbHRlckRpcmVjdGl2ZSB9IGZyb20gJy4vZGlyZWN0aXZlcyc7XHJcbmltcG9ydCB7IFV0aWxpdGllc01vZHVsZSB9IGZyb20gJy4uL3V0aWxpdGllcyc7XHJcbmltcG9ydCB7IE1hdERpYWxvZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2RpYWxvZyc7XHJcbmltcG9ydCB7IE1hdE5hdGl2ZURhdGVNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9jb3JlJztcclxuaW1wb3J0IHsgVGFibGVCdWlsZGVyU3RhdGVTdG9yZSB9IGZyb20gJy4vbmdyeC90YWJsZUJ1aWxkZXJTdGF0ZVN0b3JlJztcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgaW1wb3J0czogW1xyXG4gICAgQ29tbW9uTW9kdWxlLFxyXG4gICAgTWF0RGlhbG9nTW9kdWxlLFxyXG4gICAgTWF0TmF0aXZlRGF0ZU1vZHVsZSxcclxuICAgIFJvdXRlck1vZHVsZSxcclxuICAgIFRhYmxlQ29udGFpbmVyQ29tcG9uZW50LFxyXG4gICAgR2VuZXJpY1RhYmxlQ29tcG9uZW50LFxyXG4gICAgVGFibGVDb250YWluZXJDb21wb25lbnQsXHJcbiAgICBDdXN0b21DZWxsRGlyZWN0aXZlLFxyXG4gICAgRmlsdGVyQ29tcG9uZW50LFxyXG4gICAgTWF0U2xpZGVUb2dnbGVUYkZpbHRlckRpcmVjdGl2ZSxcclxuICAgIE1hdFJhZGlvQnV0dG9uVGJGaWx0ZXJEaXJlY3RpdmUsXHJcbiAgICBNYXRPcHRpb25UYkZpbHRlckRpcmVjdGl2ZSxcclxuICAgIE1hdENoZWNrYm94VGJGaWx0ZXJEaXJlY3RpdmUsXHJcbiAgICBNYXRCdXR0b25Ub2dnbGVGaWx0ZXJEaXJlY3RpdmUsXHJcbiAgICBUYWJsZUZpbHRlckRpcmVjdGl2ZSxcclxuICAgIFRhYmxlRmlsdGVyU3RyaW5nQ29udGFpbnNEaXJlY3RpdmUsXHJcbiAgICBUYWJsZVdyYXBwZXJEaXJlY3RpdmUsXHJcbiAgICBSZXNpemVDb2x1bW5EaXJlY3RpdmUsXHJcbiAgICBVdGlsaXRpZXNNb2R1bGUsXHJcbiAgXSxcclxuICBleHBvcnRzOiBbXHJcbiAgICBHZW5lcmljVGFibGVDb21wb25lbnQsXHJcbiAgICBUYWJsZUNvbnRhaW5lckNvbXBvbmVudCxcclxuICAgIEN1c3RvbUNlbGxEaXJlY3RpdmUsXHJcbiAgICBGaWx0ZXJDb21wb25lbnQsXHJcbiAgICBNYXRTbGlkZVRvZ2dsZVRiRmlsdGVyRGlyZWN0aXZlLFxyXG4gICAgTWF0UmFkaW9CdXR0b25UYkZpbHRlckRpcmVjdGl2ZSxcclxuICAgIE1hdE9wdGlvblRiRmlsdGVyRGlyZWN0aXZlLFxyXG4gICAgTWF0Q2hlY2tib3hUYkZpbHRlckRpcmVjdGl2ZSxcclxuICAgIE1hdEJ1dHRvblRvZ2dsZUZpbHRlckRpcmVjdGl2ZSxcclxuICAgIFRhYmxlRmlsdGVyRGlyZWN0aXZlLFxyXG4gICAgVGFibGVGaWx0ZXJTdHJpbmdDb250YWluc0RpcmVjdGl2ZSxcclxuICAgIFRhYmxlV3JhcHBlckRpcmVjdGl2ZSxcclxuICAgIFJlc2l6ZUNvbHVtbkRpcmVjdGl2ZSxcclxuICAgIFV0aWxpdGllc01vZHVsZSxcclxuICBdLFxyXG4gIHByb3ZpZGVyczogW1xyXG4gICAgU3BhY2VDYXNlUGlwZSxcclxuICAgIERhdGVQaXBlLFxyXG4gICAgQ3VycmVuY3lQaXBlLFxyXG4gICAgUGhvbmVOdW1iZXJQaXBlLFxyXG4gICAgTXVsdGlTb3J0RGlyZWN0aXZlLFxyXG4gICAgVGFibGVCdWlsZGVyU3RhdGVTdG9yZSxcclxuICBdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBUYWJsZUJ1aWxkZXJNb2R1bGUge1xyXG4gIHN0YXRpYyBmb3JSb290KGNvbmZpZzogVGFibGVCdWlsZGVyQ29uZmlnKTogTW9kdWxlV2l0aFByb3ZpZGVyczxUYWJsZUJ1aWxkZXJNb2R1bGU+IHtcclxuICAgIHJldHVybiB7XHJcbiAgICAgIG5nTW9kdWxlOiBUYWJsZUJ1aWxkZXJNb2R1bGUsXHJcbiAgICAgIHByb3ZpZGVyczogW1xyXG4gICAgICAgIHsgcHJvdmlkZTogVGFibGVCdWlsZGVyQ29uZmlnVG9rZW4sIHVzZVZhbHVlOiBjb25maWcgfVxyXG4gICAgICBdXHJcbiAgICB9O1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2022/utilities/array-helpers.mjs

@@ -0,0 +1,14 @@
+export const replaceInArrayWithClone = (arr, findMeth, actionOnClone = ((t) => { })) => {
+    const index = arr.findIndex(findMeth);
+    const clonedArray = [...arr];
+    const t = clonedArray[index];
+    clonedArray[index] =
+        t != null && typeof t === 'object' ?
+            Array.isArray(t) ?
+                [...t]
+                : { ...t }
+            : t;
+    actionOnClone(clonedArray[index]);
+    return clonedArray;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXktaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdXRpbGl0aWVzL3NyYy91dGlsaXRpZXMvYXJyYXktaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSx1QkFBdUIsR0FBRyxDQUFVLEdBQVEsRUFBRSxRQUEyQixFQUFFLGdCQUErQixDQUFDLENBQUMsQ0FBSSxFQUFFLEVBQUUsR0FBRSxDQUFDLENBQUMsRUFBTyxFQUFFO0lBQzVJLE1BQU0sS0FBSyxHQUFHLEdBQUcsQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDdEMsTUFBTSxXQUFXLEdBQUcsQ0FBQyxHQUFHLEdBQUcsQ0FBQyxDQUFDO0lBQzdCLE1BQU0sQ0FBQyxHQUFHLFdBQVcsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM3QixXQUFXLENBQUMsS0FBSyxDQUFDO1FBQ2hCLENBQUMsSUFBSSxJQUFJLElBQUksT0FBTyxDQUFDLEtBQUssUUFBUSxDQUFDLENBQUM7WUFDbEMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUNoQixDQUFDLEdBQUcsQ0FBQyxDQUFRO2dCQUNiLENBQUMsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxFQUFFO1lBQ1osQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNSLGFBQWEsQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztJQUNsQyxPQUFPLFdBQVcsQ0FBQztBQUNyQixDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgcmVwbGFjZUluQXJyYXlXaXRoQ2xvbmUgPSA8VCA9IGFueT4oYXJyOiBUW10sIGZpbmRNZXRoOiAodDogVCkgPT4gYm9vbGVhbiwgYWN0aW9uT25DbG9uZTogKHQ6IFQpID0+IGFueSA9ICgodDogVCkgPT4ge30pKTogVFtdID0+IHtcclxuICBjb25zdCBpbmRleCA9IGFyci5maW5kSW5kZXgoZmluZE1ldGgpO1xyXG4gIGNvbnN0IGNsb25lZEFycmF5ID0gWy4uLmFycl07XHJcbiAgY29uc3QgdCA9IGNsb25lZEFycmF5W2luZGV4XTtcclxuICBjbG9uZWRBcnJheVtpbmRleF0gPVxyXG4gICAgdCAhPSBudWxsICYmIHR5cGVvZiB0ID09PSAnb2JqZWN0JyA/XHJcbiAgICAgIEFycmF5LmlzQXJyYXkodCkgP1xyXG4gICAgICAgIFsuLi50XSBhcyBhbnlcclxuICAgICAgICA6IHsgLi4udCB9XHJcbiAgICAgIDogdDtcclxuICBhY3Rpb25PbkNsb25lKGNsb25lZEFycmF5W2luZGV4XSk7XHJcbiAgcmV0dXJuIGNsb25lZEFycmF5O1xyXG59Il19

package/esm2022/utilities/directives/auto-focus.directive.mjs

@@ -0,0 +1,25 @@
+import { Directive, ElementRef, Input, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AutoFocusDirective {
+    elementRef = inject(ElementRef);
+    autoFocus = true;
+    ngAfterViewInit() {
+        if (this.autoFocus) {
+            setTimeout(() => {
+                this.elementRef.nativeElement.focus();
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: AutoFocusDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: AutoFocusDirective, isStandalone: true, selector: "[autoFocus]", inputs: { autoFocus: "autoFocus" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: AutoFocusDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[autoFocus]',
+                    standalone: true,
+                }]
+        }], propDecorators: { autoFocus: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0by1mb2N1cy5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXV0aWxpdGllcy9zcmMvdXRpbGl0aWVzL2RpcmVjdGl2ZXMvYXV0by1mb2N1cy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQWlCLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTXBGLE1BQU0sT0FBTyxrQkFBa0I7SUFDckIsVUFBVSxHQUFHLE1BQU0sQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUcvQixTQUFTLEdBQUcsSUFBSSxDQUFDO0lBRTFCLGVBQWU7UUFDYixJQUFHLElBQUksQ0FBQyxTQUFTLEVBQUMsQ0FBQztZQUNqQixVQUFVLENBQUMsR0FBRyxFQUFFO2dCQUNkLElBQUksQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDLEtBQUssRUFBRSxDQUFDO1lBQ3hDLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztJQUNILENBQUM7dUdBWlUsa0JBQWtCOzJGQUFsQixrQkFBa0I7OzJGQUFsQixrQkFBa0I7a0JBSjlCLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGFBQWE7b0JBQ3ZCLFVBQVUsRUFBRSxJQUFJO2lCQUNqQjs4QkFLVSxTQUFTO3NCQUFqQixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBFbGVtZW50UmVmLCBBZnRlclZpZXdJbml0LCBJbnB1dCwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5ARGlyZWN0aXZlKHtcclxuICBzZWxlY3RvcjogJ1thdXRvRm9jdXNdJyxcclxuICBzdGFuZGFsb25lOiB0cnVlLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgQXV0b0ZvY3VzRGlyZWN0aXZlIGltcGxlbWVudHMgQWZ0ZXJWaWV3SW5pdCB7XHJcbiAgcHJpdmF0ZSBlbGVtZW50UmVmID0gaW5qZWN0KEVsZW1lbnRSZWYpO1xyXG5cclxuXHJcbiAgQElucHV0KCkgYXV0b0ZvY3VzID0gdHJ1ZTtcclxuXHJcbiAgbmdBZnRlclZpZXdJbml0KCkge1xyXG4gICAgaWYodGhpcy5hdXRvRm9jdXMpe1xyXG4gICAgICBzZXRUaW1lb3V0KCgpID0+IHtcclxuICAgICAgICB0aGlzLmVsZW1lbnRSZWYubmF0aXZlRWxlbWVudC5mb2N1cygpO1xyXG4gICAgICB9KTtcclxuICAgIH1cclxuICB9XHJcblxyXG59XHJcbiJdfQ==

package/esm2022/utilities/directives/clickEmitterDirective.mjs

@@ -0,0 +1,22 @@
+import { Directive } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ClickEmitterDirective extends Subject {
+    constructor() {
+        super();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: ClickEmitterDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: ClickEmitterDirective, isStandalone: true, selector: "[clickEmitter]", host: { listeners: { "click": "next(true)" } }, exportAs: ["clickEmitter"], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: ClickEmitterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clickEmitter]',
+                    exportAs: 'clickEmitter',
+                    host: {
+                        '(click)': 'next(true)'
+                    },
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpY2tFbWl0dGVyRGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci11dGlsaXRpZXMvc3JjL3V0aWxpdGllcy9kaXJlY3RpdmVzL2NsaWNrRW1pdHRlckRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBVTVCLE1BQU0sT0FBTyxxQkFBc0IsU0FBUSxPQUFnQjtJQUM1RDtRQUNFLEtBQUssRUFBRSxDQUFDO0lBQ1YsQ0FBQzt1R0FIYSxxQkFBcUI7MkZBQXJCLHFCQUFxQjs7MkZBQXJCLHFCQUFxQjtrQkFQcEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsZ0JBQWdCO29CQUMxQixRQUFRLEVBQUUsY0FBYztvQkFDeEIsSUFBSSxFQUFFO3dCQUNKLFNBQVMsRUFBRSxZQUFZO3FCQUN4QjtvQkFDRCxVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgU3ViamVjdCB9IGZyb20gJ3J4anMnO1xyXG5cclxuXHJcbkBEaXJlY3RpdmUoe1xyXG4gIHNlbGVjdG9yOiAnW2NsaWNrRW1pdHRlcl0nLFxyXG4gIGV4cG9ydEFzOiAnY2xpY2tFbWl0dGVyJyxcclxuICBob3N0OiB7XHJcbiAgICAnKGNsaWNrKSc6ICduZXh0KHRydWUpJ1xyXG4gIH0sXHJcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcclxufSkgZXhwb3J0IGNsYXNzIENsaWNrRW1pdHRlckRpcmVjdGl2ZSBleHRlbmRzIFN1YmplY3Q8Ym9vbGVhbj4ge1xyXG4gIGNvbnN0cnVjdG9yKCkge1xyXG4gICAgc3VwZXIoKTtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/utilities/directives/clickSubject.mjs

@@ -0,0 +1,29 @@
+import { Directive, Input } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ClickSubjectDirective extends Subject {
+    constructor() {
+        super();
+    }
+    _val;
+    set clickSubject(val) {
+        this._val = val;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: ClickSubjectDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: ClickSubjectDirective, isStandalone: true, selector: "[clickSubject]", inputs: { clickSubject: "clickSubject" }, host: { listeners: { "click": "next(this._val)" } }, exportAs: ["clickSubject"], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: ClickSubjectDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clickSubject]',
+                    exportAs: 'clickSubject',
+                    host: {
+                        '(click)': 'next(this._val)'
+                    },
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [], propDecorators: { clickSubject: [{
+                type: Input,
+                args: ['clickSubject']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpY2tTdWJqZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci11dGlsaXRpZXMvc3JjL3V0aWxpdGllcy9kaXJlY3RpdmVzL2NsaWNrU3ViamVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNqRCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFDOztBQVM1QixNQUFNLE9BQU8scUJBQW1DLFNBQVEsT0FBVTtJQUNuRTtRQUNFLEtBQUssRUFBRSxDQUFDO0lBQ1YsQ0FBQztJQUNELElBQUksQ0FBSztJQUVULElBQTJCLFlBQVksQ0FBRSxHQUFNO1FBQzdDLElBQUksQ0FBQyxJQUFJLEdBQUcsR0FBRyxDQUFDO0lBQ2xCLENBQUM7dUdBUmEscUJBQXFCOzJGQUFyQixxQkFBcUI7OzJGQUFyQixxQkFBcUI7a0JBUHBDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGdCQUFnQjtvQkFDMUIsUUFBUSxFQUFFLGNBQWM7b0JBQ3hCLElBQUksRUFBRTt3QkFDSixTQUFTLEVBQUUsaUJBQWlCO3FCQUM3QjtvQkFDRCxVQUFVLEVBQUUsSUFBSTtpQkFDakI7d0RBTTRCLFlBQVk7c0JBQXRDLEtBQUs7dUJBQUMsY0FBYyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgU3ViamVjdCB9IGZyb20gJ3J4anMnO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcbiAgc2VsZWN0b3I6ICdbY2xpY2tTdWJqZWN0XScsXHJcbiAgZXhwb3J0QXM6ICdjbGlja1N1YmplY3QnLFxyXG4gIGhvc3Q6IHtcclxuICAgICcoY2xpY2spJzogJ25leHQodGhpcy5fdmFsKSdcclxuICB9LFxyXG4gIHN0YW5kYWxvbmU6IHRydWUsXHJcbn0pIGV4cG9ydCBjbGFzcyBDbGlja1N1YmplY3REaXJlY3RpdmU8VCA9IGJvb2xlYW4+IGV4dGVuZHMgU3ViamVjdDxUPiB7XHJcbiAgY29uc3RydWN0b3IoICkge1xyXG4gICAgc3VwZXIoKTtcclxuICB9XHJcbiAgX3ZhbCE6IFQ7XHJcblxyXG4gIEBJbnB1dCgnY2xpY2tTdWJqZWN0Jykgc2V0IGNsaWNrU3ViamVjdCggdmFsOiBUKSB7XHJcbiAgICB0aGlzLl92YWwgPSB2YWw7XHJcbiAgfVxyXG59XHJcbiJdfQ==

package/esm2022/utilities/directives/conditional-classes.directive.mjs

@@ -0,0 +1,36 @@
+import { Directive, ElementRef, Input, Renderer2, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ConditionalClassesDirective {
+    el = inject(ElementRef);
+    renderer = inject(Renderer2);
+    element;
+    classes;
+    classesApplied = [];
+    ngOnChanges(changes) {
+        let toApply = [];
+        if (this.classes) {
+            toApply = Object.keys(this.classes)
+                .filter(key => this.classes[key](this.element));
+        }
+        var classesNotYetApplied = toApply.filter(c => !this.classesApplied.includes(c));
+        var classesToRemove = this.classesApplied.filter(c => !toApply.includes(c));
+        classesToRemove.forEach(c => this.renderer.removeClass(this.el.nativeElement, c));
+        classesNotYetApplied.forEach(c => this.renderer.addClass(this.el.nativeElement, c));
+        this.classesApplied = toApply;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: ConditionalClassesDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: ConditionalClassesDirective, isStandalone: true, selector: "[conditionalClasses]", inputs: { element: "element", classes: ["conditionalClasses", "classes"] }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: ConditionalClassesDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[conditionalClasses]',
+                    standalone: true
+                }]
+        }], propDecorators: { element: [{
+                type: Input
+            }], classes: [{
+                type: Input,
+                args: ['conditionalClasses']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utilities/directives/dialog-service.mjs

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DialogService {
+    allOpenOpDialogs = [];
+    addDialogRef(ref) {
+        this.allOpenOpDialogs.push(ref);
+    }
+    removeDialogRef(ref) {
+        this.allOpenOpDialogs = this.allOpenOpDialogs.filter(rf => ref.id !== rf.id);
+    }
+    closeAllOpDialogs() {
+        this.allOpenOpDialogs.forEach(ref => ref.close());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: DialogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: DialogService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLXNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXV0aWxpdGllcy9zcmMvdXRpbGl0aWVzL2RpcmVjdGl2ZXMvZGlhbG9nLXNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQzs7QUFJMUMsTUFBTSxPQUFPLGFBQWE7SUFDeEIsZ0JBQWdCLEdBQXdCLEVBQUUsQ0FBQztJQUUzQyxZQUFZLENBQUMsR0FBc0I7UUFDakMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBRUQsZUFBZSxDQUFDLEdBQXNCO1FBQ3BDLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLEVBQUUsS0FBSyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDL0UsQ0FBQztJQUVELGlCQUFpQjtRQUNmLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQztJQUNwRCxDQUFDO3VHQWJVLGFBQWE7MkdBQWIsYUFBYSxjQURBLE1BQU07OzJGQUNuQixhQUFhO2tCQUR6QixVQUFVO21CQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBNYXREaWFsb2dSZWYgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9kaWFsb2cnO1xyXG5cclxuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcclxuZXhwb3J0IGNsYXNzIERpYWxvZ1NlcnZpY2Uge1xyXG4gIGFsbE9wZW5PcERpYWxvZ3M6IE1hdERpYWxvZ1JlZjxhbnk+W10gPSBbXTtcclxuXHJcbiAgYWRkRGlhbG9nUmVmKHJlZjogTWF0RGlhbG9nUmVmPGFueT4pIHtcclxuICAgIHRoaXMuYWxsT3Blbk9wRGlhbG9ncy5wdXNoKHJlZik7XHJcbiAgfVxyXG5cclxuICByZW1vdmVEaWFsb2dSZWYocmVmOiBNYXREaWFsb2dSZWY8YW55Pikge1xyXG4gICAgdGhpcy5hbGxPcGVuT3BEaWFsb2dzID0gdGhpcy5hbGxPcGVuT3BEaWFsb2dzLmZpbHRlcihyZiA9PiByZWYuaWQgIT09IHJmLmlkKTtcclxuICB9XHJcblxyXG4gIGNsb3NlQWxsT3BEaWFsb2dzKCkge1xyXG4gICAgdGhpcy5hbGxPcGVuT3BEaWFsb2dzLmZvckVhY2gocmVmID0+IHJlZi5jbG9zZSgpKTtcclxuICB9XHJcbn1cclxuIl19