@tanstack/react-table 0.0.1-alpha.9 → 8.0.0-alpha.3

package/build/types/aggregationTypes.d.ts

@@ -0,0 +1,22 @@
+export declare const aggregationTypes: {
+    sum: typeof sum;
+    min: typeof min;
+    max: typeof max;
+    extent: typeof extent;
+    mean: typeof mean;
+    median: typeof median;
+    unique: typeof unique;
+    uniqueCount: typeof uniqueCount;
+    count: typeof count;
+};
+export declare type BuiltInAggregationType = keyof typeof aggregationTypes;
+declare function sum(_leafValues: unknown[], childValues: unknown[]): number;
+declare function min(_leafValues: unknown[], childValues: unknown[]): number | undefined;
+declare function max(_leafValues: unknown[], childValues: unknown[]): number | undefined;
+declare function extent(_leafValues: unknown[], childValues: unknown[]): (number | undefined)[];
+declare function mean(leafValues: unknown[]): number | undefined;
+declare function median(values: unknown[]): number | undefined;
+declare function unique<T>(values: T[]): T[];
+declare function uniqueCount(values: unknown[]): number;
+declare function count(values: unknown[]): number;
+export {};

package/build/types/core.d.ts

@@ -0,0 +1,111 @@
+import { RequiredKeys } from './utils';
+import { Updater, PropGetterValue, Options, TableState, ColumnDef, Row, Column, Cell, Header, AccessorFn, TableProps, TableBodyProps, PropGetter, Getter, RowProps, CellProps, ReactTable, RowValues, Renderable } from './types';
+import { RowModel } from '.';
+export declare type CoreOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    data: TData[];
+    columns: ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    debug?: boolean;
+    defaultColumn?: Partial<ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    initialState?: Partial<TableState>;
+    state?: Partial<TableState>;
+    getSubRows?: (originalRow: TData, index: number) => TData[];
+    getRowId?: (originalRow: TData, index: number, parent?: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => string;
+    onStateChange?: (newState: TableState) => void;
+    autoResetAll?: boolean;
+};
+export declare type TableCore<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    rerender: () => void;
+    initialState: TableState;
+    internalState: TableState;
+    reset: () => void;
+    options: RequiredKeys<Options<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, 'state'>;
+    updateOptions: (newOptions: Options<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => void;
+    getRowId: (_: TData, index: number, parent?: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => string;
+    getState: () => TableState;
+    setState: (updater: Updater<TableState>) => void;
+    getDefaultColumn: () => Partial<ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getColumnDefs: () => ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    createColumn: (columnDef: ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, depth: number, parent?: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getAllColumns: () => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getAllFlatColumns: () => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getAllFlatColumnsById: () => Record<string, Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getAllLeafColumns: () => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getColumn: (columnId: string) => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getColumnWidth: (columnId: string) => number;
+    getTotalWidth: () => number;
+    createCell: (row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, value: any) => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    createRow: (id: string, original: TData | undefined, rowIndex: number, depth: number, values: Record<string, any>) => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getCoreRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getCoreRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCoreFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCoreRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getRow: (id: string) => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getCell: (rowId: string, columnId: string) => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    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;
+};
+export declare type CoreRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    id: string;
+    index: number;
+    original?: TData;
+    depth: number;
+    values: RowValues;
+    leafRows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    subRows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRowProps: PropGetter<RowProps>;
+    originalSubRows?: TData[];
+    getAllCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getAllCellsByColumnId: () => Record<string, Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+};
+export declare type CoreColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    id: string;
+    accessorKey?: string & keyof TData;
+    accessorFn?: AccessorFn<TData>;
+    header?: string | Renderable<{
+        instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        header: Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    }>;
+} & //       | Renderable<{ //       | string //     header?: //     accessorKey?: never //     id: string //     accessorFn: AccessorFn<TData> // | {
+{
+    __generated: true;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    columns?: ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    footer?: Renderable<{
+        instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        header: Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    }>;
+    cell?: Renderable<{
+        instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        cell: Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        value: TValue;
+    }>;
+    defaultIsVisible?: boolean;
+};
+export declare type CoreColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    id: string;
+    depth: number;
+    accessorFn?: AccessorFn<TData>;
+    columnDef: ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getWidth: () => number;
+    columns: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    parent?: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getFlatColumns: () => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeafColumns: () => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+};
+export declare function createTableInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(options: Options<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, rerender: () => void): ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;

package/build/types/createTable.d.ts

@@ -0,0 +1,53 @@
+import { Cell, Column, Row } from '.';
+import { ReactTable, ColumnDef, AccessorFn, Options, Renderable, Header } from './types';
+import { Overwrite } from './utils';
+declare type TableHelper<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    RowType<TTData>(): TableHelper<TTData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    FilterFns: <TTFilterFns>(filterFns: TTFilterFns) => TableHelper<TData, TValue, TTFilterFns, TSortingFns, TAggregationFns>;
+    SortingFns: <TTSortingFns>(sortingFns: TTSortingFns) => TableHelper<TData, TValue, TFilterFns, TTSortingFns, TAggregationFns>;
+    AggregationFns: <TTAggregationFns>(aggregationFns: TTAggregationFns) => TableHelper<TData, TValue, TFilterFns, TSortingFns, TTAggregationFns>;
+    createColumns: (columns: ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]) => ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    createGroup: (column: Overwrite<ColumnDef<TData, unknown, TFilterFns, TSortingFns, TAggregationFns>, {
+        __generated?: never;
+        accessorFn?: never;
+        accessorKey?: never;
+        header: string;
+        id?: string;
+    } | {
+        __generated?: never;
+        accessorFn?: never;
+        accessorKey?: never;
+        id: string;
+        header?: string | Renderable<{
+            instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+            header: Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+            column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        }>;
+    }>) => ColumnDef<TData, unknown, TFilterFns, TSortingFns, TAggregationFns>;
+    createDisplayColumn: (column: Overwrite<ColumnDef<TData, unknown, TFilterFns, TSortingFns, TAggregationFns>, {
+        __generated?: never;
+        accessorFn?: never;
+        accessorKey?: never;
+    }>) => ColumnDef<TData, unknown, TFilterFns, TSortingFns, TAggregationFns>;
+    createDataColumn: <TAccessor extends AccessorFn<TData> | keyof TData>(accessor: TAccessor, column: TAccessor extends (...args: any[]) => any ? Overwrite<ColumnDef<TData, ReturnType<TAccessor>, TFilterFns, TSortingFns, TAggregationFns>, {
+        __generated?: never;
+        accessorFn?: never;
+        accessorKey?: never;
+        id: string;
+    }> : TAccessor extends keyof TData ? Overwrite<ColumnDef<TData, TData[TAccessor], TFilterFns, TSortingFns, TAggregationFns>, {
+        __generated?: never;
+        accessorFn?: never;
+        accessorKey?: never;
+        id?: string;
+    }> : never) => ColumnDef<TData, TAccessor extends (...args: any[]) => any ? ReturnType<TAccessor> : TAccessor extends keyof TData ? TData[TAccessor] : never, TFilterFns, TSortingFns, TAggregationFns>;
+    useTable: <TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(options: Options<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    types: {
+        instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        columnDef: ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        cell: Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    };
+};
+export declare function createTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(): TableHelper<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export {};

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

@@ -0,0 +1,67 @@
+import { MouseEvent as ReactMouseEvent, TouchEvent as ReactTouchEvent } from 'react';
+import { Column, Getter, OnChangeFn, PropGetterValue, ReactTable, Updater } from '../types';
+export declare type ColumnSizing = Record<string, number>;
+export declare type ColumnSizingInfoState = {
+    startOffset: null | number;
+    startSize: null | number;
+    deltaOffset: null | number;
+    deltaPercentage: null | number;
+    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>;
+    onColumnSizingInfoChange?: OnChangeFn<ColumnSizingInfoState>;
+};
+export declare type ColumnSizingDefaultOptions = {
+    columnResizeMode: ColumnResizeMode;
+    onColumnSizingChange: OnChangeFn<ColumnSizing>;
+    onColumnSizingInfoChange: OnChangeFn<ColumnSizingInfoState>;
+};
+export declare type ColumnResizerProps = {
+    title?: string;
+    onMouseDown?: (e: ReactMouseEvent) => void;
+    onTouchStart?: (e: ReactTouchEvent) => void;
+    draggable?: boolean;
+    role?: string;
+};
+export declare type ColumnSizingInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    setColumnSizing: (updater: Updater<ColumnSizing>) => void;
+    setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void;
+    resetColumnSizing: () => void;
+    resetColumnSize: (columnId: string) => void;
+    resetHeaderSize: (headerId: string) => void;
+    resetHeaderSizeInfo: () => void;
+    getColumnCanResize: (columnId: string) => boolean;
+    getHeaderCanResize: (headerId: string) => boolean;
+    getColumnResizerProps: <TGetter extends Getter<ColumnResizerProps>>(columnId: string, userProps?: TGetter) => undefined | PropGetterValue<ColumnResizerProps, TGetter>;
+    getColumnIsResizing: (columnId: string) => boolean;
+    getHeaderIsResizing: (headerId: string) => boolean;
+};
+export declare type ColumnSizingColumnDef = {
+    enableResizing?: boolean;
+    defaultCanResize?: boolean;
+};
+export declare type ColumnSizingColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    getCanResize: () => boolean;
+    getIsResizing: () => boolean;
+    getResizerProps: <TGetter extends Getter<ColumnResizerProps>>(userProps?: TGetter) => undefined | PropGetterValue<ColumnResizerProps, TGetter>;
+    resetSize: () => void;
+};
+export declare const defaultColumnSizing: {
+    width: number;
+    minWidth: number;
+    maxWidth: number;
+};
+export declare function getInitialState(): ColumnSizingTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ColumnSizingDefaultOptions;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ColumnSizingInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function createColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ColumnSizingColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function passiveEventSupported(): boolean;

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

@@ -0,0 +1,53 @@
+import { MouseEvent, TouchEvent } from 'react';
+import { RowModel } from '..';
+import { Getter, OnChangeFn, PropGetterValue, ReactTable, Row, Updater } from '../types';
+export declare type ExpandedStateList = Record<string, boolean>;
+export declare type ExpandedState = true | Record<string, boolean>;
+export declare type ExpandedTableState = {
+    expanded: ExpandedState;
+};
+export declare type ExpandedRow = {
+    toggleExpanded: (expanded?: boolean) => void;
+    getIsExpanded: () => boolean;
+    getCanExpand: () => boolean;
+    getToggleExpandedProps: <TGetter extends Getter<ToggleExpandedProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleExpandedProps, TGetter>;
+};
+export declare type ExpandedOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    onExpandedChange?: OnChangeFn<ExpandedState>;
+    autoResetExpanded?: boolean;
+    enableExpanded?: boolean;
+    expandRowsFn?: (instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, rowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    expandSubRows?: boolean;
+    defaultCanExpand?: boolean;
+    getIsRowExpanded?: (row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => boolean;
+    getRowCanExpand?: (row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => boolean;
+    paginateExpandedRows?: boolean;
+};
+export declare type ToggleExpandedProps = {
+    title?: string;
+    onClick?: (event: MouseEvent | TouchEvent) => void;
+};
+export declare type ExpandedInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    _notifyExpandedReset: () => void;
+    setExpanded: (updater: Updater<ExpandedState>) => void;
+    toggleRowExpanded: (rowId: string, expanded?: boolean) => void;
+    toggleAllRowsExpanded: (expanded?: boolean) => void;
+    resetExpanded: () => void;
+    getRowCanExpand: (rowId: string) => boolean;
+    getIsRowExpanded: (rowId: string) => boolean;
+    getToggleExpandedProps: <TGetter extends Getter<ToggleExpandedProps>>(rowId: string, userProps?: TGetter) => undefined | PropGetterValue<ToggleExpandedProps, TGetter>;
+    getToggleAllRowsExpandedProps: <TGetter extends Getter<ToggleExpandedProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleExpandedProps, TGetter>;
+    getIsAllRowsExpanded: () => boolean;
+    getExpandedDepth: () => number;
+    getExpandedRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getPreExpandedRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreExpandedFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreExpandedRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getExpandedRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getExpandedFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getExpandedRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+};
+export declare function getInitialState(): ExpandedTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ExpandedOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ExpandedInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function createRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ExpandedRow;

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

@@ -0,0 +1,98 @@
+import { RowModel } from '..';
+import { BuiltInFilterType } from '../filterTypes';
+import { Column, OnChangeFn, ReactTable, Row, Updater } from '../types';
+export declare type ColumnFilter = {
+    id: string;
+    value: unknown;
+};
+export declare type ColumnFiltersState = ColumnFilter[];
+export declare type FilterFn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    (rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[], columnIds: string[], filterValue: any): any;
+    autoRemove?: ColumnFilterAutoRemoveTestFn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+};
+export declare type ColumnFilterAutoRemoveTestFn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = (value: unknown, column?: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => boolean;
+export declare type CustomFilterTypes<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = Record<string, FilterFn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+export declare type FiltersTableState = {
+    columnFilters: ColumnFiltersState;
+    globalFilter: any;
+};
+export declare type FilterType<TFilterFns> = 'auto' | BuiltInFilterType | keyof TFilterFns | FilterFn<unknown, unknown, TFilterFns, any, any>;
+export declare type FiltersColumnDef<TFilterFns> = {
+    filterType?: FilterType<TFilterFns>;
+    enableAllFilters?: boolean;
+    enableColumnFilter?: boolean;
+    enableGlobalFilter?: boolean;
+    defaultCanFilter?: boolean;
+    defaultCanColumnFilter?: boolean;
+    defaultCanGlobalFilter?: boolean;
+};
+export declare type FiltersColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    filterType: FilterType<TFilterFns>;
+    getCanColumnFilter: () => boolean;
+    getCanGlobalFilter: () => boolean;
+    getColumnFilterIndex: () => number;
+    getIsColumnFiltered: () => boolean;
+    getColumnFilterValue: () => unknown;
+    setColumnFilterValue: (value: any) => void;
+    getPreFilteredRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[] | undefined;
+    getPreFilteredUniqueValues: () => Map<any, number>;
+    getPreFilteredMinMaxValues: () => [any, any];
+};
+export declare type FiltersOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    filterFromChildrenUp?: boolean;
+    filterTypes?: TFilterFns;
+    enableFilters?: boolean;
+    onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
+    autoResetColumnFilters?: boolean;
+    enableColumnFilters?: boolean;
+    columnFilterRowsFn?: (instance: ReactTable<any, any, any, any, any>, coreRowModel: RowModel<any, any, any, any, any>) => RowModel<any, any, any, any, any>;
+    globalFilterType?: FilterType<TFilterFns>;
+    onGlobalFilterChange?: OnChangeFn<any>;
+    enableGlobalFilters?: boolean;
+    autoResetGlobalFilter?: boolean;
+    enableGlobalFilter?: boolean;
+    globalFilterRowsFn?: (instance: ReactTable<any, any, any, any, any>, rowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getColumnCanGlobalFilterFn?: (column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => boolean;
+};
+export declare type FiltersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    _notifyFiltersReset: () => void;
+    getColumnAutoFilterFn: (columnId: string) => FilterFn<any, any, any, any, any> | undefined;
+    getColumnFilterFn: (columnId: string) => FilterFn<any, any, any, any, any> | undefined;
+    setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
+    setColumnFilterValue: (columnId: string, value: any) => void;
+    resetColumnFilters: () => void;
+    getColumnCanColumnFilter: (columnId: string) => boolean;
+    getColumnCanGlobalFilterFn?: (column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => boolean;
+    getColumnIsFiltered: (columnId: string) => boolean;
+    getColumnFilterValue: (columnId: string) => unknown;
+    getColumnFilterIndex: (columnId: string) => number;
+    getColumnFilteredRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getPreFilteredRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getPreFilteredRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreFilteredFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreFilteredRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getPreColumnFilteredRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreColumnFilteredFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreColumnFilteredRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getColumnFilteredRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getColumnFilteredFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getColumnFilteredRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    setGlobalFilter: (updater: Updater<any>) => void;
+    resetGlobalFilter: () => void;
+    getGlobalAutoFilterFn: () => FilterFn<any, any, any, any, any> | undefined;
+    getGlobalFilterFn: () => FilterFn<any, any, any, any, any> | undefined;
+    getColumnCanGlobalFilter: (columnId: string) => boolean;
+    getGlobalFilteredRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getPreGlobalFilteredRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreGlobalFilteredFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreGlobalFilteredRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getGlobalFilteredRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getGlobalFilteredFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getGlobalFilteredRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+};
+export declare function getDefaultColumn<TFilterFns>(): FiltersColumnDef<TFilterFns>;
+export declare function getInitialState(): FiltersTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): FiltersOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function createColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): FiltersColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): FiltersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function shouldAutoRemoveFilter(filterFn?: FilterFn<any, any, any, any, any>, value?: any, column?: Column<any, any, any, any, any>): boolean;

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

@@ -0,0 +1,82 @@
+import React, { MouseEvent, TouchEvent } from 'react';
+import { RowModel } from '..';
+import { BuiltInAggregationType } from '../aggregationTypes';
+import { Cell, Column, Getter, OnChangeFn, PropGetterValue, ReactTable, Row, Updater } from '../types';
+export declare type GroupingState = string[];
+export declare type AggregationFn = (leafValues: any[], childValues: any[]) => any;
+export declare type AggregationType<TAggregationFns> = 'auto' | BuiltInAggregationType | keyof TAggregationFns | AggregationFn;
+export declare type GroupingTableState = {
+    grouping: GroupingState;
+};
+export declare type GroupingColumnDef<TAggregationFns> = {
+    aggregationType?: AggregationType<TAggregationFns>;
+    aggregateValue?: (columnValue: unknown) => any;
+    renderAggregatedCell?: () => React.ReactNode;
+    enableGrouping?: boolean;
+    defaultCanGroup?: boolean;
+};
+export declare type GroupingColumn<_TData, _TValue, _TFilterFns, _TSortingFns, TAggregationFns> = {
+    aggregationType?: AggregationType<TAggregationFns>;
+    getCanGroup: () => boolean;
+    getIsGrouped: () => boolean;
+    getGroupedIndex: () => number;
+    toggleGrouping: () => void;
+    getToggleGroupingProps: <TGetter extends Getter<ToggleGroupingProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleGroupingProps, TGetter>;
+};
+export declare type GroupingRow = {
+    groupingColumnId?: string;
+    groupingValue?: any;
+    getIsGrouped: () => boolean;
+};
+export declare type GroupingCell = {
+    getIsGrouped: () => boolean;
+    getIsPlaceholder: () => boolean;
+    getIsAggregated: () => boolean;
+};
+export declare type ColumnDefaultOptions = {
+    onGroupingChange: OnChangeFn<GroupingState>;
+    autoResetGrouping: boolean;
+    enableGrouping: boolean;
+};
+export declare type GroupingOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    aggregationTypes?: TAggregationFns;
+    onGroupingChange?: OnChangeFn<GroupingState>;
+    autoResetGrouping?: boolean;
+    enableGrouping?: boolean;
+    enableGroupingRemoval?: boolean;
+    groupRowsFn?: (instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, rowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    groupedColumnMode?: false | 'reorder' | 'remove';
+};
+export declare type GroupingColumnMode = false | 'reorder' | 'remove';
+export declare type ToggleGroupingProps = {
+    title?: string;
+    onClick?: (event: MouseEvent | TouchEvent) => void;
+};
+export declare type GroupingInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    _notifyGroupingReset: () => void;
+    getColumnAutoAggregationFn: (columnId: string) => AggregationFn | undefined;
+    getColumnAggregationFn: (columnId: string) => AggregationFn | undefined;
+    setGrouping: (updater: Updater<GroupingState>) => void;
+    resetGrouping: () => void;
+    toggleColumnGrouping: (columnId: string) => void;
+    getColumnCanGroup: (columnId: string) => boolean;
+    getColumnIsGrouped: (columnId: string) => boolean;
+    getColumnGroupedIndex: (columnId: string) => number;
+    getToggleGroupingProps: <TGetter extends Getter<ToggleGroupingProps>>(columnId: string, userProps?: TGetter) => undefined | PropGetterValue<ToggleGroupingProps, TGetter>;
+    getRowIsGrouped: (rowId: string) => boolean;
+    getGroupedRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getPreGroupedRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreGroupedFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreGroupedRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getGroupedRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getGroupedFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getGroupedRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+};
+export declare function getDefaultColumn<TFilterFns>(): GroupingColumnDef<TFilterFns>;
+export declare function getInitialState(): GroupingTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): GroupingOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function createColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): GroupingColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): GroupingInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function createRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): GroupingRow;
+export declare function createCell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(cell: Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> & GroupingCell, column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, _instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): GroupingCell;
+export declare function orderColumns<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(leafColumns: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[], grouping: string[], groupedColumnMode?: GroupingColumnMode): Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];

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

@@ -0,0 +1,41 @@
+import { Cell, Column, FooterGroupProps, FooterProps, Getter, Header, HeaderGroup, HeaderGroupProps, HeaderProps, PropGetterValue, ReactTable, Row } from '../types';
+export declare type HeadersRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    _getAllVisibleCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getVisibleCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeftVisibleCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCenterVisibleCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRightVisibleCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+};
+export declare type HeadersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    createHeader: (column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, options: {
+        id?: string;
+        isPlaceholder?: boolean;
+        placeholderId?: string;
+        depth: number;
+    }) => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getHeaderGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeftHeaderGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCenterHeaderGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRightHeaderGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getFooterGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCenterFooterGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeftFooterGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRightFooterGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getFlatHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeftFlatHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCenterFlatHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRightFlatHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeafHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeftLeafHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCenterLeafHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRightLeafHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getHeader: (id: string) => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getHeaderGroupProps: <TGetter extends Getter<HeaderGroupProps>>(id: string, userProps?: TGetter) => undefined | PropGetterValue<HeaderGroupProps, TGetter>;
+    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 function createRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): HeadersRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): HeadersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function buildHeaderGroups<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(allColumns: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[], columnsToGroup: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[], instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, headerFamily?: 'center' | 'left' | 'right'): HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];

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

@@ -0,0 +1,19 @@
+import { ReactTable, OnChangeFn, Updater, Column } from '../types';
+export declare type ColumnOrderState = string[];
+export declare type ColumnOrderTableState = {
+    columnOrder: ColumnOrderState;
+};
+export declare type ColumnOrderOptions = {
+    onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
+};
+export declare type ColumnOrderDefaultOptions = {
+    onColumnOrderChange: OnChangeFn<ColumnOrderState>;
+};
+export declare type ColumnOrderInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
+    resetColumnOrder: () => void;
+    getOrderColumnsFn: () => (columns: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]) => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+};
+export declare function getInitialState(): ColumnOrderTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ColumnOrderDefaultOptions;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ColumnOrderInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;

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

@@ -0,0 +1,43 @@
+import { OnChangeFn, ReactTable, Row, RowModel, Updater } from '../types';
+export declare type PaginationState = {
+    pageIndex: number;
+    pageSize: number;
+    pageCount: number;
+};
+export declare type PaginationTableState = {
+    pagination: PaginationState;
+};
+export declare type PaginationOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    onPaginationChange?: OnChangeFn<PaginationState>;
+    autoResetPageIndex?: boolean;
+    paginateRowsFn?: (instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, rowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+};
+export declare type PaginationDefaultOptions = {
+    onPaginationChange: OnChangeFn<PaginationState>;
+    autoResetPageIndex: boolean;
+};
+export declare type PaginationInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    _notifyPageIndexReset: () => void;
+    setPagination: (updater: Updater<PaginationState>) => void;
+    resetPagination: () => void;
+    setPageIndex: (updater: Updater<number>) => void;
+    resetPageIndex: () => void;
+    setPageSize: (updater: Updater<number>) => void;
+    resetPageSize: () => void;
+    setPageCount: (updater: Updater<number>) => void;
+    getPageOptions: () => number[];
+    getCanPreviousPage: () => boolean;
+    getCanNextPage: () => boolean;
+    gotoPreviousPage: () => void;
+    gotoNextPage: () => void;
+    getPaginationRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getPrePaginationRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPrePaginationFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPrePaginationRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getPaginationRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPaginationFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPaginationRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+};
+export declare function getInitialState(): PaginationTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): PaginationDefaultOptions;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): PaginationInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;