@alaarab/ogrid-core 1.2.2 → 1.3.1

package/dist/esm/hooks/useKeyboardNavigation.js

@@ -1,8 +1,9 @@
 import { useCallback } from 'react';
 import { normalizeSelectionRange } from '../types';
 import { getCellValue } from '../utils';
+import { parseValue } from '../utils/valueParsers';
 export function useKeyboardNavigation(params) {
-    const { items, visibleCols, colOffset, hasCheckboxCol, visibleColumnCount, activeCell, setActiveCell, selectionRange, setSelectionRange, editable, onCellValueChanged, getRowId, editingCell, setEditingCell, rowSelection, selectedRowIds, handleRowCheckboxChange, handleCopy, handleCut, handlePaste, setContextMenu, wrapperRef, onUndo, onRedo, } = params;
+    const { items, visibleCols, colOffset, hasCheckboxCol, visibleColumnCount, activeCell, setActiveCell, selectionRange, setSelectionRange, editable, onCellValueChanged, getRowId, editingCell, setEditingCell, rowSelection, selectedRowIds, handleRowCheckboxChange, handleCopy, handleCut, handlePaste, setContextMenu, wrapperRef, onUndo, onRedo, clearClipboardRanges, } = params;
     const maxRowIndex = items.length - 1;
     const maxColIndex = visibleColumnCount - 1 + colOffset;
     const handleGridKeyDown = useCallback((e) => {
@@ -30,18 +31,24 @@ export function useKeyboardNavigation(params) {
         switch (e.key) {
             case 'c':
                 if (e.ctrlKey || e.metaKey) {
+                    if (editingCell != null)
+                        break; // let the input handle copy
                     e.preventDefault();
                     handleCopy();
                 }
                 break;
             case 'x':
                 if (e.ctrlKey || e.metaKey) {
+                    if (editingCell != null)
+                        break; // let the input handle cut
                     e.preventDefault();
                     handleCut();
                 }
                 break;
             case 'v':
                 if (e.ctrlKey || e.metaKey) {
+                    if (editingCell != null)
+                        break; // let the input handle paste
                     e.preventDefault();
                     void handlePaste();
                 }
@@ -216,6 +223,7 @@ export function useKeyboardNavigation(params) {
                     setEditingCell(null);
                 }
                 else {
+                    clearClipboardRanges?.();
                     setActiveCell(null);
                     setSelectionRange(null);
                 }
@@ -257,6 +265,8 @@ export function useKeyboardNavigation(params) {
                 break;
             case 'a':
                 if (e.ctrlKey || e.metaKey) {
+                    if (editingCell != null)
+                        break; // let the input handle select-all
                     e.preventDefault();
                     if (items.length > 0 && visibleColumnCount > 0) {
                         setSelectionRange({
@@ -273,6 +283,8 @@ export function useKeyboardNavigation(params) {
             case 'Backspace': {
                 if (editingCell != null)
                     break;
+                if (editable === false)
+                    break;
                 if (onCellValueChanged == null)
                     break;
                 const range = selectionRange ??
@@ -294,13 +306,20 @@ export function useKeyboardNavigation(params) {
                             continue;
                         const item = items[r];
                         const col = visibleCols[c];
+                        const colEditable = col.editable === true ||
+                            (typeof col.editable === 'function' && col.editable(item));
+                        if (!colEditable)
+                            continue;
                         const oldValue = getCellValue(item, col);
+                        const result = parseValue('', oldValue, item, col);
+                        if (!result.valid)
+                            continue;
                         onCellValueChanged({
                             item,
                             columnId: col.columnId,
                             field: col.columnId,
                             oldValue,
-                            newValue: '',
+                            newValue: result.value,
                             rowIndex: r,
                         });
                     }
@@ -359,6 +378,7 @@ export function useKeyboardNavigation(params) {
         wrapperRef,
         onUndo,
         onRedo,
+        clearClipboardRanges,
     ]);
     return { handleGridKeyDown };
 }

package/dist/esm/hooks/useOGrid.js

@@ -5,7 +5,7 @@ import { toDataGridFilterProps } from '../types';
 import { useFilterOptions } from './useFilterOptions';
 const DEFAULT_PAGE_SIZE = 20;
 export function useOGrid(props, ref) {
-    const { columns: columnsProp, getRowId, data, dataSource, page: controlledPage, pageSize: controlledPageSize, sort: controlledSort, filters: controlledFilters, visibleColumns: controlledVisibleColumns, isLoading: controlledLoading, onPageChange, onPageSizeChange, onSortChange, onFiltersChange, onVisibleColumnsChange, columnOrder, onColumnOrderChange, freezeRows, freezeCols, defaultPageSize = DEFAULT_PAGE_SIZE, defaultSortBy, defaultSortDirection = 'asc', toolbar, emptyState, entityLabelPlural = 'items', className, title, layoutMode = 'content', editable, onCellValueChanged, onUndo, onRedo, rowSelection = 'none', selectedRows, onSelectionChange, statusBar, onError, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, } = props;
+    const { columns: columnsProp, getRowId, data, dataSource, page: controlledPage, pageSize: controlledPageSize, sort: controlledSort, filters: controlledFilters, visibleColumns: controlledVisibleColumns, isLoading: controlledLoading, onPageChange, onPageSizeChange, onSortChange, onFiltersChange, onVisibleColumnsChange, columnOrder, onColumnOrderChange, freezeRows, freezeCols, defaultPageSize = DEFAULT_PAGE_SIZE, defaultSortBy, defaultSortDirection = 'asc', toolbar, emptyState, entityLabelPlural = 'items', className, title, layoutMode = 'fill', editable, cellSelection, onCellValueChanged, onUndo, onRedo, canUndo, canRedo, rowSelection = 'none', selectedRows, onSelectionChange, statusBar, onError, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, } = props;
     const columns = useMemo(() => flattenColumns(columnsProp), [columnsProp]);
     const isServerSide = dataSource != null;
     const isClientSide = !isServerSide;
@@ -307,9 +307,12 @@ export function useOGrid(props, ref) {
         freezeRows,
         freezeCols,
         editable,
+        cellSelection,
         onCellValueChanged,
         onUndo,
         onRedo,
+        canUndo,
+        canRedo,
         rowSelection,
         selectedRows: effectiveSelectedRows,
         onSelectionChange: handleSelectionChange,

package/dist/esm/hooks/useUndoRedo.js

@@ -1,46 +1,74 @@
 import { useCallback, useRef, useState } from 'react';
 /**
  * Wraps onCellValueChanged with an undo/redo history stack.
- * Undo reverts the last change; redo reapplies it.
+ * Supports batch operations: changes between beginBatch/endBatch are one undo step.
  */
 export function useUndoRedo(params) {
     const { onCellValueChanged, maxHistory = 50 } = params;
+    // Each history entry is an array of events (batch). Single edits are [event].
     const historyRef = useRef([]);
     const redoStackRef = useRef([]);
+    const batchRef = useRef(null);
     const [historyLength, setHistoryLength] = useState(0);
     const [redoLength, setRedoLength] = useState(0);
     const wrapped = useCallback((event) => {
         if (!onCellValueChanged)
             return;
-        historyRef.current = [...historyRef.current, event].slice(-maxHistory);
+        if (batchRef.current !== null) {
+            // Accumulate into the current batch — don't push to history yet
+            batchRef.current.push(event);
+        }
+        else {
+            historyRef.current = [...historyRef.current, [event]].slice(-maxHistory);
+            redoStackRef.current = [];
+            setHistoryLength(historyRef.current.length);
+            setRedoLength(0);
+        }
+        onCellValueChanged(event);
+    }, [onCellValueChanged, maxHistory]);
+    const beginBatch = useCallback(() => {
+        batchRef.current = [];
+    }, []);
+    const endBatch = useCallback(() => {
+        const batch = batchRef.current;
+        batchRef.current = null;
+        if (!batch || batch.length === 0)
+            return;
+        historyRef.current = [...historyRef.current, batch].slice(-maxHistory);
         redoStackRef.current = [];
         setHistoryLength(historyRef.current.length);
         setRedoLength(0);
-        onCellValueChanged(event);
-    }, [onCellValueChanged, maxHistory]);
+    }, [maxHistory]);
     const undo = useCallback(() => {
         if (!onCellValueChanged || historyRef.current.length === 0)
             return;
-        const last = historyRef.current[historyRef.current.length - 1];
+        const lastBatch = historyRef.current[historyRef.current.length - 1];
         historyRef.current = historyRef.current.slice(0, -1);
-        redoStackRef.current = [...redoStackRef.current, last];
+        redoStackRef.current = [...redoStackRef.current, lastBatch];
         setHistoryLength(historyRef.current.length);
         setRedoLength(redoStackRef.current.length);
-        onCellValueChanged({
-            ...last,
-            oldValue: last.newValue,
-            newValue: last.oldValue,
-        });
+        // Revert in reverse order so multi-cell undo is applied correctly
+        for (let i = lastBatch.length - 1; i >= 0; i--) {
+            const ev = lastBatch[i];
+            onCellValueChanged({
+                ...ev,
+                oldValue: ev.newValue,
+                newValue: ev.oldValue,
+            });
+        }
     }, [onCellValueChanged]);
     const redo = useCallback(() => {
         if (!onCellValueChanged || redoStackRef.current.length === 0)
             return;
-        const next = redoStackRef.current[redoStackRef.current.length - 1];
+        const nextBatch = redoStackRef.current[redoStackRef.current.length - 1];
         redoStackRef.current = redoStackRef.current.slice(0, -1);
-        historyRef.current = [...historyRef.current, next];
+        historyRef.current = [...historyRef.current, nextBatch];
         setRedoLength(redoStackRef.current.length);
         setHistoryLength(historyRef.current.length);
-        onCellValueChanged(next);
+        // Replay in original order
+        for (const ev of nextBatch) {
+            onCellValueChanged(ev);
+        }
     }, [onCellValueChanged]);
     return {
         onCellValueChanged: onCellValueChanged ? wrapped : undefined,
@@ -48,5 +76,7 @@ export function useUndoRedo(params) {
         redo,
         canUndo: historyLength > 0,
         canRedo: redoLength > 0,
+        beginBatch,
+        endBatch,
     };
 }

package/dist/esm/index.js

@@ -5,5 +5,6 @@ export { useFilterOptions, useOGrid, useActiveCell, useCellEditing, useContextMe
 export { OGridLayout } from './components/OGridLayout';
 export { StatusBar } from './components/StatusBar';
 export { GridContextMenu } from './components/GridContextMenu';
+export { MarchingAntsOverlay } from './components/MarchingAntsOverlay';
 // Utilities
-export { escapeCsvValue, buildCsvHeader, buildCsvRows, exportToCsv, triggerCsvDownload, getCellValue, flattenColumns, getFilterField, mergeFilter, deriveFilterOptionsFromData, getMultiSelectFilterFields, getStatusBarParts, getDataGridStatusBarConfig, GRID_CONTEXT_MENU_ITEMS, getContextMenuHandlers, getPaginationViewModel, PAGE_SIZE_OPTIONS, MAX_PAGE_BUTTONS, getHeaderFilterConfig, getCellRenderDescriptor, } from './utils';
+export { escapeCsvValue, buildCsvHeader, buildCsvRows, exportToCsv, triggerCsvDownload, getCellValue, flattenColumns, getFilterField, mergeFilter, deriveFilterOptionsFromData, getMultiSelectFilterFields, getStatusBarParts, getDataGridStatusBarConfig, GRID_CONTEXT_MENU_ITEMS, getContextMenuHandlers, formatShortcut, getPaginationViewModel, PAGE_SIZE_OPTIONS, MAX_PAGE_BUTTONS, getHeaderFilterConfig, getCellRenderDescriptor, parseValue, numberParser, currencyParser, dateParser, emailParser, booleanParser, } from './utils';

package/dist/esm/utils/dataGridViewModel.js

@@ -77,7 +77,12 @@ export function getCellRenderDescriptor(item, col, rowIndex, colIdx, input) {
         isInSelectionRange(input.selectionRange, rowIndex, colIdx);
     const isInCutRange = input.cutRange != null &&
         isInSelectionRange(input.cutRange, rowIndex, colIdx);
-    const isSelectionEndCell = input.selectionRange != null &&
+    const isInCopyRange = input.copyRange != null &&
+        isInSelectionRange(input.copyRange, rowIndex, colIdx);
+    const isSelectionEndCell = !input.isDragging &&
+        input.copyRange == null &&
+        input.cutRange == null &&
+        input.selectionRange != null &&
         rowIndex === input.selectionRange.endRow &&
         colIdx === input.selectionRange.endCol;
     const isPinned = col.pinned != null;
@@ -109,6 +114,7 @@ export function getCellRenderDescriptor(item, col, rowIndex, colIdx, input) {
         isActive,
         isInRange,
         isInCutRange,
+        isInCopyRange,
         isSelectionEndCell,
         canEditAny,
         isPinned,

package/dist/esm/utils/gridContextMenuHelpers.js

@@ -1,16 +1,31 @@
 export const GRID_CONTEXT_MENU_ITEMS = [
-    { id: 'copy', label: 'Copy', disabledWhenNoSelection: true },
-    { id: 'cut', label: 'Cut', disabledWhenNoSelection: true },
-    { id: 'paste', label: 'Paste' },
-    { id: 'selectAll', label: 'Select all' },
+    { id: 'undo', label: 'Undo', shortcut: 'Ctrl+Z' },
+    { id: 'redo', label: 'Redo', shortcut: 'Ctrl+Y' },
+    { id: 'copy', label: 'Copy', shortcut: 'Ctrl+C', disabledWhenNoSelection: true, dividerBefore: true },
+    { id: 'cut', label: 'Cut', shortcut: 'Ctrl+X', disabledWhenNoSelection: true },
+    { id: 'paste', label: 'Paste', shortcut: 'Ctrl+V' },
+    { id: 'selectAll', label: 'Select all', shortcut: 'Ctrl+A', dividerBefore: true },
 ];
+/** Returns the shortcut string with Ctrl swapped to ⌘ on Mac. */
+export function formatShortcut(shortcut) {
+    const isMac = typeof navigator !== 'undefined' && /Mac|iPhone|iPad|iPod/.test(navigator.userAgent);
+    return isMac ? shortcut.replace('Ctrl', '\u2318') : shortcut;
+}
 /**
  * Returns a map of menu item id -> click handler. Each handler invokes the corresponding
  * action and then onClose. Used by Fluent, Material, and Radix GridContextMenu components.
  */
 export function getContextMenuHandlers(props) {
-    const { onCopy, onCut, onPaste, onSelectAll, onClose } = props;
+    const { onCopy, onCut, onPaste, onSelectAll, onUndo, onRedo, onClose } = props;
     return {
+        undo: () => {
+            onUndo();
+            onClose();
+        },
+        redo: () => {
+            onRedo();
+            onClose();
+        },
         copy: () => {
             onCopy();
             onClose();

package/dist/esm/utils/index.js

@@ -5,5 +5,6 @@ export { getFilterField, mergeFilter, deriveFilterOptionsFromData, getMultiSelec
 export { getStatusBarParts } from './statusBarHelpers';
 export { getDataGridStatusBarConfig } from './dataGridStatusBar';
 export { getPaginationViewModel, PAGE_SIZE_OPTIONS, MAX_PAGE_BUTTONS, } from './paginationHelpers';
-export { GRID_CONTEXT_MENU_ITEMS, getContextMenuHandlers } from './gridContextMenuHelpers';
+export { GRID_CONTEXT_MENU_ITEMS, getContextMenuHandlers, formatShortcut } from './gridContextMenuHelpers';
 export { getHeaderFilterConfig, getCellRenderDescriptor, } from './dataGridViewModel';
+export { parseValue, numberParser, currencyParser, dateParser, emailParser, booleanParser, } from './valueParsers';

package/dist/esm/utils/valueParsers.js

@@ -0,0 +1,107 @@
+/**
+ * Run the column's valueParser (if any), or auto-validate select columns.
+ * Returns `{ valid: true, value }` with the parsed value, or `{ valid: false }` to reject.
+ */
+export function parseValue(newValue, oldValue, item, col) {
+    // 1. Custom valueParser takes priority
+    if (col.valueParser) {
+        const params = {
+            newValue,
+            oldValue,
+            data: item,
+            column: col,
+        };
+        const parsed = col.valueParser(params);
+        if (parsed === undefined) {
+            return { valid: false, value: undefined };
+        }
+        return { valid: true, value: parsed };
+    }
+    // 2. Auto-validate select columns against allowed values
+    if (col.cellEditor === 'select' &&
+        col.cellEditorParams?.values != null &&
+        Array.isArray(col.cellEditorParams.values)) {
+        const allowedValues = col.cellEditorParams.values;
+        const strValue = typeof newValue === 'string' ? newValue : String(newValue ?? '');
+        // Allow clearing (empty string)
+        if (strValue === '') {
+            return { valid: true, value: '' };
+        }
+        // Case-insensitive match; return canonical value from the options list
+        const match = allowedValues.find((v) => String(v).toLowerCase() === strValue.toLowerCase());
+        if (match !== undefined) {
+            return { valid: true, value: match };
+        }
+        return { valid: false, value: undefined };
+    }
+    // 3. No parser, not a select column — pass through unchanged
+    return { valid: true, value: newValue };
+}
+// --- Built-in parser helpers ---
+// Consumers assign these to columns: { valueParser: numberParser }
+// Return `undefined` to reject; `null` to clear the cell.
+/**
+ * Parses a value as a number. Strips whitespace and commas.
+ * Returns `undefined` (reject) if result is NaN.
+ */
+export function numberParser(params) {
+    const { newValue } = params;
+    if (newValue === '' || newValue == null)
+        return null;
+    const str = String(newValue).replace(/[\s,]/g, '');
+    const num = Number(str);
+    return Number.isNaN(num) ? undefined : num;
+}
+/**
+ * Parses a currency string. Strips currency symbols ($, €, £, ¥), whitespace, commas.
+ * Returns `undefined` (reject) if result is NaN.
+ */
+export function currencyParser(params) {
+    const { newValue } = params;
+    if (newValue === '' || newValue == null)
+        return null;
+    const str = String(newValue)
+        .replace(/[$\u20AC\u00A3\u00A5]/g, '') // $, €, £, ¥
+        .replace(/[\s,]/g, '');
+    const num = Number(str);
+    return Number.isNaN(num) ? undefined : num;
+}
+/**
+ * Parses a date string via `new Date()`. Returns ISO string or `undefined` if invalid.
+ */
+export function dateParser(params) {
+    const { newValue } = params;
+    if (newValue === '' || newValue == null)
+        return null;
+    const str = String(newValue).trim();
+    const date = new Date(str);
+    if (Number.isNaN(date.getTime()))
+        return undefined;
+    return date.toISOString();
+}
+/**
+ * Validates an email address with a basic regex.
+ * Returns the trimmed string or `undefined` if invalid.
+ */
+export function emailParser(params) {
+    const { newValue } = params;
+    if (newValue === '' || newValue == null)
+        return null;
+    const str = String(newValue).trim();
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str) ? str : undefined;
+}
+/**
+ * Parses boolean-like values: true/false/yes/no/1/0.
+ * Returns `undefined` if not recognized.
+ */
+export function booleanParser(params) {
+    const { newValue } = params;
+    if (newValue === '' || newValue == null)
+        return null;
+    const str = String(newValue).trim().toLowerCase();
+    if (['true', 'yes', '1'].includes(str))
+        return true;
+    if (['false', 'no', '0'].includes(str))
+        return false;
+    return undefined;
+}

package/dist/types/components/GridContextMenu.d.ts

@@ -3,12 +3,16 @@ import type { GridContextMenuHandlerProps } from '../utils/gridContextMenuHelper
 export interface GridContextMenuClassNames {
     contextMenu?: string;
     contextMenuItem?: string;
+    contextMenuItemLabel?: string;
+    contextMenuItemShortcut?: string;
     contextMenuDivider?: string;
 }
 export interface GridContextMenuProps extends GridContextMenuHandlerProps {
     x: number;
     y: number;
     hasSelection: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
     classNames?: GridContextMenuClassNames;
 }
 export declare function GridContextMenu(props: GridContextMenuProps): React.ReactElement;

package/dist/types/components/MarchingAntsOverlay.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { ISelectionRange } from '../types';
+export interface MarchingAntsOverlayProps {
+    /** Ref to the positioned container that wraps the table (must have position: relative) */
+    containerRef: React.RefObject<HTMLElement | null>;
+    /** Current selection range — solid green border */
+    selectionRange: ISelectionRange | null;
+    /** Copy range — animated dashed border */
+    copyRange: ISelectionRange | null;
+    /** Cut range — animated dashed border */
+    cutRange: ISelectionRange | null;
+    /** Column offset — 1 when checkbox column is present, else 0 */
+    colOffset: number;
+}
+export declare function MarchingAntsOverlay({ containerRef, selectionRange, copyRange, cutRange, colOffset, }: MarchingAntsOverlayProps): React.ReactElement | null;

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

@@ -10,5 +10,7 @@ export interface UseCellSelectionResult {
     setSelectionRange: (range: ISelectionRange | null) => void;
     handleCellMouseDown: (e: React.MouseEvent, rowIndex: number, globalColIndex: number) => void;
     handleSelectAllCells: () => void;
+    /** True while the user is drag-selecting cells (mousedown → mousemove → mouseup). */
+    isDragging: boolean;
 }
 export declare function useCellSelection(params: UseCellSelectionParams): UseCellSelectionResult;

package/dist/types/hooks/useClipboard.d.ts

@@ -5,7 +5,10 @@ export interface UseClipboardParams<T> {
     colOffset: number;
     selectionRange: ISelectionRange | null;
     activeCell: IActiveCell | null;
+    editable?: boolean;
     onCellValueChanged: ((event: ICellValueChangedEvent<T>) => void) | undefined;
+    beginBatch?: () => void;
+    endBatch?: () => void;
 }
 export interface UseClipboardResult {
     handleCopy: () => void;
@@ -14,5 +17,9 @@ export interface UseClipboardResult {
     cutRangeRef: React.MutableRefObject<ISelectionRange | null>;
     /** Current cut range for UI (marching ants). Null when no cut or after paste. */
     cutRange: ISelectionRange | null;
+    /** Current copy range for UI (marching ants). Null when no copy or after paste/cut. */
+    copyRange: ISelectionRange | null;
+    /** Clear both copy and cut ranges (dismisses marching ants). Called on Escape. */
+    clearClipboardRanges: () => void;
 }
 export declare function useClipboard<T>(params: UseClipboardParams<T>): UseClipboardResult;

package/dist/types/hooks/useContextMenu.d.ts

@@ -8,6 +8,7 @@ export interface UseContextMenuResult {
     handleCellContextMenu: (e: {
         clientX: number;
         clientY: number;
+        preventDefault?: () => void;
     }) => void;
     closeContextMenu: () => void;
 }

package/dist/types/hooks/useDataGridState.d.ts

@@ -57,8 +57,13 @@ export interface UseDataGridStateResult<T> {
     handleCellContextMenu: (e: {
         clientX: number;
         clientY: number;
+        preventDefault?: () => void;
     }) => void;
     closeContextMenu: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    onUndo?: () => void;
+    onRedo?: () => void;
     handleCopy: () => void;
     handleCut: () => void;
     handlePaste: () => Promise<void>;
@@ -68,6 +73,12 @@ export interface UseDataGridStateResult<T> {
         endRow: number;
         endCol: number;
     } | null;
+    copyRange: {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    } | null;
     handleGridKeyDown: (e: React.KeyboardEvent) => void;
     handleFillHandleMouseDown: (e: React.MouseEvent) => void;
     containerWidth: number;
@@ -84,6 +95,7 @@ export interface UseDataGridStateResult<T> {
     cancelPopoverEdit: () => void;
     popoverAnchorEl: HTMLElement | null;
     setPopoverAnchorEl: React.Dispatch<React.SetStateAction<HTMLElement | null>>;
+    clearClipboardRanges: () => void;
     statusBarConfig: IStatusBarProps | null;
     showEmptyInGrid: boolean;
     hasCellSelection: boolean;

package/dist/types/hooks/useFillHandle.d.ts

@@ -4,12 +4,15 @@ import type { IColumnDef, ICellValueChangedEvent } from '../types/columnTypes';
 export interface UseFillHandleParams<T> {
     items: T[];
     visibleCols: IColumnDef<T>[];
+    editable?: boolean;
     onCellValueChanged?: (event: ICellValueChangedEvent<T>) => void;
     selectionRange: ISelectionRange | null;
     setSelectionRange: (range: ISelectionRange | null) => void;
     setActiveCell: (cell: IActiveCell | null) => void;
     colOffset: number;
     wrapperRef: RefObject<HTMLDivElement | null>;
+    beginBatch?: () => void;
+    endBatch?: () => void;
 }
 export interface UseFillHandleResult {
     fillDrag: {

package/dist/types/hooks/useKeyboardNavigation.d.ts

@@ -11,7 +11,7 @@ export interface UseKeyboardNavigationParams<T> {
     setActiveCell: (cell: IActiveCell | null) => void;
     selectionRange: ISelectionRange | null;
     setSelectionRange: (range: ISelectionRange | null) => void;
-    editable: boolean | undefined;
+    editable?: boolean;
     onCellValueChanged: ((event: ICellValueChangedEvent<T>) => void) | undefined;
     getRowId: (item: T) => RowId;
     editingCell: EditingCell | null;
@@ -26,6 +26,7 @@ export interface UseKeyboardNavigationParams<T> {
     wrapperRef: React.RefObject<HTMLElement | null>;
     onUndo?: () => void;
     onRedo?: () => void;
+    clearClipboardRanges?: () => void;
 }
 export interface UseKeyboardNavigationResult {
     handleGridKeyDown: (e: React.KeyboardEvent) => void;

package/dist/types/hooks/useUndoRedo.d.ts

@@ -9,9 +9,13 @@ export interface UseUndoRedoResult<T> {
     redo: () => void;
     canUndo: boolean;
     canRedo: boolean;
+    /** Start a batch — all changes until endBatch() are grouped as one undo step. */
+    beginBatch: () => void;
+    /** End a batch — commits the accumulated changes as a single undo entry. */
+    endBatch: () => void;
 }
 /**
  * Wraps onCellValueChanged with an undo/redo history stack.
- * Undo reverts the last change; redo reapplies it.
+ * Supports batch operations: changes between beginBatch/endBatch are one undo step.
  */
 export declare function useUndoRedo<T>(params: UseUndoRedoParams<T>): UseUndoRedoResult<T>;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export type { ColumnFilterType, IColumnFilterDef, IColumnMeta, IColumnDef, IColumnGroupDef, IColumnDefinition, ICellValueChangedEvent, ICellEditorProps, CellEditorParams, UserLike, UserLikeInput, FilterValue, IFilters, IFetchParams, IPageResult, IDataSource, IGridColumnState, IOGridApi, IOGridProps, IOGridDataGridProps, RowSelectionMode, IRowSelectionChangeEvent, StatusBarPanel, IStatusBarProps, IActiveCell, ISelectionRange, } from './types';
+export type { ColumnFilterType, IColumnFilterDef, IColumnMeta, IColumnDef, IColumnGroupDef, IColumnDefinition, ICellValueChangedEvent, ICellEditorProps, CellEditorParams, IValueParserParams, UserLike, UserLikeInput, FilterValue, IFilters, IFetchParams, IPageResult, IDataSource, IGridColumnState, IOGridApi, IOGridProps, IOGridDataGridProps, RowSelectionMode, IRowSelectionChangeEvent, StatusBarPanel, IStatusBarProps, IActiveCell, ISelectionRange, } from './types';
 export { toUserLike, toDataGridFilterProps, isInSelectionRange, normalizeSelectionRange } from './types';
 export { useFilterOptions, useOGrid, useActiveCell, useCellEditing, useContextMenu, useCellSelection, useClipboard, useRowSelection, useKeyboardNavigation, useUndoRedo, useDebounce, useFillHandle, useDataGridState, useColumnHeaderFilterState, useColumnChooserState, useInlineCellEditorState, useColumnResize, } from './hooks';
 export type { UseFilterOptionsResult, UseOGridResult, UseActiveCellResult, UseCellEditingResult, EditingCell, UseContextMenuResult, ContextMenuPosition, UseCellSelectionResult, UseCellSelectionParams, UseClipboardResult, UseClipboardParams, UseRowSelectionResult, UseRowSelectionParams, UseKeyboardNavigationResult, UseKeyboardNavigationParams, UseUndoRedoResult, UseUndoRedoParams, UseFillHandleResult, UseFillHandleParams, UseDataGridStateParams, UseDataGridStateResult, UseColumnHeaderFilterStateParams, UseColumnHeaderFilterStateResult, UseColumnChooserStateParams, UseColumnChooserStateResult, UseInlineCellEditorStateParams, UseInlineCellEditorStateResult, InlineCellEditorType, UseColumnResizeParams, UseColumnResizeResult, } from './hooks';
@@ -8,5 +8,7 @@ export { StatusBar } from './components/StatusBar';
 export type { StatusBarProps, StatusBarClassNames } from './components/StatusBar';
 export { GridContextMenu } from './components/GridContextMenu';
 export type { GridContextMenuProps, GridContextMenuClassNames } from './components/GridContextMenu';
-export { escapeCsvValue, buildCsvHeader, buildCsvRows, exportToCsv, triggerCsvDownload, getCellValue, flattenColumns, getFilterField, mergeFilter, deriveFilterOptionsFromData, getMultiSelectFilterFields, getStatusBarParts, getDataGridStatusBarConfig, GRID_CONTEXT_MENU_ITEMS, getContextMenuHandlers, getPaginationViewModel, PAGE_SIZE_OPTIONS, MAX_PAGE_BUTTONS, getHeaderFilterConfig, getCellRenderDescriptor, } from './utils';
-export type { CsvColumn, StatusBarPart, StatusBarPartsInput, GridContextMenuItem, GridContextMenuHandlerProps, PaginationViewModel, HeaderFilterConfigInput, HeaderFilterConfig, CellRenderDescriptorInput, CellRenderDescriptor, CellRenderMode, } from './utils';
+export { MarchingAntsOverlay } from './components/MarchingAntsOverlay';
+export type { MarchingAntsOverlayProps } from './components/MarchingAntsOverlay';
+export { escapeCsvValue, buildCsvHeader, buildCsvRows, exportToCsv, triggerCsvDownload, getCellValue, flattenColumns, getFilterField, mergeFilter, deriveFilterOptionsFromData, getMultiSelectFilterFields, getStatusBarParts, getDataGridStatusBarConfig, GRID_CONTEXT_MENU_ITEMS, getContextMenuHandlers, formatShortcut, getPaginationViewModel, PAGE_SIZE_OPTIONS, MAX_PAGE_BUTTONS, getHeaderFilterConfig, getCellRenderDescriptor, parseValue, numberParser, currencyParser, dateParser, emailParser, booleanParser, } from './utils';
+export type { CsvColumn, StatusBarPart, StatusBarPartsInput, GridContextMenuItem, GridContextMenuHandlerProps, PaginationViewModel, HeaderFilterConfigInput, HeaderFilterConfig, CellRenderDescriptorInput, CellRenderDescriptor, CellRenderMode, ParseValueResult, } from './utils';

package/dist/types/types/columnTypes.d.ts

@@ -21,6 +21,17 @@ export interface IColumnMeta {
     /** Pin column to left or right edge (sticky during horizontal scroll). */
     pinned?: 'left' | 'right';
 }
+/** Parameters passed to the valueParser function. */
+export interface IValueParserParams<T = unknown> {
+    /** The new value to parse (typically a string from paste or editor). */
+    newValue: unknown;
+    /** The current value of the cell before the edit. */
+    oldValue: unknown;
+    /** The row data item. */
+    data: T;
+    /** The column definition. */
+    column: IColumnDef<T>;
+}
 export interface IColumnDef<T = unknown> extends IColumnMeta {
     renderCell?: (item: T) => React.ReactNode;
     compare?: (a: T, b: T) => number;
@@ -28,6 +39,12 @@ export interface IColumnDef<T = unknown> extends IColumnMeta {
     valueGetter?: (item: T) => unknown;
     /** Format the cell value for display (used when no renderCell). */
     valueFormatter?: (value: unknown, item: T) => string;
+    /**
+     * Parse/validate a new value before it is committed to the cell.
+     * Called on paste, inline edit commit, fill handle, and delete.
+     * Return the parsed value to use, or `undefined` to reject (skip) the change.
+     */
+    valueParser?: (params: IValueParserParams<T>) => unknown;
     /** Static or per-row cell inline styles. */
     cellStyle?: React.CSSProperties | ((item: T) => React.CSSProperties);
     /** Whether the cell is editable (per-column or per-row). */

package/dist/types/types/dataGridTypes.d.ts

@@ -141,9 +141,13 @@ export interface IOGridProps<T> {
     freezeRows?: number;
     freezeCols?: number;
     editable?: boolean;
+    /** Enable spreadsheet-like cell selection (active cell, range, fill handle, clipboard, context menu). Default: true. */
+    cellSelection?: boolean;
     onCellValueChanged?: (event: ICellValueChangedEvent<T>) => void;
     onUndo?: () => void;
     onRedo?: () => void;
+    canUndo?: boolean;
+    canRedo?: boolean;
     rowSelection?: RowSelectionMode;
     selectedRows?: Set<RowId>;
     onSelectionChange?: (event: IRowSelectionChangeEvent<T>) => void;
@@ -185,9 +189,13 @@ export interface IOGridDataGridProps<T> {
     isLoading?: boolean;
     loadingMessage?: string;
     editable?: boolean;
+    /** Enable spreadsheet-like cell selection. Default: true. */
+    cellSelection?: boolean;
     onCellValueChanged?: (event: ICellValueChangedEvent<T>) => void;
     onUndo?: () => void;
     onRedo?: () => void;
+    canUndo?: boolean;
+    canRedo?: boolean;
     rowSelection?: RowSelectionMode;
     selectedRows?: Set<RowId>;
     onSelectionChange?: (event: IRowSelectionChangeEvent<T>) => void;

package/dist/types/types/index.d.ts

@@ -1,3 +1,3 @@
-export type { ColumnFilterType, IColumnFilterDef, IColumnMeta, IColumnDef, IColumnGroupDef, IColumnDefinition, ICellValueChangedEvent, ICellEditorProps, CellEditorParams, } from './columnTypes';
+export type { ColumnFilterType, IColumnFilterDef, IColumnMeta, IColumnDef, IColumnGroupDef, IColumnDefinition, ICellValueChangedEvent, ICellEditorProps, CellEditorParams, IValueParserParams, } from './columnTypes';
 export type { RowId, UserLike, UserLikeInput, FilterValue, IFilters, IFetchParams, IPageResult, IDataSource, IGridColumnState, IOGridApi, IOGridProps, IOGridDataGridProps, RowSelectionMode, IRowSelectionChangeEvent, StatusBarPanel, IStatusBarProps, IActiveCell, ISelectionRange, } from './dataGridTypes';
 export { toUserLike, toDataGridFilterProps, isInSelectionRange, normalizeSelectionRange } from './dataGridTypes';