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

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

@@ -0,0 +1,188 @@
+import { OnChangeFn, RowData, Updater } from "../../types/type-utils.js";
+import { BuiltInSortFn } from "../../fns/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";
+
+//#region src/features/row-sorting/rowSortingFeature.types.d.ts
+type SortDirection = 'asc' | 'desc';
+interface ColumnSort {
+  desc: boolean;
+  id: string;
+}
+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 SortFns {}
+interface SortFn<TFeatures extends TableFeatures, TData extends RowData> {
+  (rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, 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> {
+  /**
+   * Enables/Disables multi-sorting for this column.
+   */
+  enableMultiSort?: boolean;
+  /**
+   * Enables/Disables sorting for this column.
+   */
+  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
+   */
+  invertSorting?: boolean;
+  /**
+   * Set to `true` for sorting toggles on this column to start in the descending direction.
+   */
+  sortDescFirst?: boolean;
+  /**
+   * The sorting function to use with this column.
+   * - A `string` referencing a built-in sorting function
+   * - A custom sorting function
+   */
+  sortFn?: SortFnOption<TFeatures, TData>;
+  /**
+   * 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)
+   * - `-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)
+   */
+  sortUndefined?: false | -1 | 1 | 'first' | 'last';
+}
+interface Column_RowSorting<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Removes this column from the table's sorting state
+   */
+  clearSorting: () => void;
+  /**
+   * Returns a sort direction automatically inferred based on the columns values.
+   */
+  getAutoSortDir: () => SortDirection;
+  /**
+   * Returns a sorting function automatically inferred based on the columns values.
+   */
+  getAutoSortFn: () => SortFn<TFeatures, TData>;
+  /**
+   * Returns whether this column can be multi-sorted.
+   */
+  getCanMultiSort: () => boolean;
+  /**
+   * Returns whether this column can be sorted.
+   */
+  getCanSort: () => boolean;
+  /**
+   * Returns the first direction that should be used when sorting this column.
+   */
+  getFirstSortDir: () => SortDirection;
+  /**
+   * Reads this column's current sort direction, or `false` when unsorted.
+   */
+  getIsSorted: () => false | SortDirection;
+  /**
+   * Returns the next sorting order.
+   */
+  getNextSortingOrder: () => SortDirection | false;
+  /**
+   * Finds this column's position in the ordered sorting state.
+   */
+  getSortIndex: () => number;
+  /**
+   * Returns the resolved sorting function to be used for this column
+   */
+  getSortFn: () => SortFn<TFeatures, TData>;
+  /**
+   * Creates a header/control handler that toggles this column's sorting state.
+   */
+  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).
+   */
+  toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
+}
+interface TableOptions_RowSorting {
+  /**
+   * Allows multi-sort toggles to remove a column from sorting state.
+   */
+  enableMultiRemove?: boolean;
+  /**
+   * Enables/Disables multi-sorting for the table.
+   */
+  enableMultiSort?: boolean;
+  /**
+   * Enables/Disables sorting for the table.
+   */
+  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' -> ...
+   */
+  enableSortingRemoval?: boolean;
+  /**
+   * Pass a custom function that will be used to determine if a multi-sort event should be triggered. It is passed the event from the sort toggle handler and should return `true` if the event should trigger a multi-sort.
+   */
+  isMultiSortEvent?: (e: unknown) => boolean;
+  /**
+   * Enables manual sorting for the table. If this is `true`, you will be expected to sort your data before it is passed to the table. This is useful if you are doing server-side sorting.
+   */
+  manualSorting?: boolean;
+  /**
+   * Set a maximum number of columns that can be multi-sorted.
+   */
+  maxMultiSortColCount?: number;
+  /**
+   * Called with an updater when sorting state changes. Pair this with
+   * `state.sorting` when using external state; external atoms can own the slice
+   * without this callback.
+   */
+  onSortingChange?: OnChangeFn<SortingState>;
+  /**
+   * If `true`, all sorts will default to descending as their first toggle state.
+   */
+  sortDescFirst?: boolean;
+}
+interface Table_RowSorting<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Resets `sorting` to `initialState.sorting`.
+   *
+   * Pass `true` to ignore initial state and reset to `[]`.
+   */
+  resetSorting: (defaultState?: boolean) => void;
+  /**
+   * Updates sorting state with a next ordered array or updater function.
+   */
+  setSorting: (updater: Updater<SortingState>) => void;
+}
+interface Table_RowModels_Sorted<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Reads the row model immediately before sorting.
+   */
+  getPreSortedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Resolves the row model after sorting has been applied.
+   */
+  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> {
+  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

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

@@ -0,0 +1,302 @@
+const require_utils = require('../../utils.cjs');
+const require_sortFns = require('../../fns/sortFns.cjs');
+
+//#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 ? [] : require_utils.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;
+	let sortFn;
+	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]") sortFn = sortFns === null || sortFns === void 0 ? void 0 : sortFns.datetime;
+		if (typeof value === "string") {
+			isString = true;
+			if (value.split(require_sortFns.reSplitAlphaNumeric).length > 1) sortFn = sortFns === null || sortFns === void 0 ? void 0 : sortFns.alphanumeric;
+		}
+	}
+	if (isString) sortFn = sortFns === null || sortFns === void 0 ? void 0 : sortFns.text;
+	return sortFn ?? require_sortFns.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 require_utils.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]) ?? require_sortFns.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
+exports.column_clearSorting = column_clearSorting;
+exports.column_getAutoSortDir = column_getAutoSortDir;
+exports.column_getAutoSortFn = column_getAutoSortFn;
+exports.column_getCanMultiSort = column_getCanMultiSort;
+exports.column_getCanSort = column_getCanSort;
+exports.column_getFirstSortDir = column_getFirstSortDir;
+exports.column_getIsSorted = column_getIsSorted;
+exports.column_getNextSortingOrder = column_getNextSortingOrder;
+exports.column_getSortFn = column_getSortFn;
+exports.column_getSortIndex = column_getSortIndex;
+exports.column_getToggleSortingHandler = column_getToggleSortingHandler;
+exports.column_toggleSorting = column_toggleSorting;
+exports.getDefaultSortingState = getDefaultSortingState;
+exports.table_resetSorting = table_resetSorting;
+exports.table_setSorting = table_setSorting;
+//# sourceMappingURL=rowSortingFeature.utils.cjs.map

package/dist/features/row-sorting/rowSortingFeature.utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowSortingFeature.utils.cjs","names":["cloneState","reSplitAlphaNumeric","sortFn_basic","isFunction"],"sources":["../../../src/features/row-sorting/rowSortingFeature.utils.ts"],"sourcesContent":["import { reSplitAlphaNumeric, sortFn_basic } from '../../fns/sortFns'\nimport { cloneState, isFunction } from '../../utils'\nimport type { CellData, RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Column_Internal } from '../../types/Column'\nimport type {\n  SortDirection,\n  SortFn,\n  SortingState,\n} from './rowSortingFeature.types'\n\n// State Utils\n\n/**\n * Creates the default sorting state.\n *\n * The feature default is an empty array, meaning no columns are sorted. Reset\n * APIs use this value when `defaultState` is `true`.\n *\n * @example\n * ```ts\n * const sorting = getDefaultSortingState()\n * ```\n */\nexport function getDefaultSortingState(): SortingState {\n  return []\n}\n\n/**\n * Routes a sorting updater through the table's sorting change handler.\n *\n * The updater may be a next `SortingState` array or a function of the previous\n * sorting state, matching the instance `table.setSorting` behavior.\n *\n * @example\n * ```ts\n * table_setSorting(table, (old) => [...old, { id: 'age', desc: true }])\n * ```\n */\nexport function table_setSorting<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, updater: Updater<SortingState>) {\n  table.options.onSortingChange?.(updater)\n}\n\n/**\n * Resets `sorting` to the configured initial state or feature default.\n *\n * With no argument, the reset clones `table.initialState.sorting` when it\n * exists. Passing `true` ignores initial state and resets to `[]`.\n *\n * @example\n * ```ts\n * table_resetSorting(table)\n * table_resetSorting(table, true)\n * ```\n */\nexport function table_resetSorting<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setSorting(\n    table,\n    defaultState ? [] : cloneState(table.initialState.sorting ?? []),\n  )\n}\n\n// Column Utils\n\n/**\n * Chooses a built-in sorting function from sampled filtered row values.\n *\n * Date-like values use `datetime`, mixed text/numeric strings use\n * `alphanumeric`, plain strings use `text`, and unknown values fall back to\n * `basic`.\n *\n * @example\n * ```ts\n * const sortFn = column_getAutoSortFn(column)\n * ```\n */\nexport function column_getAutoSortFn<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): SortFn<TFeatures, TData> {\n  const sortFns: Record<string, SortFn<TFeatures, TData>> | undefined =\n    column.table._rowModelFns.sortFns\n\n  let sortFn: SortFn<TFeatures, TData> | undefined\n\n  const firstRows = column.table.getFilteredRowModel().flatRows.slice(0, 10)\n\n  let isString = false\n\n  for (let i = 0; i < firstRows.length; i++) {\n    const value = firstRows[i]!.getValue(column.id)\n\n    if (Object.prototype.toString.call(value) === '[object Date]') {\n      sortFn = sortFns?.datetime\n    }\n\n    if (typeof value === 'string') {\n      isString = true\n\n      if (value.split(reSplitAlphaNumeric).length > 1) {\n        sortFn = sortFns?.alphanumeric\n      }\n    }\n  }\n\n  if (isString) {\n    sortFn = sortFns?.text\n  }\n\n  return sortFn ?? sortFn_basic\n}\n\n/**\n * Chooses the default first sort direction from the first filtered row value.\n *\n * String columns start ascending so alphabetical order is natural; other value\n * types start descending.\n *\n * @example\n * ```ts\n * const direction = column_getAutoSortDir(column)\n * ```\n */\nexport function column_getAutoSortDir<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  const firstRow = column.table.getFilteredRowModel().flatRows[0]\n\n  const value = firstRow ? firstRow.getValue(column.id) : undefined\n\n  if (typeof value === 'string') {\n    return 'asc'\n  }\n\n  return 'desc'\n}\n\n/**\n * Resolves the sorting function configured for a column.\n *\n * Function-valued `columnDef.sortFn` is returned directly, `'auto'` delegates\n * to `column_getAutoSortFn`, and string values are looked up in the table's\n * sorting function registry before falling back to `basic`.\n *\n * @example\n * ```ts\n * const sortFn = column_getSortFn(column)\n * ```\n */\nexport function column_getSortFn<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): SortFn<TFeatures, TData> {\n  const sortFns: Record<string, SortFn<TFeatures, TData>> | undefined =\n    column.table._rowModelFns.sortFns\n\n  return isFunction(column.columnDef.sortFn)\n    ? column.columnDef.sortFn\n    : column.columnDef.sortFn === 'auto'\n      ? column_getAutoSortFn(column)\n      : (sortFns?.[column.columnDef.sortFn as string] ?? sortFn_basic)\n}\n\n/**\n * Applies the next sorting state for this column.\n *\n * The toggle can add, replace, flip, or remove this column's sort entry. Multi\n * sorting respects `enableMultiSort`, `maxMultiSortColCount`, and the `multi`\n * argument.\n *\n * @example\n * ```ts\n * column_toggleSorting(column, undefined, true)\n * ```\n */\nexport function column_toggleSorting<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(\n  column: Column_Internal<TFeatures, TData, TValue>,\n  desc?: boolean,\n  multi?: boolean,\n) {\n  // if (column.columns.length) {\n  //   column.columns.forEach((c, i) => {\n  //     if (c.id) {\n  //       table.toggleColumnSorting(c.id, undefined, multi || !!i)\n  //     }\n  //   })\n  //   return\n  // }\n\n  // this needs to be outside of table.setSorting to be in sync with rerender\n  const nextSortingOrder = column_getNextSortingOrder(column)\n  const hasManualValue = typeof desc !== 'undefined'\n\n  table_setSorting(column.table, (old) => {\n    // Find any existing sorting for this column\n    const existingSorting = old.find((d) => d.id === column.id)\n    const existingIndex = old.findIndex((d) => d.id === column.id)\n\n    let newSorting: SortingState = []\n\n    // What should we do with this sort action?\n    let sortAction: 'add' | 'remove' | 'toggle' | 'replace'\n    const nextDesc = hasManualValue ? desc : nextSortingOrder === 'desc'\n\n    // Multi-mode\n    if (old.length && column_getCanMultiSort(column) && multi) {\n      if (existingSorting) {\n        sortAction = 'toggle'\n      } else {\n        sortAction = 'add'\n      }\n    } else {\n      // Normal mode\n      if (old.length && existingIndex !== old.length - 1) {\n        sortAction = 'replace'\n      } else if (existingSorting) {\n        sortAction = 'toggle'\n      } else {\n        sortAction = 'replace'\n      }\n    }\n\n    // Handle toggle states that will remove the sorting\n    if (sortAction === 'toggle') {\n      // If we are \"actually\" toggling (not a manual set value), should we remove the sorting?\n      if (!hasManualValue) {\n        // Is our intention to remove?\n        if (!nextSortingOrder) {\n          sortAction = 'remove'\n        }\n      }\n    }\n\n    if (sortAction === 'add') {\n      newSorting = [\n        ...old,\n        {\n          id: column.id,\n          desc: nextDesc,\n        },\n      ]\n      // Take latest n columns\n      newSorting.splice(\n        0,\n        newSorting.length -\n          (column.table.options.maxMultiSortColCount ??\n            Number.MAX_SAFE_INTEGER),\n      )\n    } else if (sortAction === 'toggle') {\n      // This flips (or sets) the\n      newSorting = old.map((d) => {\n        if (d.id === column.id) {\n          return {\n            ...d,\n            desc: nextDesc,\n          }\n        }\n        return d\n      })\n    } else if (sortAction === 'remove') {\n      newSorting = old.filter((d) => d.id !== column.id)\n    } else {\n      newSorting = [\n        {\n          id: column.id,\n          desc: nextDesc,\n        },\n      ]\n    }\n\n    return newSorting\n  })\n}\n\n/**\n * Resolves the first direction used when this column begins sorting.\n *\n * Column-level `sortDescFirst` wins, then table-level `sortDescFirst`, then the\n * auto direction inferred from sampled values.\n *\n * @example\n * ```ts\n * const firstDirection = column_getFirstSortDir(column)\n * ```\n */\nexport function column_getFirstSortDir<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  const sortDescFirst =\n    column.columnDef.sortDescFirst ??\n    column.table.options.sortDescFirst ??\n    column_getAutoSortDir(column) === 'desc'\n  return sortDescFirst ? 'desc' : 'asc'\n}\n\n/**\n * Resolves the next sort order for this column's toggle cycle.\n *\n * The cycle starts with the first sort direction, flips between `asc` and\n * `desc`, and can return `false` when sorting removal is enabled.\n *\n * @example\n * ```ts\n * const nextOrder = column_getNextSortingOrder(column)\n * ```\n */\nexport function column_getNextSortingOrder<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>, multi?: boolean) {\n  const firstSortDirection = column_getFirstSortDir(column)\n  const isSorted = column_getIsSorted(column)\n\n  if (!isSorted) {\n    return firstSortDirection\n  }\n\n  if (\n    isSorted !== firstSortDirection &&\n    (column.table.options.enableSortingRemoval ?? true) && // If enableSortRemove, enable in general\n    (multi ? (column.table.options.enableMultiRemove ?? true) : true) // If multi, don't allow if enableMultiRemove))\n  ) {\n    return false\n  }\n  return isSorted === 'desc' ? 'asc' : 'desc'\n}\n\n/**\n * Checks whether this accessor column can participate in sorting.\n *\n * The column must have an accessor and sorting must be enabled by both the\n * column definition and table options.\n *\n * @example\n * ```ts\n * const canSort = column_getCanSort(column)\n * ```\n */\nexport function column_getCanSort<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  return (\n    (column.columnDef.enableSorting ?? true) &&\n    (column.table.options.enableSorting ?? true) &&\n    !!column.accessorFn\n  )\n}\n\n/**\n * Checks whether this column can be added to a multi-sort state.\n *\n * Column-level `enableMultiSort` wins over table-level `enableMultiSort`; if\n * neither is set, accessor columns can multi-sort by default.\n *\n * @example\n * ```ts\n * const canMultiSort = column_getCanMultiSort(column)\n * ```\n */\nexport function column_getCanMultiSort<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): boolean {\n  return (\n    column.columnDef.enableMultiSort ??\n    column.table.options.enableMultiSort ??\n    !!column.accessorFn\n  )\n}\n\n/**\n * Reads this column's current sort direction.\n *\n * The result is `false` when the column is not sorted, otherwise `'asc'` or\n * `'desc'` based on the column's entry in `state.sorting`.\n *\n * @example\n * ```ts\n * const direction = column_getIsSorted(column)\n * ```\n */\nexport function column_getIsSorted<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): false | SortDirection {\n  const columnSort = column.table.atoms.sorting\n    ?.get()\n    ?.find((d) => d.id === column.id)\n  return !columnSort ? false : columnSort.desc ? 'desc' : 'asc'\n}\n\n/**\n * Finds this column's position in the ordered `state.sorting` array.\n *\n * The result is `-1` when the column is not sorted.\n *\n * @example\n * ```ts\n * const index = column_getSortIndex(column)\n * ```\n */\nexport function column_getSortIndex<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>): number {\n  return (\n    column.table.atoms.sorting?.get()?.findIndex((d) => d.id === column.id) ??\n    -1\n  )\n}\n\n/**\n * Removes this column from the sorting state.\n *\n * Other sorted columns are preserved, including their relative order.\n *\n * @example\n * ```ts\n * column_clearSorting(column)\n * ```\n */\nexport function column_clearSorting<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  // clear sorting for just 1 column\n  table_setSorting(column.table, (old) =>\n    old.length ? old.filter((d) => d.id !== column.id) : [],\n  )\n}\n\n/**\n * Creates a header event handler that toggles this column's sorting.\n *\n * The handler ignores events when the column cannot sort, persists React-style\n * synthetic events when present, and asks `options.isMultiSortEvent` whether\n * the event should add to a multi-sort.\n *\n * @example\n * ```ts\n * const onClick = column_getToggleSortingHandler(column)\n * ```\n */\nexport function column_getToggleSortingHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  const canSort = column_getCanSort(column)\n\n  return (e: unknown) => {\n    if (!canSort) return\n    ;(e as any).persist?.()\n    column_toggleSorting(\n      column,\n\n      undefined,\n      column_getCanMultiSort(column)\n        ? column.table.options.isMultiSortEvent?.(e)\n        : false,\n    )\n  }\n}\n"],"mappings":"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"}