@tanstack/table-core 9.0.0-beta.51 → 9.0.0-beta.53

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

@@ -1,193 +0,0 @@
-import { CellData, RowData, Updater } from "../../types/type-utils.cjs";
-import { SortDirection, SortFn, SortingState } from "./rowSortingFeature.types.cjs";
-import { Table } from "../../types/Table.cjs";
-import { Column } from "../../types/Column.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<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<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<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<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<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<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<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<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<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<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<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<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<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<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.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rowSortingFeature.utils.js","names":[],"sources":["../../../src/features/row-sorting/rowSortingFeature.utils.ts"],"sourcesContent":["import { cloneState, isFunction } from '../../utils'\nimport { reSplitAlphaNumeric, sortFn_basic } from './sortFns'\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  const firstRows = column.table.getFilteredRowModel().flatRows.slice(0, 10)\n\n  let sortFnName: string | undefined\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      sortFnName = 'datetime'\n      break\n    }\n\n    if (typeof value === 'string') {\n      isString = true\n\n      if (value.split(reSplitAlphaNumeric).length > 1) {\n        sortFnName = 'alphanumeric'\n        break\n      }\n    }\n  }\n\n  if (!sortFnName && isString) {\n    sortFnName = 'text'\n  }\n\n  if (sortFnName) {\n    let sortFn = sortFns?.[sortFnName]\n\n    if (!sortFn) {\n      if (process.env.NODE_ENV === 'development') {\n        console.warn(\n          `sortFn '${sortFnName}' (auto) for column '${column.id}' is not registered`,\n        )\n      }\n\n      // String columns degrade to a registered text sort before basic\n      if (sortFnName === 'alphanumeric') {\n        sortFn = sortFns?.text\n      }\n    }\n\n    if (sortFn) {\n      return sortFn\n    }\n  }\n\n  return 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  if (isFunction(column.columnDef.sortFn)) {\n    return column.columnDef.sortFn\n  }\n\n  if (column.columnDef.sortFn === 'auto') {\n    return column_getAutoSortFn(column)\n  }\n\n  const sortFn = sortFns?.[column.columnDef.sortFn as string]\n\n  if (process.env.NODE_ENV === 'development' && !sortFn) {\n    console.warn(\n      `sortFn '${String(column.columnDef.sortFn)}' for column '${column.id}' is not registered`,\n    )\n  }\n\n  return sortFn ?? 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  // 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 existingIndex = old.findIndex((d) => d.id === column.id)\n    const existingSorting =\n      existingIndex === -1 ? undefined : old[existingIndex]\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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"}

package/dist/features/row-sorting/sortFns.cjs

@@ -1,226 +0,0 @@
-
-//#region src/features/row-sorting/sortFns.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`.
-*/
-const reSplitAlphaNumeric = /([0-9]+)/gm;
-/**
-* 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)),
-* })
-* ```
-*/
-function constructSortFn(def) {
-	const sortFn = Object.assign((rowA, rowB, columnId) => {
-		let dataValueA = rowA.getValue(columnId);
-		let dataValueB = rowB.getValue(columnId);
-		const resolveDataValue = sortFn.resolveDataValue;
-		if (resolveDataValue) {
-			dataValueA = resolveDataValue(dataValueA);
-			dataValueB = resolveDataValue(dataValueB);
-		}
-		return sortFn.sort(dataValueA, dataValueB, rowA, rowB, columnId);
-	}, def);
-	return sortFn;
-}
-/**
-* Sorts rows with the built-in alphanumeric strategy.
-*
-* This comparator returns ascending-order results; descending order is applied by the sorting row model.
-*/
-const sortFn_alphanumeric = constructSortFn({
-	resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),
-	sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB)
-});
-/**
-* 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.
-*/
-const sortFn_alphanumericCaseSensitive = constructSortFn({
-	resolveDataValue: (dataValue) => toString(dataValue),
-	sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB)
-});
-/**
-* Sorts rows with the built-in text strategy.
-*
-* This comparator returns ascending-order results; descending order is applied by the sorting row model.
-*/
-const sortFn_text = constructSortFn({
-	resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),
-	sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB)
-});
-/**
-* 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.
-*/
-const sortFn_textCaseSensitive = constructSortFn({
-	resolveDataValue: (dataValue) => toString(dataValue),
-	sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB)
-});
-/**
-* Sorts rows with the built-in datetime strategy.
-*
-* This comparator returns ascending-order results; descending order is applied by the sorting row model.
-*/
-const sortFn_datetime = constructSortFn({
-	resolveDataValue: (dataValue) => toDateSortValue(dataValue),
-	sort: (dataValueA, dataValueB) => dataValueA > dataValueB ? 1 : dataValueA < dataValueB ? -1 : 0
-});
-/**
-* Sorts rows with the built-in basic strategy.
-*
-* This comparator returns ascending-order results; descending order is applied by the sorting row model.
-*/
-const sortFn_basic = constructSortFn({ sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB) });
-function compareBasic(a, b) {
-	return a === b ? 0 : a > b ? 1 : -1;
-}
-function toDateSortValue(value) {
-	return value instanceof Date ? value.getTime() : value;
-}
-function toString(a) {
-	if (typeof a === "number") {
-		if (isNaN(a) || a === Infinity || a === -Infinity) return "";
-		return String(a);
-	}
-	if (typeof a === "string") return a;
-	return "";
-}
-function compareAlphanumeric(aStr, bStr) {
-	let ai = 0;
-	let bi = 0;
-	const aLen = aStr.length;
-	const bLen = bStr.length;
-	while (ai < aLen && bi < bLen) {
-		const aIsNumeric = isDigit(aStr.charCodeAt(ai));
-		const bIsNumeric = isDigit(bStr.charCodeAt(bi));
-		const aEnd = findChunkEnd(aStr, ai, aIsNumeric);
-		const bEnd = findChunkEnd(bStr, bi, bIsNumeric);
-		if (!aIsNumeric && !bIsNumeric) {
-			const stringComparison = compareStringChunks(aStr, ai, aEnd, bStr, bi, bEnd);
-			if (stringComparison) return stringComparison;
-			ai = aEnd;
-			bi = bEnd;
-			continue;
-		}
-		if (aIsNumeric !== bIsNumeric) return aIsNumeric ? 1 : -1;
-		const numericComparison = compareNumericChunks(aStr, ai, aEnd, bStr, bi, bEnd);
-		if (numericComparison) return numericComparison;
-		ai = aEnd;
-		bi = bEnd;
-	}
-	return countRemainingChunks(aStr, ai) - countRemainingChunks(bStr, bi);
-}
-function isDigit(charCode) {
-	return charCode >= 48 && charCode <= 57;
-}
-function findChunkEnd(str, start, isNumeric) {
-	let end = start + 1;
-	while (end < str.length && isDigit(str.charCodeAt(end)) === isNumeric) end++;
-	return end;
-}
-function compareStringChunks(aStr, aStart, aEnd, bStr, bStart, bEnd) {
-	const aLength = aEnd - aStart;
-	const bLength = bEnd - bStart;
-	const minLength = aLength < bLength ? aLength : bLength;
-	for (let i = 0; i < minLength; i++) {
-		const aCode = aStr.charCodeAt(aStart + i);
-		const bCode = bStr.charCodeAt(bStart + i);
-		if (aCode > bCode) return 1;
-		if (bCode > aCode) return -1;
-	}
-	if (aLength > bLength) return 1;
-	if (bLength > aLength) return -1;
-	return 0;
-}
-function compareNumericChunks(aStr, aStart, aEnd, bStr, bStart, bEnd) {
-	let aSignificantStart = aStart;
-	while (aSignificantStart < aEnd && aStr.charCodeAt(aSignificantStart) === 48) aSignificantStart++;
-	let bSignificantStart = bStart;
-	while (bSignificantStart < bEnd && bStr.charCodeAt(bSignificantStart) === 48) bSignificantStart++;
-	const aSignificantLength = aEnd - aSignificantStart;
-	const bSignificantLength = bEnd - bSignificantStart;
-	if (aSignificantLength === 0 && bSignificantLength === 0) return 0;
-	if (aSignificantLength <= 15 && bSignificantLength <= 15) {
-		const an = parseSmallInt(aStr, aSignificantStart, aEnd);
-		const bn = parseSmallInt(bStr, bSignificantStart, bEnd);
-		if (an > bn) return 1;
-		if (bn > an) return -1;
-		return 0;
-	}
-	const an = parseInt(aStr.slice(aStart, aEnd), 10);
-	const bn = parseInt(bStr.slice(bStart, bEnd), 10);
-	if (an > bn) return 1;
-	if (bn > an) return -1;
-	return 0;
-}
-function parseSmallInt(str, start, end) {
-	let result = 0;
-	for (let i = start; i < end; i++) result = result * 10 + str.charCodeAt(i) - 48;
-	return result;
-}
-function countRemainingChunks(str, start) {
-	let count = 0;
-	let index = start;
-	while (index < str.length) {
-		count++;
-		index = findChunkEnd(str, index, isDigit(str.charCodeAt(index)));
-	}
-	return count;
-}
-/**
-* 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.
-*/
-const sortFns = {
-	alphanumeric: sortFn_alphanumeric,
-	alphanumericCaseSensitive: sortFn_alphanumericCaseSensitive,
-	basic: sortFn_basic,
-	datetime: sortFn_datetime,
-	text: sortFn_text,
-	textCaseSensitive: sortFn_textCaseSensitive
-};
-
-//#endregion
-exports.constructSortFn = constructSortFn;
-exports.reSplitAlphaNumeric = reSplitAlphaNumeric;
-exports.sortFn_alphanumeric = sortFn_alphanumeric;
-exports.sortFn_alphanumericCaseSensitive = sortFn_alphanumericCaseSensitive;
-exports.sortFn_basic = sortFn_basic;
-exports.sortFn_datetime = sortFn_datetime;
-exports.sortFn_text = sortFn_text;
-exports.sortFn_textCaseSensitive = sortFn_textCaseSensitive;
-exports.sortFns = sortFns;
-//# sourceMappingURL=sortFns.cjs.map

package/dist/features/row-sorting/sortFns.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"sortFns.cjs","names":[],"sources":["../../../src/features/row-sorting/sortFns.ts"],"sourcesContent":["import type { CreatedSortFn, SortFnDef } from './rowSortingFeature.types'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\n\n/**\n * Regular expression used to split mixed text and numeric chunks.\n *\n * The alphanumeric sort functions use these chunks for natural sorting of\n * strings like `item2` before `item10`.\n */\nexport const reSplitAlphaNumeric = /([0-9]+)/gm\n\n/**\n * Builds a `SortFn` from a value-level comparator plus an optional\n * `resolveDataValue` normalizer.\n *\n * The `sort` comparator receives both rows' data values, each already passed\n * through `resolveDataValue` when one is defined. Keeping normalization in the\n * resolver means a variant of an existing sorting function only has to swap\n * the resolver, not re-implement the comparison.\n *\n * The definition is attached to the returned function, so a variant can be\n * created by spreading a built-in sorting function and overriding what\n * differs:\n *\n * ```ts\n * const stripDiacritics = (value: string) =>\n *   value.normalize('NFD').replace(/\\p{Diacritic}/gu, '')\n *\n * const alphanumericIgnoreDiacritics = constructSortFn({\n *   ...sortFn_alphanumeric,\n *   resolveDataValue: (value) =>\n *     stripDiacritics(sortFn_alphanumeric.resolveDataValue!(value)),\n * })\n * ```\n */\nexport function constructSortFn<\n  TFeatures extends TableFeatures = any,\n  TData extends RowData = any,\n>(def: SortFnDef<TFeatures, TData>): CreatedSortFn<TFeatures, TData> {\n  const sortFn: CreatedSortFn<TFeatures, TData> = Object.assign(\n    <TRowFeatures extends TableFeatures, TRowData extends RowData>(\n      rowA: Row<TRowFeatures, TRowData>,\n      rowB: Row<TRowFeatures, TRowData>,\n      columnId: string,\n    ): number => {\n      let dataValueA = rowA.getValue(columnId)\n      let dataValueB = rowB.getValue(columnId)\n      const resolveDataValue = sortFn.resolveDataValue\n      if (resolveDataValue) {\n        dataValueA = resolveDataValue(dataValueA)\n        dataValueB = resolveDataValue(dataValueB)\n      }\n      // The def's comparator is typed against the factory's TFeatures/TData;\n      // the caller's row generics are erased at this boundary.\n      return sortFn.sort(\n        dataValueA,\n        dataValueB,\n        rowA as any,\n        rowB as any,\n        columnId,\n      )\n    },\n    def,\n  )\n  return sortFn\n}\n\n/**\n * Sorts rows with the built-in alphanumeric strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumeric = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),\n  sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB),\n})\n\n/**\n * Sorts rows with the built-in alphanumeric case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumericCaseSensitive = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue),\n  sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB),\n})\n\n// The text sort is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_text = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),\n  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),\n})\n\n// The text sort is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_textCaseSensitive = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue),\n  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),\n})\n\n/**\n * Sorts rows with the built-in datetime strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_datetime = constructSortFn({\n  resolveDataValue: (dataValue) => toDateSortValue(dataValue),\n  // Can handle nullish values\n  // Use > and < because == (and ===) doesn't work with\n  // Date objects (would require calling getTime()).\n  sort: (dataValueA, dataValueB) =>\n    dataValueA > dataValueB ? 1 : dataValueA < dataValueB ? -1 : 0,\n})\n\n/**\n * Sorts rows with the built-in basic strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_basic = constructSortFn({\n  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),\n})\n\n// Utils\n\nfunction compareBasic(a: any, b: any) {\n  return a === b ? 0 : a > b ? 1 : -1\n}\n\nfunction toDateSortValue(value: any) {\n  return value instanceof Date ? value.getTime() : value\n}\n\nfunction toString(a: any) {\n  if (typeof a === 'number') {\n    if (isNaN(a) || a === Infinity || a === -Infinity) {\n      return ''\n    }\n    return String(a)\n  }\n  if (typeof a === 'string') {\n    return a\n  }\n  return ''\n}\n\n// Mixed sorting is slow, but very inclusive of many edge cases.\n// It handles numbers, mixed alphanumeric combinations, and even\n// null, undefined, and Infinity\nfunction compareAlphanumeric(aStr: string, bStr: string) {\n  let ai = 0\n  let bi = 0\n  const aLen = aStr.length\n  const bLen = bStr.length\n\n  while (ai < aLen && bi < bLen) {\n    const aIsNumeric = isDigit(aStr.charCodeAt(ai))\n    const bIsNumeric = isDigit(bStr.charCodeAt(bi))\n\n    const aEnd = findChunkEnd(aStr, ai, aIsNumeric)\n    const bEnd = findChunkEnd(bStr, bi, bIsNumeric)\n\n    // Both are string chunks\n    if (!aIsNumeric && !bIsNumeric) {\n      const stringComparison = compareStringChunks(\n        aStr,\n        ai,\n        aEnd,\n        bStr,\n        bi,\n        bEnd,\n      )\n      if (stringComparison) {\n        return stringComparison\n      }\n      ai = aEnd\n      bi = bEnd\n      continue\n    }\n\n    // One is a string chunk, one is a number chunk — the string sorts first\n    if (aIsNumeric !== bIsNumeric) {\n      return aIsNumeric ? 1 : -1\n    }\n\n    // Both are numeric chunks\n    const numericComparison = compareNumericChunks(\n      aStr,\n      ai,\n      aEnd,\n      bStr,\n      bi,\n      bEnd,\n    )\n    if (numericComparison) {\n      return numericComparison\n    }\n\n    ai = aEnd\n    bi = bEnd\n  }\n\n  // One side is exhausted — compare the counts of remaining non-empty chunks\n  return countRemainingChunks(aStr, ai) - countRemainingChunks(bStr, bi)\n}\n\nfunction isDigit(charCode: number) {\n  return charCode >= 48 && charCode <= 57\n}\n\nfunction findChunkEnd(str: string, start: number, isNumeric: boolean) {\n  let end = start + 1\n  while (end < str.length && isDigit(str.charCodeAt(end)) === isNumeric) {\n    end++\n  }\n  return end\n}\n\nfunction compareStringChunks(\n  aStr: string,\n  aStart: number,\n  aEnd: number,\n  bStr: string,\n  bStart: number,\n  bEnd: number,\n) {\n  const aLength = aEnd - aStart\n  const bLength = bEnd - bStart\n  const minLength = aLength < bLength ? aLength : bLength\n\n  for (let i = 0; i < minLength; i++) {\n    const aCode = aStr.charCodeAt(aStart + i)\n    const bCode = bStr.charCodeAt(bStart + i)\n\n    if (aCode > bCode) {\n      return 1\n    }\n    if (bCode > aCode) {\n      return -1\n    }\n  }\n\n  if (aLength > bLength) {\n    return 1\n  }\n  if (bLength > aLength) {\n    return -1\n  }\n  return 0\n}\n\nfunction compareNumericChunks(\n  aStr: string,\n  aStart: number,\n  aEnd: number,\n  bStr: string,\n  bStart: number,\n  bEnd: number,\n) {\n  let aSignificantStart = aStart\n  while (\n    aSignificantStart < aEnd &&\n    aStr.charCodeAt(aSignificantStart) === 48\n  ) {\n    aSignificantStart++\n  }\n\n  let bSignificantStart = bStart\n  while (\n    bSignificantStart < bEnd &&\n    bStr.charCodeAt(bSignificantStart) === 48\n  ) {\n    bSignificantStart++\n  }\n\n  const aSignificantLength = aEnd - aSignificantStart\n  const bSignificantLength = bEnd - bSignificantStart\n\n  if (aSignificantLength === 0 && bSignificantLength === 0) {\n    return 0\n  }\n\n  if (aSignificantLength <= 15 && bSignificantLength <= 15) {\n    const an = parseSmallInt(aStr, aSignificantStart, aEnd)\n    const bn = parseSmallInt(bStr, bSignificantStart, bEnd)\n\n    if (an > bn) {\n      return 1\n    }\n    if (bn > an) {\n      return -1\n    }\n    return 0\n  }\n\n  // Preserve parseInt precision-collapse behavior for unusually large chunks.\n  const an = parseInt(aStr.slice(aStart, aEnd), 10)\n  const bn = parseInt(bStr.slice(bStart, bEnd), 10)\n\n  if (an > bn) {\n    return 1\n  }\n  if (bn > an) {\n    return -1\n  }\n  return 0\n}\n\nfunction parseSmallInt(str: string, start: number, end: number) {\n  let result = 0\n  for (let i = start; i < end; i++) {\n    result = result * 10 + str.charCodeAt(i) - 48\n  }\n  return result\n}\n\nfunction countRemainingChunks(str: string, start: number) {\n  let count = 0\n  let index = start\n\n  while (index < str.length) {\n    count++\n    index = findChunkEnd(str, index, isDigit(str.charCodeAt(index)))\n  }\n\n  return count\n}\n\n// Exports\n\n/**\n * The built-in sorting function registry.\n *\n * Registering this full object opts out of tree-shaking: every built-in\n * sorting function ends up in your bundle. Prefer importing the `sortFn_*`\n * functions you actually use and registering just those in the `sortFns`\n * slot, or passing them directly to the `sortFn` column option.\n *\n * @deprecated Import individual `sortFn_*` functions instead for a smaller\n * bundle. This export still works and is not going away in v9, but built-in\n * name resolution (including `sortFn: 'auto'`) only finds functions you\n * register yourself.\n */\nexport const sortFns = {\n  alphanumeric: sortFn_alphanumeric,\n  alphanumericCaseSensitive: sortFn_alphanumericCaseSensitive,\n  basic: sortFn_basic,\n  datetime: sortFn_datetime,\n  text: sortFn_text,\n  textCaseSensitive: sortFn_textCaseSensitive,\n}\n\nexport type BuiltInSortFn = keyof typeof sortFns\n"],"mappings":"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"}

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

@@ -1,98 +0,0 @@
-import { RowData } from "../../types/type-utils.cjs";
-import { CreatedSortFn, SortFnDef } from "./rowSortingFeature.types.cjs";
-import { TableFeatures } from "../../types/TableFeatures.cjs";
-
-//#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 };
-//# sourceMappingURL=sortFns.d.cts.map

package/dist/features/row-sorting/sortFns.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sortFns.js","names":[],"sources":["../../../src/features/row-sorting/sortFns.ts"],"sourcesContent":["import type { CreatedSortFn, SortFnDef } from './rowSortingFeature.types'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\n\n/**\n * Regular expression used to split mixed text and numeric chunks.\n *\n * The alphanumeric sort functions use these chunks for natural sorting of\n * strings like `item2` before `item10`.\n */\nexport const reSplitAlphaNumeric = /([0-9]+)/gm\n\n/**\n * Builds a `SortFn` from a value-level comparator plus an optional\n * `resolveDataValue` normalizer.\n *\n * The `sort` comparator receives both rows' data values, each already passed\n * through `resolveDataValue` when one is defined. Keeping normalization in the\n * resolver means a variant of an existing sorting function only has to swap\n * the resolver, not re-implement the comparison.\n *\n * The definition is attached to the returned function, so a variant can be\n * created by spreading a built-in sorting function and overriding what\n * differs:\n *\n * ```ts\n * const stripDiacritics = (value: string) =>\n *   value.normalize('NFD').replace(/\\p{Diacritic}/gu, '')\n *\n * const alphanumericIgnoreDiacritics = constructSortFn({\n *   ...sortFn_alphanumeric,\n *   resolveDataValue: (value) =>\n *     stripDiacritics(sortFn_alphanumeric.resolveDataValue!(value)),\n * })\n * ```\n */\nexport function constructSortFn<\n  TFeatures extends TableFeatures = any,\n  TData extends RowData = any,\n>(def: SortFnDef<TFeatures, TData>): CreatedSortFn<TFeatures, TData> {\n  const sortFn: CreatedSortFn<TFeatures, TData> = Object.assign(\n    <TRowFeatures extends TableFeatures, TRowData extends RowData>(\n      rowA: Row<TRowFeatures, TRowData>,\n      rowB: Row<TRowFeatures, TRowData>,\n      columnId: string,\n    ): number => {\n      let dataValueA = rowA.getValue(columnId)\n      let dataValueB = rowB.getValue(columnId)\n      const resolveDataValue = sortFn.resolveDataValue\n      if (resolveDataValue) {\n        dataValueA = resolveDataValue(dataValueA)\n        dataValueB = resolveDataValue(dataValueB)\n      }\n      // The def's comparator is typed against the factory's TFeatures/TData;\n      // the caller's row generics are erased at this boundary.\n      return sortFn.sort(\n        dataValueA,\n        dataValueB,\n        rowA as any,\n        rowB as any,\n        columnId,\n      )\n    },\n    def,\n  )\n  return sortFn\n}\n\n/**\n * Sorts rows with the built-in alphanumeric strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumeric = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),\n  sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB),\n})\n\n/**\n * Sorts rows with the built-in alphanumeric case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumericCaseSensitive = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue),\n  sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB),\n})\n\n// The text sort is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_text = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),\n  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),\n})\n\n// The text sort is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_textCaseSensitive = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue),\n  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),\n})\n\n/**\n * Sorts rows with the built-in datetime strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_datetime = constructSortFn({\n  resolveDataValue: (dataValue) => toDateSortValue(dataValue),\n  // Can handle nullish values\n  // Use > and < because == (and ===) doesn't work with\n  // Date objects (would require calling getTime()).\n  sort: (dataValueA, dataValueB) =>\n    dataValueA > dataValueB ? 1 : dataValueA < dataValueB ? -1 : 0,\n})\n\n/**\n * Sorts rows with the built-in basic strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_basic = constructSortFn({\n  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),\n})\n\n// Utils\n\nfunction compareBasic(a: any, b: any) {\n  return a === b ? 0 : a > b ? 1 : -1\n}\n\nfunction toDateSortValue(value: any) {\n  return value instanceof Date ? value.getTime() : value\n}\n\nfunction toString(a: any) {\n  if (typeof a === 'number') {\n    if (isNaN(a) || a === Infinity || a === -Infinity) {\n      return ''\n    }\n    return String(a)\n  }\n  if (typeof a === 'string') {\n    return a\n  }\n  return ''\n}\n\n// Mixed sorting is slow, but very inclusive of many edge cases.\n// It handles numbers, mixed alphanumeric combinations, and even\n// null, undefined, and Infinity\nfunction compareAlphanumeric(aStr: string, bStr: string) {\n  let ai = 0\n  let bi = 0\n  const aLen = aStr.length\n  const bLen = bStr.length\n\n  while (ai < aLen && bi < bLen) {\n    const aIsNumeric = isDigit(aStr.charCodeAt(ai))\n    const bIsNumeric = isDigit(bStr.charCodeAt(bi))\n\n    const aEnd = findChunkEnd(aStr, ai, aIsNumeric)\n    const bEnd = findChunkEnd(bStr, bi, bIsNumeric)\n\n    // Both are string chunks\n    if (!aIsNumeric && !bIsNumeric) {\n      const stringComparison = compareStringChunks(\n        aStr,\n        ai,\n        aEnd,\n        bStr,\n        bi,\n        bEnd,\n      )\n      if (stringComparison) {\n        return stringComparison\n      }\n      ai = aEnd\n      bi = bEnd\n      continue\n    }\n\n    // One is a string chunk, one is a number chunk — the string sorts first\n    if (aIsNumeric !== bIsNumeric) {\n      return aIsNumeric ? 1 : -1\n    }\n\n    // Both are numeric chunks\n    const numericComparison = compareNumericChunks(\n      aStr,\n      ai,\n      aEnd,\n      bStr,\n      bi,\n      bEnd,\n    )\n    if (numericComparison) {\n      return numericComparison\n    }\n\n    ai = aEnd\n    bi = bEnd\n  }\n\n  // One side is exhausted — compare the counts of remaining non-empty chunks\n  return countRemainingChunks(aStr, ai) - countRemainingChunks(bStr, bi)\n}\n\nfunction isDigit(charCode: number) {\n  return charCode >= 48 && charCode <= 57\n}\n\nfunction findChunkEnd(str: string, start: number, isNumeric: boolean) {\n  let end = start + 1\n  while (end < str.length && isDigit(str.charCodeAt(end)) === isNumeric) {\n    end++\n  }\n  return end\n}\n\nfunction compareStringChunks(\n  aStr: string,\n  aStart: number,\n  aEnd: number,\n  bStr: string,\n  bStart: number,\n  bEnd: number,\n) {\n  const aLength = aEnd - aStart\n  const bLength = bEnd - bStart\n  const minLength = aLength < bLength ? aLength : bLength\n\n  for (let i = 0; i < minLength; i++) {\n    const aCode = aStr.charCodeAt(aStart + i)\n    const bCode = bStr.charCodeAt(bStart + i)\n\n    if (aCode > bCode) {\n      return 1\n    }\n    if (bCode > aCode) {\n      return -1\n    }\n  }\n\n  if (aLength > bLength) {\n    return 1\n  }\n  if (bLength > aLength) {\n    return -1\n  }\n  return 0\n}\n\nfunction compareNumericChunks(\n  aStr: string,\n  aStart: number,\n  aEnd: number,\n  bStr: string,\n  bStart: number,\n  bEnd: number,\n) {\n  let aSignificantStart = aStart\n  while (\n    aSignificantStart < aEnd &&\n    aStr.charCodeAt(aSignificantStart) === 48\n  ) {\n    aSignificantStart++\n  }\n\n  let bSignificantStart = bStart\n  while (\n    bSignificantStart < bEnd &&\n    bStr.charCodeAt(bSignificantStart) === 48\n  ) {\n    bSignificantStart++\n  }\n\n  const aSignificantLength = aEnd - aSignificantStart\n  const bSignificantLength = bEnd - bSignificantStart\n\n  if (aSignificantLength === 0 && bSignificantLength === 0) {\n    return 0\n  }\n\n  if (aSignificantLength <= 15 && bSignificantLength <= 15) {\n    const an = parseSmallInt(aStr, aSignificantStart, aEnd)\n    const bn = parseSmallInt(bStr, bSignificantStart, bEnd)\n\n    if (an > bn) {\n      return 1\n    }\n    if (bn > an) {\n      return -1\n    }\n    return 0\n  }\n\n  // Preserve parseInt precision-collapse behavior for unusually large chunks.\n  const an = parseInt(aStr.slice(aStart, aEnd), 10)\n  const bn = parseInt(bStr.slice(bStart, bEnd), 10)\n\n  if (an > bn) {\n    return 1\n  }\n  if (bn > an) {\n    return -1\n  }\n  return 0\n}\n\nfunction parseSmallInt(str: string, start: number, end: number) {\n  let result = 0\n  for (let i = start; i < end; i++) {\n    result = result * 10 + str.charCodeAt(i) - 48\n  }\n  return result\n}\n\nfunction countRemainingChunks(str: string, start: number) {\n  let count = 0\n  let index = start\n\n  while (index < str.length) {\n    count++\n    index = findChunkEnd(str, index, isDigit(str.charCodeAt(index)))\n  }\n\n  return count\n}\n\n// Exports\n\n/**\n * The built-in sorting function registry.\n *\n * Registering this full object opts out of tree-shaking: every built-in\n * sorting function ends up in your bundle. Prefer importing the `sortFn_*`\n * functions you actually use and registering just those in the `sortFns`\n * slot, or passing them directly to the `sortFn` column option.\n *\n * @deprecated Import individual `sortFn_*` functions instead for a smaller\n * bundle. This export still works and is not going away in v9, but built-in\n * name resolution (including `sortFn: 'auto'`) only finds functions you\n * register yourself.\n */\nexport const sortFns = {\n  alphanumeric: sortFn_alphanumeric,\n  alphanumericCaseSensitive: sortFn_alphanumericCaseSensitive,\n  basic: sortFn_basic,\n  datetime: sortFn_datetime,\n  text: sortFn_text,\n  textCaseSensitive: sortFn_textCaseSensitive,\n}\n\nexport type BuiltInSortFn = keyof typeof sortFns\n"],"mappings":"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"}