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

package/src/features/row-sorting/sortFns.ts

@@ -1,366 +0,0 @@
-import type { CreatedSortFn, SortFnDef } from './rowSortingFeature.types'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeatures } from '../../types/TableFeatures'
-import type { Row } from '../../types/Row'
-
-/**
- * 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`.
- */
-export 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)),
- * })
- * ```
- */
-export function constructSortFn<
-  TFeatures extends TableFeatures = any,
-  TData extends RowData = any,
->(def: SortFnDef<TFeatures, TData>): CreatedSortFn<TFeatures, TData> {
-  const sortFn: CreatedSortFn<TFeatures, TData> = Object.assign(
-    <TRowFeatures extends TableFeatures, TRowData extends RowData>(
-      rowA: Row<TRowFeatures, TRowData>,
-      rowB: Row<TRowFeatures, TRowData>,
-      columnId: string,
-    ): number => {
-      let dataValueA = rowA.getValue(columnId)
-      let dataValueB = rowB.getValue(columnId)
-      const resolveDataValue = sortFn.resolveDataValue
-      if (resolveDataValue) {
-        dataValueA = resolveDataValue(dataValueA)
-        dataValueB = resolveDataValue(dataValueB)
-      }
-      // The def's comparator is typed against the factory's TFeatures/TData;
-      // the caller's row generics are erased at this boundary.
-      return sortFn.sort(
-        dataValueA,
-        dataValueB,
-        rowA as any,
-        rowB as any,
-        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.
- */
-export 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.
- */
-export const sortFn_alphanumericCaseSensitive = constructSortFn({
-  resolveDataValue: (dataValue) => toString(dataValue),
-  sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB),
-})
-
-// The text sort is more basic (less numeric support)
-// but is much faster
-/**
- * Sorts rows with the built-in text strategy.
- *
- * This comparator returns ascending-order results; descending order is applied by the sorting row model.
- */
-export const sortFn_text = constructSortFn({
-  resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),
-  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),
-})
-
-// The text sort is more basic (less numeric support)
-// but is much faster
-/**
- * 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.
- */
-export 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.
- */
-export const sortFn_datetime = constructSortFn({
-  resolveDataValue: (dataValue) => toDateSortValue(dataValue),
-  // Can handle nullish values
-  // Use > and < because == (and ===) doesn't work with
-  // Date objects (would require calling getTime()).
-  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.
- */
-export const sortFn_basic = constructSortFn({
-  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),
-})
-
-// Utils
-
-function compareBasic(a: any, b: any) {
-  return a === b ? 0 : a > b ? 1 : -1
-}
-
-function toDateSortValue(value: any) {
-  return value instanceof Date ? value.getTime() : value
-}
-
-function toString(a: any) {
-  if (typeof a === 'number') {
-    if (isNaN(a) || a === Infinity || a === -Infinity) {
-      return ''
-    }
-    return String(a)
-  }
-  if (typeof a === 'string') {
-    return a
-  }
-  return ''
-}
-
-// Mixed sorting is slow, but very inclusive of many edge cases.
-// It handles numbers, mixed alphanumeric combinations, and even
-// null, undefined, and Infinity
-function compareAlphanumeric(aStr: string, bStr: string) {
-  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)
-
-    // Both are string chunks
-    if (!aIsNumeric && !bIsNumeric) {
-      const stringComparison = compareStringChunks(
-        aStr,
-        ai,
-        aEnd,
-        bStr,
-        bi,
-        bEnd,
-      )
-      if (stringComparison) {
-        return stringComparison
-      }
-      ai = aEnd
-      bi = bEnd
-      continue
-    }
-
-    // One is a string chunk, one is a number chunk — the string sorts first
-    if (aIsNumeric !== bIsNumeric) {
-      return aIsNumeric ? 1 : -1
-    }
-
-    // Both are numeric chunks
-    const numericComparison = compareNumericChunks(
-      aStr,
-      ai,
-      aEnd,
-      bStr,
-      bi,
-      bEnd,
-    )
-    if (numericComparison) {
-      return numericComparison
-    }
-
-    ai = aEnd
-    bi = bEnd
-  }
-
-  // One side is exhausted — compare the counts of remaining non-empty chunks
-  return countRemainingChunks(aStr, ai) - countRemainingChunks(bStr, bi)
-}
-
-function isDigit(charCode: number) {
-  return charCode >= 48 && charCode <= 57
-}
-
-function findChunkEnd(str: string, start: number, isNumeric: boolean) {
-  let end = start + 1
-  while (end < str.length && isDigit(str.charCodeAt(end)) === isNumeric) {
-    end++
-  }
-  return end
-}
-
-function compareStringChunks(
-  aStr: string,
-  aStart: number,
-  aEnd: number,
-  bStr: string,
-  bStart: number,
-  bEnd: number,
-) {
-  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: string,
-  aStart: number,
-  aEnd: number,
-  bStr: string,
-  bStart: number,
-  bEnd: number,
-) {
-  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
-  }
-
-  // Preserve parseInt precision-collapse behavior for unusually large chunks.
-  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: string, start: number, end: number) {
-  let result = 0
-  for (let i = start; i < end; i++) {
-    result = result * 10 + str.charCodeAt(i) - 48
-  }
-  return result
-}
-
-function countRemainingChunks(str: string, start: number) {
-  let count = 0
-  let index = start
-
-  while (index < str.length) {
-    count++
-    index = findChunkEnd(str, index, isDigit(str.charCodeAt(index)))
-  }
-
-  return count
-}
-
-// Exports
-
-/**
- * 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.
- */
-export const sortFns = {
-  alphanumeric: sortFn_alphanumeric,
-  alphanumericCaseSensitive: sortFn_alphanumericCaseSensitive,
-  basic: sortFn_basic,
-  datetime: sortFn_datetime,
-  text: sortFn_text,
-  textCaseSensitive: sortFn_textCaseSensitive,
-}
-
-export type BuiltInSortFn = keyof typeof sortFns

package/src/features/stockFeatures.ts

@@ -1,56 +0,0 @@
-import { columnFacetingFeature } from './column-faceting/columnFacetingFeature'
-import { rowAggregationFeature } from './row-aggregation/rowAggregationFeature'
-import { columnFilteringFeature } from './column-filtering/columnFilteringFeature'
-import { columnGroupingFeature } from './column-grouping/columnGroupingFeature'
-import { columnOrderingFeature } from './column-ordering/columnOrderingFeature'
-import { columnPinningFeature } from './column-pinning/columnPinningFeature'
-import { columnResizingFeature } from './column-resizing/columnResizingFeature'
-import { columnSizingFeature } from './column-sizing/columnSizingFeature'
-import { columnVisibilityFeature } from './column-visibility/columnVisibilityFeature'
-import { globalFilteringFeature } from './global-filtering/globalFilteringFeature'
-import { rowExpandingFeature } from './row-expanding/rowExpandingFeature'
-import { rowPaginationFeature } from './row-pagination/rowPaginationFeature'
-import { rowPinningFeature } from './row-pinning/rowPinningFeature'
-import { rowSelectionFeature } from './row-selection/rowSelectionFeature'
-import { rowSortingFeature } from './row-sorting/rowSortingFeature'
-
-export interface StockFeatures {
-  rowAggregationFeature: typeof rowAggregationFeature
-  columnFacetingFeature: typeof columnFacetingFeature
-  columnFilteringFeature: typeof columnFilteringFeature
-  columnGroupingFeature: typeof columnGroupingFeature
-  columnOrderingFeature: typeof columnOrderingFeature
-  columnPinningFeature: typeof columnPinningFeature
-  columnResizingFeature: typeof columnResizingFeature
-  columnSizingFeature: typeof columnSizingFeature
-  columnVisibilityFeature: typeof columnVisibilityFeature
-  globalFilteringFeature: typeof globalFilteringFeature
-  rowExpandingFeature: typeof rowExpandingFeature
-  rowPaginationFeature: typeof rowPaginationFeature
-  rowPinningFeature: typeof rowPinningFeature
-  rowSelectionFeature: typeof rowSelectionFeature
-  rowSortingFeature: typeof rowSortingFeature
-}
-
-/**
- * The complete set of stock optional table features.
- *
- * Use individual feature exports for tree-shaking, or this aggregate when a table should include every built-in feature.
- */
-export const stockFeatures: StockFeatures = {
-  rowAggregationFeature,
-  columnFacetingFeature,
-  columnFilteringFeature,
-  columnGroupingFeature,
-  columnOrderingFeature,
-  columnPinningFeature,
-  columnResizingFeature,
-  columnSizingFeature,
-  columnVisibilityFeature,
-  globalFilteringFeature,
-  rowExpandingFeature,
-  rowPaginationFeature,
-  rowPinningFeature,
-  rowSelectionFeature,
-  rowSortingFeature,
-} as const

package/src/flex-render.ts

@@ -1,70 +0,0 @@
-import type { Cell } from './types/Cell'
-import type { Header } from './types/Header'
-import type { TableFeatures } from './types/TableFeatures'
-import type { CellData, RowData } from './types/type-utils'
-
-/**
- * Renders a static value or render function with the provided props.
- *
- * Framework adapters use this helper to support column definitions that contain either plain values or template functions.
- */
-export function flexRender<TProps extends object>(
-  comp: unknown,
-  props: TProps,
-): unknown | null {
-  if (comp == null) return null
-
-  if (typeof comp === 'function') {
-    return comp(props)
-  }
-
-  return comp
-}
-
-export type FlexRenderProps<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
-> =
-  | { cell: Cell<TFeatures, TData, TValue>; header?: never; footer?: never }
-  | {
-      header: Header<TFeatures, TData, TValue>
-      cell?: never
-      footer?: never
-    }
-  | {
-      footer: Header<TFeatures, TData, TValue>
-      cell?: never
-      header?: never
-    }
-
-/**
- * Renders a static value or render function with the provided props.
- *
- * Framework adapters use this helper to support column definitions that contain either plain values or template functions.
- */
-export function FlexRender<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
->(props: FlexRenderProps<TFeatures, TData, TValue>): unknown | null {
-  if ('cell' in props && props.cell) {
-    return flexRender(props.cell.column.columnDef.cell, props.cell.getContext())
-  }
-
-  if ('header' in props && props.header) {
-    return flexRender(
-      props.header.column.columnDef.header,
-      props.header.getContext(),
-    )
-  }
-
-  if ('footer' in props && props.footer) {
-    return flexRender(
-      props.footer.column.columnDef.footer,
-      props.footer.getContext(),
-    )
-  }
-
-  return null
-}

package/src/helpers/columnHelper.ts

@@ -1,122 +0,0 @@
-import type { DeepKeys, DeepValue, RowData } from '../types/type-utils'
-import type { TableFeatures } from '../types/TableFeatures'
-import type {
-  AccessorFn,
-  AccessorFnColumnDef,
-  AccessorKeyColumnDef,
-  ColumnDef,
-  DisplayColumnDef,
-  GroupColumnDef,
-  IdentifiedColumnDef,
-} from '../types/ColumnDef'
-
-export interface ColumnHelper<
-  in out TFeatures extends TableFeatures,
-  in out TData extends RowData,
-> {
-  /**
-   * Creates a data column definition with an accessor key or function to extract the cell value.
-   * @example
-   * ```ts
-   * helper.accessor('firstName', { cell: (info) => info.getValue() })
-   * helper.accessor((row) => row.lastName, { id: 'lastName' })
-   * ```
-   */
-  accessor: <
-    TAccessor extends AccessorFn<TData> | DeepKeys<TData>,
-    TValue extends TAccessor extends AccessorFn<TData, infer TReturn>
-      ? TReturn
-      : TAccessor extends DeepKeys<TData>
-        ? DeepValue<TData, TAccessor>
-        : never,
-  >(
-    accessor: TAccessor,
-    column: TAccessor extends AccessorFn<TData>
-      ? DisplayColumnDef<TFeatures, TData, TValue>
-      : IdentifiedColumnDef<TFeatures, TData, TValue>,
-  ) => TAccessor extends AccessorFn<TData>
-    ? AccessorFnColumnDef<TFeatures, TData, TValue>
-    : AccessorKeyColumnDef<TFeatures, TData, TValue>
-  /**
-   * Wraps an array of column definitions to preserve each column's individual TValue type.
-   * Uses variadic tuple types to infer element types before checking constraints, preventing type widening.
-   * @example
-   * ```ts
-   * helper.columns([helper.accessor('firstName', {}), helper.accessor('age', {})])
-   * ```
-   */
-  columns: <TColumns extends ReadonlyArray<ColumnDef<TFeatures, TData, any>>>(
-    columns: [...TColumns],
-  ) => Array<ColumnDef<TFeatures, TData, any>> & [...TColumns]
-  /**
-   * Creates a display column definition for non-data columns like actions or row selection.
-   * @example
-   * ```ts
-   * helper.display({ id: 'actions', header: 'Actions', cell: () => <button>Edit</button> })
-   * ```
-   */
-  display: (
-    column: DisplayColumnDef<TFeatures, TData>,
-  ) => DisplayColumnDef<TFeatures, TData, unknown>
-  /**
-   * Creates a group column definition that contains nested child columns.
-   * @example
-   * ```ts
-   * helper.group({
-   *   id: 'name',
-   *   header: 'Name',
-   *   columns: helper.columns([
-   *     helper.accessor('firstName', {}),
-   *     helper.accessor('lastName', { id: 'lastName' }),
-   *   ]),
-   * })
-   * ```
-   */
-  group: (
-    column: GroupColumnDef<TFeatures, TData, unknown>,
-  ) => GroupColumnDef<TFeatures, TData, unknown>
-}
-
-/**
- * Creates helper functions for authoring column definitions with stronger value
- * inference.
- *
- * `accessor` infers `TValue` from an accessor key or accessor function,
- * `display` creates non-data columns, `group` creates parent columns, and
- * `columns` preserves tuple-level value types for arrays. At runtime these
- * helpers only return column definition objects.
- *
- * @example
- * ```tsx
- * const helper = createColumnHelper<typeof features, Person>() // features is the result of `tableFeatures({})` helper
- * const columns = [
- *  helper.display({ id: 'actions', header: 'Actions' }),
- *  helper.accessor('firstName', {}),
- *  helper.accessor((row) => row.lastName, { id: 'lastName' }),
- * ]
- * ```
- */
-export function createColumnHelper<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): ColumnHelper<TFeatures, TData> {
-  return {
-    accessor: (accessor, column) => {
-      return typeof accessor === 'function'
-        ? ({
-            ...column,
-            accessorFn: accessor,
-          } as any)
-        : {
-            ...column,
-            accessorKey: accessor,
-          }
-    },
-    columns: <TColumns extends ReadonlyArray<ColumnDef<TFeatures, TData, any>>>(
-      columns: [...TColumns],
-    ): Array<ColumnDef<TFeatures, TData, any>> & [...TColumns] =>
-      columns as Array<ColumnDef<TFeatures, TData, any>> & [...TColumns],
-    display: (column) => column,
-    group: (column) => column,
-  }
-}

package/src/helpers/metaHelper.ts

@@ -1,24 +0,0 @@
-/**
- * A helper for declaring the `tableMeta`/`columnMeta` type-only slots in the
- * `features` option without a type assertion.
- *
- * Equivalent to `{} as TMeta`, but reads as type-only at the call site and
- * avoids `@typescript-eslint/no-unnecessary-type-assertion` false positives
- * when the meta type has only optional properties (where an auto-fix removing
- * the assertion would silently degrade the inferred meta type to `{}`).
- *
- * The returned value is a phantom — it is ignored and stripped from the
- * table's registered features at runtime; only its type is used.
- * @example
- * ```
- * import { metaHelper, tableFeatures, rowSortingFeature } from '@tanstack/react-table'
- * const features = tableFeatures({
- *   rowSortingFeature,
- *   tableMeta: metaHelper<MyTableMeta>(),
- *   columnMeta: metaHelper<MyColumnMeta>(),
- * });
- * ```
- */
-export function metaHelper<TMeta extends object>(): TMeta {
-  return {} as TMeta
-}

package/src/helpers/tableFeatures.ts

@@ -1,56 +0,0 @@
-import type {
-  TableFeatures,
-  ValidateFeatureSlots,
-} from '../types/TableFeatures'
-
-/**
- * A helper function to help define the features that are to be imported and applied to a table instance.
- * Use this utility to make it easier to have the correct type inference for the features that are being imported.
- * **Note:** It is recommended to use this utility statically outside of a component.
- *
- * Alongside feature modules, this object carries everything else that is
- * statically stitched into the table:
- *
- * - Row model factories (`sortedRowModel`, `filteredRowModel`, etc.)
- * - Row model function registries (`sortFns`, `filterFns`, `aggregationFns`),
- *   whose keys become the valid string values for `sortFn`, `filterFn`,
- *   `globalFilterFn`, and `aggregationFn` with full inference
- * - Type-only `tableMeta`/`columnMeta` slots for declaring per-table meta types
- *   instead of using global declaration merging. The values are phantom
- *   (ignored and stripped at runtime); only their types are used.
- * @example
- * ```
- * import {
- *   columnFilteringFeature,
- *   createFilteredRowModel,
- *   createSortedRowModel,
- *   filterFn_includesString,
- *   rowSortingFeature,
- *   sortFn_alphanumeric,
- *   sortFn_text,
- *   tableFeatures,
- * } from '@tanstack/react-table'
- * const features = tableFeatures({
- *   columnFilteringFeature,
- *   rowSortingFeature,
- *   filteredRowModel: createFilteredRowModel(),
- *   sortedRowModel: createSortedRowModel(),
- *   filterFns: { includesString: filterFn_includesString, myCustomFilterFn },
- *   sortFns: { alphanumeric: sortFn_alphanumeric, text: sortFn_text },
- *   tableMeta: {} as { updateData: (rowIndex: number, columnId: string, value: unknown) => void },
- *   columnMeta: {} as { align?: 'left' | 'right' },
- * });
- * const table = useTable({ features, columns, data });
- * ```
- */
-export function tableFeatures<TFeatures extends TableFeatures>(
-  features: TFeatures & ValidateFeatureSlots<TFeatures>,
-): TFeatures {
-  return features
-}
-
-// test
-
-// const features = tableFeatures({
-//   rowPinningFeature: {},
-// });