@tanstack/table-core 8.13.2 → 8.15.1

package/src/features/ColumnPinning.ts

@@ -0,0 +1,336 @@
+import {
+  OnChangeFn,
+  Updater,
+  Table,
+  Column,
+  Row,
+  Cell,
+  RowData,
+  TableFeature,
+} from '../types'
+import { getMemoOptions, makeStateUpdater, memo } from '../utils'
+
+export type ColumnPinningPosition = false | 'left' | 'right'
+
+export interface ColumnPinningState {
+  left?: string[]
+  right?: string[]
+}
+
+export interface ColumnPinningTableState {
+  columnPinning: ColumnPinningState
+}
+
+export interface ColumnPinningOptions {
+  /**
+   * Enables/disables column pinning for the table. Defaults to `true`.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#enablecolumnpinning)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  enableColumnPinning?: boolean
+  /**
+   * @deprecated Use `enableColumnPinning` or `enableRowPinning` instead.
+   * Enables/disables all pinning for the table. Defaults to `true`.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#enablepinning)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  enablePinning?: boolean
+  /**
+   * If provided, this function will be called with an `updaterFn` when `state.columnPinning` changes. This overrides the default internal state management, so you will also need to supply `state.columnPinning` from your own managed state.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#oncolumnpinningchange)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/oncolumnpinningchange)
+   */
+  onColumnPinningChange?: OnChangeFn<ColumnPinningState>
+}
+
+export interface ColumnPinningDefaultOptions {
+  onColumnPinningChange: OnChangeFn<ColumnPinningState>
+}
+
+export interface ColumnPinningColumnDef {
+  /**
+   * Enables/disables column pinning for this column. Defaults to `true`.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#enablepinning-1)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  enablePinning?: boolean
+}
+
+export interface ColumnPinningColumn {
+  /**
+   * Returns whether or not the column can be pinned.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getcanpin)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  getCanPin: () => boolean
+  /**
+   * Returns the pinned position of the column. (`'left'`, `'right'` or `false`)
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getispinned)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  getIsPinned: () => ColumnPinningPosition
+  /**
+   * Returns the numeric pinned index of the column within a pinned column group.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getpinnedindex)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  getPinnedIndex: () => number
+  /**
+   * Pins a column to the `'left'` or `'right'`, or unpins the column to the center if `false` is passed.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#pin)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  pin: (position: ColumnPinningPosition) => void
+}
+
+export interface ColumnPinningRow<TData extends RowData> {
+  /**
+   * Returns all center pinned (unpinned) leaf cells in the row.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getcentervisiblecells)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  getCenterVisibleCells: () => Cell<TData, unknown>[]
+  /**
+   * Returns all left pinned leaf cells in the row.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getleftvisiblecells)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  getLeftVisibleCells: () => Cell<TData, unknown>[]
+  /**
+   * Returns all right pinned leaf cells in the row.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getrightvisiblecells)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  getRightVisibleCells: () => Cell<TData, unknown>[]
+}
+
+export interface ColumnPinningInstance<TData extends RowData> {
+  /**
+   * Returns all center pinned (unpinned) leaf columns.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getcenterleafcolumns)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  getCenterLeafColumns: () => Column<TData, unknown>[]
+  /**
+   * Returns whether or not any columns are pinned. Optionally specify to only check for pinned columns in either the `left` or `right` position.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getissomecolumnspinned)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  getIsSomeColumnsPinned: (position?: ColumnPinningPosition) => boolean
+  /**
+   * Returns all left pinned leaf columns.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getleftleafcolumns)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  getLeftLeafColumns: () => Column<TData, unknown>[]
+  /**
+   * Returns all right pinned leaf columns.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getrightleafcolumns)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  getRightLeafColumns: () => Column<TData, unknown>[]
+  /**
+   * Resets the **columnPinning** state to `initialState.columnPinning`, or `true` can be passed to force a default blank state reset to `{ left: [], right: [], }`.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#resetcolumnpinning)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  resetColumnPinning: (defaultState?: boolean) => void
+  /**
+   * Sets or updates the `state.columnPinning` state.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#setcolumnpinning)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+   */
+  setColumnPinning: (updater: Updater<ColumnPinningState>) => void
+}
+
+//
+
+const getDefaultColumnPinningState = (): ColumnPinningState => ({
+  left: [],
+  right: [],
+})
+
+export const ColumnPinning: TableFeature = {
+  getInitialState: (state): ColumnPinningTableState => {
+    return {
+      columnPinning: getDefaultColumnPinningState(),
+      ...state,
+    }
+  },
+
+  getDefaultOptions: <TData extends RowData>(
+    table: Table<TData>
+  ): ColumnPinningDefaultOptions => {
+    return {
+      onColumnPinningChange: makeStateUpdater('columnPinning', table),
+    }
+  },
+
+  createColumn: <TData extends RowData, TValue>(
+    column: Column<TData, TValue>,
+    table: Table<TData>
+  ): void => {
+    column.pin = position => {
+      const columnIds = column
+        .getLeafColumns()
+        .map(d => d.id)
+        .filter(Boolean) as string[]
+
+      table.setColumnPinning(old => {
+        if (position === 'right') {
+          return {
+            left: (old?.left ?? []).filter(d => !columnIds?.includes(d)),
+            right: [
+              ...(old?.right ?? []).filter(d => !columnIds?.includes(d)),
+              ...columnIds,
+            ],
+          }
+        }
+
+        if (position === 'left') {
+          return {
+            left: [
+              ...(old?.left ?? []).filter(d => !columnIds?.includes(d)),
+              ...columnIds,
+            ],
+            right: (old?.right ?? []).filter(d => !columnIds?.includes(d)),
+          }
+        }
+
+        return {
+          left: (old?.left ?? []).filter(d => !columnIds?.includes(d)),
+          right: (old?.right ?? []).filter(d => !columnIds?.includes(d)),
+        }
+      })
+    }
+
+    column.getCanPin = () => {
+      const leafColumns = column.getLeafColumns()
+
+      return leafColumns.some(
+        d =>
+          (d.columnDef.enablePinning ?? true) &&
+          (table.options.enableColumnPinning ??
+            table.options.enablePinning ??
+            true)
+      )
+    }
+
+    column.getIsPinned = () => {
+      const leafColumnIds = column.getLeafColumns().map(d => d.id)
+
+      const { left, right } = table.getState().columnPinning
+
+      const isLeft = leafColumnIds.some(d => left?.includes(d))
+      const isRight = leafColumnIds.some(d => right?.includes(d))
+
+      return isLeft ? 'left' : isRight ? 'right' : false
+    }
+
+    column.getPinnedIndex = () => {
+      const position = column.getIsPinned()
+
+      return position
+        ? table.getState().columnPinning?.[position]?.indexOf(column.id) ?? -1
+        : 0
+    }
+  },
+
+  createRow: <TData extends RowData>(
+    row: Row<TData>,
+    table: Table<TData>
+  ): void => {
+    row.getCenterVisibleCells = memo(
+      () => [
+        row._getAllVisibleCells(),
+        table.getState().columnPinning.left,
+        table.getState().columnPinning.right,
+      ],
+      (allCells, left, right) => {
+        const leftAndRight: string[] = [...(left ?? []), ...(right ?? [])]
+
+        return allCells.filter(d => !leftAndRight.includes(d.column.id))
+      },
+      getMemoOptions(table.options, 'debugRows', 'getCenterVisibleCells')
+    )
+    row.getLeftVisibleCells = memo(
+      () => [row._getAllVisibleCells(), table.getState().columnPinning.left],
+      (allCells, left) => {
+        const cells = (left ?? [])
+          .map(columnId => allCells.find(cell => cell.column.id === columnId)!)
+          .filter(Boolean)
+          .map(d => ({ ...d, position: 'left' }) as Cell<TData, unknown>)
+
+        return cells
+      },
+      getMemoOptions(table.options, 'debugRows', 'getLeftVisibleCells')
+    )
+    row.getRightVisibleCells = memo(
+      () => [row._getAllVisibleCells(), table.getState().columnPinning.right],
+      (allCells, right) => {
+        const cells = (right ?? [])
+          .map(columnId => allCells.find(cell => cell.column.id === columnId)!)
+          .filter(Boolean)
+          .map(d => ({ ...d, position: 'right' }) as Cell<TData, unknown>)
+
+        return cells
+      },
+      getMemoOptions(table.options, 'debugRows', 'getRightVisibleCells')
+    )
+  },
+
+  createTable: <TData extends RowData>(table: Table<TData>): void => {
+    table.setColumnPinning = updater =>
+      table.options.onColumnPinningChange?.(updater)
+
+    table.resetColumnPinning = defaultState =>
+      table.setColumnPinning(
+        defaultState
+          ? getDefaultColumnPinningState()
+          : table.initialState?.columnPinning ?? getDefaultColumnPinningState()
+      )
+
+    table.getIsSomeColumnsPinned = position => {
+      const pinningState = table.getState().columnPinning
+
+      if (!position) {
+        return Boolean(pinningState.left?.length || pinningState.right?.length)
+      }
+      return Boolean(pinningState[position]?.length)
+    }
+
+    table.getLeftLeafColumns = memo(
+      () => [table.getAllLeafColumns(), table.getState().columnPinning.left],
+      (allColumns, left) => {
+        return (left ?? [])
+          .map(columnId => allColumns.find(column => column.id === columnId)!)
+          .filter(Boolean)
+      },
+      getMemoOptions(table.options, 'debugColumns', 'getLeftLeafColumns')
+    )
+
+    table.getRightLeafColumns = memo(
+      () => [table.getAllLeafColumns(), table.getState().columnPinning.right],
+      (allColumns, right) => {
+        return (right ?? [])
+          .map(columnId => allColumns.find(column => column.id === columnId)!)
+          .filter(Boolean)
+      },
+      getMemoOptions(table.options, 'debugColumns', 'getRightLeafColumns')
+    )
+
+    table.getCenterLeafColumns = memo(
+      () => [
+        table.getAllLeafColumns(),
+        table.getState().columnPinning.left,
+        table.getState().columnPinning.right,
+      ],
+      (allColumns, left, right) => {
+        const leftAndRight: string[] = [...(left ?? []), ...(right ?? [])]
+
+        return allColumns.filter(d => !leftAndRight.includes(d.id))
+      },
+      getMemoOptions(table.options, 'debugColumns', 'getCenterLeafColumns')
+    )
+  },
+}

package/src/features/ColumnSizing.ts

@@ -1,8 +1,15 @@
 import { _getVisibleLeafColumns } from '..'
-import { TableFeature } from '../core/table'
-import { RowData, Column, Header, OnChangeFn, Table, Updater } from '../types'
+import {
+  RowData,
+  Column,
+  Header,
+  OnChangeFn,
+  Table,
+  Updater,
+  TableFeature,
+} from '../types'
 import { getMemoOptions, makeStateUpdater, memo } from '../utils'
-import { ColumnPinningPosition } from './Pinning'
+import { ColumnPinningPosition } from './ColumnPinning'
 
 //
 

package/src/features/{Visibility.ts → ColumnVisibility.ts}

@@ -1,5 +1,4 @@
 import { ColumnPinningPosition } from '..'
-import { TableFeature } from '../core/table'
 import {
   Cell,
   Column,
@@ -8,6 +7,7 @@ import {
   Updater,
   Row,
   RowData,
+  TableFeature,
 } from '../types'
 import { getMemoOptions, makeStateUpdater, memo } from '../utils'
 
@@ -149,7 +149,7 @@ export interface VisibilityColumn {
 
 //
 
-export const Visibility: TableFeature = {
+export const ColumnVisibility: TableFeature = {
   getInitialState: (state): VisibilityTableState => {
     return {
       columnVisibility: {},

package/src/features/GlobalFaceting.ts

@@ -0,0 +1,66 @@
+import { RowModel } from '..'
+import { Table, RowData, TableFeature } from '../types'
+
+export interface GlobalFacetingInstance<TData extends RowData> {
+  _getGlobalFacetedMinMaxValues?: () => undefined | [number, number]
+  _getGlobalFacetedRowModel?: () => RowModel<TData>
+  _getGlobalFacetedUniqueValues?: () => Map<any, number>
+  /**
+   * Currently, this function returns the built-in `includesString` filter function. In future releases, it may return more dynamic filter functions based on the nature of the data provided.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-faceting#getglobalautofilterfn)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-faceting)
+   */
+  getGlobalFacetedMinMaxValues: () => undefined | [number, number]
+  /**
+   * Returns the row model for the table after **global** filtering has been applied.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-faceting#getglobalfacetedrowmodel)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-faceting)
+   */
+  getGlobalFacetedRowModel: () => RowModel<TData>
+  /**
+   * Returns the faceted unique values for the global filter.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-faceting#getglobalfaceteduniquevalues)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-faceting)
+   */
+  getGlobalFacetedUniqueValues: () => Map<any, number>
+}
+
+//
+
+export const GlobalFaceting: TableFeature = {
+  createTable: <TData extends RowData>(table: Table<TData>): void => {
+    table._getGlobalFacetedRowModel =
+      table.options.getFacetedRowModel &&
+      table.options.getFacetedRowModel(table, '__global__')
+
+    table.getGlobalFacetedRowModel = () => {
+      if (table.options.manualFiltering || !table._getGlobalFacetedRowModel) {
+        return table.getPreFilteredRowModel()
+      }
+
+      return table._getGlobalFacetedRowModel()
+    }
+
+    table._getGlobalFacetedUniqueValues =
+      table.options.getFacetedUniqueValues &&
+      table.options.getFacetedUniqueValues(table, '__global__')
+    table.getGlobalFacetedUniqueValues = () => {
+      if (!table._getGlobalFacetedUniqueValues) {
+        return new Map()
+      }
+
+      return table._getGlobalFacetedUniqueValues()
+    }
+
+    table._getGlobalFacetedMinMaxValues =
+      table.options.getFacetedMinMaxValues &&
+      table.options.getFacetedMinMaxValues(table, '__global__')
+    table.getGlobalFacetedMinMaxValues = () => {
+      if (!table._getGlobalFacetedMinMaxValues) {
+        return
+      }
+
+      return table._getGlobalFacetedMinMaxValues()
+    }
+  },
+}

package/src/features/GlobalFiltering.ts

@@ -0,0 +1,162 @@
+import { FilterFn, FilterFnOption } from '..'
+import { BuiltInFilterFn, filterFns } from '../filterFns'
+import {
+  Column,
+  OnChangeFn,
+  Table,
+  Updater,
+  RowData,
+  TableFeature,
+} from '../types'
+import { isFunction, makeStateUpdater } from '../utils'
+
+export interface GlobalFilterTableState {
+  globalFilter: any
+}
+
+export interface GlobalFilterColumnDef {
+  /**
+   * Enables/disables the **global** filter for this column.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#enableglobalfilter)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)
+   */
+  enableGlobalFilter?: boolean
+}
+
+export interface GlobalFilterColumn {
+  /**
+   * Returns whether or not the column can be **globally** filtered. Set to `false` to disable a column from being scanned during global filtering.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#getcanglobalfilter)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)
+   */
+  getCanGlobalFilter: () => boolean
+}
+
+export interface GlobalFilterOptions<TData extends RowData> {
+  /**
+   * Enables/disables **global** filtering for all columns.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#enableglobalfilter)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)
+   */
+  enableGlobalFilter?: boolean
+  /**
+   * If provided, this function will be called with the column and should return `true` or `false` to indicate whether this column should be used for global filtering.
+   *
+   * This is useful if the column can contain data that is not `string` or `number` (i.e. `undefined`).
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#getcolumncanglobalfilter)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)
+   */
+  getColumnCanGlobalFilter?: (column: Column<TData, unknown>) => boolean
+  /**
+   * The filter function to use for global filtering.
+   * - A `string` referencing a built-in filter function
+   * - A `string` that references a custom filter functions provided via the `tableOptions.filterFns` option
+   * - A custom filter function
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#globalfilterfn)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)
+   */
+  globalFilterFn?: FilterFnOption<TData>
+  /**
+   * If provided, this function will be called with an `updaterFn` when `state.globalFilter` changes. This overrides the default internal state management, so you will need to persist the state change either fully or partially outside of the table.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#onglobalfilterchange)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)
+   */
+  onGlobalFilterChange?: OnChangeFn<any>
+}
+
+export interface GlobalFilterInstance<TData extends RowData> {
+  /**
+   * Currently, this function returns the built-in `includesString` filter function. In future releases, it may return more dynamic filter functions based on the nature of the data provided.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#getglobalautofilterfn)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)
+   */
+  getGlobalAutoFilterFn: () => FilterFn<TData> | undefined
+  /**
+   * Returns the filter function (either user-defined or automatic, depending on configuration) for the global filter.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#getglobalfilterfn)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)
+   */
+  getGlobalFilterFn: () => FilterFn<TData> | undefined
+  /**
+   * Resets the **globalFilter** state to `initialState.globalFilter`, or `true` can be passed to force a default blank state reset to `undefined`.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#resetglobalfilter)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)
+   */
+  resetGlobalFilter: (defaultState?: boolean) => void
+  /**
+   * Sets or updates the `state.globalFilter` state.
+   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#setglobalfilter)
+   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)
+   */
+  setGlobalFilter: (updater: Updater<any>) => void
+}
+
+//
+
+export const GlobalFiltering: TableFeature = {
+  getInitialState: (state): GlobalFilterTableState => {
+    return {
+      globalFilter: undefined,
+      ...state,
+    }
+  },
+
+  getDefaultOptions: <TData extends RowData>(
+    table: Table<TData>
+  ): GlobalFilterOptions<TData> => {
+    return {
+      onGlobalFilterChange: makeStateUpdater('globalFilter', table),
+      globalFilterFn: 'auto',
+      getColumnCanGlobalFilter: column => {
+        const value = table
+          .getCoreRowModel()
+          .flatRows[0]?._getAllCellsByColumnId()
+          [column.id]?.getValue()
+
+        return typeof value === 'string' || typeof value === 'number'
+      },
+    } as GlobalFilterOptions<TData>
+  },
+
+  createColumn: <TData extends RowData>(
+    column: Column<TData, unknown>,
+    table: Table<TData>
+  ): void => {
+    column.getCanGlobalFilter = () => {
+      return (
+        (column.columnDef.enableGlobalFilter ?? true) &&
+        (table.options.enableGlobalFilter ?? true) &&
+        (table.options.enableFilters ?? true) &&
+        (table.options.getColumnCanGlobalFilter?.(column) ?? true) &&
+        !!column.accessorFn
+      )
+    }
+  },
+
+  createTable: <TData extends RowData>(table: Table<TData>): void => {
+    table.getGlobalAutoFilterFn = () => {
+      return filterFns.includesString
+    }
+
+    table.getGlobalFilterFn = () => {
+      const { globalFilterFn: globalFilterFn } = table.options
+
+      return isFunction(globalFilterFn)
+        ? globalFilterFn
+        : globalFilterFn === 'auto'
+          ? table.getGlobalAutoFilterFn()
+          : table.options.filterFns?.[globalFilterFn as string] ??
+            filterFns[globalFilterFn as BuiltInFilterFn]
+    }
+
+    table.setGlobalFilter = updater => {
+      table.options.onGlobalFilterChange?.(updater)
+    }
+
+    table.resetGlobalFilter = defaultState => {
+      table.setGlobalFilter(
+        defaultState ? undefined : table.initialState.globalFilter
+      )
+    }
+  },
+}

package/src/features/{Expanding.ts → RowExpanding.ts}

@@ -1,6 +1,12 @@
 import { RowModel } from '..'
-import { TableFeature } from '../core/table'
-import { OnChangeFn, Table, Row, Updater, RowData } from '../types'
+import {
+  OnChangeFn,
+  Table,
+  Row,
+  Updater,
+  RowData,
+  TableFeature,
+} from '../types'
 import { makeStateUpdater } from '../utils'
 
 export type ExpandedStateList = Record<string, boolean>
@@ -160,7 +166,7 @@ export interface ExpandedInstance<TData extends RowData> {
 
 //
 
-export const Expanding: TableFeature = {
+export const RowExpanding: TableFeature = {
   getInitialState: (state): ExpandedTableState => {
     return {
       expanded: {},

package/src/features/{Pagination.ts → RowPagination.ts}

@@ -1,5 +1,11 @@
-import { TableFeature } from '../core/table'
-import { OnChangeFn, Table, RowModel, Updater, RowData } from '../types'
+import {
+  OnChangeFn,
+  Table,
+  RowModel,
+  Updater,
+  RowData,
+  TableFeature,
+} from '../types'
 import {
   functionalUpdate,
   getMemoOptions,
@@ -186,7 +192,7 @@ const getDefaultPaginationState = (): PaginationState => ({
   pageSize: defaultPageSize,
 })
 
-export const Pagination: TableFeature = {
+export const RowPagination: TableFeature = {
   getInitialState: (state): PaginationTableState => {
     return {
       ...state,