better-table 1.1.0 → 1.3.0

package/dist/components/BetterTable/__tests__/helpers/test-data.d.ts

@@ -0,0 +1,125 @@
+import { Column } from '../../types';
+export interface User {
+    [key: string]: unknown;
+    id: number;
+    name: string;
+    email: string;
+    age?: number;
+    isActive?: boolean;
+    role?: string;
+    department?: {
+        name: string;
+        floor: number;
+    };
+}
+export declare const mockUsers: User[];
+export declare const fewUsers: User[];
+export declare const manyUsers: User[];
+export declare const userColumns: Column<User>[];
+/**
+ * Helper para obtener el elemento de la tabla tradicional (no cards)
+ * Útil porque ahora ambos (tabla y cards) renderizan los datos
+ */
+export declare const getTable: (container: HTMLElement) => HTMLElement;
+/**
+ * Helper para buscar dentro de la tabla tradicional
+ */
+export declare const withinTable: (container: HTMLElement) => {
+    getByLabelText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined): ReturnType<import('@testing-library/react').GetByText<T>>;
+    getAllByLabelText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByText<T>>;
+    queryByLabelText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined): ReturnType<import('@testing-library/react').QueryByText<T>>;
+    queryAllByLabelText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByText<T>>;
+    findByLabelText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindByText<T>>;
+    findAllByLabelText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindAllByText<T>>;
+    getByPlaceholderText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').GetByBoundAttribute<T>>;
+    getAllByPlaceholderText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByBoundAttribute<T>>;
+    queryByPlaceholderText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').QueryByBoundAttribute<T>>;
+    queryAllByPlaceholderText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByBoundAttribute<T>>;
+    findByPlaceholderText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindByBoundAttribute<T>>;
+    findAllByPlaceholderText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindAllByBoundAttribute<T>>;
+    getByText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined): ReturnType<import('@testing-library/react').GetByText<T>>;
+    getAllByText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByText<T>>;
+    queryByText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined): ReturnType<import('@testing-library/react').QueryByText<T>>;
+    queryAllByText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByText<T>>;
+    findByText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindByText<T>>;
+    findAllByText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindAllByText<T>>;
+    getByAltText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').GetByBoundAttribute<T>>;
+    getAllByAltText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByBoundAttribute<T>>;
+    queryByAltText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').QueryByBoundAttribute<T>>;
+    queryAllByAltText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByBoundAttribute<T>>;
+    findByAltText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindByBoundAttribute<T>>;
+    findAllByAltText<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindAllByBoundAttribute<T>>;
+    getByTitle<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').GetByBoundAttribute<T>>;
+    getAllByTitle<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByBoundAttribute<T>>;
+    queryByTitle<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').QueryByBoundAttribute<T>>;
+    queryAllByTitle<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByBoundAttribute<T>>;
+    findByTitle<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindByBoundAttribute<T>>;
+    findAllByTitle<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindAllByBoundAttribute<T>>;
+    getByDisplayValue<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').GetByBoundAttribute<T>>;
+    getAllByDisplayValue<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByBoundAttribute<T>>;
+    queryByDisplayValue<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').QueryByBoundAttribute<T>>;
+    queryAllByDisplayValue<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByBoundAttribute<T>>;
+    findByDisplayValue<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindByBoundAttribute<T>>;
+    findAllByDisplayValue<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindAllByBoundAttribute<T>>;
+    getByRole<T extends HTMLElement = HTMLElement>(role: import('@testing-library/react').ByRoleMatcher, options?: import('@testing-library/react').ByRoleOptions | undefined): ReturnType<import('@testing-library/react').GetByRole<T>>;
+    getAllByRole<T extends HTMLElement = HTMLElement>(role: import('@testing-library/react').ByRoleMatcher, options?: import('@testing-library/react').ByRoleOptions | undefined): ReturnType<import('@testing-library/react').AllByRole<T>>;
+    queryByRole<T extends HTMLElement = HTMLElement>(role: import('@testing-library/react').ByRoleMatcher, options?: import('@testing-library/react').ByRoleOptions | undefined): ReturnType<import('@testing-library/react').QueryByRole<T>>;
+    queryAllByRole<T extends HTMLElement = HTMLElement>(role: import('@testing-library/react').ByRoleMatcher, options?: import('@testing-library/react').ByRoleOptions | undefined): ReturnType<import('@testing-library/react').AllByRole<T>>;
+    findByRole<T extends HTMLElement = HTMLElement>(role: import('@testing-library/react').ByRoleMatcher, options?: import('@testing-library/react').ByRoleOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindByRole<T>>;
+    findAllByRole<T extends HTMLElement = HTMLElement>(role: import('@testing-library/react').ByRoleMatcher, options?: import('@testing-library/react').ByRoleOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindAllByRole<T>>;
+    getByTestId<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').GetByBoundAttribute<T>>;
+    getAllByTestId<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByBoundAttribute<T>>;
+    queryByTestId<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').QueryByBoundAttribute<T>>;
+    queryAllByTestId<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined): ReturnType<import('@testing-library/react').AllByBoundAttribute<T>>;
+    findByTestId<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindByBoundAttribute<T>>;
+    findAllByTestId<T extends HTMLElement = HTMLElement>(id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined): ReturnType<import('@testing-library/react').FindAllByBoundAttribute<T>>;
+} & {
+    getByLabelText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined) => HTMLElement;
+    getAllByLabelText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined) => HTMLElement[];
+    queryByLabelText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined) => HTMLElement | null;
+    queryAllByLabelText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined) => HTMLElement[];
+    findByLabelText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByLabelText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByPlaceholderText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement;
+    getAllByPlaceholderText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement[];
+    queryByPlaceholderText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByPlaceholderText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement[];
+    findByPlaceholderText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByPlaceholderText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined) => HTMLElement;
+    getAllByText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined) => HTMLElement[];
+    queryByText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined) => HTMLElement | null;
+    queryAllByText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined) => HTMLElement[];
+    findByText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').SelectorMatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByAltText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement;
+    getAllByAltText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement[];
+    queryByAltText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByAltText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement[];
+    findByAltText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByAltText: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByTitle: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement;
+    getAllByTitle: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement[];
+    queryByTitle: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByTitle: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement[];
+    findByTitle: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByTitle: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByDisplayValue: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement;
+    getAllByDisplayValue: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement[];
+    queryByDisplayValue: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByDisplayValue: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement[];
+    findByDisplayValue: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByDisplayValue: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByRole: (role: import('@testing-library/react').ByRoleMatcher, options?: import('@testing-library/react').ByRoleOptions | undefined) => HTMLElement;
+    getAllByRole: (role: import('@testing-library/react').ByRoleMatcher, options?: import('@testing-library/react').ByRoleOptions | undefined) => HTMLElement[];
+    queryByRole: (role: import('@testing-library/react').ByRoleMatcher, options?: import('@testing-library/react').ByRoleOptions | undefined) => HTMLElement | null;
+    queryAllByRole: (role: import('@testing-library/react').ByRoleMatcher, options?: import('@testing-library/react').ByRoleOptions | undefined) => HTMLElement[];
+    findByRole: (role: import('@testing-library/react').ByRoleMatcher, options?: import('@testing-library/react').ByRoleOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByRole: (role: import('@testing-library/react').ByRoleMatcher, options?: import('@testing-library/react').ByRoleOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByTestId: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement;
+    getAllByTestId: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement[];
+    queryByTestId: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByTestId: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined) => HTMLElement[];
+    findByTestId: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByTestId: (id: import('@testing-library/react').Matcher, options?: import('@testing-library/react').MatcherOptions | undefined, waitForElementOptions?: import('@testing-library/react').waitForOptions | undefined) => Promise<HTMLElement[]>;
+};

package/dist/components/BetterTable/components/TableActionOverflow.d.ts

@@ -0,0 +1,16 @@
+import { TableData, RowAction } from '../types';
+interface TableActionOverflowProps<T extends TableData> {
+    /** Actions to show in the dropdown */
+    actions: RowAction<T>[];
+    /** Row data */
+    row: T;
+    /** Row index */
+    rowIndex: number;
+    /** Handler for action clicks */
+    onActionClick: (action: RowAction<T>) => void;
+    /** Direction the menu opens */
+    direction?: 'up' | 'down';
+}
+declare function TableActionOverflowInner<T extends TableData>({ actions, row, rowIndex: _rowIndex, onActionClick, direction, }: TableActionOverflowProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare const TableActionOverflow: typeof TableActionOverflowInner;
+export {};

package/dist/components/BetterTable/components/TableColumnVisibility.d.ts

@@ -0,0 +1,4 @@
+import { TableData } from '../types';
+declare function TableColumnVisibilityInner<T extends TableData>(): import("react/jsx-runtime").JSX.Element | null;
+export declare const TableColumnVisibility: typeof TableColumnVisibilityInner;
+export {};

package/dist/components/BetterTable/components/TableExpandedRow.d.ts

@@ -0,0 +1,8 @@
+import { TableData } from '../types';
+interface TableExpandedRowProps<T extends TableData> {
+    row: T;
+    rowIndex: number;
+}
+declare function TableExpandedRowInner<T extends TableData>({ row, rowIndex }: TableExpandedRowProps<T>): import("react/jsx-runtime").JSX.Element | null;
+export declare const TableExpandedRow: typeof TableExpandedRowInner;
+export {};

package/dist/components/BetterTable/components/TableFilterPanel.d.ts

@@ -0,0 +1,7 @@
+import { TableData } from '../types';
+interface TableFilterPanelProps {
+    open: boolean;
+}
+declare function TableFilterPanelInner<T extends TableData>({ open, }: TableFilterPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export declare const TableFilterPanel: typeof TableFilterPanelInner;
+export {};

package/dist/components/BetterTable/components/TableFloatingFilter.d.ts

@@ -0,0 +1,8 @@
+import { TableData } from '../types';
+/**
+ * Floating filter row rendered inside <thead> — one input per filterable column.
+ * Reads and writes to the same filterValues state as the FilterPanel.
+ */
+declare function TableFloatingFilterInner<T extends TableData>(): import("react/jsx-runtime").JSX.Element | null;
+export declare const TableFloatingFilter: typeof TableFloatingFilterInner;
+export {};

package/dist/components/BetterTable/components/TableRow.d.ts

@@ -2,7 +2,8 @@ import { TableData } from '../types';
 interface TableRowProps<T extends TableData> {
     row: T;
     rowIndex: number;
+    rowKey: string;
 }
-declare function TableRowInner<T extends TableData>({ row, rowIndex }: TableRowProps<T>): import("react/jsx-runtime").JSX.Element;
+declare function TableRowInner<T extends TableData>({ row, rowIndex, rowKey }: TableRowProps<T>): import("react/jsx-runtime").JSX.Element;
 export declare const TableRow: typeof TableRowInner;
 export {};

package/dist/components/BetterTable/components/TableVirtualBody.d.ts

@@ -0,0 +1,10 @@
+import { TableData } from '../types';
+interface TableVirtualBodyProps {
+    startIndex: number;
+    endIndex: number;
+    totalHeight: number;
+    offsetTop: number;
+}
+declare function TableVirtualBodyInner<T extends TableData>({ startIndex, endIndex, totalHeight, offsetTop, }: TableVirtualBodyProps): import("react/jsx-runtime").JSX.Element;
+export declare const TableVirtualBody: typeof TableVirtualBodyInner;
+export {};

package/dist/components/BetterTable/components/index.d.ts

@@ -6,9 +6,15 @@ export { TableCell } from './TableCell';
 export { TableCard } from './TableCard';
 export { TableCards } from './TableCards';
 export { TableActions } from './TableActions';
+export { TableActionOverflow } from './TableActionOverflow';
+export { TableFilterPanel } from './TableFilterPanel';
+export { TableFloatingFilter } from './TableFloatingFilter';
+export { TableColumnVisibility } from './TableColumnVisibility';
 export { TablePagination } from './TablePagination';
 export { TableToolbar } from './TableToolbar';
 export { TableEmpty } from './TableEmpty';
 export { TableLoading, TableLoadingOverlay } from './TableLoading';
 export { TableModal } from './TableModal';
+export { TableVirtualBody } from './TableVirtualBody';
+export { TableExpandedRow } from './TableExpandedRow';
 export { BetterTable, default } from './Table';

package/dist/components/BetterTable/constants.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Virtualization constants
+ *
+ * VIRTUALIZATION_THRESHOLD: Minimum number of rows to auto-enable virtualization
+ * when pagination is disabled. Below this threshold, all rows render normally.
+ * Above it, only visible rows + buffer are rendered for performance.
+ *
+ * To change this value, update it here — it's the single source of truth.
+ */
+export declare const VIRTUALIZATION_THRESHOLD = 500;
+/**
+ * Default fixed row height in pixels for virtualized rendering.
+ * Assumes uniform row height (variable height is not supported yet).
+ */
+export declare const DEFAULT_ROW_HEIGHT = 48;
+/**
+ * Number of extra rows rendered above and below the visible viewport
+ * to prevent flicker during fast scrolling.
+ */
+export declare const DEFAULT_VIRTUAL_BUFFER = 5;

package/dist/components/BetterTable/context/TableContext.d.ts

@@ -1,68 +1,18 @@
 import { ReactNode } from 'react';
-import { TableData, Column, SortState, FilterState, TableLocale, TableClassNames, RowAction, GlobalAction } from '../types';
-export interface TableContextValue<T extends TableData = TableData> {
-    data: T[];
-    processedData: T[];
-    columns: Column<T>[];
-    rowKey: keyof T | ((row: T, index: number) => string);
-    rowActions?: RowAction<T>[];
-    globalActions?: GlobalAction<T>[];
-    sortState: SortState;
-    handleSort: (columnId: string) => void;
-    filters: FilterState;
-    setFilter: (columnId: string, value: string | number | boolean | null) => void;
-    clearFilters: () => void;
-    searchValue: string;
-    handleSearch: (value: string) => void;
-    clearSearch: () => void;
-    searchable: boolean;
-    selectedRows: T[];
-    isSelected: (row: T, index: number) => boolean;
-    toggleRow: (row: T, index: number) => void;
-    selectAll: () => void;
-    deselectAll: () => void;
-    isAllSelected: boolean;
-    isPartiallySelected: boolean;
-    selectedCount: number;
-    selectable: boolean;
-    selectionMode: 'single' | 'multiple';
-    page: number;
-    pageSize: number;
-    totalPages: number;
-    totalItems: number;
-    goToPage: (page: number) => void;
-    nextPage: () => void;
-    prevPage: () => void;
-    changePageSize: (size: number) => void;
-    hasNextPage: boolean;
-    hasPrevPage: boolean;
-    startIndex: number;
-    endIndex: number;
-    paginationEnabled: boolean;
-    pageSizeOptions: number[];
-    showSizeChanger: boolean;
-    loading: boolean;
-    loadingComponent?: ReactNode;
-    emptyComponent?: ReactNode;
-    locale: TableLocale;
-    classNames: TableClassNames;
-    size: 'small' | 'medium' | 'large';
-    bordered: boolean;
-    striped: boolean;
-    hoverable: boolean;
-    stickyHeader: boolean;
-    onRowClick?: (row: T, rowIndex: number) => void;
-    onRowDoubleClick?: (row: T, rowIndex: number) => void;
-    openModal: (content: ReactNode) => void;
-    closeModal: () => void;
-    modalContent: ReactNode | null;
-    isModalOpen: boolean;
-}
-export declare function useTableContext<T extends TableData>(): TableContextValue<T>;
-interface TableProviderProps<T extends TableData> {
-    value: TableContextValue<T>;
+import { TableData } from '../types';
+import { TableDataContextValue } from './TableDataContext';
+import { TableSortContextValue } from './TableSortContext';
+import { TableFilterContextValue } from './TableFilterContext';
+import { TableSelectionContextValue } from './TableSelectionContext';
+import { TablePaginationContextValue } from './TablePaginationContext';
+import { TableUIContextValue } from './TableUIContext';
+export interface TableProviderProps<T extends TableData = TableData> {
+    data: TableDataContextValue<T>;
+    sort: TableSortContextValue;
+    filter: TableFilterContextValue;
+    selection: TableSelectionContextValue<T>;
+    pagination: TablePaginationContextValue;
+    ui: TableUIContextValue<T>;
     children: ReactNode;
 }
-export declare function TableProvider<T extends TableData>({ value, children, }: TableProviderProps<T>): import("react/jsx-runtime").JSX.Element;
-export declare const defaultTableContext: Partial<TableContextValue>;
-export {};
+export declare function TableProvider<T extends TableData>({ data, sort, filter, selection, pagination, ui, children, }: TableProviderProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/components/BetterTable/context/TableDataContext.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { TableData, Column, RowAction, GlobalAction } from '../types';
+export interface TableDataContextValue<T extends TableData = TableData> {
+    data: T[];
+    processedData: T[];
+    columns: Column<T>[];
+    visibleColumns: Column<T>[];
+    rowKey: keyof T | ((row: T, index: number) => string);
+    rowActions?: RowAction<T>[];
+    globalActions?: GlobalAction<T>[];
+    maxVisibleActions: number;
+    expandableRender?: (row: T, rowIndex: number) => ReactNode;
+    isExpanded: (rowKey: string) => boolean;
+    toggleExpand: (rowKey: string) => void;
+    expandableEnabled: boolean;
+}
+export declare function useTableData<T extends TableData>(): TableDataContextValue<T>;
+export declare const TableDataProvider: import('react').Provider<TableDataContextValue<TableData> | null>;

package/dist/components/BetterTable/context/TableFilterContext.d.ts

@@ -0,0 +1,17 @@
+import { FilterState, DateFilterRange } from '../types';
+export interface TableFilterContextValue {
+    filters: FilterState;
+    setFilter: (columnId: string, value: string | number | boolean | DateFilterRange | null) => void;
+    clearFilter: (columnId: string) => void;
+    clearFilters: () => void;
+    searchValue: string;
+    handleSearch: (value: string) => void;
+    clearSearch: () => void;
+    searchable: boolean;
+    filterPanelOpen: boolean;
+    toggleFilterPanel: () => void;
+    hasFilterableColumns: boolean;
+    filterMode: 'floating' | 'panel' | 'both';
+}
+export declare function useTableFilterContext(): TableFilterContextValue;
+export declare const TableFilterProvider: import('react').Provider<TableFilterContextValue | null>;

package/dist/components/BetterTable/context/TablePaginationContext.d.ts

@@ -0,0 +1,19 @@
+export interface TablePaginationContextValue {
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    totalItems: number;
+    goToPage: (page: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    changePageSize: (size: number) => void;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+    startIndex: number;
+    endIndex: number;
+    paginationEnabled: boolean;
+    pageSizeOptions: number[];
+    showSizeChanger: boolean;
+}
+export declare function useTablePaginationContext(): TablePaginationContextValue;
+export declare const TablePaginationProvider: import('react').Provider<TablePaginationContextValue | null>;

package/dist/components/BetterTable/context/TableSelectionContext.d.ts

@@ -0,0 +1,15 @@
+import { TableData } from '../types';
+export interface TableSelectionContextValue<T extends TableData = TableData> {
+    selectedRows: T[];
+    isSelected: (row: T, index: number) => boolean;
+    toggleRow: (row: T, index: number) => void;
+    selectAll: () => void;
+    deselectAll: () => void;
+    isAllSelected: boolean;
+    isPartiallySelected: boolean;
+    selectedCount: number;
+    selectable: boolean;
+    selectionMode: 'single' | 'multiple';
+}
+export declare function useTableSelectionContext<T extends TableData>(): TableSelectionContextValue<T>;
+export declare const TableSelectionProvider: import('react').Provider<TableSelectionContextValue<TableData> | null>;

package/dist/components/BetterTable/context/TableSortContext.d.ts

@@ -0,0 +1,10 @@
+import { SortState, MultiSortState } from '../types';
+export interface TableSortContextValue {
+    sortState: SortState;
+    handleSort: (columnId: string) => void;
+    multiSortState: MultiSortState;
+    isMultiSort: boolean;
+    clearSort: () => void;
+}
+export declare function useTableSortContext(): TableSortContextValue;
+export declare const TableSortProvider: import('react').Provider<TableSortContextValue | null>;

package/dist/components/BetterTable/context/TableUIContext.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode } from 'react';
+import { TableData, TableLocale, TableClassNames, Column } from '../types';
+export interface TableUIContextValue<T extends TableData = TableData> {
+    locale: TableLocale;
+    classNames: TableClassNames;
+    size: 'small' | 'medium' | 'large';
+    bordered: boolean;
+    striped: boolean;
+    hoverable: boolean;
+    stickyHeader: boolean;
+    loading: boolean;
+    loadingComponent?: ReactNode;
+    emptyComponent?: ReactNode;
+    onRowClick?: (row: T, rowIndex: number) => void;
+    onRowDoubleClick?: (row: T, rowIndex: number) => void;
+    openModal: (content: ReactNode) => void;
+    closeModal: () => void;
+    modalContent: ReactNode | null;
+    isModalOpen: boolean;
+    columnVisibilityEnabled: boolean;
+    hiddenColumnIds: Set<string>;
+    toggleColumn: (columnId: string) => void;
+    showAllColumns: () => void;
+    isColumnVisible: (columnId: string) => boolean;
+    columns: Column<T>[];
+    resizable: boolean;
+    columnWidths: Record<string, number>;
+    isResizing: boolean;
+    startResize: (columnId: string, startX: number) => void;
+    getColumnWidth: (columnId: string) => number | undefined;
+}
+export declare function useTableUI<T extends TableData>(): TableUIContextValue<T>;
+export declare const TableUIProvider: import('react').Provider<TableUIContextValue<TableData> | null>;

package/dist/components/BetterTable/context/index.d.ts

@@ -1,2 +1,14 @@
-export { TableProvider, useTableContext, defaultTableContext, } from './TableContext';
-export type { TableContextValue } from './TableContext';
+export { TableProvider } from './TableContext';
+export type { TableProviderProps } from './TableContext';
+export { useTableData } from './TableDataContext';
+export type { TableDataContextValue } from './TableDataContext';
+export { useTableSortContext } from './TableSortContext';
+export type { TableSortContextValue } from './TableSortContext';
+export { useTableFilterContext } from './TableFilterContext';
+export type { TableFilterContextValue } from './TableFilterContext';
+export { useTableSelectionContext } from './TableSelectionContext';
+export type { TableSelectionContextValue } from './TableSelectionContext';
+export { useTablePaginationContext } from './TablePaginationContext';
+export type { TablePaginationContextValue } from './TablePaginationContext';
+export { useTableUI } from './TableUIContext';
+export type { TableUIContextValue } from './TableUIContext';

package/dist/components/BetterTable/hooks/index.d.ts

@@ -3,3 +3,9 @@ export { useTableFilter } from './useTableFilter';
 export { useTablePagination } from './useTablePagination';
 export { useTableSelection } from './useTableSelection';
 export { useTableSearch } from './useTableSearch';
+export { useColumnVisibility } from './useColumnVisibility';
+export { useColumnResize } from './useColumnResize';
+export { useMediaQuery } from './useMediaQuery';
+export { useFocusTrap } from './useFocusTrap';
+export { useVirtualization } from './useVirtualization';
+export { useExpandableRows } from './useExpandableRows';

package/dist/components/BetterTable/hooks/useColumnResize.d.ts

@@ -0,0 +1,23 @@
+import { Column, TableData } from '../types';
+interface UseColumnResizeOptions<T extends TableData> {
+    columns: Column<T>[];
+    enabled: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    onColumnResize?: (columnId: string, width: number) => void;
+    tableRef: React.RefObject<HTMLTableElement | null>;
+}
+interface UseColumnResizeReturn {
+    /** Current column widths (only populated for resized columns) */
+    columnWidths: Record<string, number>;
+    /** Whether a resize is currently in progress */
+    isResizing: boolean;
+    /** Start resizing a column */
+    startResize: (columnId: string, startX: number) => void;
+    /** Get effective width for a column (resized width or initial width) */
+    getColumnWidth: (columnId: string) => number | undefined;
+    /** Reset all column widths to initial */
+    resetColumnWidths: () => void;
+}
+export declare function useColumnResize<T extends TableData>({ columns, enabled, minWidth, maxWidth, onColumnResize, tableRef, }: UseColumnResizeOptions<T>): UseColumnResizeReturn;
+export {};

package/dist/components/BetterTable/hooks/useColumnVisibility.d.ts

@@ -0,0 +1,24 @@
+import { Column, TableData } from '../types';
+interface UseColumnVisibilityOptions<T extends TableData> {
+    columns: Column<T>[];
+    /** Controlled hidden column IDs */
+    controlledHiddenColumns?: string[];
+    /** Callback when visibility changes */
+    onColumnVisibilityChange?: (hiddenColumns: string[]) => void;
+}
+interface UseColumnVisibilityReturn<T extends TableData> {
+    /** Columns filtered by visibility */
+    visibleColumns: Column<T>[];
+    /** Set of hidden column IDs */
+    hiddenColumnIds: Set<string>;
+    /** Toggle a column's visibility */
+    toggleColumn: (columnId: string) => void;
+    /** Show all columns */
+    showAllColumns: () => void;
+    /** Check if a column is visible */
+    isColumnVisible: (columnId: string) => boolean;
+    /** Array of hidden column IDs (for serialization) */
+    hiddenColumns: string[];
+}
+export declare function useColumnVisibility<T extends TableData>({ columns, controlledHiddenColumns, onColumnVisibilityChange, }: UseColumnVisibilityOptions<T>): UseColumnVisibilityReturn<T>;
+export {};

package/dist/components/BetterTable/hooks/useExpandableRows.d.ts

@@ -0,0 +1,19 @@
+export interface UseExpandableRowsOptions {
+    /** Controlled expanded row keys */
+    controlledExpandedRows?: string[];
+    /** Callback when expanded rows change */
+    onExpandChange?: (expandedRows: string[]) => void;
+    /** Only allow one row expanded at a time */
+    accordion?: boolean;
+}
+export interface UseExpandableRowsReturn {
+    /** Set of currently expanded row keys */
+    expandedRowKeys: Set<string>;
+    /** Check if a row is expanded */
+    isExpanded: (rowKey: string) => boolean;
+    /** Toggle a row's expanded state */
+    toggleExpand: (rowKey: string) => void;
+    /** Collapse all rows */
+    collapseAll: () => void;
+}
+export declare function useExpandableRows({ controlledExpandedRows, onExpandChange, accordion, }: UseExpandableRowsOptions): UseExpandableRowsReturn;

package/dist/components/BetterTable/hooks/useFocusTrap.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Traps focus within a container element while active.
+ * On activate: stores previously focused element and focuses first focusable child.
+ * On deactivate: restores focus to the previously focused element.
+ */
+export declare function useFocusTrap(containerRef: React.RefObject<HTMLElement | null>, isActive: boolean): void;

package/dist/components/BetterTable/hooks/useMediaQuery.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hook that tracks a CSS media query match state.
+ * SSR-safe: returns `false` during server rendering and hydrates on mount.
+ *
+ * @param query - CSS media query string, e.g. `'(max-width: 640px)'`
+ * @returns `true` when the viewport matches the query
+ */
+export declare function useMediaQuery(query: string): boolean;

package/dist/components/BetterTable/hooks/useTableFilter.d.ts

@@ -1,17 +1,19 @@
-import { FilterState, TableData, Column } from '../types';
+import { FilterState, TableData, Column, DateFilterRange } from '../types';
 interface UseTableFilterOptions<T extends TableData> {
     data: T[];
     columns: Column<T>[];
     initialFilters?: FilterState;
     controlledFilters?: FilterState;
     onFilterChange?: (filters: FilterState) => void;
+    /** When true, skip client-side filtering — data is returned as-is */
+    manual?: boolean;
 }
 interface UseTableFilterReturn<T extends TableData> {
     filteredData: T[];
     filters: FilterState;
-    setFilter: (columnId: string, value: string | number | boolean | null) => void;
+    setFilter: (columnId: string, value: string | number | boolean | DateFilterRange | null) => void;
     clearFilters: () => void;
     clearFilter: (columnId: string) => void;
 }
-export declare function useTableFilter<T extends TableData>({ data, columns, initialFilters, controlledFilters, onFilterChange, }: UseTableFilterOptions<T>): UseTableFilterReturn<T>;
+export declare function useTableFilter<T extends TableData>({ data, columns, initialFilters, controlledFilters, onFilterChange, manual, }: UseTableFilterOptions<T>): UseTableFilterReturn<T>;
 export {};