@tanstack/table-core 9.0.0-beta.7 → 9.0.0-beta.70

package/dist/features/row-selection/rowSelectionFeature.utils.js

@@ -1,4 +1,4 @@
-import { cloneState } from "../../utils.js";
+import { callMemoOrStaticFn, cloneState, copyInstancePropertiesWithoutMemos, hasOwn, makeObjectMap } from "../../utils.js";
 
 //#region src/features/row-selection/rowSelectionFeature.utils.ts
 /**
@@ -13,7 +13,7 @@ import { cloneState } from "../../utils.js";
 * ```
 */
 function getDefaultRowSelectionState() {
-	return {};
+	return makeObjectMap();
 }
 /**
 * Routes a row selection updater through the table's selection change handler.
@@ -27,8 +27,7 @@ function getDefaultRowSelectionState() {
 * ```
 */
 function table_setRowSelection(table, updater) {
-	var _table$options$onRowS, _table$options;
-	(_table$options$onRowS = (_table$options = table.options).onRowSelectionChange) === null || _table$options$onRowS === void 0 || _table$options$onRowS.call(_table$options, updater);
+	table.options.onRowSelectionChange?.(updater);
 }
 /**
 * Resets `rowSelection` to the configured initial state or feature default.
@@ -43,7 +42,8 @@ function table_setRowSelection(table, updater) {
 * ```
 */
 function table_resetRowSelection(table, defaultState) {
-	table_setRowSelection(table, defaultState ? {} : cloneState(table.initialState.rowSelection ?? {}));
+	table._lastSelectedRowId = null;
+	table_setRowSelection(table, defaultState ? makeObjectMap() : Object.assign(makeObjectMap(), cloneState(table.initialState.rowSelection ?? {})));
 }
 /**
 * Selects or deselects every selectable row before grouping.
@@ -56,14 +56,15 @@ function table_resetRowSelection(table, defaultState) {
 * table_toggleAllRowsSelected(table)
 * ```
 */
-function table_toggleAllRowsSelected(table, value) {
+function table_toggleAllRowsSelected(table, value, opts) {
+	table._lastSelectedRowId = null;
 	table_setRowSelection(table, (old) => {
-		value = typeof value !== "undefined" ? value : !table_getIsAllRowsSelected(table);
-		const rowSelection = { ...old };
+		value = typeof value !== "undefined" ? value : !callMemoOrStaticFn(table, "getIsAllRowsSelected", table_getIsAllRowsSelected);
+		if (opts?.deselectAll && !value) return makeObjectMap();
+		const rowSelection = Object.assign(makeObjectMap(), old);
 		const preGroupedFlatRows = table.getPreGroupedRowModel().flatRows;
 		if (value) preGroupedFlatRows.forEach((row) => {
-			if (!row_getCanSelect(row)) return;
-			rowSelection[row.id] = true;
+			if (row_getCanSelect(row)) rowSelection[row.id] = true;
 		});
 		else preGroupedFlatRows.forEach((row) => {
 			delete rowSelection[row.id];
@@ -82,10 +83,12 @@ function table_toggleAllRowsSelected(table, value) {
 * table_toggleAllPageRowsSelected(table)
 * ```
 */
-function table_toggleAllPageRowsSelected(table, value) {
+function table_toggleAllPageRowsSelected(table, value, opts) {
+	table._lastSelectedRowId = null;
 	table_setRowSelection(table, (old) => {
-		const resolvedValue = typeof value !== "undefined" ? value : !table_getIsAllPageRowsSelected(table);
-		const rowSelection = { ...old };
+		const resolvedValue = typeof value !== "undefined" ? value : !callMemoOrStaticFn(table, "getIsAllPageRowsSelected", table_getIsAllPageRowsSelected);
+		if (opts?.deselectAll && !resolvedValue) return makeObjectMap();
+		const rowSelection = Object.assign(makeObjectMap(), old);
 		table.getRowModel().rows.forEach((row) => {
 			mutateRowIsSelected(rowSelection, row.id, resolvedValue, true, table);
 		});
@@ -118,14 +121,13 @@ function table_getPreSelectedRowModel(table) {
 * ```
 */
 function table_getSelectedRowModel(table) {
-	var _table$atoms$rowSelec;
 	const rowModel = table.getCoreRowModel();
-	if (!Object.keys(((_table$atoms$rowSelec = table.atoms.rowSelection) === null || _table$atoms$rowSelec === void 0 ? void 0 : _table$atoms$rowSelec.get()) ?? {}).length) return {
+	if (!callMemoOrStaticFn(table, "getIsSomeRowsSelected", table_getIsSomeRowsSelected)) return {
 		rows: [],
 		flatRows: [],
-		rowsById: {}
+		rowsById: makeObjectMap()
 	};
-	return selectRowsFn(rowModel);
+	return selectRowsFn(rowModel, table);
 }
 /**
 * Builds a row model containing selected rows from the filtered row model.
@@ -139,14 +141,13 @@ function table_getSelectedRowModel(table) {
 * ```
 */
 function table_getFilteredSelectedRowModel(table) {
-	var _table$atoms$rowSelec2;
-	const rowModel = table.getCoreRowModel();
-	if (!Object.keys(((_table$atoms$rowSelec2 = table.atoms.rowSelection) === null || _table$atoms$rowSelec2 === void 0 ? void 0 : _table$atoms$rowSelec2.get()) ?? {}).length) return {
+	const rowModel = table.getFilteredRowModel();
+	if (!callMemoOrStaticFn(table, "getIsSomeRowsSelected", table_getIsSomeRowsSelected)) return {
 		rows: [],
 		flatRows: [],
-		rowsById: {}
+		rowsById: makeObjectMap()
 	};
-	return selectRowsFn(rowModel);
+	return selectRowsFn(rowModel, table);
 }
 /**
 * Builds a row model containing selected rows from the grouped row model.
@@ -160,14 +161,24 @@ function table_getFilteredSelectedRowModel(table) {
 * ```
 */
 function table_getGroupedSelectedRowModel(table) {
-	var _table$atoms$rowSelec3;
-	const rowModel = table.getCoreRowModel();
-	if (!Object.keys(((_table$atoms$rowSelec3 = table.atoms.rowSelection) === null || _table$atoms$rowSelec3 === void 0 ? void 0 : _table$atoms$rowSelec3.get()) ?? {}).length) return {
+	const rowModel = table.getSortedRowModel();
+	if (!callMemoOrStaticFn(table, "getIsSomeRowsSelected", table_getIsSomeRowsSelected)) return {
 		rows: [],
 		flatRows: [],
-		rowsById: {}
+		rowsById: makeObjectMap()
 	};
-	return selectRowsFn(rowModel);
+	return selectRowsFn(rowModel, table);
+}
+/**
+* Returns the ids of all selected rows.
+*
+* @example
+* ```ts
+* const selectedRowIds = table_getSelectedRowIds(table)
+* ```
+*/
+function table_getSelectedRowIds(table) {
+	return Object.keys(table.atoms.rowSelection?.get() ?? {});
 }
 /**
 * Checks whether every selectable filtered row is selected.
@@ -181,12 +192,11 @@ function table_getGroupedSelectedRowModel(table) {
 * ```
 */
 function table_getIsAllRowsSelected(table) {
-	var _table$atoms$rowSelec4;
 	const preGroupedFlatRows = table.getFilteredRowModel().flatRows;
-	const rowSelection = ((_table$atoms$rowSelec4 = table.atoms.rowSelection) === null || _table$atoms$rowSelec4 === void 0 ? void 0 : _table$atoms$rowSelec4.get()) ?? {};
+	const rowSelection = table.atoms.rowSelection?.get() ?? {};
 	let isAllRowsSelected = Boolean(preGroupedFlatRows.length && Object.keys(rowSelection).length);
 	if (isAllRowsSelected) {
-		if (preGroupedFlatRows.some((row) => row_getCanSelect(row) && !rowSelection[row.id])) isAllRowsSelected = false;
+		if (preGroupedFlatRows.some((row) => row_getCanSelect(row) && !isRowSelected(row, rowSelection))) isAllRowsSelected = false;
 	}
 	return isAllRowsSelected;
 }
@@ -201,18 +211,16 @@ function table_getIsAllRowsSelected(table) {
 * ```
 */
 function table_getIsAllPageRowsSelected(table) {
-	var _table$atoms$rowSelec5;
 	const paginationFlatRows = table.getPaginatedRowModel().flatRows.filter((row) => row_getCanSelect(row));
-	const rowSelection = ((_table$atoms$rowSelec5 = table.atoms.rowSelection) === null || _table$atoms$rowSelec5 === void 0 ? void 0 : _table$atoms$rowSelec5.get()) ?? {};
+	const rowSelection = table.atoms.rowSelection?.get() ?? {};
 	let isAllPageRowsSelected = !!paginationFlatRows.length;
-	if (isAllPageRowsSelected && paginationFlatRows.some((row) => !rowSelection[row.id])) isAllPageRowsSelected = false;
+	if (isAllPageRowsSelected && paginationFlatRows.some((row) => !isRowSelected(row, rowSelection))) isAllPageRowsSelected = false;
 	return isAllPageRowsSelected;
 }
 /**
-* Checks whether selection is partially applied across filtered rows.
+* Checks whether at least one row id is selected.
 *
-* The result is true when at least one row id is selected but fewer ids are
-* selected than the current filtered flat row count.
+* The result stays true when every row is selected.
 *
 * @example
 * ```ts
@@ -220,15 +228,10 @@ function table_getIsAllPageRowsSelected(table) {
 * ```
 */
 function table_getIsSomeRowsSelected(table) {
-	var _table$atoms$rowSelec6;
-	const totalSelected = Object.keys(((_table$atoms$rowSelec6 = table.atoms.rowSelection) === null || _table$atoms$rowSelec6 === void 0 ? void 0 : _table$atoms$rowSelec6.get()) ?? {}).length;
-	return totalSelected > 0 && totalSelected < table.getFilteredRowModel().flatRows.length;
+	return callMemoOrStaticFn(table, "getSelectedRowIds", table_getSelectedRowIds).length > 0;
 }
 /**
-* Checks whether the current page has a partial selection.
-*
-* This is false when all selectable page rows are selected. Otherwise it is true
-* if any selectable page row or descendant is selected.
+* Checks whether at least one selectable row on the current page is selected.
 *
 * @example
 * ```ts
@@ -236,8 +239,7 @@ function table_getIsSomeRowsSelected(table) {
 * ```
 */
 function table_getIsSomePageRowsSelected(table) {
-	const paginationFlatRows = table.getPaginatedRowModel().flatRows;
-	return table_getIsAllPageRowsSelected(table) ? false : paginationFlatRows.filter((row) => row_getCanSelect(row)).some((row) => row_getIsSelected(row) || row_getIsSomeSelected(row));
+	return table.getPaginatedRowModel().flatRows.filter((row) => row_getCanSelect(row)).some((row) => row_getIsSelected(row) || callMemoOrStaticFn(row, "getIsSomeSelected", row_getIsSomeSelected));
 }
 /**
 * Creates a checkbox-style handler that selects or deselects all rows.
@@ -275,21 +277,25 @@ function table_getToggleAllPageRowsSelectedHandler(table) {
 * Selects or deselects this row.
 *
 * Omitting `value` toggles the row. Child rows are selected recursively unless
-* `opts.selectChildren` is `false` or sub-row selection is disabled.
+* `opts.selectChildren` is `false`, sub-row selection is disabled, or the row
+* only supports single selection.
 *
 * @example
 * ```ts
 * row_toggleSelected(row)
+* row_toggleSelected(row, true)
+* row_toggleSelected(row, false)
+* row_toggleSelected(row, true, { selectChildren: false })
+* row_toggleSelected(row, false, { selectChildren: false })
 * ```
 */
 function row_toggleSelected(row, value, opts) {
 	const isSelected = row_getIsSelected(row);
 	table_setRowSelection(row.table, (old) => {
 		value = typeof value !== "undefined" ? value : !isSelected;
-		if (row_getCanSelect(row) && isSelected === value) return old;
-		const selectedRowIds = { ...old };
-		mutateRowIsSelected(selectedRowIds, row.id, value, (opts === null || opts === void 0 ? void 0 : opts.selectChildren) ?? true, row.table);
-		return selectedRowIds;
+		const rowSelection = Object.assign(makeObjectMap(), old);
+		mutateRowIsSelected(rowSelection, row.id, value, (opts?.selectChildren ?? true) && row_getCanMultiSelect(row), row.table);
+		return rowSelection;
 	});
 }
 /**
@@ -303,7 +309,7 @@ function row_toggleSelected(row, value, opts) {
 * ```
 */
 function row_getIsSelected(row) {
-	return isRowSelected(row);
+	return isRowSelected(row, row.table.atoms.rowSelection?.get() ?? {});
 }
 /**
 * Checks whether some, but not all, selectable descendants are selected.
@@ -383,28 +389,91 @@ function row_getCanMultiSelect(row) {
 * Creates a checkbox-style handler that selects or deselects this row.
 *
 * The handler is a no-op when the row cannot be selected and reads
-* `event.target.checked`.
+* `event.target.checked`. Shift events select or deselect the inclusive range
+* from the most recent selectable row handled by this table. Pass
+* `selectChildren: false` to limit changes to rows explicitly present in the
+* display-order interval.
 *
 * @example
 * ```ts
 * const onChange = row_getToggleSelectedHandler(row)
 * ```
 */
-function row_getToggleSelectedHandler(row) {
+function row_getToggleSelectedHandler(row, opts) {
 	const canSelect = row_getCanSelect(row);
 	return (e) => {
 		if (!canSelect) return;
-		row_toggleSelected(row, e.target.checked);
+		const event = e;
+		const table = row.table;
+		const checked = event.target.checked;
+		const anchorId = table._lastSelectedRowId;
+		if (!(table.options.enableRowRangeSelection !== false && anchorId !== null && row_getCanMultiSelect(row) && (table.options.isRowRangeSelectionEvent?.(e) ?? false)) || !selectRowRange(row, anchorId, checked, opts?.selectChildren ?? true)) row_toggleSelected(row, checked, opts);
+		table._lastSelectedRowId = row.id;
 	};
 }
-const mutateRowIsSelected = (selectedRowIds, rowId, value, includeChildren, table) => {
+/**
+* Resolves and mutates an inclusive interval in the table's latest logical
+* display order.
+*
+* The anchor is resolved without throwing from the pre-pagination row model,
+* then the core row model. Both endpoint display indexes must still identify
+* those rows in the current order and both endpoints must support
+* multi-selection. Eligible interval rows are applied through one row
+* selection updater; non-selectable and non-multi-selectable rows are skipped.
+* Returns `false` when the interaction should fall back to an ordinary toggle.
+*/
+function selectRowRange(row, anchorId, value, includeChildren) {
+	const table = row.table;
+	const rows = table.getRowsInDisplayOrder();
+	const anchorRow = table.getPrePaginatedRowModel().rowsById[anchorId] ?? table.getCoreRowModel().rowsById[anchorId];
+	if (!anchorRow) return false;
+	const anchorIndex = anchorRow.getDisplayIndex();
+	const rowIndex = row.getDisplayIndex();
+	const anchorAtIndex = rows[anchorIndex];
+	const rowAtIndex = rows[rowIndex];
+	if (anchorIndex < 0 || rowIndex < 0 || anchorIndex >= rows.length || rowIndex >= rows.length || anchorAtIndex?.id !== anchorRow.id || rowAtIndex?.id !== row.id || !row_getCanMultiSelect(anchorRow) || !row_getCanMultiSelect(row)) return false;
+	const start = Math.min(anchorIndex, rowIndex);
+	const end = Math.max(anchorIndex, rowIndex);
+	table_setRowSelection(table, (old) => {
+		const rowSelection = Object.assign(makeObjectMap(), old);
+		for (let index = start; index <= end; index++) {
+			const rangeRow = rows[index];
+			if (!row_getCanSelect(rangeRow) || !row_getCanMultiSelect(rangeRow)) continue;
+			mutateRowIsSelected(rowSelection, rangeRow.id, value, includeChildren, table);
+		}
+		return rowSelection;
+	});
+	return true;
+}
+const mutateRowIsSelected = (rowSelection, rowId, value, includeChildren, table) => {
 	const row = table.getRow(rowId, true);
 	if (value) {
-		if (!row_getCanMultiSelect(row)) Object.keys(selectedRowIds).forEach((key) => delete selectedRowIds[key]);
-		if (row_getCanSelect(row)) selectedRowIds[rowId] = true;
-	} else delete selectedRowIds[rowId];
-	if (includeChildren && row.subRows.length && row_getCanSelectSubRows(row)) row.subRows.forEach((r) => mutateRowIsSelected(selectedRowIds, r.id, value, includeChildren, table));
+		if (!row_getCanMultiSelect(row)) Object.keys(rowSelection).forEach((key) => delete rowSelection[key]);
+		if (row_getCanSelect(row)) rowSelection[rowId] = true;
+	} else delete rowSelection[rowId];
+	if (includeChildren && row.subRows.length && row_getCanSelectSubRows(row)) row.subRows.forEach((r) => mutateRowIsSelected(rowSelection, r.id, value, includeChildren, table));
 };
+function selectRowsRecursively(rows, rowSelection, selectedFlatRows, selectedRowsById) {
+	const result = [];
+	for (let i = 0; i < rows.length; i++) {
+		const row = rows[i];
+		const isSelected = isRowSelected(row, rowSelection);
+		if (isSelected) {
+			selectedFlatRows.push(row);
+			selectedRowsById[row.id] = row;
+		}
+		if (row.subRows.length) {
+			const newSubRows = selectRowsRecursively(row.subRows, rowSelection, selectedFlatRows, selectedRowsById);
+			if (isSelected) {
+				const cloned = Object.create(Object.getPrototypeOf(row));
+				copyInstancePropertiesWithoutMemos(cloned, row);
+				cloned.subRows = newSubRows;
+				result.push(cloned);
+			}
+		} else if (isSelected) result.push(row);
+	}
+	return result;
+}
 /**
 * Builds a row model containing rows selected by the current row selection state.
 *
@@ -416,28 +485,12 @@ const mutateRowIsSelected = (selectedRowIds, rowId, value, includeChildren, tabl
 * const selectedRows = selectRowsFn(rowModel)
 * ```
 */
-function selectRowsFn(rowModel) {
+function selectRowsFn(rowModel, table) {
 	const newSelectedFlatRows = [];
-	const newSelectedRowsById = {};
-	const recurseRows = (rows, depth = 0) => {
-		const result = [];
-		for (let i = 0; i < rows.length; i++) {
-			let row = rows[i];
-			const isSelected = isRowSelected(row);
-			if (isSelected) {
-				newSelectedFlatRows.push(row);
-				newSelectedRowsById[row.id] = row;
-			}
-			if (row.subRows.length) row = {
-				...row,
-				subRows: recurseRows(row.subRows, depth + 1)
-			};
-			if (isSelected) result.push(row);
-		}
-		return result;
-	};
+	const newSelectedRowsById = makeObjectMap();
+	const rowSelection = table.atoms.rowSelection?.get() ?? {};
 	return {
-		rows: recurseRows(rowModel.rows),
+		rows: selectRowsRecursively(rowModel.rows, rowSelection, newSelectedFlatRows, newSelectedRowsById),
 		flatRows: newSelectedFlatRows,
 		rowsById: newSelectedRowsById
 	};
@@ -450,9 +503,8 @@ function selectRowsFn(rowModel) {
 * const selected = isRowSelected(row)
 * ```
 */
-function isRowSelected(row) {
-	var _row$table$atoms$rowS;
-	return (((_row$table$atoms$rowS = row.table.atoms.rowSelection) === null || _row$table$atoms$rowS === void 0 ? void 0 : _row$table$atoms$rowS.get()) ?? {})[row.id] ?? false;
+function isRowSelected(row, rowSelection) {
+	return !!(hasOwn(rowSelection, row.id) && rowSelection[row.id]);
 }
 /**
 * Returns whether all, some, or none of a row's selectable descendants are selected.
@@ -466,11 +518,13 @@ function isRowSelected(row) {
 */
 function isSubRowSelected(row) {
 	if (!row.subRows.length) return false;
-	let allChildrenSelected = true;
+	const rowSelection = row.table.atoms.rowSelection?.get() ?? {};
 	let someSelected = false;
-	row.subRows.forEach((subRow) => {
-		if (someSelected && !allChildrenSelected) return;
-		if (row_getCanSelect(subRow)) if (isRowSelected(subRow)) someSelected = true;
+	let allChildrenSelected = true;
+	for (let i = 0; i < row.subRows.length; i++) {
+		const subRow = row.subRows[i];
+		if (someSelected && !allChildrenSelected) break;
+		if (row_getCanSelect(subRow)) if (isRowSelected(subRow, rowSelection)) someSelected = true;
 		else allChildrenSelected = false;
 		if (subRow.subRows.length) {
 			const subRowChildrenSelected = isSubRowSelected(subRow);
@@ -480,10 +534,9 @@ function isSubRowSelected(row) {
 				allChildrenSelected = false;
 			} else allChildrenSelected = false;
 		}
-	});
+	}
 	return allChildrenSelected ? "all" : someSelected ? "some" : false;
 }
 
 //#endregion
-export { getDefaultRowSelectionState, isRowSelected, isSubRowSelected, row_getCanMultiSelect, row_getCanSelect, row_getCanSelectSubRows, row_getIsAllSubRowsSelected, row_getIsSelected, row_getIsSomeSelected, row_getToggleSelectedHandler, row_toggleSelected, selectRowsFn, table_getFilteredSelectedRowModel, table_getGroupedSelectedRowModel, table_getIsAllPageRowsSelected, table_getIsAllRowsSelected, table_getIsSomePageRowsSelected, table_getIsSomeRowsSelected, table_getPreSelectedRowModel, table_getSelectedRowModel, table_getToggleAllPageRowsSelectedHandler, table_getToggleAllRowsSelectedHandler, table_resetRowSelection, table_setRowSelection, table_toggleAllPageRowsSelected, table_toggleAllRowsSelected };
-//# sourceMappingURL=rowSelectionFeature.utils.js.map
+export { getDefaultRowSelectionState, isRowSelected, isSubRowSelected, row_getCanMultiSelect, row_getCanSelect, row_getCanSelectSubRows, row_getIsAllSubRowsSelected, row_getIsSelected, row_getIsSomeSelected, row_getToggleSelectedHandler, row_toggleSelected, selectRowsFn, table_getFilteredSelectedRowModel, table_getGroupedSelectedRowModel, table_getIsAllPageRowsSelected, table_getIsAllRowsSelected, table_getIsSomePageRowsSelected, table_getIsSomeRowsSelected, table_getPreSelectedRowModel, table_getSelectedRowIds, table_getSelectedRowModel, table_getToggleAllPageRowsSelectedHandler, table_getToggleAllRowsSelectedHandler, table_resetRowSelection, table_setRowSelection, table_toggleAllPageRowsSelected, table_toggleAllRowsSelected };

package/dist/features/row-sorting/createSortedRowModel.d.ts

@@ -1,16 +1,20 @@
 import { RowData } from "../../types/type-utils.js";
-import { SortFn, SortFns } from "./rowSortingFeature.types.js";
-import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table } from "../../types/Table.js";
 import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
-
+import { Table } from "../../types/Table.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/row-sorting/createSortedRowModel.d.ts
 /**
  * Creates a memoized sorted row model factory.
  *
  * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
+ *
+ * Register the sorting functions you use with the `sortFns` slot on the
+ * `features` option:
+ * `tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns: { alphanumeric: sortFn_alphanumeric } })`.
+ * Importing individual `sortFn_*` functions keeps unused built-ins out of
+ * your bundle; sorting functions passed directly to the `sortFn` column
+ * option need no registration at all.
  */
-declare function createSortedRowModel<TFeatures extends TableFeatures, TData extends RowData>(sortFns: Record<keyof SortFns, SortFn<TFeatures, TData>>): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
+declare function createSortedRowModel<TFeatures extends TableFeatures, TData extends RowData>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
 //#endregion
-export { createSortedRowModel };
-//# sourceMappingURL=createSortedRowModel.d.ts.map
+export { createSortedRowModel };

package/dist/features/row-sorting/createSortedRowModel.js

@@ -1,4 +1,4 @@
-import { tableMemo } from "../../utils.js";
+import { copyInstancePropertiesWithoutMemos, tableMemo } from "../../utils.js";
 import { table_autoResetPageIndex } from "../row-pagination/rowPaginationFeature.utils.js";
 import { column_getCanSort, column_getSortFn } from "./rowSortingFeature.utils.js";
 
@@ -7,89 +7,107 @@ import { column_getCanSort, column_getSortFn } from "./rowSortingFeature.utils.j
 * Creates a memoized sorted row model factory.
 *
 * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
+*
+* Register the sorting functions you use with the `sortFns` slot on the
+* `features` option:
+* `tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns: { alphanumeric: sortFn_alphanumeric } })`.
+* Importing individual `sortFn_*` functions keeps unused built-ins out of
+* your bundle; sorting functions passed directly to the `sortFn` column
+* option need no registration at all.
 */
-function createSortedRowModel(sortFns) {
+function createSortedRowModel() {
 	return (_table) => {
 		const table = _table;
-		if (!table._rowModelFns.sortFns) table._rowModelFns.sortFns = sortFns;
 		return tableMemo({
 			feature: "rowSortingFeature",
 			table,
 			fnName: "table.getSortedRowModel",
-			memoDeps: () => {
-				var _table$atoms$sorting;
-				return [(_table$atoms$sorting = table.atoms.sorting) === null || _table$atoms$sorting === void 0 ? void 0 : _table$atoms$sorting.get(), table.getPreSortedRowModel()];
-			},
+			memoDeps: () => [table.atoms.sorting?.get(), table.getPreSortedRowModel()],
 			fn: () => _createSortedRowModel(table),
 			onAfterUpdate: () => table_autoResetPageIndex(table)
 		});
 	};
 }
 function _createSortedRowModel(table) {
-	var _table$atoms$sorting2;
 	const preSortedRowModel = table.getPreSortedRowModel();
-	const sorting = (_table$atoms$sorting2 = table.atoms.sorting) === null || _table$atoms$sorting2 === void 0 ? void 0 : _table$atoms$sorting2.get();
-	if (!preSortedRowModel.rows.length || !(sorting === null || sorting === void 0 ? void 0 : sorting.length)) return preSortedRowModel;
+	const sorting = table.atoms.sorting?.get();
+	if (!preSortedRowModel.rows.length || !sorting?.length) return preSortedRowModel;
 	const sortedFlatRows = [];
-	const availableSorting = sorting.filter((sort) => column_getCanSort(table.getColumn(sort.id)));
-	const columnInfoById = {};
-	availableSorting.forEach((sortEntry) => {
+	const availableSorting = sorting.filter((sort) => {
+		const column = table.getColumn(sort.id);
+		return column ? column_getCanSort(column) : false;
+	});
+	if (!availableSorting.length) return preSortedRowModel;
+	const resolvedSorting = [];
+	for (let i = 0; i < availableSorting.length; i++) {
+		const sortEntry = availableSorting[i];
 		const column = table.getColumn(sortEntry.id);
-		if (!column) return;
-		columnInfoById[sortEntry.id] = {
+		if (!column) continue;
+		resolvedSorting.push({
+			id: sortEntry.id,
+			desc: sortEntry.desc,
 			sortUndefined: column.columnDef.sortUndefined,
 			invertSorting: column.columnDef.invertSorting,
 			sortFn: column_getSortFn(column)
-		};
-	});
-	const sortData = (rows) => {
-		const sortedData = rows.slice();
-		sortedData.sort((rowA, rowB) => {
-			for (let i = 0; i < availableSorting.length; i++) {
-				const sortEntry = availableSorting[i];
-				const columnInfo = columnInfoById[sortEntry.id];
-				const sortUndefined = columnInfo.sortUndefined;
-				const isDesc = sortEntry.desc;
-				let sortInt = 0;
-				if (sortUndefined) {
-					const aValue = rowA.getValue(sortEntry.id);
-					const bValue = rowB.getValue(sortEntry.id);
-					const aUndefined = aValue === void 0;
-					const bUndefined = bValue === void 0;
-					if (aUndefined || bUndefined) {
-						if (sortUndefined === "first") return aUndefined ? -1 : 1;
-						if (sortUndefined === "last") return aUndefined ? 1 : -1;
-						sortInt = aUndefined && bUndefined ? 0 : aUndefined ? sortUndefined : -sortUndefined;
-					}
-				}
-				if (sortInt === 0) sortInt = columnInfo.sortFn(rowA, rowB, sortEntry.id);
-				if (sortInt !== 0) {
-					if (isDesc) sortInt *= -1;
-					if (columnInfo.invertSorting) sortInt *= -1;
-					return sortInt;
+		});
+	}
+	const compareRows = (rowA, rowB) => {
+		for (let i = 0; i < resolvedSorting.length; i++) {
+			const sortEntry = resolvedSorting[i];
+			const sortUndefined = sortEntry.sortUndefined;
+			const isDesc = sortEntry.desc;
+			let sortInt = 0;
+			if (sortUndefined) {
+				const aValue = rowA.getValue(sortEntry.id);
+				const bValue = rowB.getValue(sortEntry.id);
+				const aUndefined = aValue === void 0;
+				const bUndefined = bValue === void 0;
+				if (aUndefined && bUndefined) continue;
+				if (aUndefined || bUndefined) {
+					if (sortUndefined === "first") return aUndefined ? -1 : 1;
+					if (sortUndefined === "last") return aUndefined ? 1 : -1;
+					sortInt = aUndefined ? sortUndefined : -sortUndefined;
 				}
 			}
-			return rowA.index - rowB.index;
-		});
+			if (sortInt === 0) sortInt = sortEntry.sortFn(rowA, rowB, sortEntry.id);
+			if (sortInt !== 0) {
+				if (isDesc) sortInt *= -1;
+				if (sortEntry.invertSorting) sortInt *= -1;
+				return sortInt;
+			}
+		}
+		return rowA.index - rowB.index;
+	};
+	const sortData = (rows) => {
+		const sortedData = rows.slice();
+		sortedData.sort(compareRows);
+		let changed = false;
 		for (let i = 0; i < sortedData.length; i++) {
 			const row = sortedData[i];
+			if (row !== rows[i]) changed = true;
 			if (row.subRows.length) {
-				const cloned = Object.create(Object.getPrototypeOf(row));
-				Object.assign(cloned, row);
-				cloned.subRows = sortData(row.subRows);
-				sortedData[i] = cloned;
-				sortedFlatRows.push(cloned);
+				const sortedSubRows = sortData(row.subRows);
+				if (sortedSubRows.changed) {
+					const cloned = Object.create(Object.getPrototypeOf(row));
+					copyInstancePropertiesWithoutMemos(cloned, row);
+					cloned.subRows = sortedSubRows.rows;
+					sortedData[i] = cloned;
+					sortedFlatRows.push(cloned);
+					changed = true;
+				} else sortedFlatRows.push(row);
 			} else sortedFlatRows.push(row);
 		}
-		return sortedData;
+		return {
+			rows: sortedData,
+			changed
+		};
 	};
 	return {
-		rows: sortData(preSortedRowModel.rows),
+		rows: sortData(preSortedRowModel.rows).rows,
 		flatRows: sortedFlatRows,
 		rowsById: preSortedRowModel.rowsById
 	};
 }
 
 //#endregion
-export { createSortedRowModel };
-//# sourceMappingURL=createSortedRowModel.js.map
+export { createSortedRowModel };

package/dist/features/row-sorting/rowSortingFeature.d.ts

@@ -1,10 +1,8 @@
 import { TableFeature } from "../../types/TableFeatures.js";
-
 //#region src/features/row-sorting/rowSortingFeature.d.ts
 /**
  * Feature that adds row sorting state, defaults, and column/table sorting APIs.
  */
 declare const rowSortingFeature: TableFeature;
 //#endregion
-export { rowSortingFeature };
-//# sourceMappingURL=rowSortingFeature.d.ts.map
+export { rowSortingFeature };

package/dist/features/row-sorting/rowSortingFeature.js

@@ -51,5 +51,4 @@ const rowSortingFeature = {
 };
 
 //#endregion
-export { rowSortingFeature };
-//# sourceMappingURL=rowSortingFeature.js.map
+export { rowSortingFeature };