@tanstack/table-core 8.0.0-alpha.9 → 8.0.0-beta.0

package/build/types/aggregationFns.d.ts

@@ -0,0 +1,13 @@
+import { AggregationFn } from './features/Grouping';
+export declare const aggregationFns: {
+    sum: AggregationFn<any>;
+    min: AggregationFn<any>;
+    max: AggregationFn<any>;
+    extent: AggregationFn<any>;
+    mean: AggregationFn<any>;
+    median: AggregationFn<any>;
+    unique: AggregationFn<any>;
+    uniqueCount: AggregationFn<any>;
+    count: AggregationFn<any>;
+};
+export declare type BuiltInAggregationFn = keyof typeof aggregationFns;

package/build/types/core/cell.d.ts

@@ -0,0 +1,9 @@
+import { Cell, Column, Row, TableGenerics, TableInstance } from '../types';
+export declare type CoreCell<TGenerics extends TableGenerics> = {
+    id: string;
+    getValue: () => TGenerics['Value'];
+    row: Row<TGenerics>;
+    column: Column<TGenerics>;
+    renderCell: () => string | null | TGenerics['Rendered'];
+};
+export declare function createCell<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, row: Row<TGenerics>, column: Column<TGenerics>, columnId: string): Cell<TGenerics>;

package/build/types/core/column.d.ts

@@ -0,0 +1,40 @@
+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>;
+        getValue: () => 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 function createColumn<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, columnDef: ColumnDef<TGenerics> & {
+    columnDefType?: CoreColumnDefType;
+}, depth: number, parent?: Column<TGenerics>): Column<TGenerics>;

package/build/types/core/headers.d.ts

@@ -0,0 +1,46 @@
+import { Column, Header, HeaderGroup, TableGenerics, TableInstance } from '../types';
+import { TableFeature } from './instance';
+export declare type CoreHeaderGroup<TGenerics extends TableGenerics> = {
+    id: string;
+    depth: number;
+    headers: Header<TGenerics>[];
+};
+export declare type CoreHeader<TGenerics extends TableGenerics> = {
+    id: string;
+    index: number;
+    depth: number;
+    column: Column<TGenerics>;
+    headerGroup: HeaderGroup<TGenerics>;
+    subHeaders: Header<TGenerics>[];
+    colSpan: number;
+    rowSpan: number;
+    getLeafHeaders: () => Header<TGenerics>[];
+    isPlaceholder: boolean;
+    placeholderId?: string;
+    renderHeader: (options?: {
+        renderPlaceholder?: boolean;
+    }) => string | null | TGenerics['Rendered'];
+    renderFooter: (options?: {
+        renderPlaceholder?: boolean;
+    }) => string | null | TGenerics['Rendered'];
+};
+export declare type HeadersInstance<TGenerics extends TableGenerics> = {
+    getHeaderGroups: () => HeaderGroup<TGenerics>[];
+    getLeftHeaderGroups: () => HeaderGroup<TGenerics>[];
+    getCenterHeaderGroups: () => HeaderGroup<TGenerics>[];
+    getRightHeaderGroups: () => HeaderGroup<TGenerics>[];
+    getFooterGroups: () => HeaderGroup<TGenerics>[];
+    getLeftFooterGroups: () => HeaderGroup<TGenerics>[];
+    getCenterFooterGroups: () => HeaderGroup<TGenerics>[];
+    getRightFooterGroups: () => HeaderGroup<TGenerics>[];
+    getFlatHeaders: () => Header<TGenerics>[];
+    getLeftFlatHeaders: () => Header<TGenerics>[];
+    getCenterFlatHeaders: () => Header<TGenerics>[];
+    getRightFlatHeaders: () => Header<TGenerics>[];
+    getLeafHeaders: () => Header<TGenerics>[];
+    getLeftLeafHeaders: () => Header<TGenerics>[];
+    getCenterLeafHeaders: () => Header<TGenerics>[];
+    getRightLeafHeaders: () => Header<TGenerics>[];
+};
+export declare const Headers: TableFeature;
+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/core/instance.d.ts

@@ -0,0 +1,57 @@
+import { RequiredKeys } from '../utils';
+import { Updater, TableOptionsResolved, TableState, TableInstance, Renderable, TableGenerics, InitialTableState, Row, Column, RowModel, ColumnDef } from '../types';
+export declare type TableFeature = {
+    getDefaultOptions?: (instance: any) => any;
+    getInitialState?: (initialState?: InitialTableState) => any;
+    createInstance?: (instance: any) => any;
+    getDefaultColumnDef?: () => 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 CoreTableState = {};
+export declare type CoreOptions<TGenerics extends TableGenerics> = {
+    data: TGenerics['Row'][];
+    state: Partial<TableState>;
+    onStateChange: (updater: Updater<TableState>) => void;
+    render: TGenerics['Renderer'];
+    debugAll?: boolean;
+    debugTable?: boolean;
+    debugHeaders?: boolean;
+    debugColumns?: boolean;
+    debugRows?: boolean;
+    initialState?: InitialTableState;
+    autoResetAll?: boolean;
+    mergeOptions?: <T>(defaultOptions: T, options: Partial<T>) => T;
+    meta?: TGenerics['TableMeta'];
+    getCoreRowModel: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+    getSubRows?: (originalRow: TGenerics['Row'], index: number) => undefined | TGenerics['Row'][];
+    getRowId?: (originalRow: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
+    columns: ColumnDef<TGenerics>[];
+    defaultColumn?: Partial<ColumnDef<TGenerics>>;
+};
+export declare type CoreInstance<TGenerics extends TableGenerics> = {
+    initialState: TableState;
+    reset: () => void;
+    options: RequiredKeys<TableOptionsResolved<TGenerics>, 'state'>;
+    setOptions: (newOptions: Updater<TableOptionsResolved<TGenerics>>) => void;
+    getState: () => TableState;
+    setState: (updater: Updater<TableState>) => void;
+    _features: readonly TableFeature[];
+    _queue: (cb: () => void) => void;
+    _render: <TProps>(template: Renderable<TGenerics, TProps>, props: TProps) => string | null | TGenerics['Rendered'];
+    _getRowId: (_: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
+    getCoreRowModel: () => RowModel<TGenerics>;
+    _getCoreRowModel?: () => RowModel<TGenerics>;
+    getRowModel: () => RowModel<TGenerics>;
+    getRow: (id: string) => Row<TGenerics>;
+    _getDefaultColumnDef: () => Partial<ColumnDef<TGenerics>>;
+    _getColumnDefs: () => ColumnDef<TGenerics>[];
+    _getAllFlatColumnsById: () => Record<string, Column<TGenerics>>;
+    getAllColumns: () => Column<TGenerics>[];
+    getAllFlatColumns: () => Column<TGenerics>[];
+    getAllLeafColumns: () => Column<TGenerics>[];
+    getColumn: (columnId: string) => Column<TGenerics>;
+};
+export declare function createTableInstance<TGenerics extends TableGenerics>(options: TableOptionsResolved<TGenerics>): TableInstance<TGenerics>;

package/build/types/core/row.d.ts

@@ -0,0 +1,15 @@
+import { Cell, Row, TableGenerics, TableInstance } from '../types';
+export declare type CoreRow<TGenerics extends TableGenerics> = {
+    id: string;
+    index: number;
+    original?: TGenerics['Row'];
+    depth: number;
+    _valuesCache: Record<string, any>;
+    getValue: (columnId: string) => any;
+    subRows: Row<TGenerics>[];
+    getLeafRows: () => Row<TGenerics>[];
+    originalSubRows?: TGenerics['Row'][];
+    getAllCells: () => Cell<TGenerics>[];
+    _getAllCellsByColumnId: () => Record<string, Cell<TGenerics>>;
+};
+export declare const createRow: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, id: string, original: TGenerics["Row"] | undefined, rowIndex: number, depth: number, subRows?: Row<TGenerics>[] | undefined) => Row<TGenerics>;

package/build/types/createTable.d.ts

@@ -1,42 +1,63 @@
-import { CustomFilterTypes } from './features/Filters';
-import { CustomAggregationTypes } from './features/Grouping';
-import { CustomSortingTypes } from './features/Sorting';
-import { ColumnDef, AccessorFn, DefaultGenerics, PartialGenerics, _NonGenerated } from './types';
-import { Overwrite, PartialKeys } from './utils';
-export declare type CreatTableFactory<TGenerics extends Partial<DefaultGenerics>> = <TRow>() => TableFactory<Overwrite<TGenerics, {
-    Row: TRow;
-}>>;
-export declare type CreateTableFactoryOptions<TFilterFns extends CustomFilterTypes<any>, TSortingFns extends CustomSortingTypes<any>, TAggregationFns extends CustomAggregationTypes<any>> = {
+import { CustomFilterFns, FilterFn } from './features/Filters';
+import { AggregationFn, CustomAggregationFns } from './features/Grouping';
+import { CustomSortingFns, SortingFn } from './features/Sorting';
+import { ColumnDef, AccessorFn, AnyRender, TableGenerics, TableOptionsResolved, TableOptions } from './types';
+import { IfDefined, Overwrite } from './utils';
+export declare type TableFactory<TGenerics extends TableGenerics> = () => Table<TGenerics>;
+export declare type CreateTableOptions<TRender extends AnyRender, TFilterFns extends CustomFilterFns<any>, TSortingFns extends CustomSortingFns<any>, TAggregationFns extends CustomAggregationFns<any>, TGenerics extends TableGenerics> = Partial<{
+    render?: TRender;
     filterFns?: TFilterFns;
     sortingFns?: TSortingFns;
     aggregationFns?: TAggregationFns;
-};
-export declare function createTableFactory<TFilterFns extends CustomFilterTypes<any>, TSortingFns extends CustomSortingTypes<any>, TAggregationFns extends CustomAggregationTypes<any>>(opts: CreateTableFactoryOptions<TFilterFns, TSortingFns, TAggregationFns>): CreatTableFactory<Overwrite<PartialGenerics, {
-    FilterFns: TFilterFns;
-    SortingFns: TSortingFns;
-    AggregationFns: TAggregationFns;
-}>>;
-export declare type TableFactory<TGenerics extends Partial<DefaultGenerics>> = {
-    __options: CreateTableFactoryOptions<any, any, any>;
-    createColumns: (columns: ColumnDef<TGenerics>[]) => ColumnDef<TGenerics>[];
-    createGroup: (column: Overwrite<Overwrite<_NonGenerated<ColumnDef<TGenerics>>, {
+} & Omit<TableOptionsResolved<TGenerics>, 'filterFns' | 'sortingFns' | 'aggregationFns'>>;
+export declare type Table<TGenerics extends TableGenerics> = {
+    generics: TGenerics;
+    options: Partial<TableOptionsResolved<TGenerics>>;
+    setRowType: <TRow>() => Table<Overwrite<TGenerics, {
+        Row: TRow;
+    }>>;
+    setTableMetaType: <TTableMeta>() => Table<Overwrite<TGenerics, {
+        TableMeta: TTableMeta;
+    }>>;
+    setColumnMetaType: <TColumnMeta>() => Table<Overwrite<TGenerics, {
+        ColumnMeta: TColumnMeta;
+    }>>;
+    setFilterMetaType: <TFilterMeta>() => Table<Overwrite<TGenerics, {
+        FilterMeta: TFilterMeta;
+    }>>;
+    setOptions: <TFilterFns extends Record<string, FilterFn<TGenerics>>, TSortingFns extends Record<string, SortingFn<TGenerics>>, TAggregationFns extends Record<string, AggregationFn<TGenerics>>>(options: CreateTableOptions<any, TFilterFns, TSortingFns, TAggregationFns, TGenerics>) => Table<Overwrite<TGenerics, {
+        FilterFns: IfDefined<TFilterFns, TGenerics['FilterFns']>;
+        SortingFns: IfDefined<TSortingFns, TGenerics['SortingFns']>;
+        AggregationFns: IfDefined<TAggregationFns, TGenerics['AggregationFns']>;
+    }>>;
+    createGroup: (column: Overwrite<Overwrite<ColumnDef<any>, {
         header: string;
         id?: string;
-    }> | Overwrite<_NonGenerated<ColumnDef<TGenerics>>, {
+    }> | Overwrite<ColumnDef<any>, {
         id: string;
-        header?: string | ColumnDef<TGenerics>['header'];
+        header?: string | ((...any: any) => any);
     }>, {
         accessorFn?: never;
         accessorKey?: never;
+        columns?: ColumnDef<any>[];
     }>) => ColumnDef<TGenerics>;
-    createDisplayColumn: (column: PartialKeys<_NonGenerated<ColumnDef<TGenerics>>, 'accessorFn' | 'accessorKey'>) => ColumnDef<TGenerics>;
-    createDataColumn: <TAccessor extends AccessorFn<TGenerics['Row']> | keyof TGenerics['Row']>(accessor: TAccessor, column: Overwrite<TAccessor extends (...args: any[]) => any ? _NonGenerated<ColumnDef<TGenerics>> : TAccessor extends keyof TGenerics['Row'] ? Overwrite<_NonGenerated<ColumnDef<TGenerics>>, {
+    createDisplayColumn: (column: Omit<ColumnDef<TGenerics>, 'columns'>) => ColumnDef<TGenerics>;
+    createDataColumn: <TAccessor extends AccessorFn<TGenerics['Row']> | keyof TGenerics['Row']>(accessor: TAccessor, column: Overwrite<TAccessor extends (...args: any[]) => any ? ColumnDef<Overwrite<TGenerics, {
+        Value: ReturnType<TAccessor>;
+    }>> : TAccessor extends keyof TGenerics['Row'] ? Overwrite<ColumnDef<Overwrite<TGenerics, {
+        Value: TGenerics['Row'][TAccessor];
+    }>>, {
         id?: string;
     }> : never, {
         accessorFn?: never;
         accessorKey?: never;
+        columns?: ColumnDef<any>[];
     }>) => ColumnDef<TGenerics>;
+    createOptions: (options: TableOptions<TGenerics>) => TableOptions<TGenerics>;
 };
-export declare function createTable<TRow>(): TableFactory<Overwrite<Partial<DefaultGenerics>, {
-    Row: TRow;
-}>>;
+export declare function createTableFactory<TRenderer extends AnyRender>(opts: {
+    render: TRenderer;
+}): () => Table<{
+    Renderer: TRenderer;
+    Rendered: ReturnType<TRenderer>;
+}>;

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

@@ -1,6 +1,11 @@
-import { MouseEvent as ReactMouseEvent, TouchEvent as ReactTouchEvent } from 'react';
-import { Column, Getter, Header, OnChangeFn, PartialGenerics, PropGetterValue, TableInstance, Updater } from '../types';
-export declare type ColumnSizing = Record<string, number>;
+import { TableFeature } from '../core/instance';
+import { OnChangeFn, TableGenerics, Updater } from '../types';
+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;
@@ -9,67 +14,50 @@ 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 = {
-    title?: string;
-    onMouseDown?: (e: ReactMouseEvent) => void;
-    onTouchStart?: (e: ReactTouchEvent) => void;
-    draggable?: boolean;
-    role?: string;
-};
-export declare type ColumnSizingInstance<TGenerics extends PartialGenerics> = {
-    setColumnSizing: (updater: Updater<ColumnSizing>) => void;
+export declare type ColumnSizingInstance<TGenerics extends TableGenerics> = {
+    setColumnSizing: (updater: Updater<ColumnSizingState>) => 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;
-    getHeaderResizerProps: <TGetter extends Getter<ColumnResizerProps>>(headerId: string, userProps?: TGetter) => undefined | PropGetterValue<ColumnResizerProps, TGetter>;
-    getColumnIsResizing: (columnId: string) => boolean;
-    getHeaderIsResizing: (headerId: string) => boolean;
+    resetColumnSizing: (defaultState?: boolean) => void;
+    resetHeaderSizeInfo: (defaultState?: boolean) => void;
+    getTotalSize: () => number;
+    getLeftTotalSize: () => number;
+    getCenterTotalSize: () => number;
+    getRightTotalSize: () => number;
 };
 export declare type ColumnSizingColumnDef = {
     enableResizing?: boolean;
-    defaultCanResize?: boolean;
+    size?: number;
+    minSize?: number;
+    maxSize?: number;
 };
-export declare type ColumnSizingColumn<TGenerics extends PartialGenerics> = {
+export declare type ColumnSizingColumn<TGenerics extends TableGenerics> = {
+    getSize: () => number;
+    getStart: (position?: ColumnPinningPosition) => number;
     getCanResize: () => boolean;
     getIsResizing: () => boolean;
     resetSize: () => void;
 };
-export declare type ColumnSizingHeader<TGenerics extends PartialGenerics> = {
-    getCanResize: () => boolean;
-    getIsResizing: () => boolean;
-    getResizerProps: <TGetter extends Getter<ColumnResizerProps>>(userProps?: TGetter) => undefined | PropGetterValue<ColumnResizerProps, TGetter>;
-    resetSize: () => void;
+export declare type ColumnSizingHeader<TGenerics extends TableGenerics> = {
+    getSize: () => number;
+    getStart: (position?: ColumnPinningPosition) => number;
+    getResizeHandler: () => (event: unknown) => void;
 };
 export declare const defaultColumnSizing: {
-    width: number;
-    minWidth: number;
-    maxWidth: number;
-};
-export declare const ColumnSizing: {
-    getInitialState: () => ColumnSizingTableState;
-    getDefaultOptions: <TGenerics extends Partial<import("../types").DefaultGenerics>>(instance: TableInstance<TGenerics>) => ColumnSizingDefaultOptions;
-    getInstance: <TGenerics_1 extends Partial<import("../types").DefaultGenerics>>(instance: TableInstance<TGenerics_1>) => ColumnSizingInstance<TGenerics_1>;
-    createColumn: <TGenerics_2 extends Partial<import("../types").DefaultGenerics>>(column: Column<TGenerics_2>, instance: TableInstance<TGenerics_2>) => ColumnSizingColumn<TGenerics_2>;
-    createHeader: <TGenerics_3 extends Partial<import("../types").DefaultGenerics>>(header: Header<TGenerics_3>, instance: TableInstance<TGenerics_3>) => ColumnSizingHeader<TGenerics_3>;
+    size: number;
+    minSize: number;
+    maxSize: number;
 };
+export declare const ColumnSizing: TableFeature;
 export declare function passiveEventSupported(): boolean;

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

@@ -1,6 +1,6 @@
-import { MouseEvent, TouchEvent } from 'react';
 import { RowModel } from '..';
-import { Getter, OnChangeFn, PartialGenerics, PropGetterValue, TableInstance, Row, Updater } from '../types';
+import { TableFeature } from '../core/instance';
+import { OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
 export declare type ExpandedStateList = Record<string, boolean>;
 export declare type ExpandedState = true | Record<string, boolean>;
 export declare type ExpandedTableState = {
@@ -10,41 +10,30 @@ export declare type ExpandedRow = {
     toggleExpanded: (expanded?: boolean) => void;
     getIsExpanded: () => boolean;
     getCanExpand: () => boolean;
-    getToggleExpandedProps: <TGetter extends Getter<ToggleExpandedProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleExpandedProps, TGetter>;
+    getToggleExpandedHandler: () => () => void;
 };
-export declare type ExpandedOptions<TGenerics extends PartialGenerics> = {
+export declare type ExpandedOptions<TGenerics extends TableGenerics> = {
+    manualExpanding?: boolean;
     onExpandedChange?: OnChangeFn<ExpandedState>;
     autoResetExpanded?: boolean;
-    enableExpanded?: boolean;
-    expandRowsFn?: (instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>) => RowModel<TGenerics>;
-    expandSubRows?: boolean;
-    defaultCanExpand?: boolean;
+    enableExpanding?: boolean;
+    getExpandedRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     getIsRowExpanded?: (row: Row<TGenerics>) => boolean;
     getRowCanExpand?: (row: Row<TGenerics>) => boolean;
     paginateExpandedRows?: boolean;
 };
-export declare type ToggleExpandedProps = {
-    title?: string;
-    onClick?: (event: MouseEvent | TouchEvent) => void;
-};
-export declare type ExpandedInstance<TGenerics extends PartialGenerics> = {
-    _notifyExpandedReset: () => void;
+export declare type ExpandedInstance<TGenerics extends TableGenerics> = {
+    _autoResetExpanded: () => 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>;
+    resetExpanded: (defaultState?: boolean) => void;
+    getCanSomeRowsExpand: () => boolean;
+    getToggleAllRowsExpandedHandler: () => (event: unknown) => void;
+    getIsSomeRowsExpanded: () => boolean;
     getIsAllRowsExpanded: () => boolean;
     getExpandedDepth: () => number;
     getExpandedRowModel: () => RowModel<TGenerics>;
+    _getExpandedRowModel?: () => RowModel<TGenerics>;
     getPreExpandedRowModel: () => RowModel<TGenerics>;
 };
-export declare const Expanding: {
-    getInitialState: () => ExpandedTableState;
-    getDefaultOptions: <TGenerics extends Partial<import("..").DefaultGenerics>>(instance: TableInstance<TGenerics>) => ExpandedOptions<TGenerics>;
-    getInstance: <TGenerics_1 extends Partial<import("..").DefaultGenerics>>(instance: TableInstance<TGenerics_1>) => ExpandedInstance<TGenerics_1>;
-    createRow: <TGenerics_2 extends Partial<import("..").DefaultGenerics>>(row: Row<TGenerics_2>, instance: TableInstance<TGenerics_2>) => ExpandedRow;
-};
+export declare const Expanding: TableFeature;

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

@@ -1,92 +1,93 @@
 import { RowModel } from '..';
-import { BuiltInFilterType } from '../filterTypes';
-import { Column, OnChangeFn, PartialGenerics, TableInstance, Row, Updater } from '../types';
+import { TableFeature } from '../core/instance';
+import { BuiltInFilterFn } from '../filterFns';
+import { Column, OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
 import { Overwrite } from '../utils';
+export declare type FiltersTableState = {
+    columnFilters: ColumnFiltersState;
+    globalFilter: any;
+};
+export declare type ColumnFiltersState = ColumnFilter[];
 export declare type ColumnFilter = {
     id: string;
     value: unknown;
 };
-export declare type ColumnFiltersState = ColumnFilter[];
-export declare type FilterFn<TGenerics extends PartialGenerics> = {
-    (rows: Row<TGenerics>[], columnIds: string[], filterValue: any): any;
-    autoRemove?: ColumnFilterAutoRemoveTestFn<TGenerics>;
+export declare type ResolvedColumnFilter<TGenerics extends TableGenerics> = {
+    id: string;
+    resolvedValue: unknown;
+    filterFn: FilterFn<TGenerics>;
 };
-export declare type ColumnFilterAutoRemoveTestFn<TGenerics extends PartialGenerics> = (value: unknown, column?: Column<TGenerics>) => boolean;
-export declare type CustomFilterTypes<TGenerics extends PartialGenerics> = Record<string, FilterFn<TGenerics>>;
-export declare type FiltersTableState = {
-    columnFilters: ColumnFiltersState;
-    globalFilter: any;
+export declare type FilterFn<TGenerics extends TableGenerics> = {
+    (row: Row<TGenerics>, columnId: string, filterValue: any, addMeta: (meta: TGenerics['FilterMeta']) => void): boolean;
+    resolveFilterValue?: TransformFilterValueFn<TGenerics>;
+    autoRemove?: ColumnFilterAutoRemoveTestFn<TGenerics>;
 };
-export declare type FilterType<TGenerics extends PartialGenerics> = 'auto' | BuiltInFilterType | TGenerics['FilterFns'] | FilterFn<TGenerics>;
-export declare type FiltersColumnDef<TGenerics extends PartialGenerics> = {
-    filterType?: FilterType<Overwrite<TGenerics, {
+export declare type TransformFilterValueFn<TGenerics extends TableGenerics> = (value: any, column?: Column<TGenerics>) => unknown;
+export declare type ColumnFilterAutoRemoveTestFn<TGenerics extends TableGenerics> = (value: any, column?: Column<TGenerics>) => boolean;
+export declare type CustomFilterFns<TGenerics extends TableGenerics> = Record<string, FilterFn<TGenerics>>;
+export declare type FilterFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInFilterFn | keyof TGenerics['FilterFns'] | FilterFn<TGenerics>;
+export declare type FiltersColumnDef<TGenerics extends TableGenerics> = {
+    filterFn?: FilterFnOption<Overwrite<TGenerics, {
         Value: any;
     }>>;
-    enableAllFilters?: boolean;
     enableColumnFilter?: boolean;
     enableGlobalFilter?: boolean;
-    defaultCanFilter?: boolean;
-    defaultCanColumnFilter?: boolean;
-    defaultCanGlobalFilter?: boolean;
 };
-export declare type FiltersColumn<TGenerics extends PartialGenerics> = {
-    filterType: FilterType<Overwrite<TGenerics, {
+export declare type FiltersColumn<TGenerics extends TableGenerics> = {
+    filterFn: FilterFnOption<Overwrite<TGenerics, {
         Value: any;
     }>>;
-    getCanColumnFilter: () => boolean;
+    getAutoFilterFn: () => FilterFn<TGenerics> | undefined;
+    getFilterFn: () => FilterFn<TGenerics> | undefined;
+    setFilterValue: (updater: Updater<any>) => void;
+    getCanFilter: () => boolean;
     getCanGlobalFilter: () => boolean;
-    getColumnFilterIndex: () => number;
-    getIsColumnFiltered: () => boolean;
-    getColumnFilterValue: () => unknown;
-    setColumnFilterValue: (value: any) => void;
-    getPreFilteredRows: () => Row<TGenerics>[] | undefined;
-    getPreFilteredUniqueValues: () => Map<any, number>;
-    getPreFilteredMinMaxValues: () => [any, any];
+    getFacetedRowModel: () => RowModel<TGenerics>;
+    _getFacetedRowModel?: () => RowModel<TGenerics>;
+    getIsFiltered: () => boolean;
+    getFilterValue: () => unknown;
+    getFilterIndex: () => number;
+    getFacetedUniqueValues: () => Map<any, number>;
+    _getFacetedUniqueValues?: () => Map<any, number>;
+    getFacetedMinMaxValues: () => undefined | [number, number];
+    _getFacetedMinMaxValues?: () => undefined | [number, number];
+};
+export declare type FiltersRow<TGenerics extends TableGenerics> = {
+    columnFilters: Record<string, boolean>;
+    columnFiltersMeta: Record<string, TGenerics['FilterMeta']>;
 };
-export declare type FiltersOptions<TGenerics extends PartialGenerics> = {
-    filterFromChildrenUp?: boolean;
-    filterTypes?: TGenerics['FilterFns'];
+export declare type FiltersOptions<TGenerics extends TableGenerics> = {
     enableFilters?: boolean;
+    manualFiltering?: boolean;
+    filterFromLeafRows?: boolean;
+    filterFns?: TGenerics['FilterFns'];
+    getFilteredRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
-    autoResetColumnFilters?: boolean;
     enableColumnFilters?: boolean;
-    columnFilterRowsFn?: (instance: TableInstance<TGenerics>, coreRowModel: RowModel<TGenerics>) => RowModel<TGenerics>;
-    globalFilterType?: FilterType<TGenerics>;
+    globalFilterFn?: FilterFnOption<TGenerics>;
     onGlobalFilterChange?: OnChangeFn<any>;
-    enableGlobalFilters?: boolean;
-    autoResetGlobalFilter?: boolean;
     enableGlobalFilter?: boolean;
-    globalFilterRowsFn?: (instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>) => RowModel<TGenerics>;
-    getColumnCanGlobalFilterFn?: (column: Column<TGenerics>) => boolean;
+    getColumnCanGlobalFilter?: (column: Column<TGenerics>) => boolean;
+    getFacetedRowModel?: (instance: TableInstance<TGenerics>, columnId: string) => () => RowModel<TGenerics>;
+    getFacetedUniqueValues?: (instance: TableInstance<TGenerics>, columnId: string) => () => Map<any, number>;
+    getFacetedMinMaxValues?: (instance: TableInstance<TGenerics>, columnId: string) => () => undefined | [number, number];
 };
-export declare type FiltersInstance<TGenerics extends PartialGenerics> = {
-    _notifyFiltersReset: () => void;
-    getColumnAutoFilterFn: (columnId: string) => FilterFn<TGenerics> | undefined;
-    getColumnFilterFn: (columnId: string) => FilterFn<TGenerics> | undefined;
+export declare type FiltersInstance<TGenerics extends TableGenerics> = {
     setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
-    setColumnFilterValue: (columnId: string, value: any) => void;
-    resetColumnFilters: () => void;
-    getColumnCanColumnFilter: (columnId: string) => boolean;
-    getColumnCanGlobalFilterFn?: (column: Column<TGenerics>) => boolean;
-    getColumnIsFiltered: (columnId: string) => boolean;
-    getColumnFilterValue: (columnId: string) => unknown;
-    getColumnFilterIndex: (columnId: string) => number;
+    resetColumnFilters: (defaultState?: boolean) => void;
     getPreFilteredRowModel: () => RowModel<TGenerics>;
-    getPreColumnFilteredRowModel: () => RowModel<TGenerics>;
-    getColumnFilteredRowModel: () => RowModel<TGenerics>;
+    getFilteredRowModel: () => RowModel<TGenerics>;
+    _getFilteredRowModel?: () => RowModel<TGenerics>;
     setGlobalFilter: (updater: Updater<any>) => void;
-    resetGlobalFilter: () => void;
+    resetGlobalFilter: (defaultState?: boolean) => void;
     getGlobalAutoFilterFn: () => FilterFn<TGenerics> | undefined;
     getGlobalFilterFn: () => FilterFn<TGenerics> | undefined;
-    getColumnCanGlobalFilter: (columnId: string) => boolean;
-    getPreGlobalFilteredRowModel: () => RowModel<TGenerics>;
-    getGlobalFilteredRowModel: () => RowModel<TGenerics>;
-};
-export declare function getDefaultColumn<TGenerics extends PartialGenerics>(): FiltersColumnDef<TGenerics>;
-export declare const Filters: {
-    getInitialState: () => FiltersTableState;
-    getDefaultOptions: <TGenerics extends Partial<import("..").DefaultGenerics>>(instance: TableInstance<TGenerics>) => FiltersOptions<TGenerics>;
-    createColumn: <TGenerics_1 extends Partial<import("..").DefaultGenerics>>(column: Column<TGenerics_1>, instance: TableInstance<TGenerics_1>) => FiltersColumn<TGenerics_1>;
-    getInstance: <TGenerics_2 extends Partial<import("..").DefaultGenerics>>(instance: TableInstance<TGenerics_2>) => FiltersInstance<TGenerics_2>;
+    getGlobalFacetedRowModel: () => RowModel<TGenerics>;
+    _getGlobalFacetedRowModel?: () => RowModel<TGenerics>;
+    getGlobalFacetedUniqueValues: () => Map<any, number>;
+    _getGlobalFacetedUniqueValues?: () => Map<any, number>;
+    getGlobalFacetedMinMaxValues: () => undefined | [number, number];
+    _getGlobalFacetedMinMaxValues?: () => undefined | [number, number];
 };
-export declare function shouldAutoRemoveFilter<TGenerics extends PartialGenerics>(filterFn?: FilterFn<TGenerics>, value?: any, column?: Column<TGenerics>): boolean;
+export declare const Filters: TableFeature;
+export declare function shouldAutoRemoveFilter<TGenerics extends TableGenerics>(filterFn?: FilterFn<TGenerics>, value?: any, column?: Column<TGenerics>): boolean;