@tanstack/table-core 9.0.0-beta.46 → 9.0.0-beta.47

package/src/features/column-grouping/columnGroupingFeature.utils.ts

@@ -141,6 +141,11 @@ export function column_getToggleGroupingHandler<
  * Numeric columns default to `sum`, date-like values default to `extent`, and
  * other value types leave aggregation unspecified.
  *
+ * The chosen aggregation function is looked up in the table's
+ * `aggregationFns` registry. When it is not registered there, this returns
+ * `undefined` and warns in development instead of substituting a different
+ * aggregation function.
+ *
  * @example
  * ```ts
  * const aggregationFn = column_getAutoAggregationFn(column)
@@ -159,15 +164,27 @@ export function column_getAutoAggregationFn<
 
   const value = firstRow?.getValue(column.id)
 
+  let aggregationFnName: string | undefined
+
   if (typeof value === 'number') {
-    return aggregationFns?.sum
+    aggregationFnName = 'sum'
+  } else if (Object.prototype.toString.call(value) === '[object Date]') {
+    aggregationFnName = 'extent'
   }
 
-  if (Object.prototype.toString.call(value) === '[object Date]') {
-    return aggregationFns?.extent
+  if (!aggregationFnName) {
+    return undefined
   }
 
-  return undefined
+  const aggregationFn = aggregationFns?.[aggregationFnName]
+
+  if (process.env.NODE_ENV === 'development' && !aggregationFn) {
+    console.warn(
+      `aggregationFn '${aggregationFnName}' (auto) for column '${column.id}' is not registered`,
+    )
+  }
+
+  return aggregationFn
 }
 
 /**
@@ -191,11 +208,28 @@ export function column_getAggregationFn<
     | Record<string, AggregationFn<TFeatures, TData>>
     | undefined = column.table._rowModelFns.aggregationFns
 
-  return isFunction(column.columnDef.aggregationFn)
-    ? column.columnDef.aggregationFn
-    : column.columnDef.aggregationFn === 'auto'
-      ? column_getAutoAggregationFn(column)
-      : aggregationFns?.[column.columnDef.aggregationFn as string]
+  if (isFunction(column.columnDef.aggregationFn)) {
+    return column.columnDef.aggregationFn
+  }
+
+  if (column.columnDef.aggregationFn === 'auto') {
+    return column_getAutoAggregationFn(column)
+  }
+
+  const aggregationFn =
+    aggregationFns?.[column.columnDef.aggregationFn as string]
+
+  if (
+    process.env.NODE_ENV === 'development' &&
+    !aggregationFn &&
+    column.columnDef.aggregationFn != null
+  ) {
+    console.warn(
+      `aggregationFn '${String(column.columnDef.aggregationFn)}' for column '${column.id}' is not registered`,
+    )
+  }
+
+  return aggregationFn
 }
 
 /**

package/src/features/column-grouping/createGroupedRowModel.ts

@@ -20,9 +20,12 @@ import type { RowData } from '../../types/type-utils'
  *
  * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
  *
- * Register aggregation functions with the `aggregationFns` slot on the
- * `features` option:
- * `tableFeatures({ columnGroupingFeature, groupedRowModel: createGroupedRowModel(), aggregationFns })`.
+ * Register the aggregation functions you use with the `aggregationFns` slot
+ * on the `features` option:
+ * `tableFeatures({ columnGroupingFeature, groupedRowModel: createGroupedRowModel(), aggregationFns: { sum: aggregationFn_sum } })`.
+ * Importing individual `aggregationFn_*` functions keeps unused built-ins out
+ * of your bundle; aggregation functions passed directly to the
+ * `aggregationFn` column option need no registration at all.
  */
 export function createGroupedRowModel<
   TFeatures extends TableFeatures,

package/src/features/global-filtering/globalFilteringFeature.utils.ts

@@ -74,6 +74,14 @@ export function table_getGlobalFilterFn<
       ? table_getGlobalAutoFilterFn()
       : filterFns?.[globalFilterFn as string]
 
+  if (
+    process.env.NODE_ENV === 'development' &&
+    !filterFn &&
+    globalFilterFn != null
+  ) {
+    console.warn(`globalFilterFn '${String(globalFilterFn)}' is not registered`)
+  }
+
   return filterFn
 }
 

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

@@ -14,8 +14,12 @@ import type { RowData } from '../../types/type-utils'
  *
  * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
  *
- * Register sorting functions with the `sortFns` slot on the `features` option:
- * `tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns })`.
+ * Register the sorting functions you use with the `sortFns` slot on the
+ * `features` option:
+ * `tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns: { alphanumeric: sortFn_alphanumeric } })`.
+ * Importing individual `sortFn_*` functions keeps unused built-ins out of
+ * your bundle; sorting functions passed directly to the `sortFn` column
+ * option need no registration at all.
  */
 export function createSortedRowModel<
   TFeatures extends TableFeatures,

package/src/features/row-sorting/rowSortingFeature.types.ts

@@ -1,6 +1,11 @@
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
 import type { BuiltInSortFn } from '../../fns/sortFns'
-import type { OnChangeFn, RowData, Updater } from '../../types/type-utils'
+import type {
+  OnChangeFn,
+  RowData,
+  TransformDataValueFn,
+  Updater,
+} from '../../types/type-utils'
 import type { IsAny, TableFeatures } from '../../types/TableFeatures'
 import type { Row } from '../../types/Row'
 
@@ -35,6 +40,53 @@ export interface SortFn<
     rowB: Row<TFeatures, TData>,
     columnId: string,
   ): number
+  /**
+   * Normalizes each row's value before the two sides are compared. Only
+   * honored by sorting functions built with `constructSortFn` (including all
+   * built-in sorting functions).
+   */
+  resolveDataValue?: TransformDataValueFn
+}
+
+/**
+ * The definition object accepted by `constructSortFn`.
+ *
+ * `sort` is a value-level comparator: it receives both rows' (resolved) data
+ * values instead of the whole rows, so normalization concerns stay in
+ * `resolveDataValue`.
+ */
+export interface SortFnDef<
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
+> {
+  sort: (
+    dataValueA: any,
+    dataValueB: any,
+    rowA: Row<TFeatures, TData>,
+    rowB: Row<TFeatures, TData>,
+    columnId: string,
+  ) => number
+  resolveDataValue?: TransformDataValueFn
+}
+
+/**
+ * The shape returned by `constructSortFn`: a `SortFn` with its definition
+ * attached, so variants can be built by spreading it into another
+ * `constructSortFn` call.
+ *
+ * The call signature is generic so a created sorting function can be used
+ * with any table's rows, regardless of the feature set it was defined
+ * against.
+ */
+export interface CreatedSortFn<
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
+> extends SortFnDef<TFeatures, TData> {
+  <TRowFeatures extends TableFeatures, TRowData extends RowData>(
+    rowA: Row<TRowFeatures, TRowData>,
+    rowB: Row<TRowFeatures, TRowData>,
+    columnId: string,
+  ): number
 }
 
 export type CustomSortFns<

package/src/features/row-sorting/rowSortingFeature.utils.ts

@@ -91,30 +91,50 @@ export function column_getAutoSortFn<
 
   const firstRows = column.table.getFilteredRowModel().flatRows.slice(0, 10)
 
+  let sortFnName: string | undefined
   let isString = false
 
   for (let i = 0; i < firstRows.length; i++) {
     const value = firstRows[i]!.getValue(column.id)
 
     if (Object.prototype.toString.call(value) === '[object Date]') {
-      if (sortFns?.datetime) {
-        return sortFns.datetime
-      }
+      sortFnName = 'datetime'
+      break
     }
 
     if (typeof value === 'string') {
       isString = true
 
       if (value.split(reSplitAlphaNumeric).length > 1) {
-        if (sortFns?.alphanumeric) {
-          return sortFns.alphanumeric
-        }
+        sortFnName = 'alphanumeric'
+        break
       }
     }
   }
 
-  if (isString) {
-    return sortFns?.text ?? sortFn_basic
+  if (!sortFnName && isString) {
+    sortFnName = 'text'
+  }
+
+  if (sortFnName) {
+    let sortFn = sortFns?.[sortFnName]
+
+    if (!sortFn) {
+      if (process.env.NODE_ENV === 'development') {
+        console.warn(
+          `sortFn '${sortFnName}' (auto) for column '${column.id}' is not registered`,
+        )
+      }
+
+      // String columns degrade to a registered text sort before basic
+      if (sortFnName === 'alphanumeric') {
+        sortFn = sortFns?.text
+      }
+    }
+
+    if (sortFn) {
+      return sortFn
+    }
   }
 
   return sortFn_basic
@@ -167,11 +187,23 @@ export function column_getSortFn<
   const sortFns: Record<string, SortFn<TFeatures, TData>> | undefined =
     column.table._rowModelFns.sortFns
 
-  return isFunction(column.columnDef.sortFn)
-    ? column.columnDef.sortFn
-    : column.columnDef.sortFn === 'auto'
-      ? column_getAutoSortFn(column)
-      : (sortFns?.[column.columnDef.sortFn as string] ?? sortFn_basic)
+  if (isFunction(column.columnDef.sortFn)) {
+    return column.columnDef.sortFn
+  }
+
+  if (column.columnDef.sortFn === 'auto') {
+    return column_getAutoSortFn(column)
+  }
+
+  const sortFn = sortFns?.[column.columnDef.sortFn as string]
+
+  if (process.env.NODE_ENV === 'development' && !sortFn) {
+    console.warn(
+      `sortFn '${String(column.columnDef.sortFn)}' for column '${column.id}' is not registered`,
+    )
+  }
+
+  return sortFn ?? sortFn_basic
 }
 
 /**