react-kd-grid 5.0.1

package/dist/components/filters/BooleanFilter.d.ts

@@ -0,0 +1,7 @@
+import { ColumnFilterValue } from "../../types";
+interface BooleanFilterProps {
+    value: ColumnFilterValue | null;
+    onChange: (value: ColumnFilterValue | null) => void;
+}
+export declare const BooleanFilter: ({ value, onChange }: BooleanFilterProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/filters/DateFilter.d.ts

@@ -0,0 +1,9 @@
+import { ColumnFilterValue } from "../../types";
+interface DateFilterProps {
+    value: ColumnFilterValue | null;
+    onChange: (value: ColumnFilterValue | null) => void;
+    min?: number;
+    max?: number;
+}
+export declare const DateFilter: ({ value, onChange, min, max }: DateFilterProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/filters/FilterContent.d.ts

@@ -0,0 +1,9 @@
+import { ColumnFilterValue, GridColumn, GridRow } from "../../types";
+interface FilterContentProps {
+    column: GridColumn;
+    data: GridRow[];
+    value: ColumnFilterValue | null;
+    onChange: (val: ColumnFilterValue | null) => void;
+}
+export declare const FilterContent: ({ column, data, value, onChange }: FilterContentProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/filters/FilterPopup.d.ts

@@ -0,0 +1,2 @@
+import { FilterPopupProps } from "../../types";
+export declare const FilterPopup: ({ column, data, currentFilter, onApplyFilter, onClose, position, autoApply, }: FilterPopupProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/filters/MultiselectFilter.d.ts

@@ -0,0 +1,10 @@
+import { ColumnFilterValue, FilterOption, GridRow } from "../../types";
+interface MultiselectFilterProps {
+    value: ColumnFilterValue | null;
+    onChange: (value: ColumnFilterValue | null) => void;
+    options?: FilterOption[];
+    data: GridRow[];
+    columnKey: string;
+}
+export declare const MultiselectFilter: ({ value, onChange, options, data, columnKey, }: MultiselectFilterProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/filters/NumberFilter.d.ts

@@ -0,0 +1,9 @@
+import { ColumnFilterValue } from "../../types";
+interface NumberFilterProps {
+    value: ColumnFilterValue | null;
+    onChange: (value: ColumnFilterValue | null) => void;
+    min?: number;
+    max?: number;
+}
+export declare const NumberFilter: ({ value, onChange, min, max, }: NumberFilterProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/filters/TextFilter.d.ts

@@ -0,0 +1,8 @@
+import { ColumnFilterValue } from "../../types";
+interface TextFilterProps {
+    value: ColumnFilterValue | null;
+    onChange: (value: ColumnFilterValue | null) => void;
+    placeholder?: string;
+}
+export declare const TextFilter: ({ value, onChange, placeholder, }: TextFilterProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+export { TextFilter } from './TextFilter';
+export { NumberFilter } from './NumberFilter';
+export { DateFilter } from './DateFilter';
+export { MultiselectFilter } from './MultiselectFilter';
+export { BooleanFilter } from './BooleanFilter';
+export { FilterPopup } from './FilterPopup';

package/dist/components/ui/DatePicker.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+interface DatePickerProps {
+    name?: string;
+    label?: string;
+    value: string | null;
+    onChange: (value: string | null) => void;
+    className?: string;
+}
+export declare const DatePicker: React.FC<DatePickerProps>;
+export {};

package/dist/constants.d.ts

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

package/dist/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/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/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/hooks/useColumnState.d.ts

@@ -0,0 +1,45 @@
+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;
+}
+export interface UseColumnStateReturn {
+    columnWidths: Record<string, number>;
+    columnOrder: string[];
+    pinnedColumns: Set<string>;
+    columnVisibility: Record<string, boolean>;
+    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
+ */
+export declare const useColumnState: ({ columns, data, initialColumnConfig, onColumnConfigChange, setSortConfig, setGroupKeys, setDensity, setGlobalFilter, setColumnFilter, sortConfig, groupConfig, globalFilter, columnFilters, density, }: UseColumnStateProps) => UseColumnStateReturn;
+export {};

package/dist/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/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/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/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/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/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/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/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/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/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 {};

package/dist/icons/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * KDGrid Icon Library
+ *
+ * Hand-crafted inline SVG icons — zero external dependency.
+ * Every icon accepts standard SVG props (className, style, etc.)
+ * and defaults to currentColor so they inherit text color.
+ *
+ * All icons are 24×24 viewBox and stroke-based (strokeWidth=2),
+ * matching Lucide's visual style exactly.
+ */
+import type { SVGProps } from "react";
+type IconProps = SVGProps<SVGSVGElement> & {
+    size?: number;
+};
+export declare const ChevronLeft: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ChevronRight: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ChevronDown: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ChevronsLeft: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ChevronsRight: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ArrowUp: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ArrowDown: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ArrowUpDown: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const X: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Check: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Copy: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Edit: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Trash2: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Archive: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Download: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Menu: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Filter: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FilterX: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Settings: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Pin: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const PinOff: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Group: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Ungroup: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const MoreHorizontal: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Eye: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const EyeOff: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Search: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Database: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FileText: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Table: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Users: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const LocateFixed: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Loader2: (p: IconProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Classic CSS-framework spinner — fill-based, works with `animate-spin`.
+ * A faint full ring (opacity-25) + a solid quarter-arc (opacity-75).
+ * Uses fill="currentColor" so colour is inherited from text / className.
+ */
+export declare const Spinner: ({ size, className, style, ...rest }: IconProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { KDGrid } from "./core/DataGrid";
+export type { KDGridProps, KDGridRef, GridColumn, GridRow, Density, SortConfig, SortDirection, PaginationConfig, PaginationOptions, ExportOptions, PerformanceConfig, InfiniteScrollOptions, GroupConfig, ActiveFilters, ColumnFilterValue, ColumnFilter, FilterType, ColumnConfig, ContextMenuItem, BulkActionOption, SavedFilter, SearchMode, ExportFormat, RowEventParams, CellClickParams, CellContextMenuParams, CellFocusParams, CellEditParams, CellSelectionPayload, CopyCellsPayload, } from "./types";
+export { usePagination } from "./hooks/usePagination";
+export { useVirtualization } from "./hooks/useVirtualization";
+export { useSelection } from "./hooks/useSelection";
+export { useAdvancedFiltering } from "./hooks/useAdvancedFiltering";
+export { setLicenseKey } from "./utils/license";
+export { PaginationControls } from "./components/PaginationControls";
+export { GridHeader } from "./components/GridHeader";
+export { GridRows } from "./components/GridRows";
+export { SearchToolbar } from "./components/SearchToolbar";
+export { FooterAggregate } from "./components/FooterAggregate";