@rivet-health/design-system 40.44.0 → 40.44.2

package/esm2022/lib/table/table/state-helpers/nesting-helpers.mjs

@@ -0,0 +1,123 @@
+import { sumBy } from 'lodash';
+import { TableCollapseHelpers } from './collapse-helpers';
+export var TableNestingHelpers;
+(function (TableNestingHelpers) {
+    function convertToFullNestedRow(currentRow, coreState, rowLinkFunction) {
+        const currentSubRows = currentRow.subRows
+            ? currentRow.subRows.map(subrow => convertToFullNestedRow(subrow, coreState, rowLinkFunction))
+            : [];
+        const currentRowLink = rowLinkFunction
+            ? rowLinkFunction(currentRow.data)
+            : null;
+        // We don't currently support selecting nested rows
+        const currentRowIsSelected = false;
+        const currentRowIsCollapsed = TableCollapseHelpers.isRowCollapsed(coreState, currentRow.data.id);
+        return {
+            id: currentRow.data.id,
+            data: currentRow.data,
+            rowLink: currentRowLink,
+            selected: currentRowIsSelected,
+            subRows: currentSubRows,
+            isCollapsed: currentRowIsCollapsed,
+        };
+    }
+    TableNestingHelpers.convertToFullNestedRow = convertToFullNestedRow;
+    function convertToFullNestedHeaderRow(currentRow, coreState, rowLinkFunction) {
+        const currentSubRows = currentRow.subRows
+            ? currentRow.subRows.map(subrow => convertToFullNestedRow(subrow, coreState, rowLinkFunction))
+            : [];
+        const currentHeaderIsCollapsed = TableCollapseHelpers.isHeaderCollapsed(coreState, currentRow.headerText);
+        return {
+            id: currentRow.headerText ?? '',
+            subRows: currentSubRows,
+            headerText: currentRow.headerText,
+            isCollapsed: currentHeaderIsCollapsed,
+        };
+    }
+    TableNestingHelpers.convertToFullNestedHeaderRow = convertToFullNestedHeaderRow;
+    function findNestedRowsWithHeadersToKeep(allRows, filteredRows) {
+        const filteredIds = new Set(filteredRows.map(row => row.id));
+        function recursiveFindRowsToKeep(currentNestedRow) {
+            // Keep all subrows if a parent row matches the filter
+            if (filteredIds.has(currentNestedRow.data.id)) {
+                return currentNestedRow;
+            }
+            if (!currentNestedRow.subRows) {
+                return null;
+            }
+            const subRowsToKeep = [];
+            for (const subRow of currentNestedRow.subRows) {
+                const rowToKeep = recursiveFindRowsToKeep(subRow);
+                if (rowToKeep) {
+                    subRowsToKeep.push(rowToKeep);
+                }
+            }
+            if (subRowsToKeep.length == 0) {
+                return null;
+            }
+            return {
+                ...currentNestedRow,
+                subRows: subRowsToKeep,
+            };
+        }
+        const keptNestedRows = [];
+        for (const outerLevelHeader of allRows) {
+            if (!outerLevelHeader.subRows) {
+                continue;
+            }
+            const keptSubRows = [];
+            for (const nestedRow of outerLevelHeader.subRows) {
+                const rowToKeep = recursiveFindRowsToKeep(nestedRow);
+                if (rowToKeep) {
+                    keptSubRows.push(rowToKeep);
+                }
+            }
+            if (keptSubRows.length == 0) {
+                continue;
+            }
+            keptNestedRows.push({
+                ...outerLevelHeader,
+                subRows: keptSubRows,
+            });
+        }
+        return keptNestedRows;
+    }
+    TableNestingHelpers.findNestedRowsWithHeadersToKeep = findNestedRowsWithHeadersToKeep;
+    // Count how many rows we have at the bottom level of nesting.
+    function countBottomLevelNestedRows(allNestedRows) {
+        let bottomLevelRowCount = 0;
+        function recursiveCountRows(currentNestedRow) {
+            if (!currentNestedRow.subRows || currentNestedRow.subRows.length == 0) {
+                bottomLevelRowCount++;
+            }
+            else {
+                for (const subRow of currentNestedRow.subRows) {
+                    recursiveCountRows(subRow);
+                }
+            }
+        }
+        for (const nestedRow of allNestedRows) {
+            recursiveCountRows(nestedRow);
+        }
+        return bottomLevelRowCount;
+    }
+    TableNestingHelpers.countBottomLevelNestedRows = countBottomLevelNestedRows;
+    // Count the rows pagination pages through.
+    function countNestedRows(allHeaders, paginateBy) {
+        return paginateBy === 'topRows'
+            ? sumBy(allHeaders, header => header.subRows.length)
+            : countBottomLevelNestedHeaderRows(allHeaders);
+    }
+    TableNestingHelpers.countNestedRows = countNestedRows;
+    // Count how many rows we have at the bottom level of nesting.
+    function countBottomLevelNestedHeaderRows(allHeaders) {
+        let bottomLevelRowCount = 0;
+        for (const headerRow of allHeaders) {
+            const currentHeaderBottomRowCount = countBottomLevelNestedRows(headerRow.subRows);
+            bottomLevelRowCount += currentHeaderBottomRowCount;
+        }
+        return bottomLevelRowCount;
+    }
+    TableNestingHelpers.countBottomLevelNestedHeaderRows = countBottomLevelNestedHeaderRows;
+})(TableNestingHelpers || (TableNestingHelpers = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nesting-helpers.js","sourceRoot":"","sources":["../../../../../../../projects/riv/src/lib/table/table/state-helpers/nesting-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { sumBy } from 'lodash';\nimport { RivTable } from '../state';\nimport { TableCollapseHelpers } from './collapse-helpers';\n\nexport namespace TableNestingHelpers {\n  export function convertToFullNestedRow<\n    R extends RivTable.Row,\n    C extends RivTable.Column,\n    F extends RivTable.Filters,\n    G extends RivTable.Group = { key: '' },\n  >(\n    currentRow: RivTable.NestedRow<R>,\n    coreState: RivTable.CoreState<R, C, F, G>,\n    rowLinkFunction?: (row: R, group?: G) => RivTable.RowLink,\n  ): RivTable.FullNestedRow<R> {\n    const currentSubRows: RivTable.FullNestedRow<R>[] = currentRow.subRows\n      ? currentRow.subRows.map(subrow =>\n          convertToFullNestedRow(subrow, coreState, rowLinkFunction),\n        )\n      : [];\n\n    const currentRowLink: RivTable.RowLink | null = rowLinkFunction\n      ? rowLinkFunction(currentRow.data)\n      : null;\n\n    // We don't currently support selecting nested rows\n    const currentRowIsSelected: boolean = false;\n\n    const currentRowIsCollapsed: boolean = TableCollapseHelpers.isRowCollapsed(\n      coreState,\n      currentRow.data.id,\n    );\n\n    return {\n      id: currentRow.data.id,\n      data: currentRow.data,\n      rowLink: currentRowLink,\n      selected: currentRowIsSelected,\n      subRows: currentSubRows,\n      isCollapsed: currentRowIsCollapsed,\n    };\n  }\n\n  export function convertToFullNestedHeaderRow<\n    R extends RivTable.Row,\n    C extends RivTable.Column,\n    F extends RivTable.Filters,\n    G extends RivTable.Group = { key: '' },\n  >(\n    currentRow: RivTable.NestedHeaderRow<R>,\n    coreState: RivTable.CoreState<R, C, F, G>,\n    rowLinkFunction?: (row: R, group?: G) => RivTable.RowLink,\n  ): RivTable.FullNestedHeaderRow<R> {\n    const currentSubRows: RivTable.FullNestedRow<R>[] = currentRow.subRows\n      ? currentRow.subRows.map(subrow =>\n          convertToFullNestedRow(subrow, coreState, rowLinkFunction),\n        )\n      : [];\n\n    const currentHeaderIsCollapsed: boolean =\n      TableCollapseHelpers.isHeaderCollapsed(coreState, currentRow.headerText);\n\n    return {\n      id: currentRow.headerText ?? '',\n      subRows: currentSubRows,\n      headerText: currentRow.headerText,\n      isCollapsed: currentHeaderIsCollapsed,\n    };\n  }\n\n  export function findNestedRowsWithHeadersToKeep<R extends RivTable.Row>(\n    allRows: RivTable.NestedHeaderRow<R>[],\n    filteredRows: R[],\n  ): RivTable.NestedHeaderRow<R>[] {\n    const filteredIds: Set<string | number> = new Set(\n      filteredRows.map(row => row.id),\n    );\n\n    function recursiveFindRowsToKeep(\n      currentNestedRow: RivTable.NestedRow<R>,\n    ): RivTable.NestedRow<R> | null {\n      // Keep all subrows if a parent row matches the filter\n      if (filteredIds.has(currentNestedRow.data.id)) {\n        return currentNestedRow;\n      }\n\n      if (!currentNestedRow.subRows) {\n        return null;\n      }\n\n      const subRowsToKeep: RivTable.NestedRow<R>[] = [];\n      for (const subRow of currentNestedRow.subRows) {\n        const rowToKeep: RivTable.NestedRow<R> | null =\n          recursiveFindRowsToKeep(subRow);\n        if (rowToKeep) {\n          subRowsToKeep.push(rowToKeep);\n        }\n      }\n\n      if (subRowsToKeep.length == 0) {\n        return null;\n      }\n\n      return {\n        ...currentNestedRow,\n        subRows: subRowsToKeep,\n      };\n    }\n\n    const keptNestedRows: RivTable.NestedHeaderRow<R>[] = [];\n\n    for (const outerLevelHeader of allRows) {\n      if (!outerLevelHeader.subRows) {\n        continue;\n      }\n\n      const keptSubRows: RivTable.NestedRow<R>[] = [];\n      for (const nestedRow of outerLevelHeader.subRows) {\n        const rowToKeep: RivTable.NestedRow<R> | null =\n          recursiveFindRowsToKeep(nestedRow);\n        if (rowToKeep) {\n          keptSubRows.push(rowToKeep);\n        }\n      }\n\n      if (keptSubRows.length == 0) {\n        continue;\n      }\n\n      keptNestedRows.push({\n        ...outerLevelHeader,\n        subRows: keptSubRows,\n      });\n    }\n\n    return keptNestedRows;\n  }\n\n  // Count how many rows we have at the bottom level of nesting.\n  export function countBottomLevelNestedRows<R extends RivTable.Row>(\n    allNestedRows: RivTable.NestedRow<R>[],\n  ): number {\n    let bottomLevelRowCount: number = 0;\n\n    function recursiveCountRows(currentNestedRow: RivTable.NestedRow<R>) {\n      if (!currentNestedRow.subRows || currentNestedRow.subRows.length == 0) {\n        bottomLevelRowCount++;\n      } else {\n        for (const subRow of currentNestedRow.subRows) {\n          recursiveCountRows(subRow);\n        }\n      }\n    }\n\n    for (const nestedRow of allNestedRows) {\n      recursiveCountRows(nestedRow);\n    }\n\n    return bottomLevelRowCount;\n  }\n\n  // Count the rows pagination pages through.\n  export function countNestedRows<R extends RivTable.Row>(\n    allHeaders: RivTable.NestedHeaderRow<R>[],\n    paginateBy: RivTable.NestedPaginateBy,\n  ): number {\n    return paginateBy === 'topRows'\n      ? sumBy(allHeaders, header => header.subRows.length)\n      : countBottomLevelNestedHeaderRows(allHeaders);\n  }\n\n  // Count how many rows we have at the bottom level of nesting.\n  export function countBottomLevelNestedHeaderRows<R extends RivTable.Row>(\n    allHeaders: RivTable.NestedHeaderRow<R>[],\n  ): number {\n    let bottomLevelRowCount: number = 0;\n\n    for (const headerRow of allHeaders) {\n      const currentHeaderBottomRowCount: number = countBottomLevelNestedRows(\n        headerRow.subRows,\n      );\n      bottomLevelRowCount += currentHeaderBottomRowCount;\n    }\n\n    return bottomLevelRowCount;\n  }\n}\n"]}

package/esm2022/lib/table/table/state-helpers/order-helpers.mjs

@@ -0,0 +1,164 @@
+import { orderBy } from 'lodash';
+export var TableOrderHelpers;
+(function (TableOrderHelpers) {
+    function orderEmptyLast(rows, key, direction) {
+        return orderBy(rows, [row => row[key] == null, key], ['asc', direction]);
+    }
+    TableOrderHelpers.orderEmptyLast = orderEmptyLast;
+    function orderNestedRowsEmptyLast(rows, key, direction) {
+        return orderBy(rows, [row => row.data[key] == null, row => row.data[key]], ['asc', direction]);
+    }
+    TableOrderHelpers.orderNestedRowsEmptyLast = orderNestedRowsEmptyLast;
+    function orderNestedRowsBySearchMatch(rows, idToSearchIndexMap) {
+        return orderBy(rows, [row => idToSearchIndexMap.get(row.data.id)], ['asc']);
+    }
+    TableOrderHelpers.orderNestedRowsBySearchMatch = orderNestedRowsBySearchMatch;
+    function toggleColumnOrder(state, column) {
+        if (state.query.order?.column === column) {
+            return {
+                ...state,
+                query: {
+                    ...state.query,
+                    order: state.query.order.direction === 'asc'
+                        ? {
+                            column,
+                            direction: 'desc',
+                        }
+                        : null,
+                },
+            };
+        }
+        return {
+            ...state,
+            query: {
+                ...state.query,
+                order: {
+                    column,
+                    direction: 'asc',
+                },
+            },
+        };
+    }
+    TableOrderHelpers.toggleColumnOrder = toggleColumnOrder;
+    /*
+      We only sort the lowest level rows if rows are nested.
+  
+      In other words, we sort within each nested group, but do
+        NOT sort in relation to the other groups.
+    */
+    function sortLowLevelNestedRows(allRows, sortKey, direction) {
+        function recursiveSortRows(nestedRows) {
+            const hasDeeperNesting = nestedRows.some(row => row.subRows && row.subRows.length > 0);
+            if (!hasDeeperNesting) {
+                const sortedRows = orderNestedRowsEmptyLast(nestedRows, sortKey, direction);
+                return sortedRows;
+            }
+            else {
+                // If there is a deeper nesting, keep recursing
+                const sortedRows = [];
+                for (const currentNestedRow of nestedRows) {
+                    if (currentNestedRow.subRows && currentNestedRow.subRows.length > 0) {
+                        const sortedSubRows = recursiveSortRows(currentNestedRow.subRows);
+                        sortedRows.push({
+                            ...currentNestedRow,
+                            subRows: sortedSubRows,
+                        });
+                    }
+                    else {
+                        sortedRows.push(currentNestedRow);
+                    }
+                }
+                return sortedRows;
+            }
+        }
+        return recursiveSortRows(allRows);
+    }
+    TableOrderHelpers.sortLowLevelNestedRows = sortLowLevelNestedRows;
+    // Sort the data inside the headers, not the headers themselves
+    function sortLowLevelNestedRowsWithHeaders(allHeaders, sortKey, direction) {
+        const sortedHeaderRows = [];
+        for (const headerRow of allHeaders) {
+            const sortedSubRows = sortLowLevelNestedRows(headerRow.subRows, sortKey, direction);
+            sortedHeaderRows.push({
+                ...headerRow,
+                subRows: sortedSubRows,
+            });
+        }
+        return sortedHeaderRows;
+    }
+    TableOrderHelpers.sortLowLevelNestedRowsWithHeaders = sortLowLevelNestedRowsWithHeaders;
+    // Create map to help us sort on Fuse relevance order
+    function createIdToSearchIndexMap(rowsMatchingSearch) {
+        const idToSearchIndexMap = new Map();
+        for (let i = 0; i < rowsMatchingSearch.length; i++) {
+            const rowMatchingIndex = rowsMatchingSearch[i];
+            idToSearchIndexMap.set(rowMatchingIndex.id, i);
+        }
+        return idToSearchIndexMap;
+    }
+    TableOrderHelpers.createIdToSearchIndexMap = createIdToSearchIndexMap;
+    // Sort based on how well the rows match a search
+    function sortNestedRowsBasedOnSearchMatches(allRows, idToSearchIndexMap) {
+        function recursiveSortRowsBySearchMatch(nestedRows) {
+            const hasDeeperNesting = nestedRows.some(row => row.subRows && row.subRows.length > 0);
+            if (!hasDeeperNesting) {
+                const sortedRows = orderNestedRowsBySearchMatch(nestedRows, idToSearchIndexMap);
+                return sortedRows;
+            }
+            else {
+                // If there is a deeper nesting, keep recursing
+                const sortedRows = [];
+                for (const currentNestedRow of nestedRows) {
+                    if (currentNestedRow.subRows && currentNestedRow.subRows.length > 0) {
+                        const sortedSubRows = recursiveSortRowsBySearchMatch(currentNestedRow.subRows);
+                        sortedRows.push({
+                            ...currentNestedRow,
+                            subRows: sortedSubRows,
+                        });
+                    }
+                    else {
+                        sortedRows.push(currentNestedRow);
+                    }
+                }
+                return sortedRows;
+            }
+        }
+        return recursiveSortRowsBySearchMatch(allRows);
+    }
+    TableOrderHelpers.sortNestedRowsBasedOnSearchMatches = sortNestedRowsBasedOnSearchMatches;
+    // Sort based on how well the rows match a search
+    function sortNestedRowsWithHeadersBasedOnSearchMatches(allHeaders, idToSearchIndexMap) {
+        const sortedHeaderRows = [];
+        for (const headerRow of allHeaders) {
+            const sortedSubRows = sortNestedRowsBasedOnSearchMatches(headerRow.subRows, idToSearchIndexMap);
+            sortedHeaderRows.push({
+                ...headerRow,
+                subRows: sortedSubRows,
+            });
+        }
+        return sortedHeaderRows;
+    }
+    TableOrderHelpers.sortNestedRowsWithHeadersBasedOnSearchMatches = sortNestedRowsWithHeadersBasedOnSearchMatches;
+    /*
+      When a defaultSort is specified, seed the initial query.order so the
+      table header shows the sort indicator from the start.
+    */
+    function seedDefaultSortOption(options) {
+        if (options?.defaultSort && !options?.initialState?.query?.order) {
+            const order = options.defaultSort;
+            return {
+                ...options,
+                initialState: {
+                    ...options.initialState,
+                    query: {
+                        ...options.initialState?.query,
+                        order,
+                    },
+                },
+            };
+        }
+        return options;
+    }
+    TableOrderHelpers.seedDefaultSortOption = seedDefaultSortOption;
+})(TableOrderHelpers || (TableOrderHelpers = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"order-helpers.js","sourceRoot":"","sources":["../../../../../../../projects/riv/src/lib/table/table/state-helpers/order-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { orderBy } from 'lodash';\nimport { DeepPartial } from 'utility-types';\nimport { RivTable } from '../state';\n\nexport namespace TableOrderHelpers {\n  export function orderEmptyLast<R>(\n    rows: R[],\n    key: keyof R,\n    direction: RivTable.OrderDirection,\n  ): R[] {\n    return orderBy(rows, [row => row[key] == null, key], ['asc', direction]);\n  }\n\n  export function orderNestedRowsEmptyLast<R extends RivTable.Row>(\n    rows: RivTable.NestedRow<R>[],\n    key: keyof R,\n    direction: RivTable.OrderDirection,\n  ): RivTable.NestedRow<R>[] {\n    return orderBy(\n      rows,\n      [row => row.data[key] == null, row => row.data[key]],\n      ['asc', direction],\n    );\n  }\n\n  export function orderNestedRowsBySearchMatch<R extends RivTable.Row>(\n    rows: RivTable.NestedRow<R>[],\n    idToSearchIndexMap: Map<string | number, number>,\n  ): RivTable.NestedRow<R>[] {\n    return orderBy(rows, [row => idToSearchIndexMap.get(row.data.id)], ['asc']);\n  }\n\n  export function toggleColumnOrder<\n    R extends RivTable.Row,\n    C extends RivTable.Column,\n    F extends RivTable.Filters,\n    G extends RivTable.Group,\n  >(\n    state: RivTable.CoreState<R, C, F, G>,\n    column: C,\n  ): RivTable.CoreState<R, C, F, G> {\n    if (state.query.order?.column === column) {\n      return {\n        ...state,\n        query: {\n          ...state.query,\n          order:\n            state.query.order.direction === 'asc'\n              ? {\n                  column,\n                  direction: 'desc',\n                }\n              : null,\n        },\n      };\n    }\n    return {\n      ...state,\n      query: {\n        ...state.query,\n        order: {\n          column,\n          direction: 'asc',\n        },\n      },\n    };\n  }\n\n  /*\n    We only sort the lowest level rows if rows are nested.\n\n    In other words, we sort within each nested group, but do\n      NOT sort in relation to the other groups.\n  */\n  export function sortLowLevelNestedRows<R extends RivTable.Row>(\n    allRows: RivTable.NestedRow<R>[],\n    sortKey: keyof R,\n    direction: RivTable.OrderDirection,\n  ): RivTable.NestedRow<R>[] {\n    function recursiveSortRows(\n      nestedRows: RivTable.NestedRow<R>[],\n    ): RivTable.NestedRow<R>[] {\n      const hasDeeperNesting: boolean = nestedRows.some(\n        row => row.subRows && row.subRows.length > 0,\n      );\n      if (!hasDeeperNesting) {\n        const sortedRows: RivTable.NestedRow<R>[] = orderNestedRowsEmptyLast(\n          nestedRows,\n          sortKey,\n          direction,\n        );\n        return sortedRows;\n      } else {\n        // If there is a deeper nesting, keep recursing\n        const sortedRows: RivTable.NestedRow<R>[] = [];\n        for (const currentNestedRow of nestedRows) {\n          if (currentNestedRow.subRows && currentNestedRow.subRows.length > 0) {\n            const sortedSubRows: RivTable.NestedRow<R>[] = recursiveSortRows(\n              currentNestedRow.subRows,\n            );\n            sortedRows.push({\n              ...currentNestedRow,\n              subRows: sortedSubRows,\n            });\n          } else {\n            sortedRows.push(currentNestedRow);\n          }\n        }\n\n        return sortedRows;\n      }\n    }\n\n    return recursiveSortRows(allRows);\n  }\n\n  // Sort the data inside the headers, not the headers themselves\n  export function sortLowLevelNestedRowsWithHeaders<R extends RivTable.Row>(\n    allHeaders: RivTable.NestedHeaderRow<R>[],\n    sortKey: keyof R,\n    direction: RivTable.OrderDirection,\n  ): RivTable.NestedHeaderRow<R>[] {\n    const sortedHeaderRows: RivTable.NestedHeaderRow<R>[] = [];\n    for (const headerRow of allHeaders) {\n      const sortedSubRows: RivTable.NestedRow<R>[] = sortLowLevelNestedRows(\n        headerRow.subRows,\n        sortKey,\n        direction,\n      );\n      sortedHeaderRows.push({\n        ...headerRow,\n        subRows: sortedSubRows,\n      });\n    }\n\n    return sortedHeaderRows;\n  }\n\n  // Create map to help us sort on Fuse relevance order\n  export function createIdToSearchIndexMap<R extends RivTable.Row>(\n    rowsMatchingSearch: R[],\n  ): Map<string | number, number> {\n    const idToSearchIndexMap: Map<string | number, number> = new Map();\n\n    for (let i = 0; i < rowsMatchingSearch.length; i++) {\n      const rowMatchingIndex: R = rowsMatchingSearch[i];\n      idToSearchIndexMap.set(rowMatchingIndex.id, i);\n    }\n\n    return idToSearchIndexMap;\n  }\n\n  // Sort based on how well the rows match a search\n  export function sortNestedRowsBasedOnSearchMatches<R extends RivTable.Row>(\n    allRows: RivTable.NestedRow<R>[],\n    idToSearchIndexMap: Map<string | number, number>,\n  ): RivTable.NestedRow<R>[] {\n    function recursiveSortRowsBySearchMatch(\n      nestedRows: RivTable.NestedRow<R>[],\n    ): RivTable.NestedRow<R>[] {\n      const hasDeeperNesting: boolean = nestedRows.some(\n        row => row.subRows && row.subRows.length > 0,\n      );\n      if (!hasDeeperNesting) {\n        const sortedRows: RivTable.NestedRow<R>[] =\n          orderNestedRowsBySearchMatch(nestedRows, idToSearchIndexMap);\n        return sortedRows;\n      } else {\n        // If there is a deeper nesting, keep recursing\n        const sortedRows: RivTable.NestedRow<R>[] = [];\n        for (const currentNestedRow of nestedRows) {\n          if (currentNestedRow.subRows && currentNestedRow.subRows.length > 0) {\n            const sortedSubRows: RivTable.NestedRow<R>[] =\n              recursiveSortRowsBySearchMatch(currentNestedRow.subRows);\n            sortedRows.push({\n              ...currentNestedRow,\n              subRows: sortedSubRows,\n            });\n          } else {\n            sortedRows.push(currentNestedRow);\n          }\n        }\n\n        return sortedRows;\n      }\n    }\n\n    return recursiveSortRowsBySearchMatch(allRows);\n  }\n\n  // Sort based on how well the rows match a search\n  export function sortNestedRowsWithHeadersBasedOnSearchMatches<\n    R extends RivTable.Row,\n  >(\n    allHeaders: RivTable.NestedHeaderRow<R>[],\n    idToSearchIndexMap: Map<string | number, number>,\n  ): RivTable.NestedHeaderRow<R>[] {\n    const sortedHeaderRows: RivTable.NestedHeaderRow<R>[] = [];\n    for (const headerRow of allHeaders) {\n      const sortedSubRows: RivTable.NestedRow<R>[] =\n        sortNestedRowsBasedOnSearchMatches(\n          headerRow.subRows,\n          idToSearchIndexMap,\n        );\n      sortedHeaderRows.push({\n        ...headerRow,\n        subRows: sortedSubRows,\n      });\n    }\n\n    return sortedHeaderRows;\n  }\n\n  /*\n    When a defaultSort is specified, seed the initial query.order so the\n    table header shows the sort indicator from the start.\n  */\n  export function seedDefaultSortOption<\n    R extends RivTable.Row,\n    C extends RivTable.Column,\n    F extends RivTable.Filters,\n  >(\n    options?: RivTable.InMemoryManagerOptions<R, C, F>,\n  ): RivTable.InMemoryManagerOptions<R, C, F> | undefined {\n    if (options?.defaultSort && !options?.initialState?.query?.order) {\n      const order: RivTable.Query<C, F>['order'] = options.defaultSort;\n      return {\n        ...options,\n        initialState: {\n          ...options.initialState,\n          query: {\n            ...options.initialState?.query,\n            order,\n          } as DeepPartial<RivTable.Query<C, F>>,\n        },\n      };\n    }\n\n    return options;\n  }\n}\n"]}

package/esm2022/lib/table/table/state-helpers/pagination-helpers.mjs

@@ -0,0 +1,139 @@
+import { range } from 'lodash';
+import { RivTable } from '../state';
+import { TableResultHelpers } from './result-helpers';
+export var TablePaginationHelpers;
+(function (TablePaginationHelpers) {
+    function getPageCount(state) {
+        if (TableResultHelpers.isGroupResult(state.result)) {
+            return Math.max(Math.ceil(state.result.totalGroupCount / state.query.grouping.groupsPerPage), 1);
+        }
+        return Math.max(Math.ceil(state.result.totalMatchingRowCount / state.query.pagination.pageSize), 1);
+    }
+    TablePaginationHelpers.getPageCount = getPageCount;
+    function getPreviousPage(state) {
+        return state.query.pagination.page === 0
+            ? null
+            : state.query.pagination.page - 1;
+    }
+    TablePaginationHelpers.getPreviousPage = getPreviousPage;
+    function getPages(state) {
+        const padding = 4;
+        const min = 0;
+        const max = getPageCount(state) - 1;
+        const desiredStart = state.query.pagination.page - padding;
+        const clampedStart = Math.max(min, desiredStart);
+        const desiredEnd = state.query.pagination.page + padding;
+        const clampedEnd = Math.min(max, desiredEnd);
+        const start = Math.max(min, clampedStart - (desiredEnd - clampedEnd));
+        const end = Math.min(max, clampedEnd + (clampedStart - desiredStart));
+        return range(start, end + 1);
+    }
+    TablePaginationHelpers.getPages = getPages;
+    function getNextPage(state) {
+        const max = getPageCount(state) - 1;
+        const next = state.query.pagination.page + 1;
+        return next <= max ? next : null;
+    }
+    TablePaginationHelpers.getNextPage = getNextPage;
+    // We don't want to show the pagination controls when they are unnecessary.
+    function getShowPaginationControls(state) {
+        if (state.query.pagination.page > 0) {
+            return true;
+        }
+        if (TableResultHelpers.isGroupResult(state.result)) {
+            return state.result.totalGroupCount > state.query.grouping.groupsPerPage;
+        }
+        return (state.result.totalMatchingRowCount > Math.min(...[...RivTable.pageSizes]));
+    }
+    TablePaginationHelpers.getShowPaginationControls = getShowPaginationControls;
+    function getPageRowStart(state) {
+        return state.query.pagination.page * state.query.pagination.pageSize + 1;
+    }
+    TablePaginationHelpers.getPageRowStart = getPageRowStart;
+    function getPageRowEnd(state) {
+        return Math.min((state.query.pagination.page + 1) * state.query.pagination.pageSize, state.result.totalMatchingRowCount);
+    }
+    TablePaginationHelpers.getPageRowEnd = getPageRowEnd;
+    function isPageOutOfBounds(state, result) {
+        if (TableResultHelpers.isGroupResult(result)) {
+            const minGroupValToShowOnCurrentPage = state.query.pagination.page * state.query.grouping.groupsPerPage + 1;
+            if (result.totalGroupCount < minGroupValToShowOnCurrentPage) {
+                return true;
+            }
+        }
+        else {
+            const minRowToShowOnCurrentPage = state.query.pagination.page * state.query.pagination.pageSize + 1;
+            if (result.totalMatchingRowCount < minRowToShowOnCurrentPage) {
+                return true;
+            }
+        }
+        return false;
+    }
+    TablePaginationHelpers.isPageOutOfBounds = isPageOutOfBounds;
+    /*
+      Paginate based on bottom level rows, splitting as necessary to fit within the page,
+      or based on top level rows, keeping each with all of its subrows.
+    */
+    function paginateNestedHeaderRows(allHeaders, pageNumber, pageSize, paginateBy = 'bottomRows') {
+        const startIdx = pageSize * pageNumber;
+        const endIdx = startIdx + pageSize;
+        let countedRowCount = 0;
+        function countRow(currentNestedRow) {
+            countedRowCount++;
+            // Since we add 1 first, the bounds should be (startIdx, endIdx]
+            return countedRowCount > startIdx && countedRowCount <= endIdx
+                ? currentNestedRow
+                : null;
+        }
+        function recursivePaginateRows(currentNestedRow) {
+            if (countedRowCount > endIdx) {
+                return null;
+            }
+            // If there are no subrows, stop recursing
+            if (!currentNestedRow.subRows?.length) {
+                return countRow(currentNestedRow);
+            }
+            else {
+                const subRowsToKeep = [];
+                for (const subRow of currentNestedRow.subRows) {
+                    const countedRow = recursivePaginateRows(subRow);
+                    if (countedRow != null) {
+                        subRowsToKeep.push(countedRow);
+                    }
+                }
+                if (subRowsToKeep.length == 0) {
+                    return null;
+                }
+                else {
+                    // Keep any top level row that has at least one subrow
+                    return {
+                        ...currentNestedRow,
+                        subRows: subRowsToKeep,
+                    };
+                }
+            }
+        }
+        const paginatedHeaders = [];
+        for (const headerRow of allHeaders) {
+            const paginatedSubRows = [];
+            for (const subRow of headerRow.subRows) {
+                const recursedSubRow = paginateBy === 'topRows'
+                    ? countRow(subRow)
+                    : recursivePaginateRows(subRow);
+                if (recursedSubRow != null) {
+                    paginatedSubRows.push(recursedSubRow);
+                }
+            }
+            if (paginatedSubRows.length > 0) {
+                // Keep any header that has at least one subrow in the current page
+                paginatedHeaders.push({
+                    ...headerRow,
+                    subRows: paginatedSubRows,
+                });
+            }
+        }
+        return paginatedHeaders;
+    }
+    TablePaginationHelpers.paginateNestedHeaderRows = paginateNestedHeaderRows;
+})(TablePaginationHelpers || (TablePaginationHelpers = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination-helpers.js","sourceRoot":"","sources":["../../../../../../../projects/riv/src/lib/table/table/state-helpers/pagination-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { range } from 'lodash';\nimport { RivTable } from '../state';\nimport { TableResultHelpers } from './result-helpers';\n\nexport namespace TablePaginationHelpers {\n  export function getPageCount<\n    R extends RivTable.Row,\n    C extends RivTable.Column,\n    F extends RivTable.Filters,\n    G extends RivTable.Group,\n  >(state: RivTable.CoreState<R, C, F, G>): number {\n    if (TableResultHelpers.isGroupResult(state.result)) {\n      return Math.max(\n        Math.ceil(\n          state.result.totalGroupCount / state.query.grouping.groupsPerPage,\n        ),\n        1,\n      );\n    }\n    return Math.max(\n      Math.ceil(\n        state.result.totalMatchingRowCount / state.query.pagination.pageSize,\n      ),\n      1,\n    );\n  }\n\n  export function getPreviousPage<\n    R extends RivTable.Row,\n    C extends RivTable.Column,\n    F extends RivTable.Filters,\n    G extends RivTable.Group,\n  >(state: RivTable.CoreState<R, C, F, G>): number | null {\n    return state.query.pagination.page === 0\n      ? null\n      : state.query.pagination.page - 1;\n  }\n\n  export function getPages<\n    R extends RivTable.Row,\n    C extends RivTable.Column,\n    F extends RivTable.Filters,\n    G extends RivTable.Group,\n  >(state: RivTable.CoreState<R, C, F, G>): number[] {\n    const padding = 4;\n    const min = 0;\n    const max = getPageCount(state) - 1;\n    const desiredStart = state.query.pagination.page - padding;\n    const clampedStart = Math.max(min, desiredStart);\n    const desiredEnd = state.query.pagination.page + padding;\n    const clampedEnd = Math.min(max, desiredEnd);\n    const start = Math.max(min, clampedStart - (desiredEnd - clampedEnd));\n    const end = Math.min(max, clampedEnd + (clampedStart - desiredStart));\n    return range(start, end + 1);\n  }\n\n  export function getNextPage<\n    R extends RivTable.Row,\n    C extends RivTable.Column,\n    F extends RivTable.Filters,\n    G extends RivTable.Group,\n  >(state: RivTable.CoreState<R, C, F, G>): number | null {\n    const max = getPageCount(state) - 1;\n    const next = state.query.pagination.page + 1;\n    return next <= max ? next : null;\n  }\n\n  // We don't want to show the pagination controls when they are unnecessary.\n  export function getShowPaginationControls<\n    R extends RivTable.Row,\n    C extends RivTable.Column,\n    F extends RivTable.Filters,\n    G extends RivTable.Group,\n  >(state: RivTable.CoreState<R, C, F, G>): boolean {\n    if (state.query.pagination.page > 0) {\n      return true;\n    }\n    if (TableResultHelpers.isGroupResult(state.result)) {\n      return state.result.totalGroupCount > state.query.grouping.groupsPerPage;\n    }\n    return (\n      state.result.totalMatchingRowCount > Math.min(...[...RivTable.pageSizes])\n    );\n  }\n\n  export function getPageRowStart<\n    R extends RivTable.Row,\n    C extends RivTable.Column,\n    F extends RivTable.Filters,\n    G extends RivTable.Group,\n  >(state: RivTable.CoreState<R, C, F, G>): number {\n    return state.query.pagination.page * state.query.pagination.pageSize + 1;\n  }\n\n  export function getPageRowEnd<\n    R extends RivTable.Row,\n    C extends RivTable.Column,\n    F extends RivTable.Filters,\n    G extends RivTable.Group,\n  >(state: RivTable.CoreState<R, C, F, G>): number {\n    return Math.min(\n      (state.query.pagination.page + 1) * state.query.pagination.pageSize,\n      state.result.totalMatchingRowCount,\n    );\n  }\n\n  export function isPageOutOfBounds<\n    R extends RivTable.Row,\n    C extends RivTable.Column,\n    F extends RivTable.Filters,\n    G extends RivTable.Group,\n  >(\n    state: RivTable.CoreState<R, C, F, G>,\n    result:\n      | RivTable.Result<R>\n      | RivTable.GroupResult<R, G>\n      | RivTable.NestedResult<R>,\n  ): boolean {\n    if (TableResultHelpers.isGroupResult(result)) {\n      const minGroupValToShowOnCurrentPage =\n        state.query.pagination.page * state.query.grouping.groupsPerPage + 1;\n      if (result.totalGroupCount < minGroupValToShowOnCurrentPage) {\n        return true;\n      }\n    } else {\n      const minRowToShowOnCurrentPage =\n        state.query.pagination.page * state.query.pagination.pageSize + 1;\n      if (result.totalMatchingRowCount < minRowToShowOnCurrentPage) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /*\n    Paginate based on bottom level rows, splitting as necessary to fit within the page,\n    or based on top level rows, keeping each with all of its subrows.\n  */\n  export function paginateNestedHeaderRows<R extends RivTable.Row>(\n    allHeaders: RivTable.NestedHeaderRow<R>[],\n    pageNumber: number,\n    pageSize: number,\n    paginateBy: RivTable.NestedPaginateBy = 'bottomRows',\n  ): RivTable.NestedHeaderRow<R>[] {\n    const startIdx: number = pageSize * pageNumber;\n    const endIdx: number = startIdx + pageSize;\n\n    let countedRowCount: number = 0;\n\n    function countRow(\n      currentNestedRow: RivTable.NestedRow<R>,\n    ): RivTable.NestedRow<R> | null {\n      countedRowCount++;\n\n      // Since we add 1 first, the bounds should be (startIdx, endIdx]\n      return countedRowCount > startIdx && countedRowCount <= endIdx\n        ? currentNestedRow\n        : null;\n    }\n\n    function recursivePaginateRows(\n      currentNestedRow: RivTable.NestedRow<R>,\n    ): RivTable.NestedRow<R> | null {\n      if (countedRowCount > endIdx) {\n        return null;\n      }\n\n      // If there are no subrows, stop recursing\n      if (!currentNestedRow.subRows?.length) {\n        return countRow(currentNestedRow);\n      } else {\n        const subRowsToKeep: RivTable.NestedRow<R>[] = [];\n        for (const subRow of currentNestedRow.subRows) {\n          const countedRow: RivTable.NestedRow<R> | null =\n            recursivePaginateRows(subRow);\n          if (countedRow != null) {\n            subRowsToKeep.push(countedRow);\n          }\n        }\n\n        if (subRowsToKeep.length == 0) {\n          return null;\n        } else {\n          // Keep any top level row that has at least one subrow\n          return {\n            ...currentNestedRow,\n            subRows: subRowsToKeep,\n          };\n        }\n      }\n    }\n\n    const paginatedHeaders: RivTable.NestedHeaderRow<R>[] = [];\n    for (const headerRow of allHeaders) {\n      const paginatedSubRows: RivTable.NestedRow<R>[] = [];\n\n      for (const subRow of headerRow.subRows) {\n        const recursedSubRow: RivTable.NestedRow<R> | null =\n          paginateBy === 'topRows'\n            ? countRow(subRow)\n            : recursivePaginateRows(subRow);\n\n        if (recursedSubRow != null) {\n          paginatedSubRows.push(recursedSubRow);\n        }\n      }\n\n      if (paginatedSubRows.length > 0) {\n        // Keep any header that has at least one subrow in the current page\n        paginatedHeaders.push({\n          ...headerRow,\n          subRows: paginatedSubRows,\n        });\n      }\n    }\n\n    return paginatedHeaders;\n  }\n}\n"]}

package/esm2022/lib/table/table/state-helpers/result-helpers.mjs

@@ -0,0 +1,70 @@
+export var TableResultHelpers;
+(function (TableResultHelpers) {
+    function isRegularResult(result) {
+        if ('currentPageData' in result) {
+            return true;
+        }
+        return false;
+    }
+    TableResultHelpers.isRegularResult = isRegularResult;
+    function isGroupResult(result) {
+        if ('totalGroupCount' in result) {
+            return true;
+        }
+        return false;
+    }
+    TableResultHelpers.isGroupResult = isGroupResult;
+    function isNestedResult(result) {
+        if ('currentPageNestedHeaders' in result) {
+            return true;
+        }
+        return false;
+    }
+    TableResultHelpers.isNestedResult = isNestedResult;
+    function hasHeaderRows(result) {
+        return result.currentPageNestedHeaders.some(header => header.headerText != null);
+    }
+    TableResultHelpers.hasHeaderRows = hasHeaderRows;
+    function getAllRowsFromResult(result) {
+        if (isGroupResult(result)) {
+            return result.groupResults.flatMap(groups => groups.currentPageData);
+        }
+        else if (isNestedResult(result)) {
+            return getAllRowsFromNestedHeaders(result.currentPageNestedHeaders);
+        }
+        else {
+            return result.currentPageData;
+        }
+    }
+    TableResultHelpers.getAllRowsFromResult = getAllRowsFromResult;
+    function getAllRowsFromNestedRows(nestedRows) {
+        const allRows = [];
+        function recursiveGetNestedRows(currentNestedRow) {
+            allRows.push(currentNestedRow.data);
+            const subRows = currentNestedRow.subRows ?? [];
+            for (const subRow of subRows) {
+                recursiveGetNestedRows(subRow);
+            }
+        }
+        for (const nestedRow of nestedRows) {
+            recursiveGetNestedRows(nestedRow);
+        }
+        return allRows;
+    }
+    function getAllRowsFromNestedHeaders(nestedHeaders) {
+        const allRows = [];
+        for (const outerNestedHeaderRow of nestedHeaders) {
+            const rowsInHeader = getAllRowsFromNestedRows(outerNestedHeaderRow.subRows);
+            for (const rowInHeader of rowsInHeader) {
+                allRows.push(rowInHeader);
+            }
+        }
+        return allRows;
+    }
+    TableResultHelpers.getAllRowsFromNestedHeaders = getAllRowsFromNestedHeaders;
+    function getCsvFilename(pluralEntityName, options) {
+        return ((options?.csvFileBasename?.slice(0, 200) ?? pluralEntityName) + '.csv');
+    }
+    TableResultHelpers.getCsvFilename = getCsvFilename;
+})(TableResultHelpers || (TableResultHelpers = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzdWx0LWhlbHBlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9yaXYvc3JjL2xpYi90YWJsZS90YWJsZS9zdGF0ZS1oZWxwZXJzL3Jlc3VsdC1oZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sS0FBVyxrQkFBa0IsQ0E0SGxDO0FBNUhELFdBQWlCLGtCQUFrQjtJQUNqQyxTQUFnQixlQUFlLENBSTdCLE1BRzRCO1FBRTVCLElBQUksaUJBQWlCLElBQUksTUFBTSxFQUFFLENBQUM7WUFDaEMsT0FBTyxJQUFJLENBQUM7UUFDZCxDQUFDO1FBQ0QsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBYmUsa0NBQWUsa0JBYTlCLENBQUE7SUFFRCxTQUFnQixhQUFhLENBSTNCLE1BRzRCO1FBRTVCLElBQUksaUJBQWlCLElBQUksTUFBTSxFQUFFLENBQUM7WUFDaEMsT0FBTyxJQUFJLENBQUM7UUFDZCxDQUFDO1FBQ0QsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBYmUsZ0NBQWEsZ0JBYTVCLENBQUE7SUFFRCxTQUFnQixjQUFjLENBSTVCLE1BRzRCO1FBRTVCLElBQUksMEJBQTBCLElBQUksTUFBTSxFQUFFLENBQUM7WUFDekMsT0FBTyxJQUFJLENBQUM7UUFDZCxDQUFDO1FBQ0QsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBYmUsaUNBQWMsaUJBYTdCLENBQUE7SUFFRCxTQUFnQixhQUFhLENBQzNCLE1BQWdDO1FBRWhDLE9BQU8sTUFBTSxDQUFDLHdCQUF3QixDQUFDLElBQUksQ0FDekMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsVUFBVSxJQUFJLElBQUksQ0FDcEMsQ0FBQztJQUNKLENBQUM7SUFOZSxnQ0FBYSxnQkFNNUIsQ0FBQTtJQUVELFNBQWdCLG9CQUFvQixDQUlsQyxNQUc0QjtRQUU1QixJQUFJLGFBQWEsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1lBQzFCLE9BQU8sTUFBTSxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsZUFBZSxDQUFDLENBQUM7UUFDdkUsQ0FBQzthQUFNLElBQUksY0FBYyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7WUFDbEMsT0FBTywyQkFBMkIsQ0FBQyxNQUFNLENBQUMsd0JBQXdCLENBQUMsQ0FBQztRQUN0RSxDQUFDO2FBQU0sQ0FBQztZQUNOLE9BQU8sTUFBTSxDQUFDLGVBQWUsQ0FBQztRQUNoQyxDQUFDO0lBQ0gsQ0FBQztJQWhCZSx1Q0FBb0IsdUJBZ0JuQyxDQUFBO0lBRUQsU0FBUyx3QkFBd0IsQ0FDL0IsVUFBbUM7UUFFbkMsTUFBTSxPQUFPLEdBQVEsRUFBRSxDQUFDO1FBRXhCLFNBQVMsc0JBQXNCLENBQUMsZ0JBQXVDO1lBQ3JFLE9BQU8sQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLENBQUM7WUFFcEMsTUFBTSxPQUFPLEdBQTRCLGdCQUFnQixDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUM7WUFDeEUsS0FBSyxNQUFNLE1BQU0sSUFBSSxPQUFPLEVBQUUsQ0FBQztnQkFDN0Isc0JBQXNCLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDakMsQ0FBQztRQUNILENBQUM7UUFFRCxLQUFLLE1BQU0sU0FBUyxJQUFJLFVBQVUsRUFBRSxDQUFDO1lBQ25DLHNCQUFzQixDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQ3BDLENBQUM7UUFFRCxPQUFPLE9BQU8sQ0FBQztJQUNqQixDQUFDO0lBRUQsU0FBZ0IsMkJBQTJCLENBQ3pDLGFBQTRDO1FBRTVDLE1BQU0sT0FBTyxHQUFRLEVBQUUsQ0FBQztRQUV4QixLQUFLLE1BQU0sb0JBQW9CLElBQUksYUFBYSxFQUFFLENBQUM7WUFDakQsTUFBTSxZQUFZLEdBQVEsd0JBQXdCLENBQ2hELG9CQUFvQixDQUFDLE9BQU8sQ0FDN0IsQ0FBQztZQUVGLEtBQUssTUFBTSxXQUFXLElBQUksWUFBWSxFQUFFLENBQUM7Z0JBQ3ZDLE9BQU8sQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7WUFDNUIsQ0FBQztRQUNILENBQUM7UUFFRCxPQUFPLE9BQU8sQ0FBQztJQUNqQixDQUFDO0lBaEJlLDhDQUEyQiw4QkFnQjFDLENBQUE7SUFFRCxTQUFnQixjQUFjLENBTTVCLGdCQUF3QixFQUN4QixPQUE2QztRQUU3QyxPQUFPLENBQ0wsQ0FBQyxPQUFPLEVBQUUsZUFBZSxFQUFFLEtBQUssQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDLElBQUksZ0JBQWdCLENBQUMsR0FBRyxNQUFNLENBQ3ZFLENBQUM7SUFDSixDQUFDO0lBWmUsaUNBQWMsaUJBWTdCLENBQUE7QUFDSCxDQUFDLEVBNUhnQixrQkFBa0IsS0FBbEIsa0JBQWtCLFFBNEhsQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJpdlRhYmxlIH0gZnJvbSAnLi4vc3RhdGUnO1xuXG5leHBvcnQgbmFtZXNwYWNlIFRhYmxlUmVzdWx0SGVscGVycyB7XG4gIGV4cG9ydCBmdW5jdGlvbiBpc1JlZ3VsYXJSZXN1bHQ8XG4gICAgUiBleHRlbmRzIFJpdlRhYmxlLlJvdyxcbiAgICBHIGV4dGVuZHMgUml2VGFibGUuR3JvdXAsXG4gID4oXG4gICAgcmVzdWx0OlxuICAgICAgfCBSaXZUYWJsZS5SZXN1bHQ8Uj5cbiAgICAgIHwgUml2VGFibGUuR3JvdXBSZXN1bHQ8UiwgRz5cbiAgICAgIHwgUml2VGFibGUuTmVzdGVkUmVzdWx0PFI+LFxuICApOiByZXN1bHQgaXMgUml2VGFibGUuUmVzdWx0PFI+IHtcbiAgICBpZiAoJ2N1cnJlbnRQYWdlRGF0YScgaW4gcmVzdWx0KSB7XG4gICAgICByZXR1cm4gdHJ1ZTtcbiAgICB9XG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG5cbiAgZXhwb3J0IGZ1bmN0aW9uIGlzR3JvdXBSZXN1bHQ8XG4gICAgUiBleHRlbmRzIFJpdlRhYmxlLlJvdyxcbiAgICBHIGV4dGVuZHMgUml2VGFibGUuR3JvdXAsXG4gID4oXG4gICAgcmVzdWx0OlxuICAgICAgfCBSaXZUYWJsZS5SZXN1bHQ8Uj5cbiAgICAgIHwgUml2VGFibGUuR3JvdXBSZXN1bHQ8UiwgRz5cbiAgICAgIHwgUml2VGFibGUuTmVzdGVkUmVzdWx0PFI+LFxuICApOiByZXN1bHQgaXMgUml2VGFibGUuR3JvdXBSZXN1bHQ8UiwgRz4ge1xuICAgIGlmICgndG90YWxHcm91cENvdW50JyBpbiByZXN1bHQpIHtcbiAgICAgIHJldHVybiB0cnVlO1xuICAgIH1cbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cblxuICBleHBvcnQgZnVuY3Rpb24gaXNOZXN0ZWRSZXN1bHQ8XG4gICAgUiBleHRlbmRzIFJpdlRhYmxlLlJvdyxcbiAgICBHIGV4dGVuZHMgUml2VGFibGUuR3JvdXAsXG4gID4oXG4gICAgcmVzdWx0OlxuICAgICAgfCBSaXZUYWJsZS5SZXN1bHQ8Uj5cbiAgICAgIHwgUml2VGFibGUuR3JvdXBSZXN1bHQ8UiwgRz5cbiAgICAgIHwgUml2VGFibGUuTmVzdGVkUmVzdWx0PFI+LFxuICApOiByZXN1bHQgaXMgUml2VGFibGUuTmVzdGVkUmVzdWx0PFI+IHtcbiAgICBpZiAoJ2N1cnJlbnRQYWdlTmVzdGVkSGVhZGVycycgaW4gcmVzdWx0KSB7XG4gICAgICByZXR1cm4gdHJ1ZTtcbiAgICB9XG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG5cbiAgZXhwb3J0IGZ1bmN0aW9uIGhhc0hlYWRlclJvd3M8UiBleHRlbmRzIFJpdlRhYmxlLlJvdz4oXG4gICAgcmVzdWx0OiBSaXZUYWJsZS5OZXN0ZWRSZXN1bHQ8Uj4sXG4gICk6IGJvb2xlYW4ge1xuICAgIHJldHVybiByZXN1bHQuY3VycmVudFBhZ2VOZXN0ZWRIZWFkZXJzLnNvbWUoXG4gICAgICBoZWFkZXIgPT4gaGVhZGVyLmhlYWRlclRleHQgIT0gbnVsbCxcbiAgICApO1xuICB9XG5cbiAgZXhwb3J0IGZ1bmN0aW9uIGdldEFsbFJvd3NGcm9tUmVzdWx0PFxuICAgIFIgZXh0ZW5kcyBSaXZUYWJsZS5Sb3csXG4gICAgRyBleHRlbmRzIFJpdlRhYmxlLkdyb3VwLFxuICA+KFxuICAgIHJlc3VsdDpcbiAgICAgIHwgUml2VGFibGUuUmVzdWx0PFI+XG4gICAgICB8IFJpdlRhYmxlLkdyb3VwUmVzdWx0PFIsIEc+XG4gICAgICB8IFJpdlRhYmxlLk5lc3RlZFJlc3VsdDxSPixcbiAgKTogUltdIHtcbiAgICBpZiAoaXNHcm91cFJlc3VsdChyZXN1bHQpKSB7XG4gICAgICByZXR1cm4gcmVzdWx0Lmdyb3VwUmVzdWx0cy5mbGF0TWFwKGdyb3VwcyA9PiBncm91cHMuY3VycmVudFBhZ2VEYXRhKTtcbiAgICB9IGVsc2UgaWYgKGlzTmVzdGVkUmVzdWx0KHJlc3VsdCkpIHtcbiAgICAgIHJldHVybiBnZXRBbGxSb3dzRnJvbU5lc3RlZEhlYWRlcnMocmVzdWx0LmN1cnJlbnRQYWdlTmVzdGVkSGVhZGVycyk7XG4gICAgfSBlbHNlIHtcbiAgICAgIHJldHVybiByZXN1bHQuY3VycmVudFBhZ2VEYXRhO1xuICAgIH1cbiAgfVxuXG4gIGZ1bmN0aW9uIGdldEFsbFJvd3NGcm9tTmVzdGVkUm93czxSIGV4dGVuZHMgUml2VGFibGUuUm93PihcbiAgICBuZXN0ZWRSb3dzOiBSaXZUYWJsZS5OZXN0ZWRSb3c8Uj5bXSxcbiAgKTogUltdIHtcbiAgICBjb25zdCBhbGxSb3dzOiBSW10gPSBbXTtcblxuICAgIGZ1bmN0aW9uIHJlY3Vyc2l2ZUdldE5lc3RlZFJvd3MoY3VycmVudE5lc3RlZFJvdzogUml2VGFibGUuTmVzdGVkUm93PFI+KSB7XG4gICAgICBhbGxSb3dzLnB1c2goY3VycmVudE5lc3RlZFJvdy5kYXRhKTtcblxuICAgICAgY29uc3Qgc3ViUm93czogUml2VGFibGUuTmVzdGVkUm93PFI+W10gPSBjdXJyZW50TmVzdGVkUm93LnN1YlJvd3MgPz8gW107XG4gICAgICBmb3IgKGNvbnN0IHN1YlJvdyBvZiBzdWJSb3dzKSB7XG4gICAgICAgIHJlY3Vyc2l2ZUdldE5lc3RlZFJvd3Moc3ViUm93KTtcbiAgICAgIH1cbiAgICB9XG5cbiAgICBmb3IgKGNvbnN0IG5lc3RlZFJvdyBvZiBuZXN0ZWRSb3dzKSB7XG4gICAgICByZWN1cnNpdmVHZXROZXN0ZWRSb3dzKG5lc3RlZFJvdyk7XG4gICAgfVxuXG4gICAgcmV0dXJuIGFsbFJvd3M7XG4gIH1cblxuICBleHBvcnQgZnVuY3Rpb24gZ2V0QWxsUm93c0Zyb21OZXN0ZWRIZWFkZXJzPFIgZXh0ZW5kcyBSaXZUYWJsZS5Sb3c+KFxuICAgIG5lc3RlZEhlYWRlcnM6IFJpdlRhYmxlLk5lc3RlZEhlYWRlclJvdzxSPltdLFxuICApOiBSW10ge1xuICAgIGNvbnN0IGFsbFJvd3M6IFJbXSA9IFtdO1xuXG4gICAgZm9yIChjb25zdCBvdXRlck5lc3RlZEhlYWRlclJvdyBvZiBuZXN0ZWRIZWFkZXJzKSB7XG4gICAgICBjb25zdCByb3dzSW5IZWFkZXI6IFJbXSA9IGdldEFsbFJvd3NGcm9tTmVzdGVkUm93cyhcbiAgICAgICAgb3V0ZXJOZXN0ZWRIZWFkZXJSb3cuc3ViUm93cyxcbiAgICAgICk7XG5cbiAgICAgIGZvciAoY29uc3Qgcm93SW5IZWFkZXIgb2Ygcm93c0luSGVhZGVyKSB7XG4gICAgICAgIGFsbFJvd3MucHVzaChyb3dJbkhlYWRlcik7XG4gICAgICB9XG4gICAgfVxuXG4gICAgcmV0dXJuIGFsbFJvd3M7XG4gIH1cblxuICBleHBvcnQgZnVuY3Rpb24gZ2V0Q3N2RmlsZW5hbWU8XG4gICAgUiBleHRlbmRzIFJpdlRhYmxlLlJvdyxcbiAgICBDIGV4dGVuZHMgUml2VGFibGUuQ29sdW1uLFxuICAgIEYgZXh0ZW5kcyBSaXZUYWJsZS5GaWx0ZXJzLFxuICAgIEcgZXh0ZW5kcyBSaXZUYWJsZS5Hcm91cCxcbiAgPihcbiAgICBwbHVyYWxFbnRpdHlOYW1lOiBzdHJpbmcsXG4gICAgb3B0aW9ucz86IFJpdlRhYmxlLk1hbmFnZXJPcHRpb25zPFIsIEMsIEYsIEc+LFxuICApOiBzdHJpbmcge1xuICAgIHJldHVybiAoXG4gICAgICAob3B0aW9ucz8uY3N2RmlsZUJhc2VuYW1lPy5zbGljZSgwLCAyMDApID8/IHBsdXJhbEVudGl0eU5hbWUpICsgJy5jc3YnXG4gICAgKTtcbiAgfVxufVxuIl19