@tanstack/table-core 9.0.0-beta.9 → 9.0.0

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,30 +42,37 @@ 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.
 *
 * Omitting `value` toggles based on `table_getIsAllRowsSelected(table)`.
-* Deselecting removes matching ids from the existing selection map.
+* Selecting skips sub-rows whose ancestors block descent via
+* `enableSubRowSelection`. Deselecting removes matching selectable ids from the
+* existing selection map; rows that cannot be selected keep their selection
+* unless `opts.deselectAll` is `true`.
 *
 * @example
 * ```ts
 * 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;
-		});
-		else preGroupedFlatRows.forEach((row) => {
-			delete rowSelection[row.id];
+		if (value) {
+			const subtreeCache = /* @__PURE__ */ new Map();
+			preGroupedFlatRows.forEach((row) => {
+				if (isRowSelectableInSelectAll(row, subtreeCache)) rowSelection[row.id] = true;
+			});
+		} else preGroupedFlatRows.forEach((row) => {
+			if (row_getCanSelect(row)) delete rowSelection[row.id];
 		});
 		return rowSelection;
 	});
@@ -82,12 +88,14 @@ 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);
+			mutateRowIsSelected(rowSelection, row.id, resolvedValue, true, table, true);
 		});
 		return rowSelection;
 	});
@@ -118,14 +126,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 +146,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,20 +166,31 @@ 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.
 *
 * The result is false when there are no filtered rows or when selection state is
-* empty.
+* empty. Sub-rows whose ancestors block descent via `enableSubRowSelection` are
+* ignored, matching the rows that `table_toggleAllRowsSelected` selects.
 *
 * @example
 * ```ts
@@ -181,19 +198,20 @@ 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;
+		const subtreeCache = /* @__PURE__ */ new Map();
+		if (preGroupedFlatRows.some((row) => !isRowSelected(row, rowSelection) && isRowSelectableInSelectAll(row, subtreeCache))) isAllRowsSelected = false;
 	}
 	return isAllRowsSelected;
 }
 /**
 * Checks whether every selectable row on the current page is selected.
 *
-* Non-selectable rows are ignored for this calculation.
+* Non-selectable rows are ignored for this calculation, as are sub-rows whose
+* ancestors block descent via `enableSubRowSelection`.
 *
 * @example
 * ```ts
@@ -201,18 +219,22 @@ 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()) ?? {};
-	let isAllPageRowsSelected = !!paginationFlatRows.length;
-	if (isAllPageRowsSelected && paginationFlatRows.some((row) => !rowSelection[row.id])) isAllPageRowsSelected = false;
-	return isAllPageRowsSelected;
+	const paginationFlatRows = table.getPaginatedRowModel().flatRows;
+	const rowSelection = table.atoms.rowSelection?.get() ?? {};
+	const subtreeCache = /* @__PURE__ */ new Map();
+	let sawSelectableRow = false;
+	for (let i = 0; i < paginationFlatRows.length; i++) {
+		const row = paginationFlatRows[i];
+		if (!isRowSelected(row, rowSelection)) {
+			if (isRowSelectableInSelectAll(row, subtreeCache)) return false;
+		} else if (!sawSelectableRow && isRowSelectableInSelectAll(row, subtreeCache)) sawSelectableRow = true;
+	}
+	return sawSelectableRow;
 }
 /**
-* 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 +242,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 +253,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 +291,27 @@ 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. Pass `deselectParents: true` to also remove
+* ancestor row ids from the selection when this row is deselected.
 *
 * @example
 * ```ts
 * row_toggleSelected(row)
+* row_toggleSelected(row, true)
+* row_toggleSelected(row, false)
+* row_toggleSelected(row, true, { selectChildren: false })
+* row_toggleSelected(row, false, { deselectParents: true })
 * ```
 */
 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);
+		if (!value && opts?.deselectParents) pruneAncestorRowIds(rowSelection, row);
+		return rowSelection;
 	});
 }
 /**
@@ -303,7 +325,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 +405,139 @@ 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, and `deselectParents: true` to remove ancestor row
+* ids from the selection when rows are deselected.
 *
 * @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)) 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, opts) {
+	const includeChildren = opts?.selectChildren ?? true;
+	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);
+			if (!value && opts?.deselectParents) pruneAncestorRowIds(rowSelection, rangeRow);
+		}
+		return rowSelection;
+	});
+	return true;
+}
+function mutateRowIsSelected(rowSelection, rowId, value, includeChildren, table, respectCanSelectOnDeselect) {
 	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 if (!respectCanSelectOnDeselect || row_getCanSelect(row)) delete rowSelection[rowId];
+	if (includeChildren && row.subRows.length && row_getCanSelectSubRows(row)) row.subRows.forEach((r) => mutateRowIsSelected(rowSelection, r.id, value, includeChildren, table, respectCanSelectOnDeselect));
+}
+/**
+* Returns whether a select-all cascade can reach this row: the row itself is
+* selectable and no ancestor blocks descent via `enableSubRowSelection`.
+*
+* `subtreeCache` memoizes the per-ancestor verdict for one select-all pass, so
+* ancestor chains shared by sibling rows are only walked (and the
+* `enableSubRowSelection` predicate only invoked) once per unique ancestor.
+*/
+function isRowSelectableInSelectAll(row, subtreeCache) {
+	if (!row_getCanSelect(row)) return false;
+	const table = row.table;
+	if (table.options.enableSubRowSelection === true) return true;
+	const parentId = row.parentId;
+	if (parentId === void 0) return true;
+	const cached = subtreeCache.get(parentId);
+	if (cached !== void 0) return cached;
+	const rowsById = table.getCoreRowModel().rowsById;
+	const visited = [];
+	let selectable = true;
+	let currentId = parentId;
+	while (currentId !== void 0) {
+		const known = subtreeCache.get(currentId);
+		if (known !== void 0) {
+			selectable = known;
+			break;
+		}
+		visited.push(currentId);
+		const parent = rowsById[currentId] ?? table.getRow(currentId, true);
+		if (!row_getCanSelectSubRows(parent)) {
+			selectable = false;
+			break;
+		}
+		currentId = parent.parentId;
+	}
+	visited.forEach((id) => subtreeCache.set(id, selectable));
+	return selectable;
+}
+function pruneAncestorRowIds(rowSelection, row) {
+	const rowsById = row.table.getCoreRowModel().rowsById;
+	let parentId = row.parentId;
+	while (parentId !== void 0) {
+		delete rowSelection[parentId];
+		parentId = (rowsById[parentId] ?? row.table.getRow(parentId, true)).parentId;
+	}
+}
+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,32 +549,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++) {
-			const row = rows[i];
-			const isSelected = isRowSelected(row);
-			if (isSelected) {
-				newSelectedFlatRows.push(row);
-				newSelectedRowsById[row.id] = row;
-			}
-			if (row.subRows.length) {
-				const newSubRows = recurseRows(row.subRows, depth + 1);
-				if (isSelected) {
-					const cloned = Object.create(Object.getPrototypeOf(row));
-					Object.assign(cloned, row);
-					cloned.subRows = newSubRows;
-					result.push(cloned);
-				}
-			} else 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
 	};
@@ -454,9 +567,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.
@@ -470,24 +582,33 @@ 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;
-		else allChildrenSelected = false;
+	let allChildrenSelected = true;
+	let someSelectable = false;
+	for (let i = 0; i < row.subRows.length; i++) {
+		const subRow = row.subRows[i];
+		if (someSelected && !allChildrenSelected) break;
+		if (row_getCanSelect(subRow)) {
+			someSelectable = true;
+			if (isRowSelected(subRow, rowSelection)) someSelected = true;
+			else allChildrenSelected = false;
+		}
 		if (subRow.subRows.length) {
 			const subRowChildrenSelected = isSubRowSelected(subRow);
-			if (subRowChildrenSelected === "all") someSelected = true;
-			else if (subRowChildrenSelected === "some") {
+			if (subRowChildrenSelected === "all") {
+				someSelected = true;
+				someSelectable = true;
+			} else if (subRowChildrenSelected === "some") {
 				someSelected = true;
 				allChildrenSelected = false;
+				someSelectable = true;
 			} else allChildrenSelected = false;
 		}
-	});
+	}
+	if (!someSelectable) return 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 };