@one-paragon/angular-utilities 0.1.21 → 0.1.23

package/esm2020/table-builder/pipes/format-filter-value.pipe.mjs

@@ -0,0 +1,46 @@
+import { Pipe } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { FieldType } from '../interfaces/report-def';
+import { FilterType } from '../enums/filterTypes';
+import { spaceCase } from '../../utilities/pipes/space-case.pipes';
+import * as i0 from "@angular/core";
+import * as i1 from "../classes/table-store";
+import * as i2 from "@angular/common";
+export class FormatFilterValuePipe {
+    constructor(tableState, datePipe) {
+        this.tableState = tableState;
+        this.datePipe = datePipe;
+    }
+    transform(value, key, filterType) {
+        return this.tableState.getMetaData$(key).pipe(map(md => {
+            if (filterType === FilterType.IsNull) {
+                return '';
+            }
+            if (value && (filterType === FilterType.In)) {
+                if (md.fieldType === FieldType.Enum) {
+                    return value.map((v) => spaceCase(md.additional.enumMap[v])).join(', ') ?? value;
+                }
+                return value.join(', ') ?? value;
+            }
+            if (filterType === FilterType.NumberBetween) {
+                if (md.fieldType === FieldType.Date) {
+                    value = this.datePipe.transform(value.Start, 'MM/dd/yy') + ' - ' + this.datePipe.transform(value.End, 'MM/dd/yy');
+                }
+                else {
+                    value = value.Start + ' - ' + value.End;
+                }
+            }
+            else if (md.fieldType === FieldType.Date) {
+                value = this.datePipe.transform(value, 'MM/dd/yy');
+            }
+            return value;
+        }));
+    }
+}
+FormatFilterValuePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FormatFilterValuePipe, deps: [{ token: i1.TableStore }, { token: i2.DatePipe }], target: i0.ɵɵFactoryTarget.Pipe });
+FormatFilterValuePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: FormatFilterValuePipe, name: "formatFilterValue" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FormatFilterValuePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'formatFilterValue' }]
+        }], ctorParameters: function () { return [{ type: i1.TableStore }, { type: i2.DatePipe }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/table-builder/pipes/key-display.mjs

@@ -0,0 +1,20 @@
+import { Pipe } from '@angular/core';
+import { spaceCase } from '../../utilities/pipes/space-case.pipes';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../classes/table-store";
+export class KeyDisplayPipe {
+    constructor(tableState) {
+        this.tableState = tableState;
+    }
+    transform(key) {
+        return this.tableState.getMetaData$(key).pipe(map(metaData => metaData.displayName || spaceCase(key)));
+    }
+}
+KeyDisplayPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: KeyDisplayPipe, deps: [{ token: i1.TableStore }], target: i0.ɵɵFactoryTarget.Pipe });
+KeyDisplayPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: KeyDisplayPipe, name: "keyDisplay" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: KeyDisplayPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'keyDisplay' }]
+        }], ctorParameters: function () { return [{ type: i1.TableStore }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5LWRpc3BsYXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXV0aWxpdGllcy9zcmMvdGFibGUtYnVpbGRlci9waXBlcy9rZXktZGlzcGxheS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUVwRCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFFbkUsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLGdCQUFnQixDQUFDOzs7QUFHckMsTUFBTSxPQUFPLGNBQWM7SUFDekIsWUFBb0IsVUFBc0I7UUFBdEIsZUFBVSxHQUFWLFVBQVUsQ0FBWTtJQUMxQyxDQUFDO0lBQ0QsU0FBUyxDQUFDLEdBQVc7UUFDbkIsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQzNDLEdBQUcsQ0FBRSxRQUFRLENBQUMsRUFBRSxDQUFDLFFBQVEsQ0FBQyxXQUFXLElBQUksU0FBUyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQ3pELENBQUM7SUFDSixDQUFDOzsyR0FQVSxjQUFjO3lHQUFkLGNBQWM7MkZBQWQsY0FBYztrQkFEMUIsSUFBSTttQkFBQyxFQUFDLElBQUksRUFBRSxZQUFZLEVBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IFRhYmxlU3RvcmUgfSBmcm9tICcuLi9jbGFzc2VzL3RhYmxlLXN0b3JlJztcclxuaW1wb3J0IHsgc3BhY2VDYXNlIH0gZnJvbSAnLi4vLi4vdXRpbGl0aWVzL3BpcGVzL3NwYWNlLWNhc2UucGlwZXMnO1xyXG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IG1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcclxuXHJcbkBQaXBlKHtuYW1lOiAna2V5RGlzcGxheSd9KVxyXG5leHBvcnQgY2xhc3MgS2V5RGlzcGxheVBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcclxuICBjb25zdHJ1Y3RvciggcHVibGljIHRhYmxlU3RhdGU6IFRhYmxlU3RvcmUpIHtcclxuICB9XHJcbiAgdHJhbnNmb3JtKGtleTogc3RyaW5nKTogT2JzZXJ2YWJsZTxzdHJpbmc+IHtcclxuICAgIHJldHVybiB0aGlzLnRhYmxlU3RhdGUuZ2V0TWV0YURhdGEkKGtleSkucGlwZShcclxuICAgICAgbWFwKCBtZXRhRGF0YSA9PiBtZXRhRGF0YS5kaXNwbGF5TmFtZSB8fCBzcGFjZUNhc2Uoa2V5KSlcclxuICAgICk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

package/esm2020/table-builder/services/export-to-csv.service.mjs

@@ -0,0 +1,84 @@
+import { Inject, Injectable } from '@angular/core';
+import { first, map } from 'rxjs/operators';
+import { combineLatest } from 'rxjs';
+import { orderMetaData } from '../classes/table-store';
+import { TableBuilderConfigToken } from '../classes/TableBuilderConfig';
+import { downloadData } from '../functions/download-data';
+import { ArrayStyle, FieldType } from '../interfaces/report-def';
+import { isPipe } from './transform-creator';
+import { get } from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "../classes/table-store";
+import * as i2 from "@angular/common";
+export class ExportToCsvService {
+    constructor(state, config, datePipe) {
+        this.state = state;
+        this.config = config;
+        this.datePipe = datePipe;
+        this.exportToCsv = (data) => {
+            const exportableFields$ = this.state.state$.pipe(map(mapExportableFields));
+            combineLatest([data, exportableFields$]).pipe(first(), map(([data, fields]) => this.csvData(data, fields))).subscribe(csv => downloadData(csv, 'export.csv', 'text/csv'));
+        };
+        this.csvData = (data, metaData) => {
+            const res = data.map(row => metaData.map(meta => this.metaToField(meta, row)).join(','));
+            res.unshift(metaData.map(meta => meta.displayName || meta.key).join(','));
+            return res.join('\n');
+        };
+        this.metaToField = (meta, row) => {
+            let val = get(row, meta.key);
+            if (val == null && !meta.transform)
+                return val;
+            if (meta.transform && meta.fieldType !== FieldType.Expression) {
+                const transform = meta.transform;
+                return isPipe(transform) ? transform.transform(val) : transform(val);
+            }
+            switch (meta.fieldType) {
+                case FieldType.Date:
+                    const dateFormat = meta.additional?.export?.dateFormat || this.config?.export?.dateFormat || meta.additional?.dateFormat;
+                    val = this.transform(val, dateFormat);
+                    break;
+                case FieldType.String:
+                    const prepend = meta.additional?.export?.prepend || this.config?.export?.prepend || '';
+                    val = prepend + val;
+                    break;
+                case FieldType.Array:
+                    const additional = meta.additional;
+                    val = val.slice(0, additional.limit).join(additional.arrayStyle === ArrayStyle.NewLine ? '\n' : ', ');
+                    break;
+                case FieldType.Expression:
+                    val = meta.transform(row);
+                    break;
+            }
+            if (typeof val === 'string' && (val.includes(',') || val.includes('"') || val.includes('\n'))) {
+                val = val.replaceAll('"', '""');
+                val = '"' + val + '"';
+            }
+            return val;
+        };
+    }
+    transform(val, dateFormat) {
+        if (this.config.transformers && this.config.transformers[FieldType.Date]) {
+            return this.config.transformers[FieldType.Date](val);
+        }
+        return this.datePipe.transform(val, dateFormat);
+    }
+}
+ExportToCsvService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ExportToCsvService, deps: [{ token: i1.TableStore }, { token: TableBuilderConfigToken }, { token: i2.DatePipe }], target: i0.ɵɵFactoryTarget.Injectable });
+ExportToCsvService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ExportToCsvService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ExportToCsvService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.TableStore }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TableBuilderConfigToken]
+                }] }, { type: i2.DatePipe }]; } });
+export const removeFromMetaData = (state, keysToRemove) => orderMetaData(state)
+    .filter(meta => !keysToRemove.includes(meta.key));
+export const nonExportableFields = (state) => Object.values(state.metaData)
+    .filter(md => md.noExport)
+    .map(md => md.key);
+export const mapExportableFields = (state) => {
+    const fieldsToRemove = nonExportableFields(state)
+        .concat(state.hiddenKeys);
+    return removeFromMetaData(state, fieldsToRemove);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"export-to-csv.service.js","sourceRoot":"","sources":["../../../../../projects/angular-utilities/src/table-builder/services/export-to-csv.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DatePipe } from '@angular/common';\r\nimport { Inject, Injectable } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\nimport { first, map  } from 'rxjs/operators';\r\nimport { combineLatest} from 'rxjs';\r\nimport { orderMetaData, TableStore } from '../classes/table-store';\r\nimport { TableBuilderConfig, TableBuilderConfigToken } from '../classes/TableBuilderConfig';\r\nimport { downloadData } from '../functions/download-data';\r\nimport { ArrayAdditional, ArrayStyle, FieldType, MetaData } from '../interfaces/report-def';\r\nimport { TableState } from '../classes/TableState';\r\nimport { isPipe } from './transform-creator';\r\nimport { get } from 'lodash';\r\n\r\n@Injectable()\r\nexport class ExportToCsvService<T> {\r\n  constructor(\r\n    public state: TableStore,\r\n    @Inject(TableBuilderConfigToken) private config: TableBuilderConfig,\r\n    private datePipe: DatePipe,\r\n  ){}\r\n\r\n  exportToCsv = (data: Observable<T[]>) => {\r\n    const exportableFields$ = this.state.state$.pipe(\r\n      map(mapExportableFields)\r\n    );\r\n\r\n    combineLatest([data,exportableFields$]).pipe(\r\n      first(),\r\n      map(([data,fields]) => this.csvData(data,fields)),\r\n    ).subscribe(csv => downloadData(csv,'export.csv','text/csv') );\r\n  }\r\n\r\n  csvData = (data:Array<T>, metaData: MetaData<T>[]) => {\r\n    const res = data.map(row => metaData.map(meta => this.metaToField(meta, row)).join(','));\r\n    res.unshift(metaData.map(meta => meta.displayName || meta.key).join(','));\r\n    return res.join('\\n');\r\n  }\r\n\r\n  metaToField = (meta: MetaData<T>, row: T) => {\r\n    let val: any = get( row,meta.key);\r\n    if (val == null && !meta.transform) return val\r\n    if(meta.transform && meta.fieldType !== FieldType.Expression){\r\n      const transform = meta.transform as any;\r\n      return  isPipe(transform) ? transform.transform(val) : transform(val);\r\n    }\r\n    switch (meta.fieldType) {\r\n      case FieldType.Date:\r\n        const dateFormat = meta.additional?.export?.dateFormat || this.config?.export?.dateFormat || meta.additional?.dateFormat;\r\n        val = this.transform(val, dateFormat);\r\n        break;\r\n      case FieldType.String:\r\n        const prepend: string = meta.additional?.export?.prepend || this.config?.export?.prepend || '';\r\n        val = prepend + val;\r\n        break;\r\n      case FieldType.Array:\r\n        const additional = meta.additional as ArrayAdditional;\r\n        val = (val as Array<string>).slice(0,additional.limit).join(additional.arrayStyle === ArrayStyle.NewLine ? '\\n' : ', ');\r\n        break;\r\n      case FieldType.Expression:\r\n        val = (meta.transform as any)(row);\r\n        break;\r\n    }\r\n    if (typeof val === 'string' && (val.includes(',') || val.includes('\"') || val.includes('\\n'))) {\r\n      val = val.replaceAll('\"', '\"\"');\r\n      val = '\"' + val + '\"';\r\n    }\r\n    return val;\r\n  }\r\n\r\n  private transform(val: any, dateFormat: any) {\r\n    if (this.config.transformers && this.config.transformers[FieldType.Date]) {\r\n      return this.config.transformers[FieldType.Date]!(val);\r\n    }\r\n    return this.datePipe.transform(val, dateFormat);\r\n  }\r\n}\r\n\r\nexport const removeFromMetaData = (state: TableState, keysToRemove: string[]) =>\r\n\r\n  orderMetaData(state)\r\n  .filter( meta => !keysToRemove.includes(meta.key));\r\n\r\n\r\nexport const nonExportableFields = (state: TableState) => Object.values( state.metaData)\r\n  .filter(md => md.noExport )\r\n  .map( md => md.key );\r\n\r\nexport const mapExportableFields = (state: TableState) => {\r\n  const fieldsToRemove = nonExportableFields(state)\r\n    .concat(state.hiddenKeys);\r\n   return removeFromMetaData(state, fieldsToRemove);\r\n}\r\n"]}

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

@@ -0,0 +1,42 @@
+import { get } from "lodash";
+export function createLinkCreator(metaData) {
+    const target = metaData.additional?.link?.target || metaData.additional?.target || '_blank';
+    const useRouterLink = metaData.additional?.link?.useRouterLink || metaData.additional?.useRouterLink;
+    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 || metaData.additional.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) :
+    metaData.additional.urlKey ?
+        (element) => get(element, metaData.additional.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/esm2020/table-builder/services/table-template-service.mjs

@@ -0,0 +1,43 @@
+import { Injectable } from "@angular/core";
+import { InitializationComponent } from "../components/initialization-component/initialization-component";
+import { FieldType } from "../interfaces/report-def";
+import * as i0 from "@angular/core";
+export class TableTemplateService {
+    constructor(resolver, i) {
+        const factory = resolver.resolveComponentFactory(InitializationComponent);
+        const c = factory.create(i);
+        this.instance = c.instance;
+        this.initTemplates();
+    }
+    initTemplates() {
+        this.templates = {};
+        this.templates[FieldType.Array] = this.instance.arrayTemplate;
+        this.templates[FieldType.Boolean] = this.instance.defaultWithIcon;
+        this.templates[FieldType.Currency] = this.instance.defaultTemplate;
+        this.templates[FieldType.Date] = this.instance.defaultTemplate;
+        this.templates[FieldType.Expression] = this.instance.defaultTemplate;
+        this.templates[FieldType.ImageUrl] = this.instance.imageUrlTemplate;
+        this.templates[FieldType.Link] = this.instance.linkTemplate;
+        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 = this.templates[metaData.fieldType];
+        if (metaData.useIcon) {
+            if (tmp === this.instance.defaultTemplate) {
+                tmp = this.instance.defaultWithIcon;
+            }
+        }
+        return tmp;
+    }
+}
+TableTemplateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TableTemplateService, deps: [{ token: i0.ComponentFactoryResolver }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+TableTemplateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TableTemplateService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TableTemplateService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,70 @@
+import { Inject, Injectable } from '@angular/core';
+import { FieldType } from '../interfaces/report-def';
+import { TableBuilderConfigToken } from '../classes/TableBuilderConfig';
+import { get } from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../utilities/pipes/phone.pipe";
+import * as i3 from "../../utilities";
+export function isPipe(o) {
+    return typeof (o.transform) === 'function';
+}
+export class TransformCreator {
+    constructor(datePipe, currencyPipe, phonePipe, casePipe, config) {
+        this.datePipe = datePipe;
+        this.currencyPipe = currencyPipe;
+        this.phonePipe = phonePipe;
+        this.casePipe = casePipe;
+        this.config = config;
+    }
+    createTransformer(metaData) {
+        const defaultFunc = (value) => get(value, metaData.key);
+        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 tranformer = this.config.transformers[metaData.fieldType];
+            return (value) => tranformer(defaultFunc(value));
+        }
+        switch (metaData.fieldType) {
+            case FieldType.Date:
+                const dateFormat = metaData.additional?.dateFormat ?? this.config.defaultSettings?.dateFormat ?? 'shortDate';
+                return (value) => this.datePipe.transform(defaultFunc(value), dateFormat);
+            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:
+                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;
+    }
+}
+TransformCreator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TransformCreator, deps: [{ token: i1.DatePipe }, { token: i1.CurrencyPipe }, { token: i2.PhoneNumberPipe }, { token: i3.SpaceCasePipe }, { token: TableBuilderConfigToken }], target: i0.ɵɵFactoryTarget.Injectable });
+TransformCreator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TransformCreator, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TransformCreator, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DatePipe }, { type: i1.CurrencyPipe }, { type: i2.PhoneNumberPipe }, { type: i3.SpaceCasePipe }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TableBuilderConfigToken]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,204 @@
+import { NgModule } from '@angular/core';
+import { GenericTableComponent } from './components/generic-table/generic-table.component';
+import { CustomCellDirective } from './directives/custom-cell-directive';
+import { GenColDisplayerComponent } from './components/gen-col-displayer/gen-col-displayer.component';
+import { GenFilterDisplayerComponent } from './components/table-container-filter/gen-filter-displayer/gen-filter-displayer.component';
+import { FilterComponent } from './components/filter/filter.component';
+import { CommonModule, DatePipe, CurrencyPipe } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { SpaceCasePipe } from '../utilities/pipes/space-case.pipes';
+import { MaterialModule } from './material.module';
+import { DateFilterComponent } from './components/date-filter/date-filter.component';
+import { TableContainerComponent } from './components/table-container/table-container';
+import { ColumnTotalPipe } from './pipes/column-total.pipe';
+import { MultiSortDirective } from './directives/multi-sort.directive';
+import { ColumnBuilderComponent } from './components/column-builder/column-builder.component';
+import { TableBuilderConfigToken } from './classes/TableBuilderConfig';
+import { NumberFilterComponent } from './components/number-filter/number-filter.component';
+import { StoreModule } from '@ngrx/store';
+import { storageStateReducer } from './ngrx/reducer';
+import { HeaderMenuComponent } from './components/header-menu/header-menu.component';
+import { EffectsModule } from '@ngrx/effects';
+import { SaveTableEffects } from './ngrx/effects';
+import { KeyDisplayPipe } from './pipes/key-display';
+import { PhoneNumberPipe } from '../utilities/pipes/phone.pipe';
+import { RouterModule } from '@angular/router';
+import { ArrayColumnComponent } from './components/array-column.component';
+import { LinkColumnComponent } from './components/link-column.component';
+import { InFilterComponent } from './components/in-filter/in-filter.component';
+import { FormatFilterValuePipe } from './pipes/format-filter-value.pipe';
+import { FormatFilterTypePipe } from './pipes/format-filter-type.pipe';
+import { ResizeColumnDirective } from './directives/resize-column.directive';
+import { LetModule } from '@ngrx/component';
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import { InitializationComponent } from './components/initialization-component/initialization-component';
+import { InListFilterComponent } from './components/filter/in-list/in-list-filter.component';
+import { SortMenuComponent } from './components/sort-menu/sort-menu.component';
+import { FilterChipsComponent } from './components/table-container-filter/filter-list/filter-list.component';
+import { PaginatorComponent } from './components/generic-table/paginator.component';
+import { UtilitiesModule } from '../utilities';
+import { MatButtonToggleFilterDirective, MatCheckboxTbFilterDirective, MatOptionTbFilterDirective, MatRadioButtonTbFilterDirective, MatSlideToggleTbFilterDirective, TableFilterDirective, TableFilterStringContainsDirective, } from './directives';
+import { TableWrapperDirective } from './directives/table-wrapper.directive';
+import { GroupByListComponent } from './components/group-by-list/group-by-list.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@ngrx/effects";
+export class TableBuilderModule {
+    static forRoot(config) {
+        return {
+            ngModule: TableBuilderModule,
+            providers: [
+                MultiSortDirective,
+                { provide: TableBuilderConfigToken, useValue: config }
+            ]
+        };
+    }
+}
+TableBuilderModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TableBuilderModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TableBuilderModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: TableBuilderModule, declarations: [ColumnTotalPipe,
+        TableContainerComponent,
+        GenericTableComponent,
+        PaginatorComponent,
+        CustomCellDirective,
+        GenColDisplayerComponent,
+        GenFilterDisplayerComponent,
+        DateFilterComponent,
+        FilterComponent,
+        MultiSortDirective,
+        NumberFilterComponent,
+        ColumnBuilderComponent,
+        ArrayColumnComponent,
+        LinkColumnComponent,
+        HeaderMenuComponent,
+        KeyDisplayPipe,
+        FormatFilterValuePipe,
+        FormatFilterTypePipe,
+        ResizeColumnDirective,
+        InFilterComponent,
+        InitializationComponent,
+        InListFilterComponent,
+        SortMenuComponent,
+        FilterChipsComponent,
+        MatSlideToggleTbFilterDirective,
+        MatRadioButtonTbFilterDirective,
+        MatOptionTbFilterDirective,
+        MatCheckboxTbFilterDirective,
+        MatButtonToggleFilterDirective,
+        TableFilterDirective,
+        TableFilterStringContainsDirective,
+        TableWrapperDirective,
+        GroupByListComponent], imports: [CommonModule,
+        MaterialModule, i1.StoreFeatureModule, i2.EffectsFeatureModule, FormsModule,
+        RouterModule,
+        LetModule,
+        DragDropModule,
+        UtilitiesModule], exports: [GenericTableComponent,
+        PaginatorComponent,
+        TableContainerComponent,
+        CustomCellDirective,
+        GenColDisplayerComponent,
+        GenFilterDisplayerComponent,
+        FilterComponent,
+        MultiSortDirective,
+        ResizeColumnDirective,
+        MatSlideToggleTbFilterDirective,
+        MatRadioButtonTbFilterDirective,
+        MatOptionTbFilterDirective,
+        MatCheckboxTbFilterDirective,
+        MatButtonToggleFilterDirective,
+        TableFilterDirective,
+        TableFilterStringContainsDirective,
+        TableWrapperDirective,
+        GroupByListComponent] });
+TableBuilderModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TableBuilderModule, providers: [
+        SpaceCasePipe,
+        DatePipe,
+        CurrencyPipe,
+        PhoneNumberPipe
+    ], imports: [CommonModule,
+        MaterialModule,
+        StoreModule.forFeature('globalStorageState', storageStateReducer),
+        EffectsModule.forFeature([SaveTableEffects]),
+        FormsModule,
+        RouterModule,
+        LetModule,
+        DragDropModule,
+        UtilitiesModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TableBuilderModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        MaterialModule,
+                        StoreModule.forFeature('globalStorageState', storageStateReducer),
+                        EffectsModule.forFeature([SaveTableEffects]),
+                        FormsModule,
+                        RouterModule,
+                        LetModule,
+                        DragDropModule,
+                        UtilitiesModule,
+                    ],
+                    exports: [
+                        GenericTableComponent,
+                        PaginatorComponent,
+                        TableContainerComponent,
+                        CustomCellDirective,
+                        GenColDisplayerComponent,
+                        GenFilterDisplayerComponent,
+                        FilterComponent,
+                        MultiSortDirective,
+                        ResizeColumnDirective,
+                        MatSlideToggleTbFilterDirective,
+                        MatRadioButtonTbFilterDirective,
+                        MatOptionTbFilterDirective,
+                        MatCheckboxTbFilterDirective,
+                        MatButtonToggleFilterDirective,
+                        TableFilterDirective,
+                        TableFilterStringContainsDirective,
+                        TableWrapperDirective,
+                        GroupByListComponent,
+                    ],
+                    declarations: [
+                        ColumnTotalPipe,
+                        TableContainerComponent,
+                        GenericTableComponent,
+                        PaginatorComponent,
+                        CustomCellDirective,
+                        GenColDisplayerComponent,
+                        GenFilterDisplayerComponent,
+                        DateFilterComponent,
+                        FilterComponent,
+                        MultiSortDirective,
+                        NumberFilterComponent,
+                        ColumnBuilderComponent,
+                        ArrayColumnComponent,
+                        LinkColumnComponent,
+                        HeaderMenuComponent,
+                        KeyDisplayPipe,
+                        FormatFilterValuePipe,
+                        FormatFilterTypePipe,
+                        ResizeColumnDirective,
+                        InFilterComponent,
+                        InitializationComponent,
+                        InListFilterComponent,
+                        SortMenuComponent,
+                        FilterChipsComponent,
+                        MatSlideToggleTbFilterDirective,
+                        MatRadioButtonTbFilterDirective,
+                        MatOptionTbFilterDirective,
+                        MatCheckboxTbFilterDirective,
+                        MatButtonToggleFilterDirective,
+                        TableFilterDirective,
+                        TableFilterStringContainsDirective,
+                        TableWrapperDirective,
+                        GroupByListComponent,
+                    ],
+                    providers: [
+                        SpaceCasePipe,
+                        DatePipe,
+                        CurrencyPipe,
+                        PhoneNumberPipe
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-builder.module.js","sourceRoot":"","sources":["../../../../projects/angular-utilities/src/table-builder/table-builder.module.ts"],"names":[],"mappings":"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","sourcesContent":["\r\nimport { NgModule } from '@angular/core';\r\nimport { GenericTableComponent } from './components/generic-table/generic-table.component';\r\nimport { CustomCellDirective } from './directives/custom-cell-directive';\r\nimport { GenColDisplayerComponent } from './components/gen-col-displayer/gen-col-displayer.component';\r\nimport { GenFilterDisplayerComponent } from './components/table-container-filter/gen-filter-displayer/gen-filter-displayer.component';\r\nimport { FilterComponent } from './components/filter/filter.component';\r\nimport { CommonModule, DatePipe, CurrencyPipe } from '@angular/common';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { SpaceCasePipe } from '../utilities/pipes/space-case.pipes';\r\nimport { MaterialModule } from './material.module';\r\nimport { DateFilterComponent } from './components/date-filter/date-filter.component';\r\nimport { TableContainerComponent } from './components/table-container/table-container';\r\nimport { ColumnTotalPipe } from './pipes/column-total.pipe';\r\nimport { MultiSortDirective } from './directives/multi-sort.directive';\r\nimport { ColumnBuilderComponent } from './components/column-builder/column-builder.component';\r\nimport { ModuleWithProviders } from '@angular/core';\r\nimport { TableBuilderConfig, TableBuilderConfigToken } from './classes/TableBuilderConfig';\r\nimport { NumberFilterComponent } from './components/number-filter/number-filter.component';\r\nimport { StoreModule } from '@ngrx/store';\r\nimport { storageStateReducer } from './ngrx/reducer';\r\nimport { HeaderMenuComponent } from './components/header-menu/header-menu.component';\r\nimport { EffectsModule } from '@ngrx/effects';\r\nimport { SaveTableEffects } from './ngrx/effects';\r\nimport { KeyDisplayPipe } from './pipes/key-display';\r\nimport { PhoneNumberPipe } from '../utilities/pipes/phone.pipe';\r\nimport { RouterModule } from '@angular/router';\r\nimport { ArrayColumnComponent } from './components/array-column.component';\r\nimport { LinkColumnComponent } from './components/link-column.component';\r\nimport { InFilterComponent } from './components/in-filter/in-filter.component';\r\nimport { FormatFilterValuePipe } from './pipes/format-filter-value.pipe';\r\nimport { FormatFilterTypePipe } from './pipes/format-filter-type.pipe';\r\nimport { ResizeColumnDirective } from './directives/resize-column.directive';\r\nimport {LetModule} from '@ngrx/component'\r\nimport { DragDropModule } from '@angular/cdk/drag-drop';\r\nimport { InitializationComponent } from './components/initialization-component/initialization-component';\r\nimport { InListFilterComponent } from './components/filter/in-list/in-list-filter.component';\r\nimport { SortMenuComponent } from './components/sort-menu/sort-menu.component';\r\nimport { FilterChipsComponent } from './components/table-container-filter/filter-list/filter-list.component';\r\nimport { PaginatorComponent } from './components/generic-table/paginator.component';\r\nimport { UtilitiesModule } from '../utilities';\r\nimport {\r\n  MatButtonToggleFilterDirective,\r\n  MatCheckboxTbFilterDirective,\r\n  MatOptionTbFilterDirective,\r\n  MatRadioButtonTbFilterDirective,\r\n  MatSlideToggleTbFilterDirective,\r\n  TableFilterDirective,\r\n  TableFilterStringContainsDirective,\r\n} from './directives';\r\nimport { TableWrapperDirective } from './directives/table-wrapper.directive';\r\nimport { GroupByListComponent } from './components/group-by-list/group-by-list.component';\r\n\r\n@NgModule({\r\n  imports: [\r\n    CommonModule,\r\n    MaterialModule,\r\n    StoreModule.forFeature('globalStorageState', storageStateReducer),\r\n    EffectsModule.forFeature([SaveTableEffects]),\r\n    FormsModule,\r\n    RouterModule,\r\n    LetModule,\r\n    DragDropModule,\r\n    UtilitiesModule,\r\n  ],\r\n    exports: [\r\n        GenericTableComponent,\r\n        PaginatorComponent,\r\n        TableContainerComponent,\r\n        CustomCellDirective,\r\n        GenColDisplayerComponent,\r\n        GenFilterDisplayerComponent,\r\n        FilterComponent,\r\n        MultiSortDirective,\r\n        ResizeColumnDirective,\r\n        MatSlideToggleTbFilterDirective,\r\n        MatRadioButtonTbFilterDirective,\r\n        MatOptionTbFilterDirective,\r\n        MatCheckboxTbFilterDirective,\r\n        MatButtonToggleFilterDirective,\r\n        TableFilterDirective,\r\n        TableFilterStringContainsDirective,\r\n        TableWrapperDirective,\r\n        GroupByListComponent,\r\n    ],\r\n    declarations: [\r\n        ColumnTotalPipe,\r\n        TableContainerComponent,\r\n        GenericTableComponent,\r\n        PaginatorComponent,\r\n        CustomCellDirective,\r\n        GenColDisplayerComponent,\r\n        GenFilterDisplayerComponent,\r\n        DateFilterComponent,\r\n        FilterComponent,\r\n        MultiSortDirective,\r\n        NumberFilterComponent,\r\n        ColumnBuilderComponent,\r\n        ArrayColumnComponent,\r\n        LinkColumnComponent,\r\n        HeaderMenuComponent,\r\n        KeyDisplayPipe,\r\n        FormatFilterValuePipe,\r\n        FormatFilterTypePipe,\r\n        ResizeColumnDirective,\r\n        InFilterComponent,\r\n        InitializationComponent,\r\n        InListFilterComponent,\r\n        SortMenuComponent,\r\n        FilterChipsComponent,\r\n        MatSlideToggleTbFilterDirective,\r\n        MatRadioButtonTbFilterDirective,\r\n        MatOptionTbFilterDirective,\r\n        MatCheckboxTbFilterDirective,\r\n        MatButtonToggleFilterDirective,\r\n        TableFilterDirective,\r\n        TableFilterStringContainsDirective,\r\n        TableWrapperDirective,\r\n        GroupByListComponent,\r\n    ],\r\n    providers : [\r\n      SpaceCasePipe,\r\n      DatePipe,\r\n      CurrencyPipe,\r\n      PhoneNumberPipe\r\n    ]\r\n})\r\nexport class TableBuilderModule {\r\n  static forRoot(config: TableBuilderConfig): ModuleWithProviders<TableBuilderModule> {\r\n    return {\r\n      ngModule: TableBuilderModule,\r\n      providers: [\r\n        MultiSortDirective,\r\n        { provide : TableBuilderConfigToken , useValue: config}\r\n      ]\r\n    };\r\n  }\r\n}\r\n"]}