@rivet-health/design-system 40.27.2 → 40.28.0

package/esm2020/lib/table/simple-table/simple-table.component.mjs

@@ -3,6 +3,7 @@ import { RivTable } from '../table/state';
 import { createCellCoordinateCalculator } from './coordinate-helper';
 import { SimpleTableCellComponent } from './simple-table-cell.component';
 import { SimpleTableHeaderCellComponent } from './simple-table-header-cell.component';
+import { TableColumnHelpers } from '../table/state-helpers/column-helpers';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
 export class SimpleTableComponent {
@@ -20,7 +21,7 @@ export class SimpleTableComponent {
                 const allowedTypes = RivTable.ColumnDataTypes.join(', ');
                 throw new Error(`Each header cell must define an appropriate dataType, one of ${allowedTypes}`);
             }
-            const newAlignment = RivTable.getColumnAlignment(dataType, i === 0);
+            const newAlignment = TableColumnHelpers.getColumnAlignment(dataType, i === 0);
             const newLeftPinOffset = runningWidthTotal;
             runningWidthTotal += headerCell.width;
             const changed = headerCell.alignment != newAlignment ||
@@ -100,4 +101,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                 type: ContentChildren,
                 args: [SimpleTableCellComponent, { descendants: true }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-table.component.js","sourceRoot":"","sources":["../../../../../../projects/riv/src/lib/table/simple-table/simple-table.component.ts","../../../../../../projects/riv/src/lib/table/simple-table/simple-table.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentChecked,\n  ChangeDetectionStrategy,\n  Component,\n  ContentChild,\n  ContentChildren,\n  QueryList,\n  TemplateRef,\n} from '@angular/core';\nimport { RivTable } from '../table/state';\nimport { createCellCoordinateCalculator } from './coordinate-helper';\nimport { SimpleTableCellComponent } from './simple-table-cell.component';\nimport { SimpleTableHeaderCellComponent } from './simple-table-header-cell.component';\n\n@Component({\n  selector: 'riv-simple-table',\n  templateUrl: './simple-table.component.html',\n  styleUrls: ['./simple-table.component.css'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class SimpleTableComponent implements AfterContentChecked {\n  @ContentChild('header')\n  headerTemplate?: TemplateRef<void>;\n\n  @ContentChildren(SimpleTableHeaderCellComponent, { descendants: true })\n  private headerCells?: QueryList<SimpleTableHeaderCellComponent>;\n\n  @ContentChildren(SimpleTableCellComponent, { descendants: true })\n  private dataCells?: QueryList<SimpleTableCellComponent>;\n\n  ngAfterContentChecked() {\n    this.setCellProperties();\n  }\n\n  private setCellProperties() {\n    const { headerCells, dataCells } = this;\n    if (!headerCells || !dataCells) return;\n\n    let runningWidthTotal = 0;\n    headerCells.forEach((headerCell, i) => {\n      const { dataType } = headerCell;\n      if (!dataType) {\n        const allowedTypes = RivTable.ColumnDataTypes.join(', ');\n        throw new Error(\n          `Each header cell must define an appropriate dataType, one of ${allowedTypes}`,\n        );\n      }\n\n      const newAlignment = RivTable.getColumnAlignment(dataType, i === 0);\n      const newLeftPinOffset = runningWidthTotal;\n      runningWidthTotal += headerCell.width;\n\n      const changed =\n        headerCell.alignment != newAlignment ||\n        headerCell.leftPinOffset != newLeftPinOffset;\n      headerCell.alignment = newAlignment;\n      headerCell.leftPinOffset = newLeftPinOffset;\n\n      // Only mark for check when changed to prevent infinite cycles\n      if (changed) {\n        queueMicrotask(() => {\n          headerCell.cdr.markForCheck();\n        });\n      }\n    });\n\n    const cellSpanData = dataCells.map(dataCell => {\n      const element = dataCell.elementRef.nativeElement;\n      return {\n        rowspan: parseInt(element.getAttribute('rowspan') || '1', 10),\n        colspan: parseInt(element.getAttribute('colspan') || '1', 10),\n      };\n    });\n\n    // When there are no header cells, calculate totalColumns from the first <tr>\n    let totalColumns = headerCells.length;\n    if (totalColumns === 0 && dataCells.length > 0) {\n      const firstRow = dataCells.first?.elementRef.nativeElement.parentElement;\n      if (firstRow) {\n        // Count td elements in the first row and sum their colspans\n        const cellsInFirstRow = Array.from(\n          firstRow.querySelectorAll('td[riv-simple-table-cell]'),\n        );\n        totalColumns = cellsInFirstRow.reduce((sum, cell) => {\n          const colspan = parseInt(cell.getAttribute('colspan') || '1', 10);\n          return sum + colspan;\n        }, 0);\n      }\n      // Fallback to 1 if we couldn't determine\n      if (totalColumns === 0) {\n        totalColumns = 1;\n      }\n    }\n\n    const getCellCoordinates = createCellCoordinateCalculator(\n      cellSpanData,\n      totalColumns,\n    );\n\n    const maxRow = Math.max(\n      ...dataCells.map((_, i) => getCellCoordinates(i).end.row),\n    );\n\n    dataCells.forEach((dataCell, cellIndex) => {\n      const bounds = getCellCoordinates(cellIndex);\n\n      const headerCell = headerCells.get(bounds.start.col);\n      let changed = false;\n      if (headerCell) {\n        changed =\n          dataCell.alignment != headerCell.alignment ||\n          dataCell.pinned != headerCell.pinned ||\n          dataCell.leftPinOffset != headerCell.leftPinOffset;\n\n        dataCell.alignment = headerCell.alignment;\n        dataCell.pinned = headerCell.pinned;\n        dataCell.leftPinOffset = headerCell.leftPinOffset;\n      }\n\n      const newIsLastRow = bounds.end.row === maxRow;\n      changed = changed || dataCell.isLastRow != newIsLastRow;\n      dataCell.isLastRow = newIsLastRow;\n\n      // Only mark for check when changed to prevent infinite cycles\n      if (changed) {\n        queueMicrotask(() => {\n          dataCell.cdr.markForCheck();\n        });\n      }\n    });\n  }\n}\n","<div class=\"header\" *ngIf=\"headerTemplate\">\n  <ng-container *ngTemplateOutlet=\"headerTemplate\"></ng-container>\n</div>\n<div class=\"container\" tabindex=\"0\">\n  <table>\n    <ng-content></ng-content>\n  </table>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-table.component.js","sourceRoot":"","sources":["../../../../../../projects/riv/src/lib/table/simple-table/simple-table.component.ts","../../../../../../projects/riv/src/lib/table/simple-table/simple-table.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentChecked,\n  ChangeDetectionStrategy,\n  Component,\n  ContentChild,\n  ContentChildren,\n  QueryList,\n  TemplateRef,\n} from '@angular/core';\nimport { RivTable } from '../table/state';\nimport { createCellCoordinateCalculator } from './coordinate-helper';\nimport { SimpleTableCellComponent } from './simple-table-cell.component';\nimport { SimpleTableHeaderCellComponent } from './simple-table-header-cell.component';\nimport { TableColumnHelpers } from '../table/state-helpers/column-helpers';\n\n@Component({\n  selector: 'riv-simple-table',\n  templateUrl: './simple-table.component.html',\n  styleUrls: ['./simple-table.component.css'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class SimpleTableComponent implements AfterContentChecked {\n  @ContentChild('header')\n  headerTemplate?: TemplateRef<void>;\n\n  @ContentChildren(SimpleTableHeaderCellComponent, { descendants: true })\n  private headerCells?: QueryList<SimpleTableHeaderCellComponent>;\n\n  @ContentChildren(SimpleTableCellComponent, { descendants: true })\n  private dataCells?: QueryList<SimpleTableCellComponent>;\n\n  ngAfterContentChecked() {\n    this.setCellProperties();\n  }\n\n  private setCellProperties() {\n    const { headerCells, dataCells } = this;\n    if (!headerCells || !dataCells) return;\n\n    let runningWidthTotal = 0;\n    headerCells.forEach((headerCell, i) => {\n      const { dataType } = headerCell;\n      if (!dataType) {\n        const allowedTypes = RivTable.ColumnDataTypes.join(', ');\n        throw new Error(\n          `Each header cell must define an appropriate dataType, one of ${allowedTypes}`,\n        );\n      }\n\n      const newAlignment = TableColumnHelpers.getColumnAlignment(\n        dataType,\n        i === 0,\n      );\n      const newLeftPinOffset = runningWidthTotal;\n      runningWidthTotal += headerCell.width;\n\n      const changed =\n        headerCell.alignment != newAlignment ||\n        headerCell.leftPinOffset != newLeftPinOffset;\n      headerCell.alignment = newAlignment;\n      headerCell.leftPinOffset = newLeftPinOffset;\n\n      // Only mark for check when changed to prevent infinite cycles\n      if (changed) {\n        queueMicrotask(() => {\n          headerCell.cdr.markForCheck();\n        });\n      }\n    });\n\n    const cellSpanData = dataCells.map(dataCell => {\n      const element = dataCell.elementRef.nativeElement;\n      return {\n        rowspan: parseInt(element.getAttribute('rowspan') || '1', 10),\n        colspan: parseInt(element.getAttribute('colspan') || '1', 10),\n      };\n    });\n\n    // When there are no header cells, calculate totalColumns from the first <tr>\n    let totalColumns = headerCells.length;\n    if (totalColumns === 0 && dataCells.length > 0) {\n      const firstRow = dataCells.first?.elementRef.nativeElement.parentElement;\n      if (firstRow) {\n        // Count td elements in the first row and sum their colspans\n        const cellsInFirstRow = Array.from(\n          firstRow.querySelectorAll('td[riv-simple-table-cell]'),\n        );\n        totalColumns = cellsInFirstRow.reduce((sum, cell) => {\n          const colspan = parseInt(cell.getAttribute('colspan') || '1', 10);\n          return sum + colspan;\n        }, 0);\n      }\n      // Fallback to 1 if we couldn't determine\n      if (totalColumns === 0) {\n        totalColumns = 1;\n      }\n    }\n\n    const getCellCoordinates = createCellCoordinateCalculator(\n      cellSpanData,\n      totalColumns,\n    );\n\n    const maxRow = Math.max(\n      ...dataCells.map((_, i) => getCellCoordinates(i).end.row),\n    );\n\n    dataCells.forEach((dataCell, cellIndex) => {\n      const bounds = getCellCoordinates(cellIndex);\n\n      const headerCell = headerCells.get(bounds.start.col);\n      let changed = false;\n      if (headerCell) {\n        changed =\n          dataCell.alignment != headerCell.alignment ||\n          dataCell.pinned != headerCell.pinned ||\n          dataCell.leftPinOffset != headerCell.leftPinOffset;\n\n        dataCell.alignment = headerCell.alignment;\n        dataCell.pinned = headerCell.pinned;\n        dataCell.leftPinOffset = headerCell.leftPinOffset;\n      }\n\n      const newIsLastRow = bounds.end.row === maxRow;\n      changed = changed || dataCell.isLastRow != newIsLastRow;\n      dataCell.isLastRow = newIsLastRow;\n\n      // Only mark for check when changed to prevent infinite cycles\n      if (changed) {\n        queueMicrotask(() => {\n          dataCell.cdr.markForCheck();\n        });\n      }\n    });\n  }\n}\n","<div class=\"header\" *ngIf=\"headerTemplate\">\n  <ng-container *ngTemplateOutlet=\"headerTemplate\"></ng-container>\n</div>\n<div class=\"container\" tabindex=\"0\">\n  <table>\n    <ng-content></ng-content>\n  </table>\n</div>\n"]}

package/esm2020/lib/table/table/state-helpers/column-helpers.mjs

@@ -0,0 +1,255 @@
+import { difference } from 'lodash';
+import { RivTable } from '../state';
+export var TableColumnHelpers;
+(function (TableColumnHelpers) {
+    function getColumnAlignment(dataType, isFirst) {
+        if (isFirst)
+            return 'left';
+        switch (dataType) {
+            case 'date':
+            case 'longText':
+                return 'left';
+            case 'advanced':
+            case 'icon':
+            case 'shortText':
+                return 'center';
+            case 'currency':
+            case 'number':
+                return 'right';
+        }
+    }
+    TableColumnHelpers.getColumnAlignment = getColumnAlignment;
+    function getAllColumns(state, supportedColumns, columnNameMap) {
+        // If the table offers more columns than the user has configuration settings
+        // for (or if the user has no configuration settings yet), we'll append them
+        // to the end (unless they should be pinned by default, in which case we'll
+        // append them after the other pinned columns). This ensures that new columns
+        // we add to existing tables over time (1) get displayed even though they
+        // don't appear in the user's configuration settings yet, and (2) don't
+        // interrupt their existing setup.
+        const columnNamesWithoutUserSettings = difference([...supportedColumns.keys()], state.display.columnSettings.map(({ key }) => key));
+        // Throw out settings for columns no longer offered by the table.
+        const columnsWithUserSettings = state.display.columnSettings.filter(({ key }) => supportedColumns.has(key));
+        const columnsWithoutUserSettings = [
+            ...columnNamesWithoutUserSettings,
+        ].map((key) => ({
+            key,
+            enabled: true,
+            preferredWidth: 'auto',
+            pinned: !!supportedColumns.get(key)?.defaultPinned,
+        }));
+        return orderIntentionally([...columnsWithUserSettings, ...columnsWithoutUserSettings], columnNameMap);
+    }
+    TableColumnHelpers.getAllColumns = getAllColumns;
+    function orderIntentionally(columns, columnNameMap) {
+        return [
+            ...columns.filter(v => v.pinned),
+            ...columns.filter(v => v.enabled && !v.pinned),
+            ...columns
+                .filter(v => !v.enabled && !v.pinned)
+                .sort((a, b) => {
+                const aName = columnNameMap.get(a.key) ?? a.key;
+                const bName = columnNameMap.get(b.key) ?? b.key;
+                return aName.localeCompare(bName);
+            }),
+        ];
+    }
+    function getAlignment(metadata, index, allowSelection) {
+        return getColumnAlignment(metadata.dataType, index === 0 && !allowSelection);
+    }
+    function resolveColumns(state, supportedColumns, columnNameMap, allowSelection) {
+        const allColumns = getAllColumns(state, supportedColumns, columnNameMap);
+        return allColumns
+            .filter(({ enabled }) => enabled)
+            .reduce((fullColumns, settings, i) => {
+            const metadata = supportedColumns.get(settings.key);
+            const resolvedWidth = settings.preferredWidth === 'auto'
+                ? metadata.minWidth
+                : Math.max(metadata.minWidth, settings.preferredWidth);
+            const previousColumn = fullColumns[i - 1];
+            return [
+                ...fullColumns,
+                {
+                    ...settings,
+                    ...metadata,
+                    width: resolvedWidth,
+                    left: settings.pinned
+                        ? previousColumn
+                            ? (previousColumn.left || 0) + previousColumn.width
+                            : !!allowSelection
+                                ? 40
+                                : 0
+                        : null,
+                    alignment: getAlignment(metadata, i, !!allowSelection),
+                },
+            ];
+        }, []);
+    }
+    TableColumnHelpers.resolveColumns = resolveColumns;
+    function changeColumnPin(state, columns, columnNameMap, column, pinned) {
+        const allColumns = getAllColumns(state, columns, columnNameMap);
+        if (pinned) {
+            const target = allColumns.find(c => c.key === column);
+            const wasEnabled = !!target?.enabled;
+            if (!wasEnabled) {
+                const enabledCount = allColumns.filter(col => col.enabled).length;
+                if (enabledCount >= RivTable.ColumnsMaxShown) {
+                    return state; // refuse the pin since it would exceed the max
+                }
+            }
+        }
+        return {
+            ...state,
+            display: {
+                ...state.display,
+                columnSettings: orderIntentionally(allColumns.map(c => ({
+                    ...c,
+                    pinned: c.key === column ? pinned : c.pinned,
+                    // Check/enable if being pinned
+                    enabled: c.key === column && pinned ? true : c.enabled,
+                })), columnNameMap),
+            },
+        };
+    }
+    TableColumnHelpers.changeColumnPin = changeColumnPin;
+    function changeColumnsFreezeState(state, columns, columnNameMap, index, freeze) {
+        const allColumns = getAllColumns(state, columns, columnNameMap);
+        return {
+            ...state,
+            display: {
+                ...state.display,
+                columnSettings: allColumns.map((c, i) => {
+                    return { ...c, pinned: freeze && i <= index };
+                }),
+            },
+        };
+    }
+    TableColumnHelpers.changeColumnsFreezeState = changeColumnsFreezeState;
+    function moveColumnTo(state, columns, columnNameMap, column, position) {
+        const allColumns = getAllColumns(state, columns, columnNameMap);
+        const previousIndex = allColumns.findIndex(c => c.key === column);
+        const lastIndex = position == 'end' ? allColumns.findIndex(c => !c.enabled) : 0;
+        const newIndex = position == 'start'
+            ? 0
+            : lastIndex == -1
+                ? allColumns.length - 1
+                : lastIndex;
+        if (!allColumns[previousIndex].enabled &&
+            allColumns.filter(col => col.enabled).length >= RivTable.ColumnsMaxShown)
+            return state;
+        const movedState = changeColumnOrder(state, columns, columnNameMap, previousIndex, newIndex);
+        //Make sure the column is enabled
+        return changeColumnEnabled(movedState, columns, columnNameMap, column, true);
+    }
+    TableColumnHelpers.moveColumnTo = moveColumnTo;
+    function changeColumnOrder(state, columns, columnNameMap, previousIndex, newIndex) {
+        const allColumns = getAllColumns(state, columns, columnNameMap);
+        // First, put the columns in the desired order.
+        const item = allColumns[previousIndex];
+        const withoutItem = allColumns.filter((_, i) => i !== previousIndex);
+        const reordered = [
+            ...withoutItem.slice(0, newIndex),
+            item,
+            ...withoutItem.slice(newIndex),
+        ];
+        // Then, we may need to fix the pins (all pinned columns appear at the
+        // beginning of the columns array) since the user is allowed to drag
+        // and drop columns to and from the pinned area. If the user drags a
+        // column across that threshold, update its pinned status.
+        const updated = reordered.map((settings, i, arr) => {
+            if (newIndex === i) {
+                return {
+                    ...settings,
+                    pinned: settings.pinned
+                        ? arr[i - 1]?.pinned ?? true
+                        : arr[i + 1]?.pinned ?? false,
+                    enabled: settings.enabled
+                        ? arr[i - 1]?.enabled ?? true
+                        : arr[i + 1]?.enabled ?? false,
+                };
+            }
+            else
+                return settings;
+        });
+        const wasDisabled = !item.enabled;
+        const becameEnabled = updated[newIndex].enabled;
+        if (wasDisabled && becameEnabled) {
+            const enabledCount = allColumns.filter(c => c.enabled).length;
+            if (enabledCount >= RivTable.ColumnsMaxShown) {
+                // Refuse the move; keep state as-is
+                return state;
+            }
+        }
+        return {
+            ...state,
+            display: {
+                ...state.display,
+                columnSettings: orderIntentionally(updated, columnNameMap),
+            },
+        };
+    }
+    TableColumnHelpers.changeColumnOrder = changeColumnOrder;
+    function changeColumnEnabled(state, columns, columnNameMap, column, enabled) {
+        const allColumns = getAllColumns(state, columns, columnNameMap);
+        if (enabled &&
+            allColumns.filter(col => col.enabled).length >= RivTable.ColumnsMaxShown) {
+            return state;
+        }
+        return {
+            ...state,
+            display: {
+                ...state.display,
+                columnSettings: orderIntentionally(allColumns.map(c => ({
+                    ...c,
+                    enabled: c.key === column ? enabled : c.enabled,
+                    // Unpin if being unchecked
+                    pinned: c.key === column && !enabled ? false : c.pinned,
+                })), columnNameMap),
+            },
+        };
+    }
+    TableColumnHelpers.changeColumnEnabled = changeColumnEnabled;
+    function enableAllColumns(state, columns, columnNameMap, enabled) {
+        const allColumns = getAllColumns(state, columns, columnNameMap);
+        if (enabled && allColumns.length > RivTable.ColumnsMaxShown)
+            return state;
+        return {
+            ...state,
+            display: {
+                ...state.display,
+                columnSettings: orderIntentionally(allColumns.map(c => ({
+                    ...c,
+                    enabled: enabled,
+                    // Unpin if being unchecked
+                    pinned: !enabled ? false : c.pinned,
+                })), columnNameMap),
+            },
+        };
+    }
+    TableColumnHelpers.enableAllColumns = enableAllColumns;
+    function changeColumnWidth(state, columns, columnNameMap, column, preferredWidth) {
+        const allColumns = getAllColumns(state, columns, columnNameMap);
+        return {
+            ...state,
+            display: {
+                ...state.display,
+                columnSettings: allColumns.map(c => ({
+                    ...c,
+                    preferredWidth: c.key === column ? preferredWidth : c.preferredWidth,
+                })),
+            },
+        };
+    }
+    TableColumnHelpers.changeColumnWidth = changeColumnWidth;
+    function resetToDefaultColumns(state, columns, columnNameMap, defaultColumnState) {
+        return {
+            ...state,
+            display: {
+                ...state.display,
+                columnSettings: orderIntentionally(defaultColumnState, columnNameMap),
+            },
+        };
+    }
+    TableColumnHelpers.resetToDefaultColumns = resetToDefaultColumns;
+})(TableColumnHelpers || (TableColumnHelpers = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"column-helpers.js","sourceRoot":"","sources":["../../../../../../../projects/riv/src/lib/table/table/state-helpers/column-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { difference } from 'lodash';\nimport { RivTable } from '../state';\n\nexport namespace TableColumnHelpers {\n  export function getColumnAlignment(\n    dataType: RivTable.ColumnDataType,\n    isFirst: boolean,\n  ): RivTable.ColumnAlignment {\n    if (isFirst) return 'left';\n    switch (dataType) {\n      case 'date':\n      case 'longText':\n        return 'left';\n      case 'advanced':\n      case 'icon':\n      case 'shortText':\n        return 'center';\n      case 'currency':\n      case 'number':\n        return 'right';\n    }\n  }\n\n  export function getAllColumns<\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    supportedColumns: Map<C, RivTable.ColumnMetadata>,\n    columnNameMap: RivTable.ColumnNameMap<C>,\n  ): RivTable.ColumnSettings<C>[] {\n    // If the table offers more columns than the user has configuration settings\n    // for (or if the user has no configuration settings yet), we'll append them\n    // to the end (unless they should be pinned by default, in which case we'll\n    // append them after the other pinned columns). This ensures that new columns\n    // we add to existing tables over time (1) get displayed even though they\n    // don't appear in the user's configuration settings yet, and (2) don't\n    // interrupt their existing setup.\n    const columnNamesWithoutUserSettings = difference(\n      [...supportedColumns.keys()],\n      state.display.columnSettings.map(({ key }) => key),\n    );\n\n    // Throw out settings for columns no longer offered by the table.\n    const columnsWithUserSettings: RivTable.ColumnSettings<C>[] =\n      state.display.columnSettings.filter(({ key }) =>\n        supportedColumns.has(key),\n      );\n\n    const columnsWithoutUserSettings: RivTable.ColumnSettings<C>[] = [\n      ...columnNamesWithoutUserSettings,\n    ].map((key: C) => ({\n      key,\n      enabled: true,\n      preferredWidth: 'auto',\n      pinned: !!supportedColumns.get(key)?.defaultPinned,\n    }));\n\n    return orderIntentionally(\n      [...columnsWithUserSettings, ...columnsWithoutUserSettings],\n      columnNameMap,\n    );\n  }\n\n  function orderIntentionally<C extends RivTable.Column>(\n    columns: RivTable.ColumnSettings<C>[],\n    columnNameMap: RivTable.ColumnNameMap<C>,\n  ): RivTable.ColumnSettings<C>[] {\n    return [\n      ...columns.filter(v => v.pinned),\n      ...columns.filter(v => v.enabled && !v.pinned),\n      ...columns\n        .filter(v => !v.enabled && !v.pinned)\n        .sort((a, b) => {\n          const aName = columnNameMap.get(a.key) ?? a.key;\n          const bName = columnNameMap.get(b.key) ?? b.key;\n          return aName.localeCompare(bName);\n        }),\n    ];\n  }\n\n  function getAlignment(\n    metadata: RivTable.ColumnMetadata,\n    index: number,\n    allowSelection?: boolean,\n  ): RivTable.ColumnAlignment {\n    return getColumnAlignment(\n      metadata.dataType,\n      index === 0 && !allowSelection,\n    );\n  }\n\n  export function resolveColumns<\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    supportedColumns: Map<C, RivTable.ColumnMetadata>,\n    columnNameMap: RivTable.ColumnNameMap<C>,\n    allowSelection: boolean | undefined,\n  ): RivTable.FullColumn<C>[] {\n    const allColumns = getAllColumns(state, supportedColumns, columnNameMap);\n    return allColumns\n      .filter(({ enabled }) => enabled)\n      .reduce(\n        (\n          fullColumns: RivTable.FullColumn<C>[],\n          settings: RivTable.ColumnSettings<C>,\n          i: number,\n        ): RivTable.FullColumn<C>[] => {\n          const metadata = supportedColumns.get(settings.key)!;\n          const resolvedWidth =\n            settings.preferredWidth === 'auto'\n              ? metadata.minWidth\n              : Math.max(metadata.minWidth, settings.preferredWidth);\n          const previousColumn: RivTable.FullColumn<C> | undefined =\n            fullColumns[i - 1];\n          return [\n            ...fullColumns,\n            {\n              ...settings,\n              ...metadata,\n              width: resolvedWidth,\n              left: settings.pinned\n                ? previousColumn\n                  ? (previousColumn.left || 0) + previousColumn.width\n                  : !!allowSelection\n                  ? 40\n                  : 0\n                : null,\n              alignment: getAlignment(metadata, i, !!allowSelection),\n            },\n          ];\n        },\n        [],\n      );\n  }\n\n  export function changeColumnPin<\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    columns: Map<C, RivTable.ColumnMetadata>,\n    columnNameMap: RivTable.ColumnNameMap<C>,\n    column: C,\n    pinned: boolean,\n  ): RivTable.CoreState<R, C, F, G> {\n    const allColumns = getAllColumns(state, columns, columnNameMap);\n\n    if (pinned) {\n      const target = allColumns.find(c => c.key === column);\n      const wasEnabled = !!target?.enabled;\n      if (!wasEnabled) {\n        const enabledCount = allColumns.filter(col => col.enabled).length;\n        if (enabledCount >= RivTable.ColumnsMaxShown) {\n          return state; // refuse the pin since it would exceed the max\n        }\n      }\n    }\n\n    return {\n      ...state,\n      display: {\n        ...state.display,\n        columnSettings: orderIntentionally(\n          allColumns.map(c => ({\n            ...c,\n            pinned: c.key === column ? pinned : c.pinned,\n            // Check/enable if being pinned\n            enabled: c.key === column && pinned ? true : c.enabled,\n          })),\n          columnNameMap,\n        ),\n      },\n    };\n  }\n\n  export function changeColumnsFreezeState<\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    columns: Map<C, RivTable.ColumnMetadata>,\n    columnNameMap: RivTable.ColumnNameMap<C>,\n    index: number,\n    freeze: boolean,\n  ): RivTable.CoreState<R, C, F, G> {\n    const allColumns = getAllColumns(state, columns, columnNameMap);\n\n    return {\n      ...state,\n      display: {\n        ...state.display,\n        columnSettings: allColumns.map((c, i) => {\n          return { ...c, pinned: freeze && i <= index };\n        }),\n      },\n    };\n  }\n\n  export function moveColumnTo<\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    columns: Map<C, RivTable.ColumnMetadata>,\n    columnNameMap: RivTable.ColumnNameMap<C>,\n    column: C,\n    position: 'start' | 'end',\n  ): RivTable.CoreState<R, C, F, G> {\n    const allColumns = getAllColumns(state, columns, columnNameMap);\n    const previousIndex = allColumns.findIndex(c => c.key === column);\n    const lastIndex =\n      position == 'end' ? allColumns.findIndex(c => !c.enabled) : 0;\n    const newIndex =\n      position == 'start'\n        ? 0\n        : lastIndex == -1\n        ? allColumns.length - 1\n        : lastIndex;\n\n    if (\n      !allColumns[previousIndex].enabled &&\n      allColumns.filter(col => col.enabled).length >= RivTable.ColumnsMaxShown\n    )\n      return state;\n\n    const movedState = changeColumnOrder(\n      state,\n      columns,\n      columnNameMap,\n      previousIndex,\n      newIndex,\n    );\n    //Make sure the column is enabled\n    return changeColumnEnabled(\n      movedState,\n      columns,\n      columnNameMap,\n      column,\n      true,\n    );\n  }\n\n  export function changeColumnOrder<\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    columns: Map<C, RivTable.ColumnMetadata>,\n    columnNameMap: RivTable.ColumnNameMap<C>,\n    previousIndex: number,\n    newIndex: number,\n  ): RivTable.CoreState<R, C, F, G> {\n    const allColumns = getAllColumns(state, columns, columnNameMap);\n\n    // First, put the columns in the desired order.\n    const item = allColumns[previousIndex];\n    const withoutItem = allColumns.filter((_, i) => i !== previousIndex);\n    const reordered = [\n      ...withoutItem.slice(0, newIndex),\n      item,\n      ...withoutItem.slice(newIndex),\n    ];\n\n    // Then, we may need to fix the pins (all pinned columns appear at the\n    // beginning of the columns array) since the user is allowed to drag\n    // and drop columns to and from the pinned area. If the user drags a\n    // column across that threshold, update its pinned status.\n    const updated = reordered.map((settings, i, arr) => {\n      if (newIndex === i) {\n        return {\n          ...settings,\n          pinned: settings.pinned\n            ? arr[i - 1]?.pinned ?? true\n            : arr[i + 1]?.pinned ?? false,\n          enabled: settings.enabled\n            ? arr[i - 1]?.enabled ?? true\n            : arr[i + 1]?.enabled ?? false,\n        };\n      } else return settings;\n    });\n\n    const wasDisabled = !item.enabled;\n    const becameEnabled = updated[newIndex].enabled;\n    if (wasDisabled && becameEnabled) {\n      const enabledCount = allColumns.filter(c => c.enabled).length;\n      if (enabledCount >= RivTable.ColumnsMaxShown) {\n        // Refuse the move; keep state as-is\n        return state;\n      }\n    }\n\n    return {\n      ...state,\n      display: {\n        ...state.display,\n        columnSettings: orderIntentionally(updated, columnNameMap),\n      },\n    };\n  }\n\n  export function changeColumnEnabled<\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    columns: Map<C, RivTable.ColumnMetadata>,\n    columnNameMap: RivTable.ColumnNameMap<C>,\n    column: C,\n    enabled: boolean,\n  ): RivTable.CoreState<R, C, F, G> {\n    const allColumns = getAllColumns(state, columns, columnNameMap);\n    if (\n      enabled &&\n      allColumns.filter(col => col.enabled).length >= RivTable.ColumnsMaxShown\n    ) {\n      return state;\n    }\n\n    return {\n      ...state,\n      display: {\n        ...state.display,\n        columnSettings: orderIntentionally(\n          allColumns.map(c => ({\n            ...c,\n            enabled: c.key === column ? enabled : c.enabled,\n            // Unpin if being unchecked\n            pinned: c.key === column && !enabled ? false : c.pinned,\n          })),\n          columnNameMap,\n        ),\n      },\n    };\n  }\n\n  export function enableAllColumns<\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    columns: Map<C, RivTable.ColumnMetadata>,\n    columnNameMap: RivTable.ColumnNameMap<C>,\n    enabled: boolean,\n  ): RivTable.CoreState<R, C, F, G> {\n    const allColumns = getAllColumns(state, columns, columnNameMap);\n    if (enabled && allColumns.length > RivTable.ColumnsMaxShown) return state;\n\n    return {\n      ...state,\n      display: {\n        ...state.display,\n        columnSettings: orderIntentionally(\n          allColumns.map(c => ({\n            ...c,\n            enabled: enabled,\n            // Unpin if being unchecked\n            pinned: !enabled ? false : c.pinned,\n          })),\n          columnNameMap,\n        ),\n      },\n    };\n  }\n\n  export function changeColumnWidth<\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    columns: Map<C, RivTable.ColumnMetadata>,\n    columnNameMap: RivTable.ColumnNameMap<C>,\n    column: C,\n    preferredWidth: RivTable.ColumnSettings<C>['preferredWidth'],\n  ): RivTable.CoreState<R, C, F, G> {\n    const allColumns = getAllColumns(state, columns, columnNameMap);\n    return {\n      ...state,\n      display: {\n        ...state.display,\n        columnSettings: allColumns.map(c => ({\n          ...c,\n          preferredWidth: c.key === column ? preferredWidth : c.preferredWidth,\n        })),\n      },\n    };\n  }\n\n  export function resetToDefaultColumns<\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    columns: Map<C, RivTable.ColumnMetadata>,\n    columnNameMap: RivTable.ColumnNameMap<C>,\n    defaultColumnState: RivTable.ColumnSettings<C>[],\n  ): RivTable.CoreState<R, C, F, G> {\n    return {\n      ...state,\n      display: {\n        ...state.display,\n        columnSettings: orderIntentionally(defaultColumnState, columnNameMap),\n      },\n    };\n  }\n}\n"]}

package/esm2020/lib/table/table/state-helpers/display-helpers.mjs

@@ -0,0 +1,48 @@
+import { toInteger } from 'lodash';
+import { TableResultHelpers } from './result-helpers';
+import { TableSearchHelpers } from './search-helpers';
+export var TableDisplayHelpers;
+(function (TableDisplayHelpers) {
+    function getZeroStateMessage(state, entity) {
+        if ((TableResultHelpers.isGroupResult(state.result) &&
+            state.result.totalGroupCount > 0) ||
+            (!TableResultHelpers.isGroupResult(state.result) &&
+                state.result.totalMatchingRowCount > 0))
+            return null;
+        const allSearchColumnsSelected = TableSearchHelpers.getSearchColumnsSelectedState(state, 'all');
+        if (state.query.search && allSearchColumnsSelected)
+            return `No ${entity} match your current search keyword.`;
+        if (state.query.search && !allSearchColumnsSelected)
+            return `No ${entity} match your current search keyword in the selected search columns.`;
+        if (state.query.filters)
+            return `No ${entity} match your current filters.`;
+        return `No ${entity}.`;
+    }
+    TableDisplayHelpers.getZeroStateMessage = getZeroStateMessage;
+    function memoizedCellRowSpan(s, fullColumns, options) {
+        const getRowSpanForCell = options?.getRowSpanForCell;
+        const result = s.result;
+        // If the dataset exceeds the current page size, skip span calculations.
+        if (s.result.totalMatchingRowCount > s.query.pagination.pageSize)
+            return null;
+        // If the user hasn't provided the row span configuration, default to no spanning
+        if (!getRowSpanForCell)
+            return null;
+        // Row spanning is not supported on grouped tables.
+        if (TableResultHelpers.isGroupResult(result))
+            return null;
+        // Memoize the user's configuration for the current page.
+        return new Map(fullColumns.map(column => [
+            column.key,
+            result.currentPageData.map((_, i) => {
+                const raw = getRowSpanForCell(i, column.key);
+                if (raw === 0)
+                    return 0;
+                else
+                    return Math.max(1, toInteger(raw));
+            }),
+        ]));
+    }
+    TableDisplayHelpers.memoizedCellRowSpan = memoizedCellRowSpan;
+})(TableDisplayHelpers || (TableDisplayHelpers = {}));
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,143 @@
+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;
+})(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 { 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"]}