react-kd-grid 5.0.3 → 5.0.8

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 {};

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

@@ -0,0 +1,49 @@
+/**
+ * useEditingCell
+ *
+ * Owns the lifecycle of an inline cell edit session:
+ *   - Which cell is currently being edited (rowId + columnKey)
+ *   - Starting an edit (triggered by double-click or F2)
+ *   - Committing the edit and firing onCellEdit
+ *   - Cancelling the edit
+ *   - Keyboard F2 to open edit when a cell is focused (delegates from useCellSelection)
+ *
+ * Design: state is intentionally kept minimal. The *draft value* is owned by
+ * <CellEditor> because it needs to stay strictly local to the input DOM. This
+ * hook only needs to know *which* cell is open so GridRows can render the editor.
+ */
+import type { GridColumn, GridRow, CellEditParams } from "../types";
+export interface EditingCell {
+    rowId: string | number;
+    columnKey: string;
+    /** Snapshot of the value at the moment editing started. */
+    initialValue: any;
+    row: GridRow;
+    column: GridColumn;
+}
+interface UseEditingCellProps {
+    getRowId: (row: GridRow) => string | number;
+    onCellEdit?: (params: CellEditParams) => void;
+    onCellEditStart?: (params: {
+        row: GridRow;
+        column: GridColumn;
+        value: any;
+    }) => boolean | void;
+    /** Currently focused cell (from useCellSelection) — used for F2 shortcut. */
+    focusedCell?: {
+        rowId: string | number;
+        columnKey: string;
+    } | null;
+    /** Full row-and-column lookup helpers for F2 shortcut. */
+    getRowById?: (rowId: string | number) => GridRow | undefined;
+    getColumnByKey?: (key: string) => GridColumn | undefined;
+}
+export interface UseEditingCellReturn {
+    editingCell: EditingCell | null;
+    startEdit: (row: GridRow, column: GridColumn) => void;
+    commitEdit: (newValue: any) => void;
+    cancelEdit: () => void;
+    isEditing: (rowId: string | number, columnKey: string) => boolean;
+}
+export declare const useEditingCell: ({ getRowId, onCellEdit, onCellEditStart, focusedCell, getRowById, getColumnByKey, }: UseEditingCellProps) => UseEditingCellReturn;
+export {};

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

@@ -0,0 +1,14 @@
+import { GridRow, GridColumn, ExportFormat } from "../types";
+interface UseExportProps {
+    data: GridRow[];
+    columns: GridColumn[];
+    selectedRows?: Set<string | number>;
+    filename?: string;
+    columnVisibility?: Record<string, boolean>;
+}
+export declare const useExport: ({ data, columns, selectedRows, filename, columnVisibility, }: UseExportProps) => {
+    exportData: (format: ExportFormat, exportSelected?: boolean) => void;
+    canExportSelected: boolean;
+    selectedCount: number;
+};
+export {};

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

@@ -0,0 +1,17 @@
+import { GridRow } from "../types";
+interface UseGridDataMapsProps {
+    dataToDisplay: any[];
+    columnsWithWidths: any[];
+    getRowId?: (row: GridRow) => string | number;
+}
+export declare const useGridDataMaps: ({ dataToDisplay, columnsWithWidths, getRowId, }: UseGridDataMapsProps) => {
+    colIndexByKey: Map<string, number>;
+    colByKey: Map<string, any>;
+    flatRows: any[];
+    rowIndexById: Map<string | number, number>;
+    rowById: Map<string | number, any>;
+    totalWidth: any;
+    columnKeys: any[];
+    hasFooterAggregate: boolean;
+};
+export {};

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

@@ -0,0 +1,20 @@
+import { RefObject } from "react";
+interface UseGridMethodsProps {
+    scrollRef: RefObject<HTMLDivElement>;
+    rowIndexById: Map<string | number, number>;
+    colIndexByKey: Map<string, number>;
+    columnsWithWidths: any[];
+    resolvedRowHeight: number;
+    selectable: boolean;
+}
+/**
+ * useGridMethods
+ *
+ * Centralizes imperative grid operations like scrolling to specific rows or columns.
+ * This logic was previously duplicated in DataGrid.tsx and its sub-components.
+ */
+export declare function useGridMethods({ scrollRef, rowIndexById, colIndexByKey, columnsWithWidths, resolvedRowHeight, selectable, }: UseGridMethodsProps): {
+    scrollToRow: (rowId: string | number) => void;
+    scrollToColumn: (columnKey: string) => void;
+};
+export {};

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

@@ -0,0 +1,28 @@
+import { GridRow, GroupConfig, GridColumn } from "../types";
+interface UseGroupingProps {
+    data: GridRow[];
+    columns: GridColumn[];
+}
+export declare const useGrouping: ({ data, columns }: UseGroupingProps) => {
+    groupConfig: GroupConfig;
+    displayData: (GridRow & {
+        _isGroupHeader?: boolean;
+        _groupKey?: string;
+        _groupCount?: number;
+        _groupLevel?: number;
+        _groupColumnKey?: string;
+        _groupValue?: string;
+        _groupRows?: GridRow[];
+        _isGroupFooter?: boolean;
+        _groupAgg?: Record<string, any>;
+    })[];
+    handleGroupBy: (columnKey: string | null) => void;
+    addGroupKey: (columnKey: string) => void;
+    removeGroupKey: (columnKey: string) => void;
+    setGroupKeys: (columnKeys: string[]) => void;
+    toggleGroupExpansion: (groupPath: string) => void;
+    expandAllGroups: () => void;
+    collapseAllGroups: () => void;
+    isGrouped: boolean;
+};
+export {};

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

@@ -0,0 +1,18 @@
+interface UseHorizontalVirtualizationProps {
+    columnsWithWidths: any[];
+    pinnedAll: any[];
+    unpinnedAll: any[];
+    effectivePinnedColumns: Set<string>;
+    hScrollLeft: number;
+    viewportWidth: number;
+    selectable: boolean;
+    enableHorizontalVirtualization: boolean;
+    horizontalVirtualizationThreshold: number;
+}
+export declare const useHorizontalVirtualization: ({ columnsWithWidths, pinnedAll, unpinnedAll, effectivePinnedColumns, hScrollLeft, viewportWidth, selectable, enableHorizontalVirtualization, horizontalVirtualizationThreshold, }: UseHorizontalVirtualizationProps) => {
+    needsHorizontalVirtualization: boolean;
+    visibleColumns: any[];
+    hvPadLeftMemo: number;
+    hvPadRightMemo: number;
+};
+export {};

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

@@ -0,0 +1,31 @@
+export interface UseInfiniteScrollOptions {
+    /** When false, the observer is disconnected entirely. */
+    enabled: boolean;
+    /** Whether there are more rows to load. */
+    hasMore: boolean;
+    /** True while a fetch is in flight – prevents double-triggering. */
+    isLoading: boolean;
+    /** Called when the sentinel enters the viewport. */
+    onLoadMore: () => void;
+    /**
+     * Pixels of extra root margin below the scroll viewport.
+     * A positive value means `onLoadMore` fires before the sentinel is
+     * fully visible (pre-fetch). Default: 200 px.
+     */
+    threshold?: number;
+    /**
+     * The scrollable element that clips the sentinel.
+     * If not provided, defaults to the browser viewport.
+     */
+    rootRef?: React.RefObject<Element | null>;
+}
+/**
+ * Attaches an IntersectionObserver to a sentinel <div> placed at the
+ * bottom of the scrollable area. When the sentinel enters the viewport
+ * (plus the optional threshold), onLoadMore is called.
+ *
+ * @returns `sentinelRef` – attach this to a div at the bottom of the list.
+ */
+export declare function useInfiniteScroll({ enabled, onLoadMore, threshold, rootRef, }: UseInfiniteScrollOptions): {
+    sentinelRef: import("react").MutableRefObject<HTMLDivElement>;
+};

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

@@ -0,0 +1,21 @@
+import { RefObject } from "react";
+interface UseLoadingBarProps {
+    loading: boolean;
+    isServerLoading: boolean;
+    resolvedHeaderHeight: number;
+    scrollRef: RefObject<HTMLDivElement>;
+    containerRef: RefObject<HTMLElement>;
+}
+interface UseLoadingBarReturn {
+    showLoader: boolean;
+    finishingLoader: boolean;
+    loaderTop: number;
+}
+/**
+ * Manages the animated top loading bar state.
+ * - Tracks overall loading (prop + server)
+ * - Smooth 200 ms "finish" fade-out when loading completes
+ * - Positions the bar just below the sticky header via ResizeObserver
+ */
+export declare const useLoadingBar: ({ loading, isServerLoading, resolvedHeaderHeight, scrollRef, containerRef, }: UseLoadingBarProps) => UseLoadingBarReturn;
+export {};

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

@@ -0,0 +1,28 @@
+import { PaginationConfig, GridRow } from "../types";
+interface UsePaginationProps {
+    data: GridRow[];
+    pagination?: {
+        enabled?: boolean;
+        mode?: "client" | "server";
+        pageSize?: number;
+        showPageSizeSelector?: boolean;
+        pageSizeOptions?: number[];
+        serverConfig?: {
+            enabled: boolean;
+            onPageChange: (page: number, pageSize: number) => Promise<void> | void;
+            onPageSizeChange?: (pageSize: number) => Promise<void> | void;
+            loading?: boolean;
+            totalRows: number;
+        };
+    };
+}
+export declare const usePagination: ({ data, pagination }: UsePaginationProps) => {
+    currentPage: number;
+    resetPage: () => void;
+    paginationConfig: PaginationConfig;
+    paginatedData: GridRow[];
+    isServerLoading: boolean;
+    handlePageChange: (page: number) => Promise<void>;
+    handlePageSizeChange: (newPageSize: number) => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,29 @@
+import { RefObject } from "react";
+import React from "react";
+interface UseScrollSyncProps {
+    scrollRef: RefObject<HTMLDivElement>;
+    footerScrollRef: RefObject<HTMLDivElement>;
+    hasFooterAggregate: boolean;
+}
+interface UseScrollSyncReturn {
+    /** Current horizontal scroll position of the body (RAF-throttled). */
+    hScrollLeft: number;
+    /** Current viewport width of the scroll container. */
+    viewportWidth: number;
+    /** Schedules a RAF-debounced update to hScrollLeft. */
+    scheduleHScrollUpdate: (value: number) => void;
+    /** Forwards horizontal wheel events from non-scrollable header/footer to the body. */
+    forwardWheelToBody: (e: React.WheelEvent<HTMLDivElement>) => void;
+}
+/**
+ * Coordinates horizontal scroll state between the body scroll container,
+ * the sticky footer aggregate row, and the horizontal virtualisation system.
+ *
+ * Responsibilities:
+ * - RAF-throttled `hScrollLeft` state (used by horizontal virtualisation)
+ * - `viewportWidth` via ResizeObserver (used for visible column slicing)
+ * - Footer ↔ body scroll sync via an event listener
+ * - `forwardWheelToBody` for header/footer wheel events
+ */
+export declare const useScrollSync: ({ scrollRef, footerScrollRef, hasFooterAggregate, }: UseScrollSyncProps) => UseScrollSyncReturn;
+export {};

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

@@ -0,0 +1,13 @@
+import { GridRow } from "../types";
+interface UseSelectionProps {
+    data: GridRow[];
+    selectedRowIds?: Iterable<string | number> | null;
+    onRowSelect?: (row: GridRow) => void;
+    getRowId?: (row: GridRow) => string | number;
+}
+export declare const useSelection: ({ data, selectedRowIds, onRowSelect, getRowId, }: UseSelectionProps) => {
+    selectedRows: Set<string | number>;
+    handleRowSelect: (rowId: string | number, isSelected: boolean) => void;
+    handleSelectAll: (isSelected: boolean) => void;
+};
+export {};

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

@@ -0,0 +1,17 @@
+import { UIEvent } from "react";
+import { VirtualizedRange, GridRow } from "../types";
+interface UseVirtualizationProps {
+    data: GridRow[];
+    virtualized?: boolean;
+    rowHeight?: number;
+    overscan?: number;
+    height: number;
+}
+export declare const useVirtualization: ({ data, virtualized, rowHeight, overscan, height, }: UseVirtualizationProps) => {
+    scrollRef: import("react").MutableRefObject<HTMLDivElement>;
+    virtualizedRange: VirtualizedRange;
+    visibleData: GridRow[];
+    totalHeight: number;
+    handleScroll: (e: UIEvent<HTMLDivElement>) => void;
+};
+export {};