react-kd-grid 5.0.2 → 5.0.4

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