@tanstack/table-core 8.0.0-alpha.54 → 8.0.0-alpha.58

package/build/types/core.d.ts

@@ -1,24 +1,19 @@
 import { RequiredKeys } from './utils';
-import { Updater, PropGetterValue, Options, TableState, ColumnDef, Row, Column, Cell, Header, AccessorFn, TableProps, TableBodyProps, PropGetter, Getter, RowProps, CellProps, TableInstance, RowValues, Renderable, UseRenderer, RowModel, TableFeature, TableGenerics } from './types';
+import { Updater, Options, TableState, TableProps, TableBodyProps, PropGetter, TableInstance, Renderable, UseRenderer, TableFeature, TableGenerics } from './types';
 export declare type CoreTableState = {
     coreProgress: number;
 };
 export declare type CoreOptions<TGenerics extends TableGenerics> = {
     data: TGenerics['Row'][];
-    columns: ColumnDef<TGenerics>[];
     state: Partial<TableState>;
     onStateChange: (updater: Updater<TableState>) => void;
     render: TGenerics['Render'];
-    getCoreRowModel: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     debugAll?: boolean;
     debugTable?: boolean;
     debugHeaders?: boolean;
     debugColumns?: boolean;
     debugRows?: boolean;
-    defaultColumn?: Partial<ColumnDef<TGenerics>>;
     initialState?: Partial<TableState>;
-    getSubRows?: (originalRow: TGenerics['Row'], index: number) => TGenerics['Row'][];
-    getRowId?: (originalRow: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
     autoResetAll?: boolean;
     mergeOptions?: (defaultOptions: TableFeature, options: Partial<Options<TGenerics>>) => Options<TGenerics>;
     meta?: TGenerics['TableMeta'];
@@ -30,84 +25,12 @@ export declare type TableCore<TGenerics extends TableGenerics> = {
     setOptions: (newOptions: Updater<Options<TGenerics>>) => void;
     queue: (cb: () => void) => void;
     willUpdate: () => void;
-    getRowId: (_: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
     getState: () => TableState;
     setState: (updater: Updater<TableState>) => void;
-    getDefaultColumn: () => Partial<ColumnDef<TGenerics>>;
-    getColumnDefs: () => ColumnDef<TGenerics>[];
-    createColumn: (columnDef: ColumnDef<TGenerics>, depth: number, parent?: Column<TGenerics>) => Column<TGenerics>;
-    getAllColumns: () => Column<TGenerics>[];
-    getAllFlatColumns: () => Column<TGenerics>[];
-    getAllFlatColumnsById: () => Record<string, Column<TGenerics>>;
-    getAllLeafColumns: () => Column<TGenerics>[];
-    getColumn: (columnId: string) => Column<TGenerics>;
-    getTotalWidth: () => number;
-    createCell: (row: Row<TGenerics>, column: Column<TGenerics>, value: any) => Cell<TGenerics>;
-    createRow: (id: string, original: TGenerics['Row'] | undefined, rowIndex: number, depth: number, values: Record<string, any>) => Row<TGenerics>;
-    getCoreRowModel: () => RowModel<TGenerics>;
-    _getCoreRowModel?: () => RowModel<TGenerics>;
-    getRowModel: () => RowModel<TGenerics>;
-    getRow: (id: string) => Row<TGenerics>;
-    getCell: (rowId: string, columnId: string) => Cell<TGenerics>;
     getTableProps: PropGetter<TableProps>;
     getTableBodyProps: PropGetter<TableBodyProps>;
-    getRowProps: <TGetter extends Getter<RowProps>>(rowId: string, userProps?: TGetter) => undefined | PropGetterValue<RowProps, TGetter>;
-    getCellProps: <TGetter extends Getter<CellProps>>(rowId: string, columnId: string, userProps?: TGetter) => undefined | PropGetterValue<CellProps, TGetter>;
-    getTableWidth: () => number;
-    getLeftTableWidth: () => number;
-    getCenterTableWidth: () => number;
-    getRightTableWidth: () => number;
     render: <TProps>(template: Renderable<TGenerics, TProps>, props: TProps) => string | null | ReturnType<UseRenderer<TGenerics>>;
     getOverallProgress: () => number;
-};
-export declare type CoreRow<TGenerics extends TableGenerics> = {
-    id: string;
-    index: number;
-    original?: TGenerics['Row'];
-    depth: number;
-    values: RowValues;
-    subRows: Row<TGenerics>[];
-    getLeafRows: () => Row<TGenerics>[];
-    getRowProps: PropGetter<RowProps>;
-    originalSubRows?: TGenerics['Row'][];
-    getAllCells: () => Cell<TGenerics>[];
-    getAllCellsByColumnId: () => Record<string, Cell<TGenerics>>;
-};
-export declare 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>;
-        value: TGenerics['Value'];
-    }>;
-    meta?: TGenerics['ColumnMeta'];
-};
-export declare type CoreColumnDefType = 'data' | 'display' | 'group';
-export declare type CoreColumn<TGenerics extends TableGenerics> = {
-    id: string;
-    depth: number;
-    accessorFn?: AccessorFn<TGenerics['Row']>;
-    columnDef: ColumnDef<TGenerics>;
-    columnDefType: CoreColumnDefType;
-    getWidth: () => number;
-    columns: Column<TGenerics>[];
-    parent?: Column<TGenerics>;
-    getFlatColumns: () => Column<TGenerics>[];
-    getLeafColumns: () => Column<TGenerics>[];
+    _features: readonly TableFeature[];
 };
 export declare function createTableInstance<TGenerics extends TableGenerics>(options: Options<TGenerics>): TableInstance<TGenerics>;

package/build/types/features/Cells.d.ts

@@ -0,0 +1,14 @@
+import { Cell, TableGenerics, TableInstance, Row, Column, Getter, CellProps, PropGetterValue } from '../types';
+export declare type CellsRow<TGenerics extends TableGenerics> = {
+    getAllCells: () => Cell<TGenerics>[];
+    getAllCellsByColumnId: () => Record<string, Cell<TGenerics>>;
+};
+export declare type CellsInstance<TGenerics extends TableGenerics> = {
+    createCell: (row: Row<TGenerics>, column: Column<TGenerics>, value: any) => Cell<TGenerics>;
+    getCell: (rowId: string, columnId: string) => Cell<TGenerics>;
+    getCellProps: <TGetter extends Getter<CellProps>>(rowId: string, columnId: string, userProps?: TGetter) => undefined | PropGetterValue<CellProps, TGetter>;
+};
+export declare const Cells: {
+    createRow: <TGenerics extends TableGenerics>(row: Row<TGenerics>, instance: TableInstance<TGenerics>) => CellsRow<TGenerics>;
+    createInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => CellsInstance<TGenerics_1>;
+};

package/build/types/features/ColumnSizing.d.ts

@@ -1,5 +1,10 @@
 import { Column, Getter, Header, OnChangeFn, TableGenerics, PropGetterValue, TableInstance, Updater } from '../types';
-export declare type ColumnSizing = Record<string, number>;
+import { ColumnPinningPosition } from './Pinning';
+export declare type ColumnSizingTableState = {
+    columnSizing: ColumnSizingState;
+    columnSizingInfo: ColumnSizingInfoState;
+};
+export declare type ColumnSizingState = Record<string, number>;
 export declare type ColumnSizingInfoState = {
     startOffset: null | number;
     startSize: null | number;
@@ -8,20 +13,16 @@ export declare type ColumnSizingInfoState = {
     isResizingColumn: false | string;
     columnSizingStart: [string, number][];
 };
-export declare type ColumnSizingTableState = {
-    columnSizing: ColumnSizing;
-    columnSizingInfo: ColumnSizingInfoState;
-};
 export declare type ColumnResizeMode = 'onChange' | 'onEnd';
 export declare type ColumnSizingOptions = {
     enableColumnResizing?: boolean;
     columnResizeMode?: ColumnResizeMode;
-    onColumnSizingChange?: OnChangeFn<ColumnSizing>;
+    onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
     onColumnSizingInfoChange?: OnChangeFn<ColumnSizingInfoState>;
 };
 export declare type ColumnSizingDefaultOptions = {
     columnResizeMode: ColumnResizeMode;
-    onColumnSizingChange: OnChangeFn<ColumnSizing>;
+    onColumnSizingChange: OnChangeFn<ColumnSizingState>;
     onColumnSizingInfoChange: OnChangeFn<ColumnSizingInfoState>;
 };
 export declare type ColumnResizerProps = {
@@ -32,8 +33,9 @@ export declare type ColumnResizerProps = {
     role?: string;
 };
 export declare type ColumnSizingInstance<TGenerics extends TableGenerics> = {
-    getColumnWidth: (columnId: string) => number;
-    setColumnSizing: (updater: Updater<ColumnSizing>) => void;
+    getColumnSize: (columnId: string) => number;
+    getColumnStart: (columnId: string, position?: ColumnPinningPosition) => number;
+    setColumnSizing: (updater: Updater<ColumnSizingState>) => void;
     setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void;
     resetColumnSizing: () => void;
     resetColumnSize: (columnId: string) => void;
@@ -44,15 +46,21 @@ export declare type ColumnSizingInstance<TGenerics extends TableGenerics> = {
     getHeaderResizerProps: <TGetter extends Getter<ColumnResizerProps>>(headerId: string, userProps?: TGetter) => undefined | PropGetterValue<ColumnResizerProps, TGetter>;
     getColumnIsResizing: (columnId: string) => boolean;
     getHeaderIsResizing: (headerId: string) => boolean;
+    getTotalSize: () => number;
+    getLeftTotalSize: () => number;
+    getCenterTotalSize: () => number;
+    getRightTotalSize: () => number;
 };
 export declare type ColumnSizingColumnDef = {
     enableResizing?: boolean;
     defaultCanResize?: boolean;
-    width?: number;
-    minWidth?: number;
-    maxWidth?: number;
+    size?: number;
+    minSize?: number;
+    maxSize?: number;
 };
 export declare type ColumnSizingColumn<TGenerics extends TableGenerics> = {
+    getSize: () => number;
+    getStart: (position?: ColumnPinningPosition) => number;
     getCanResize: () => boolean;
     getIsResizing: () => boolean;
     resetSize: () => void;
@@ -64,16 +72,16 @@ export declare type ColumnSizingHeader<TGenerics extends TableGenerics> = {
     resetSize: () => void;
 };
 export declare const defaultColumnSizing: {
-    width: number;
-    minWidth: number;
-    maxWidth: number;
+    size: number;
+    minSize: number;
+    maxSize: number;
 };
 export declare const ColumnSizing: {
     getDefaultColumn: () => ColumnSizingColumnDef;
     getInitialState: () => ColumnSizingTableState;
     getDefaultOptions: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => ColumnSizingDefaultOptions;
-    getInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => ColumnSizingInstance<TGenerics_1>;
-    createColumn: <TGenerics_2 extends TableGenerics>(column: Column<TGenerics_2>, instance: TableInstance<TGenerics_2>) => ColumnSizingColumn<TGenerics_2>;
-    createHeader: <TGenerics_3 extends TableGenerics>(header: Header<TGenerics_3>, instance: TableInstance<TGenerics_3>) => ColumnSizingHeader<TGenerics_3>;
+    createColumn: <TGenerics_1 extends TableGenerics>(column: Column<TGenerics_1>, instance: TableInstance<TGenerics_1>) => ColumnSizingColumn<TGenerics_1>;
+    createHeader: <TGenerics_2 extends TableGenerics>(header: Header<TGenerics_2>, instance: TableInstance<TGenerics_2>) => ColumnSizingHeader<TGenerics_2>;
+    createInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => ColumnSizingInstance<TGenerics_3>;
 };
 export declare function passiveEventSupported(): boolean;

package/build/types/features/Columns.d.ts

@@ -0,0 +1,54 @@
+import { Cell, Column, Header, TableGenerics, TableInstance, Row, AccessorFn, ColumnDef, Renderable } from '../types';
+export declare type CoreColumnDefType = 'data' | 'display' | 'group';
+export declare 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>;
+        value: TGenerics['Value'];
+    }>;
+    meta?: TGenerics['ColumnMeta'];
+};
+export declare 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 declare type ColumnsOptions<TGenerics extends TableGenerics> = {
+    columns: ColumnDef<TGenerics>[];
+    defaultColumn?: Partial<ColumnDef<TGenerics>>;
+};
+export declare type ColumnsInstance<TGenerics extends TableGenerics> = {
+    getDefaultColumn: () => Partial<ColumnDef<TGenerics>>;
+    getColumnDefs: () => ColumnDef<TGenerics>[];
+    createColumn: (columnDef: ColumnDef<TGenerics>, depth: number, parent?: Column<TGenerics>) => Column<TGenerics>;
+    getAllColumns: () => Column<TGenerics>[];
+    getAllFlatColumns: () => Column<TGenerics>[];
+    getAllFlatColumnsById: () => Record<string, Column<TGenerics>>;
+    getAllLeafColumns: () => Column<TGenerics>[];
+    getColumn: (columnId: string) => Column<TGenerics>;
+};
+export declare const Columns: {
+    createInstance: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => ColumnsInstance<TGenerics>;
+};

package/build/types/features/Expanding.d.ts

@@ -12,6 +12,7 @@ export declare type ExpandedRow = {
     getToggleExpandedProps: <TGetter extends Getter<ToggleExpandedProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleExpandedProps, TGetter>;
 };
 export declare type ExpandedOptions<TGenerics extends TableGenerics> = {
+    manualExpanding?: boolean;
     onExpandedChange?: OnChangeFn<ExpandedState>;
     autoResetExpanded?: boolean;
     enableExpanded?: boolean;
@@ -47,6 +48,6 @@ export declare type ExpandedInstance<TGenerics extends TableGenerics> = {
 export declare const Expanding: {
     getInitialState: () => ExpandedTableState;
     getDefaultOptions: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => ExpandedOptions<TGenerics>;
-    getInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => ExpandedInstance<TGenerics_1>;
+    createInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => ExpandedInstance<TGenerics_1>;
     createRow: <TGenerics_2 extends TableGenerics>(row: Row<TGenerics_2>, instance: TableInstance<TGenerics_2>) => ExpandedRow;
 };

package/build/types/features/Filters.d.ts

@@ -49,10 +49,12 @@ export declare type FiltersOptions<TGenerics extends TableGenerics> = {
     filterFromLeafRows?: boolean;
     filterFns?: TGenerics['FilterFns'];
     enableFilters?: boolean;
+    manualColumnFiltering?: boolean;
     onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
     autoResetColumnFilters?: boolean;
     enableColumnFilters?: boolean;
     getColumnFilteredRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+    manualGlobalFiltering?: boolean;
     globalFilterFn?: FilterFnOption<TGenerics>;
     onGlobalFilterChange?: OnChangeFn<any>;
     autoResetGlobalFilter?: boolean;
@@ -88,6 +90,6 @@ export declare const Filters: {
     getInitialState: () => FiltersTableState;
     getDefaultOptions: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => FiltersOptions<TGenerics_1>;
     createColumn: <TGenerics_2 extends TableGenerics>(column: Column<TGenerics_2>, instance: TableInstance<TGenerics_2>) => FiltersColumn<TGenerics_2>;
-    getInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => FiltersInstance<TGenerics_3>;
+    createInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => FiltersInstance<TGenerics_3>;
 };
 export declare function shouldAutoRemoveFilter<TGenerics extends TableGenerics>(filterFn?: FilterFn<TGenerics>, value?: any, column?: Column<TGenerics>): boolean;

package/build/types/features/Grouping.d.ts

@@ -51,6 +51,7 @@ export declare type ColumnDefaultOptions = {
     enableGrouping: boolean;
 };
 export declare type GroupingOptions<TGenerics extends TableGenerics> = {
+    manualGrouping?: boolean;
     aggregationFns?: TGenerics['AggregationFns'];
     onGroupingChange?: OnChangeFn<GroupingState>;
     autoResetGrouping?: boolean;
@@ -85,7 +86,7 @@ export declare const Grouping: {
     getInitialState: () => GroupingTableState;
     getDefaultOptions: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => GroupingOptions<TGenerics_1>;
     createColumn: <TGenerics_2 extends TableGenerics>(column: Column<TGenerics_2>, instance: TableInstance<TGenerics_2>) => GroupingColumn<TGenerics_2>;
-    getInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => GroupingInstance<TGenerics_3>;
+    createInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => GroupingInstance<TGenerics_3>;
     createRow: <TGenerics_4 extends TableGenerics>(row: Row<TGenerics_4>, instance: TableInstance<TGenerics_4>) => GroupingRow;
     createCell: <TGenerics_5 extends TableGenerics>(cell: Cell<TGenerics_5>, column: Column<TGenerics_5>, row: Row<TGenerics_5>, instance: TableInstance<TGenerics_5>) => GroupingCell<TGenerics_5>;
     orderColumns: <TGenerics_6 extends TableGenerics>(leafColumns: Column<TGenerics_6>[], grouping: string[], groupedColumnMode?: GroupingColumnMode) => Column<TGenerics_6>[];

package/build/types/features/Headers.d.ts

@@ -1,16 +1,10 @@
-import { Cell, Column, FooterGroupProps, FooterProps, Getter, Header, HeaderGroup, HeaderGroupProps, HeaderProps, TableGenerics, PropGetterValue, TableInstance, Row } from '../types';
-export declare type HeadersRow<TGenerics extends TableGenerics> = {
-    _getAllVisibleCells: () => Cell<TGenerics>[];
-    getVisibleCells: () => Cell<TGenerics>[];
-    getLeftVisibleCells: () => Cell<TGenerics>[];
-    getCenterVisibleCells: () => Cell<TGenerics>[];
-    getRightVisibleCells: () => Cell<TGenerics>[];
-};
+import { Column, FooterGroupProps, FooterProps, Getter, Header, HeaderGroup, HeaderGroupProps, HeaderProps, TableGenerics, PropGetterValue, TableInstance } from '../types';
 export declare type HeadersInstance<TGenerics extends TableGenerics> = {
     createHeader: (column: Column<TGenerics>, options: {
         id?: string;
         isPlaceholder?: boolean;
         placeholderId?: string;
+        index: number;
         depth: number;
     }) => Header<TGenerics>;
     getHeaderGroups: () => HeaderGroup<TGenerics>[];
@@ -34,10 +28,8 @@ export declare type HeadersInstance<TGenerics extends TableGenerics> = {
     getFooterGroupProps: <TGetter extends Getter<FooterGroupProps>>(id: string, userProps?: TGetter) => undefined | PropGetterValue<FooterGroupProps, TGetter>;
     getHeaderProps: <TGetter extends Getter<HeaderProps>>(headerId: string, userProps?: TGetter) => undefined | PropGetterValue<HeaderProps, TGetter>;
     getFooterProps: <TGetter extends Getter<FooterProps>>(headerId: string, userProps?: TGetter) => undefined | PropGetterValue<FooterProps, TGetter>;
-    getTotalWidth: () => number;
 };
 export declare const Headers: {
-    createRow: <TGenerics extends TableGenerics>(row: Row<TGenerics>, instance: TableInstance<TGenerics>) => HeadersRow<TGenerics>;
-    getInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => HeadersInstance<TGenerics_1>;
+    createInstance: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => HeadersInstance<TGenerics>;
 };
 export declare function buildHeaderGroups<TGenerics extends TableGenerics>(allColumns: Column<TGenerics>[], columnsToGroup: Column<TGenerics>[], instance: TableInstance<TGenerics>, headerFamily?: 'center' | 'left' | 'right'): HeaderGroup<TGenerics>[];

package/build/types/features/Ordering.d.ts

@@ -17,5 +17,5 @@ export declare type ColumnOrderInstance<TGenerics extends TableGenerics> = {
 export declare const Ordering: {
     getInitialState: () => ColumnOrderTableState;
     getDefaultOptions: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => ColumnOrderDefaultOptions;
-    getInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => ColumnOrderInstance<TGenerics_1>;
+    createInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => ColumnOrderInstance<TGenerics_1>;
 };

package/build/types/features/Pagination.d.ts

@@ -8,6 +8,7 @@ export declare type PaginationTableState = {
     pagination: PaginationState;
 };
 export declare type PaginationOptions<TGenerics extends TableGenerics> = {
+    manualPagination?: boolean;
     onPaginationChange?: OnChangeFn<PaginationState>;
     autoResetPageIndex?: boolean;
     getPaginationRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
@@ -38,5 +39,5 @@ export declare type PaginationInstance<TGenerics extends TableGenerics> = {
 export declare const Pagination: {
     getInitialState: () => PaginationTableState;
     getDefaultOptions: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => PaginationDefaultOptions;
-    getInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => PaginationInstance<TGenerics_1>;
+    createInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => PaginationInstance<TGenerics_1>;
 };

package/build/types/features/Pinning.d.ts

@@ -1,5 +1,5 @@
-import { OnChangeFn, Updater, TableInstance, Column, TableGenerics } from '../types';
-declare type ColumnPinningPosition = false | 'left' | 'right';
+import { OnChangeFn, Updater, TableInstance, Column, TableGenerics, Row, Cell } from '../types';
+export declare type ColumnPinningPosition = false | 'left' | 'right';
 export declare type ColumnPinningState = {
     left?: string[];
     right?: string[];
@@ -24,6 +24,16 @@ export declare type ColumnPinningColumn = {
     getIsPinned: () => ColumnPinningPosition;
     pin: (position: ColumnPinningPosition) => void;
 };
+export declare type ColumnPinningRow<TGenerics extends TableGenerics> = {
+    getLeftVisibleCells: () => Cell<TGenerics>[];
+    getCenterVisibleCells: () => Cell<TGenerics>[];
+    getRightVisibleCells: () => Cell<TGenerics>[];
+};
+export declare type ColumnPinningCell<TGenerics extends TableGenerics> = {
+    getLeftVisibleCells: () => Cell<TGenerics>[];
+    getCenterVisibleCells: () => Cell<TGenerics>[];
+    getRightVisibleCells: () => Cell<TGenerics>[];
+};
 export declare type ColumnPinningInstance<TGenerics extends TableGenerics> = {
     setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
     resetColumnPinning: () => void;
@@ -32,11 +42,15 @@ export declare type ColumnPinningInstance<TGenerics extends TableGenerics> = {
     getColumnIsPinned: (columnId: string) => ColumnPinningPosition;
     getColumnPinnedIndex: (columnId: string) => number;
     getIsSomeColumnsPinned: () => boolean;
+    getLeftLeafColumns: () => Column<TGenerics>[];
+    getRightLeafColumns: () => Column<TGenerics>[];
+    getCenterLeafColumns: () => Column<TGenerics>[];
 };
 export declare const Pinning: {
     getInitialState: () => ColumnPinningTableState;
     getDefaultOptions: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => ColumnPinningDefaultOptions;
     createColumn: <TGenerics_1 extends TableGenerics>(column: Column<TGenerics_1>, instance: TableInstance<TGenerics_1>) => ColumnPinningColumn;
-    getInstance: <TGenerics_2 extends TableGenerics>(instance: TableInstance<TGenerics_2>) => ColumnPinningInstance<TGenerics_2>;
+    createRow: <TGenerics_2 extends TableGenerics>(row: Row<TGenerics_2>, instance: TableInstance<TGenerics_2>) => ColumnPinningRow<TGenerics_2>;
+    createCell: <TGenerics_3 extends TableGenerics>(cell: Cell<TGenerics_3>, instance: TableInstance<TGenerics_3>) => ColumnPinningCell<TGenerics_3>;
+    createInstance: <TGenerics_4 extends TableGenerics>(instance: TableInstance<TGenerics_4>) => ColumnPinningInstance<TGenerics_4>;
 };
-export {};

package/build/types/features/RowSelection.d.ts

@@ -51,7 +51,7 @@ export declare type RowSelectionInstance<TGenerics extends TableGenerics> = {
 export declare const RowSelection: {
     getInitialState: () => RowSelectionTableState;
     getDefaultOptions: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => RowSelectionOptions<TGenerics>;
-    getInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => RowSelectionInstance<TGenerics_1>;
+    createInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => RowSelectionInstance<TGenerics_1>;
     createRow: <TGenerics_2 extends TableGenerics>(row: Row<TGenerics_2>, instance: TableInstance<TGenerics_2>) => RowSelectionRow;
 };
 export declare function selectRowsFn<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>): RowModel<TGenerics>;

package/build/types/features/Rows.d.ts

@@ -0,0 +1,29 @@
+import { TableGenerics, TableInstance, Row, Getter, PropGetterValue, RowProps, RowModel, RowValues, PropGetter } from '../types';
+export declare type CoreRow<TGenerics extends TableGenerics> = {
+    id: string;
+    index: number;
+    original?: TGenerics['Row'];
+    depth: number;
+    values: RowValues;
+    subRows: Row<TGenerics>[];
+    getLeafRows: () => Row<TGenerics>[];
+    getRowProps: PropGetter<RowProps>;
+    originalSubRows?: TGenerics['Row'][];
+};
+export declare type RowsOptions<TGenerics extends TableGenerics> = {
+    getCoreRowModel: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+    getSubRows?: (originalRow: TGenerics['Row'], index: number) => TGenerics['Row'][];
+    getRowId?: (originalRow: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
+};
+export declare type RowsInstance<TGenerics extends TableGenerics> = {
+    getRowId: (_: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
+    createRow: (id: string, original: TGenerics['Row'] | undefined, rowIndex: number, depth: number, values: Record<string, any>) => Row<TGenerics>;
+    getCoreRowModel: () => RowModel<TGenerics>;
+    _getCoreRowModel?: () => RowModel<TGenerics>;
+    getRowModel: () => RowModel<TGenerics>;
+    getRow: (id: string) => Row<TGenerics>;
+    getRowProps: <TGetter extends Getter<RowProps>>(rowId: string, userProps?: TGetter) => undefined | PropGetterValue<RowProps, TGetter>;
+};
+export declare const Rows: {
+    createInstance: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => RowsInstance<TGenerics>;
+};

package/build/types/features/Sorting.d.ts

@@ -40,6 +40,7 @@ export declare type SortingColumn<TGenerics extends TableGenerics> = {
     getToggleSortingProps: <TGetter extends Getter<ToggleSortingProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleSortingProps, TGetter>;
 };
 export declare type SortingOptions<TGenerics extends TableGenerics> = {
+    manualSorting?: boolean;
     sortingFns?: TGenerics['SortingFns'];
     onSortingChange?: OnChangeFn<SortingState>;
     autoResetSorting?: boolean;
@@ -78,5 +79,5 @@ export declare const Sorting: {
     getInitialState: () => SortingTableState;
     getDefaultOptions: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => SortingOptions<TGenerics_1>;
     createColumn: <TGenerics_2 extends TableGenerics>(column: Column<TGenerics_2>, instance: TableInstance<TGenerics_2>) => SortingColumn<TGenerics_2>;
-    getInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => SortingInstance<TGenerics_3>;
+    createInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => SortingInstance<TGenerics_3>;
 };

package/build/types/features/Visibility.d.ts

@@ -1,4 +1,4 @@
-import { Cell, Column, Getter, OnChangeFn, TableGenerics, PropGetterValue, TableInstance, Updater } from '../types';
+import { Cell, Column, Getter, OnChangeFn, TableGenerics, PropGetterValue, TableInstance, Updater, Row } from '../types';
 export declare type VisibilityOptions = {
     onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
     enableHiding?: boolean;
@@ -13,6 +13,9 @@ export declare type VisibilityTableState = {
 export declare type VisibilityInstance<TGenerics extends TableGenerics> = {
     getVisibleFlatColumns: () => Column<TGenerics>[];
     getVisibleLeafColumns: () => Column<TGenerics>[];
+    getLeftVisibleLeafColumns: () => Column<TGenerics>[];
+    getRightVisibleLeafColumns: () => Column<TGenerics>[];
+    getCenterVisibleLeafColumns: () => Column<TGenerics>[];
     setColumnVisibility: (updater: Updater<VisibilityState>) => void;
     toggleColumnVisibility: (columnId: string, value?: boolean) => void;
     toggleAllColumnsVisible: (value?: boolean) => void;
@@ -30,6 +33,7 @@ export declare type VisibilityColumnDef = {
     defaultIsVisible?: boolean;
 };
 export declare type VisibilityRow<TGenerics extends TableGenerics> = {
+    _getAllVisibleCells: () => Cell<TGenerics>[];
     getVisibleCells: () => Cell<TGenerics>[];
 };
 export declare type VisibilityColumn = {
@@ -45,6 +49,7 @@ export declare const Visibility: {
         defaultIsVisible: boolean;
     };
     createColumn: <TGenerics_1 extends TableGenerics>(column: Column<TGenerics_1>, instance: TableInstance<TGenerics_1>) => VisibilityColumn;
-    getInstance: <TGenerics_2 extends TableGenerics>(instance: TableInstance<TGenerics_2>) => VisibilityInstance<TGenerics_2>;
+    createRow: <TGenerics_2 extends TableGenerics>(row: Row<TGenerics_2>, instance: TableInstance<TGenerics_2>) => VisibilityRow<TGenerics_2>;
+    createInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => VisibilityInstance<TGenerics_3>;
 };
 export {};

package/build/types/types.d.ts

@@ -1,8 +1,9 @@
-import { CoreColumn, CoreColumnDef, CoreOptions, CoreRow, CoreTableState, TableCore } from './core';
+import { CoreOptions, CoreTableState, TableCore } from './core';
+import { ColumnsOptions, CoreColumn, CoreColumnDef } from './features/Columns';
 import { VisibilityInstance, VisibilityTableState, VisibilityColumn as ColumnVisibilityColumn, VisibilityOptions, VisibilityColumnDef, VisibilityRow } from './features/Visibility';
 import { ColumnOrderInstance, ColumnOrderOptions, ColumnOrderTableState } from './features/Ordering';
-import { ColumnPinningColumn, ColumnPinningColumnDef, ColumnPinningInstance, ColumnPinningOptions, ColumnPinningTableState } from './features/Pinning';
-import { HeadersInstance, HeadersRow } from './features/Headers';
+import { ColumnPinningColumn, ColumnPinningColumnDef, ColumnPinningInstance, ColumnPinningOptions, ColumnPinningRow, ColumnPinningTableState } from './features/Pinning';
+import { HeadersInstance } from './features/Headers';
 import { FiltersColumn, FiltersColumnDef, FiltersInstance, FiltersOptions, FiltersTableState } from './features/Filters';
 import { SortingColumn, SortingColumnDef, SortingInstance, SortingOptions, SortingTableState } from './features/Sorting';
 import { GroupingCell, GroupingColumn, GroupingColumnDef, GroupingInstance, GroupingOptions, GroupingRow, GroupingTableState } from './features/Grouping';
@@ -11,6 +12,11 @@ import { Overwrite } from './utils';
 import { ColumnSizingColumn, ColumnSizingColumnDef, ColumnSizingHeader, ColumnSizingInstance, ColumnSizingOptions, ColumnSizingTableState } from './features/ColumnSizing';
 import { PaginationInstance, PaginationOptions, PaginationTableState } from './features/Pagination';
 import { RowSelectionInstance, RowSelectionOptions, RowSelectionRow, RowSelectionTableState } from './features/RowSelection';
+import { ColumnsInstance } from './features/Columns';
+import { CellsInstance, CellsRow } from './features/Cells';
+import { CoreRow, RowsInstance, RowsOptions } from './features/Rows';
+export declare type Updater<T> = T | ((old: T) => T);
+export declare type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void;
 export declare type TableGenerics = {
     Row?: any;
     Value?: any;
@@ -26,18 +32,17 @@ export declare type UseRenderer<TGenerics extends TableGenerics> = TGenerics['Re
 export declare type TableFeature = {
     getDefaultOptions?: (instance: any) => any;
     getInitialState?: () => any;
-    getInstance?: (instance: any) => any;
+    createInstance?: (instance: any) => any;
     getDefaultColumn?: () => any;
     createColumn?: (column: any, instance: any) => any;
+    createHeader?: (column: any, instance: any) => any;
     createCell?: (cell: any, column: any, row: any, instance: any) => any;
     createRow?: (row: any, instance: any) => any;
 };
-export declare type TableInstance<TGenerics extends TableGenerics> = TableCore<TGenerics> & VisibilityInstance<TGenerics> & ColumnOrderInstance<TGenerics> & ColumnPinningInstance<TGenerics> & HeadersInstance<TGenerics> & FiltersInstance<TGenerics> & SortingInstance<TGenerics> & GroupingInstance<TGenerics> & ColumnSizingInstance<TGenerics> & ExpandedInstance<TGenerics> & PaginationInstance<TGenerics> & RowSelectionInstance<TGenerics>;
-export declare type Options<TGenerics extends TableGenerics> = CoreOptions<TGenerics> & VisibilityOptions & ColumnOrderOptions & ColumnPinningOptions & FiltersOptions<TGenerics> & SortingOptions<TGenerics> & GroupingOptions<TGenerics> & ExpandedOptions<TGenerics> & ColumnSizingOptions & PaginationOptions<TGenerics> & RowSelectionOptions<TGenerics>;
-export declare type Updater<T> = T | ((old: T) => T);
-export declare type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void;
+export declare type TableInstance<TGenerics extends TableGenerics> = TableCore<TGenerics> & ColumnsInstance<TGenerics> & RowsInstance<TGenerics> & CellsInstance<TGenerics> & VisibilityInstance<TGenerics> & ColumnOrderInstance<TGenerics> & ColumnPinningInstance<TGenerics> & HeadersInstance<TGenerics> & FiltersInstance<TGenerics> & SortingInstance<TGenerics> & GroupingInstance<TGenerics> & ColumnSizingInstance<TGenerics> & ExpandedInstance<TGenerics> & PaginationInstance<TGenerics> & RowSelectionInstance<TGenerics>;
+export declare type Options<TGenerics extends TableGenerics> = CoreOptions<TGenerics> & ColumnsOptions<TGenerics> & RowsOptions<TGenerics> & VisibilityOptions & ColumnOrderOptions & ColumnPinningOptions & FiltersOptions<TGenerics> & SortingOptions<TGenerics> & GroupingOptions<TGenerics> & ExpandedOptions<TGenerics> & ColumnSizingOptions & PaginationOptions<TGenerics> & RowSelectionOptions<TGenerics>;
 export declare type TableState = CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationTableState & RowSelectionTableState;
-export declare type Row<TGenerics extends TableGenerics> = CoreRow<TGenerics> & VisibilityRow<TGenerics> & HeadersRow<TGenerics> & GroupingRow & RowSelectionRow & ExpandedRow;
+export declare type Row<TGenerics extends TableGenerics> = CoreRow<TGenerics> & CellsRow<TGenerics> & VisibilityRow<TGenerics> & ColumnPinningRow<TGenerics> & GroupingRow & RowSelectionRow & ExpandedRow;
 export declare type RowValues = {
     [key: string]: any;
 };
@@ -64,9 +69,12 @@ export declare type CoreCell<TGenerics extends TableGenerics> = {
 export declare type Header<TGenerics extends TableGenerics> = CoreHeader<TGenerics> & ColumnSizingHeader<TGenerics>;
 export declare type CoreHeader<TGenerics extends TableGenerics> = {
     id: string;
+    index: number;
     depth: number;
     column: Column<TGenerics>;
-    getWidth: () => number;
+    getStart: () => number;
+    getSize: () => number;
+    headerGroup: HeaderGroup<TGenerics>;
     subHeaders: Header<TGenerics>[];
     colSpan?: number;
     rowSpan?: number;

package/build/types/utils.d.ts

@@ -6,7 +6,6 @@ export declare type Overwrite<T, U extends {
     [TKey in keyof T]?: any;
 }> = Omit<T, keyof U> & U;
 export declare type IfDefined<T, N> = 0 extends 1 & T ? N : T extends {} ? T : N;
-export declare type DataUpdateFunction<T> = (input: T) => T;
 export declare function functionalUpdate<T>(updater: Updater<T>, input: T): T;
 export declare function noop(): void;
 export declare function getBatchGroups<T>(arr: T[], count: number): {