@opencorestack/opengridx 3.3.0 → 3.4.0

package/lib/hooks/core/useGridUndoRedo.ts

@@ -0,0 +1,220 @@
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import type { MutableRefObject, RefObject } from 'react';
+import type {
+    GridApi,
+    GridBatchEditResult,
+    GridColDef,
+    GridHistoryChangeParams,
+    GridRowId,
+    GridRowModel,
+} from '../../types';
+import { classifyKeyTarget } from '../../utils/focus';
+import type { FocusedCell } from '../../utils/focus';
+import { scrollColumnIntoView, scrollRowIntoView } from '../../utils/scroll';
+import { boundingTargetRect, buildEditTargetContext, rectCorners } from '../../utils/editing/targets';
+import type { GridCellChange } from '../../utils/editing/commit';
+import type { GridEditSource, UseGridBatchEditReturn } from '../features/useGridBatchEdit';
+import type { UseGridCellSelectionReturn } from './useGridCellSelection';
+import type { LayoutResult } from './useLayout';
+
+/** Default number of actions `undoRedo` keeps. */
+export const UNDO_HISTORY_LIMIT = 100;
+
+type CommitListener = (changes: GridCellChange[], source: GridEditSource) => void;
+
+export interface GridEditCommitChannel {
+    /** Passed to the commit paths (`useGridEditing`, `useGridBatchEdit`) as `onCommitted`. Stable. */
+    emit: CommitListener;
+    /** Set by `useGridUndoRedo`, which runs later in the hook order. Stable. */
+    setListener: (listener: CommitListener | null) => void;
+}
+
+/**
+ * Connects the commit paths, which run early in the hook order, to the history, which runs late
+ * (it needs the focus and selection hooks). Created before `useGridBatchEdit`.
+ */
+export function useGridEditCommitChannel(): GridEditCommitChannel {
+    const listenerRef = useRef<CommitListener | null>(null);
+    const emit = useCallback<CommitListener>((changes, source) => {
+        const listener = listenerRef.current;
+        if (listener) listener(changes, source);
+    }, []);
+    const setListener = useCallback((listener: CommitListener | null) => {
+        listenerRef.current = listener;
+    }, []);
+    return useMemo(() => ({ emit, setListener }), [emit, setListener]);
+}
+
+export interface UseGridUndoRedoParams<R extends GridRowModel> {
+    apiRef: MutableRefObject<GridApi>;
+    enabled: boolean;
+    limit: number;
+    onHistoryChange?: (params: GridHistoryChangeParams) => void;
+    channel: GridEditCommitChannel;
+    batchEdit: UseGridBatchEditReturn<R>;
+    isEditing: boolean;
+    containerRef: RefObject<HTMLDivElement | null>;
+    viewportRef: RefObject<HTMLDivElement | null>;
+    selection: UseGridCellSelectionReturn;
+    setFocusedCell: React.Dispatch<React.SetStateAction<FocusedCell | null>>;
+    allRenderableRows: R[];
+    getRowId: (row: R) => GridRowId;
+    navigationColumns: ReadonlyArray<GridColDef<R>>;
+    layout: LayoutResult<R>;
+    rowHeight: number;
+    pinnedTopRowCount: number;
+}
+
+const emptyResult = (): GridBatchEditResult => ({ updated: [], failed: [], skipped: [] });
+
+/** 'undo', 'redo' or null for a keydown. Ctrl/Cmd+Z, Ctrl/Cmd+Shift+Z, Ctrl+Y (also on non-Latin layouts). */
+function historyShortcut(event: KeyboardEvent): 'undo' | 'redo' | null {
+    if (event.altKey || !(event.ctrlKey || event.metaKey)) return null;
+    const key = (event.key ?? '').toLowerCase();
+    const latin = /^[a-z]$/.test(key);
+    const isZ = key === 'z' || (!latin && event.code === 'KeyZ');
+    const isY = key === 'y' || (!latin && event.code === 'KeyY');
+    if (isZ) return event.shiftKey ? 'redo' : 'undo';
+    if (isY && event.ctrlKey && !event.shiftKey) return 'redo';
+    return null;
+}
+
+/**
+ * Undo / redo of cell edits, pastes and range clears (`undoRedo`, v3.4). An action is recorded only
+ * after `processRowUpdate` succeeded, as the changed cells with their value before and the stored
+ * value after. Undo writes the `before` values as a batch edit (so `valueSetter` and
+ * `processRowUpdate` run); a cell that no longer holds its `after` value is skipped (`'changed'`), a
+ * row that is gone too (`'missing'`). Redo is the reverse. Runs after useGridClipboardPaste.
+ */
+export function useGridUndoRedo<R extends GridRowModel>(params: UseGridUndoRedoParams<R>): void {
+    const { apiRef, enabled, channel, containerRef } = params;
+    const latestRef = useRef(params);
+    useLayoutEffect(() => {
+        latestRef.current = params;
+    });
+
+    const undoStackRef = useRef<GridCellChange[][]>([]);
+    const redoStackRef = useRef<GridCellChange[][]>([]);
+    const lastEmittedRef = useRef<GridHistoryChangeParams>({ canUndo: false, canRedo: false, size: 0 });
+    // Undo and redo run one after the other, each on the rows the previous one stored.
+    const queueRef = useRef<Promise<unknown>>(Promise.resolve());
+
+    const notify = useCallback(() => {
+        const next = {
+            canUndo: undoStackRef.current.length > 0,
+            canRedo: redoStackRef.current.length > 0,
+            size: undoStackRef.current.length,
+        };
+        const last = lastEmittedRef.current;
+        if (last.canUndo === next.canUndo && last.canRedo === next.canRedo && last.size === next.size) return;
+        lastEmittedRef.current = next;
+        latestRef.current.onHistoryChange?.(next);
+    }, []);
+
+    const record = useCallback((changes: GridCellChange[]) => {
+        if (!latestRef.current.enabled || changes.length === 0) return;
+        const stack = undoStackRef.current;
+        stack.push(changes);
+        const limit = Math.max(1, latestRef.current.limit);
+        if (stack.length > limit) stack.splice(0, stack.length - limit);
+        redoStackRef.current = [];
+        notify();
+    }, [notify]);
+
+    useLayoutEffect(() => {
+        channel.setListener(enabled ? record : null);
+        return () => channel.setListener(null);
+    }, [channel, enabled, record]);
+
+    const clearHistory = useCallback(() => {
+        undoStackRef.current = [];
+        redoStackRef.current = [];
+        notify();
+    }, [notify]);
+
+    // Turning undoRedo off forgets the history.
+    useEffect(() => {
+        if (!enabled) clearHistory();
+    }, [enabled, clearHistory]);
+
+    /** Selects the affected cells (their bounding rectangle) and scrolls its first cell into view. */
+    const reveal = useCallback((cells: GridCellChange[]) => {
+        const p = latestRef.current;
+        const ctx = buildEditTargetContext(p.allRenderableRows, p.getRowId, p.navigationColumns);
+        const rect = boundingTargetRect(ctx, cells);
+        if (!rect) return;
+        const { anchor, head } = rectCorners(ctx, rect);
+        if (p.selection.enabled) p.selection.setModel([{ anchor, head }], 'keyboard');
+        else p.setFocusedCell({ id: anchor.id, field: anchor.field, rowIndex: rect.top });
+        const viewport = p.viewportRef.current;
+        if (!viewport) return;
+        scrollRowIntoView(viewport, rect.top - p.pinnedTopRowCount, p.layout.cumulativeHeights, p.layout.pinnedBottomHeight, p.rowHeight);
+        scrollColumnIntoView(viewport, p.layout.unpinnedColsWithWidth.findIndex(c => c.field === anchor.field), p.layout);
+    }, []);
+
+    /** Replays the top action of one stack onto the other. */
+    const replay = useCallback((direction: 'undo' | 'redo'): Promise<GridBatchEditResult> => {
+        const run = async (): Promise<GridBatchEditResult> => {
+            if (!latestRef.current.enabled) return emptyResult();
+            const from = direction === 'undo' ? undoStackRef : redoStackRef;
+            const to = direction === 'undo' ? redoStackRef : undoStackRef;
+            const action = from.current.pop();
+            if (!action) return emptyResult();
+            notify();
+            // Undo writes `before` where `after` still holds; redo writes `after` where `before` holds.
+            const edits = action.map(change => direction === 'undo'
+                ? { id: change.id, field: change.field, value: change.before, expect: { value: change.after } }
+                : { id: change.id, field: change.field, value: change.after, expect: { value: change.before } });
+            const outcome = await latestRef.current.batchEdit.applyEdits(edits, direction);
+            if (outcome.committed.length > 0) {
+                // The opposite action: for an undo, `before` is what it stored and `after` what it replaced.
+                to.current.push(direction === 'undo'
+                    ? outcome.committed.map(c => ({ id: c.id, field: c.field, before: c.after, after: c.before }))
+                    : outcome.committed);
+            }
+            // Rows whose processRowUpdate failed keep their part of the action, to try again.
+            const failedIds = new Set<GridRowId>(outcome.result.failed.map(f => f.id));
+            if (failedIds.size > 0) {
+                const remainder = action.filter(change => failedIds.has(change.id));
+                if (remainder.length > 0) from.current.push(remainder);
+            }
+            notify();
+            if (outcome.committed.length > 0) reveal(outcome.committed);
+            return outcome.result;
+        };
+        const next = queueRef.current.then(run, run);
+        queueRef.current = next;
+        return next;
+    }, [notify, reveal]);
+
+    const undo = useCallback(() => replay('undo'), [replay]);
+    const redo = useCallback(() => replay('redo'), [replay]);
+
+    useEffect(() => {
+        const root = containerRef.current;
+        if (!root || !enabled) return;
+        const onKeyDown = (event: KeyboardEvent) => {
+            if (event.defaultPrevented) return;
+            const shortcut = historyShortcut(event);
+            if (!shortcut) return;
+            const viewport = latestRef.current.viewportRef.current;
+            if (!viewport || latestRef.current.isEditing) return;
+            // Inside an editor or a text field the input's own undo wins.
+            const kind = classifyKeyTarget(event.target, viewport);
+            if (kind !== 'grid' && kind !== 'control') return;
+            event.preventDefault();
+            void (shortcut === 'undo' ? undo() : redo());
+        };
+        root.addEventListener('keydown', onKeyDown);
+        return () => root.removeEventListener('keydown', onKeyDown);
+    }, [containerRef, enabled, undo, redo]);
+
+    useLayoutEffect(() => {
+        const api = apiRef.current;
+        api.undo = undo;
+        api.redo = redo;
+        api.canUndo = () => latestRef.current.enabled && undoStackRef.current.length > 0;
+        api.canRedo = () => latestRef.current.enabled && redoStackRef.current.length > 0;
+        api.clearHistory = clearHistory;
+    }, [apiRef, undo, redo, clearHistory]);
+}

package/lib/hooks/features/useGridBatchEdit.ts

@@ -0,0 +1,217 @@
+import { useCallback, useLayoutEffect, useMemo, useRef } from 'react';
+import type { GridBatchEditResult, GridColDef, GridEditSkipReason, GridRowId, GridRowModel } from '../../types';
+import { attempt } from '../../utils/attempt';
+import { getCellValue } from '../../utils/values';
+import {
+    buildEditedRow,
+    invalidProcessedRowError,
+    isPromiseLike,
+    isSameValue,
+    reportEditError,
+} from '../../utils/editing/commit';
+import type { GridCellChange } from '../../utils/editing/commit';
+
+/** What made a commit: history records `edit`, `paste` and `clear`; `undo` / `redo` replay it. */
+export type GridEditSource = 'edit' | 'paste' | 'clear' | 'undo' | 'redo';
+
+/** One cell to write in a batch edit. */
+export interface GridBatchCellEdit {
+    id: GridRowId;
+    field: string;
+    value: unknown;
+    /**
+     * Undo/redo: the value the cell must still hold. When it holds something else the cell is
+     * skipped with reason `'changed'` (values are compared, not row objects).
+     */
+    expect?: { value: unknown };
+}
+
+/** A batch edit's result, plus the cell changes that were stored (what history records). */
+export interface GridBatchEditOutcome {
+    result: GridBatchEditResult;
+    committed: GridCellChange[];
+}
+
+export interface UseGridBatchEditParams<R extends GridRowModel> {
+    /** The rendered row store (`state.rows.idRowsLookup`). */
+    rowsLookup: ReadonlyMap<GridRowId, R>;
+    columns: GridColDef<R>[];
+    processRowUpdate?: (newRow: R, oldRow: R) => R | Promise<R>;
+    onProcessRowUpdateError?: (error: unknown) => void;
+    /** Stores rows in one update (`replaceRows` of the row store). */
+    replaceRows: (rows: ReadonlyMap<GridRowId, R>) => void;
+    /** Receives the stored changes of every commit that is not an undo or redo (history). */
+    onCommitted?: (changes: GridCellChange[], source: GridEditSource) => void;
+}
+
+export interface UseGridBatchEditReturn<R extends GridRowModel> {
+    /**
+     * Writes cells through `valueSetter` → `processRowUpdate` (once per row, rows in parallel) →
+     * the store (one update for every row that succeeded). A row that throws or rejects is reported
+     * to `onProcessRowUpdateError` and does not stop the others. Cells whose value does not change
+     * are left alone. Resolves when every row has settled.
+     */
+    applyEdits: (edits: readonly GridBatchCellEdit[], source: GridEditSource) => Promise<GridBatchEditOutcome>;
+    /** The latest row under `id`, including rows stored but not rendered yet. */
+    getRow: (id: GridRowId) => R | undefined;
+    /** Stores one committed row (a single-cell edit), so `getRow` sees it before the next render. */
+    storeRow: (id: GridRowId, row: R) => void;
+}
+
+interface RowCell<R extends GridRowModel> {
+    field: string;
+    value: unknown;
+    colDef: GridColDef<R> | undefined;
+    order: number;
+}
+
+interface RowGroup<R extends GridRowModel> {
+    id: GridRowId;
+    row: R;
+    cells: RowCell<R>[];
+}
+
+type Settled = { id: GridRowId; ok: true; processed: unknown } | { id: GridRowId; ok: false; error: unknown };
+
+/**
+ * Batch edits: several cells committed together through the single-edit pipeline (paste, range clear,
+ * undo, redo). One `processRowUpdate` per row, one store update for the batch, failures isolated per
+ * row and reported through the same path as single edits. The returned functions are stable.
+ */
+export function useGridBatchEdit<R extends GridRowModel>(params: UseGridBatchEditParams<R>): UseGridBatchEditReturn<R> {
+    const latestRef = useRef(params);
+    // Rows stored since the last render. The rendered lookup catches up on the next render, when
+    // this is emptied; until then an undo right after a paste still reads the pasted rows.
+    const overlayRef = useRef(new Map<GridRowId, R>());
+    const warnedFieldsRef = useRef(new Set<string>());
+    useLayoutEffect(() => {
+        latestRef.current = params;
+        overlayRef.current.clear();
+    });
+
+    const getRow = useCallback((id: GridRowId): R | undefined => {
+        const pending = overlayRef.current.get(id);
+        return pending === undefined ? latestRef.current.rowsLookup.get(id) : pending;
+    }, []);
+
+    const store = useCallback((rows: Map<GridRowId, R>) => {
+        if (rows.size === 0) return;
+        rows.forEach((row, id) => { overlayRef.current.set(id, row); });
+        latestRef.current.replaceRows(rows);
+    }, []);
+
+    const storeRow = useCallback((id: GridRowId, row: R) => {
+        store(new Map([[id, row]]));
+    }, [store]);
+
+    const applyEdits = useCallback((edits: readonly GridBatchCellEdit[], source: GridEditSource): Promise<GridBatchEditOutcome> => {
+        const { columns, processRowUpdate } = latestRef.current;
+        const report = (error: unknown) => reportEditError(error, latestRef.current.onProcessRowUpdateError);
+        const columnOrder = new Map<string, number>();
+        const columnByField = new Map<string, GridColDef<R>>();
+        columns.forEach((col, index) => {
+            columnOrder.set(col.field, index);
+            columnByField.set(col.field, col);
+        });
+
+        const skipped: { id: GridRowId; field: string; reason: GridEditSkipReason }[] = [];
+        const groups = new Map<GridRowId, RowGroup<R>>();
+        for (const edit of edits) {
+            const row = getRow(edit.id);
+            if (row === undefined) {
+                skipped.push({ id: edit.id, field: edit.field, reason: 'missing' });
+                continue;
+            }
+            const colDef = columnByField.get(edit.field);
+            if (edit.expect && !isSameValue(getCellValue(row, edit.field, colDef), edit.expect.value)) {
+                skipped.push({ id: edit.id, field: edit.field, reason: 'changed' });
+                continue;
+            }
+            let group = groups.get(edit.id);
+            if (!group) {
+                group = { id: edit.id, row, cells: [] };
+                groups.set(edit.id, group);
+            }
+            const order = columnOrder.get(edit.field) ?? Number.MAX_SAFE_INTEGER;
+            const existing = group.cells.findIndex(cell => cell.field === edit.field);
+            const cell = { field: edit.field, value: edit.value, colDef, order };
+            // The same cell twice: the last value wins.
+            if (existing === -1) group.cells.push(cell);
+            else group.cells[existing] = cell;
+        }
+
+        const settled: Settled[] = [];
+        const pending: Promise<Settled>[] = [];
+        const warned = warnedFieldsRef.current;
+        groups.forEach(group => {
+            const { id, row } = group;
+            // Cells that already hold the value are not written; a row with none left is left alone.
+            const cells = group.cells
+                .filter(cell => !isSameValue(getCellValue(row, cell.field, cell.colDef), cell.value))
+                .sort((a, b) => a.order - b.order);
+            group.cells = cells;
+            if (cells.length === 0) return;
+            const outcome = attempt<unknown>(() => {
+                let newRow = row;
+                for (const cell of cells) newRow = buildEditedRow(newRow, cell, cell.colDef, warned);
+                return processRowUpdate ? processRowUpdate(newRow, row) : newRow;
+            });
+            if (!outcome.ok) {
+                settled.push({ id, ok: false, error: outcome.error });
+                return;
+            }
+            const value = outcome.value;
+            if (isPromiseLike(value)) {
+                pending.push(Promise.resolve(value).then(
+                    (processed): Settled => ({ id, ok: true, processed }),
+                    (error: unknown): Settled => ({ id, ok: false, error }),
+                ));
+            } else {
+                settled.push({ id, ok: true, processed: value });
+            }
+        });
+
+        const finish = (all: Settled[]): GridBatchEditOutcome => {
+            const byId = new Map<GridRowId, Settled>();
+            all.forEach(entry => { byId.set(entry.id, entry); });
+            const updated: GridRowId[] = [];
+            const failed: { id: GridRowId; error: unknown }[] = [];
+            const committed: GridCellChange[] = [];
+            const stored = new Map<GridRowId, R>();
+            groups.forEach(group => {
+                const entry = byId.get(group.id);
+                if (!entry) return;
+                if (!entry.ok) {
+                    failed.push({ id: group.id, error: entry.error });
+                    report(entry.error);
+                    return;
+                }
+                const processed = entry.processed;
+                if (typeof processed !== 'object' || processed === null) {
+                    const error = invalidProcessedRowError(processed, 'The row was not saved.');
+                    failed.push({ id: group.id, error });
+                    report(error);
+                    return;
+                }
+                const storedRow = processed as R;
+                stored.set(group.id, storedRow);
+                updated.push(group.id);
+                for (const cell of group.cells) {
+                    const before = getCellValue(group.row, cell.field, cell.colDef);
+                    const after = getCellValue(storedRow, cell.field, cell.colDef);
+                    if (!isSameValue(before, after)) committed.push({ id: group.id, field: cell.field, before, after });
+                }
+            });
+            store(stored);
+            if (committed.length > 0 && source !== 'undo' && source !== 'redo') {
+                latestRef.current.onCommitted?.(committed, source);
+            }
+            return { result: { updated, failed, skipped }, committed };
+        };
+
+        if (pending.length === 0) return Promise.resolve(finish(settled));
+        return Promise.all(pending).then(results => finish([...settled, ...results]));
+    }, [getRow, store]);
+
+    return useMemo(() => ({ applyEdits, getRow, storeRow }), [applyEdits, getRow, storeRow]);
+}

package/lib/hooks/features/useGridEditing.ts

@@ -1,6 +1,15 @@
 import { useState, useCallback, useRef, useEffect, useLayoutEffect, useMemo } from 'react';
 import type { GridColDef, GridRowId, GridRowModel } from '../../types';
 import { attempt } from '../../utils/attempt';
+import { getCellValue } from '../../utils/values';
+import {
+    buildEditedRow,
+    invalidProcessedRowError,
+    isPromiseLike,
+    isSameValue,
+    reportEditError,
+} from '../../utils/editing/commit';
+import type { GridCellChange } from '../../utils/editing/commit';
 
 export interface GridEditingState {
     editingCell: {
@@ -23,6 +32,12 @@ export interface UseGridEditingParams<R extends GridRowModel> {
      * grid resolved with getRowId), not on a field of the returned row.
      */
     onRowChange?: (newRow: R, id: GridRowId) => void;
+    /**
+     * Receives the cell change once `processRowUpdate` succeeded and the row was stored (undo/redo
+     * history): the value before and the stored value, both read through `getCellValue`. Not called
+     * when the stored value equals the previous one.
+     */
+    onCommitted?: (changes: GridCellChange[]) => void;
 }
 
 export interface StopCellEditParams {
@@ -46,18 +61,6 @@ interface PendingCommit {
 
 const RESOLVED: Promise<void> = Promise.resolve();
 
-/** A misuse of the editing contract (e.g. processRowUpdate returned nothing), as opposed to a consumer rejection. */
-class OpenGridXEditError extends Error {}
-
-function isSameValue(a: unknown, b: unknown): boolean {
-    if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
-    return Object.is(a, b);
-}
-
-function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
-    return typeof value === 'object' && value !== null && typeof (value as { then?: unknown }).then === 'function';
-}
-
 /**
  * Cell edit sessions and their commits.
  *
@@ -126,24 +129,21 @@ export function useGridEditing<R extends GridRowModel>(params: UseGridEditingPar
             return RESOLVED;
         }
 
-        const report = (error: unknown) => {
-            const onError = latestRef.current.onProcessRowUpdateError;
-            if (onError) {
-                onError(error);
-            } else if (process.env.NODE_ENV !== 'production' && error instanceof OpenGridXEditError) {
-                console.error(error.message);
-            }
-        };
+        const report = (error: unknown) => reportEditError(error, latestRef.current.onProcessRowUpdateError);
+        const colDef = columns?.find(c => c.field === cell.field);
 
         const apply = (processed: unknown) => {
             if (typeof processed !== 'object' || processed === null) {
-                report(new OpenGridXEditError(
-                    `[OpenGridX] processRowUpdate must return the updated row object (or a Promise of it); ` +
-                    `it returned ${processed === null ? 'null' : typeof processed}. The edit was not saved and the editor stays open.`
-                ));
+                report(invalidProcessedRowError(processed, 'The edit was not saved and the editor stays open.'));
                 return;
             }
             latestRef.current.onRowChange?.(processed as R, cell.id);
+            const { onCommitted } = latestRef.current;
+            if (onCommitted) {
+                const before = getCellValue(existingRow, cell.field, colDef);
+                const after = getCellValue(processed as R, cell.field, colDef);
+                if (!isSameValue(before, after)) onCommitted([{ id: cell.id, field: cell.field, before, after }]);
+            }
             const now = editingCellRef.current;
             if (sessionRef.current !== token || !now) return;
             if (isSameValue(now.value, cell.value)) {
@@ -164,7 +164,6 @@ export function useGridEditing<R extends GridRowModel>(params: UseGridEditingPar
             if (pendingRef.current.get(token) === entry) pendingRef.current.delete(token);
         };
 
-        const colDef = columns?.find(c => c.field === cell.field);
         const outcome = attempt<unknown>(() => {
             const newRow = buildEditedRow(existingRow, cell, colDef, warnedFieldsRef.current);
             return processRowUpdate ? processRowUpdate(newRow, existingRow) : newRow;
@@ -246,23 +245,3 @@ export function useGridEditing<R extends GridRowModel>(params: UseGridEditingPar
         setEditCellValue
     }), [editingCell, startCellEdit, stopCellEdit, setEditCellValue]);
 }
-
-function buildEditedRow<R extends GridRowModel>(
-    row: R,
-    cell: EditingCell,
-    colDef: GridColDef<R> | undefined,
-    warnedFields: Set<string>
-): R {
-    if (colDef?.valueSetter) {
-        return colDef.valueSetter({ value: cell.value, row, field: cell.field });
-    }
-    if (colDef?.valueGetter && process.env.NODE_ENV !== 'production' && !warnedFields.has(cell.field)) {
-        warnedFields.add(cell.field);
-        console.warn(
-            `[OpenGridX] Column "${cell.field}" is editable and has a valueGetter but no valueSetter. ` +
-            `The edited value was written to row["${cell.field}"], which the valueGetter may ignore, so the cell ` +
-            'can keep showing the old value. Add a valueSetter that maps the value back onto the row.'
-        );
-    }
-    return { ...row, [cell.field]: cell.value };
-}

package/lib/index.ts

@@ -93,6 +93,7 @@ export type {
     GridValueGetterParams,
     GridSortCellParams,
     GridValueSetterParams,
+    GridValueParserParams,
     GridValueFormatterParams,
     GridRowParams,
     GridCellParams,
@@ -108,6 +109,12 @@ export type {
     GridCellSelectionChangeDetails,
     GridSelectedCell,
     GridCellSelectionStatsSlotProps,
+    GridEditSkipReason,
+    GridBatchEditResult,
+    GridClipboardPasteResult,
+    GridBeforeClipboardPasteParams,
+    GridHistoryChangeParams,
+    GridUndoRedoOptions,
     GridColumnOrder,
     GridColumnOrderChangeParams,
     GridRowOrderChangeParams,

package/lib/styles/opengridx.css

@@ -1,5 +1,7 @@
 @import './base/variables.css';
 @import './base/reset.css';
+/* Shared primitives first, so component styles that restyle them win on equal specificity. */
+@import '../components/ui/Input.css';
 @import '../components/DataGrid/DataGrid.css';
 @import '../components/Header/Header.css';
 @import '../components/Row/Row.css';
@@ -16,7 +18,6 @@
 @import '../components/ui/Checkbox.css';
 @import '../components/ui/DragHandleIcon.css';
 @import '../components/ui/ExpandIcon.css';
-@import '../components/ui/Input.css';
 @import '../components/Toolbar/GridToolbar.css';
 @import '../components/Toolbar/PivotPanel.css';
 @import '../components/FilterPanel/FilterPanel.css';