@one-paragon/angular-utilities 0.3.11-beta.1 → 0.4.0

package/esm2022/table-builder/classes/table-store.mjs

@@ -0,0 +1,320 @@
+import { FieldType } from '../interfaces/report-def';
+import { v4 as uuid } from 'uuid';
+import { defaultTableState, InitializationState, keysToDelete } from './TableState';
+import { Injectable, Inject } from '@angular/core';
+import { TableBuilderConfigToken } from './TableBuilderConfig';
+import { isCustomFilter, isFilterInfo } from './filter-info';
+import { ComponentStore } from '@ngrx/component-store';
+import { distinctUntilChanged, filter, last, map, tap } from 'rxjs/operators';
+import { moveItemInArray } from '@angular/cdk/drag-drop';
+import { notNull, onceWhen } from '../../rxjs/rxjs-operators';
+import { NotPersistedTableSettings, PersistedTableSettings } from './table-builder-general-settings';
+import { replaceInArrayWithClone } from '../../utilities/array-helpers';
+import { isDifferent } from '../directives';
+import * as i0 from "@angular/core";
+export function stateIs(initializationState) {
+    return (state) => state.initializationState === initializationState;
+}
+export class TableStore extends ComponentStore {
+    constructor(config) {
+        super({ ...defaultTableState, ...config.defaultTableState });
+        this.selectStateReady = this.select(state => state.initializationState).pipe(filter(i => i === InitializationState.Ready));
+        this.on = (srcObservable, func) => {
+            this.effect(() => srcObservable.pipe(tap(func)));
+            return this;
+        };
+        this.metaData$ = this.select(state => state.metaData);
+        this.metaDataArray = this.selectSignal(this.state, orderMetaData);
+        this.metaDataArray$ = this.select(this.state$, orderMetaData);
+        this.getMetaData$ = (key) => {
+            return this.select(state => state.metaData[key]).pipe(tap(meta => { if (!meta)
+                console.warn(`Meta data with key ${key} not found`); }), notNull());
+        };
+        this.getUserDefinedWidth$ = (key) => this.select(state => state.userDefined.widths[key]);
+        this.getUserDefinedWidth = (key) => this.selectSignal(state => state.userDefined.widths[key]);
+        this.getUserDefinedWidths$ = this.select(state => state.userDefined.widths);
+        this.getUserDefinedWidths = this.selectSignal(state => state.userDefined.widths);
+        this.displayedColumns = (state) => orderMetaData(state).map(md => md.key)
+            .filter(key => !state.hiddenKeys.includes(key) && state.metaData[key].fieldType !== FieldType.Hidden);
+        this.displayedColumns$ = this.select(this.displayedColumns);
+        this.hideColumn = this.updater((state, key) => ({
+            ...state,
+            hiddenKeys: [...state.hiddenKeys.filter(k => k !== key), key],
+        }));
+        this.resetState = this.updater((state) => {
+            const hiddenKeys = Object.values(state.metaData)
+                .filter(md => md.fieldType === FieldType.Hidden)
+                .map(md => md.key);
+            const sorted = this.createPreSort(state.metaData);
+            return ({ ...state, hiddenKeys, sorted, filters: {}, groupBy: [], userDefined: { widths: {}, order: {}, table: {} } });
+        });
+        this.showColumn = this.updater((state, key) => ({
+            ...state,
+            hiddenKeys: state.hiddenKeys.filter(k => k !== key),
+        }));
+        this.setHiddenColumns = this.updater((state, displayCols) => {
+            var hiddenKeysSet = new Set([
+                ...displayCols.filter(col => !col.visible).map(col => col.key),
+                ...Object.values(state.metaData).filter(md => md.fieldType === FieldType.Hidden).map(md => md.key)
+            ]);
+            return ({ ...state, hiddenKeys: [...hiddenKeysSet] });
+        });
+        this.setUserDefinedWidth = this.updater((state, colWidths) => {
+            const userDefinedWidths = { ...state.userDefined.widths };
+            colWidths.forEach(cw => {
+                userDefinedWidths[cw.key] = cw.widthInPixel;
+            });
+            return { ...state, userDefined: { ...state.userDefined, widths: userDefinedWidths } };
+        });
+        this.setUserDefinedOrder = this.updater((state, moved) => {
+            const { newOrder, oldOrder } = moved;
+            const mdsArr = orderViewableMetaData(state);
+            moveItemInArray(mdsArr, oldOrder, newOrder);
+            const userDefinedOrder = mdsArr.reduce((aggregate, current, index) => {
+                aggregate[current.key] = index;
+                return aggregate;
+            }, {});
+            return ({ ...state, userDefined: { ...state.userDefined, order: userDefinedOrder } });
+        });
+        this.filters$ = this.select(state => state.filters);
+        this.getFilter$ = (filterId) => {
+            return this.select(state => state.filters[filterId]);
+        };
+        this.addFilter = this.updater((state, filter) => {
+            return this.addFiltersToState(state, [filter]);
+        });
+        this.addFilters = this.updater((state, filters) => {
+            return this.addFiltersToState(state, filters);
+        });
+        this.addFiltersToState = (state, filters) => {
+            var customFilters = filters.filter(isCustomFilter);
+            var filterInfos = filters.filter(isFilterInfo);
+            const filtersObj = filterInfos
+                .filter(fltr => Object.keys(state.metaData).some(key => key === fltr.key) || console.warn(`Meta data with key ${fltr.key} not found`))
+                .reduce((filtersObj, filter) => {
+                if (!filter.filterId) {
+                    filter.filterId = uuid();
+                }
+                filtersObj[filter.filterId] = filter;
+                return filtersObj;
+            }, {});
+            customFilters.forEach(fltr => {
+                if (!fltr.filterId) {
+                    fltr.filterId = uuid();
+                }
+                filtersObj[fltr.filterId] = fltr;
+            });
+            return {
+                ...state,
+                filters: { ...state.filters, ...filtersObj }
+            };
+        };
+        this.removeFilter = this.updater((state, filterId) => {
+            const filtersCopy = { ...state.filters };
+            delete filtersCopy[filterId];
+            return ({ ...state, filters: filtersCopy });
+        });
+        this.removeFilters = this.updater((state, filterIds) => {
+            const filtersCopy = { ...state.filters };
+            filterIds.forEach(id => { delete filtersCopy[id]; });
+            return ({ ...state, filters: filtersCopy });
+        });
+        this.clearFilters = this.updater((state) => ({ ...state, filters: {} }));
+        this.selectSorted = this.select(state => state.sorted).pipe(distinctUntilChanged((f, s) => !isDifferent(f, s)));
+        this.sort$ = this.select(this.selectStateReady, this.selectSorted, (_, s) => s);
+        this.createPreSort = (metaDatas) => {
+            return Object.values(metaDatas).filter((metaData) => !!metaData.preSort)
+                .sort(({ preSort: ps1 }, { preSort: ps2 }) => (ps1.precedence || Number.MAX_VALUE) - (ps2.precedence || Number.MAX_VALUE))
+                .map(({ key, preSort }) => ({ active: key, direction: preSort.direction }));
+        };
+        this.setSort = this.updater((state, { key, direction }) => {
+            const sortArray = state.sorted.filter(s => s.active !== key);
+            if (direction) {
+                sortArray.unshift({ active: key, direction });
+            }
+            return {
+                ...state,
+                sorted: sortArray,
+            };
+        });
+        this.setAllSort = this.updater((state, sortArray) => {
+            return {
+                ...state,
+                sorted: sortArray,
+            };
+        });
+        this.updateStateFunc = (state, incomingTableState) => {
+            const metaData = state.metaData;
+            const sorted = incomingTableState.sorted?.length ? incomingTableState.sorted
+                : state.initializationState === InitializationState.Created ? this.createPreSort(metaData) : state.sorted;
+            return { ...state, ...incomingTableState, metaData, sorted };
+        };
+        this.setPageSize = this.updater((state, pageSize) => ({ ...state, pageSize, userDefined: { ...state.userDefined, pageSize } }));
+        this.getPageSize = this.select(state => state.userDefined.pageSize || state.pageSize);
+        this.updateState = this.updater(this.updateStateFunc);
+        this.updateStateFromPersistedState = this.updater((state, persistedState) => {
+            const incomingTableState = this.cleanPersistedState(state, persistedState);
+            const newState = this.updateStateFunc(state, incomingTableState);
+            newState.initializationState = state.initializationState === InitializationState.MetaDataLoaded ? InitializationState.LoadedFromStore : state.initializationState;
+            return newState;
+        });
+        this.getUserDefinedTableSize = this.selectSignal(state => state.userDefined.table.width);
+        this.getUserDefinedTableSize$ = this.select(state => state.userDefined.table.width);
+        this.setTableWidth = this.updater((state, widthInPixels) => ({ ...state, userDefined: { ...state.userDefined, table: { width: widthInPixels } } }));
+        this.mergeMeta = (orig, merge) => {
+            return {
+                key: orig.key,
+                displayName: merge.displayName ?? orig.displayName,
+                fieldType: merge.fieldType || orig.fieldType,
+                additional: { ...orig.additional, ...merge.additional },
+                order: merge.order ?? orig.order,
+                preSort: merge.preSort ?? orig.preSort,
+                _internalNotUserDefined: merge._internalNotUserDefined || orig._internalNotUserDefined,
+                width: merge.width ?? orig.width,
+                noExport: merge.noExport || orig.noExport,
+                noFilter: merge.noFilter || orig.noFilter,
+                customCell: merge.customCell ?? orig.customCell,
+                transform: merge.transform ?? orig.transform,
+                click: merge.click ?? orig.click,
+                classes: merge.classes ?? orig.classes,
+                noSort: merge.noSort ?? orig.noSort,
+                template: merge.template ?? orig.template,
+                toolTip: merge.toolTip ?? orig.toolTip,
+                useIcon: merge.useIcon ?? orig.useIcon,
+            };
+        };
+        this.setInitializationState = this.updater((state, initializationState) => {
+            return { ...state, initializationState };
+        });
+        this.setMetaData = this.updater((state, md) => {
+            const metaData = (Array.isArray(md) ? [...md] : [md])
+                .reduce((prev, curr) => {
+                if (prev[curr.key]) {
+                    prev[curr.key] = this.mergeMeta(prev[curr.key], curr);
+                }
+                else {
+                    prev[curr.key] = curr;
+                }
+                return prev;
+            }, {});
+            let sorted = state.sorted;
+            if (sorted.length === 0) {
+                sorted = this.createPreSort(metaData);
+            }
+            const order = this.initializeOrder(state, metaData);
+            const initializationState = state.initializationState == InitializationState.Created ? InitializationState.MetaDataLoaded : state.initializationState;
+            return { ...state, initializationState, metaData, sorted, userDefined: { ...state.userDefined, order: order } };
+        });
+        this.initializeOrder = (state, mds) => {
+            const viewableMetaDataArr = Object.values(mds).filter(a => a.fieldType !== FieldType.Hidden);
+            let userDefinedOrder = state.userDefined.order;
+            if (viewableMetaDataArr.some(meta => userDefinedOrder[meta.key] == null)) {
+                return {};
+            }
+            return userDefinedOrder;
+        };
+        this.toggleCollapseHeader = this.updater((state) => {
+            const tableSettings = { ...state.persistedTableSettings };
+            tableSettings.collapseHeader = !tableSettings.collapseHeader;
+            return ({ ...state, persistedTableSettings: new PersistedTableSettings(tableSettings) });
+        });
+        this.toggleCollapseFooter = this.updater((state) => {
+            const tableSettings = { ...state.persistedTableSettings };
+            tableSettings.collapseFooter = !tableSettings.collapseFooter;
+            return ({ ...state, persistedTableSettings: new PersistedTableSettings(tableSettings) });
+        });
+        this.addGroupByKey = this.updater((state, groupByKey) => ({
+            ...state,
+            groupBy: [...state.groupBy, { key: groupByKey, expandedHeaders: [] }]
+        }));
+        this.removeGroupByKey = this.updater((state, groupByKey) => ({
+            ...state,
+            groupBy: state.groupBy.filter(key => groupByKey !== key.key)
+        }));
+        this.updateExpandedGroups = this.updater((state, data) => {
+            const gbk = replaceInArrayWithClone(state.groupBy, k => k.key === data.key, gk => {
+                gk.expandedHeaders = data.isExpanded ? [...gk.expandedHeaders, data.groupKey] : gk.expandedHeaders.filter(g => g !== data.groupKey);
+            });
+            return ({
+                ...state,
+                groupBy: gbk
+            });
+        });
+        this.groupByKeys$ = this.select(state => state.groupBy.map(gbk => gbk.key))
+            .pipe(distinctUntilChanged((prev, curr) => prev.length === curr.length && curr.every((k, i) => prev[i] === k)));
+        this.expandedGroups$ = this.select(state => state.groupBy).pipe(distinctUntilChanged((a, b) => {
+            const aa = a.flatMap(g => g.expandedHeaders);
+            const bb = b.flatMap(g => g.expandedHeaders);
+            return aa.length === bb.length && aa.every((k) => bb.includes(k));
+        }));
+        this.setTableSettings = this.updater((state, settings) => {
+            const s = {
+                ...state,
+                persistedTableSettings: new PersistedTableSettings(settings),
+                notPersistedTableSettings: new NotPersistedTableSettings(settings)
+            };
+            return s;
+        });
+        this.tableSettings = this.selectSignal(state => {
+            const ts = { ...state.persistedTableSettings, ...state.notPersistedTableSettings };
+            return ts;
+        });
+        this.tableSettings$ = this.select(state => {
+            const ts = { ...state.persistedTableSettings, ...state.notPersistedTableSettings };
+            return ts;
+        });
+        this.props = this.selectSignal(s => s.props);
+        this.setLinkMaps = this.updater((state, maps) => {
+            return { ...state, linkMaps: maps };
+        });
+        this.getLinkInfo = (md) => this.selectSignal(state => state.linkMaps[md.key]);
+        this.getIsExpanded = (columnKey, groupHeaderKey) => {
+            return this.select(state => !!state.groupBy.filter(g => g.key === columnKey && g.expandedHeaders.includes(groupHeaderKey)).length);
+        };
+    }
+    getSavableState() {
+        return this.state$.pipe(map(s => {
+            const savableState = { ...s };
+            keysToDelete.forEach(key => delete savableState[key]);
+            return savableState;
+        }));
+    }
+    onLast(callback) {
+        this.on(this.state$.pipe(last()), callback);
+    }
+    cleanPersistedState(state, pState) {
+        const metas = Object.values(state.metaData);
+        const filters = Object.values(pState.filters).filter(fltr => isCustomFilter(fltr) || metas.some(m => m.key === fltr.key)).reduce((obj, filter) => {
+            obj[filter.filterId] = pState.filters[filter.filterId];
+            return obj;
+        }, {});
+        const sorted = pState.sorted.filter(s => metas.some(m => m.key === s.active));
+        return ({ ...pState, filters, sorted });
+    }
+    runOnceWhen(predicate, func) {
+        const obs = this.state$.pipe(onceWhen(predicate));
+        this.on(obs, (state) => {
+            func(state);
+        });
+    }
+    onReady(func) {
+        this.runOnceWhen(stateIs(InitializationState.Ready), func);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: TableStore, deps: [{ token: TableBuilderConfigToken }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: TableStore }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: TableStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TableBuilderConfigToken]
+                }] }] });
+export const orderViewableMetaData = (state) => orderMetaData(state).filter(a => a.fieldType !== FieldType.Hidden);
+export const orderMetaData = (state) => {
+    const userOrderArr = Object.entries(state.userDefined.order);
+    return userOrderArr.length ?
+        Object.values(state.metaData).sort((a, b) => state.userDefined.order[a.key] - state.userDefined.order[b.key])
+        :
+            Object.values(state.metaData).sort((a, b) => a.order - b.order);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-store.js","sourceRoot":"","sources":["../../../../../projects/angular-utilities/src/table-builder/classes/table-store.ts"],"names":[],"mappings":"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","sourcesContent":["import { FieldType, MetaData, SortDef } from '../interfaces/report-def';\r\nimport { v4 as uuid } from 'uuid';\r\nimport { Observable } from 'rxjs';\r\nimport { defaultTableState, InitializationState, keysToDelete, PersistedTableState, TableState } from './TableState';\r\nimport { Injectable, Inject, Predicate } from '@angular/core';\r\nimport { TableBuilderConfig, TableBuilderConfigToken } from './TableBuilderConfig';\r\nimport { CustomFilter, FilterInfo, isCustomFilter, isFilterInfo } from './filter-info';\r\nimport { Sort, SortDirection }  from '@angular/material/sort' ;\r\nimport { ComponentStore } from '@ngrx/component-store'  ;\r\nimport { Dictionary } from '../interfaces/dictionary';\r\nimport { distinctUntilChanged, filter, last, map, tap } from 'rxjs/operators'\r\nimport { moveItemInArray } from '@angular/cdk/drag-drop';\r\nimport { notNull, onceWhen } from '../../rxjs/rxjs-operators';\r\nimport { GeneralTableSettings, NotPersistedTableSettings, PersistedTableSettings } from './table-builder-general-settings';\r\nimport { replaceInArrayWithClone } from '../../utilities/array-helpers';\r\nimport { isDifferent } from '../directives';\r\n\r\nexport function stateIs(initializationState: InitializationState) {\r\n  return (state: TableState) => state.initializationState === initializationState;\r\n}\r\n\r\n@Injectable()\r\nexport class TableStore extends ComponentStore<TableState> {\r\n\r\n  constructor(@Inject(TableBuilderConfigToken) config: TableBuilderConfig) {\r\n   super( { ...defaultTableState, ...config.defaultTableState});\r\n  }\r\n\r\n  selectStateReady = this.select(state => state.initializationState).pipe(filter(i => i === InitializationState.Ready));\r\n  getSavableState() : Observable<PersistedTableState> {\r\n    return  this.state$.pipe(\r\n      map( s => {\r\n        const savableState = {...s} as Partial<TableState>;\r\n        keysToDelete.forEach(key => delete savableState[key]);\r\n        return savableState as PersistedTableState;\r\n      })\r\n    );\r\n  }\r\n\r\n  on = <V>(srcObservable: Observable<V>, func: (obj: V) => void) => {\r\n    this.effect(() => srcObservable.pipe(\r\n      tap(func)\r\n    ));\r\n    return this;\r\n  }\r\n\r\n  onLast(callback: (state: TableState) => void ) {\r\n    this.on(this.state$.pipe(last()),callback);\r\n  }\r\n\r\n  readonly metaData$ = this.select( state => state.metaData);\r\n\r\n  metaDataArray = this.selectSignal(\r\n    this.state,\r\n    orderMetaData\r\n  )\r\n  readonly metaDataArray$ = this.select(\r\n    this.state$,\r\n    orderMetaData\r\n  );\r\n\r\n  getMetaData$ = (key: string) : Observable<MetaData> => {\r\n    return this.select( state => state.metaData[key]  ).pipe(\r\n      tap(meta => {if(!meta)console.warn(`Meta data with key ${key} not found`)}),\r\n      notNull())\r\n  }\r\n\r\n  getUserDefinedWidth$ = (key:string) => this.select(state => state.userDefined.widths[key]);\r\n  getUserDefinedWidth = (key:string) => this.selectSignal(state => state.userDefined.widths[key]);\r\n  getUserDefinedWidths$ = this.select(state => state.userDefined.widths);\r\n  getUserDefinedWidths = this.selectSignal(state => state.userDefined.widths);\r\n  private displayedColumns =  (state:TableState) => orderMetaData(state).map(md => md.key)\r\n    .filter(key => !state.hiddenKeys.includes(key) && state.metaData[key].fieldType !== FieldType.Hidden);\r\n  readonly displayedColumns$ = this.select(this.displayedColumns);\r\n  readonly hideColumn = this.updater((state, key: string) => ({\r\n    ...state,\r\n    hiddenKeys: [...state.hiddenKeys.filter( k => k !== key), key],\r\n  }));\r\n\r\n  readonly resetState = this.updater((state) => {\r\n    const hiddenKeys = Object.values(state.metaData)\r\n      .filter(md => md.fieldType === FieldType.Hidden)\r\n      .map(md => md.key);\r\n    const sorted = this.createPreSort(state.metaData);\r\n    return ({...state, hiddenKeys, sorted, filters: {} , groupBy: [],  userDefined: {widths:{},order:{},table:{}} });\r\n  });\r\n\r\n  readonly showColumn = this.updater((state, key: string) => ({\r\n    ...state,\r\n    hiddenKeys: state.hiddenKeys.filter( k => k !== key),\r\n  }));\r\n\r\n  readonly setHiddenColumns = this.updater((state, displayCols: {key: string, visible: boolean}[]) => {\r\n\r\n    var hiddenKeysSet= new Set<string>(\r\n      [\r\n        ...displayCols.filter(col => !col.visible).map(col => col.key),\r\n        ...Object.values(state.metaData).filter(md => md.fieldType === FieldType.Hidden).map(md => md.key)\r\n      ]\r\n    );\r\n\r\n    return ({...state, hiddenKeys: [...hiddenKeysSet]})\r\n  });\r\n\r\n\r\n  setUserDefinedWidth = this.updater((state,colWidths:{key: string, widthInPixel:number}[]) => {\r\n    const userDefinedWidths = {...state.userDefined.widths};\r\n    colWidths.forEach(cw => {\r\n      userDefinedWidths[cw.key] = cw.widthInPixel;\r\n    });\r\n    return {...state, userDefined: {...state.userDefined, widths:userDefinedWidths}};\r\n  });\r\n\r\n  setUserDefinedOrder = this.updater((state,moved:{newOrder:number,oldOrder:number})=>{\r\n    const {newOrder ,oldOrder} = moved;\r\n    const mdsArr = orderViewableMetaData(state);\r\n    moveItemInArray(mdsArr,oldOrder,newOrder);\r\n\r\n    const userDefinedOrder = mdsArr.reduce((aggregate: any,current,index) => {\r\n      aggregate[current.key] = index;\r\n      return aggregate\r\n    },{});\r\n    return({...state, userDefined: {...state.userDefined, order:userDefinedOrder}})\r\n  })\r\n\r\n\r\n  readonly filters$ = this.select(state => state.filters );\r\n\r\n  readonly getFilter$ = (filterId: string) : Observable<FilterInfo | CustomFilter | undefined> => {\r\n    return this.select( state => state.filters[filterId] );\r\n  }\r\n  readonly addFilter = this.updater( (state, filter: FilterInfo | CustomFilter ) => {\r\n    return this.addFiltersToState(state, [filter]);\r\n  });\r\n\r\n  readonly addFilters = this.updater((state,filters:(FilterInfo | CustomFilter )[])=>{\r\n    return this.addFiltersToState(state, filters);\r\n  })\r\n\r\n\r\n  private addFiltersToState = (state:TableState, filters:(FilterInfo | CustomFilter)[]) : TableState => {\r\n\r\n    var customFilters = filters.filter(  isCustomFilter );\r\n\r\n    var filterInfos = filters.filter(isFilterInfo);\r\n\r\n    const filtersObj = filterInfos\r\n      .filter(fltr => Object.keys(state.metaData).some(key => key === fltr.key) || console.warn(`Meta data with key ${fltr.key} not found`))\r\n      .reduce((filtersObj: {[k: string]: any},filter)=>{\r\n        if (!filter.filterId) {\r\n          filter.filterId = uuid();\r\n        }\r\n        filtersObj[filter.filterId] = filter;\r\n        return filtersObj;\r\n      },{});\r\n\r\n    customFilters.forEach( fltr => {\r\n      if(!fltr.filterId) {\r\n        fltr.filterId = uuid();\r\n      }\r\n      filtersObj[fltr.filterId] = fltr;\r\n    })\r\n    return {\r\n      ...state,\r\n      filters : {...state.filters, ...filtersObj }\r\n    };\r\n  }\r\n\r\n  readonly removeFilter = this.updater( (state, filterId: string) => {\r\n    const filtersCopy = { ...state.filters };\r\n    delete filtersCopy[filterId];\r\n    return ({...state, filters: filtersCopy });\r\n  });\r\n\r\n  readonly removeFilters = this.updater( (state, filterIds: string[]) => {\r\n    const filtersCopy = { ...state.filters };\r\n    filterIds.forEach(id => { delete filtersCopy[id] })\r\n    return ({...state, filters: filtersCopy });\r\n  });\r\n\r\n  readonly clearFilters = this.updater((state)=>\r\n    ({...state,filters:{}}))\r\n\r\n\r\n  selectSorted = this.select(state => state.sorted).pipe(distinctUntilChanged((f,s) => !isDifferent(f,s)));\r\n  readonly sort$ = this.select(this.selectStateReady, this.selectSorted, (_,s) => s );\r\n  \r\n  createPreSort = (metaDatas: Dictionary<MetaData>): Sort[] => {\r\n    return Object.values(metaDatas).filter(( metaData ) : metaData is MetaData & {preSort: SortDef} => !!metaData.preSort)\r\n      .sort(({  preSort: ps1  }, { preSort: ps2 } ) => (ps1.precedence || Number.MAX_VALUE) - ( ps2.precedence || Number.MAX_VALUE))\r\n      .map(( {key, preSort} ) => ({ active: key, direction: preSort.direction }))\r\n  }\r\n\r\n  readonly setSort = this.updater<{key: string, direction?: SortDirection}>((state, {key, direction} ) => {\r\n    const sortArray = state.sorted.filter( s => s.active !== key );\r\n    if(direction) {\r\n      sortArray.unshift({active: key, direction});\r\n    }\r\n    return {\r\n      ...state,\r\n      sorted: sortArray,\r\n    };\r\n  });\r\n\r\n  readonly setAllSort = this.updater((state,sortArray:Sort[])=>{\r\n    return {\r\n      ...state,\r\n      sorted: sortArray,\r\n    };\r\n  });\r\n\r\n  updateStateFunc = (state: TableState, incomingTableState: Partial<TableState>) : TableState => {\r\n    const metaData = state.metaData;\r\n    const sorted = incomingTableState.sorted?.length ? incomingTableState.sorted\r\n      : state.initializationState === InitializationState.Created ? this.createPreSort(metaData) : state.sorted;\r\n    return {...state, ...incomingTableState, metaData , sorted};\r\n  }\r\n\r\n  readonly setPageSize = this.updater( (state, pageSize: number)=> ({ ...state, pageSize, userDefined: { ...state.userDefined, pageSize } }));\r\n  getPageSize = this.select(state => state.userDefined.pageSize || state.pageSize);\r\n  readonly updateState = this.updater<Partial<TableState>>(this.updateStateFunc);\r\n\r\n  cleanPersistedState(state: TableState,pState: PersistedTableState) {\r\n    const metas = Object.values(state.metaData);\r\n    const filters = Object.values(pState.filters).filter(fltr => isCustomFilter(fltr) || metas.some(m => m.key === fltr.key)).reduce((obj: any, filter) => {\r\n      obj[filter.filterId!] = pState.filters[filter.filterId!];\r\n      return obj;\r\n    }, {});\r\n    const sorted = pState.sorted.filter(s => metas.some(m => m.key === s.active));\r\n    return ({...pState,filters,sorted})\r\n  }\r\n\r\n  readonly updateStateFromPersistedState = this.updater( ( state: TableState, persistedState: PersistedTableState) : TableState => {\r\n    const incomingTableState: Partial<TableState> = this.cleanPersistedState(state,persistedState);\r\n    const newState =  this.updateStateFunc(state,incomingTableState);\r\n    newState.initializationState = state.initializationState === InitializationState.MetaDataLoaded ? InitializationState.LoadedFromStore : state.initializationState;\r\n    return newState;\r\n  });\r\n\r\n  getUserDefinedTableSize = this.selectSignal(state => state.userDefined.table.width);\r\n  getUserDefinedTableSize$ = this.select(state => state.userDefined.table.width);\r\n  setTableWidth = this.updater((state, widthInPixels:number) => ({...state, userDefined: { ...state.userDefined, table: { width: widthInPixels } } })) ;\r\n\r\n  mergeMeta = (orig: MetaData, merge: MetaData): MetaData => {\r\n    return {\r\n        key: orig.key,\r\n        displayName: merge.displayName ?? orig.displayName,\r\n        fieldType: merge.fieldType || orig.fieldType,\r\n        additional: {...orig.additional, ...merge.additional},\r\n        order: merge.order ?? orig.order,\r\n        preSort: merge.preSort ?? orig.preSort,\r\n        _internalNotUserDefined: merge._internalNotUserDefined || orig._internalNotUserDefined,\r\n        width: merge.width ?? orig.width,\r\n        noExport: merge.noExport || orig.noExport,\r\n        noFilter: merge.noFilter || orig.noFilter,\r\n        customCell: merge.customCell ?? orig.customCell,\r\n        transform: merge.transform ?? orig.transform,\r\n        click: merge.click ?? orig.click,\r\n        classes: merge.classes ?? orig.classes,\r\n        noSort: merge.noSort ?? orig.noSort,\r\n        template: merge.template ?? orig.template,\r\n        toolTip: merge.toolTip ?? orig.toolTip,\r\n        useIcon: merge.useIcon ?? orig.useIcon,\r\n    };\r\n  }\r\n\r\n  readonly setInitializationState = this.updater( (state, initializationState:  InitializationState) => {\r\n    return {...state, initializationState};\r\n  });\r\n\r\n  runOnceWhen(predicate: Predicate<TableState>, func: (state:TableState) => void) {\r\n    const obs = this.state$.pipe(onceWhen(predicate));\r\n    this.on(obs, (state) => {\r\n      func(state);\r\n    });\r\n  }\r\n\r\n  onReady( func: (state: TableState) => void ) {\r\n    this.runOnceWhen(stateIs(InitializationState.Ready),func);\r\n  }\r\n\r\n  readonly setMetaData = this.updater((state, md: MetaData[] | MetaData ) => {\r\n    const metaData = ( Array.isArray(md) ? [...md] : [md] )\r\n      .reduce((prev: Dictionary<MetaData>,curr) => {\r\n        if(prev[curr.key]) {\r\n          prev[curr.key] = this.mergeMeta(prev[curr.key],curr);\r\n        } else {\r\n          prev[curr.key] = curr;\r\n        }\r\n        return prev;\r\n      } ,{});\r\n    let sorted = state.sorted;\r\n    if(sorted.length === 0) {\r\n      sorted = this.createPreSort(metaData);\r\n    }\r\n    const order = this.initializeOrder(state, metaData);\r\n    const initializationState = state.initializationState == InitializationState.Created ?  InitializationState.MetaDataLoaded : state.initializationState;\r\n    return {...state, initializationState, metaData, sorted, userDefined:{...state.userDefined,order:order}};\r\n  });\r\n\r\n  private initializeOrder = (state:TableState,mds: Dictionary<MetaData>) : Dictionary<number> => {\r\n    const viewableMetaDataArr = Object.values(mds).filter(a => a.fieldType !== FieldType.Hidden);\r\n    let userDefinedOrder = state.userDefined.order;\r\n    if(viewableMetaDataArr.some(meta => userDefinedOrder[meta.key] == null)){\r\n      return {}\r\n    }\r\n    return userDefinedOrder;\r\n  }\r\n\r\n  toggleCollapseHeader = this.updater((state)=>{\r\n    const tableSettings = {...state.persistedTableSettings};\r\n    tableSettings.collapseHeader = !tableSettings.collapseHeader;\r\n    return ({...state,persistedTableSettings : new PersistedTableSettings(tableSettings)});\r\n  })\r\n\r\n  toggleCollapseFooter = this.updater((state)=>{\r\n    const tableSettings = {...state.persistedTableSettings};\r\n    tableSettings.collapseFooter = !tableSettings.collapseFooter;\r\n    return ({...state,persistedTableSettings : new PersistedTableSettings(tableSettings)});\r\n  })\r\n\r\n  addGroupByKey = this.updater((state, groupByKey: string) => ({\r\n    ...state,\r\n    groupBy: [...state.groupBy, { key: groupByKey, expandedHeaders: [] }]\r\n  }));\r\n\r\n  removeGroupByKey = this.updater((state, groupByKey: string) => ({\r\n    ...state,\r\n    groupBy: state.groupBy.filter(key => groupByKey !== key.key)\r\n  }));\r\n\r\n  updateExpandedGroups = this.updater((state, data: {key: string, groupKey: string, isExpanded: boolean}) => {\r\n    const gbk = replaceInArrayWithClone(state.groupBy, k => k.key === data.key, gk => {\r\n      gk.expandedHeaders = data.isExpanded ? [...gk.expandedHeaders, data.groupKey] : gk.expandedHeaders.filter(g => g !== data.groupKey);\r\n    });\r\n    return ({\r\n      ...state,\r\n      groupBy: gbk\r\n    })}\r\n  );\r\n\r\n  groupByKeys$ = this.select(state => state.groupBy.map(gbk => gbk.key))\r\n    .pipe(distinctUntilChanged<string[]>((prev, curr) => prev.length === curr.length && curr.every((k,i) => prev[i] === k)));\r\n\r\n  expandedGroups$ = this.select(state => state.groupBy).pipe(distinctUntilChanged((a, b) => {\r\n    const aa = a.flatMap(g => g.expandedHeaders);\r\n    const bb = b.flatMap(g => g.expandedHeaders);\r\n    return aa.length === bb.length && aa.every((k) => bb.includes(k));\r\n  }));\r\n  \r\n  setTableSettings = this.updater((state,settings:GeneralTableSettings)=>{\r\n    const s:TableState = {\r\n      ...state,\r\n      persistedTableSettings : new PersistedTableSettings(settings),\r\n      notPersistedTableSettings : new NotPersistedTableSettings(settings)\r\n      };\r\n    return s;\r\n  });\r\n\r\n  tableSettings = this.selectSignal(state => {\r\n    const ts : PersistedTableSettings & NotPersistedTableSettings =\r\n      {...state.persistedTableSettings, ...state.notPersistedTableSettings};\r\n    return ts;\r\n  });\r\n\r\n  tableSettings$ = this.select(state => {\r\n    const ts : PersistedTableSettings & NotPersistedTableSettings =\r\n      {...state.persistedTableSettings,...state.notPersistedTableSettings};\r\n    return ts;\r\n  })\r\n\r\n  props = this.selectSignal(s => s.props);\r\n\r\n  setLinkMaps = this.updater((state,maps: any)=>{\r\n    return {...state,linkMaps:maps};\r\n  });\r\n\r\n  getLinkInfo = (md:MetaData) => this.selectSignal(state => state.linkMaps[md.key]);\r\n\r\n  getIsExpanded = (columnKey: string, groupHeaderKey: string) => {\r\n    return this.select(state => !!state.groupBy.filter(g => g.key === columnKey && g.expandedHeaders.includes(groupHeaderKey)).length);\r\n  }\r\n}\r\nexport const orderViewableMetaData = (state:TableState) => orderMetaData(state).filter(a => a.fieldType !== FieldType.Hidden);\r\n\r\nexport const orderMetaData = (state:TableState) => {\r\n  const userOrderArr = Object.entries(state.userDefined.order);\r\n  return userOrderArr.length ?\r\n   Object.values(state.metaData).sort((a,b)=> state.userDefined.order[a.key] - state.userDefined.order[b.key])\r\n   :\r\n   Object.values(state.metaData).sort((a,b)=> a.order! - b.order!)\r\n}\r\n\r\n\r\n"]}

package/esm2022/table-builder/components/array-column.component.mjs

@@ -0,0 +1,57 @@
+import { ChangeDetectionStrategy, Component, input, computed } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ArrayCommaColumnComponent {
+    constructor() {
+        this.value = input.required();
+        this.additional = input(3);
+        this.displayArray = computed(() => (this.value() || []).slice(0, this.additional()));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ArrayCommaColumnComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.1.2", type: ArrayCommaColumnComponent, isStandalone: true, selector: "tb-comma-array-column", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: true, transformFunction: null }, additional: { classPropertyName: "additional", publicName: "additional", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+  @for(val of displayArray(); track $index){
+          {{val + (!$last ? ',' : '')}}
+        }
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ArrayCommaColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tb-comma-array-column',
+                    standalone: true,
+                    template: `
+  @for(val of displayArray(); track $index){
+          {{val + (!$last ? ',' : '')}}
+        }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }] });
+export class ArrayNewLineColumnComponent {
+    constructor() {
+        this.value = input.required();
+        this.additional = input(3);
+        this.displayArray = computed(() => (this.value() || []).slice(0, this.additional()));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ArrayNewLineColumnComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.1.2", type: ArrayNewLineColumnComponent, isStandalone: true, selector: "tb-new-line-array-column", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: true, transformFunction: null }, additional: { classPropertyName: "additional", publicName: "additional", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+  @for(val of displayArray(); track $index){
+          {{val}}
+          @if(!$last){ <br/> }
+        }
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ArrayNewLineColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tb-new-line-array-column',
+                    standalone: true,
+                    template: `
+  @for(val of displayArray(); track $index){
+          {{val}}
+          @if(!$last){ <br/> }
+        }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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