@tanstack/table-core 9.0.0-alpha.4 → 9.0.0-alpha.41

package/src/features/stockFeatures.ts

@@ -0,0 +1,48 @@
+import { columnFacetingFeature } from './column-faceting/columnFacetingFeature'
+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 {
+  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
+}
+
+export const stockFeatures: StockFeatures = {
+  columnFacetingFeature,
+  columnFilteringFeature,
+  columnGroupingFeature,
+  columnOrderingFeature,
+  columnPinningFeature,
+  columnResizingFeature,
+  columnSizingFeature,
+  columnVisibilityFeature,
+  globalFilteringFeature,
+  rowExpandingFeature,
+  rowPaginationFeature,
+  rowPinningFeature,
+  rowSelectionFeature,
+  rowSortingFeature,
+} as const

package/src/features/table-reactivity/tableReactivityFeature.ts

@@ -0,0 +1,92 @@
+import type { ReadonlyStore, Store } from '@tanstack/store'
+import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
+import type { RowData } from '../../types/type-utils'
+
+export interface TableReactivityFeatureConstructors<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {}
+
+export function constructReactivityFeature<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(bindings: {
+  stateNotifier?: () => unknown
+  optionsNotifier?: () => unknown
+}): TableFeature<TableReactivityFeatureConstructors<TFeatures, TData>> {
+  return {
+    constructTableAPIs: (table) => {
+      table.optionsStore = bindStore(
+        table.optionsStore,
+        bindings.optionsNotifier,
+      )
+      table.atoms = bindAtoms(table.atoms, bindings.stateNotifier)
+    },
+  }
+}
+
+const bindStore = <T extends Store<any> | ReadonlyStore<any>>(
+  store: T,
+  notifier?: () => unknown,
+): T => {
+  const stateDescriptor = Object.getOwnPropertyDescriptor(
+    Object.getPrototypeOf(store),
+    'state',
+  )!
+
+  Object.defineProperty(store, 'state', {
+    configurable: true,
+    enumerable: true,
+    get() {
+      notifier?.()
+      return stateDescriptor.get!.call(store)
+    },
+  })
+
+  return store
+}
+
+// Wraps an atoms/baseAtoms map so that `.get()` on any individual atom
+// calls the framework notifier first — matching how `bindStore` wraps
+// `store.state`. The proxy also transparently forwards missing slices
+// (atoms for features not registered on this table) as `undefined`.
+const bindAtoms = <T extends object>(atoms: T, notifier?: () => unknown): T => {
+  if (!notifier) return atoms
+  // Cache wrapped atoms so referential identity is stable per slice.
+  const wrappedCache = new Map<PropertyKey, any>()
+  return new Proxy(atoms, {
+    get(target, prop, receiver) {
+      const atom = Reflect.get(target, prop, receiver) as unknown
+      if (!atom || typeof prop !== 'string' || !isAtomLike(atom)) {
+        return atom
+      }
+      if (wrappedCache.has(prop)) return wrappedCache.get(prop)
+      const originalGet = atom.get.bind(atom)
+      const wrapped = new Proxy(atom, {
+        get(atomTarget, atomProp, atomReceiver) {
+          if (atomProp === 'get') {
+            return () => {
+              notifier()
+              return originalGet()
+            }
+          }
+          return Reflect.get(atomTarget, atomProp, atomReceiver)
+        },
+      })
+      wrappedCache.set(prop, wrapped)
+      return wrapped
+    },
+  })
+}
+
+interface AtomLike {
+  get: () => unknown
+}
+
+function isAtomLike(value: unknown): value is AtomLike {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { get?: unknown }).get === 'function'
+  )
+}

package/src/flex-render.ts

@@ -0,0 +1,60 @@
+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'
+
+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
+    }
+
+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/fns/aggregationFns.ts

@@ -0,0 +1,220 @@
+import { isNumberArray } from '../utils'
+import type { RowData } from '../types/type-utils'
+import type { TableFeatures } from '../types/TableFeatures'
+import type { Row } from '../types/Row'
+import type { AggregationFn } from '../features/column-grouping/columnGroupingFeature.types'
+
+/**
+ * Aggregation function for summing up the values of a column.
+ */
+export const aggregationFn_sum: AggregationFn<any, any> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  columnId: string,
+  _leafRows: Array<Row<any, any>>,
+  childRows: Array<Row<any, any>>,
+) => {
+  // It's faster to just add the aggregations together instead of
+  // process leaf nodes individually
+  return childRows.reduce((sumValue, next) => {
+    const nextValue = next.getValue(columnId)
+    return sumValue + (typeof nextValue === 'number' ? nextValue : 0)
+  }, 0)
+}
+
+/**
+ * Aggregation function for finding the minimum value of a column.
+ */
+export const aggregationFn_min: AggregationFn<any, any> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  columnId: string,
+  _leafRows: Array<Row<any, any>>,
+  childRows: Array<Row<any, any>>,
+) => {
+  let minValue: number | undefined
+
+  childRows.forEach((row) => {
+    const value = row.getValue(columnId)
+
+    if (
+      value != null &&
+      typeof value === 'number' &&
+      (minValue === undefined || value < minValue)
+    ) {
+      minValue = value
+    }
+  })
+
+  return minValue
+}
+
+/**
+ * Aggregation function for finding the maximum value of a column.
+ */
+export const aggregationFn_max: AggregationFn<any, any> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  columnId: string,
+  _leafRows: Array<Row<any, any>>,
+  childRows: Array<Row<any, any>>,
+) => {
+  let maxValue: number | undefined
+
+  childRows.forEach((row) => {
+    const value = row.getValue(columnId)
+    if (
+      value != null &&
+      typeof value === 'number' &&
+      (maxValue === undefined || value > maxValue)
+    ) {
+      maxValue = value
+    }
+  })
+
+  return maxValue
+}
+
+/**
+ * Aggregation function for finding the extent (min and max) of a column.
+ */
+export const aggregationFn_extent: AggregationFn<any, any> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  columnId: string,
+  _leafRows: Array<Row<any, any>>,
+  childRows: Array<Row<any, any>>,
+) => {
+  let minValue: number | undefined
+  let maxValue: number | undefined
+
+  childRows.forEach((row) => {
+    const value = row.getValue(columnId)
+    if (value != null && typeof value === 'number') {
+      if (minValue === undefined) {
+        minValue = maxValue = value
+      } else {
+        if (minValue > value) minValue = value
+        if (maxValue! < value) maxValue = value
+      }
+    }
+  })
+
+  return [minValue, maxValue]
+}
+
+/**
+ * Aggregation function for finding the mean (average) of a column.
+ */
+export const aggregationFn_mean: AggregationFn<any, any> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  columnId: string,
+  leafRows: Array<Row<any, any>>,
+) => {
+  let count = 0
+  let sumValue = 0
+
+  leafRows.forEach((row) => {
+    const value = row.getValue(columnId)
+    if (value != null && typeof value === 'number') {
+      ++count
+      sumValue += value
+    } else if (value != null) {
+      const numValue = +value
+      if (!Number.isNaN(numValue)) {
+        ++count
+        sumValue += numValue
+      }
+    }
+  })
+
+  if (count) return sumValue / count
+
+  return
+}
+
+/**
+ * Aggregation function for finding the median value of a column.
+ */
+export const aggregationFn_median: AggregationFn<any, any> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  columnId: string,
+  leafRows: Array<Row<any, any>>,
+) => {
+  if (!leafRows.length) {
+    return
+  }
+
+  const values = leafRows.map((row) => row.getValue(columnId))
+  if (!isNumberArray(values)) {
+    return
+  }
+  if (values.length === 1) {
+    return values[0]
+  }
+
+  const mid = Math.floor(values.length / 2)
+  const nums = values.sort((a, b) => a - b)
+  return values.length % 2 !== 0 ? nums[mid] : (nums[mid - 1]! + nums[mid]!) / 2
+}
+
+/**
+ * Aggregation function for finding the unique values of a column.
+ */
+export const aggregationFn_unique: AggregationFn<any, any> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  columnId: string,
+  leafRows: Array<Row<any, any>>,
+) => {
+  return Array.from(new Set(leafRows.map((d) => d.getValue(columnId))).values())
+}
+
+/**
+ * Aggregation function for finding the count of unique values of a column.
+ */
+export const aggregationFn_uniqueCount: AggregationFn<any, any> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  columnId: string,
+  leafRows: Array<Row<any, any>>,
+) => {
+  return new Set(leafRows.map((d) => d.getValue(columnId))).size
+}
+
+/**
+ * Aggregation function for counting the number of rows in a column.
+ */
+export const aggregationFn_count: AggregationFn<any, any> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  _columnId: string,
+  leafRows: Array<Row<any, any>>,
+) => {
+  return leafRows.length
+}
+
+export const aggregationFns = {
+  sum: aggregationFn_sum,
+  min: aggregationFn_min,
+  max: aggregationFn_max,
+  extent: aggregationFn_extent,
+  mean: aggregationFn_mean,
+  median: aggregationFn_median,
+  unique: aggregationFn_unique,
+  uniqueCount: aggregationFn_uniqueCount,
+  count: aggregationFn_count,
+}
+
+export type BuiltInAggregationFn = keyof typeof aggregationFns