@tanstack/table-core 8.0.0-alpha.73 → 8.0.0-alpha.78

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tanstack/table-core",
   "author": "Tanner Linsley",
-  "version": "8.0.0-alpha.73",
+  "version": "8.0.0-alpha.78",
   "description": "Hooks for building lightweight, fast and extendable datagrids for React",
   "license": "MIT",
   "homepage": "https://github.com/tanstack/react-table#readme",
@@ -26,7 +26,7 @@
   },
   "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": {

package/src/core.ts

@@ -88,8 +88,6 @@ export type CoreInstance<TGenerics extends TableGenerics> = {
 //   facets: Batch[]
 // }
 
-// export type TaskPriority = keyof CoreBatches
-
 export function createTableInstance<TGenerics extends TableGenerics>(
   options: TableOptions<TGenerics>
 ): TableInstance<TGenerics> {
@@ -147,74 +145,6 @@ export function createTableInstance<TGenerics extends TableGenerics>(
   const queued: (() => void)[] = []
   let queuedTimeout = false
 
-  // let workScheduled = false
-  // let working = false
-  // let latestCallback: ReturnType<typeof requestIdleCallback>
-  // let batchUid = 0
-  // const onProgress = () => {}
-  // const getBatch = () => {
-  //   instance.batches.data = instance.batches.data.filter(d => d.tasks.length)
-  //   instance.batches.facets = instance.batches.facets.filter(
-  //     d => d.tasks.length
-  //   )
-
-  //   return (
-  //     instance.batches.data.find(d => d.tasks.length) ??
-  //     instance.batches.facets.find(d => d.tasks.length)
-  //   )
-  // }
-
-  // const startWorkLoop = () => {
-  //   working = true
-
-  //   const workLoop = (deadline: IdleDeadline) => {
-  //     const batch = getBatch()
-
-  //     if (!batch) {
-  //       working = false
-  //       return
-  //     }
-  //     // Prioritize tasks
-  //     while (deadline.timeRemaining() > 0 && batch.tasks.length) {
-  //       batch.tasks.shift()!()
-  //     }
-
-  //     onProgress()
-
-  //     if (working) {
-  //       latestCallback = requestIdleCallback(workLoop, { timeout: 10000 })
-  //     }
-  //   }
-
-  //   latestCallback = requestIdleCallback(workLoop, { timeout: 10000 })
-  // }
-
-  // const startWork = () => {
-  //   if (getBatch() && !working) {
-  //     if (
-  //       (process.env.NODE_ENV === 'development' && instance.options.debugAll) ??
-  //       instance.options.debugTable
-  //     ) {
-  //       console.info('Starting work...')
-  //     }
-  //     startWorkLoop()
-  //   }
-  // }
-
-  // const stopWork = () => {
-  //   if (working) {
-  //     if (
-  //       (process.env.NODE_ENV === 'development' && instance.options.debugAll) ??
-  //       instance.options.debugTable
-  //     ) {
-  //       console.info('Stopping work...')
-  //     }
-
-  //     working = false
-  //     cancelIdleCallback(latestCallback)
-  //   }
-  // }
-
   const midInstance: CoreInstance<TGenerics> = {
     ...instance,
     // init: () => {
@@ -253,43 +183,6 @@ export function createTableInstance<TGenerics extends TableGenerics>(
           )
       }
     },
-    // batches: {
-    //   data: [],
-    //   facets: [],
-    // },
-    // createBatch: priority => {
-    //   const batchId = batchUid++
-    //   let canceled: boolean
-
-    //   const batch: Batch = {
-    //     id: batchId,
-    //     priority,
-    //     tasks: [],
-    //     schedule: cb => {
-    //       if (canceled) return
-    //       batch.tasks.push(cb)
-
-    //       if (!working && !workScheduled) {
-    //         workScheduled = true
-    //         instance.queue(() => {
-    //           workScheduled = false
-    //           instance.setState(old => ({ ...old }))
-    //         })
-    //       }
-    //     },
-    //     cancel: () => {
-    //       canceled = true
-    //       batch.tasks = []
-    //       instance.batches[priority] = instance.batches[priority].filter(
-    //         b => b.id !== batchId
-    //       )
-    //     },
-    //   }
-
-    //   instance.batches[priority].push(batch)
-
-    //   return batch
-    // },
     reset: () => {
       instance.setState(instance.initialState)
     },

package/src/features/Headers.ts

@@ -121,15 +121,20 @@ export const Headers = {
           instance.getState().columnPinning.right,
         ],
         (allColumns, leafColumns, left, right) => {
-          const leftColumns = leafColumns.filter(column =>
-            left?.includes(column.id)
-          )
-          const rightColumns = leafColumns.filter(column =>
-            right?.includes(column.id)
-          )
+          const leftColumns =
+            left
+              ?.map(columnId => leafColumns.find(d => d.id === columnId)!)
+              .filter(Boolean) ?? []
+
+          const rightColumns =
+            right
+              ?.map(columnId => leafColumns.find(d => d.id === columnId)!)
+              .filter(Boolean) ?? []
+
           const centerColumns = leafColumns.filter(
             column => !left?.includes(column.id) && !right?.includes(column.id)
           )
+
           const headerGroups = buildHeaderGroups(
             allColumns,
             [...leftColumns, ...centerColumns, ...rightColumns],
@@ -173,8 +178,17 @@ export const Headers = {
           instance.getState().columnPinning.left,
         ],
         (allColumns, leafColumns, left) => {
-          leafColumns = leafColumns.filter(column => left?.includes(column.id))
-          return buildHeaderGroups(allColumns, leafColumns, instance, 'left')
+          const orderedLeafColumns =
+            left
+              ?.map(columnId => leafColumns.find(d => d.id === columnId)!)
+              .filter(Boolean) ?? []
+
+          return buildHeaderGroups(
+            allColumns,
+            orderedLeafColumns,
+            instance,
+            'left'
+          )
         },
         {
           key: process.env.NODE_ENV === 'development' && 'getLeftHeaderGroups',
@@ -190,8 +204,17 @@ export const Headers = {
           instance.getState().columnPinning.right,
         ],
         (allColumns, leafColumns, right) => {
-          leafColumns = leafColumns.filter(column => right?.includes(column.id))
-          return buildHeaderGroups(allColumns, leafColumns, instance, 'right')
+          const orderedLeafColumns =
+            right
+              ?.map(columnId => leafColumns.find(d => d.id === columnId)!)
+              .filter(Boolean) ?? []
+
+          return buildHeaderGroups(
+            allColumns,
+            orderedLeafColumns,
+            instance,
+            'right'
+          )
         },
         {
           key: process.env.NODE_ENV === 'development' && 'getRightHeaderGroups',

package/src/utils/getCoreRowModel.ts

@@ -14,78 +14,65 @@ export function getCoreRowModel<TGenerics extends TableGenerics>(): (
         flatRows: Row<TGenerics>[]
         rowsById: Record<string, Row<TGenerics>>
       } => {
-        // Access the row model using initial columns
-        const rows: Row<TGenerics>[] = []
-        const flatRows: Row<TGenerics>[] = []
-        const rowsById: Record<string, Row<TGenerics>> = {}
+        const rowModel: RowModel<TGenerics> = {
+          rows: [],
+          flatRows: [],
+          rowsById: {},
+        }
 
-        const leafColumns = instance.getAllLeafColumns()
+        let rows
+        let row
+        let originalRow
 
-        const accessRow = (
-          originalRow: TGenerics['Row'],
-          rowIndex: number,
+        const accessRows = (
+          originalRows: TGenerics['Row'][],
           depth = 0,
-          parentRows: Row<TGenerics>[],
           parent?: Row<TGenerics>
-        ) => {
-          const id = instance.getRowId(originalRow, rowIndex, parent)
-
-          if (!id) {
-            if (process.env.NODE_ENV !== 'production') {
-              throw new Error(`getRowId expected an ID, but got ${id}`)
-            }
-          }
+        ): Row<TGenerics>[] => {
+          rows = []
 
-          const values: Record<string, any> = {}
+          for (let i = 0; i < originalRows.length; i++) {
+            originalRow = originalRows[i]
 
-          for (let i = 0; i < leafColumns.length; i++) {
-            const column = leafColumns[i]
-            if (column && column.accessorFn) {
-              values[column.id] = column.accessorFn(originalRow, rowIndex)
-            }
-          }
+            // This could be an expensive check at scale, so we should move it somewhere else, but where?
+            // if (!id) {
+            //   if (process.env.NODE_ENV !== 'production') {
+            //     throw new Error(`getRowId expected an ID, but got ${id}`)
+            //   }
+            // }
 
-          // Make the row
-          const row = instance.createRow(id, originalRow, rowIndex, depth)
-
-          // Push instance row into the parentRows array
-          parentRows.push(row)
-          // Keep track of every row in a flat array
-          flatRows.push(row)
-          // Also keep track of every row by its ID
-          rowsById[id] = row
-
-          // Get the original subrows
-          if (instance.options.getSubRows) {
-            const originalSubRows = instance.options.getSubRows(
+            // Make the row
+            row = instance.createRow(
+              instance.getRowId(originalRow, i, parent),
               originalRow,
-              rowIndex
+              i,
+              depth
             )
 
-            // Then recursively access them
-            if (originalSubRows?.length) {
-              row.originalSubRows = originalSubRows
-              const subRows: Row<TGenerics>[] = []
+            // Keep track of every row in a flat array
+            rowModel.flatRows.push(row)
+            // Also keep track of every row by its ID
+            rowModel.rowsById[row.id] = row
+            // Push instance row into parent
+            rows.push(row)
+
+            // Get the original subrows
+            if (instance.options.getSubRows) {
+              row.originalSubRows = instance.options.getSubRows(originalRow, i)
 
-              for (let i = 0; i < row.originalSubRows.length; i++) {
-                accessRow(
-                  row.originalSubRows[i] as TGenerics['Row'],
-                  i,
-                  depth + 1,
-                  subRows,
-                  row
-                )
+              // Then recursively access them
+              if (row.originalSubRows?.length) {
+                row.subRows = accessRows(row.originalSubRows, depth + 1, row)
               }
-              row.subRows = subRows
             }
           }
-        }
 
-        for (let i = 0; i < data.length; i++) {
-          accessRow(data[i] as TGenerics['Row'], i, 0, rows)
+          return rows
         }
 
-        return { rows, flatRows, rowsById }
+        rowModel.rows = accessRows(data)
+
+        return rowModel
       },
       {
         key: process.env.NODE_ENV === 'development' && 'getRowModel',