@tanstack/table-core 9.0.0-alpha.8 → 9.0.0-beta.10

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

@@ -0,0 +1,193 @@
+import { CellData, RowData, Updater } from "../../types/type-utils.cjs";
+import { SortDirection, SortFn, SortingState } from "./rowSortingFeature.types.cjs";
+import { Column_Internal } from "../../types/Column.cjs";
+import { Table_Internal } from "../../types/Table.cjs";
+import { TableFeatures } from "../../types/TableFeatures.cjs";
+
+//#region src/features/row-sorting/rowSortingFeature.utils.d.ts
+/**
+ * Creates the default sorting state.
+ *
+ * The feature default is an empty array, meaning no columns are sorted. Reset
+ * APIs use this value when `defaultState` is `true`.
+ *
+ * @example
+ * ```ts
+ * const sorting = getDefaultSortingState()
+ * ```
+ */
+declare function getDefaultSortingState(): SortingState;
+/**
+ * Routes a sorting updater through the table's sorting change handler.
+ *
+ * The updater may be a next `SortingState` array or a function of the previous
+ * sorting state, matching the instance `table.setSorting` behavior.
+ *
+ * @example
+ * ```ts
+ * 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;
+/**
+ * Resets `sorting` to the configured initial state or feature default.
+ *
+ * With no argument, the reset clones `table.initialState.sorting` when it
+ * exists. Passing `true` ignores initial state and resets to `[]`.
+ *
+ * @example
+ * ```ts
+ * table_resetSorting(table)
+ * table_resetSorting(table, true)
+ * ```
+ */
+declare function table_resetSorting<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
+/**
+ * Chooses a built-in sorting function from sampled filtered row values.
+ *
+ * Date-like values use `datetime`, mixed text/numeric strings use
+ * `alphanumeric`, plain strings use `text`, and unknown values fall back to
+ * `basic`.
+ *
+ * @example
+ * ```ts
+ * 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>;
+/**
+ * Chooses the default first sort direction from the first filtered row value.
+ *
+ * String columns start ascending so alphabetical order is natural; other value
+ * types start descending.
+ *
+ * @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";
+/**
+ * Resolves the sorting function configured for a column.
+ *
+ * Function-valued `columnDef.sortFn` is returned directly, `'auto'` delegates
+ * to `column_getAutoSortFn`, and string values are looked up in the table's
+ * sorting function registry before falling back to `basic`.
+ *
+ * @example
+ * ```ts
+ * 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>;
+/**
+ * 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.
+ *
+ * @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;
+/**
+ * Resolves the first direction used when this column begins sorting.
+ *
+ * Column-level `sortDescFirst` wins, then table-level `sortDescFirst`, then the
+ * auto direction inferred from sampled values.
+ *
+ * @example
+ * ```ts
+ * 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";
+/**
+ * Resolves the next sort order for this column's toggle cycle.
+ *
+ * The cycle starts with the first sort direction, flips between `asc` and
+ * `desc`, and can return `false` when sorting removal is enabled.
+ *
+ * @example
+ * ```ts
+ * 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";
+/**
+ * Checks whether this accessor column can participate in sorting.
+ *
+ * The column must have an accessor and sorting must be enabled by both the
+ * column definition and table options.
+ *
+ * @example
+ * ```ts
+ * 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;
+/**
+ * Checks whether this column can be added to a multi-sort state.
+ *
+ * Column-level `enableMultiSort` wins over table-level `enableMultiSort`; if
+ * neither is set, accessor columns can multi-sort by default.
+ *
+ * @example
+ * ```ts
+ * 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;
+/**
+ * Reads this column's current sort direction.
+ *
+ * The result is `false` when the column is not sorted, otherwise `'asc'` or
+ * `'desc'` based on the column's entry in `state.sorting`.
+ *
+ * @example
+ * ```ts
+ * 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;
+/**
+ * Finds this column's position in the ordered `state.sorting` array.
+ *
+ * The result is `-1` when the column is not sorted.
+ *
+ * @example
+ * ```ts
+ * 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;
+/**
+ * Removes this column from the sorting state.
+ *
+ * Other sorted columns are preserved, including their relative order.
+ *
+ * @example
+ * ```ts
+ * column_clearSorting(column)
+ * ```
+ */
+declare function column_clearSorting<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<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.
+ *
+ * @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;
+//#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.cts.map

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

@@ -0,0 +1,193 @@
+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 { Table_Internal } from "../../types/Table.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+
+//#region src/features/row-sorting/rowSortingFeature.utils.d.ts
+/**
+ * Creates the default sorting state.
+ *
+ * The feature default is an empty array, meaning no columns are sorted. Reset
+ * APIs use this value when `defaultState` is `true`.
+ *
+ * @example
+ * ```ts
+ * const sorting = getDefaultSortingState()
+ * ```
+ */
+declare function getDefaultSortingState(): SortingState;
+/**
+ * Routes a sorting updater through the table's sorting change handler.
+ *
+ * The updater may be a next `SortingState` array or a function of the previous
+ * sorting state, matching the instance `table.setSorting` behavior.
+ *
+ * @example
+ * ```ts
+ * 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;
+/**
+ * Resets `sorting` to the configured initial state or feature default.
+ *
+ * With no argument, the reset clones `table.initialState.sorting` when it
+ * exists. Passing `true` ignores initial state and resets to `[]`.
+ *
+ * @example
+ * ```ts
+ * table_resetSorting(table)
+ * table_resetSorting(table, true)
+ * ```
+ */
+declare function table_resetSorting<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
+/**
+ * Chooses a built-in sorting function from sampled filtered row values.
+ *
+ * Date-like values use `datetime`, mixed text/numeric strings use
+ * `alphanumeric`, plain strings use `text`, and unknown values fall back to
+ * `basic`.
+ *
+ * @example
+ * ```ts
+ * 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>;
+/**
+ * Chooses the default first sort direction from the first filtered row value.
+ *
+ * String columns start ascending so alphabetical order is natural; other value
+ * types start descending.
+ *
+ * @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";
+/**
+ * Resolves the sorting function configured for a column.
+ *
+ * Function-valued `columnDef.sortFn` is returned directly, `'auto'` delegates
+ * to `column_getAutoSortFn`, and string values are looked up in the table's
+ * sorting function registry before falling back to `basic`.
+ *
+ * @example
+ * ```ts
+ * 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>;
+/**
+ * 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.
+ *
+ * @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;
+/**
+ * Resolves the first direction used when this column begins sorting.
+ *
+ * Column-level `sortDescFirst` wins, then table-level `sortDescFirst`, then the
+ * auto direction inferred from sampled values.
+ *
+ * @example
+ * ```ts
+ * 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";
+/**
+ * Resolves the next sort order for this column's toggle cycle.
+ *
+ * The cycle starts with the first sort direction, flips between `asc` and
+ * `desc`, and can return `false` when sorting removal is enabled.
+ *
+ * @example
+ * ```ts
+ * 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";
+/**
+ * Checks whether this accessor column can participate in sorting.
+ *
+ * The column must have an accessor and sorting must be enabled by both the
+ * column definition and table options.
+ *
+ * @example
+ * ```ts
+ * 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;
+/**
+ * Checks whether this column can be added to a multi-sort state.
+ *
+ * Column-level `enableMultiSort` wins over table-level `enableMultiSort`; if
+ * neither is set, accessor columns can multi-sort by default.
+ *
+ * @example
+ * ```ts
+ * 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;
+/**
+ * Reads this column's current sort direction.
+ *
+ * The result is `false` when the column is not sorted, otherwise `'asc'` or
+ * `'desc'` based on the column's entry in `state.sorting`.
+ *
+ * @example
+ * ```ts
+ * 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;
+/**
+ * Finds this column's position in the ordered `state.sorting` array.
+ *
+ * The result is `-1` when the column is not sorted.
+ *
+ * @example
+ * ```ts
+ * 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;
+/**
+ * Removes this column from the sorting state.
+ *
+ * Other sorted columns are preserved, including their relative order.
+ *
+ * @example
+ * ```ts
+ * column_clearSorting(column)
+ * ```
+ */
+declare function column_clearSorting<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<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.
+ *
+ * @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;
+//#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

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

@@ -0,0 +1,291 @@
+import { cloneState, isFunction } from "../../utils.js";
+import { reSplitAlphaNumeric, sortFn_basic } from "../../fns/sortFns.js";
+
+//#region src/features/row-sorting/rowSortingFeature.utils.ts
+/**
+* Creates the default sorting state.
+*
+* The feature default is an empty array, meaning no columns are sorted. Reset
+* APIs use this value when `defaultState` is `true`.
+*
+* @example
+* ```ts
+* const sorting = getDefaultSortingState()
+* ```
+*/
+function getDefaultSortingState() {
+	return [];
+}
+/**
+* Routes a sorting updater through the table's sorting change handler.
+*
+* The updater may be a next `SortingState` array or a function of the previous
+* sorting state, matching the instance `table.setSorting` behavior.
+*
+* @example
+* ```ts
+* table_setSorting(table, (old) => [...old, { id: 'age', desc: true }])
+* ```
+*/
+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);
+}
+/**
+* Resets `sorting` to the configured initial state or feature default.
+*
+* With no argument, the reset clones `table.initialState.sorting` when it
+* exists. Passing `true` ignores initial state and resets to `[]`.
+*
+* @example
+* ```ts
+* table_resetSorting(table)
+* table_resetSorting(table, true)
+* ```
+*/
+function table_resetSorting(table, defaultState) {
+	table_setSorting(table, defaultState ? [] : cloneState(table.initialState.sorting ?? []));
+}
+/**
+* Chooses a built-in sorting function from sampled filtered row values.
+*
+* Date-like values use `datetime`, mixed text/numeric strings use
+* `alphanumeric`, plain strings use `text`, and unknown values fall back to
+* `basic`.
+*
+* @example
+* ```ts
+* const sortFn = column_getAutoSortFn(column)
+* ```
+*/
+function column_getAutoSortFn(column) {
+	const sortFns = column.table._rowModelFns.sortFns;
+	const firstRows = column.table.getFilteredRowModel().flatRows.slice(0, 10);
+	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;
+		}
+		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;
+			}
+		}
+	}
+	if (isString) return (sortFns === null || sortFns === void 0 ? void 0 : sortFns.text) ?? sortFn_basic;
+	return sortFn_basic;
+}
+/**
+* Chooses the default first sort direction from the first filtered row value.
+*
+* String columns start ascending so alphabetical order is natural; other value
+* types start descending.
+*
+* @example
+* ```ts
+* const direction = column_getAutoSortDir(column)
+* ```
+*/
+function column_getAutoSortDir(column) {
+	const firstRow = column.table.getFilteredRowModel().flatRows[0];
+	if (typeof (firstRow ? firstRow.getValue(column.id) : void 0) === "string") return "asc";
+	return "desc";
+}
+/**
+* Resolves the sorting function configured for a column.
+*
+* Function-valued `columnDef.sortFn` is returned directly, `'auto'` delegates
+* to `column_getAutoSortFn`, and string values are looked up in the table's
+* sorting function registry before falling back to `basic`.
+*
+* @example
+* ```ts
+* const sortFn = column_getSortFn(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;
+}
+/**
+* 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.
+*
+* @example
+* ```ts
+* column_toggleSorting(column, undefined, true)
+* ```
+*/
+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);
+		let newSorting = [];
+		let sortAction;
+		const nextDesc = hasManualValue ? desc : nextSortingOrder === "desc";
+		if (old.length && column_getCanMultiSort(column) && multi) 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") {
+			if (!hasManualValue) {
+				if (!nextSortingOrder) sortAction = "remove";
+			}
+		}
+		if (sortAction === "add") {
+			newSorting = [...old, {
+				id: column.id,
+				desc: nextDesc
+			}];
+			newSorting.splice(0, newSorting.length - (column.table.options.maxMultiSortColCount ?? Number.MAX_SAFE_INTEGER));
+		} else if (sortAction === "toggle") newSorting = 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);
+		else newSorting = [{
+			id: column.id,
+			desc: nextDesc
+		}];
+		return newSorting;
+	});
+}
+/**
+* Resolves the first direction used when this column begins sorting.
+*
+* Column-level `sortDescFirst` wins, then table-level `sortDescFirst`, then the
+* auto direction inferred from sampled values.
+*
+* @example
+* ```ts
+* const firstDirection = column_getFirstSortDir(column)
+* ```
+*/
+function column_getFirstSortDir(column) {
+	return column.columnDef.sortDescFirst ?? column.table.options.sortDescFirst ?? column_getAutoSortDir(column) === "desc" ? "desc" : "asc";
+}
+/**
+* Resolves the next sort order for this column's toggle cycle.
+*
+* The cycle starts with the first sort direction, flips between `asc` and
+* `desc`, and can return `false` when sorting removal is enabled.
+*
+* @example
+* ```ts
+* const nextOrder = column_getNextSortingOrder(column)
+* ```
+*/
+function column_getNextSortingOrder(column, multi) {
+	const firstSortDirection = column_getFirstSortDir(column);
+	const isSorted = column_getIsSorted(column);
+	if (!isSorted) return firstSortDirection;
+	if (isSorted !== firstSortDirection && (column.table.options.enableSortingRemoval ?? true) && (multi ? column.table.options.enableMultiRemove ?? true : true)) return false;
+	return isSorted === "desc" ? "asc" : "desc";
+}
+/**
+* Checks whether this accessor column can participate in sorting.
+*
+* The column must have an accessor and sorting must be enabled by both the
+* column definition and table options.
+*
+* @example
+* ```ts
+* const canSort = column_getCanSort(column)
+* ```
+*/
+function column_getCanSort(column) {
+	return (column.columnDef.enableSorting ?? true) && (column.table.options.enableSorting ?? true) && !!column.accessorFn;
+}
+/**
+* Checks whether this column can be added to a multi-sort state.
+*
+* Column-level `enableMultiSort` wins over table-level `enableMultiSort`; if
+* neither is set, accessor columns can multi-sort by default.
+*
+* @example
+* ```ts
+* const canMultiSort = column_getCanMultiSort(column)
+* ```
+*/
+function column_getCanMultiSort(column) {
+	return column.columnDef.enableMultiSort ?? column.table.options.enableMultiSort ?? !!column.accessorFn;
+}
+/**
+* Reads this column's current sort direction.
+*
+* The result is `false` when the column is not sorted, otherwise `'asc'` or
+* `'desc'` based on the column's entry in `state.sorting`.
+*
+* @example
+* ```ts
+* const direction = column_getIsSorted(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);
+	return !columnSort ? false : columnSort.desc ? "desc" : "asc";
+}
+/**
+* Finds this column's position in the ordered `state.sorting` array.
+*
+* The result is `-1` when the column is not sorted.
+*
+* @example
+* ```ts
+* const index = column_getSortIndex(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;
+}
+/**
+* Removes this column from the sorting state.
+*
+* Other sorted columns are preserved, including their relative order.
+*
+* @example
+* ```ts
+* column_clearSorting(column)
+* ```
+*/
+function column_clearSorting(column) {
+	table_setSorting(column.table, (old) => old.length ? old.filter((d) => d.id !== column.id) : []);
+}
+/**
+* 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.
+*
+* @example
+* ```ts
+* const onClick = column_getToggleSortingHandler(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);
+	};
+}
+
+//#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