@rivet-health/design-system 40.27.2 → 40.28.0

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

@@ -6,7 +6,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';
@@ -8095,6 +8095,784 @@ 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) => {
+            var _a;
+            return ({
+                key,
+                enabled: true,
+                preferredWidth: 'auto',
+                pinned: !!((_a = supportedColumns.get(key)) === null || _a === void 0 ? void 0 : _a.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) => {
+                var _a, _b;
+                const aName = (_a = columnNameMap.get(a.key)) !== null && _a !== void 0 ? _a : a.key;
+                const bName = (_b = columnNameMap.get(b.key)) !== null && _b !== void 0 ? _b : 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,
+                Object.assign(Object.assign(Object.assign({}, 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 === null || target === void 0 ? void 0 : 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 Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, state.display), { columnSettings: orderIntentionally(allColumns.map(c => (Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, state.display), { columnSettings: allColumns.map((c, i) => {
+                    return Object.assign(Object.assign({}, 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) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            if (newIndex === i) {
+                return Object.assign(Object.assign({}, settings), { pinned: settings.pinned
+                        ? (_b = (_a = arr[i - 1]) === null || _a === void 0 ? void 0 : _a.pinned) !== null && _b !== void 0 ? _b : true
+                        : (_d = (_c = arr[i + 1]) === null || _c === void 0 ? void 0 : _c.pinned) !== null && _d !== void 0 ? _d : false, enabled: settings.enabled
+                        ? (_f = (_e = arr[i - 1]) === null || _e === void 0 ? void 0 : _e.enabled) !== null && _f !== void 0 ? _f : true
+                        : (_h = (_g = arr[i + 1]) === null || _g === void 0 ? void 0 : _g.enabled) !== null && _h !== void 0 ? _h : 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 Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, state.display), { columnSettings: orderIntentionally(allColumns.map(c => (Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, state.display), { columnSettings: orderIntentionally(allColumns.map(c => (Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, state.display), { columnSettings: allColumns.map(c => (Object.assign(Object.assign({}, c), { preferredWidth: c.key === column ? preferredWidth : c.preferredWidth }))) }) });
+    }
+    TableColumnHelpers.changeColumnWidth = changeColumnWidth;
+    function resetToDefaultColumns(state, columns, columnNameMap, defaultColumnState) {
+        return Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, 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) {
+            var _a;
+            allRows.push(currentNestedRow.data);
+            const subRows = (_a = currentNestedRow.subRows) !== null && _a !== void 0 ? _a : [];
+            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) {
+        var _a, _b;
+        return (((_b = (_a = options === null || options === void 0 ? void 0 : options.csvFileBasename) === null || _a === void 0 ? void 0 : _a.slice(0, 200)) !== null && _b !== void 0 ? _b : 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 Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, 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 === null || options === void 0 ? void 0 : 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) {
+        var _a;
+        if (((_a = state.query.order) === null || _a === void 0 ? void 0 : _a.column) === column) {
+            return Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, state.query), { order: state.query.order.direction === 'asc'
+                        ? {
+                            column,
+                            direction: 'desc',
+                        }
+                        : null }) });
+        }
+        return Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { selection: Object.assign({ 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 Object.assign(Object.assign({}, state), { selection: Object.assign({ 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, Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { selection: {
+                    mostRecentlySelected: null,
+                    mode: 'include',
+                    included: new Set(),
+                } });
+        }
+        else {
+            return Object.assign(Object.assign({}, state), { selection: {
+                    mostRecentlySelected: null,
+                    mode: 'exclude',
+                    excluded: new Set(),
+                } });
+        }
+    }
+    TableSelectionHelpers.toggleAllSelected = toggleAllSelected;
+    function clearSelection(state) {
+        return Object.assign(Object.assign({}, state), { selection: {
+                mostRecentlySelected: null,
+                mode: 'include',
+                included: new Set(),
+            } });
+    }
+    TableSelectionHelpers.clearSelection = clearSelection;
+})(TableSelectionHelpers || (TableSelectionHelpers = {}));
+
 var RivTable;
 (function (RivTable) {
     RivTable.pageSizes = [25, 50, 100, 250];
@@ -8173,8 +8951,8 @@ var RivTable;
         // Augment state with derived state, and subscribe.
         const state = connectable(coreState.pipe(map(({ state: s }) => {
             var _a, _b, _c, _d;
-            const resolvedColumns = resolveColumns(s, columns, columnNameMap, !!(options === null || options === void 0 ? void 0 : options.allowSelection));
-            if (isGroupResult(s.result)) {
+            const resolvedColumns = TableColumnHelpers.resolveColumns(s, columns, columnNameMap, !!(options === null || options === void 0 ? void 0 : options.allowSelection));
+            if (TableResultHelpers.isGroupResult(s.result)) {
                 if (options === null || options === void 0 ? void 0 : options.getRowSpanForCell) {
                     // eslint-disable-next-line no-console
                     console.warn('Heads up! Custom row spans are not supported for grouped tables.');
@@ -8186,8 +8964,8 @@ var RivTable;
                 const rowGroups = s.result.groupResults.map(group => ({
                     rows: group.currentPageData.map(row => (Object.assign(Object.assign({}, row), { rowLink: (options === null || options === void 0 ? void 0 : options.rowLink)
                             ? options.rowLink(row, group.groupData)
-                            : null, selected: isRowSelected(s, row.id) }))),
-                    selected: isGroupSelected(s, group),
+                            : null, selected: TableSelectionHelpers.isRowSelected(s, row.id) }))),
+                    selected: TableSelectionHelpers.isGroupSelected(s, group),
                     totalMatchingRowCount: group.totalMatchingRowCount,
                     groupData: group.groupData,
                 }));
@@ -8202,9 +8980,9 @@ var RivTable;
                                 page: 0,
                                 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 }) => { var _a; return (_a = columnNameMap.get(key)) !== null && _a !== void 0 ? _a : key; }));
                         if (groupCellFormatter) {
@@ -8215,7 +8993,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) {
@@ -8229,11 +9008,11 @@ var RivTable;
                         yield yield __await({ loading: false, data });
                     });
                 }
-                return Object.assign(Object.assign({}, s), { query: Object.assign(Object.assign({}, s.query), { pagination: Object.assign(Object.assign({}, s.query.pagination), { previous: getPreviousPage(s), pages: getPages(s), next: getNextPage(s), pageCount: getPageCount(s), showControls: getShowPaginationControls(s), pageRowStart: getPageRowStart(s), pageRowEnd: getPageRowEnd(s) }), noSearchColumnsSelected: getSearchColumnsSelectedState(s, 'none') }), display: Object.assign(Object.assign({}, s.display), { columns: resolvedColumns, allColumns: getAllColumns(s, columns, columnNameMap), columnNameMap: columnNameMap, searchableColumnMap: searchableColumnMap, zeroStateMessage: getZeroStateMessage(s, pluralEntityName), columnsAreFreezable: !!(options === null || options === void 0 ? void 0 : options.columnsAreFreezable), columnsAreHideable: !!(options === null || options === void 0 ? void 0 : options.columnsAreHideable), columnsAreReorderable: (_a = options === null || options === void 0 ? void 0 : options.columnsAreReorderable) !== null && _a !== void 0 ? _a : true, rowsAreGrayed: !!(options === null || options === void 0 ? void 0 : options.rowsAreGrayed), customSummaryRow: !!(options === null || options === void 0 ? void 0 : options.customSummaryRow), csvExportAllowed, enabledCount: resolvedColumns.length, hidePageSizeSelector: !!(options === null || options === void 0 ? void 0 : options.hidePageSizeSelector), cellRowSpan: (_i, _column) => 1, needsRightBorder: () => false }), selection: Object.assign(Object.assign({}, s.selection), { allowSelection: (_b = options === null || options === void 0 ? void 0 : options.allowSelection) !== null && _b !== void 0 ? _b : false, isAllSelected: isAllSelected(s), isCurrentPageSelected: isCurrentPageSelected(s), selectedCount: selectedCount(s) }), result: Object.assign(Object.assign({}, s.result), { isGrouped: true, rowGroups, rows: rowGroups.flatMap(group => group.rows), csvData, csvFilename: getCsvFilename(pluralEntityName, options) }) });
+                return Object.assign(Object.assign({}, s), { query: Object.assign(Object.assign({}, s.query), { pagination: Object.assign(Object.assign({}, s.query.pagination), { 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: TableSearchHelpers.getSearchColumnsSelectedState(s, 'none') }), display: Object.assign(Object.assign({}, s.display), { columns: resolvedColumns, allColumns: TableColumnHelpers.getAllColumns(s, columns, columnNameMap), columnNameMap: columnNameMap, searchableColumnMap: searchableColumnMap, zeroStateMessage: TableDisplayHelpers.getZeroStateMessage(s, pluralEntityName), columnsAreFreezable: !!(options === null || options === void 0 ? void 0 : options.columnsAreFreezable), columnsAreHideable: !!(options === null || options === void 0 ? void 0 : options.columnsAreHideable), columnsAreReorderable: (_a = options === null || options === void 0 ? void 0 : options.columnsAreReorderable) !== null && _a !== void 0 ? _a : true, rowsAreGrayed: !!(options === null || options === void 0 ? void 0 : options.rowsAreGrayed), customSummaryRow: !!(options === null || options === void 0 ? void 0 : options.customSummaryRow), csvExportAllowed, enabledCount: resolvedColumns.length, hidePageSizeSelector: !!(options === null || options === void 0 ? void 0 : options.hidePageSizeSelector), cellRowSpan: (_i, _column) => 1, needsRightBorder: () => false }), selection: Object.assign(Object.assign({}, s.selection), { allowSelection: (_b = options === null || options === void 0 ? void 0 : options.allowSelection) !== null && _b !== void 0 ? _b : false, isAllSelected: TableSelectionHelpers.isAllSelected(s), isCurrentPageSelected: TableSelectionHelpers.isCurrentPageSelected(s), selectedCount: TableSelectionHelpers.selectedCount(s) }), result: Object.assign(Object.assign({}, s.result), { isGrouped: true, rowGroups, rows: rowGroups.flatMap(group => group.rows), csvData, csvFilename: TableResultHelpers.getCsvFilename(pluralEntityName, options) }) });
             }
             else {
-                const rows = s.result.currentPageData.map(row => (Object.assign(Object.assign({}, row), { rowLink: (options === null || options === void 0 ? void 0 : options.rowLink) ? options.rowLink(row) : null, selected: isRowSelected(s, row.id) })));
-                const cellRowSpanCache = memoizedCellRowSpan(s, resolvedColumns, options);
+                const rows = s.result.currentPageData.map(row => (Object.assign(Object.assign({}, row), { rowLink: (options === null || options === void 0 ? void 0 : options.rowLink) ? options.rowLink(row) : null, selected: TableSelectionHelpers.isRowSelected(s, row.id) })));
+                const cellRowSpanCache = TableDisplayHelpers.memoizedCellRowSpan(s, resolvedColumns, options);
                 const cellRowSpan = (rowIndex, column) => { var _a, _b; return (_b = (_a = cellRowSpanCache === null || cellRowSpanCache === void 0 ? void 0 : cellRowSpanCache.get(column)) === null || _a === void 0 ? void 0 : _a[rowIndex]) !== null && _b !== void 0 ? _b : 1; };
                 const hasAnyRowSpans = cellRowSpanCache
                     ? [...cellRowSpanCache.values()].some(spans => spans.some(span => span > 1))
@@ -8252,13 +9031,14 @@ var RivTable;
                                 page: 0,
                                 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 }) => { var _a; return (_a = columnNameMap.get(key)) !== null && _a !== void 0 ? _a : 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) {
@@ -8269,19 +9049,19 @@ var RivTable;
                         yield yield __await({ loading: false, data });
                     });
                 }
-                return Object.assign(Object.assign({}, s), { query: Object.assign(Object.assign({}, s.query), { order: hasAnyRowSpans ? null : s.query.order, pagination: Object.assign(Object.assign({}, s.query.pagination), { previous: getPreviousPage(s), pages: getPages(s), next: getNextPage(s), pageCount: getPageCount(s), showControls: getShowPaginationControls(s), pageRowStart: getPageRowStart(s), pageRowEnd: getPageRowEnd(s) }), noSearchColumnsSelected: getSearchColumnsSelectedState(s, 'none') }), display: Object.assign(Object.assign({}, s.display), { columns: resolvedColumns.map(column => hasAnyRowSpans ? Object.assign(Object.assign({}, column), { orderable: false }) : column), allColumns: getAllColumns(s, columns, columnNameMap), columnNameMap: columnNameMap, searchableColumnMap: searchableColumnMap, zeroStateMessage: getZeroStateMessage(s, pluralEntityName), columnsAreFreezable: !!(options === null || options === void 0 ? void 0 : options.columnsAreFreezable), columnsAreHideable: !!(options === null || options === void 0 ? void 0 : options.columnsAreHideable), columnsAreReorderable: (_c = options === null || options === void 0 ? void 0 : options.columnsAreReorderable) !== null && _c !== void 0 ? _c : true, rowsAreGrayed: !!(options === null || options === void 0 ? void 0 : options.rowsAreGrayed), customSummaryRow: !!(options === null || options === void 0 ? void 0 : options.customSummaryRow), csvExportAllowed, enabledCount: resolvedColumns.length, hidePageSizeSelector: !!(options === null || options === void 0 ? void 0 : options.hidePageSizeSelector), cellRowSpan, needsRightBorder: (rowIndex, column) => {
+                return Object.assign(Object.assign({}, s), { query: Object.assign(Object.assign({}, s.query), { order: hasAnyRowSpans ? null : s.query.order, pagination: Object.assign(Object.assign({}, s.query.pagination), { 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: TableSearchHelpers.getSearchColumnsSelectedState(s, 'none') }), display: Object.assign(Object.assign({}, s.display), { columns: resolvedColumns.map(column => hasAnyRowSpans ? Object.assign(Object.assign({}, column), { orderable: false }) : column), allColumns: TableColumnHelpers.getAllColumns(s, columns, columnNameMap), columnNameMap: columnNameMap, searchableColumnMap: searchableColumnMap, zeroStateMessage: TableDisplayHelpers.getZeroStateMessage(s, pluralEntityName), columnsAreFreezable: !!(options === null || options === void 0 ? void 0 : options.columnsAreFreezable), columnsAreHideable: !!(options === null || options === void 0 ? void 0 : options.columnsAreHideable), columnsAreReorderable: (_c = options === null || options === void 0 ? void 0 : options.columnsAreReorderable) !== null && _c !== void 0 ? _c : true, rowsAreGrayed: !!(options === null || options === void 0 ? void 0 : options.rowsAreGrayed), customSummaryRow: !!(options === null || options === void 0 ? void 0 : options.customSummaryRow), csvExportAllowed, enabledCount: resolvedColumns.length, hidePageSizeSelector: !!(options === null || options === void 0 ? void 0 : options.hidePageSizeSelector), cellRowSpan, needsRightBorder: (rowIndex, column) => {
                             const i = resolvedColumnKeys.findIndex(key => key === column);
                             if (i < 0 || i === resolvedColumnKeys.length - 1)
                                 return false;
                             const rightColKey = resolvedColumnKeys[i + 1];
                             const spanOnRight = cellRowSpan(rowIndex, rightColKey);
                             return spanOnRight > 1 || spanOnRight === 0;
-                        } }), selection: Object.assign(Object.assign({}, s.selection), { allowSelection: (_d = options === null || options === void 0 ? void 0 : options.allowSelection) !== null && _d !== void 0 ? _d : false, isAllSelected: isAllSelected(s), isCurrentPageSelected: isCurrentPageSelected(s), selectedCount: selectedCount(s) }), result: Object.assign(Object.assign({}, s.result), { isGrouped: false, rows, rowsAsGroup: {
+                        } }), selection: Object.assign(Object.assign({}, s.selection), { allowSelection: (_d = options === null || options === void 0 ? void 0 : options.allowSelection) !== null && _d !== void 0 ? _d : false, isAllSelected: TableSelectionHelpers.isAllSelected(s), isCurrentPageSelected: TableSelectionHelpers.isCurrentPageSelected(s), selectedCount: TableSelectionHelpers.selectedCount(s) }), result: Object.assign(Object.assign({}, s.result), { isGrouped: false, rows, rowsAsGroup: {
                             rows,
                             selected: false,
                             totalMatchingRowCount: rows.length,
                             groupData: { key: '' },
-                        }, csvFilename: getCsvFilename(pluralEntityName, options), csvData }) });
+                        }, csvFilename: TableResultHelpers.getCsvFilename(pluralEntityName, options), csvData }) });
             }
         }), scan((stable, newState) => stableState(stable, newState))), {
             connector: () => new ReplaySubject(1),
@@ -8298,9 +9078,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) {
         var _a, _b, _c;
         let data;
@@ -8357,14 +9134,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;
@@ -8405,26 +9182,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
@@ -8462,326 +9219,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) {
-    var _a, _b;
-    return ((_b = (_a = options === null || options === void 0 ? void 0 : options.csvFileBasename) === null || _a === void 0 ? void 0 : _a.slice(0, 200)) !== null && _b !== void 0 ? _b : pluralEntityName) + '.csv';
-}
-function memoizedCellRowSpan(s, fullColumns, options) {
-    const getRowSpanForCell = options === null || options === void 0 ? void 0 : 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) => {
-        var _a;
-        return ({
-            key,
-            enabled: true,
-            preferredWidth: 'auto',
-            pinned: !!((_a = supportedColumns.get(key)) === null || _a === void 0 ? void 0 : _a.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) => {
-            var _a, _b;
-            const aName = (_a = columnNameMap.get(a.key)) !== null && _a !== void 0 ? _a : a.key;
-            const bName = (_b = columnNameMap.get(b.key)) !== null && _b !== void 0 ? _b : 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,
-            Object.assign(Object.assign(Object.assign({}, 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 === null || target === void 0 ? void 0 : 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 Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, state.display), { columnSettings: orderIntentionally(allColumns.map(c => (Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, state.display), { columnSettings: allColumns.map((c, i) => {
-                return Object.assign(Object.assign({}, 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) => {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        if (newIndex === i) {
-            return Object.assign(Object.assign({}, settings), { pinned: settings.pinned
-                    ? (_b = (_a = arr[i - 1]) === null || _a === void 0 ? void 0 : _a.pinned) !== null && _b !== void 0 ? _b : true
-                    : (_d = (_c = arr[i + 1]) === null || _c === void 0 ? void 0 : _c.pinned) !== null && _d !== void 0 ? _d : false, enabled: settings.enabled
-                    ? (_f = (_e = arr[i - 1]) === null || _e === void 0 ? void 0 : _e.enabled) !== null && _f !== void 0 ? _f : true
-                    : (_h = (_g = arr[i + 1]) === null || _g === void 0 ? void 0 : _g.enabled) !== null && _h !== void 0 ? _h : 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 Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, state.display), { columnSettings: orderIntentionally(allColumns.map(c => (Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, state.display), { columnSettings: orderIntentionally(allColumns.map(c => (Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, state.display), { columnSettings: allColumns.map(c => (Object.assign(Object.assign({}, c), { preferredWidth: c.key === column ? preferredWidth : c.preferredWidth }))) }) });
-}
-function resetToDefaultColumns(state, columns, columnNameMap, defaultColumnState) {
-    return Object.assign(Object.assign({}, state), { display: Object.assign(Object.assign({}, 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;
-    }
-}
 function refreshResultWith(state, source, mostRecentAction) {
     return __asyncGenerator(this, arguments, function* refreshResultWith_1() {
         yield yield __await({
@@ -8793,7 +9230,7 @@ function refreshResultWith(state, source, mostRecentAction) {
         });
         try {
             const result = yield __await(source(state.query, mostRecentAction));
-            if (isPageOutOfBounds(state, result)) {
+            if (TablePaginationHelpers.isPageOutOfBounds(state, result)) {
                 state.query.pagination.page = 0;
             }
             yield yield __await({
@@ -8817,106 +9254,6 @@ 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 Object.assign(Object.assign({}, state), { selection: Object.assign({ 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 Object.assign(Object.assign({}, state), { selection: Object.assign({ 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, Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { selection: {
-                mostRecentlySelected: null,
-                mode: 'include',
-                included: new Set(),
-            } });
-    }
-    else {
-        return Object.assign(Object.assign({}, state), { selection: {
-                mostRecentlySelected: null,
-                mode: 'exclude',
-                excluded: new Set(),
-            } });
-    }
-}
-function clearSelection(state) {
-    return Object.assign(Object.assign({}, state), { selection: {
-            mostRecentlySelected: null,
-            mode: 'include',
-            included: new Set(),
-        } });
-}
-function toggleColumnOrder(state, column) {
-    var _a;
-    if (((_a = state.query.order) === null || _a === void 0 ? void 0 : _a.column) === column) {
-        return Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, state.query), { order: state.query.order.direction === 'asc'
-                    ? {
-                        column,
-                        direction: 'desc',
-                    }
-                    : null }) });
-    }
-    return Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, state.query), { searchColumns: payload }) });
-}
 function reduce(state, action, columns, source, columnNameMap, defaultColumnState) {
     var _a, _b;
     return __asyncGenerator(this, arguments, function* reduce_1() {
@@ -8932,7 +9269,7 @@ function reduce(state, action, columns, source, columnNameMap, defaultColumnStat
                     } }), source, action))));
                 break;
             case 'orderColumnToggle':
-                yield __await(yield* __asyncDelegator(__asyncValues(refreshResultWith(toggleColumnOrder(state, action.column), source, action))));
+                yield __await(yield* __asyncDelegator(__asyncValues(refreshResultWith(TableOrderHelpers.toggleColumnOrder(state, action.column), source, action))));
                 break;
             case 'searchChange':
                 yield __await(yield* __asyncDelegator(__asyncValues(refreshResultWith(Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, state.query), { search: action.payload, pagination: Object.assign(Object.assign({}, state.query.pagination), { page: 0 }) }), selection: {
@@ -8958,10 +9295,10 @@ function reduce(state, action, columns, source, columnNameMap, defaultColumnStat
                 yield __await(yield* __asyncDelegator(__asyncValues(refreshResultWith(Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, state.query), { grouping: action.payload }) }), source, action))));
                 break;
             case 'previousPageNavigate':
-                yield __await(yield* __asyncDelegator(__asyncValues(refreshResultWith(Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, state.query), { pagination: Object.assign(Object.assign({}, state.query.pagination), { page: (_a = getPreviousPage(state)) !== null && _a !== void 0 ? _a : 0 }) }) }), source, action))));
+                yield __await(yield* __asyncDelegator(__asyncValues(refreshResultWith(Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, state.query), { pagination: Object.assign(Object.assign({}, state.query.pagination), { page: (_a = TablePaginationHelpers.getPreviousPage(state)) !== null && _a !== void 0 ? _a : 0 }) }) }), source, action))));
                 break;
             case 'nextPageNavigate':
-                yield __await(yield* __asyncDelegator(__asyncValues(refreshResultWith(Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, state.query), { pagination: Object.assign(Object.assign({}, state.query.pagination), { page: (_b = getNextPage(state)) !== null && _b !== void 0 ? _b : getPageCount(state) - 1 }) }) }), source, action))));
+                yield __await(yield* __asyncDelegator(__asyncValues(refreshResultWith(Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, state.query), { pagination: Object.assign(Object.assign({}, state.query.pagination), { page: (_b = TablePaginationHelpers.getNextPage(state)) !== null && _b !== void 0 ? _b : TablePaginationHelpers.getPageCount(state) - 1 }) }) }), source, action))));
                 break;
             case 'pageChange':
                 yield __await(yield* __asyncDelegator(__asyncValues(refreshResultWith(Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, state.query), { pagination: Object.assign(Object.assign({}, state.query.pagination), { page: action.page }) }) }), source, action))));
@@ -8989,49 +9326,49 @@ function reduce(state, action, columns, source, columnNameMap, defaultColumnStat
                 break;
             case 'columnPinChange':
                 yield yield __await({
-                    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 yield __await({
-                    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 yield __await({
-                    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 yield __await({
-                    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 yield __await({
-                    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 yield __await({
-                    state: enableAllColumns(state, columns, columnNameMap, action.enabled),
+                    state: TableColumnHelpers.enableAllColumns(state, columns, columnNameMap, action.enabled),
                     effect: 'saveColumnPreferences',
                 });
                 break;
             case 'columnWidthChange':
                 yield yield __await({
-                    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 yield __await({
-                    state: resetToDefaultColumns(state, columns, columnNameMap, defaultColumnState),
+                    state: TableColumnHelpers.resetToDefaultColumns(state, columns, columnNameMap, defaultColumnState),
                     effect: 'saveColumnPreferences',
                 });
                 break;
@@ -9043,31 +9380,31 @@ function reduce(state, action, columns, source, columnNameMap, defaultColumnStat
                 break;
             case 'rowSelectedChange':
                 yield yield __await({
-                    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 yield __await({
-                    state: togglePageSelected(state),
+                    state: TableSelectionHelpers.togglePageSelected(state),
                     effect: null,
                 });
                 break;
             case 'allSelectedChange':
                 yield yield __await({
-                    state: toggleAllSelected(state),
+                    state: TableSelectionHelpers.toggleAllSelected(state),
                     effect: null,
                 });
                 break;
             case 'selectionClear':
                 yield yield __await({
-                    state: clearSelection(state),
+                    state: TableSelectionHelpers.clearSelection(state),
                     effect: null,
                 });
                 break;
             case 'groupSelectionChange':
                 yield yield __await({
-                    state: toggleGroupSelected(state, action.payload),
+                    state: TableSelectionHelpers.toggleGroupSelected(state, action.payload),
                     effect: null,
                 });
                 break;
@@ -9081,40 +9418,11 @@ function reduce(state, action, columns, source, columnNameMap, defaultColumnStat
                 yield __await(yield* __asyncDelegator(__asyncValues(refreshResultWith(Object.assign(Object.assign({}, state), { query: Object.assign(Object.assign({}, state.query), { grouping: Object.assign(Object.assign({}, state.query.grouping), { viewMoreKey: action.viewMoreKey }) }) }), source, action))));
                 break;
             case 'toggleAllSearchColumns':
-                yield __await(yield* __asyncDelegator(__asyncValues(refreshResultWith(toggleAllSearchColumns(state), source, action))));
+                yield __await(yield* __asyncDelegator(__asyncValues(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
@@ -9193,7 +9501,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 ||
@@ -9653,10 +9961,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,