@tanstack/table-core 8.9.3 → 8.9.8

package/src/features/Grouping.ts

@@ -135,127 +135,115 @@ export const Grouping: TableFeature = {
   createColumn: <TData extends RowData, TValue>(
     column: Column<TData, TValue>,
     table: Table<TData>
-  ): GroupingColumn<TData> => {
-    return {
-      toggleGrouping: () => {
-        table.setGrouping(old => {
-          // Find any existing grouping for this column
-          if (old?.includes(column.id)) {
-            return old.filter(d => d !== column.id)
-          }
-
-          return [...(old ?? []), column.id]
-        })
-      },
-
-      getCanGroup: () => {
-        return (
-          column.columnDef.enableGrouping ??
-          true ??
-          table.options.enableGrouping ??
-          true ??
-          !!column.accessorFn
-        )
-      },
-
-      getIsGrouped: () => {
-        return table.getState().grouping?.includes(column.id)
-      },
-
-      getGroupedIndex: () => table.getState().grouping?.indexOf(column.id),
-
-      getToggleGroupingHandler: () => {
-        const canGroup = column.getCanGroup()
-
-        return () => {
-          if (!canGroup) return
-          column.toggleGrouping()
+  ): void => {
+    column.toggleGrouping = () => {
+      table.setGrouping(old => {
+        // Find any existing grouping for this column
+        if (old?.includes(column.id)) {
+          return old.filter(d => d !== column.id)
         }
-      },
-      getAutoAggregationFn: () => {
-        const firstRow = table.getCoreRowModel().flatRows[0]
 
-        const value = firstRow?.getValue(column.id)
+        return [...(old ?? []), column.id]
+      })
+    }
 
-        if (typeof value === 'number') {
-          return aggregationFns.sum
-        }
+    column.getCanGroup = () => {
+      return (
+        column.columnDef.enableGrouping ??
+        true ??
+        table.options.enableGrouping ??
+        true ??
+        !!column.accessorFn
+      )
+    }
 
-        if (Object.prototype.toString.call(value) === '[object Date]') {
-          return aggregationFns.extent
-        }
-      },
-      getAggregationFn: () => {
-        if (!column) {
-          throw new Error()
-        }
+    column.getIsGrouped = () => {
+      return table.getState().grouping?.includes(column.id)
+    }
 
-        return isFunction(column.columnDef.aggregationFn)
-          ? column.columnDef.aggregationFn
-          : column.columnDef.aggregationFn === 'auto'
-          ? column.getAutoAggregationFn()
-          : table.options.aggregationFns?.[
-              column.columnDef.aggregationFn as string
-            ] ??
-            aggregationFns[
-              column.columnDef.aggregationFn as BuiltInAggregationFn
-            ]
-      },
+    column.getGroupedIndex = () => table.getState().grouping?.indexOf(column.id)
+
+    column.getToggleGroupingHandler = () => {
+      const canGroup = column.getCanGroup()
+
+      return () => {
+        if (!canGroup) return
+        column.toggleGrouping()
+      }
+    }
+    column.getAutoAggregationFn = () => {
+      const firstRow = table.getCoreRowModel().flatRows[0]
+
+      const value = firstRow?.getValue(column.id)
+
+      if (typeof value === 'number') {
+        return aggregationFns.sum
+      }
+
+      if (Object.prototype.toString.call(value) === '[object Date]') {
+        return aggregationFns.extent
+      }
+    }
+    column.getAggregationFn = () => {
+      if (!column) {
+        throw new Error()
+      }
+
+      return isFunction(column.columnDef.aggregationFn)
+        ? column.columnDef.aggregationFn
+        : column.columnDef.aggregationFn === 'auto'
+        ? column.getAutoAggregationFn()
+        : table.options.aggregationFns?.[
+            column.columnDef.aggregationFn as string
+          ] ??
+          aggregationFns[column.columnDef.aggregationFn as BuiltInAggregationFn]
     }
   },
 
-  createTable: <TData extends RowData>(
-    table: Table<TData>
-  ): GroupingInstance<TData> => {
-    return {
-      setGrouping: updater => table.options.onGroupingChange?.(updater),
-
-      resetGrouping: defaultState => {
-        table.setGrouping(
-          defaultState ? [] : table.initialState?.grouping ?? []
-        )
-      },
-
-      getPreGroupedRowModel: () => table.getFilteredRowModel(),
-      getGroupedRowModel: () => {
-        if (!table._getGroupedRowModel && table.options.getGroupedRowModel) {
-          table._getGroupedRowModel = table.options.getGroupedRowModel(table)
-        }
+  createTable: <TData extends RowData>(table: Table<TData>): void => {
+    table.setGrouping = updater => table.options.onGroupingChange?.(updater)
 
-        if (table.options.manualGrouping || !table._getGroupedRowModel) {
-          return table.getPreGroupedRowModel()
-        }
+    table.resetGrouping = defaultState => {
+      table.setGrouping(defaultState ? [] : table.initialState?.grouping ?? [])
+    }
+
+    table.getPreGroupedRowModel = () => table.getFilteredRowModel()
+    table.getGroupedRowModel = () => {
+      if (!table._getGroupedRowModel && table.options.getGroupedRowModel) {
+        table._getGroupedRowModel = table.options.getGroupedRowModel(table)
+      }
+
+      if (table.options.manualGrouping || !table._getGroupedRowModel) {
+        return table.getPreGroupedRowModel()
+      }
 
-        return table._getGroupedRowModel()
-      },
+      return table._getGroupedRowModel()
     }
   },
 
   createRow: <TData extends RowData>(
     row: Row<TData>,
     table: Table<TData>
-  ): GroupingRow => {
-    return {
-      getIsGrouped: () => !!row.groupingColumnId,
-      getGroupingValue: columnId => {
-        if (row._groupingValuesCache.hasOwnProperty(columnId)) {
-          return row._groupingValuesCache[columnId]
-        }
+  ): void => {
+    row.getIsGrouped = () => !!row.groupingColumnId
+    row.getGroupingValue = columnId => {
+      if (row._groupingValuesCache.hasOwnProperty(columnId)) {
+        return row._groupingValuesCache[columnId]
+      }
 
-        const column = table.getColumn(columnId)
+      const column = table.getColumn(columnId)
 
-        if (!column?.columnDef.getGroupingValue) {
-          return row.getValue(columnId)
-        }
+      if (!column?.columnDef.getGroupingValue) {
+        return row.getValue(columnId)
+      }
 
-        row._groupingValuesCache[columnId] = column.columnDef.getGroupingValue(
-          row.original
-        )
+      row._groupingValuesCache[columnId] = column.columnDef.getGroupingValue(
+        row.original
+      )
 
-        return row._groupingValuesCache[columnId]
-      },
-      _groupingValuesCache: {},
+      return row._groupingValuesCache[columnId]
     }
+    row._groupingValuesCache = {}
   },
 
   createCell: <TData extends RowData, TValue>(
@@ -263,19 +251,15 @@ export const Grouping: TableFeature = {
     column: Column<TData, TValue>,
     row: Row<TData>,
     table: Table<TData>
-  ): GroupingCell => {
+  ): void => {
     const getRenderValue = () =>
       cell.getValue() ?? table.options.renderFallbackValue
 
-    return {
-      getIsGrouped: () =>
-        column.getIsGrouped() && column.id === row.groupingColumnId,
-      getIsPlaceholder: () => !cell.getIsGrouped() && column.getIsGrouped(),
-      getIsAggregated: () =>
-        !cell.getIsGrouped() &&
-        !cell.getIsPlaceholder() &&
-        !!row.subRows?.length,
-    }
+    cell.getIsGrouped = () =>
+      column.getIsGrouped() && column.id === row.groupingColumnId
+    cell.getIsPlaceholder = () => !cell.getIsGrouped() && column.getIsGrouped()
+    cell.getIsAggregated = () =>
+      !cell.getIsGrouped() && !cell.getIsPlaceholder() && !!row.subRows?.length
   },
 }
 

package/src/features/Ordering.ts

@@ -45,60 +45,57 @@ export const Ordering: TableFeature = {
     }
   },
 
-  createTable: <TData extends RowData>(
-    table: Table<TData>
-  ): ColumnOrderInstance<TData> => {
-    return {
-      setColumnOrder: updater => table.options.onColumnOrderChange?.(updater),
-      resetColumnOrder: defaultState => {
-        table.setColumnOrder(
-          defaultState ? [] : table.initialState.columnOrder ?? []
-        )
-      },
-      _getOrderColumnsFn: memo(
-        () => [
-          table.getState().columnOrder,
-          table.getState().grouping,
-          table.options.groupedColumnMode,
-        ],
-        (columnOrder, grouping, groupedColumnMode) => columns => {
-          // Sort grouped columns to the start of the column list
-          // before the headers are built
-          let orderedColumns: Column<TData, unknown>[] = []
-
-          // If there is no order, return the normal columns
-          if (!columnOrder?.length) {
-            orderedColumns = columns
-          } else {
-            const columnOrderCopy = [...columnOrder]
-
-            // If there is an order, make a copy of the columns
-            const columnsCopy = [...columns]
-
-            // And make a new ordered array of the columns
-
-            // Loop over the columns and place them in order into the new array
-            while (columnsCopy.length && columnOrderCopy.length) {
-              const targetColumnId = columnOrderCopy.shift()
-              const foundIndex = columnsCopy.findIndex(
-                d => d.id === targetColumnId
-              )
-              if (foundIndex > -1) {
-                orderedColumns.push(columnsCopy.splice(foundIndex, 1)[0]!)
-              }
+  createTable: <TData extends RowData>(table: Table<TData>): void => {
+    table.setColumnOrder = updater =>
+      table.options.onColumnOrderChange?.(updater)
+    table.resetColumnOrder = defaultState => {
+      table.setColumnOrder(
+        defaultState ? [] : table.initialState.columnOrder ?? []
+      )
+    }
+    table._getOrderColumnsFn = memo(
+      () => [
+        table.getState().columnOrder,
+        table.getState().grouping,
+        table.options.groupedColumnMode,
+      ],
+      (columnOrder, grouping, groupedColumnMode) => columns => {
+        // Sort grouped columns to the start of the column list
+        // before the headers are built
+        let orderedColumns: Column<TData, unknown>[] = []
+
+        // If there is no order, return the normal columns
+        if (!columnOrder?.length) {
+          orderedColumns = columns
+        } else {
+          const columnOrderCopy = [...columnOrder]
+
+          // If there is an order, make a copy of the columns
+          const columnsCopy = [...columns]
+
+          // And make a new ordered array of the columns
+
+          // Loop over the columns and place them in order into the new array
+          while (columnsCopy.length && columnOrderCopy.length) {
+            const targetColumnId = columnOrderCopy.shift()
+            const foundIndex = columnsCopy.findIndex(
+              d => d.id === targetColumnId
+            )
+            if (foundIndex > -1) {
+              orderedColumns.push(columnsCopy.splice(foundIndex, 1)[0]!)
             }
-
-            // If there are any columns left, add them to the end
-            orderedColumns = [...orderedColumns, ...columnsCopy]
           }
 
-          return orderColumns(orderedColumns, grouping, groupedColumnMode)
-        },
-        {
-          key: process.env.NODE_ENV === 'development' && 'getOrderColumnsFn',
-          // debug: () => table.options.debugAll ?? table.options.debugTable,
+          // If there are any columns left, add them to the end
+          orderedColumns = [...orderedColumns, ...columnsCopy]
         }
-      ),
-    }
+
+        return orderColumns(orderedColumns, grouping, groupedColumnMode)
+      },
+      {
+        key: process.env.NODE_ENV === 'development' && 'getOrderColumnsFn',
+        // debug: () => table.options.debugAll ?? table.options.debugTable,
+      }
+    )
   },
 }

package/src/features/Pagination.ts

@@ -76,181 +76,177 @@ export const Pagination: TableFeature = {
     }
   },
 
-  createTable: <TData extends RowData>(
-    table: Table<TData>
-  ): PaginationInstance<TData> => {
+  createTable: <TData extends RowData>(table: Table<TData>): void => {
     let registered = false
     let queued = false
 
-    return {
-      _autoResetPageIndex: () => {
-        if (!registered) {
-          table._queue(() => {
-            registered = true
-          })
-          return
-        }
-
-        if (
-          table.options.autoResetAll ??
-          table.options.autoResetPageIndex ??
-          !table.options.manualPagination
-        ) {
-          if (queued) return
-          queued = true
-          table._queue(() => {
-            table.resetPageIndex()
-            queued = false
-          })
-        }
-      },
-      setPagination: updater => {
-        const safeUpdater: Updater<PaginationState> = old => {
-          let newState = functionalUpdate(updater, old)
-
-          return newState
-        }
-
-        return table.options.onPaginationChange?.(safeUpdater)
-      },
-      resetPagination: defaultState => {
-        table.setPagination(
-          defaultState
-            ? getDefaultPaginationState()
-            : table.initialState.pagination ?? getDefaultPaginationState()
-        )
-      },
-      setPageIndex: updater => {
-        table.setPagination(old => {
-          let pageIndex = functionalUpdate(updater, old.pageIndex)
-
-          const maxPageIndex =
-            typeof table.options.pageCount === 'undefined' ||
-            table.options.pageCount === -1
-              ? Number.MAX_SAFE_INTEGER
-              : table.options.pageCount - 1
-
-          pageIndex = Math.max(0, Math.min(pageIndex, maxPageIndex))
-
-          return {
-            ...old,
-            pageIndex,
-          }
+    table._autoResetPageIndex = () => {
+      if (!registered) {
+        table._queue(() => {
+          registered = true
         })
-      },
-      resetPageIndex: defaultState => {
-        table.setPageIndex(
-          defaultState
-            ? defaultPageIndex
-            : table.initialState?.pagination?.pageIndex ?? defaultPageIndex
-        )
-      },
-      resetPageSize: defaultState => {
-        table.setPageSize(
-          defaultState
-            ? defaultPageSize
-            : table.initialState?.pagination?.pageSize ?? defaultPageSize
-        )
-      },
-      setPageSize: updater => {
-        table.setPagination(old => {
-          const pageSize = Math.max(1, functionalUpdate(updater, old.pageSize))
-          const topRowIndex = old.pageSize * old.pageIndex!
-          const pageIndex = Math.floor(topRowIndex / pageSize)
-
-          return {
-            ...old,
-            pageIndex,
-            pageSize,
-          }
+        return
+      }
+
+      if (
+        table.options.autoResetAll ??
+        table.options.autoResetPageIndex ??
+        !table.options.manualPagination
+      ) {
+        if (queued) return
+        queued = true
+        table._queue(() => {
+          table.resetPageIndex()
+          queued = false
         })
-      },
-      setPageCount: updater =>
-        table.setPagination(old => {
-          let newPageCount = functionalUpdate(
-            updater,
-            table.options.pageCount ?? -1
-          )
-
-          if (typeof newPageCount === 'number') {
-            newPageCount = Math.max(-1, newPageCount)
-          }
-
-          return {
-            ...old,
-            pageCount: newPageCount,
-          }
-        }),
-
-      getPageOptions: memo(
-        () => [table.getPageCount()],
-        pageCount => {
-          let pageOptions: number[] = []
-          if (pageCount && pageCount > 0) {
-            pageOptions = [...new Array(pageCount)].fill(null).map((_, i) => i)
-          }
-          return pageOptions
-        },
-        {
-          key: process.env.NODE_ENV === 'development' && 'getPageOptions',
-          debug: () => table.options.debugAll ?? table.options.debugTable,
-        }
-      ),
+      }
+    }
+    table.setPagination = updater => {
+      const safeUpdater: Updater<PaginationState> = old => {
+        let newState = functionalUpdate(updater, old)
+
+        return newState
+      }
 
-      getCanPreviousPage: () => table.getState().pagination.pageIndex > 0,
+      return table.options.onPaginationChange?.(safeUpdater)
+    }
+    table.resetPagination = defaultState => {
+      table.setPagination(
+        defaultState
+          ? getDefaultPaginationState()
+          : table.initialState.pagination ?? getDefaultPaginationState()
+      )
+    }
+    table.setPageIndex = updater => {
+      table.setPagination(old => {
+        let pageIndex = functionalUpdate(updater, old.pageIndex)
 
-      getCanNextPage: () => {
-        const { pageIndex } = table.getState().pagination
+        const maxPageIndex =
+          typeof table.options.pageCount === 'undefined' ||
+          table.options.pageCount === -1
+            ? Number.MAX_SAFE_INTEGER
+            : table.options.pageCount - 1
 
-        const pageCount = table.getPageCount()
+        pageIndex = Math.max(0, Math.min(pageIndex, maxPageIndex))
 
-        if (pageCount === -1) {
-          return true
+        return {
+          ...old,
+          pageIndex,
         }
+      })
+    }
+    table.resetPageIndex = defaultState => {
+      table.setPageIndex(
+        defaultState
+          ? defaultPageIndex
+          : table.initialState?.pagination?.pageIndex ?? defaultPageIndex
+      )
+    }
+    table.resetPageSize = defaultState => {
+      table.setPageSize(
+        defaultState
+          ? defaultPageSize
+          : table.initialState?.pagination?.pageSize ?? defaultPageSize
+      )
+    }
+    table.setPageSize = updater => {
+      table.setPagination(old => {
+        const pageSize = Math.max(1, functionalUpdate(updater, old.pageSize))
+        const topRowIndex = old.pageSize * old.pageIndex!
+        const pageIndex = Math.floor(topRowIndex / pageSize)
+
+        return {
+          ...old,
+          pageIndex,
+          pageSize,
+        }
+      })
+    }
+    table.setPageCount = updater =>
+      table.setPagination(old => {
+        let newPageCount = functionalUpdate(
+          updater,
+          table.options.pageCount ?? -1
+        )
 
-        if (pageCount === 0) {
-          return false
+        if (typeof newPageCount === 'number') {
+          newPageCount = Math.max(-1, newPageCount)
         }
 
-        return pageIndex < pageCount - 1
+        return {
+          ...old,
+          pageCount: newPageCount,
+        }
+      })
+
+    table.getPageOptions = memo(
+      () => [table.getPageCount()],
+      pageCount => {
+        let pageOptions: number[] = []
+        if (pageCount && pageCount > 0) {
+          pageOptions = [...new Array(pageCount)].fill(null).map((_, i) => i)
+        }
+        return pageOptions
       },
+      {
+        key: process.env.NODE_ENV === 'development' && 'getPageOptions',
+        debug: () => table.options.debugAll ?? table.options.debugTable,
+      }
+    )
 
-      previousPage: () => {
-        return table.setPageIndex(old => old - 1)
-      },
+    table.getCanPreviousPage = () => table.getState().pagination.pageIndex > 0
 
-      nextPage: () => {
-        return table.setPageIndex(old => {
-          return old + 1
-        })
-      },
+    table.getCanNextPage = () => {
+      const { pageIndex } = table.getState().pagination
 
-      getPrePaginationRowModel: () => table.getExpandedRowModel(),
-      getPaginationRowModel: () => {
-        if (
-          !table._getPaginationRowModel &&
-          table.options.getPaginationRowModel
-        ) {
-          table._getPaginationRowModel =
-            table.options.getPaginationRowModel(table)
-        }
+      const pageCount = table.getPageCount()
 
-        if (table.options.manualPagination || !table._getPaginationRowModel) {
-          return table.getPrePaginationRowModel()
-        }
+      if (pageCount === -1) {
+        return true
+      }
 
-        return table._getPaginationRowModel()
-      },
+      if (pageCount === 0) {
+        return false
+      }
+
+      return pageIndex < pageCount - 1
+    }
+
+    table.previousPage = () => {
+      return table.setPageIndex(old => old - 1)
+    }
 
-      getPageCount: () => {
-        return (
-          table.options.pageCount ??
-          Math.ceil(
-            table.getPrePaginationRowModel().rows.length /
-              table.getState().pagination.pageSize
-          )
+    table.nextPage = () => {
+      return table.setPageIndex(old => {
+        return old + 1
+      })
+    }
+
+    table.getPrePaginationRowModel = () => table.getExpandedRowModel()
+    table.getPaginationRowModel = () => {
+      if (
+        !table._getPaginationRowModel &&
+        table.options.getPaginationRowModel
+      ) {
+        table._getPaginationRowModel =
+          table.options.getPaginationRowModel(table)
+      }
+
+      if (table.options.manualPagination || !table._getPaginationRowModel) {
+        return table.getPrePaginationRowModel()
+      }
+
+      return table._getPaginationRowModel()
+    }
+
+    table.getPageCount = () => {
+      return (
+        table.options.pageCount ??
+        Math.ceil(
+          table.getPrePaginationRowModel().rows.length /
+            table.getState().pagination.pageSize
         )
-      },
+      )
     }
   },
 }