@one-paragon/angular-utilities 1.2.12 → 1.2.13

package/esm2022/table-builder/components/table-container/table-container.helpers/data-state.helpers.mjs

@@ -0,0 +1,135 @@
+import { combineLatest, map, scan, timestamp } from "rxjs";
+import { filterData, sortData, tbNoShowSymbol } from "../../../functions/sort-data-function";
+import { defaultShareReplay } from "../../../../rxjs/defaultShareReplay";
+import { FieldType } from "../../../interfaces/report-def";
+import { get, set } from "lodash";
+export const sortAndFilterData = (data, sortState, filterState) => combineLatest([
+    data.pipe(timestamp()),
+    sortState.pipe(timestamp()),
+    filterState.pipe(timestamp())
+]).pipe(scan(({ mappedData: resultData }, [data, sort, f], index) => {
+    if (index === 0 || (data.timestamp > sort.timestamp && data.timestamp > f.timestamp)) {
+        return ({ mappedData: filterData(sortData(data.value, sort.value.sortsToRun), f.value.allFilters) });
+    }
+    if (sort.timestamp > f.timestamp) {
+        return ({ mappedData: sortData(resultData, sort.value.sortsToRun) });
+    }
+    return ({ mappedData: filterData(resultData, f.value.onlyAddedFilters || f.value.allFilters, !f.value.onlyAddedFilters) });
+}, { mappedData: [] })).pipe(map(({ mappedData: resultData }) => resultData.filter(item => !item[tbNoShowSymbol])), defaultShareReplay());
+export const createDataCleaners = (metadatas, mutate = false) => {
+    const transforms = createCleaners(metadatas);
+    return (data) => {
+        if (!mutate) {
+            data = { ...data };
+        }
+        for (const transform of transforms) {
+            transform(data);
+        }
+        return data;
+    };
+};
+const createCleaners = (metadatas) => {
+    return metadatas.reduce((transforms, metaData) => {
+        switch (metaData.fieldType) {
+            case FieldType.Currency:
+            case FieldType.Number: {
+                const nested = metaData.key.includes('.');
+                if (nested) {
+                    transforms.push((t) => {
+                        const val = get(t, metaData.key);
+                        const num = Number(val);
+                        set(t, metaData.key, isNaN(num) || val == null ? null : num);
+                        t[metaData.key] = (isNaN(num) || val == null ? null : num);
+                    });
+                }
+                else {
+                    transforms.push((t) => {
+                        const val = t[metaData.key];
+                        const num = Number(val);
+                        t[metaData.key] = (isNaN(num) || val == null ? null : num);
+                    });
+                }
+                break;
+            }
+            case FieldType.Date: {
+                const nested = metaData.key.includes('.');
+                if (nested) {
+                    transforms.push((t) => {
+                        const val = get(t, metaData.key);
+                        const date = Date.parse(val);
+                        if (isNaN(date)) {
+                            set(t, metaData.key, null);
+                            return;
+                        }
+                        const d = new Date(date);
+                        d.setHours(0, 0, 0, 0);
+                        set(t, metaData.key, d);
+                    });
+                }
+                else {
+                    transforms.push((t) => {
+                        const val = t[metaData.key];
+                        const date = Date.parse(val);
+                        if (isNaN(date)) {
+                            t[metaData.key] = null;
+                            return;
+                        }
+                        const d = new Date(date);
+                        d.setHours(0, 0, 0, 0);
+                        t[metaData.key] = d;
+                    });
+                }
+                break;
+            }
+            case FieldType.DateTime: {
+                const nested = metaData.key.includes('.');
+                if (nested) {
+                    transforms.push((t) => {
+                        const val = get(t, metaData.key);
+                        const dateTime = Date.parse(val);
+                        if (isNaN(dateTime)) {
+                            set(t, metaData.key, null);
+                            return;
+                        }
+                        const dt = new Date(dateTime);
+                        if (metaData.additional?.dateTimeOptions?.includeMilliseconds) {
+                            set(t, metaData.key, dt);
+                            return;
+                        }
+                        if (metaData.additional?.dateTimeOptions?.includeSeconds) {
+                            dt.setMilliseconds(0);
+                            set(t, metaData.key, dt);
+                            return;
+                        }
+                        dt.setSeconds(0, 0);
+                        set(t, metaData.key, dt);
+                    });
+                }
+                else {
+                    transforms.push((t) => {
+                        const val = t[metaData.key];
+                        const dateTime = Date.parse(val);
+                        if (isNaN(dateTime)) {
+                            t[metaData.key] = null;
+                            return;
+                        }
+                        const dt = new Date(dateTime);
+                        if (metaData.additional?.dateTimeOptions?.includeMilliseconds) {
+                            t[metaData.key] = dt;
+                            return;
+                        }
+                        if (metaData.additional?.dateTimeOptions?.includeSeconds) {
+                            dt.setMilliseconds(0);
+                            t[metaData.key] = dt;
+                            return;
+                        }
+                        dt.setSeconds(0, 0);
+                        t[metaData.key] = dt;
+                    });
+                }
+            }
+        }
+        return transforms;
+    }, []);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-state.helpers.js","sourceRoot":"","sources":["../../../../../../../projects/angular-utilities/src/table-builder/components/table-container/table-container.helpers/data-state.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, combineLatest, map, scan, timestamp } from \"rxjs\";\r\nimport { SortState } from \"./sort-state.helpers\";\r\nimport { FilterPredicateState } from \"./filter-state.helpers\";\r\nimport { filterData, sortData, tbNoShowSymbol } from \"../../../functions/sort-data-function\";\r\nimport { defaultShareReplay } from \"../../../../rxjs/defaultShareReplay\";\r\nimport { FieldType, MetaData } from \"../../../interfaces/report-def\";\r\nimport { get, set } from \"lodash\";\r\n\r\nexport const sortAndFilterData = <T>(data: Observable<T[]>, sortState: Observable<SortState>, filterState: Observable<FilterPredicateState<T>>) => combineLatest([\r\n  data.pipe(timestamp()),\r\n  sortState.pipe(timestamp()),\r\n  filterState.pipe(timestamp())\r\n]).pipe(scan(({ mappedData: resultData }, [data, sort, f], index)=> {\r\n\r\n      if(index === 0 || (data.timestamp > sort.timestamp && data.timestamp > f.timestamp)){\r\n        return ({ mappedData: filterData(sortData(data.value , sort.value.sortsToRun ), f.value.allFilters)});\r\n      }\r\n\r\n      if(sort.timestamp > f.timestamp){\r\n        return ({ mappedData: sortData(resultData, sort.value.sortsToRun)});\r\n      }\r\n      return ({ mappedData: filterData(resultData, f.value.onlyAddedFilters || f.value.allFilters, !f.value.onlyAddedFilters)});\r\n    }, { mappedData: []} as { mappedData: T[]})\r\n  ).pipe(\r\n    map(({ mappedData: resultData }) => resultData.filter(item => !item[tbNoShowSymbol])),\r\n    defaultShareReplay()\r\n  );\r\n\r\nexport const createDataCleaners = <T>(metadatas: MetaData<T>[], mutate = false) => {\r\n  const transforms = createCleaners(metadatas);\r\n  return (data: T) => {\r\n    if(!mutate){\r\n      data = { ...data }\r\n    }\r\n    for(const transform of transforms){\r\n      transform(data);\r\n    }\r\n    return data;\r\n  }\r\n}\r\n\r\nconst createCleaners = <T>(metadatas: MetaData<T> []) => {\r\n  return metadatas.reduce((transforms,metaData) => {\r\n    switch ( metaData.fieldType ) {\r\n      case FieldType.Currency:\r\n      case FieldType.Number:{\r\n        const nested = metaData.key.includes('.');\r\n        if(nested){\r\n          transforms.push( (t:T) => {\r\n            const val = get(t, metaData.key);\r\n            const num = Number( val );\r\n            set(t as {}, metaData.key, isNaN(num) || val == null ? null : num)\r\n            t[metaData.key] =  (isNaN(num) || val == null ? null : num) as any});\r\n        } else {\r\n          transforms.push( (t:T) => {\r\n            const val = t[metaData.key];\r\n            const num = Number( val );\r\n            t[metaData.key] =  (isNaN(num) || val == null ? null : num) as any});\r\n        }\r\n        break;\r\n      }\r\n      case FieldType.Date:{\r\n        const nested = metaData.key.includes('.');\r\n        if(nested){\r\n          transforms.push( (t:T) => {\r\n            const val = get(t, metaData.key) as string;\r\n            const date = Date.parse(val);\r\n            if(isNaN(date)){\r\n              set(t as {}, metaData.key,  null as any);\r\n              return\r\n            }\r\n            const d = new Date(date);\r\n            d.setHours(0,0,0,0);\r\n            set(t as {}, metaData.key,  d as any);\r\n          })\r\n        } else {\r\n          transforms.push( (t:T) => {\r\n            const val = t[metaData.key] as string;\r\n            const date = Date.parse(val);\r\n            if(isNaN(date)){\r\n              t[metaData.key] =  null as any;\r\n              return\r\n            }\r\n            const d = new Date(date);\r\n            d.setHours(0,0,0,0);\r\n            t[metaData.key] =  d as any;\r\n          })\r\n        }\r\n        break;\r\n      }\r\n        \r\n      case FieldType.DateTime:{\r\n        const nested = metaData.key.includes('.');\r\n        if(nested){\r\n          transforms.push( (t:T) => {\r\n            const val = get(t, metaData.key);\r\n            const dateTime = Date.parse(val as string);\r\n            if(isNaN(dateTime)){\r\n              set(t as {}, metaData.key,  null as any);\r\n              return\r\n            }\r\n            const dt = new Date(dateTime);\r\n            if(metaData.additional?.dateTimeOptions?.includeMilliseconds){\r\n              set(t as {}, metaData.key,  dt as any);\r\n              return\r\n            }\r\n            if(metaData.additional?.dateTimeOptions?.includeSeconds){\r\n              dt.setMilliseconds(0);\r\n              set(t as {}, metaData.key,  dt as any);\r\n              return\r\n            }\r\n            dt.setSeconds(0, 0);\r\n            set(t as {}, metaData.key,  dt as any);\r\n          })\r\n        } else {\r\n          transforms.push((t:T) => {\r\n            const val = t[metaData.key] as string;\r\n            const dateTime = Date.parse(val);\r\n            if(isNaN(dateTime)){\r\n              t[metaData.key] =  null as any;\r\n              return;\r\n            }\r\n            const dt = new Date(dateTime);\r\n            if(metaData.additional?.dateTimeOptions?.includeMilliseconds){\r\n              t[metaData.key] =  dt as any;\r\n              return;\r\n            }\r\n            if(metaData.additional?.dateTimeOptions?.includeSeconds){\r\n              dt.setMilliseconds(0);\r\n              t[metaData.key] =  dt as any;\r\n              return;\r\n            }\r\n            dt.setSeconds(0, 0);\r\n            t[metaData.key] =  dt as any;\r\n          })\r\n        }\r\n      }\r\n    }\r\n    return transforms;\r\n  }, [] as ((t:T) => void)[])\r\n}"]}

package/esm2022/table-builder/components/table-container/table-container.helpers/filter-state.helpers.mjs

@@ -0,0 +1,83 @@
+import { createFilterFunc } from "../../../classes/filter-info";
+import { difference, intersection } from "lodash";
+//The idea of this is that if filters were only added, and none were removed or changed, then we only need to tag more rows to not be shown. We don't need to remove any 'dont show' tags.
+// So if filters were only added this method will return the added filters, if filters were removed or changed this method will return undefined.
+export const updateFilterInfoState = (previousState, filterInfos) => {
+    filterInfos = filterNonActiveFilters(filterInfos);
+    const currentState = {
+        allFilters: filterInfos,
+        onlyAddedFilters: filterInfoOnlyAdded(previousState.allFilters, filterInfos)
+    };
+    return currentState;
+};
+export const mapFilterInfoStateToPredicateState = (s) => {
+    const mappedAddOnly = s.onlyAddedFilters ? Object.entries(s.onlyAddedFilters).reduce((obj, [key, value]) => {
+        obj[key] = createFilterFunc(value);
+        return obj;
+    }, {}) : {};
+    const mappedAll = Object.entries(s.allFilters).map(([key, value]) => mappedAddOnly[key] || createFilterFunc(value));
+    return ({
+        allFilters: mappedAll,
+        onlyAddedFilters: s.onlyAddedFilters ? Object.values(mappedAddOnly) : undefined
+    });
+};
+export const updateFilterPredicateState = (previousState, filters) => {
+    const currentState = {
+        allFilters: filters,
+        onlyAddedFilters: predicatesOnlyAdded(previousState.allFilters, filters)
+    };
+    return currentState;
+};
+export const updateFilterState = (filterInfos, predicates) => {
+    const infos = mapFilterInfoStateToPredicateState(filterInfos.value);
+    const filtersState = {
+        allFilters: [...infos.allFilters, ...predicates.value.allFilters]
+    };
+    if (filterInfos.timestamp > predicates.timestamp && !!filterInfos.value.onlyAddedFilters) {
+        filtersState.onlyAddedFilters = infos.onlyAddedFilters;
+    }
+    else {
+        filtersState.onlyAddedFilters = predicates.value.onlyAddedFilters;
+    }
+    return filtersState;
+};
+const filterNonActiveFilters = (filtersDict) => Object.entries(filtersDict).reduce((obj, [key, value]) => {
+    if (value.active !== false) {
+        obj[key] = value;
+    }
+    ;
+    return obj;
+}, {});
+function filterInfoOnlyAdded(previousFilterInfos, currentFilterInfos) {
+    const previousKeys = Object.keys(previousFilterInfos);
+    const currentKeys = Object.keys(currentFilterInfos);
+    const keysInBoth = intersection(previousKeys, currentKeys);
+    const someRemoved = previousKeys.length > keysInBoth.length;
+    if (someRemoved || !previousKeys.length) {
+        return undefined;
+    }
+    if (filtersInfosUpdated(previousFilterInfos, currentFilterInfos)) {
+        return undefined;
+    }
+    const addedFilters = difference(currentKeys, keysInBoth).reduce((dict, key) => {
+        dict[key] = currentFilterInfos[key];
+        return dict;
+    }, {});
+    return addedFilters;
+}
+function predicatesOnlyAdded(previousPredicates, currentPredicates) {
+    if (!previousPredicates.length) {
+        return undefined;
+    }
+    const predicateFiltersRemoved = difference(previousPredicates, currentPredicates).length;
+    if (predicateFiltersRemoved) {
+        return undefined;
+    }
+    return difference(currentPredicates, previousPredicates);
+}
+function filtersInfosUpdated(previousFilterInfos, currentFilterInfos) {
+    return !Object.entries(previousFilterInfos).every(([key, val]) => {
+        return currentFilterInfos[key].filterType === val.filterType && currentFilterInfos[key].filterValue === val.filterValue;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-state.helpers.js","sourceRoot":"","sources":["../../../../../../../projects/angular-utilities/src/table-builder/components/table-container/table-container.helpers/filter-state.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { Timestamp } from \"rxjs\";\r\nimport { CustomFilter, FilterInfo, createFilterFunc } from \"../../../classes/filter-info\";\r\nimport { Dictionary } from \"../../../interfaces/dictionary\";\r\nimport { Predicate } from \"@angular/core\";\r\nimport { difference, intersection } from \"lodash\";\r\n\r\n//The idea of this is that if filters were only added, and none were removed or changed, then we only need to tag more rows to not be shown. We don't need to remove any 'dont show' tags.\r\n// So if filters were only added this method will return the added filters, if filters were removed or changed this method will return undefined.\r\n\r\nexport const updateFilterInfoState = <T>(previousState: FilterInfoState<T>, filterInfos: FilterInfoDict) => {\r\n  filterInfos = filterNonActiveFilters(filterInfos);\r\n  const currentState: FilterInfoState<T> = {\r\n    allFilters: filterInfos,\r\n    onlyAddedFilters: filterInfoOnlyAdded(previousState.allFilters, filterInfos)\r\n  }\r\n  return currentState;\r\n}\r\n\r\nexport const mapFilterInfoStateToPredicateState = <T>(s: FilterInfoState<T>): FilterPredicateState<T> => {\r\n  const mappedAddOnly: {[key in keyof T]: Predicate<T>} = s.onlyAddedFilters ? Object.entries(s.onlyAddedFilters).reduce((obj, [key, value]) => {\r\n    obj[key] = createFilterFunc(value);\r\n    return obj;\r\n  }, {} as {[key in keyof T]: Predicate<T>}) : {} as {[key in keyof T]: Predicate<T>};\r\n  const mappedAll = Object.entries(s.allFilters).map(([key, value]) => mappedAddOnly[key] || createFilterFunc(value));\r\n  return ({\r\n    allFilters: mappedAll,\r\n    onlyAddedFilters: s.onlyAddedFilters ? Object.values(mappedAddOnly) : undefined\r\n  })\r\n}\r\n\r\nexport const updateFilterPredicateState = <T>(previousState: FilterPredicateState<T>, filters: Predicate<any>[]) => {\r\n  const currentState: FilterPredicateState<T> = {\r\n    allFilters: filters,\r\n    onlyAddedFilters: predicatesOnlyAdded(previousState.allFilters, filters)\r\n  }\r\n  return currentState;\r\n}\r\n\r\nexport const updateFilterState = <T>(filterInfos: Timestamp<FilterInfoState<T>>, predicates: Timestamp<FilterPredicateState<T>>): FilterPredicateState<T> => {\r\n  const infos = mapFilterInfoStateToPredicateState(filterInfos.value);\r\n  const filtersState: FilterPredicateState<T> = {\r\n    allFilters: [...infos.allFilters, ...predicates.value.allFilters]\r\n  }\r\n  if(filterInfos.timestamp > predicates.timestamp && !!filterInfos.value.onlyAddedFilters){\r\n    filtersState.onlyAddedFilters = infos.onlyAddedFilters;\r\n  } else {\r\n    filtersState.onlyAddedFilters = predicates.value.onlyAddedFilters\r\n  }\r\n  return filtersState\r\n}\r\n\r\n\r\nconst filterNonActiveFilters = <T>(filtersDict : FilterInfoDict) => Object.entries(filtersDict).reduce((obj ,[key, value]) => { \r\n  if(value.active !== false){\r\n    obj[key] = value\r\n  };\r\n  return obj;\r\n}, {} as Dictionary<FilterInfo | CustomFilter>);\r\n\r\n\r\nfunction filterInfoOnlyAdded(previousFilterInfos: FilterInfoDict, currentFilterInfos: FilterInfoDict): FilterInfoDict | undefined{\r\n  const previousKeys = Object.keys(previousFilterInfos);\r\n  const currentKeys = Object.keys(currentFilterInfos);\r\n  const keysInBoth = intersection(previousKeys, currentKeys);\r\n  const someRemoved = previousKeys.length > keysInBoth.length;\r\n  if(someRemoved || !previousKeys.length){\r\n    return undefined;\r\n  }\r\n  if(filtersInfosUpdated(previousFilterInfos, currentFilterInfos)){\r\n    return undefined;\r\n  }\r\n  const addedFilters = difference(currentKeys, keysInBoth).reduce((dict, key) => {\r\n    dict[key] = currentFilterInfos[key];\r\n    return dict;\r\n  }, {} as FilterInfoDict);\r\n  return addedFilters;\r\n}\r\n\r\nfunction predicatesOnlyAdded(previousPredicates: Predicate<any>[], currentPredicates: Predicate<any>[]){\r\n  if(!previousPredicates.length){\r\n    return undefined;\r\n  }\r\n  const predicateFiltersRemoved = difference(previousPredicates, currentPredicates).length;\r\n  if(predicateFiltersRemoved){\r\n    return undefined;\r\n  }\r\n  return difference(currentPredicates, previousPredicates);\r\n}\r\n\r\nfunction filtersInfosUpdated(previousFilterInfos: FilterInfoDict<any>, currentFilterInfos: FilterInfoDict<any>){\r\n  return !Object.entries(previousFilterInfos).every(([key, val]) => {\r\n    return currentFilterInfos[key].filterType === val.filterType && currentFilterInfos[key].filterValue === val.filterValue\r\n  })\r\n}\r\n\r\nexport interface FilterInfoState<T> {\r\n  allFilters: FilterInfoDict<T>, \r\n  onlyAddedFilters?: FilterInfoDict<T> | undefined,\r\n}\r\n\r\nexport interface FilterPredicateState<T> {\r\n  allFilters: Predicate<T>[], \r\n  onlyAddedFilters?: Predicate<T>[] | undefined,\r\n}\r\n\r\nexport type FilterInfoDict<T = any> = Dictionary<FilterInfo<any, T> | CustomFilter<any>>;"]}

package/esm2022/table-builder/components/table-container/table-container.helpers/groupBy.helpers.mjs

@@ -0,0 +1,71 @@
+import { groupBy } from "lodash";
+import { initIndexSymbol } from "./sort-state.helpers";
+function getGroupedData(data, groupByKeys) {
+    return tbGroupBy(data, groupByKeys);
+}
+const tbGroupBy = (data, groupByKeys, parentGroupName) => {
+    const currentKey = groupByKeys[0];
+    const res = groupBy(data, currentKey);
+    const remainingGroupByKeys = groupByKeys.slice(1);
+    const finalGroups = !remainingGroupByKeys.length;
+    if (remainingGroupByKeys.length) {
+        Object.keys(res).forEach(key => res[key] = tbGroupBy(res[key], remainingGroupByKeys, key));
+    }
+    return Object.keys(res).map((groupName, i) => {
+        const uniqName = parentGroupName ? `${parentGroupName}-${groupName}` : `${groupName}`;
+        const groupHeaders = res[groupName]?.filter(row => row.isGroupHeader) ?? [];
+        return {
+            isGroupHeader: true,
+            groupHeaderDisplay: groupName,
+            hasTheData: finalGroups,
+            children: finalGroups ? res[groupName] : res[groupName].map(d => { d.padding += 20; return d; }),
+            groupName: `tb_group_${uniqName}`,
+            padding: 1,
+            key: currentKey,
+            length: groupHeaders.reduce((acc, curr) => curr.length + acc, 0) + ((res[groupName] ?? []).length - groupHeaders.length),
+            [initIndexSymbol]: uniqName,
+        };
+    });
+};
+export function updateGroupByState({ groupedData }, [data, groups, expandedGroups], index) {
+    if (index === 0
+        || dataUpdated(data, groups, expandedGroups)
+        || groupsUpdated(groups, expandedGroups)) {
+        groupedData = groups.value.length ? getGroupedData(data.value, groups.value) : data.value;
+    }
+    const newDisplayData = expandedGroups.value.length === 0
+        ? groupedData
+        : groupedData.map(group => mapGroupHeader(group, expandedGroups.value)).flat();
+    return ({ displayData: newDisplayData, groupedData });
+}
+function mapGroupHeader(obj, data) {
+    const showChildren = data.find(a => a.expandedHeaders.includes(obj.groupName));
+    const children = !showChildren ? [] :
+        obj.hasTheData ? obj.children
+            : obj.children.map(a => mapGroupHeader(a, data));
+    return [obj, ...children].flat();
+}
+function dataUpdated(data, groups, expandedGroups) {
+    return data.timestamp > groups.timestamp && data.timestamp > expandedGroups.timestamp;
+}
+function groupsUpdated(groups, expandedGroups) {
+    return groups.timestamp > expandedGroups.timestamp;
+}
+;
+export const initialGroupByState = { displayData: [], groupedData: [] };
+export const getAllGroupHeaderNames = (data) => {
+    const groups = getGroupHeaders(data, (d) => d.isGroupHeader);
+    return groupBy(groups, 'key');
+};
+export const getAllGroupHeaderNamesByKeys = (data, keys) => {
+    const groups = getGroupHeaders(data, (d) => d.isGroupHeader && keys.includes(d.key));
+    return groupBy(groups, 'key');
+};
+const getGroupHeaders = (data, filterFunc, arr = []) => {
+    const headers = data.filter(filterFunc);
+    arr.push(...headers);
+    headers.forEach(h => { if (!!h.children.length)
+        getGroupHeaders(h.children, filterFunc, arr); });
+    return arr;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"groupBy.helpers.js","sourceRoot":"","sources":["../../../../../../../projects/angular-utilities/src/table-builder/components/table-container/table-container.helpers/groupBy.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAGjC,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,SAAS,cAAc,CAAC,IAAW,EAAE,WAAqB;IACxD,OAAO,SAAS,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;AACtC,CAAC;AAED,MAAM,SAAS,GAAG,CAAC,IAAW,EAAE,WAAqB,EAAE,eAAqB,EAAS,EAAE;IACrF,MAAM,UAAU,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;IAClC,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IACtC,MAAM,oBAAoB,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClD,MAAM,WAAW,GAAG,CAAC,oBAAoB,CAAC,MAAM,CAAC;IACjD,IAAI,oBAAoB,CAAC,MAAM,EAAE,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,oBAAoB,EAAE,GAAG,CAAC,CAAC,CAAA;IAC5F,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE;QAC3C,MAAM,QAAQ,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,eAAe,IAAI,SAAS,EAAE,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC;QACtF,MAAM,YAAY,GAAG,GAAG,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QAC5E,OAAQ;YACJ,aAAa,EAAE,IAAI;YACnB,kBAAkB,EAAE,SAAS;YAC7B,UAAU,EAAE,WAAW;YACvB,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAE,CAAC,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA,CAAA,CAAC,CAAC;YAC7F,SAAS,EAAE,YAAY,QAAQ,EAAE;YACjC,OAAO,EAAE,CAAC;YACV,GAAG,EAAE,UAAU;YACf,MAAM,EAAG,YAAY,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,GAAG,EAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC;YACxH,CAAC,eAAe,CAAC,EAAE,QAAQ;SAE9B,CAAC;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC,CAAA;AAED,MAAM,UAAU,kBAAkB,CAAC,EAAE,WAAW,EAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,CAAqE,EAAE,KAAa;IAChL,IACE,KAAK,KAAK,CAAC;WACR,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,CAAC;WACzC,aAAa,CAAC,MAAM,EAAE,cAAc,CAAC,EACzC,CAAC;QACA,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;IAC5F,CAAC;IACD,MAAM,cAAc,GAAG,cAAc,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;QACtD,CAAC,CAAC,WAAW;QACb,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,cAAc,CAAC,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACjF,OAAO,CAAC,EAAC,WAAW,EAAE,cAAc,EAAE,WAAW,EAAC,CAAC,CAAC;AACtD,CAAC;AAED,SAAS,cAAc,CAAC,GAAQ,EAAE,IAAmB;IACnD,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;IAC/E,MAAM,QAAQ,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACf,GAAG,CAAC,UAAU,CAAC,CAAC,CAAE,GAAG,CAAC,QAAQ;YAC5B,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;IAExE,OAAO,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAA;AAClC,CAAC;AAED,SAAS,WAAW,CAAC,IAAsB,EAAE,MAA2B,EAAE,cAAwC;IAChH,OAAO,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,GAAG,cAAc,CAAC,SAAS,CAAC;AACxF,CAAC;AAED,SAAS,aAAa,CAAC,MAA2B,EAAE,cAAwC;IAC1F,OAAO,MAAM,CAAC,SAAS,GAAG,cAAc,CAAC,SAAS,CAAC;AACrD,CAAC;AAE+D,CAAC;AAEjE,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,WAAW,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAC,CAAA;AAEtE,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,IAAW,EAAE,EAAE;IACpD,MAAM,MAAM,GAAG,eAAe,CAAC,IAAI,EAAE,CAAC,CAAK,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC;IACjE,OAAO,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;AAC/B,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,IAAW,EAAE,IAAc,EAAE,EAAE;IAC1E,MAAM,MAAM,GAAG,eAAe,CAAC,IAAI,EAAE,CAAC,CAAK,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACzF,OAAO,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;AAC/B,CAAC,CAAA;AAED,MAAM,eAAe,GAAG,CAAC,IAAW,EAAE,UAA8B,EAAE,MAAY,EAAE,EAAW,EAAE;IAC/F,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IACxC,GAAG,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC;IACrB,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,GAAE,IAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM;QAAE,eAAe,CAAC,CAAC,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,CAAC,CAAA,CAAA,CAAC,CAAC,CAAC;IAC7F,OAAO,GAAG,CAAC;AACb,CAAC,CAAA","sourcesContent":["import { groupBy } from \"lodash\";\r\nimport { Timestamp } from \"rxjs\";\r\nimport { Group, GroupedData } from \"../../../classes/TableState\";\r\nimport { initIndexSymbol } from \"./sort-state.helpers\";\r\n\r\nfunction getGroupedData(data: any[], groupByKeys: string[]): any[] {\r\n  return tbGroupBy(data, groupByKeys);\r\n}\r\n\r\nconst tbGroupBy = (data: any[], groupByKeys: string[], parentGroupName?: any): any[] => {\r\n  const currentKey = groupByKeys[0];\r\n  const res = groupBy(data, currentKey);\r\n  const remainingGroupByKeys = groupByKeys.slice(1);\r\n  const finalGroups = !remainingGroupByKeys.length;\r\n  if (remainingGroupByKeys.length) {\r\n    Object.keys(res).forEach(key => res[key] = tbGroupBy(res[key], remainingGroupByKeys, key))\r\n  }\r\n  return Object.keys(res).map((groupName, i) => {\r\n    const uniqName = parentGroupName ? `${parentGroupName}-${groupName}` : `${groupName}`;\r\n    const groupHeaders = res[groupName]?.filter(row => row.isGroupHeader) ?? [];\r\n    return ({\r\n        isGroupHeader: true,\r\n        groupHeaderDisplay: groupName,\r\n        hasTheData: finalGroups,\r\n        children: finalGroups ? res[groupName] : res[groupName].map(d => {d.padding += 20; return d}),\r\n        groupName: `tb_group_${uniqName}`,\r\n        padding: 1,\r\n        key: currentKey,\r\n        length : groupHeaders.reduce((acc, curr) => curr.length + acc,0) + ((res[groupName] ?? []).length - groupHeaders.length),\r\n        [initIndexSymbol]: uniqName,\r\n      } as Group\r\n    );\r\n  })\r\n}\r\n\r\nexport function updateGroupByState({ groupedData }:GroupByState, [data, groups, expandedGroups] : [Timestamp<any[]>, Timestamp<string[]>, Timestamp<GroupedData[]>], index: number){\r\n  if(\r\n    index === 0\r\n    || dataUpdated(data, groups, expandedGroups)\r\n    || groupsUpdated(groups, expandedGroups)\r\n  ){\r\n    groupedData = groups.value.length ? getGroupedData(data.value, groups.value) : data.value;\r\n  }\r\n  const newDisplayData = expandedGroups.value.length === 0\r\n    ? groupedData\r\n    : groupedData.map(group => mapGroupHeader(group, expandedGroups.value)).flat();\r\n  return ({displayData: newDisplayData, groupedData});\r\n}\r\n\r\nfunction mapGroupHeader(obj: any, data: GroupedData[]){\r\n  const showChildren = data.find(a => a.expandedHeaders.includes(obj.groupName));\r\n  const children = !showChildren ? [] : \r\n                        obj.hasTheData ?  obj.children\r\n                          : obj.children.map(a => mapGroupHeader(a, data))\r\n\r\n  return [obj, ...children].flat()\r\n}\r\n\r\nfunction dataUpdated(data: Timestamp<any[]>, groups: Timestamp<string[]>, expandedGroups: Timestamp<GroupedData[]>){\r\n  return data.timestamp > groups.timestamp && data.timestamp > expandedGroups.timestamp;\r\n}\r\n\r\nfunction groupsUpdated(groups: Timestamp<string[]>, expandedGroups: Timestamp<GroupedData[]>){\r\n  return groups.timestamp > expandedGroups.timestamp;\r\n}\r\n\r\ninterface GroupByState { displayData: any[], groupedData: any[]};\r\n\r\nexport const initialGroupByState = { displayData: [], groupedData: []}\r\n\r\nexport const getAllGroupHeaderNames = (data: any[]) => {\r\n  const groups = getGroupHeaders(data, (d:any) => d.isGroupHeader);\r\n  return groupBy(groups, 'key')\r\n}\r\n\r\nexport const getAllGroupHeaderNamesByKeys = (data: any[], keys: string[]) => {\r\n  const groups = getGroupHeaders(data, (d:any) => d.isGroupHeader && keys.includes(d.key));\r\n  return groupBy(groups, 'key')\r\n}\r\n\r\nconst getGroupHeaders = (data: any[], filterFunc: (d:any) => boolean, arr:any[] = []): Group[] => {\r\n  const headers = data.filter(filterFunc);\r\n  arr.push(...headers);\r\n  headers.forEach(h => {if(!!h.children.length) getGroupHeaders(h.children, filterFunc, arr)});\r\n  return arr;\r\n}"]}

package/esm2022/table-builder/components/table-container/table-container.helpers/sort-state.helpers.mjs

@@ -0,0 +1,36 @@
+import { difference } from "lodash";
+// If we are only sorting due to a change in the Sorts[] we can 'optimize'. If the sort array was first by column a asc then by column b desc then by column c asc,
+// and now it is first by column d asc then by column a desc then by column b desc then by column c asc, we dont need to rerun the tail, i.e. for culumn b and c.
+// So we need to calculate the matching tail of the sort array. Then sortsToRun will be the non-matching head.
+// But if any sorts were removed the only way to 'unsort' is to start by the original data and run all the existing sorts again, so 'sorts to run' will be all
+// the sorts.
+// We always pass allSorts to the container because if the table data changes all the sorts will need to be run.
+export function updateSortState(previousSorts, currentSorts) {
+    currentSorts = addInitSort(currentSorts);
+    if (sortsRemoved(previousSorts.allSorts, currentSorts)) {
+        return ({ sortsToRun: currentSorts, allSorts: currentSorts });
+    }
+    const sameTailLength = getSameTailLength(previousSorts.allSorts, currentSorts);
+    const sortsToRun = currentSorts.slice(0, currentSorts.length - sameTailLength);
+    return ({ sortsToRun, allSorts: currentSorts });
+}
+function addInitSort(sorts) {
+    return [...sorts, { active: initIndexSymbol, direction: 'asc' }];
+}
+function sortsRemoved(previousSorts, currentSorts) {
+    const previousSortedColumns = previousSorts.map(s => s.active);
+    const currentSortedColumns = currentSorts.map(s => s.active);
+    const sortsRemoved = !!difference(previousSortedColumns, currentSortedColumns).length;
+    return sortsRemoved;
+}
+function getSameTailLength(previousSorts, currentSorts) {
+    previousSorts = [...previousSorts].reverse();
+    currentSorts = [...currentSorts].reverse();
+    let indexOfChange = currentSorts.findIndex((s, i) => s.active !== previousSorts[i]?.active || s.direction !== previousSorts[i]?.direction);
+    if (indexOfChange === -1)
+        return indexOfChange = currentSorts.length;
+    return indexOfChange;
+}
+export const initIndexSymbol = Symbol('tb_init_index');
+export const initialSortState = { sortsToRun: [], allSorts: [] };
+//# sourceMappingURL=data:application/json;base64,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