@rivet-health/design-system 40.27.2 → 40.28.0

package/fesm2020/rivet-health-design-system.mjs

@@ -5,7 +5,7 @@ import { DOCUMENT, DatePipe as DatePipe$1, DecimalPipe, CurrencyPipe, PercentPip
 import { BehaviorSubject, Subject, merge, scan, startWith, connectable, map, ReplaySubject, distinctUntilChanged, skip, filter, combineLatest, shareReplay, skipUntil, mergeScan, from, share, fromEvent, tap, switchMap, takeUntil, concatWith, of } from 'rxjs';
 import { timeYears, timeYear, timeMonths, timeMonth, timeDays, timeDay, timeSunday, timeWeek, utcYear, utcMonth, utcWeek, utcDay } from 'd3-time';
 import { timeFormat, utcFormat } from 'd3-time-format';
-import { defaultsDeep, sortBy, isNumber, flattenDeep, debounce, isEqual, uniqueId, cloneDeep, orderBy, range, toInteger, difference, union, sumBy, sum, uniq } from 'lodash';
+import { defaultsDeep, sortBy, isNumber, flattenDeep, debounce, isEqual, uniqueId, cloneDeep, difference, toInteger, orderBy, range, union, sumBy, sum, uniq } from 'lodash';
 import Fuse from 'fuse.js';
 import { query, style, animate, trigger, transition, group } from '@angular/animations';
 import { map as map$1, distinctUntilChanged as distinctUntilChanged$1 } from 'rxjs/operators';
@@ -8263,6 +8263,900 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                 args: ['class.selected']
             }] } });
 
+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 = {}));
+
+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 ('currentPageNestedRows' in result) {
+            return true;
+        }
+        return false;
+    }
+    TableResultHelpers.isNestedResult = isNestedResult;
+    function isNestedWithHeaderResult(result) {
+        if ('currentPageNestedHeaders' in result) {
+            return true;
+        }
+        return false;
+    }
+    TableResultHelpers.isNestedWithHeaderResult = isNestedWithHeaderResult;
+    function getAllRowsFromResult(result) {
+        if (isGroupResult(result)) {
+            return result.groupResults.flatMap(groups => groups.currentPageData);
+        }
+        else if (isNestedResult(result)) {
+            return getAllRowsFromNestedRows(result.currentPageNestedRows);
+        }
+        else if (isNestedWithHeaderResult(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;
+    }
+    TableResultHelpers.getAllRowsFromNestedRows = getAllRowsFromNestedRows;
+    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 = {}));
+
+var TableSearchHelpers;
+(function (TableSearchHelpers) {
+    function getSearchColumnsSelectedState(state, expectedValue) {
+        switch (expectedValue) {
+            case 'all':
+                return Array.from(state.query.searchColumns.values()).every(value => value);
+            case 'none':
+                return Array.from(state.query.searchColumns.values()).every(value => !value);
+        }
+    }
+    TableSearchHelpers.getSearchColumnsSelectedState = getSearchColumnsSelectedState;
+    function toggleAllSearchColumns(state) {
+        const noneSelected = getSearchColumnsSelectedState(state, 'none');
+        const payload = new Map(Array.from(state.query.searchColumns.keys()).map(key => [
+            key,
+            noneSelected,
+        ]));
+        return {
+            ...state,
+            query: {
+                ...state.query,
+                searchColumns: payload,
+            },
+        };
+    }
+    TableSearchHelpers.toggleAllSearchColumns = toggleAllSearchColumns;
+})(TableSearchHelpers || (TableSearchHelpers = {}));
+
+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 = {}));
+
+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 = {}));
+
+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
+    function paginateNestedRows(allNestedRows, pageNumber, pageSize) {
+        const startIdx = pageSize * pageNumber;
+        const endIdx = startIdx + pageSize;
+        let bottomLevelRowCount = 0;
+        function recursivePaginateRows(currentNestedRow) {
+            // If there are no subrows, stop recursing
+            if (!currentNestedRow.subRows) {
+                bottomLevelRowCount++;
+                // Since we add 1 first, the bounds should be (startIdx, endIdx]
+                if (bottomLevelRowCount > startIdx && bottomLevelRowCount <= endIdx) {
+                    return currentNestedRow;
+                }
+                return null;
+            }
+            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 paginatedRows = [];
+        for (const nestedRow of allNestedRows) {
+            const recursedRow = recursivePaginateRows(nestedRow);
+            if (recursedRow != null) {
+                paginatedRows.push(recursedRow);
+            }
+        }
+        return paginatedRows;
+    }
+    TablePaginationHelpers.paginateNestedRows = paginateNestedRows;
+    // Paginate based on bottom level rows, splitting as necessary to fit within the page
+    function paginateNestedHeaderRows(allHeaders, pageNumber, pageSize) {
+        const startIdx = pageSize * pageNumber;
+        const endIdx = startIdx + pageSize;
+        let bottomLevelRowCount = 0;
+        function recursivePaginateRows(currentNestedRow) {
+            // If there are no subrows, stop recursing
+            if (!currentNestedRow.subRows) {
+                bottomLevelRowCount++;
+                // Since we add 1 first, the bounds should be (startIdx, endIdx]
+                if (bottomLevelRowCount > startIdx && bottomLevelRowCount <= endIdx) {
+                    return currentNestedRow;
+                }
+                return null;
+            }
+            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 = 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 = {}));
+
+var TableSelectionHelpers;
+(function (TableSelectionHelpers) {
+    function isRowSelected(state, id) {
+        switch (state.selection.mode) {
+            case 'include':
+                return state.selection.included.has(id);
+            case 'exclude':
+                return !state.selection.excluded.has(id);
+        }
+    }
+    TableSelectionHelpers.isRowSelected = isRowSelected;
+    function isGroupSelected(state, group) {
+        switch (state.selection.mode) {
+            case 'include': {
+                let allFound = true;
+                let anyFound = false;
+                for (const row of group.currentPageData) {
+                    if (!state.selection.included.has(row.id)) {
+                        allFound = false;
+                    }
+                    else {
+                        anyFound = true;
+                    }
+                }
+                return allFound ? true : anyFound ? 'indeterminate' : false;
+            }
+            case 'exclude': {
+                let allFound = true;
+                let anyFound = false;
+                for (const row of group.currentPageData) {
+                    if (state.selection.excluded.has(row.id)) {
+                        allFound = false;
+                    }
+                    else {
+                        anyFound = true;
+                    }
+                }
+                return allFound ? true : anyFound ? 'indeterminate' : false;
+            }
+        }
+    }
+    TableSelectionHelpers.isGroupSelected = isGroupSelected;
+    function isAllSelected(state) {
+        // If there are no rows, "all selected" should be false
+        if (state.result.totalMatchingRowCount === 0) {
+            return false;
+        }
+        if ((state.selection.mode === 'exclude' &&
+            state.selection.excluded.size === 0) ||
+            (state.selection.mode === 'include' &&
+                state.selection.included.size === state.result.totalMatchingRowCount))
+            return true;
+        if ((state.selection.mode === 'exclude' &&
+            state.selection.excluded.size === state.result.totalMatchingRowCount) ||
+            (state.selection.mode === 'include' &&
+                state.selection.included.size === 0))
+            return false;
+        return 'indeterminate';
+    }
+    TableSelectionHelpers.isAllSelected = isAllSelected;
+    function isCurrentPageSelected(state) {
+        const selectedStates = TableResultHelpers.getAllRowsFromResult(state.result).map(({ id }) => isRowSelected(state, id));
+        if (selectedStates.length > 0) {
+            if (selectedStates.every(v => v))
+                return true;
+            if (selectedStates.some(v => v))
+                return 'indeterminate';
+        }
+        return false;
+    }
+    TableSelectionHelpers.isCurrentPageSelected = isCurrentPageSelected;
+    function selectedCount(state) {
+        switch (state.selection.mode) {
+            case 'include':
+                return state.selection.included.size;
+            case 'exclude':
+                return (state.result.totalMatchingRowCount - state.selection.excluded.size);
+        }
+    }
+    TableSelectionHelpers.selectedCount = selectedCount;
+    function setRowSelected(state, id, selected, contiguous) {
+        if (selected) {
+            const newSelection = new Set([id]);
+            if (contiguous && state.selection.mostRecentlySelected) {
+                const startIdx = TableResultHelpers.getAllRowsFromResult(state.result).findIndex(row => row.id === state.selection.mostRecentlySelected);
+                const endIdx = TableResultHelpers.getAllRowsFromResult(state.result).findIndex(row => row.id === id);
+                if (typeof startIdx === 'number' && typeof endIdx === 'number') {
+                    for (let i = Math.min(startIdx, endIdx); i <= Math.max(startIdx, endIdx); i++) {
+                        newSelection.add(TableResultHelpers.getAllRowsFromResult(state.result)[i].id);
+                    }
+                }
+            }
+            return {
+                ...state,
+                selection: {
+                    mostRecentlySelected: id,
+                    ...(state.selection.mode === 'include'
+                        ? {
+                            mode: 'include',
+                            included: new Set(union([...state.selection.included], [...newSelection])),
+                        }
+                        : {
+                            mode: 'exclude',
+                            excluded: new Set(difference([...state.selection.excluded], [...newSelection])),
+                        }),
+                },
+            };
+        }
+        else {
+            return {
+                ...state,
+                selection: {
+                    mostRecentlySelected: null,
+                    ...(state.selection.mode === 'include'
+                        ? {
+                            mode: 'include',
+                            included: new Set(difference([...state.selection.included], [id])),
+                        }
+                        : {
+                            mode: 'exclude',
+                            excluded: new Set(union([...state.selection.excluded], [id])),
+                        }),
+                },
+            };
+        }
+    }
+    TableSelectionHelpers.setRowSelected = setRowSelected;
+    function toggleGroupSelected(state, group) {
+        const isGroupFullySelected = isGroupSelected(state, { ...group, currentPageData: group.rows }) ===
+            true;
+        return group.rows.reduce((accumulatedState, row) => {
+            return setRowSelected(accumulatedState, row.id, !isGroupFullySelected, false);
+        }, state);
+    }
+    TableSelectionHelpers.toggleGroupSelected = toggleGroupSelected;
+    function togglePageSelected(state) {
+        const isPageFullySelected = TableResultHelpers.getAllRowsFromResult(state.result).every(({ id }) => isRowSelected(state, id));
+        return TableResultHelpers.getAllRowsFromResult(state.result).reduce((accumulatedState, row) => {
+            return setRowSelected(accumulatedState, row.id, !isPageFullySelected, false);
+        }, state);
+    }
+    TableSelectionHelpers.togglePageSelected = togglePageSelected;
+    function toggleAllSelected(state) {
+        if (isAllSelected(state) === true) {
+            return {
+                ...state,
+                selection: {
+                    mostRecentlySelected: null,
+                    mode: 'include',
+                    included: new Set(),
+                },
+            };
+        }
+        else {
+            return {
+                ...state,
+                selection: {
+                    mostRecentlySelected: null,
+                    mode: 'exclude',
+                    excluded: new Set(),
+                },
+            };
+        }
+    }
+    TableSelectionHelpers.toggleAllSelected = toggleAllSelected;
+    function clearSelection(state) {
+        return {
+            ...state,
+            selection: {
+                mostRecentlySelected: null,
+                mode: 'include',
+                included: new Set(),
+            },
+        };
+    }
+    TableSelectionHelpers.clearSelection = clearSelection;
+})(TableSelectionHelpers || (TableSelectionHelpers = {}));
+
 var RivTable;
 (function (RivTable) {
     RivTable.pageSizes = [25, 50, 100, 250];
@@ -8334,8 +9228,8 @@ var RivTable;
         const csvExportAllowed = !(options?.getRowSpanForCell || options?.customSummaryRow);
         // Augment state with derived state, and subscribe.
         const state = connectable(coreState.pipe(map(({ state: s }) => {
-            const resolvedColumns = resolveColumns(s, columns, columnNameMap, !!options?.allowSelection);
-            if (isGroupResult(s.result)) {
+            const resolvedColumns = TableColumnHelpers.resolveColumns(s, columns, columnNameMap, !!options?.allowSelection);
+            if (TableResultHelpers.isGroupResult(s.result)) {
                 if (options?.getRowSpanForCell) {
                     // eslint-disable-next-line no-console
                     console.warn('Heads up! Custom row spans are not supported for grouped tables.');
@@ -8350,9 +9244,9 @@ var RivTable;
                         rowLink: options?.rowLink
                             ? options.rowLink(row, group.groupData)
                             : null,
-                        selected: isRowSelected(s, row.id),
+                        selected: TableSelectionHelpers.isRowSelected(s, row.id),
                     })),
-                    selected: isGroupSelected(s, group),
+                    selected: TableSelectionHelpers.isGroupSelected(s, group),
                     totalMatchingRowCount: group.totalMatchingRowCount,
                     groupData: group.groupData,
                 }));
@@ -8369,9 +9263,9 @@ var RivTable;
                             pageSize: s.result.totalMatchingRowCount,
                         },
                     }, { type: 'load' });
-                    if (!isGroupResult(dataSet))
+                    if (!TableResultHelpers.isGroupResult(dataSet))
                         throw new Error('Returned non-grouped CSV data for grouped table');
-                    const fullColumns = resolveColumns(s, columns, columnNameMap, !!options.allowSelection);
+                    const fullColumns = TableColumnHelpers.resolveColumns(s, columns, columnNameMap, !!options.allowSelection);
                     const data = [];
                     data.push(fullColumns.map(({ key }) => columnNameMap.get(key) ?? key));
                     if (groupCellFormatter) {
@@ -8382,7 +9276,8 @@ var RivTable;
                         group: groups.groupData,
                     })))) {
                         const record = rowItem.row;
-                        if (mode === 'selection' && !isRowSelected(s, record.id))
+                        if (mode === 'selection' &&
+                            !TableSelectionHelpers.isRowSelected(s, record.id))
                             continue;
                         const row = [];
                         for (const column of fullColumns) {
@@ -8401,23 +9296,23 @@ var RivTable;
                         ...s.query,
                         pagination: {
                             ...s.query.pagination,
-                            previous: getPreviousPage(s),
-                            pages: getPages(s),
-                            next: getNextPage(s),
-                            pageCount: getPageCount(s),
-                            showControls: getShowPaginationControls(s),
-                            pageRowStart: getPageRowStart(s),
-                            pageRowEnd: getPageRowEnd(s),
+                            previous: TablePaginationHelpers.getPreviousPage(s),
+                            pages: TablePaginationHelpers.getPages(s),
+                            next: TablePaginationHelpers.getNextPage(s),
+                            pageCount: TablePaginationHelpers.getPageCount(s),
+                            showControls: TablePaginationHelpers.getShowPaginationControls(s),
+                            pageRowStart: TablePaginationHelpers.getPageRowStart(s),
+                            pageRowEnd: TablePaginationHelpers.getPageRowEnd(s),
                         },
-                        noSearchColumnsSelected: getSearchColumnsSelectedState(s, 'none'),
+                        noSearchColumnsSelected: TableSearchHelpers.getSearchColumnsSelectedState(s, 'none'),
                     },
                     display: {
                         ...s.display,
                         columns: resolvedColumns,
-                        allColumns: getAllColumns(s, columns, columnNameMap),
+                        allColumns: TableColumnHelpers.getAllColumns(s, columns, columnNameMap),
                         columnNameMap: columnNameMap,
                         searchableColumnMap: searchableColumnMap,
-                        zeroStateMessage: getZeroStateMessage(s, pluralEntityName),
+                        zeroStateMessage: TableDisplayHelpers.getZeroStateMessage(s, pluralEntityName),
                         columnsAreFreezable: !!options?.columnsAreFreezable,
                         columnsAreHideable: !!options?.columnsAreHideable,
                         columnsAreReorderable: options?.columnsAreReorderable ?? true,
@@ -8432,9 +9327,9 @@ var RivTable;
                     selection: {
                         ...s.selection,
                         allowSelection: options?.allowSelection ?? false,
-                        isAllSelected: isAllSelected(s),
-                        isCurrentPageSelected: isCurrentPageSelected(s),
-                        selectedCount: selectedCount(s),
+                        isAllSelected: TableSelectionHelpers.isAllSelected(s),
+                        isCurrentPageSelected: TableSelectionHelpers.isCurrentPageSelected(s),
+                        selectedCount: TableSelectionHelpers.selectedCount(s),
                     },
                     result: {
                         ...s.result,
@@ -8442,7 +9337,7 @@ var RivTable;
                         rowGroups,
                         rows: rowGroups.flatMap(group => group.rows),
                         csvData,
-                        csvFilename: getCsvFilename(pluralEntityName, options),
+                        csvFilename: TableResultHelpers.getCsvFilename(pluralEntityName, options),
                     },
                 };
             }
@@ -8450,9 +9345,9 @@ var RivTable;
                 const rows = s.result.currentPageData.map(row => ({
                     ...row,
                     rowLink: options?.rowLink ? options.rowLink(row) : null,
-                    selected: isRowSelected(s, row.id),
+                    selected: TableSelectionHelpers.isRowSelected(s, row.id),
                 }));
-                const cellRowSpanCache = memoizedCellRowSpan(s, resolvedColumns, options);
+                const cellRowSpanCache = TableDisplayHelpers.memoizedCellRowSpan(s, resolvedColumns, options);
                 const cellRowSpan = (rowIndex, column) => cellRowSpanCache?.get(column)?.[rowIndex] ?? 1;
                 const hasAnyRowSpans = cellRowSpanCache
                     ? [...cellRowSpanCache.values()].some(spans => spans.some(span => span > 1))
@@ -8473,13 +9368,14 @@ var RivTable;
                             pageSize: s.result.totalMatchingRowCount,
                         },
                     }, { type: 'load' });
-                    if (isGroupResult(dataSet))
+                    if (TableResultHelpers.isGroupResult(dataSet))
                         throw new Error('Returned grouped CSV data for non-grouped table');
-                    const fullColumns = resolveColumns(s, columns, columnNameMap, !!options.allowSelection);
+                    const fullColumns = TableColumnHelpers.resolveColumns(s, columns, columnNameMap, !!options.allowSelection);
                     const data = [];
                     data.push(fullColumns.map(({ key }) => columnNameMap.get(key) ?? key));
                     for (const record of dataSet.currentPageData) {
-                        if (mode === 'selection' && !isRowSelected(s, record.id))
+                        if (mode === 'selection' &&
+                            !TableSelectionHelpers.isRowSelected(s, record.id))
                             continue;
                         const row = [];
                         for (const column of fullColumns) {
@@ -8496,23 +9392,23 @@ var RivTable;
                         order: hasAnyRowSpans ? null : s.query.order,
                         pagination: {
                             ...s.query.pagination,
-                            previous: getPreviousPage(s),
-                            pages: getPages(s),
-                            next: getNextPage(s),
-                            pageCount: getPageCount(s),
-                            showControls: getShowPaginationControls(s),
-                            pageRowStart: getPageRowStart(s),
-                            pageRowEnd: getPageRowEnd(s),
+                            previous: TablePaginationHelpers.getPreviousPage(s),
+                            pages: TablePaginationHelpers.getPages(s),
+                            next: TablePaginationHelpers.getNextPage(s),
+                            pageCount: TablePaginationHelpers.getPageCount(s),
+                            showControls: TablePaginationHelpers.getShowPaginationControls(s),
+                            pageRowStart: TablePaginationHelpers.getPageRowStart(s),
+                            pageRowEnd: TablePaginationHelpers.getPageRowEnd(s),
                         },
-                        noSearchColumnsSelected: getSearchColumnsSelectedState(s, 'none'),
+                        noSearchColumnsSelected: TableSearchHelpers.getSearchColumnsSelectedState(s, 'none'),
                     },
                     display: {
                         ...s.display,
                         columns: resolvedColumns.map(column => hasAnyRowSpans ? { ...column, orderable: false } : column),
-                        allColumns: getAllColumns(s, columns, columnNameMap),
+                        allColumns: TableColumnHelpers.getAllColumns(s, columns, columnNameMap),
                         columnNameMap: columnNameMap,
                         searchableColumnMap: searchableColumnMap,
-                        zeroStateMessage: getZeroStateMessage(s, pluralEntityName),
+                        zeroStateMessage: TableDisplayHelpers.getZeroStateMessage(s, pluralEntityName),
                         columnsAreFreezable: !!options?.columnsAreFreezable,
                         columnsAreHideable: !!options?.columnsAreHideable,
                         columnsAreReorderable: options?.columnsAreReorderable ?? true,
@@ -8534,9 +9430,9 @@ var RivTable;
                     selection: {
                         ...s.selection,
                         allowSelection: options?.allowSelection ?? false,
-                        isAllSelected: isAllSelected(s),
-                        isCurrentPageSelected: isCurrentPageSelected(s),
-                        selectedCount: selectedCount(s),
+                        isAllSelected: TableSelectionHelpers.isAllSelected(s),
+                        isCurrentPageSelected: TableSelectionHelpers.isCurrentPageSelected(s),
+                        selectedCount: TableSelectionHelpers.selectedCount(s),
                     },
                     result: {
                         ...s.result,
@@ -8548,7 +9444,7 @@ var RivTable;
                             totalMatchingRowCount: rows.length,
                             groupData: { key: '' },
                         },
-                        csvFilename: getCsvFilename(pluralEntityName, options),
+                        csvFilename: TableResultHelpers.getCsvFilename(pluralEntityName, options),
                         csvData,
                     },
                 };
@@ -8568,9 +9464,6 @@ var RivTable;
         return { actions, state, effects };
     }
     RivTable.createManager = createManager;
-    function orderEmptyLast(rows, key, direction) {
-        return orderBy(rows, [row => row[key] == null, key], ['asc', direction]);
-    }
     function createInMemoryManager(fetchDataset, columns, pluralEntityName, options) {
         let data;
         let fuse;
@@ -8630,14 +9523,14 @@ var RivTable;
                 const matches = fuse.search(query.search).map(result => result.item);
                 ordered =
                     hasExplicitSort && query.order
-                        ? orderEmptyLast(matches, orderColumn, query.order.direction)
+                        ? TableOrderHelpers.orderEmptyLast(matches, orderColumn, query.order.direction)
                         : matches;
             }
             else if (hasExplicitSort && query.order) {
-                ordered = orderEmptyLast(data, orderColumn, query.order.direction);
+                ordered = TableOrderHelpers.orderEmptyLast(data, orderColumn, query.order.direction);
             }
             else if (query.order == null && defaultSortSpec) {
-                ordered = orderEmptyLast(data, defaultSortSpec.key, defaultSortSpec.direction);
+                ordered = TableOrderHelpers.orderEmptyLast(data, defaultSortSpec.key, defaultSortSpec.direction);
             }
             else {
                 ordered = data;
@@ -8687,26 +9580,6 @@ var RivTable;
         return createManager(source, columnMetadata, pluralEntityName, options);
     }
     RivTable.createInMemoryManager = createInMemoryManager;
-    ///////////////
-    // Utilities //
-    ///////////////
-    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';
-        }
-    }
-    RivTable.getColumnAlignment = getColumnAlignment;
 })(RivTable || (RivTable = {}));
 /**
  * This function keeps the state object references as stable as possible, which
@@ -8744,384 +9617,6 @@ function stableState(target, source) {
     }
     return target;
 }
-function getPageCount(state) {
-    if (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);
-}
-function getPreviousPage(state) {
-    return state.query.pagination.page === 0
-        ? null
-        : state.query.pagination.page - 1;
-}
-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);
-}
-function getNextPage(state) {
-    const max = getPageCount(state) - 1;
-    const next = state.query.pagination.page + 1;
-    return next <= max ? next : null;
-}
-// 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 (isGroupResult(state.result)) {
-        return state.result.totalGroupCount > state.query.grouping.groupsPerPage;
-    }
-    return (state.result.totalMatchingRowCount > Math.min(...[...RivTable.pageSizes]));
-}
-function getPageRowStart(state) {
-    return state.query.pagination.page * state.query.pagination.pageSize + 1;
-}
-function getPageRowEnd(state) {
-    return Math.min((state.query.pagination.page + 1) * state.query.pagination.pageSize, state.result.totalMatchingRowCount);
-}
-function getCsvFilename(pluralEntityName, options) {
-    return (options?.csvFileBasename?.slice(0, 200) ?? pluralEntityName) + '.csv';
-}
-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 (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));
-        }),
-    ]));
-}
-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);
-}
-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 RivTable.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),
-            },
-        ];
-    }, []);
-}
-function getZeroStateMessage(state, entity) {
-    if ((isGroupResult(state.result) && state.result.totalGroupCount > 0) ||
-        (!isGroupResult(state.result) && state.result.totalMatchingRowCount > 0))
-        return null;
-    const allSearchColumnsSelected = 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}.`;
-}
-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),
-        },
-    };
-}
-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 };
-            }),
-        },
-    };
-}
-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);
-}
-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),
-        },
-    };
-}
-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),
-        },
-    };
-}
-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),
-        },
-    };
-}
-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,
-            })),
-        },
-    };
-}
-function resetToDefaultColumns(state, columns, columnNameMap, defaultColumnState) {
-    return {
-        ...state,
-        display: {
-            ...state.display,
-            columnSettings: orderIntentionally(defaultColumnState, columnNameMap),
-        },
-    };
-}
-function isRowSelected(state, id) {
-    switch (state.selection.mode) {
-        case 'include':
-            return state.selection.included.has(id);
-        case 'exclude':
-            return !state.selection.excluded.has(id);
-    }
-}
-function isGroupSelected(state, group) {
-    switch (state.selection.mode) {
-        case 'include': {
-            let allFound = true;
-            let anyFound = false;
-            for (const row of group.currentPageData) {
-                if (!state.selection.included.has(row.id)) {
-                    allFound = false;
-                }
-                else {
-                    anyFound = true;
-                }
-            }
-            return allFound ? true : anyFound ? 'indeterminate' : false;
-        }
-        case 'exclude': {
-            let allFound = true;
-            let anyFound = false;
-            for (const row of group.currentPageData) {
-                if (state.selection.excluded.has(row.id)) {
-                    allFound = false;
-                }
-                else {
-                    anyFound = true;
-                }
-            }
-            return allFound ? true : anyFound ? 'indeterminate' : false;
-        }
-    }
-}
-function isAllSelected(state) {
-    // If there are no rows, "all selected" should be false
-    if (state.result.totalMatchingRowCount === 0) {
-        return false;
-    }
-    if ((state.selection.mode === 'exclude' &&
-        state.selection.excluded.size === 0) ||
-        (state.selection.mode === 'include' &&
-            state.selection.included.size === state.result.totalMatchingRowCount))
-        return true;
-    if ((state.selection.mode === 'exclude' &&
-        state.selection.excluded.size === state.result.totalMatchingRowCount) ||
-        (state.selection.mode === 'include' && state.selection.included.size === 0))
-        return false;
-    return 'indeterminate';
-}
-function isCurrentPageSelected(state) {
-    const selectedStates = getAllRowsFromResult(state.result).map(({ id }) => isRowSelected(state, id));
-    if (selectedStates.length > 0) {
-        if (selectedStates.every(v => v))
-            return true;
-        if (selectedStates.some(v => v))
-            return 'indeterminate';
-    }
-    return false;
-}
-function selectedCount(state) {
-    switch (state.selection.mode) {
-        case 'include':
-            return state.selection.included.size;
-        case 'exclude':
-            return state.result.totalMatchingRowCount - state.selection.excluded.size;
-    }
-}
 async function* refreshResultWith(state, source, mostRecentAction) {
     yield {
         state: {
@@ -9135,7 +9630,7 @@ async function* refreshResultWith(state, source, mostRecentAction) {
     };
     try {
         const result = await source(state.query, mostRecentAction);
-        if (isPageOutOfBounds(state, result)) {
+        if (TablePaginationHelpers.isPageOutOfBounds(state, result)) {
             state.query.pagination.page = 0;
         }
         yield {
@@ -9165,144 +9660,6 @@ async function* refreshResultWith(state, source, mostRecentAction) {
         };
     }
 }
-function setRowSelected(state, id, selected, contiguous) {
-    if (selected) {
-        const newSelection = new Set([id]);
-        if (contiguous && state.selection.mostRecentlySelected) {
-            const startIdx = getAllRowsFromResult(state.result).findIndex(row => row.id === state.selection.mostRecentlySelected);
-            const endIdx = getAllRowsFromResult(state.result).findIndex(row => row.id === id);
-            if (typeof startIdx === 'number' && typeof endIdx === 'number') {
-                for (let i = Math.min(startIdx, endIdx); i <= Math.max(startIdx, endIdx); i++) {
-                    newSelection.add(getAllRowsFromResult(state.result)[i].id);
-                }
-            }
-        }
-        return {
-            ...state,
-            selection: {
-                mostRecentlySelected: id,
-                ...(state.selection.mode === 'include'
-                    ? {
-                        mode: 'include',
-                        included: new Set(union([...state.selection.included], [...newSelection])),
-                    }
-                    : {
-                        mode: 'exclude',
-                        excluded: new Set(difference([...state.selection.excluded], [...newSelection])),
-                    }),
-            },
-        };
-    }
-    else {
-        return {
-            ...state,
-            selection: {
-                mostRecentlySelected: null,
-                ...(state.selection.mode === 'include'
-                    ? {
-                        mode: 'include',
-                        included: new Set(difference([...state.selection.included], [id])),
-                    }
-                    : {
-                        mode: 'exclude',
-                        excluded: new Set(union([...state.selection.excluded], [id])),
-                    }),
-            },
-        };
-    }
-}
-function toggleGroupSelected(state, group) {
-    const isGroupFullySelected = isGroupSelected(state, { ...group, currentPageData: group.rows }) === true;
-    return group.rows.reduce((accumulatedState, row) => {
-        return setRowSelected(accumulatedState, row.id, !isGroupFullySelected, false);
-    }, state);
-}
-function togglePageSelected(state) {
-    const isPageFullySelected = getAllRowsFromResult(state.result).every(({ id }) => isRowSelected(state, id));
-    return getAllRowsFromResult(state.result).reduce((accumulatedState, row) => {
-        return setRowSelected(accumulatedState, row.id, !isPageFullySelected, false);
-    }, state);
-}
-function toggleAllSelected(state) {
-    if (isAllSelected(state) === true) {
-        return {
-            ...state,
-            selection: {
-                mostRecentlySelected: null,
-                mode: 'include',
-                included: new Set(),
-            },
-        };
-    }
-    else {
-        return {
-            ...state,
-            selection: {
-                mostRecentlySelected: null,
-                mode: 'exclude',
-                excluded: new Set(),
-            },
-        };
-    }
-}
-function clearSelection(state) {
-    return {
-        ...state,
-        selection: {
-            mostRecentlySelected: null,
-            mode: 'include',
-            included: new Set(),
-        },
-    };
-}
-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',
-            },
-        },
-    };
-}
-function getSearchColumnsSelectedState(state, expectedValue) {
-    switch (expectedValue) {
-        case 'all':
-            return Array.from(state.query.searchColumns.values()).every(value => value);
-        case 'none':
-            return Array.from(state.query.searchColumns.values()).every(value => !value);
-    }
-}
-function toggleAllSearchColumns(state) {
-    const noneSelected = getSearchColumnsSelectedState(state, 'none');
-    const payload = new Map(Array.from(state.query.searchColumns.keys()).map(key => [
-        key,
-        noneSelected,
-    ]));
-    return {
-        ...state,
-        query: {
-            ...state.query,
-            searchColumns: payload,
-        },
-    };
-}
 async function* reduce(state, action, columns, source, columnNameMap, defaultColumnState) {
     switch (action.type) {
         case 'load':
@@ -9323,7 +9680,7 @@ async function* reduce(state, action, columns, source, columnNameMap, defaultCol
             }, source, action);
             break;
         case 'orderColumnToggle':
-            yield* refreshResultWith(toggleColumnOrder(state, action.column), source, action);
+            yield* refreshResultWith(TableOrderHelpers.toggleColumnOrder(state, action.column), source, action);
             break;
         case 'searchChange':
             yield* refreshResultWith({
@@ -9389,7 +9746,7 @@ async function* reduce(state, action, columns, source, columnNameMap, defaultCol
                     ...state.query,
                     pagination: {
                         ...state.query.pagination,
-                        page: getPreviousPage(state) ?? 0,
+                        page: TablePaginationHelpers.getPreviousPage(state) ?? 0,
                     },
                 },
             }, source, action);
@@ -9401,7 +9758,8 @@ async function* reduce(state, action, columns, source, columnNameMap, defaultCol
                     ...state.query,
                     pagination: {
                         ...state.query.pagination,
-                        page: getNextPage(state) ?? getPageCount(state) - 1,
+                        page: TablePaginationHelpers.getNextPage(state) ??
+                            TablePaginationHelpers.getPageCount(state) - 1,
                     },
                 },
             }, source, action);
@@ -9468,49 +9826,49 @@ async function* reduce(state, action, columns, source, columnNameMap, defaultCol
             break;
         case 'columnPinChange':
             yield {
-                state: changeColumnPin(state, columns, columnNameMap, action.column, action.pinned),
+                state: TableColumnHelpers.changeColumnPin(state, columns, columnNameMap, action.column, action.pinned),
                 effect: 'saveColumnPreferences',
             };
             break;
         case 'columnsFreezeUpToChange':
             yield {
-                state: changeColumnsFreezeState(state, columns, columnNameMap, action.index, action.freeze),
+                state: TableColumnHelpers.changeColumnsFreezeState(state, columns, columnNameMap, action.index, action.freeze),
                 effect: 'saveColumnPreferences',
             };
             break;
         case 'columnOrderChange':
             yield {
-                state: changeColumnOrder(state, columns, columnNameMap, action.previousIndex, action.newIndex),
+                state: TableColumnHelpers.changeColumnOrder(state, columns, columnNameMap, action.previousIndex, action.newIndex),
                 effect: 'saveColumnPreferences',
             };
             break;
         case 'columnMoveToChange':
             yield {
-                state: moveColumnTo(state, columns, columnNameMap, action.column, action.position),
+                state: TableColumnHelpers.moveColumnTo(state, columns, columnNameMap, action.column, action.position),
                 effect: 'saveColumnPreferences',
             };
             break;
         case 'columnEnabledChange':
             yield {
-                state: changeColumnEnabled(state, columns, columnNameMap, action.column, action.enabled),
+                state: TableColumnHelpers.changeColumnEnabled(state, columns, columnNameMap, action.column, action.enabled),
                 effect: 'saveColumnPreferences',
             };
             break;
         case 'enableAllColumnsChange':
             yield {
-                state: enableAllColumns(state, columns, columnNameMap, action.enabled),
+                state: TableColumnHelpers.enableAllColumns(state, columns, columnNameMap, action.enabled),
                 effect: 'saveColumnPreferences',
             };
             break;
         case 'columnWidthChange':
             yield {
-                state: changeColumnWidth(state, columns, columnNameMap, action.column, action.preferredWidth),
+                state: TableColumnHelpers.changeColumnWidth(state, columns, columnNameMap, action.column, action.preferredWidth),
                 effect: 'saveColumnPreferences',
             };
             break;
         case 'resetToDefaultColumns':
             yield {
-                state: resetToDefaultColumns(state, columns, columnNameMap, defaultColumnState),
+                state: TableColumnHelpers.resetToDefaultColumns(state, columns, columnNameMap, defaultColumnState),
                 effect: 'saveColumnPreferences',
             };
             break;
@@ -9525,31 +9883,31 @@ async function* reduce(state, action, columns, source, columnNameMap, defaultCol
             break;
         case 'rowSelectedChange':
             yield {
-                state: setRowSelected(state, action.id, action.selected, action.contiguous),
+                state: TableSelectionHelpers.setRowSelected(state, action.id, action.selected, action.contiguous),
                 effect: null,
             };
             break;
         case 'pageSelectedChange':
             yield {
-                state: togglePageSelected(state),
+                state: TableSelectionHelpers.togglePageSelected(state),
                 effect: null,
             };
             break;
         case 'allSelectedChange':
             yield {
-                state: toggleAllSelected(state),
+                state: TableSelectionHelpers.toggleAllSelected(state),
                 effect: null,
             };
             break;
         case 'selectionClear':
             yield {
-                state: clearSelection(state),
+                state: TableSelectionHelpers.clearSelection(state),
                 effect: null,
             };
             break;
         case 'groupSelectionChange':
             yield {
-                state: toggleGroupSelected(state, action.payload),
+                state: TableSelectionHelpers.toggleGroupSelected(state, action.payload),
                 effect: null,
             };
             break;
@@ -9590,39 +9948,10 @@ async function* reduce(state, action, columns, source, columnNameMap, defaultCol
             }, source, action);
             break;
         case 'toggleAllSearchColumns':
-            yield* refreshResultWith(toggleAllSearchColumns(state), source, action);
+            yield* refreshResultWith(TableSearchHelpers.toggleAllSearchColumns(state), source, action);
             break;
     }
 }
-function isGroupResult(result) {
-    if ('totalGroupCount' in result) {
-        return true;
-    }
-    return false;
-}
-function getAllRowsFromResult(result) {
-    if (isGroupResult(result)) {
-        return result.groupResults.flatMap(groups => groups.currentPageData);
-    }
-    else {
-        return result.currentPageData;
-    }
-}
-function isPageOutOfBounds(state, result) {
-    if (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;
-}
 
 function createCellCoordinateCalculator(cells, totalColumns) {
     // Pre-calculate coordinates for all cells
@@ -9700,7 +10029,7 @@ 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 ||
@@ -10140,10 +10469,10 @@ class TableHeaderResizeHandleComponent {
     }
 }
 TableHeaderResizeHandleComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TableHeaderResizeHandleComponent, deps: [{ token: i0.ElementRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
-TableHeaderResizeHandleComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: TableHeaderResizeHandleComponent, selector: "riv-table-header-resize-handle", outputs: { dragResize: "dragResize" }, ngImport: i0, template: "", styles: [":host{position:absolute;top:0;right:calc(var(--border-width) * -1);bottom:0;padding-left:var(--size-small);background-color:var(--brand);background-clip:content-box;box-sizing:content-box;width:var(--border-width);opacity:0;transition:opacity var(--medium-transition);cursor:ew-resize}:host:hover{opacity:1}\n"] });
+TableHeaderResizeHandleComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: TableHeaderResizeHandleComponent, selector: "riv-table-header-resize-handle", outputs: { dragResize: "dragResize" }, ngImport: i0, template: "", styles: [":host{position:absolute;top:0;right:calc(var(--border-width) * -1);bottom:0;padding-left:var(--size-small);background-color:var(--brand);background-clip:content-box;box-sizing:content-box;width:var(--border-width);opacity:0;transition:opacity var(--medium-transition);cursor:ew-resize}:host:hover{opacity:1}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TableHeaderResizeHandleComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'riv-table-header-resize-handle', template: "", styles: [":host{position:absolute;top:0;right:calc(var(--border-width) * -1);bottom:0;padding-left:var(--size-small);background-color:var(--brand);background-clip:content-box;box-sizing:content-box;width:var(--border-width);opacity:0;transition:opacity var(--medium-transition);cursor:ew-resize}:host:hover{opacity:1}\n"] }]
+            args: [{ selector: 'riv-table-header-resize-handle', changeDetection: ChangeDetectionStrategy.OnPush, template: "", styles: [":host{position:absolute;top:0;right:calc(var(--border-width) * -1);bottom:0;padding-left:var(--size-small);background-color:var(--brand);background-clip:content-box;box-sizing:content-box;width:var(--border-width);opacity:0;transition:opacity var(--medium-transition);cursor:ew-resize}:host:hover{opacity:1}\n"] }]
         }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: Document, decorators: [{
                     type: Inject,
                     args: [DOCUMENT]