react-kd-grid 5.0.2 → 5.0.4

package/dist/grid/components/Shared/GridHeader.d.ts

@@ -0,0 +1,39 @@
+import React from "react";
+import { GridColumn, SortConfig, ActiveFilters, ColumnFilterValue, GridRow } from "../../types";
+interface GridHeaderProps {
+    pinnedColumns: GridColumn[];
+    unpinnedColumns: GridColumn[];
+    hvPadLeft?: number;
+    hvPadRight?: number;
+    headerHeight: number;
+    sortConfig: SortConfig;
+    columnFilters: ActiveFilters;
+    selectable: boolean;
+    selectedRows: Set<string | number>;
+    totalRows: number;
+    data: GridRow[];
+    onSort: (key: string) => void;
+    onColumnFilter: (key: string, filter: ColumnFilterValue | null) => void;
+    onSelectAll: () => void;
+    onColumnResize?: (columnKey: string, width: number) => void;
+    pinnedKeySet?: Set<string>;
+    onColumnPin?: (columnKey: string, pinned: boolean) => void;
+    groupable?: boolean;
+    groupedByColumn?: string | null;
+    onGroupBy?: (columnKey: string | null) => void;
+    groupedByColumns?: string[];
+    onGroupToggle?: (columnKey: string, nextGrouped: boolean) => void;
+    onAutosizeColumn?: (columnKey: string) => void;
+    onAutosizeAllColumns?: () => void;
+    onResetColumns?: () => void;
+    columnOrder: string[];
+    onColumnOrderChange: (order: string[]) => void;
+    paginationMode?: "client" | "server" | null;
+    /** Minimum column width enforced during drag-resize. Defaults to 80px. */
+    minResizeWidth?: number;
+}
+export declare const GridHeader: React.MemoExoticComponent<{
+    ({ pinnedColumns, unpinnedColumns, hvPadLeft, hvPadRight, headerHeight, sortConfig, columnFilters, selectable, selectedRows, totalRows, data, onSort, onColumnFilter, onSelectAll, onColumnResize, pinnedKeySet, onColumnPin, groupable, groupedByColumn, onGroupBy, groupedByColumns, onGroupToggle, onAutosizeColumn, onAutosizeAllColumns, onResetColumns, columnOrder, onColumnOrderChange, paginationMode, minResizeWidth, }: GridHeaderProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}>;
+export {};

package/dist/grid/components/Shared/GridRows.d.ts

@@ -0,0 +1,53 @@
+import { CSSProperties, MouseEvent } from "react";
+import { GridRow, GridColumn, VirtualizedRange, ContextMenuItem, RowEventParams, CellClickParams, CellContextMenuParams } from "../../types";
+interface GridRowsProps {
+    data: GridRow[];
+    columns: GridColumn[];
+    selectedRows: Set<string | number>;
+    virtualized: boolean;
+    virtualizedRange: VirtualizedRange;
+    rowHeight: number;
+    selectable: boolean;
+    isRowSelectable?: (row: GridRow) => boolean;
+    onRowSelect: (rowId: string | number, isSelected: boolean) => void;
+    pinnedColumns?: Set<string>;
+    hvPadLeft?: number;
+    hvPadRight?: number;
+    rowStyle?: (row: GridRow) => CSSProperties | undefined;
+    globalFilter?: string;
+    onContextMenu?: (params: RowEventParams) => void;
+    onRowDoubleClick?: (params: RowEventParams) => void;
+    onRowClick?: (params: RowEventParams) => void;
+    onCellClick?: (params: CellClickParams) => void;
+    isCellFocused?: (rowId: string | number, columnKey: string) => boolean;
+    isCellSelected?: (rowId: string | number, columnKey: string) => boolean;
+    onCellContextMenu?: (params: CellContextMenuParams) => void;
+    onCellMouseDown?: (args: {
+        row: GridRow;
+        column: GridColumn;
+        event: MouseEvent;
+    }) => void;
+    onCellMouseEnter?: (args: {
+        row: GridRow;
+        column: GridColumn;
+        event: MouseEvent;
+    }) => void;
+    /** Custom items for the row right-click context menu. */
+    contextMenuItems?: ContextMenuItem[];
+    getRowId?: (row: GridRow) => string | number;
+    /** Returns true when a specific (rowId, columnKey) pair is currently being edited. */
+    isEditing?: (rowId: string | number, columnKey: string) => boolean;
+    /** Called when the user double-clicks (or presses F2 on) an editable cell. */
+    onStartEdit?: (row: GridRow, column: GridColumn) => void;
+    /** Called by CellEditor when the user commits a value. */
+    onCommitEdit?: (newValue: any) => void;
+    /** Called by CellEditor when the user cancels without saving. */
+    onCancelEdit?: () => void;
+    /** The current edit initial value — passed down to CellEditor to initialise draft state. */
+    editingInitialValue?: any;
+}
+export declare const GridRows: import("react").MemoExoticComponent<{
+    ({ data, columns, selectedRows, virtualized, virtualizedRange, rowHeight, selectable, isRowSelectable, onRowSelect, pinnedColumns, hvPadLeft, hvPadRight, rowStyle, globalFilter, onContextMenu, onRowDoubleClick, onRowClick, onCellClick, isCellFocused, isCellSelected, onCellContextMenu, onCellMouseDown, onCellMouseEnter, contextMenuItems, getRowId, isEditing, onStartEdit, onCommitEdit, onCancelEdit, editingInitialValue, }: GridRowsProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}>;
+export {};

package/dist/grid/components/Shared/GroupBar.d.ts

@@ -0,0 +1,12 @@
+import type { GridColumn } from "../../types";
+interface GroupBarProps {
+    columns: GridColumn[];
+    groupedKeys: string[];
+    onRemove: (columnKey: string) => void;
+    onReorder: (newOrder: string[]) => void;
+    onDropColumnKey: (columnKey: string) => void;
+    onToggleExpandAll?: () => void;
+    isAnyExpanded?: boolean;
+}
+export declare const GroupBar: ({ columns, groupedKeys, onRemove, onReorder, onDropColumnKey, onToggleExpandAll, isAnyExpanded, }: GroupBarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/grid/components/Shared/GroupHeader.d.ts

@@ -0,0 +1,29 @@
+import { GridRow, KDGridProps } from "../../types";
+interface GroupHeaderProps {
+    row: GridRow & {
+        _isGroupHeader?: boolean;
+        _groupKey?: string;
+        _groupCount?: number;
+    };
+    isExpanded: boolean;
+    onToggle: (groupKey: string) => void;
+    viewportWidth: number;
+    selectable: boolean;
+    rowHeight?: number;
+    /**
+     * Optional function to map a column key to its display label (header).
+     * If not provided, the raw column key will be used as a fallback.
+     */
+    getHeaderLabel?: (columnKey: string) => string;
+    /**
+     * Optional function to map a column key and raw group value to a display label.
+     * Useful to apply the column's formatter for group headers.
+     */
+    getValueLabel?: (columnKey: string, rawValue: any) => string;
+    /**
+     * Optional custom renderer for actions on grouped rows.
+     */
+    renderGroupActions?: KDGridProps["renderGroupActions"];
+}
+export declare const GroupHeader: import("react").MemoExoticComponent<({ row, isExpanded, onToggle, viewportWidth, selectable, rowHeight, getHeaderLabel, getValueLabel, renderGroupActions, }: GroupHeaderProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/grid/components/Shared/LicenseError.d.ts

@@ -0,0 +1,9 @@
+/**
+ * LicenseError
+ *
+ * Shown inside the grid body when an invalid or missing `licenseKey` is
+ * detected. Rendering it in the body (rather than replacing the entire
+ * component) keeps the column header visible so consumers can still see
+ * the grid structure and understand what data *should* be there.
+ */
+export declare const LicenseError: () => import("react/jsx-runtime").JSX.Element;

package/dist/grid/components/Shared/NoDataMessage.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from "react";
+interface NoDataMessageProps {
+    hasFilters?: boolean;
+    hasData?: boolean;
+    /** Custom text message. Overridden by `renderer` if both are set. */
+    message?: string;
+    /** Fully custom empty-state renderer — takes precedence over `message`. */
+    renderer?: () => ReactNode;
+}
+export declare const NoDataMessage: ({ hasFilters, hasData, message, renderer, }: NoDataMessageProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/grid/components/Shared/PaginationControls.d.ts

@@ -0,0 +1,18 @@
+import { PaginationConfig } from "../../types";
+interface PaginationControlsProps {
+    paginationConfig: PaginationConfig;
+    currentPage: number;
+    isServerLoading: boolean;
+    selectedRowsCount: number;
+    totalDataLength: number;
+    filteredDataLength?: number;
+    paginationMode?: "client" | "server";
+    onPageChange: (page: number, pageSize: number) => void;
+    onPageSizeChange: (pageSize: number) => void;
+    showNoDataMessage?: boolean;
+}
+export declare const PaginationControls: import("react").MemoExoticComponent<{
+    ({ paginationConfig, currentPage, isServerLoading, selectedRowsCount, totalDataLength, filteredDataLength, paginationMode, onPageChange, onPageSizeChange, }: PaginationControlsProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}>;
+export {};

package/dist/grid/components/Shared/RowContextMenu.d.ts

@@ -0,0 +1,18 @@
+import { GridRow, ContextMenuItem } from "../../types";
+/** Ready-made starter items — ONLY for development / demos.
+ *  All items are no-ops in dev environments (they log in DEV only).
+ *  Do NOT rely on these in production; wire your own `contextMenuItems`. */
+export declare const defaultContextMenuItems: ContextMenuItem[];
+interface RowContextMenuProps {
+    row: GridRow;
+    position: {
+        x: number;
+        y: number;
+    };
+    isVisible: boolean;
+    onClose: () => void;
+    /** Custom menu items. If not provided the menu will not render. */
+    menuItems?: ContextMenuItem[];
+}
+export declare const RowContextMenu: ({ row, position, isVisible, onClose, menuItems, }: RowContextMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/grid/components/Toolbar/Toolbar.d.ts

@@ -0,0 +1,70 @@
+import { ChangeEvent, ReactNode } from "react";
+import type { BulkActionOption, Density, ExportFormat, SavedFilter } from "../../types";
+interface ColumnVisibility {
+    [columnKey: string]: boolean;
+}
+interface SearchToolbarProps {
+    globalFilter: string;
+    filteredDataLength: number;
+    totalDataLength: number;
+    paginationMode?: "client" | "server";
+    totalRows?: number;
+    selectedRowsCount?: number;
+    selectedRows?: Set<string | number>;
+    showExport?: boolean;
+    showRefresh?: boolean;
+    showColumnToggle?: boolean;
+    showBulkActions?: boolean;
+    showSavedFilters?: boolean;
+    columns?: Array<{
+        key: string;
+        header: string;
+        visible?: boolean;
+        filterOptions?: Array<{
+            label: string;
+            value: string | number;
+        }>;
+        filterType?: "text" | "select" | "multiselect";
+        filterable?: any;
+    }>;
+    columnVisibility?: ColumnVisibility;
+    columnFilters?: Record<string, any>;
+    savedFilters?: SavedFilter[];
+    bulkActions?: BulkActionOption[];
+    loading?: boolean;
+    exportOptions?: {
+        enabled: boolean;
+        formats?: ExportFormat[];
+        filename?: string;
+        onExport?: (format: ExportFormat, exportSelected: boolean) => void;
+    };
+    onGlobalFilterChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    onClearFilters?: () => void;
+    onRefresh?: () => void;
+    onColumnVisibilityChange?: (columnKey: string, visible: boolean) => void;
+    onColumnFilter?: (columnKey: string, filter: any) => void;
+    onSaveFilter?: (filter: Omit<SavedFilter, "id">) => void;
+    onLoadFilter?: (filter: SavedFilter) => void;
+    onDeleteFilter?: (filterId: string) => void;
+    onRowSelect?: (selectedRows: number[]) => void;
+    onToggleFilters?: (show: boolean) => void;
+    onResetColumns?: () => void;
+    columnOrder?: string[];
+    onColumnOrderChange?: (order: string[]) => void;
+    pinnedColumns?: Set<string>;
+    onScrollToColumn?: (columnKey: string) => void;
+    density?: Density;
+    onDensityChange?: (density: Density) => void;
+    showDensityControl?: boolean;
+    customLeftContent?: ReactNode;
+    customRightContent?: ReactNode;
+}
+/**
+ * Optimized SearchToolbar using React.memo to prevent unnecessary re-renders
+ * as users type in the global search or modify filters.
+ */
+export declare const Toolbar: import("react").MemoExoticComponent<{
+    ({ globalFilter, filteredDataLength, totalDataLength, selectedRowsCount, selectedRows, showExport, showColumnToggle, showBulkActions, columns, columnVisibility, columnFilters, bulkActions, exportOptions, onGlobalFilterChange, onClearFilters, onColumnVisibilityChange, onColumnFilter, onResetColumns, columnOrder, onColumnOrderChange, pinnedColumns, onScrollToColumn, density, onDensityChange, showDensityControl, customLeftContent, customRightContent, }: SearchToolbarProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}>;
+export {};

package/dist/grid/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const SELECT_COL_WIDTH = 48;

package/dist/grid/constants/toolbar.d.ts

@@ -0,0 +1,17 @@
+import { ExportFormat, Density } from "../types";
+/**
+ * Mappings for Export formats to their respective icons.
+ */
+export declare const getExportIcon: (format: ExportFormat) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Mappings for Bulk Action IDs to their respective icons.
+ */
+export declare const getBulkActionIcon: (action: string) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Human-readable labels for export formats.
+ */
+export declare const getFormatLabel: (format: ExportFormat) => "CSV" | "JSON" | "Excel";
+/**
+ * Default density options for the grid.
+ */
+export declare const DENSITY_OPTIONS: Density[];

package/dist/grid/core/DataGrid.d.ts

@@ -0,0 +1,3 @@
+import type { KDGridProps, KDGridRef } from "../types";
+export declare const KDGrid: import("react").ForwardRefExoticComponent<KDGridProps & import("react").RefAttributes<KDGridRef>>;
+export default KDGrid;

package/dist/grid/core/GridBodyContainer.d.ts

@@ -0,0 +1,83 @@
+import React, { RefObject } from "react";
+import type { GridColumn, GridRow, SortConfig, ColumnFilterValue } from "../types";
+interface GridBodyContainerProps {
+    scrollRef: RefObject<HTMLDivElement>;
+    flatRows: any[];
+    columnsWithWidths: any[];
+    visibleColumns: any[];
+    totalWidth: number;
+    selectable: boolean;
+    dataToDisplay: any[];
+    pinnedAll: any[];
+    effectivePinnedColumns: Set<string>;
+    hvPadLeftMemo: number;
+    hvPadRightMemo: number;
+    resolvedHeaderHeight: number;
+    sortConfig: SortConfig;
+    columnFilters: Record<string, ColumnFilterValue | null>;
+    selectedRows: Set<string | number>;
+    data: any[];
+    handleSort: (key: string) => void;
+    setColumnFilter: (key: string, filter: ColumnFilterValue | null) => void;
+    handleSelectAll: (checked: boolean) => void;
+    handleColumnResize: (columnKey: string, width: number) => void;
+    handleColumnPin: (columnKey: string, pinned: boolean) => void;
+    addGroupKey: (key: string) => void;
+    removeGroupKey: (key: string) => void;
+    handleGroupBy: (columnKey: string) => void;
+    autosizeColumn: (columnKey: string) => void;
+    autosizeAllColumns: () => void;
+    resetColumns: () => void;
+    columnOrder: string[];
+    setColumnOrder: React.Dispatch<React.SetStateAction<string[]>>;
+    pagination: any;
+    minResizeWidth?: number;
+    effectiveVirtualized: boolean;
+    virtualizedRange: {
+        offsetY: number;
+        startIndex: number;
+        endIndex: number;
+    };
+    resolvedRowHeight: number;
+    visibleData: any[];
+    isRowSelectable?: (row: GridRow) => boolean;
+    handleRowSelect: (rowId: string | number, isSelected: boolean) => void;
+    rowStyle?: any;
+    globalFilter: string;
+    onContextMenu?: any;
+    onRowDoubleClick?: any;
+    onRowClick?: any;
+    onCellClick?: any;
+    onCellContextMenu?: any;
+    isCellFocused: (rowId: string | number, columnKey: string) => boolean;
+    isCellSelected: (rowId: string | number, columnKey: string) => boolean;
+    handleCellMouseDown: any;
+    handleCellMouseEnter: any;
+    contextMenuItems?: any;
+    getRowId?: any;
+    isEditing: (rowId: string | number, columnKey: string) => boolean;
+    startEdit: any;
+    commitEdit: any;
+    cancelEdit: any;
+    editingCell: any;
+    safeGetRowId: (r: any) => string | number;
+    toggleGroupExpansion: (groupKey: string) => void;
+    containerWidth: number;
+    groupConfig: any;
+    columns: GridColumn[];
+    renderGroupActions?: any;
+    groupFooterVariant: "chips" | "columns";
+    isValidLicense: boolean;
+    infiniteScroll: any;
+    sentinelRef: RefObject<HTMLDivElement>;
+    loading: boolean;
+    showLoader: boolean;
+    finishingLoader: boolean;
+    loaderTop: number;
+    noDataMessage?: string;
+    noDataRenderer?: any;
+    handleScroll: (e: React.UIEvent<HTMLDivElement>) => void;
+    cellSelectionEnabled: boolean;
+}
+export declare const GridBodyContainer: React.FC<GridBodyContainerProps>;
+export {};

package/dist/grid/core/GridFooterContainer.d.ts

@@ -0,0 +1,23 @@
+import React, { RefObject } from "react";
+interface GridFooterContainerProps {
+    hasFooterAggregate: boolean;
+    footerScrollRef: RefObject<HTMLDivElement>;
+    forwardWheelToBody: (e: React.WheelEvent) => void;
+    totalWidth: number;
+    selectable: boolean;
+    resolvedRowHeight: number;
+    columnsWithWidths: any[];
+    flatRows: any[];
+    effectivePinnedColumns: Set<string>;
+    infiniteScroll: any;
+    paginationConfig: any;
+    isServerLoading: boolean;
+    selectedRowsCount: number;
+    data: any[];
+    filteredData: any[];
+    pagination: any;
+    handlePageChange: (page: number) => void;
+    handlePageSizeChange: (pageSize: number) => void;
+}
+export declare const GridFooterContainer: React.FC<GridFooterContainerProps>;
+export {};

package/dist/grid/core/GridToolbarContainer.d.ts

@@ -0,0 +1,48 @@
+import React, { ChangeEvent } from "react";
+import type { GridColumn, ColumnFilterValue, Density } from "../types";
+interface GridToolbarContainerProps {
+    showToolbar: boolean;
+    filterable: boolean;
+    globalFilter: string;
+    filteredDataLength: number;
+    totalDataLength: number;
+    paginationMode?: "client" | "server";
+    selectedRowsCount: number;
+    showExport: boolean;
+    columns: GridColumn[];
+    columnFilters: Record<string, ColumnFilterValue | null>;
+    columnVisibility: Record<string, boolean>;
+    onResetColumns: () => void;
+    exportOptions: {
+        enabled: boolean;
+        formats: any[];
+        filename: string;
+        onExport: (format: any, exportSelected: boolean) => void;
+    };
+    toolbarLeft?: React.ReactNode;
+    toolbarRight?: React.ReactNode;
+    onGlobalFilterChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    onClearFilters: () => void;
+    onColumnFilter: (columnKey: string, filter: ColumnFilterValue | null) => void;
+    onColumnVisibilityChange: (columnKey: string, visible: boolean) => void;
+    columnOrder: string[];
+    onColumnOrderChange: (order: string[]) => void;
+    pinnedColumns: Set<string>;
+    onScrollToColumn: (columnKey: string) => void;
+    density: Density;
+    onDensityChange: (density: Density) => void;
+    showDensityControl: boolean;
+    groupable: boolean;
+    groupBarVisibility: "auto" | "visible" | "hidden";
+    groupConfig: {
+        columnKeys: string[];
+        expanded: Set<string>;
+    };
+    removeGroupKey: (key: string) => void;
+    setGroupKeys: (keys: string[]) => void;
+    addGroupKey: (key: string) => void;
+    collapseAllGroups: () => void;
+    expandAllGroups: () => void;
+}
+export declare const GridToolbarContainer: React.FC<GridToolbarContainerProps>;
+export {};

package/dist/grid/hooks/toolbar/useColumnDnD.d.ts

@@ -0,0 +1,28 @@
+interface Column {
+    key: string;
+    header: string;
+}
+interface UseColumnDnDProps {
+    columns: Column[];
+    columnOrder: string[];
+    pinnedColumns?: Set<string>;
+    onColumnOrderChange?: (order: string[]) => void;
+}
+/**
+ * useColumnDnD
+ *
+ * Encapsulates the drag-and-drop logic for reordering columns within the toolbar menu.
+ * Previously, this logic was mixed with the rendering and menu state in SearchToolbar.tsx.
+ */
+export declare function useColumnDnD({ columns, columnOrder, pinnedColumns, onColumnOrderChange, }: UseColumnDnDProps): {
+    draggingKey: string;
+    dragOver: {
+        key: string;
+        position: "before" | "after";
+    };
+    handleDragStart: (columnKey: string, e: React.DragEvent) => void;
+    handleDragOver: (targetKey: string, e: React.DragEvent) => void;
+    handleDrop: (targetKey: string) => void;
+    handleDragEnd: () => void;
+};
+export {};

package/dist/grid/hooks/toolbar/useToolbarMenus.d.ts

@@ -0,0 +1,29 @@
+/**
+ * useToolbarMenus
+ *
+ * Manages the visibility of various popover menus in the grid toolbar.
+ * Includes logic to close menus when clicking outside and handle specific cases like MUI DatePickers.
+ */
+export declare function useToolbarMenus(): {
+    showExportMenu: boolean;
+    setShowExportMenu: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    showFilters: boolean;
+    setShowFilters: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    showBulkActionsMenu: boolean;
+    setShowBulkActionsMenu: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    showColumnMenu: boolean;
+    setShowColumnMenu: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    showSettingsMenu: boolean;
+    setShowSettingsMenu: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    exportMenuRef: import("react").MutableRefObject<HTMLDivElement>;
+    bulkActionsRef: import("react").MutableRefObject<HTMLDivElement>;
+    columnMenuRef: import("react").MutableRefObject<HTMLDivElement>;
+    filtersMenuRef: import("react").MutableRefObject<HTMLDivElement>;
+    settingsMenuRef: import("react").MutableRefObject<HTMLDivElement>;
+    exportAnchorRef: import("react").MutableRefObject<HTMLButtonElement>;
+    bulkActionsAnchorRef: import("react").MutableRefObject<HTMLButtonElement>;
+    columnAnchorRef: import("react").MutableRefObject<HTMLButtonElement>;
+    filtersAnchorRef: import("react").MutableRefObject<HTMLButtonElement>;
+    settingsAnchorRef: import("react").MutableRefObject<HTMLButtonElement>;
+    closeAllMenus: () => void;
+};

package/dist/grid/hooks/useAdvancedFiltering.d.ts

@@ -0,0 +1,18 @@
+import { GridRow, GridColumn, ActiveFilters, ColumnFilterValue } from "../types";
+interface UseAdvancedFilteringProps {
+    data: GridRow[];
+    columns: GridColumn[];
+}
+export declare const useAdvancedFiltering: ({ data, columns, }: UseAdvancedFilteringProps) => {
+    globalFilter: string;
+    setGlobalFilter: (value: string) => void;
+    columnFilters: ActiveFilters;
+    filteredData: GridRow[];
+    setColumnFilter: (columnKey: string, filter: ColumnFilterValue | null) => void;
+    clearColumnFilter: (columnKey: string) => void;
+    clearAllFilters: () => void;
+    getActiveFilterCount: () => number;
+    /** True while a filter transition is in-flight — use to show a loading indicator */
+    isFilterPending: boolean;
+};
+export {};

package/dist/grid/hooks/useCellSelection.d.ts

@@ -0,0 +1,67 @@
+import { RefObject } from "react";
+import type { CellFocusParams, CellSelectionPayload, CopyCellsPayload } from "../types";
+interface CellCoord {
+    rowIndex: number;
+    colIndex: number;
+}
+interface FocusedCell {
+    rowId: string | number;
+    columnKey: string;
+}
+interface DragOverlay {
+    x: number;
+    y: number;
+    rows: number;
+    cols: number;
+}
+interface UseCellSelectionProps {
+    cellFocusEnabled: boolean;
+    cellSelectionEnabled: boolean;
+    canSelectCell: (row: any, column: any) => boolean;
+    flatRows: any[];
+    columnsWithWidths: any[];
+    rowIndexById: Map<string | number, number>;
+    colIndexByKey: Map<string, number>;
+    rowById: Map<string | number, any>;
+    colByKey: Map<string, any>;
+    scrollRef: RefObject<HTMLDivElement>;
+    headerScrollRef: RefObject<HTMLDivElement>;
+    resolvedRowHeight: number;
+    selectable: boolean;
+    onCellFocusChange?: (params: CellFocusParams) => void;
+    onCellSelectionChange?: (payload: CellSelectionPayload) => void;
+    onCopyCells?: (payload: CopyCellsPayload) => void;
+    /** Stable column keys used to avoid dep on full column objects in effects */
+    columnKeys: string[];
+    /** Mirrors the grid-level getRowId — needed so focus/selection uses the correct key. */
+    getRowId?: (row: any) => string | number;
+}
+export interface UseCellSelectionReturn {
+    focusedCell: FocusedCell | null;
+    selectionAnchor: CellCoord | null;
+    selectionEnd: CellCoord | null;
+    dragOverlay: DragOverlay | null;
+    isCellSelected: (rowId: string | number, columnKey: string) => boolean;
+    isCellFocused: (rowId: string | number, columnKey: string) => boolean;
+    handleCellMouseDown: (params: {
+        row: any;
+        column: any;
+        event: any;
+    }) => void;
+    handleCellMouseEnter: (params: {
+        row: any;
+        column: any;
+        event: any;
+    }) => void;
+}
+/**
+ * Owns the entire cell focus + rectangular selection subsystem:
+ * - State: focusedCell, selectionAnchor, selectionEnd, dragOverlay
+ * - Mouse handlers: handleCellMouseDown, handleCellMouseEnter
+ * - Global effects: mouseup, mousemove, Shift+Arrow, keyboard focus nav
+ * - Auto-scroll RAF loop while dragging near scroll container edges
+ * - Ctrl/Cmd+C copy handler (Excel-compatible TSV output)
+ * - onCellSelectionChange callback (de-duped via signature ref)
+ */
+export declare const useCellSelection: ({ cellFocusEnabled, cellSelectionEnabled, canSelectCell, flatRows, columnsWithWidths, rowIndexById, colIndexByKey, rowById, colByKey, scrollRef, headerScrollRef, resolvedRowHeight, selectable, onCellFocusChange, onCellSelectionChange, onCopyCells, columnKeys, getRowId, }: UseCellSelectionProps) => UseCellSelectionReturn;
+export {};

package/dist/grid/hooks/useColumnState.d.ts

@@ -0,0 +1,52 @@
+import React from "react";
+import type { GridColumn, GridRow, ColumnConfig, ColumnFilterValue, Density, SortConfig } from "../types";
+interface UseColumnStateProps {
+    columns: GridColumn[];
+    data: GridRow[];
+    initialColumnConfig?: Partial<ColumnConfig>;
+    onColumnConfigChange?: (config: ColumnConfig) => void;
+    setSortConfig: (config: SortConfig) => void;
+    setGroupKeys: (keys: string[]) => void;
+    setDensity: (density: Density) => void;
+    setGlobalFilter: (value: string) => void;
+    setColumnFilter: (key: string, filter: ColumnFilterValue) => void;
+    sortConfig: SortConfig;
+    groupConfig: {
+        columnKeys: string[];
+    };
+    globalFilter: string;
+    columnFilters: Record<string, ColumnFilterValue | null>;
+    density: Density;
+    containerWidth: number;
+    selectable: boolean;
+}
+export interface UseColumnStateReturn {
+    columnWidths: Record<string, number>;
+    columnOrder: string[];
+    pinnedColumns: Set<string>;
+    columnVisibility: Record<string, boolean>;
+    columnsWithWidths: any[];
+    pinnedAll: any[];
+    unpinnedAll: any[];
+    effectivePinnedColumns: Set<string>;
+    handleColumnResize: (columnKey: string, width: number) => void;
+    handleColumnPin: (columnKey: string, pinned: boolean) => void;
+    handleColumnVisibilityChange: (columnKey: string, visible: boolean) => void;
+    setColumnOrder: React.Dispatch<React.SetStateAction<string[]>>;
+    autosizeColumn: (columnKey: string) => void;
+    autosizeAllColumns: () => void;
+    resetColumns: () => void;
+    setColumnWidths: React.Dispatch<React.SetStateAction<Record<string, number>>>;
+    setPinnedColumns: React.Dispatch<React.SetStateAction<Set<string>>>;
+    setColumnVisibility: React.Dispatch<React.SetStateAction<Record<string, boolean>>>;
+}
+/**
+ * Owns all column configuration state:
+ * - Column widths, order, pinning, visibility
+ * - Autosize (canvas-based measureText, with heuristic fallback)
+ * - Column config hydration from `initialColumnConfig` on mount
+ * - Debounced `onColumnConfigChange` emission
+ * - Calculation of resolved columnsWithWidths including flex-grow
+ */
+export declare const useColumnState: ({ columns, data, initialColumnConfig, onColumnConfigChange, setSortConfig, setGroupKeys, setDensity, setGlobalFilter, setColumnFilter, sortConfig, groupConfig, globalFilter, columnFilters, density, containerWidth, selectable, }: UseColumnStateProps) => UseColumnStateReturn;
+export {};

package/dist/grid/hooks/useDataWorker.d.ts

@@ -0,0 +1,11 @@
+type SortCfg = {
+    key: string;
+    direction: "asc" | "desc";
+} | null;
+/** Lazily-created worker singleton per hook instance. */
+export declare function useDataWorker(options?: {
+    enabled?: boolean;
+}): {
+    process: (rows: any[], sort: SortCfg) => Promise<any[]>;
+};
+export {};