@tanstack/table-core 9.0.0-alpha.10 → 9.0.0-alpha.11

package/dist/esm/types/Row.d.ts

@@ -0,0 +1,19 @@
+import { Row_ColumnVisibility } from '../features/column-visibility/columnVisibilityFeature.types';
+import { Row_ColumnPinning } from '../features/column-pinning/columnPinningFeature.types';
+import { Row_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types';
+import { Row_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types';
+import { RowData, UnionToIntersection } from './type-utils.js';
+import { Row_RowExpanding } from '../features/row-expanding/rowExpandingFeature.types';
+import { Row_RowPinning } from '../features/row-pinning/rowPinningFeature.types';
+import { Row_RowSelection } from '../features/row-selection/rowSelectionFeature.types';
+import { ExtractFeatureTypes, TableFeatures } from './TableFeatures.js';
+import { Row_Row } from '../core/rows/coreRowsFeature.types';
+/**
+ * Use this interface as a target for declaration merging to add your own plugin properties.
+ * Note: This will affect the types of all tables in your project.
+ */
+export interface Row_Plugins<TFeatures extends TableFeatures, TData extends RowData> {
+}
+export interface Row_Core<TFeatures extends TableFeatures, TData extends RowData> extends Row_Row<TFeatures, TData> {
+}
+export type Row<TFeatures extends TableFeatures, TData extends RowData> = Row_Core<TFeatures, TData> & UnionToIntersection<('columnFilteringFeature' extends keyof TFeatures ? Row_ColumnFiltering<TFeatures, TData> : never) | ('columnGroupingFeature' extends keyof TFeatures ? Row_ColumnGrouping : never) | ('columnPinningFeature' extends keyof TFeatures ? Row_ColumnPinning<TFeatures, TData> : never) | ('columnVisibilityFeature' extends keyof TFeatures ? Row_ColumnVisibility<TFeatures, TData> : never) | ('rowExpandingFeature' extends keyof TFeatures ? Row_RowExpanding : never) | ('rowPinningFeature' extends keyof TFeatures ? Row_RowPinning : never) | ('rowSelectionFeature' extends keyof TFeatures ? Row_RowSelection : never)> & ExtractFeatureTypes<'Row', TFeatures> & Row_Plugins<TFeatures, TData>;

package/dist/esm/types/RowModel.d.ts

@@ -0,0 +1,23 @@
+import { CachedRowModel_Faceted, CreateRowModel_Faceted } from '../features/column-faceting/columnFacetingFeature.types';
+import { CachedRowModel_Grouped, CreateRowModel_Grouped } from '../features/column-grouping/columnGroupingFeature.types';
+import { CachedRowModel_Filtered, CreateRowModel_Filtered } from '../features/column-filtering/columnFilteringFeature.types';
+import { CachedRowModel_Core, CreateRowModel_Core, RowModel } from '../core/row-models/coreRowModelsFeature.types';
+import { CachedRowModel_Expanded, CreateRowModel_Expanded } from '../features/row-expanding/rowExpandingFeature.types';
+import { CachedRowModel_Paginated, CreateRowModel_Paginated } from '../features/row-pagination/rowPaginationFeature.types';
+import { CachedRowModel_Sorted, CreateRowModel_Sorted } from '../features/row-sorting/rowSortingFeature.types';
+import { RowData, UnionToIntersection } from './type-utils.js';
+import { ExtractFeatureTypes, TableFeatures } from './TableFeatures.js';
+/**
+ * Use this interface as a target for declaration merging to add your own plugin properties.
+ * Note: This will affect the types of all tables in your project.
+ */
+export interface CreateRowModels_Plugins<TFeatures extends TableFeatures, TData extends RowData> {
+}
+export type CreateRowModels<TFeatures extends TableFeatures, TData extends RowData> = CreateRowModel_Core<TFeatures, TData> & UnionToIntersection<('columnFacetingFeature' extends keyof TFeatures ? CreateRowModel_Faceted<TFeatures, TData> : never) | ('columnFilteringFeature' extends keyof TFeatures ? CreateRowModel_Filtered<TFeatures, TData> : never) | ('rowExpandingFeature' extends keyof TFeatures ? CreateRowModel_Expanded<TFeatures, TData> : never) | ('columnGroupingFeature' extends keyof TFeatures ? CreateRowModel_Grouped<TFeatures, TData> : never) | ('rowPaginationFeature' extends keyof TFeatures ? CreateRowModel_Paginated<TFeatures, TData> : never) | ('rowSortingFeature' extends keyof TFeatures ? CreateRowModel_Sorted<TFeatures, TData> : never)> & ExtractFeatureTypes<'CreateRowModels', TFeatures> & CreateRowModels_Plugins<TFeatures, TData>;
+export type CreateRowModels_All<TFeatures extends TableFeatures, TData extends RowData> = CreateRowModel_Core<TFeatures, TData> & CreateRowModel_Expanded<TFeatures, TData> & CreateRowModel_Faceted<TFeatures, TData> & CreateRowModel_Filtered<TFeatures, TData> & CreateRowModel_Grouped<TFeatures, TData> & CreateRowModel_Paginated<TFeatures, TData> & CreateRowModel_Sorted<TFeatures, TData>;
+export interface CachedRowModels_Plugins<TFeatures extends TableFeatures, TData extends RowData> {
+}
+export type CachedRowModels<TFeatures extends TableFeatures, TData extends RowData> = {
+    CachedRowModel_Core: () => RowModel<TFeatures, TData>;
+} & UnionToIntersection<('columnFacetingFeature' extends keyof TFeatures ? CachedRowModel_Faceted<TFeatures, TData> : never) | ('columnFilteringFeature' extends keyof TFeatures ? CachedRowModel_Filtered<TFeatures, TData> : never) | ('rowExpandingFeature' extends keyof TFeatures ? CachedRowModel_Expanded<TFeatures, TData> : never) | ('columnGroupingFeature' extends keyof TFeatures ? CachedRowModel_Grouped<TFeatures, TData> : never) | ('rowPaginationFeature' extends keyof TFeatures ? CachedRowModel_Paginated<TFeatures, TData> : never) | ('rowSortingFeature' extends keyof TFeatures ? CachedRowModel_Sorted<TFeatures, TData> : never)> & ExtractFeatureTypes<'CachedRowModel', TFeatures> & CachedRowModels_Plugins<TFeatures, TData>;
+export type CachedRowModel_All<TFeatures extends TableFeatures, TData extends RowData = any> = Partial<CachedRowModel_Core<TFeatures, TData> & CachedRowModel_Expanded<TFeatures, TData> & CachedRowModel_Faceted<TFeatures, TData> & CachedRowModel_Filtered<TFeatures, TData> & CachedRowModel_Grouped<TFeatures, TData> & CachedRowModel_Paginated<TFeatures, TData> & CachedRowModel_Sorted<TFeatures, TData>>;

package/dist/esm/types/RowModelFns.d.ts

@@ -0,0 +1,15 @@
+import { RowModelFns_RowSorting } from '../features/row-sorting/rowSortingFeature.types';
+import { RowModelFns_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types';
+import { RowData, UnionToIntersection } from './type-utils.js';
+import { RowModelFns_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types';
+import { ExtractFeatureTypes, TableFeatures } from './TableFeatures.js';
+/**
+ * Use this interface as a target for declaration merging to add your own plugin properties.
+ * Note: This will affect the types of all tables in your project.
+ */
+export interface RowModelFns_Plugins<TFeatures extends TableFeatures, TData extends RowData> {
+}
+export interface RowModelFns_Core {
+}
+export type RowModelFns<TFeatures extends TableFeatures, TData extends RowData> = Partial<UnionToIntersection<('columnFilteringFeature' extends keyof TFeatures ? RowModelFns_ColumnFiltering<TFeatures, TData> : never) | ('columnGroupingFeature' extends keyof TFeatures ? RowModelFns_ColumnGrouping<TFeatures, TData> : never) | ('rowSortingFeature' extends keyof TFeatures ? RowModelFns_RowSorting<TFeatures, TData> : never)> & ExtractFeatureTypes<'RowModelFns', TFeatures> & RowModelFns_Plugins<TFeatures, TData>>;
+export type RowModelFns_All<TFeatures extends TableFeatures, TData extends RowData> = Partial<RowModelFns_ColumnFiltering<TFeatures, TData> & RowModelFns_ColumnGrouping<TFeatures, TData> & RowModelFns_RowSorting<TFeatures, TData>>;

package/dist/esm/types/Table.d.ts

@@ -0,0 +1,53 @@
+import { Derived, Store } from '@tanstack/store';
+import { Table_ColumnFaceting } from '../features/column-faceting/columnFacetingFeature.types';
+import { Table_ColumnResizing } from '../features/column-resizing/columnResizingFeature.types';
+import { Table_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types';
+import { Table_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types';
+import { Table_ColumnPinning } from '../features/column-pinning/columnPinningFeature.types';
+import { Table_ColumnOrdering } from '../features/column-ordering/columnOrderingFeature.types';
+import { Table_ColumnVisibility } from '../features/column-visibility/columnVisibilityFeature.types';
+import { Table_ColumnSizing } from '../features/column-sizing/columnSizingFeature.types';
+import { Table_RowPinning } from '../features/row-pinning/rowPinningFeature.types';
+import { Table_GlobalFiltering } from '../features/global-filtering/globalFilteringFeature.types';
+import { Table_RowExpanding } from '../features/row-expanding/rowExpandingFeature.types';
+import { Table_RowPagination } from '../features/row-pagination/rowPaginationFeature.types';
+import { Table_RowSelection } from '../features/row-selection/rowSelectionFeature.types';
+import { Table_RowSorting } from '../features/row-sorting/rowSortingFeature.types';
+import { Table_RowModels } from '../core/row-models/coreRowModelsFeature.types';
+import { CachedRowModel_All, CreateRowModels_All } from './RowModel.js';
+import { RowModelFns_All } from './RowModelFns.js';
+import { TableState_All } from './TableState.js';
+import { RowData, UnionToIntersection } from './type-utils.js';
+import { ExtractFeatureTypes, TableFeatures } from './TableFeatures.js';
+import { Table_Columns } from '../core/columns/coreColumnsFeature.types';
+import { Table_Headers } from '../core/headers/coreHeadersFeature.types';
+import { Table_Rows } from '../core/rows/coreRowsFeature.types';
+import { Table_Table } from '../core/table/coreTablesFeature.types';
+import { TableOptions_All } from './TableOptions.js';
+/**
+ * Use this interface as a target for declaration merging to add your own plugin properties.
+ * Note: This will affect the types of all tables in your project.
+ */
+export interface Table_Plugins<TFeatures extends TableFeatures, TData extends RowData> {
+}
+/**
+ * The core table object that only includes the core table functionality such as column, header, row, and table APIS.
+ * No features are included.
+ */
+export type Table_Core<TFeatures extends TableFeatures, TData extends RowData> = Table_Table<TFeatures, TData> & Table_Columns<TFeatures, TData> & Table_Rows<TFeatures, TData> & Table_RowModels<TFeatures, TData> & Table_Headers<TFeatures, TData>;
+/**
+ * The table object that includes both the core table functionality and the features that are enabled via the `_features` table option.
+ */
+export type Table<TFeatures extends TableFeatures, TData extends RowData> = Table_Core<TFeatures, TData> & UnionToIntersection<('columnFilteringFeature' extends keyof TFeatures ? Table_ColumnFiltering : never) | ('columnGroupingFeature' extends keyof TFeatures ? Table_ColumnGrouping<TFeatures, TData> : never) | ('columnOrderingFeature' extends keyof TFeatures ? Table_ColumnOrdering<TFeatures, TData> : never) | ('columnPinningFeature' extends keyof TFeatures ? Table_ColumnPinning<TFeatures, TData> : never) | ('columnResizingFeature' extends keyof TFeatures ? Table_ColumnResizing : never) | ('columnSizingFeature' extends keyof TFeatures ? Table_ColumnSizing : never) | ('columnVisibilityFeature' extends keyof TFeatures ? Table_ColumnVisibility<TFeatures, TData> : never) | ('columnFacetingFeature' extends keyof TFeatures ? Table_ColumnFaceting<TFeatures, TData> : never) | ('globalFilteringFeature' extends keyof TFeatures ? Table_GlobalFiltering<TFeatures, TData> : never) | ('rowExpandingFeature' extends keyof TFeatures ? Table_RowExpanding<TFeatures, TData> : never) | ('rowPaginationFeature' extends keyof TFeatures ? Table_RowPagination<TFeatures, TData> : never) | ('rowPinningFeature' extends keyof TFeatures ? Table_RowPinning<TFeatures, TData> : never) | ('rowSelectionFeature' extends keyof TFeatures ? Table_RowSelection<TFeatures, TData> : never) | ('rowSortingFeature' extends keyof TFeatures ? Table_RowSorting<TFeatures, TData> : never)> & ExtractFeatureTypes<'Table', TFeatures> & Table_Plugins<TFeatures, TData>;
+export type Table_Internal<TFeatures extends TableFeatures, TData extends RowData = any> = Table<TFeatures, TData> & {
+    _rowModels: CachedRowModel_All<TFeatures, TData>;
+    _rowModelFns: RowModelFns_All<TFeatures, TData>;
+    options: TableOptions_All<TFeatures, TData> & {
+        _rowModels?: CreateRowModels_All<TFeatures, TData>;
+        state?: TableState_All;
+        initialState?: TableState_All;
+    };
+    initialState: TableState_All;
+    baseStore: Store<TableState_All>;
+    store: Derived<TableState_All>;
+};

package/dist/esm/types/TableFeatures.d.ts

@@ -0,0 +1,77 @@
+import { CoreFeatures } from '../core/coreFeatures.js';
+import { CellData, RowData, UnionToIntersection } from './type-utils.js';
+import { ColumnDefBase_All } from './ColumnDef.js';
+import { Row } from './Row.js';
+import { Table_Internal } from './Table.js';
+import { TableOptions_All } from './TableOptions.js';
+import { TableState_All } from './TableState.js';
+import { StockFeatures } from '../features/stockFeatures.js';
+export type ExtractFeatureTypes<TKey extends keyof FeatureConstructors, TFeatures extends TableFeatures> = UnionToIntersection<{
+    [K in keyof TFeatures]: TFeatures[K] extends TableFeature<infer FeatureConstructorOptions> ? TKey extends keyof FeatureConstructorOptions ? FeatureConstructorOptions[TKey] : never : any;
+}[keyof TFeatures]>;
+interface FeatureConstructors {
+    CachedRowModel?: any;
+    Cell?: any;
+    Column?: any;
+    ColumnDef?: any;
+    CreateRowModels?: any;
+    Header?: any;
+    HeaderGroup?: any;
+    Row?: any;
+    RowModelFns?: any;
+    Table?: any;
+    TableOptions?: any;
+    TableState?: any;
+}
+export interface Plugins {
+}
+export interface TableFeatures extends Partial<CoreFeatures>, Partial<StockFeatures>, Partial<Plugins> {
+}
+export type ConstructTableAPIs<TConstructors extends FeatureConstructors> = <TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData> & Partial<TConstructors['Table']> & {
+    options: Partial<TConstructors['TableOptions']>;
+}) => void;
+export type GetDefaultColumnDef<TConstructors extends FeatureConstructors> = <TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>() => ColumnDefBase_All<TFeatures, TData, TValue> & Partial<TConstructors['ColumnDef']>;
+export type GetDefaultTableOptions<TConstructors extends FeatureConstructors> = <TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData> & Partial<TConstructors['Table']>) => Partial<TableOptions_All<TFeatures, TData>> & Partial<TConstructors['TableOptions']>;
+export type GetInitialState<TConstructors extends FeatureConstructors> = (initialState: Partial<TableState_All> & Partial<TConstructors['TableState']>) => TableState_All & Partial<TConstructors['TableState']>;
+export type GetDefaultStateSelector<TConstructors extends FeatureConstructors> = (state: TableState_All) => Partial<TableState_All> & Partial<TConstructors['TableState']>;
+export type AssignCellPrototype<TConstructors extends FeatureConstructors> = <TFeatures extends TableFeatures, TData extends RowData>(prototype: Record<string, any>, table: Table_Internal<TFeatures, TData>) => void;
+export type AssignColumnPrototype<TConstructors extends FeatureConstructors> = <TFeatures extends TableFeatures, TData extends RowData>(prototype: Record<string, any>, table: Table_Internal<TFeatures, TData>) => void;
+export type AssignHeaderPrototype<TConstructors extends FeatureConstructors> = <TFeatures extends TableFeatures, TData extends RowData>(prototype: Record<string, any>, table: Table_Internal<TFeatures, TData>) => void;
+export type AssignRowPrototype<TConstructors extends FeatureConstructors> = <TFeatures extends TableFeatures, TData extends RowData>(prototype: Record<string, any>, table: Table_Internal<TFeatures, TData>) => void;
+export type InitRowInstanceData<TConstructors extends FeatureConstructors> = <TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData> & Partial<TConstructors['Row']>) => void;
+export interface TableFeature<TConstructors extends FeatureConstructors> {
+    /**
+     * Assigns Cell APIs to the cell prototype for memory-efficient method sharing.
+     * This is called once per table to build a shared prototype for all cells.
+     */
+    assignCellPrototype?: AssignCellPrototype<TConstructors>;
+    /**
+     * Assigns Column APIs to the column prototype for memory-efficient method sharing.
+     * This is called once per table to build a shared prototype for all columns.
+     */
+    assignColumnPrototype?: AssignColumnPrototype<TConstructors>;
+    /**
+     * Assigns Header APIs to the header prototype for memory-efficient method sharing.
+     * This is called once per table to build a shared prototype for all headers.
+     */
+    assignHeaderPrototype?: AssignHeaderPrototype<TConstructors>;
+    /**
+     * Assigns Row APIs to the row prototype for memory-efficient method sharing.
+     * This is called once per table to build a shared prototype for all rows.
+     */
+    assignRowPrototype?: AssignRowPrototype<TConstructors>;
+    /**
+     * Assigns Table APIs to the table instance.
+     * Unlike row/cell/column/header, the table is a singleton so methods are assigned directly.
+     */
+    constructTableAPIs?: ConstructTableAPIs<TConstructors>;
+    getDefaultColumnDef?: GetDefaultColumnDef<TConstructors>;
+    getDefaultTableOptions?: GetDefaultTableOptions<TConstructors>;
+    getInitialState?: GetInitialState<TConstructors>;
+    /**
+     * Initializes instance-specific data on each row (e.g., caches).
+     * Methods should be assigned via assignRowPrototype instead.
+     */
+    initRowInstanceData?: InitRowInstanceData<TConstructors>;
+}
+export {};

package/dist/esm/types/TableOptions.d.ts

@@ -0,0 +1,39 @@
+import { CoreFeatures } from '../core/coreFeatures.js';
+import { TableOptions_Cell } from '../core/cells/coreCellsFeature.types';
+import { TableOptions_Columns } from '../core/columns/coreColumnsFeature.types';
+import { TableOptions_Rows } from '../core/rows/coreRowsFeature.types';
+import { TableOptions_Table } from '../core/table/coreTablesFeature.types';
+import { TableOptions_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types';
+import { TableOptions_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types';
+import { TableOptions_ColumnOrdering } from '../features/column-ordering/columnOrderingFeature.types';
+import { TableOptions_ColumnPinning } from '../features/column-pinning/columnPinningFeature.types';
+import { TableOptions_ColumnResizing } from '../features/column-resizing/columnResizingFeature.types';
+import { TableOptions_ColumnSizing } from '../features/column-sizing/columnSizingFeature.types';
+import { TableOptions_ColumnVisibility } from '../features/column-visibility/columnVisibilityFeature.types';
+import { TableOptions_GlobalFiltering } from '../features/global-filtering/globalFilteringFeature.types';
+import { TableOptions_RowExpanding } from '../features/row-expanding/rowExpandingFeature.types';
+import { TableOptions_RowPagination } from '../features/row-pagination/rowPaginationFeature.types';
+import { TableOptions_RowPinning } from '../features/row-pinning/rowPinningFeature.types';
+import { TableOptions_RowSelection } from '../features/row-selection/rowSelectionFeature.types';
+import { TableOptions_RowSorting } from '../features/row-sorting/rowSortingFeature.types';
+import { RowData, UnionToIntersection } from './type-utils.js';
+import { ExtractFeatureTypes, TableFeatures } from './TableFeatures.js';
+export interface TableOptions_Plugins<TFeatures extends TableFeatures, TData extends RowData> {
+}
+export interface TableOptions_Core<TFeatures extends TableFeatures, TData extends RowData> extends TableOptions_Table<TFeatures, TData>, TableOptions_Cell, TableOptions_Columns<TFeatures, TData>, TableOptions_Rows<TFeatures, TData> {
+}
+type DebugKeysFor<TFeatures extends TableFeatures> = {
+    [K in keyof TFeatures & string as `debug${Capitalize<K>}`]?: boolean;
+};
+export type DebugOptions<TFeatures extends TableFeatures> = {
+    debugAll?: boolean;
+    debugCache?: boolean;
+    debugCells?: boolean;
+    debugColumns?: boolean;
+    debugHeaders?: boolean;
+    debugRows?: boolean;
+    debugTable?: boolean;
+} & DebugKeysFor<CoreFeatures & TFeatures>;
+export type TableOptions<TFeatures extends TableFeatures, TData extends RowData> = TableOptions_Core<TFeatures, TData> & UnionToIntersection<('columnFilteringFeature' extends keyof TFeatures ? TableOptions_ColumnFiltering<TFeatures, TData> : never) | ('columnGroupingFeature' extends keyof TFeatures ? TableOptions_ColumnGrouping : never) | ('columnOrderingFeature' extends keyof TFeatures ? TableOptions_ColumnOrdering : never) | ('columnPinningFeature' extends keyof TFeatures ? TableOptions_ColumnPinning : never) | ('columnResizingFeature' extends keyof TFeatures ? TableOptions_ColumnResizing : never) | ('columnSizingFeature' extends keyof TFeatures ? TableOptions_ColumnSizing : never) | ('columnVisibilityFeature' extends keyof TFeatures ? TableOptions_ColumnVisibility : never) | ('globalFilteringFeature' extends keyof TFeatures ? TableOptions_GlobalFiltering<TFeatures, TData> : never) | ('rowExpandingFeature' extends keyof TFeatures ? TableOptions_RowExpanding<TFeatures, TData> : never) | ('rowPaginationFeature' extends keyof TFeatures ? TableOptions_RowPagination : never) | ('rowPinningFeature' extends keyof TFeatures ? TableOptions_RowPinning<TFeatures, TData> : never) | ('rowSelectionFeature' extends keyof TFeatures ? TableOptions_RowSelection<TFeatures, TData> : never) | ('rowSortingFeature' extends keyof TFeatures ? TableOptions_RowSorting : never)> & ExtractFeatureTypes<'TableOptions', TFeatures> & TableOptions_Plugins<TFeatures, TData> & DebugOptions<TFeatures>;
+export type TableOptions_All<TFeatures extends TableFeatures, TData extends RowData> = TableOptions_Core<TFeatures, TData> & Partial<TableOptions_ColumnFiltering<TFeatures, TData> & TableOptions_ColumnGrouping & TableOptions_ColumnOrdering & TableOptions_ColumnPinning & TableOptions_ColumnResizing & TableOptions_ColumnSizing & TableOptions_ColumnVisibility & TableOptions_GlobalFiltering<TFeatures, TData> & TableOptions_RowExpanding<TFeatures, TData> & TableOptions_RowPagination & TableOptions_RowPinning<TFeatures, TData> & TableOptions_RowSelection<TFeatures, TData> & TableOptions_RowSorting>;
+export {};

package/dist/esm/types/TableState.d.ts

@@ -0,0 +1,23 @@
+import { UnionToIntersection } from './type-utils.js';
+import { TableState_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types';
+import { TableState_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types';
+import { TableState_ColumnOrdering } from '../features/column-ordering/columnOrderingFeature.types';
+import { TableState_ColumnPinning } from '../features/column-pinning/columnPinningFeature.types';
+import { TableState_ColumnResizing } from '../features/column-resizing/columnResizingFeature.types';
+import { TableState_ColumnSizing } from '../features/column-sizing/columnSizingFeature.types';
+import { TableState_ColumnVisibility } from '../features/column-visibility/columnVisibilityFeature.types';
+import { TableState_GlobalFiltering } from '../features/global-filtering/globalFilteringFeature.types';
+import { TableState_RowExpanding } from '../features/row-expanding/rowExpandingFeature.types';
+import { TableState_RowPagination } from '../features/row-pagination/rowPaginationFeature.types';
+import { TableState_RowPinning } from '../features/row-pinning/rowPinningFeature.types';
+import { TableState_RowSelection } from '../features/row-selection/rowSelectionFeature.types';
+import { TableState_RowSorting } from '../features/row-sorting/rowSortingFeature.types';
+import { ExtractFeatureTypes, TableFeatures } from './TableFeatures.js';
+/**
+ * Use this interface as a target for declaration merging to add your own state properties.
+ * Note: This will affect the types of all tables in your project.
+ */
+export interface TableState_Plugins<TFeatures extends TableFeatures> {
+}
+export type TableState<TFeatures extends TableFeatures> = UnionToIntersection<('columnFilteringFeature' extends keyof TFeatures ? TableState_ColumnFiltering : never) | ('columnGroupingFeature' extends keyof TFeatures ? TableState_ColumnGrouping : never) | ('columnOrderingFeature' extends keyof TFeatures ? TableState_ColumnOrdering : never) | ('columnPinningFeature' extends keyof TFeatures ? TableState_ColumnPinning : never) | ('columnResizingFeature' extends keyof TFeatures ? TableState_ColumnResizing : never) | ('columnSizingFeature' extends keyof TFeatures ? TableState_ColumnSizing : never) | ('columnVisibilityFeature' extends keyof TFeatures ? TableState_ColumnVisibility : never) | ('globalFilteringFeature' extends keyof TFeatures ? TableState_GlobalFiltering : never) | ('rowExpandingFeature' extends keyof TFeatures ? TableState_RowExpanding : never) | ('rowPaginationFeature' extends keyof TFeatures ? TableState_RowPagination : never) | ('rowPinningFeature' extends keyof TFeatures ? TableState_RowPinning : never) | ('rowSelectionFeature' extends keyof TFeatures ? TableState_RowSelection : never) | ('rowSortingFeature' extends keyof TFeatures ? TableState_RowSorting : never)> & ExtractFeatureTypes<'TableState', TFeatures> & TableState_Plugins<TFeatures>;
+export type TableState_All = Partial<TableState_ColumnFiltering & TableState_ColumnGrouping & TableState_ColumnOrdering & TableState_ColumnPinning & TableState_ColumnResizing & TableState_ColumnSizing & TableState_ColumnVisibility & TableState_GlobalFiltering & TableState_RowExpanding & TableState_RowPagination & TableState_RowPinning & TableState_RowSelection & TableState_RowSorting>;

package/dist/esm/types/type-utils.d.ts

@@ -0,0 +1,22 @@
+export type Updater<T> = T | ((old: T) => T);
+export type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void;
+export type RowData = Record<string, any> | Array<any>;
+export type CellData = unknown;
+export type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type RequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+export type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+type ComputeRange<N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : ComputeRange<N, [...Result, Result['length']]>;
+type Index40 = ComputeRange<40>[number];
+type IsTuple<T> = T extends ReadonlyArray<any> & {
+    length: infer Length;
+} ? Length extends Index40 ? T : never : never;
+type AllowedIndexes<Tuple extends ReadonlyArray<any>, Keys extends number = never> = Tuple extends readonly [] ? Keys : Tuple extends readonly [infer _, ...infer Tail] ? AllowedIndexes<Tail, Keys | Tail['length']> : Keys;
+export type DeepKeys<T, TDepth extends Array<any> = []> = TDepth['length'] extends 5 ? never : unknown extends T ? string : T extends ReadonlyArray<any> & IsTuple<T> ? AllowedIndexes<T> | DeepKeysPrefix<T, AllowedIndexes<T>, TDepth> : T extends Array<any> ? DeepKeys<T[number], [...TDepth, any]> : T extends Date ? never : T extends object ? (keyof T & string) | DeepKeysPrefix<T, keyof T, TDepth> : never;
+type DeepKeysPrefix<T, TPrefix, TDepth extends Array<any>> = TPrefix extends keyof T & (number | string) ? `${TPrefix}.${DeepKeys<T[TPrefix], [...TDepth, any]> & string}` : never;
+export type DeepValue<T, TProp> = T extends Record<string | number, any> ? TProp extends `${infer TBranch}.${infer TDeepProp}` ? DeepValue<T[TBranch], TDeepProp> : T[TProp & string] : never;
+export type NoInfer<T> = [T][T extends any ? 0 : never];
+export type Getter<TValue> = <TTValue = TValue>() => NoInfer<TTValue>;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & unknown;
+export {};

package/dist/esm/utils.d.ts

@@ -1,39 +1,72 @@
-import { TableOptionsResolved, TableState, Updater } from './types.js';
-
-export type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-export type RequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
-export type Overwrite<T, U extends {
-    [TKey in keyof T]?: any;
-}> = Omit<T, keyof U> & U;
-export type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
-export type IsAny<T, Y, N> = 1 extends 0 & T ? Y : N;
-export type IsKnown<T, Y, N> = unknown extends T ? N : Y;
-type ComputeRange<N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : ComputeRange<N, [...Result, Result['length']]>;
-type Index40 = ComputeRange<40>[number];
-type IsTuple<T> = T extends readonly any[] & {
-    length: infer Length;
-} ? Length extends Index40 ? T : never : never;
-type AllowedIndexes<Tuple extends ReadonlyArray<any>, Keys extends number = never> = Tuple extends readonly [] ? Keys : Tuple extends readonly [infer _, ...infer Tail] ? AllowedIndexes<Tail, Keys | Tail['length']> : Keys;
-export type DeepKeys<T, TDepth extends any[] = []> = TDepth['length'] extends 5 ? never : unknown extends T ? string : T extends readonly any[] & IsTuple<T> ? AllowedIndexes<T> | DeepKeysPrefix<T, AllowedIndexes<T>, TDepth> : T extends any[] ? DeepKeys<T[number], [...TDepth, any]> : T extends Date ? never : T extends object ? (keyof T & string) | DeepKeysPrefix<T, keyof T, TDepth> : never;
-type DeepKeysPrefix<T, TPrefix, TDepth extends any[]> = TPrefix extends keyof T & (number | string) ? `${TPrefix}.${DeepKeys<T[TPrefix], [...TDepth, any]> & string}` : never;
-export type DeepValue<T, TProp> = T extends Record<string | number, any> ? TProp extends `${infer TBranch}.${infer TDeepProp}` ? DeepValue<T[TBranch], TDeepProp> : T[TProp & string] : never;
-export type NoInfer<T> = [T][T extends any ? 0 : never];
-export type Getter<TValue> = <TTValue = TValue>() => NoInfer<TTValue>;
+import { Table, Table_Internal } from './types/Table.js';
+import { NoInfer, RowData, Updater } from './types/type-utils.js';
+import { TableFeatures } from './types/TableFeatures.js';
+import { TableState, TableState_All } from './types/TableState.js';
 export declare function functionalUpdate<T>(updater: Updater<T>, input: T): T;
 export declare function noop(): void;
-export declare function makeStateUpdater<K extends keyof TableState>(key: K, instance: unknown): (updater: Updater<TableState[K]>) => void;
+export declare function makeStateUpdater<TFeatures extends TableFeatures, K extends (string & {}) | keyof TableState_All | keyof TableState<TFeatures>>(key: K, instance: Table<TFeatures, any>): (updater: Updater<TableState<any>[K & keyof TableState<any>]>) => void;
 type AnyFunction = (...args: any) => any;
 export declare function isFunction<T extends AnyFunction>(d: any): d is T;
-export declare function isNumberArray(d: any): d is number[];
-export declare function flattenBy<TNode>(arr: TNode[], getChildren: (item: TNode) => TNode[]): TNode[];
-export declare function memo<TDeps extends readonly any[], TDepArgs, TResult>(getDeps: (depArgs?: TDepArgs) => [...TDeps], fn: (...args: NoInfer<[...TDeps]>) => TResult, opts: {
-    key: any;
-    debug?: () => any;
-    onChange?: (result: TResult) => void;
-}): (depArgs?: TDepArgs) => TResult;
-export declare function getMemoOptions(tableOptions: Partial<TableOptionsResolved<any>>, debugLevel: 'debugAll' | 'debugCells' | 'debugTable' | 'debugColumns' | 'debugRows' | 'debugHeaders', key: string, onChange?: (result: any) => void): {
-    debug: () => boolean | undefined;
-    key: string | false;
-    onChange: ((result: any) => void) | undefined;
+export declare function isNumberArray(d: any): d is Array<number>;
+export declare function flattenBy<TNode>(arr: Array<TNode>, getChildren: (item: TNode) => Array<TNode>): TNode[];
+export declare const $internalMemoFnMeta: unique symbol;
+export type MemoFnMeta = {
+    originalArgsLength?: number;
 };
+/**
+ * @internal
+ */
+export declare function getMemoFnMeta(fn: any): MemoFnMeta | null;
+interface MemoOptions<TDeps extends ReadonlyArray<any>, TDepArgs, TResult> {
+    fn: (...args: NoInfer<TDeps>) => TResult;
+    memoDeps?: (depArgs?: TDepArgs) => [...TDeps] | undefined;
+    onAfterCompare?: (depsChanged: boolean) => void;
+    onAfterUpdate?: (result: TResult) => void;
+    onBeforeCompare?: () => void;
+    onBeforeUpdate?: () => void;
+}
+export declare const memo: <TDeps extends ReadonlyArray<any>, TDepArgs, TResult>({ fn, memoDeps, onAfterCompare, onAfterUpdate, onBeforeCompare, onBeforeUpdate, }: MemoOptions<TDeps, TDepArgs, TResult>) => ((depArgs?: TDepArgs) => TResult);
+interface TableMemoOptions<TFeatures extends TableFeatures, TDeps extends ReadonlyArray<any>, TDepArgs, TResult> extends MemoOptions<TDeps, TDepArgs, TResult> {
+    feature?: keyof TFeatures & string;
+    fnName: string;
+    objectId?: string;
+    onAfterUpdate?: () => void;
+    table: Table_Internal<TFeatures, any>;
+}
+export declare function tableMemo<TFeatures extends TableFeatures, TDeps extends ReadonlyArray<any>, TDepArgs, TResult>({ feature, fnName, objectId, onAfterUpdate, table, ...memoOptions }: TableMemoOptions<TFeatures, TDeps, TDepArgs, TResult>): (depArgs?: TDepArgs | undefined) => TResult;
+export interface API<TDeps extends ReadonlyArray<any>, TDepArgs> {
+    fn: (...args: any) => any;
+    memoDeps?: (depArgs?: any) => [...any] | undefined;
+}
+export type APIObject<TDeps extends ReadonlyArray<any>, TDepArgs> = Record<string, API<TDeps, TDepArgs>>;
+/**
+ * Assumes that a function name is in the format of `parentName_fnKey` and returns the `fnKey` and `fnName` in the format of `parentName.fnKey`.
+ */
+export declare function getFunctionNameInfo(staticFnName: string, splitBy?: '_' | '.'): {
+    fnKey: string;
+    fnName: string;
+    parentName: string;
+};
+/**
+ * Assigns Table API methods directly to the table instance.
+ * Unlike row/cell/column/header, the table is a singleton so methods are assigned directly.
+ */
+export declare function assignTableAPIs<TFeatures extends TableFeatures, TData extends RowData, TDeps extends ReadonlyArray<any>, TDepArgs>(feature: keyof TFeatures & string, table: Table_Internal<TFeatures, TData>, apis: APIObject<TDeps, NoInfer<TDepArgs>>): void;
+export interface PrototypeAPI<TDeps extends ReadonlyArray<any>, TDepArgs> {
+    fn: (self: any, ...args: any) => any;
+    memoDeps?: (self: any, depArgs?: any) => [...any] | undefined;
+}
+export type PrototypeAPIObject<TDeps extends ReadonlyArray<any>, TDepArgs> = Record<string, PrototypeAPI<TDeps, TDepArgs>>;
+/**
+ * Assigns API methods to a prototype object for memory-efficient method sharing.
+ * All instances created with this prototype will share the same method references.
+ *
+ * For memoized methods, the memo state is lazily created and stored on each instance.
+ * This provides the best of both worlds: shared method code + per-instance caching.
+ */
+export declare function assignPrototypeAPIs<TFeatures extends TableFeatures, TData extends RowData, TDeps extends ReadonlyArray<any>, TDepArgs>(feature: keyof TFeatures & string, prototype: Record<string, any>, table: Table_Internal<TFeatures, TData>, apis: PrototypeAPIObject<TDeps, NoInfer<TDepArgs>>): void;
+/**
+ * Looks to run the memoized function with the builder pattern on the object if it exists, otherwise fallback to the static method passed in.
+ */
+export declare function callMemoOrStaticFn<TObject extends Record<string, any>, TStaticFn extends AnyFunction>(obj: TObject, fnKey: string, staticFn: TStaticFn, ...args: Parameters<TStaticFn> extends [any, ...infer Rest] ? Rest : never): ReturnType<TStaticFn>;
 export {};