@tanstack/table-core 8.0.0-alpha.9 → 8.0.0-beta.0

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "@tanstack/table-core",
   "author": "Tanner Linsley",
-  "version": "8.0.0-alpha.9",
-  "description": "Hooks for building lightweight, fast and extendable datagrids for React",
+  "version": "8.0.0-beta.0",
+  "description": "Headless UI for building powerful tables & datagrids for TS/JS.",
   "license": "MIT",
-  "homepage": "https://github.com/tanstack/react-table#readme",
+  "homepage": "https://github.com/tanstack/table#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tanstack/react-table.git"
+    "url": "git+https://github.com/tanstack/table.git"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
   "keywords": [
     "react",
+    "vue",
+    "solid",
     "table",
     "table-core",
     "datagrid"
@@ -24,17 +26,14 @@
   },
   "module": "build/esm/index.js",
   "main": "build/cjs/index.js",
-  "browser": "build/umd/index.production.min.js",
+  "browser": "build/umd/index.production.js",
   "types": "build/types/index.d.ts",
+  "sideEffects": false,
   "engines": {
     "node": ">=12"
   },
   "files": [
     "build",
     "src"
-  ],
-  "peerDependencies": {
-    "react": ">=16",
-    "react-dom": ">=16"
-  }
+  ]
 }

package/src/aggregationFns.ts

@@ -0,0 +1,123 @@
+import { AggregationFn } from './features/Grouping'
+
+const sum: AggregationFn<any> = (columnId, _leafRows, childRows) => {
+  // It's faster to just add the aggregations together instead of
+  // process leaf nodes individually
+  return childRows.reduce(
+    (sum: number, next: unknown) => sum + (typeof next === 'number' ? next : 0),
+    0
+  )
+}
+
+const min: AggregationFn<any> = (columnId, _leafRows, childRows) => {
+  let min: number | undefined
+
+  childRows.forEach(row => {
+    const value = row.getValue(columnId)
+
+    if (
+      value != null &&
+      (min! > value || (min === undefined && value >= value))
+    ) {
+      min = value
+    }
+  })
+
+  return min
+}
+
+const max: AggregationFn<any> = (columnId, _leafRows, childRows) => {
+  let max: number | undefined
+
+  childRows.forEach(row => {
+    const value = row.getValue(columnId)
+    if (
+      value != null &&
+      (max! < value || (max === undefined && value >= value))
+    ) {
+      max = value
+    }
+  })
+
+  return max
+}
+
+const extent: AggregationFn<any> = (columnId, _leafRows, childRows) => {
+  let min: number | undefined
+  let max: number | undefined
+
+  childRows.forEach(row => {
+    const value = row.getValue(columnId)
+    if (value != null) {
+      if (min === undefined) {
+        if (value >= value) min = max = value
+      } else {
+        if (min > value) min = value
+        if (max! < value) max = value
+      }
+    }
+  })
+
+  return [min, max]
+}
+
+const mean: AggregationFn<any> = (columnId, leafRows) => {
+  let count = 0
+  let sum = 0
+
+  leafRows.forEach(row => {
+    let value = row.getValue(columnId)
+    if (value != null && (value = +value) >= value) {
+      ++count, (sum += value)
+    }
+  })
+
+  if (count) return sum / count
+
+  return
+}
+
+const median: AggregationFn<any> = (columnId, leafRows) => {
+  if (!leafRows.length) {
+    return
+  }
+
+  let min = 0
+  let max = 0
+
+  leafRows.forEach(row => {
+    let value = row.getValue(columnId)
+    if (typeof value === 'number') {
+      min = Math.min(min, value)
+      max = Math.max(max, value)
+    }
+  })
+
+  return (min + max) / 2
+}
+
+const unique: AggregationFn<any> = (columnId, leafRows) => {
+  return Array.from(new Set(leafRows.map(d => d.getValue(columnId))).values())
+}
+
+const uniqueCount: AggregationFn<any> = (columnId, leafRows) => {
+  return new Set(leafRows.map(d => d.getValue(columnId))).size
+}
+
+const count: AggregationFn<any> = (_columnId, leafRows) => {
+  return leafRows.length
+}
+
+export const aggregationFns = {
+  sum,
+  min,
+  max,
+  extent,
+  mean,
+  median,
+  unique,
+  uniqueCount,
+  count,
+}
+
+export type BuiltInAggregationFn = keyof typeof aggregationFns

package/src/core/cell.ts

@@ -0,0 +1,48 @@
+import { Cell, Column, Row, TableGenerics, TableInstance } from '../types'
+
+export type CoreCell<TGenerics extends TableGenerics> = {
+  id: string
+  getValue: () => TGenerics['Value']
+  row: Row<TGenerics>
+  column: Column<TGenerics>
+  renderCell: () => string | null | TGenerics['Rendered']
+}
+
+export function createCell<TGenerics extends TableGenerics>(
+  instance: TableInstance<TGenerics>,
+  row: Row<TGenerics>,
+  column: Column<TGenerics>,
+  columnId: string
+) {
+  const cell: CoreCell<TGenerics> = {
+    id: `${row.id}_${column.id}`,
+    row,
+    column,
+    getValue: () => row.getValue(columnId),
+    renderCell: () => {
+      return column.columnDef.cell
+        ? instance._render(column.columnDef.cell, {
+            instance,
+            column,
+            row,
+            cell: cell as Cell<TGenerics>,
+            getValue: cell.getValue,
+          })
+        : null
+    },
+  }
+
+  instance._features.forEach(feature => {
+    Object.assign(
+      cell,
+      feature.createCell?.(
+        cell as Cell<TGenerics>,
+        column,
+        row as Row<TGenerics>,
+        instance
+      )
+    )
+  }, {})
+
+  return cell as Cell<TGenerics>
+}

package/src/core/column.ts

@@ -0,0 +1,147 @@
+import {
+  Cell,
+  Column,
+  Header,
+  TableGenerics,
+  TableInstance,
+  Row,
+  AccessorFn,
+  ColumnDef,
+  Renderable,
+} from '../types'
+import { memo } from '../utils'
+
+export type CoreColumnDefType = 'data' | 'display' | 'group'
+
+export type CoreColumnDef<TGenerics extends TableGenerics> = {
+  id: string
+  accessorKey?: string & keyof TGenerics['Row']
+  accessorFn?: AccessorFn<TGenerics['Row']>
+  columns?: ColumnDef<TGenerics>[]
+  header?: Renderable<
+    TGenerics,
+    {
+      instance: TableInstance<TGenerics>
+      header: Header<TGenerics>
+      column: Column<TGenerics>
+    }
+  >
+  footer?: Renderable<
+    TGenerics,
+    {
+      instance: TableInstance<TGenerics>
+      header: Header<TGenerics>
+      column: Column<TGenerics>
+    }
+  >
+  cell?: Renderable<
+    TGenerics,
+    {
+      instance: TableInstance<TGenerics>
+      row: Row<TGenerics>
+      column: Column<TGenerics>
+      cell: Cell<TGenerics>
+      getValue: () => TGenerics['Value']
+    }
+  >
+  meta?: TGenerics['ColumnMeta']
+}
+
+export type CoreColumn<TGenerics extends TableGenerics> = {
+  id: string
+  depth: number
+  accessorFn?: AccessorFn<TGenerics['Row']>
+  columnDef: ColumnDef<TGenerics>
+  columnDefType: CoreColumnDefType
+  columns: Column<TGenerics>[]
+  parent?: Column<TGenerics>
+  getFlatColumns: () => Column<TGenerics>[]
+  getLeafColumns: () => Column<TGenerics>[]
+}
+
+export function createColumn<TGenerics extends TableGenerics>(
+  instance: TableInstance<TGenerics>,
+  columnDef: ColumnDef<TGenerics> & { columnDefType?: CoreColumnDefType },
+  depth: number,
+  parent?: Column<TGenerics>
+) {
+  const defaultColumn = instance._getDefaultColumnDef()
+
+  columnDef = {
+    ...defaultColumn,
+    ...columnDef,
+  }
+
+  let id =
+    columnDef.id ??
+    columnDef.accessorKey ??
+    (typeof columnDef.header === 'string' ? columnDef.header : undefined)
+
+  let accessorFn: AccessorFn<TGenerics['Row']> | undefined
+
+  if (columnDef.accessorFn) {
+    accessorFn = columnDef.accessorFn
+  } else if (columnDef.accessorKey) {
+    accessorFn = (originalRow?: TGenerics['Row']) =>
+      (originalRow as any)[columnDef.accessorKey]
+  }
+
+  if (!id) {
+    if (process.env.NODE_ENV !== 'production') {
+      throw new Error(
+        columnDef.accessorFn
+          ? `Columns require an id when using an accessorFn`
+          : `Columns require an id when using a non-string header`
+      )
+    }
+    throw new Error()
+  }
+
+  let column: CoreColumn<TGenerics> = {
+    id: `${id}`,
+    accessorFn,
+    parent: parent as any,
+    depth,
+    columnDef,
+    columnDefType: columnDef.columnDefType as CoreColumnDefType,
+    columns: [],
+    getFlatColumns: memo(
+      () => [true],
+      () => {
+        return [
+          column as Column<TGenerics>,
+          ...column.columns?.flatMap(d => d.getFlatColumns()),
+        ]
+      },
+      {
+        key: process.env.NODE_ENV === 'production' && 'column.getFlatColumns',
+        debug: () => instance.options.debugAll ?? instance.options.debugColumns,
+      }
+    ),
+    getLeafColumns: memo(
+      () => [instance._getOrderColumnsFn()],
+      orderColumns => {
+        if (column.columns?.length) {
+          let leafColumns = column.columns.flatMap(column =>
+            column.getLeafColumns()
+          )
+
+          return orderColumns(leafColumns)
+        }
+
+        return [column as Column<TGenerics>]
+      },
+      {
+        key: process.env.NODE_ENV === 'production' && 'column.getLeafColumns',
+        debug: () => instance.options.debugAll ?? instance.options.debugColumns,
+      }
+    ),
+  }
+
+  column = instance._features.reduce((obj, feature) => {
+    return Object.assign(obj, feature.createColumn?.(column, instance))
+  }, column)
+
+  // Yes, we have to convert instance to uknown, because we know more than the compiler here.
+  return column as Column<TGenerics>
+}