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

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

@@ -1,10 +1,8 @@
-import { OnChangeFn, RowData, Updater } from "../../types/type-utils.js";
-import { BuiltInSortFn } from "../../fns/sortFns.js";
+import { OnChangeFn, RowData, TransformDataValueFn, Updater } from "../../types/type-utils.js";
+import { BuiltInSortFn } from "./sortFns.js";
 import { Row } from "../../types/Row.js";
-import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table } from "../../types/Table.js";
 import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
-
+import { IsAny, TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/row-sorting/rowSortingFeature.types.d.ts
 type SortDirection = 'asc' | 'desc';
 interface ColumnSort {
@@ -15,16 +13,57 @@ type SortingState = Array<ColumnSort>;
 interface TableState_RowSorting {
   sorting: SortingState;
 }
-interface RowModelFns_RowSorting<TFeatures extends TableFeatures, TData extends RowData> {
-  sortFns: Record<keyof SortFns, SortFn<TFeatures, TData>>;
+interface RowModelFns_RowSorting<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  sortFns: Record<string, SortFn<TFeatures, TData>>;
 }
 interface SortFns {}
-interface SortFn<TFeatures extends TableFeatures, TData extends RowData> {
+interface SortFn<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   (rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string): number;
+  /**
+   * Normalizes each row's value before the two sides are compared. Only
+   * honored by sorting functions built with `constructSortFn` (including all
+   * built-in sorting functions).
+   */
+  resolveDataValue?: TransformDataValueFn;
+}
+/**
+ * The definition object accepted by `constructSortFn`.
+ *
+ * `sort` is a value-level comparator: it receives both rows' (resolved) data
+ * values instead of the whole rows, so normalization concerns stay in
+ * `resolveDataValue`.
+ */
+interface SortFnDef<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  sort: (dataValueA: any, dataValueB: any, rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
+  resolveDataValue?: TransformDataValueFn;
+}
+/**
+ * The shape returned by `constructSortFn`: a `SortFn` with its definition
+ * attached, so variants can be built by spreading it into another
+ * `constructSortFn` call.
+ *
+ * The call signature is generic so a created sorting function can be used
+ * with any table's rows, regardless of the feature set it was defined
+ * against.
+ */
+interface CreatedSortFn<in out TFeatures extends TableFeatures, in out TData extends RowData> extends SortFnDef<TFeatures, TData> {
+  <TRowFeatures extends TableFeatures, TRowData extends RowData>(rowA: Row<TRowFeatures, TRowData>, rowB: Row<TRowFeatures, TRowData>, columnId: string): number;
 }
 type CustomSortFns<TFeatures extends TableFeatures, TData extends RowData> = Record<string, SortFn<TFeatures, TData>>;
-type SortFnOption<TFeatures extends TableFeatures, TData extends RowData> = 'auto' | keyof SortFns | BuiltInSortFn | SortFn<TFeatures, TData>;
-interface ColumnDef_RowSorting<TFeatures extends TableFeatures, TData extends RowData> {
+/**
+ * Resolves the valid string names for `columnDef.sortFn` for a feature set.
+ *
+ * When the features object declares a `sortFns` registry
+ * (`tableFeatures({ ..., sortFns })`), its keys are the only valid names; a
+ * name is only assignable if a sorting function is actually registered for it.
+ * Otherwise this falls back to the global declaration-merged `SortFns`
+ * interface.
+ */
+type ExtractSortFnKeys<TFeatures extends TableFeatures> = IsAny<TFeatures> extends true ? keyof SortFns | BuiltInSortFn : TFeatures extends {
+  sortFns: infer TSortFns extends object;
+} ? Extract<keyof TSortFns, string> : keyof SortFns;
+type SortFnOption<TFeatures extends TableFeatures, TData extends RowData> = 'auto' | ExtractSortFnKeys<TFeatures> | SortFn<TFeatures, TData>;
+interface ColumnDef_RowSorting<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   /**
    * Enables/Disables multi-sorting for this column.
    */
@@ -58,7 +97,7 @@ interface ColumnDef_RowSorting<TFeatures extends TableFeatures, TData extends Ro
    */
   sortUndefined?: false | -1 | 1 | 'first' | 'last';
 }
-interface Column_RowSorting<TFeatures extends TableFeatures, TData extends RowData> {
+interface Column_RowSorting<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   /**
    * Removes this column from the table's sorting state
    */
@@ -109,6 +148,13 @@ interface Column_RowSorting<TFeatures extends TableFeatures, TData extends RowDa
   toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
 }
 interface TableOptions_RowSorting {
+  /**
+   * Resets sorting to its initial state when the `data` option changes.
+   *
+   * This is disabled by default. `autoResetAll` overrides this option when it
+   * is explicitly set.
+   */
+  autoResetSorting?: boolean;
   /**
    * Allows multi-sort toggles to remove a column from sorting state.
    */
@@ -150,7 +196,7 @@ interface TableOptions_RowSorting {
    */
   sortDescFirst?: boolean;
 }
-interface Table_RowSorting<TFeatures extends TableFeatures, TData extends RowData> {
+interface Table_RowSorting<in out _TFeatures extends TableFeatures, in out _TData extends RowData> {
   /**
    * Resets `sorting` to `initialState.sorting`.
    *
@@ -162,7 +208,7 @@ interface Table_RowSorting<TFeatures extends TableFeatures, TData extends RowDat
    */
   setSorting: (updater: Updater<SortingState>) => void;
 }
-interface Table_RowModels_Sorted<TFeatures extends TableFeatures, TData extends RowData> {
+interface Table_RowModels_Sorted<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   /**
    * Reads the row model immediately before sorting.
    */
@@ -172,17 +218,8 @@ interface Table_RowModels_Sorted<TFeatures extends TableFeatures, TData extends
    */
   getSortedRowModel: () => RowModel<TFeatures, TData>;
 }
-interface CreateRowModel_Sorted<TFeatures extends TableFeatures, TData extends RowData> {
-  /**
-   * Factory used to retrieve the sorted row model. If using server-side
-   * sorting, this is not required. To use client-side sorting, pass the
-   * exported `createSortedRowModel()` or implement your own factory.
-   */
-  sortedRowModel?: (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
-}
-interface CachedRowModel_Sorted<TFeatures extends TableFeatures, TData extends RowData> {
+interface CachedRowModel_Sorted<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   sortedRowModel: () => RowModel<TFeatures, TData>;
 }
 //#endregion
-export { CachedRowModel_Sorted, ColumnDef_RowSorting, ColumnSort, Column_RowSorting, CreateRowModel_Sorted, CustomSortFns, RowModelFns_RowSorting, SortDirection, SortFn, SortFnOption, SortFns, SortingState, TableOptions_RowSorting, TableState_RowSorting, Table_RowModels_Sorted, Table_RowSorting };
-//# sourceMappingURL=rowSortingFeature.types.d.ts.map
+export { CachedRowModel_Sorted, ColumnDef_RowSorting, ColumnSort, Column_RowSorting, CreatedSortFn, CustomSortFns, ExtractSortFnKeys, RowModelFns_RowSorting, SortDirection, SortFn, SortFnDef, SortFnOption, SortFns, SortingState, TableOptions_RowSorting, TableState_RowSorting, Table_RowModels_Sorted, Table_RowSorting };

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

@@ -1,9 +1,8 @@
 import { CellData, RowData, Updater } from "../../types/type-utils.js";
 import { SortDirection, SortFn, SortingState } from "./rowSortingFeature.types.js";
-import { Column_Internal } from "../../types/Column.js";
+import { Column } from "../../types/Column.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table_Internal } from "../../types/Table.js";
-
 //#region src/features/row-sorting/rowSortingFeature.utils.d.ts
 /**
  * Creates the default sorting state.
@@ -28,7 +27,7 @@ declare function getDefaultSortingState(): SortingState;
  * table_setSorting(table, (old) => [...old, { id: 'age', desc: true }])
  * ```
  */
-declare function table_setSorting<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<SortingState>): void;
+declare function table_setSorting<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, updater: Updater<SortingState>): void;
 /**
  * Resets `sorting` to the configured initial state or feature default.
  *
@@ -41,7 +40,19 @@ declare function table_setSorting<TFeatures extends TableFeatures, TData extends
  * table_resetSorting(table, true)
  * ```
  */
-declare function table_resetSorting<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
+declare function table_resetSorting<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, defaultState?: boolean): void;
+/**
+ * Resets sorting after the table data changes when explicitly enabled.
+ *
+ * Unlike other auto-reset behaviors, sorting is preserved by default. An
+ * explicit `autoResetAll` value takes precedence over `autoResetSorting`.
+ *
+ * @example
+ * ```ts
+ * table_autoResetSorting(table)
+ * ```
+ */
+declare function table_autoResetSorting<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): void;
 /**
  * Chooses a built-in sorting function from sampled filtered row values.
  *
@@ -54,7 +65,7 @@ declare function table_resetSorting<TFeatures extends TableFeatures, TData exten
  * const sortFn = column_getAutoSortFn(column)
  * ```
  */
-declare function column_getAutoSortFn<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): SortFn<TFeatures, TData>;
+declare function column_getAutoSortFn<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): SortFn<TFeatures, TData>;
 /**
  * Chooses the default first sort direction from the first filtered row value.
  *
@@ -66,7 +77,7 @@ declare function column_getAutoSortFn<TFeatures extends TableFeatures, TData ext
  * const direction = column_getAutoSortDir(column)
  * ```
  */
-declare function column_getAutoSortDir<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): "asc" | "desc";
+declare function column_getAutoSortDir<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): "asc" | "desc";
 /**
  * Resolves the sorting function configured for a column.
  *
@@ -79,7 +90,7 @@ declare function column_getAutoSortDir<TFeatures extends TableFeatures, TData ex
  * const sortFn = column_getSortFn(column)
  * ```
  */
-declare function column_getSortFn<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): SortFn<TFeatures, TData>;
+declare function column_getSortFn<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): SortFn<TFeatures, TData>;
 /**
  * Applies the next sorting state for this column.
  *
@@ -92,7 +103,7 @@ declare function column_getSortFn<TFeatures extends TableFeatures, TData extends
  * column_toggleSorting(column, undefined, true)
  * ```
  */
-declare function column_toggleSorting<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>, desc?: boolean, multi?: boolean): void;
+declare function column_toggleSorting<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>, desc?: boolean, multi?: boolean): void;
 /**
  * Resolves the first direction used when this column begins sorting.
  *
@@ -104,7 +115,7 @@ declare function column_toggleSorting<TFeatures extends TableFeatures, TData ext
  * const firstDirection = column_getFirstSortDir(column)
  * ```
  */
-declare function column_getFirstSortDir<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): "asc" | "desc";
+declare function column_getFirstSortDir<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): "asc" | "desc";
 /**
  * Resolves the next sort order for this column's toggle cycle.
  *
@@ -116,7 +127,7 @@ declare function column_getFirstSortDir<TFeatures extends TableFeatures, TData e
  * const nextOrder = column_getNextSortingOrder(column)
  * ```
  */
-declare function column_getNextSortingOrder<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>, multi?: boolean): false | "asc" | "desc";
+declare function column_getNextSortingOrder<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>, multi?: boolean): false | "asc" | "desc";
 /**
  * Checks whether this accessor column can participate in sorting.
  *
@@ -128,7 +139,7 @@ declare function column_getNextSortingOrder<TFeatures extends TableFeatures, TDa
  * const canSort = column_getCanSort(column)
  * ```
  */
-declare function column_getCanSort<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
+declare function column_getCanSort<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): boolean;
 /**
  * Checks whether this column can be added to a multi-sort state.
  *
@@ -140,7 +151,7 @@ declare function column_getCanSort<TFeatures extends TableFeatures, TData extend
  * const canMultiSort = column_getCanMultiSort(column)
  * ```
  */
-declare function column_getCanMultiSort<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
+declare function column_getCanMultiSort<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): boolean;
 /**
  * Reads this column's current sort direction.
  *
@@ -152,7 +163,7 @@ declare function column_getCanMultiSort<TFeatures extends TableFeatures, TData e
  * const direction = column_getIsSorted(column)
  * ```
  */
-declare function column_getIsSorted<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): false | SortDirection;
+declare function column_getIsSorted<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): false | SortDirection;
 /**
  * Finds this column's position in the ordered `state.sorting` array.
  *
@@ -163,7 +174,7 @@ declare function column_getIsSorted<TFeatures extends TableFeatures, TData exten
  * const index = column_getSortIndex(column)
  * ```
  */
-declare function column_getSortIndex<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): number;
+declare function column_getSortIndex<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): number;
 /**
  * Removes this column from the sorting state.
  *
@@ -174,20 +185,18 @@ declare function column_getSortIndex<TFeatures extends TableFeatures, TData exte
  * column_clearSorting(column)
  * ```
  */
-declare function column_clearSorting<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): void;
+declare function column_clearSorting<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): void;
 /**
  * Creates a header event handler that toggles this column's sorting.
  *
- * The handler ignores events when the column cannot sort, persists React-style
- * synthetic events when present, and asks `options.isMultiSortEvent` whether
- * the event should add to a multi-sort.
+ * The handler ignores events when the column cannot sort, and asks
+ * `options.isMultiSortEvent` whether the event should add to a multi-sort.
  *
  * @example
  * ```ts
  * const onClick = column_getToggleSortingHandler(column)
  * ```
  */
-declare function column_getToggleSortingHandler<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): (e: unknown) => void;
+declare function column_getToggleSortingHandler<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): (e: unknown) => void;
 //#endregion
-export { column_clearSorting, column_getAutoSortDir, column_getAutoSortFn, column_getCanMultiSort, column_getCanSort, column_getFirstSortDir, column_getIsSorted, column_getNextSortingOrder, column_getSortFn, column_getSortIndex, column_getToggleSortingHandler, column_toggleSorting, getDefaultSortingState, table_resetSorting, table_setSorting };
-//# sourceMappingURL=rowSortingFeature.utils.d.ts.map
+export { column_clearSorting, column_getAutoSortDir, column_getAutoSortFn, column_getCanMultiSort, column_getCanSort, column_getFirstSortDir, column_getIsSorted, column_getNextSortingOrder, column_getSortFn, column_getSortIndex, column_getToggleSortingHandler, column_toggleSorting, getDefaultSortingState, table_autoResetSorting, table_resetSorting, table_setSorting };

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

@@ -1,5 +1,5 @@
 import { cloneState, isFunction } from "../../utils.js";
-import { reSplitAlphaNumeric, sortFn_basic } from "../../fns/sortFns.js";
+import { reSplitAlphaNumeric, sortFn_basic } from "./sortFns.js";
 
 //#region src/features/row-sorting/rowSortingFeature.utils.ts
 /**
@@ -28,8 +28,7 @@ function getDefaultSortingState() {
 * ```
 */
 function table_setSorting(table, updater) {
-	var _table$options$onSort, _table$options;
-	(_table$options$onSort = (_table$options = table.options).onSortingChange) === null || _table$options$onSort === void 0 || _table$options$onSort.call(_table$options, updater);
+	table.options.onSortingChange?.(updater);
 }
 /**
 * Resets `sorting` to the configured initial state or feature default.
@@ -47,6 +46,21 @@ function table_resetSorting(table, defaultState) {
 	table_setSorting(table, defaultState ? [] : cloneState(table.initialState.sorting ?? []));
 }
 /**
+* Resets sorting after the table data changes when explicitly enabled.
+*
+* Unlike other auto-reset behaviors, sorting is preserved by default. An
+* explicit `autoResetAll` value takes precedence over `autoResetSorting`.
+*
+* @example
+* ```ts
+* table_autoResetSorting(table)
+* ```
+*/
+function table_autoResetSorting(table) {
+	if (!table.atoms.sorting) return;
+	if (table.options.autoResetAll ?? table.options.autoResetSorting ?? false) table_resetSorting(table);
+}
+/**
 * Chooses a built-in sorting function from sampled filtered row values.
 *
 * Date-like values use `datetime`, mixed text/numeric strings use
@@ -61,20 +75,31 @@ function table_resetSorting(table, defaultState) {
 function column_getAutoSortFn(column) {
 	const sortFns = column.table._rowModelFns.sortFns;
 	const firstRows = column.table.getFilteredRowModel().flatRows.slice(0, 10);
+	let sortFnName;
 	let isString = false;
 	for (let i = 0; i < firstRows.length; i++) {
 		const value = firstRows[i].getValue(column.id);
 		if (Object.prototype.toString.call(value) === "[object Date]") {
-			if (sortFns === null || sortFns === void 0 ? void 0 : sortFns.datetime) return sortFns.datetime;
+			sortFnName = "datetime";
+			break;
 		}
 		if (typeof value === "string") {
 			isString = true;
 			if (value.split(reSplitAlphaNumeric).length > 1) {
-				if (sortFns === null || sortFns === void 0 ? void 0 : sortFns.alphanumeric) return sortFns.alphanumeric;
+				sortFnName = "alphanumeric";
+				break;
 			}
 		}
 	}
-	if (isString) return (sortFns === null || sortFns === void 0 ? void 0 : sortFns.text) ?? sortFn_basic;
+	if (!sortFnName && isString) sortFnName = "text";
+	if (sortFnName) {
+		let sortFn = sortFns?.[sortFnName];
+		if (!sortFn) {
+			if (process.env.NODE_ENV === "development") console.warn(`sortFn '${sortFnName}' (auto) for column '${column.id}' is not registered`);
+			if (sortFnName === "alphanumeric") sortFn = sortFns?.text;
+		}
+		if (sortFn) return sortFn;
+	}
 	return sortFn_basic;
 }
 /**
@@ -107,7 +132,11 @@ function column_getAutoSortDir(column) {
 */
 function column_getSortFn(column) {
 	const sortFns = column.table._rowModelFns.sortFns;
-	return isFunction(column.columnDef.sortFn) ? column.columnDef.sortFn : column.columnDef.sortFn === "auto" ? column_getAutoSortFn(column) : (sortFns === null || sortFns === void 0 ? void 0 : sortFns[column.columnDef.sortFn]) ?? sortFn_basic;
+	if (isFunction(column.columnDef.sortFn)) return column.columnDef.sortFn;
+	if (column.columnDef.sortFn === "auto") return column_getAutoSortFn(column);
+	const sortFn = sortFns?.[column.columnDef.sortFn];
+	if (process.env.NODE_ENV === "development" && !sortFn) console.warn(`sortFn '${String(column.columnDef.sortFn)}' for column '${column.id}' is not registered`);
+	return sortFn ?? sortFn_basic;
 }
 /**
 * Applies the next sorting state for this column.
@@ -125,14 +154,14 @@ function column_toggleSorting(column, desc, multi) {
 	const nextSortingOrder = column_getNextSortingOrder(column);
 	const hasManualValue = typeof desc !== "undefined";
 	table_setSorting(column.table, (old) => {
-		const existingSorting = old.find((d) => d.id === column.id);
 		const existingIndex = old.findIndex((d) => d.id === column.id);
+		const existingSorting = existingIndex === -1 ? void 0 : old[existingIndex];
 		let newSorting = [];
 		let sortAction;
 		const nextDesc = hasManualValue ? desc : nextSortingOrder === "desc";
-		if (old.length && column_getCanMultiSort(column) && multi) if (existingSorting) sortAction = "toggle";
+		const isMultiMode = !!(old.length && column_getCanMultiSort(column) && multi);
+		if (isMultiMode) if (existingSorting) sortAction = "toggle";
 		else sortAction = "add";
-		else if (old.length && existingIndex !== old.length - 1) sortAction = "replace";
 		else if (existingSorting) sortAction = "toggle";
 		else sortAction = "replace";
 		if (sortAction === "toggle") {
@@ -146,14 +175,17 @@ function column_toggleSorting(column, desc, multi) {
 				desc: nextDesc
 			}];
 			newSorting.splice(0, newSorting.length - (column.table.options.maxMultiSortColCount ?? Number.MAX_SAFE_INTEGER));
-		} else if (sortAction === "toggle") newSorting = old.map((d) => {
+		} else if (sortAction === "toggle") newSorting = isMultiMode ? old.map((d) => {
 			if (d.id === column.id) return {
 				...d,
 				desc: nextDesc
 			};
 			return d;
-		});
-		else if (sortAction === "remove") newSorting = old.filter((d) => d.id !== column.id);
+		}) : [{
+			id: column.id,
+			desc: nextDesc
+		}];
+		else if (sortAction === "remove") newSorting = isMultiMode ? old.filter((d) => d.id !== column.id) : [];
 		else newSorting = [{
 			id: column.id,
 			desc: nextDesc
@@ -233,8 +265,7 @@ function column_getCanMultiSort(column) {
 * ```
 */
 function column_getIsSorted(column) {
-	var _column$table$atoms$s;
-	const columnSort = (_column$table$atoms$s = column.table.atoms.sorting) === null || _column$table$atoms$s === void 0 || (_column$table$atoms$s = _column$table$atoms$s.get()) === null || _column$table$atoms$s === void 0 ? void 0 : _column$table$atoms$s.find((d) => d.id === column.id);
+	const columnSort = column.table.atoms.sorting?.get()?.find((d) => d.id === column.id);
 	return !columnSort ? false : columnSort.desc ? "desc" : "asc";
 }
 /**
@@ -248,8 +279,7 @@ function column_getIsSorted(column) {
 * ```
 */
 function column_getSortIndex(column) {
-	var _column$table$atoms$s2;
-	return ((_column$table$atoms$s2 = column.table.atoms.sorting) === null || _column$table$atoms$s2 === void 0 || (_column$table$atoms$s2 = _column$table$atoms$s2.get()) === null || _column$table$atoms$s2 === void 0 ? void 0 : _column$table$atoms$s2.findIndex((d) => d.id === column.id)) ?? -1;
+	return column.table.atoms.sorting?.get()?.findIndex((d) => d.id === column.id) ?? -1;
 }
 /**
 * Removes this column from the sorting state.
@@ -267,9 +297,8 @@ function column_clearSorting(column) {
 /**
 * Creates a header event handler that toggles this column's sorting.
 *
-* The handler ignores events when the column cannot sort, persists React-style
-* synthetic events when present, and asks `options.isMultiSortEvent` whether
-* the event should add to a multi-sort.
+* The handler ignores events when the column cannot sort, and asks
+* `options.isMultiSortEvent` whether the event should add to a multi-sort.
 *
 * @example
 * ```ts
@@ -279,13 +308,10 @@ function column_clearSorting(column) {
 function column_getToggleSortingHandler(column) {
 	const canSort = column_getCanSort(column);
 	return (e) => {
-		var _persist, _column$table$options, _column$table$options2;
 		if (!canSort) return;
-		(_persist = e.persist) === null || _persist === void 0 || _persist.call(e);
-		column_toggleSorting(column, void 0, column_getCanMultiSort(column) ? (_column$table$options = (_column$table$options2 = column.table.options).isMultiSortEvent) === null || _column$table$options === void 0 ? void 0 : _column$table$options.call(_column$table$options2, e) : false);
+		column_toggleSorting(column, void 0, column_getCanMultiSort(column) ? column.table.options.isMultiSortEvent?.(e) : false);
 	};
 }
 
 //#endregion
-export { column_clearSorting, column_getAutoSortDir, column_getAutoSortFn, column_getCanMultiSort, column_getCanSort, column_getFirstSortDir, column_getIsSorted, column_getNextSortingOrder, column_getSortFn, column_getSortIndex, column_getToggleSortingHandler, column_toggleSorting, getDefaultSortingState, table_resetSorting, table_setSorting };
-//# sourceMappingURL=rowSortingFeature.utils.js.map
+export { column_clearSorting, column_getAutoSortDir, column_getAutoSortFn, column_getCanMultiSort, column_getCanSort, column_getFirstSortDir, column_getIsSorted, column_getNextSortingOrder, column_getSortFn, column_getSortIndex, column_getToggleSortingHandler, column_toggleSorting, getDefaultSortingState, table_autoResetSorting, table_resetSorting, table_setSorting };

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

@@ -0,0 +1,96 @@
+import { RowData } from "../../types/type-utils.js";
+import { CreatedSortFn, SortFnDef } from "./rowSortingFeature.types.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+//#region src/features/row-sorting/sortFns.d.ts
+/**
+ * Regular expression used to split mixed text and numeric chunks.
+ *
+ * The alphanumeric sort functions use these chunks for natural sorting of
+ * strings like `item2` before `item10`.
+ */
+declare const reSplitAlphaNumeric: RegExp;
+/**
+ * Builds a `SortFn` from a value-level comparator plus an optional
+ * `resolveDataValue` normalizer.
+ *
+ * The `sort` comparator receives both rows' data values, each already passed
+ * through `resolveDataValue` when one is defined. Keeping normalization in the
+ * resolver means a variant of an existing sorting function only has to swap
+ * the resolver, not re-implement the comparison.
+ *
+ * The definition is attached to the returned function, so a variant can be
+ * created by spreading a built-in sorting function and overriding what
+ * differs:
+ *
+ * ```ts
+ * const stripDiacritics = (value: string) =>
+ *   value.normalize('NFD').replace(/\p{Diacritic}/gu, '')
+ *
+ * const alphanumericIgnoreDiacritics = constructSortFn({
+ *   ...sortFn_alphanumeric,
+ *   resolveDataValue: (value) =>
+ *     stripDiacritics(sortFn_alphanumeric.resolveDataValue!(value)),
+ * })
+ * ```
+ */
+declare function constructSortFn<TFeatures extends TableFeatures = any, TData extends RowData = any>(def: SortFnDef<TFeatures, TData>): CreatedSortFn<TFeatures, TData>;
+/**
+ * Sorts rows with the built-in alphanumeric strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+declare const sortFn_alphanumeric: CreatedSortFn<any, any>;
+/**
+ * Sorts rows with the built-in alphanumeric case sensitive strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+declare const sortFn_alphanumericCaseSensitive: CreatedSortFn<any, any>;
+/**
+ * Sorts rows with the built-in text strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+declare const sortFn_text: CreatedSortFn<any, any>;
+/**
+ * Sorts rows with the built-in text case sensitive strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+declare const sortFn_textCaseSensitive: CreatedSortFn<any, any>;
+/**
+ * Sorts rows with the built-in datetime strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+declare const sortFn_datetime: CreatedSortFn<any, any>;
+/**
+ * Sorts rows with the built-in basic strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+declare const sortFn_basic: CreatedSortFn<any, any>;
+/**
+ * The built-in sorting function registry.
+ *
+ * Registering this full object opts out of tree-shaking: every built-in
+ * sorting function ends up in your bundle. Prefer importing the `sortFn_*`
+ * functions you actually use and registering just those in the `sortFns`
+ * slot, or passing them directly to the `sortFn` column option.
+ *
+ * @deprecated Import individual `sortFn_*` functions instead for a smaller
+ * bundle. This export still works and is not going away in v9, but built-in
+ * name resolution (including `sortFn: 'auto'`) only finds functions you
+ * register yourself.
+ */
+declare const sortFns: {
+  alphanumeric: CreatedSortFn<any, any>;
+  alphanumericCaseSensitive: CreatedSortFn<any, any>;
+  basic: CreatedSortFn<any, any>;
+  datetime: CreatedSortFn<any, any>;
+  text: CreatedSortFn<any, any>;
+  textCaseSensitive: CreatedSortFn<any, any>;
+};
+type BuiltInSortFn = keyof typeof sortFns;
+//#endregion
+export { BuiltInSortFn, constructSortFn, reSplitAlphaNumeric, sortFn_alphanumeric, sortFn_alphanumericCaseSensitive, sortFn_basic, sortFn_datetime, sortFn_text, sortFn_textCaseSensitive, sortFns };