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

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

@@ -1,4 +1,4 @@
-import { tableMemo } from "../../utils.js";
+import { copyInstancePropertiesWithoutMemos, skipFirstRun, 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)
+			onAfterUpdate: skipFirstRun(() => 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

@@ -20,6 +20,7 @@ const rowSortingFeature = {
 	},
 	getDefaultTableOptions(table) {
 		return {
+			autoResetSorting: false,
 			onSortingChange: makeStateUpdater("sorting", table),
 			isMultiSortEvent: (e) => {
 				return e.shiftKey;
@@ -51,5 +52,4 @@ const rowSortingFeature = {
 };
 
 //#endregion
-export { rowSortingFeature };
-//# sourceMappingURL=rowSortingFeature.js.map
+export { rowSortingFeature };

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.
    */
@@ -34,7 +73,7 @@ interface ColumnDef_RowSorting<TFeatures extends TableFeatures, TData extends Ro
    */
   enableSorting?: boolean;
   /**
-   * Inverts the order of the sorting for this column. This is useful for values that have an inverted best/worst scale where lower numbers are better, eg. a ranking (1st, 2nd, 3rd) or golf-like scoring
+   * Inverts the order of the sorting for this column. This is useful for values that have an inverted best/worst scale where lower numbers are better, e.g. a ranking (1st, 2nd, 3rd) or golf-like scoring
    */
   invertSorting?: boolean;
   /**
@@ -50,15 +89,19 @@ interface ColumnDef_RowSorting<TFeatures extends TableFeatures, TData extends Ro
   /**
    * The priority of undefined values when sorting this column.
    * - `false`
-   *   - Undefined values will be considered tied and need to be sorted by the next column filter or original index (whichever applies)
+   *   - Undefined values will be passed to the sorting function like any other value with no special handling; the sorting function is responsible for handling them
    * - `-1`
    *   - Undefined values will be sorted with higher priority (ascending) (if ascending, undefined will appear on the beginning of the list)
    * - `1`
    *   - Undefined values will be sorted with lower priority (descending) (if ascending, undefined will appear on the end of the list)
+   * - `'first'`
+   *   - Undefined values will be pushed to the beginning of the list regardless of sort direction
+   * - `'last'`
+   *   - Undefined values will be pushed to the end of the list regardless of sort direction
    */
   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
    */
@@ -88,9 +131,11 @@ interface Column_RowSorting<TFeatures extends TableFeatures, TData extends RowDa
    */
   getIsSorted: () => false | SortDirection;
   /**
-   * Returns the next sorting order.
+   * Returns the next sorting order. Pass `multi` to resolve the order for a
+   * multi-sort toggle, where `enableMultiRemove` governs whether the cycle can
+   * remove the sort.
    */
-  getNextSortingOrder: () => SortDirection | false;
+  getNextSortingOrder: (multi?: boolean) => SortDirection | false;
   /**
    * Finds this column's position in the ordered sorting state.
    */
@@ -104,11 +149,18 @@ interface Column_RowSorting<TFeatures extends TableFeatures, TData extends RowDa
    */
   getToggleSortingHandler: () => undefined | ((event: unknown) => void);
   /**
-   * Toggles this columns sorting state. If `desc` is provided, it will force the sort direction to that value. If `isMulti` is provided, it will additivity multi-sort the column (or toggle it if it is already sorted).
+   * Toggles this column's sorting state. If `desc` is provided, it will force the sort direction to that value. If `isMulti` is provided, it will additively multi-sort the column (or toggle it if it is already sorted).
    */
   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.
    */
@@ -123,8 +175,8 @@ interface TableOptions_RowSorting {
   enableSorting?: boolean;
   /**
    * Enables/Disables the ability to remove sorting for the table.
-   * - If `true` then changing sort order will circle like: 'none' -> 'desc' -> 'asc' -> 'none' -> ...
-   * - If `false` then changing sort order will circle like: 'none' -> 'desc' -> 'asc' -> 'desc' -> 'asc' -> ...
+   * - If `true` then changing sort order will cycle like: 'none' -> 'desc' -> 'asc' -> 'none' -> ...
+   * - If `false` then changing sort order will cycle like: 'none' -> 'desc' -> 'asc' -> 'desc' -> 'asc' -> ...
    */
   enableSortingRemoval?: boolean;
   /**
@@ -150,7 +202,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 +214,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 +224,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,19 +65,22 @@ 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.
+ * Chooses the default first sort direction from sampled filtered row values.
  *
- * String columns start ascending so alphabetical order is natural; other value
- * types start descending.
+ * The first non-nullish value among the sampled rows decides: string columns
+ * start ascending so alphabetical order is natural; other value types (or
+ * columns with no non-nullish sample) start descending. Sampling past leading
+ * nullish values keeps the toggle cycle stable when sorting or a data swap
+ * moves an empty value into the first row.
  *
  * @example
  * ```ts
  * 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,20 +93,20 @@ 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.
  *
  * The toggle can add, replace, flip, or remove this column's sort entry. Multi
- * sorting respects `enableMultiSort`, `maxMultiSortColCount`, and the `multi`
- * argument.
+ * sorting respects `enableMultiSort`, `enableMultiRemove`,
+ * `maxMultiSortColCount`, and the `multi` argument.
  *
  * @example
  * ```ts
  * 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 +118,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 +130,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 +142,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 +154,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 +166,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 +177,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 +188,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 };