@one-paragon/angular-utilities 0.3.6 → 0.3.7-beta.1

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

@@ -0,0 +1,62 @@
+import { combineLatest, map, timestamp } from "rxjs";
+import { createFilterFunc } from "../../../classes/filter-info";
+import { difference, intersection } from "lodash";
+export const updateFilterState = (previousState, [filterInfoDict, predicateArr], index) => {
+    const currentFilterState = {
+        predicateArr: predicateArr.value,
+        filterInfoDict: filterInfoDict.value,
+        allFilters: [...predicateArr.value, ...Object.values(filterInfoDict.value).map(createFilterFunc)],
+        onlyAddedFilters: undefined
+    };
+    if (index === 0) {
+        return currentFilterState;
+    }
+    if (filterInfoDict.timestamp > predicateArr.timestamp) {
+        currentFilterState.onlyAddedFilters = filterInfoOnlyAdded(previousState.filterInfoDict, filterInfoDict.value);
+    }
+    else {
+        currentFilterState.onlyAddedFilters = predicatesOnlyAdded(previousState.predicateArr, predicateArr.value);
+    }
+    return currentFilterState;
+};
+export const predicateAndFilterInfos = (filterInfos, predicates) => {
+    return combineLatest([filterInfos.pipe(map(filterNonActiveFilters), timestamp()),
+        predicates.pipe(timestamp())]);
+};
+const filterNonActiveFilters = (filtersDict) => Object.entries(filtersDict).reduce((obj, [key, value]) => {
+    if (value.active !== false) {
+        obj[key] = value;
+    }
+    ;
+    return obj;
+}, {});
+//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.
+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) {
+        return undefined;
+    }
+    if (filtersUpdated(previousFilterInfos, currentFilterInfos)) {
+        return undefined;
+    }
+    const addedFilters = difference(currentKeys, keysInBoth).map(key => createFilterFunc(currentFilterInfos[key]));
+    return addedFilters;
+}
+function predicatesOnlyAdded(previousPredicates, currentPredicates) {
+    const predicateFiltersRemoved = difference(previousPredicates, currentPredicates).length;
+    if (predicateFiltersRemoved) {
+        return undefined;
+    }
+    return difference(currentPredicates, previousPredicates);
+}
+function filtersUpdated(previousFilterInfos, currentFilterInfos) {
+    return !Object.entries(previousFilterInfos).every(([key, val]) => {
+        return currentFilterInfos[key].filterType === val.filterType && currentFilterInfos[key].filterValue === val.filterValue;
+    });
+}
+export const initialFilterState = { allFilters: [], onlyAddedFilters: undefined, predicateArr: [], filterInfoDict: {} };
+//# 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 { Observable, Timestamp, combineLatest, map, 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\nexport const updateFilterState = <T>(previousState: FiltersState<T>, [filterInfoDict, predicateArr] : [Timestamp<FilterInfoDict>, Timestamp<Predicate<T>[]>], index: number) => {\r\n  const currentFilterState: FiltersState<T> = {\r\n    predicateArr: predicateArr.value,\r\n    filterInfoDict: filterInfoDict.value,\r\n    allFilters: [...predicateArr.value, ...Object.values(filterInfoDict.value).map(createFilterFunc)],\r\n    onlyAddedFilters: undefined\r\n  };\r\n\r\n  if(index === 0){\r\n    return currentFilterState;\r\n  }\r\n  if(filterInfoDict.timestamp > predicateArr.timestamp){\r\n    currentFilterState.onlyAddedFilters = filterInfoOnlyAdded(previousState.filterInfoDict, filterInfoDict.value);\r\n  }\r\n  else{\r\n    currentFilterState.onlyAddedFilters = predicatesOnlyAdded(previousState.predicateArr, predicateArr.value);\r\n  }\r\n  return currentFilterState;\r\n};\r\n\r\nexport const predicateAndFilterInfos = <T>(filterInfos : Observable<FilterInfoDict>, predicates: Observable< Predicate<T>[]>) => {\r\n  return combineLatest([filterInfos.pipe(\r\n    map(filterNonActiveFilters),\r\n    timestamp()\r\n  ),\r\n  predicates.pipe(timestamp())])\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//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\nfunction filterInfoOnlyAdded(previousFilterInfos: FilterInfoDict, currentFilterInfos: FilterInfoDict): Predicate<any>[] | 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){\r\n    return undefined;\r\n  }\r\n  if(filtersUpdated(previousFilterInfos, currentFilterInfos)){\r\n    return undefined;\r\n  }\r\n  const addedFilters = difference(currentKeys, keysInBoth).map(key => createFilterFunc(currentFilterInfos[key]));\r\n  return addedFilters;\r\n}\r\n\r\nfunction predicatesOnlyAdded(previousPredicates: Predicate<any>[], currentPredicates: Predicate<any>[]){\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 filtersUpdated(previousFilterInfos: FilterInfoDict, currentFilterInfos: FilterInfoDict){\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\ninterface FiltersState<T> {\r\n  allFilters: Predicate<T>[], \r\n  predicateArr: Predicate<T>[],\r\n  filterInfoDict: Dictionary<FilterInfo | CustomFilter>\r\n  onlyAddedFilters?: Predicate<T>[] | undefined,\r\n}\r\n\r\nexport const initialFilterState: FiltersState<any> =\r\n  {allFilters: [], onlyAddedFilters: undefined, predicateArr: [], filterInfoDict: {}};\r\n\r\ntype FilterInfoDict = Dictionary<FilterInfo<any> | CustomFilter<any>>;"]}

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

@@ -0,0 +1,54 @@
+import { groupBy } from "lodash";
+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),
+        });
+    });
+};
+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: [] };
+//# 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":"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","sourcesContent":["import { groupBy } from \"lodash\";\r\nimport { Timestamp } from \"rxjs\";\r\nimport { GroupedData } from \"../../../classes/TableState\";\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      }\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: []}"]}

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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