@svgrid/grid 1.1.1 → 1.2.1

package/dist/editing.test.js

@@ -1,732 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { createEditing } from './editing';
-function makeCtx(opts = {}) {
-    const columns = opts.columns ?? [
-        { id: 'a', field: 'a', editable: true, editorType: 'text' },
-        { id: 'b', field: 'b', editable: true, editorType: 'number' },
-    ];
-    const data = (opts.data ?? [
-        { a: 'a0', b: 0 },
-        { a: 'a1', b: 1 },
-    ]).map((d) => ({ ...d }));
-    const allColumns = columns.map((c) => ({
-        id: c.id,
-        columnDef: {
-            field: c.field,
-            editable: c.editable,
-            editorType: c.editorType,
-            editorMultiple: c.editorMultiple,
-        },
-    }));
-    let activeCell = null;
-    const buildRows = (rows) => rows.map((row, index) => ({
-        id: String(index),
-        original: row,
-        getCanExpand: () => opts.groupRows?.has(index) ?? false,
-        getCellValueByColumnId: (colId) => row[colId],
-    }));
-    let backing = data;
-    const ctx = {
-        allColumns,
-        _rows: buildRows(data),
-        get allRows() {
-            return ctx._rows;
-        },
-        editingEnabled: opts.editingEnabled ?? true,
-        editingCell: null,
-        editorSelectAll: false,
-        editedCellValues: {},
-        selectionRange: { anchor: null, focus: null },
-        gridRootEl: null,
-        props: {},
-        history: [],
-        historyPtr: -1,
-        historyVersion: 0,
-        UNDO_LIMIT: 100,
-        activeCalls: [],
-        selectionCalls: [],
-        setActiveCell: (r, c) => {
-            activeCell = { rowIndex: r, colIndex: c };
-            ctx.activeCalls.push([r, c]);
-        },
-        setSelection: (r, c) => {
-            ctx.selectionCalls.push([r, c]);
-        },
-        grid: {
-            getState: () => ({ activeCell }),
-            store: { setState: vi.fn() },
-        },
-    };
-    Object.defineProperty(ctx, 'internalData', {
-        get: () => backing,
-        set: (next) => {
-            backing = next;
-            ctx._rows = buildRows(next);
-        },
-    });
-    ctx.internalData = data;
-    return ctx;
-}
-const editingFor = (opts) => {
-    const ctx = makeCtx(opts);
-    return { ctx, ed: createEditing(ctx) };
-};
-describe('isCellEditable', () => {
-    it('treats undefined editable as editable', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a' }],
-            data: [{ a: 1 }],
-        });
-        expect(ed.isCellEditable(ctx.allColumns[0], ctx.allRows[0])).toBe(true);
-    });
-    it('treats editable:false as locked (fast path, no row needed)', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editable: false }],
-        });
-        expect(ed.isCellEditable(ctx.allColumns[0])).toBe(false);
-    });
-    it('honours a cell-level predicate returning false', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editable: () => false }],
-            data: [{ a: 1 }],
-        });
-        expect(ed.isCellEditable(ctx.allColumns[0], ctx.allRows[0])).toBe(false);
-    });
-    it('honours a cell-level predicate returning true', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editable: (cc) => cc.row.id === '0' }],
-            data: [{ a: 1 }],
-        });
-        expect(ed.isCellEditable(ctx.allColumns[0], ctx.allRows[0])).toBe(true);
-    });
-    it('passes a usable CellContext to the predicate', () => {
-        const spy = vi.fn().mockReturnValue(true);
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editable: spy }],
-            data: [{ a: 'hello' }],
-        });
-        ed.isCellEditable(ctx.allColumns[0], ctx.allRows[0]);
-        const cc = spy.mock.calls[0][0];
-        expect(cc.getValue()).toBe('hello');
-        expect(cc.cell.getValue()).toBe('hello');
-        expect(cc.cell.getContext()).toBe(cc);
-        expect(cc.column).toBe(ctx.allColumns[0]);
-    });
-    it('returns editable when predicate exists but no row supplied', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editable: () => false }],
-        });
-        // No row -> cannot evaluate predicate -> defaults to editable.
-        expect(ed.isCellEditable(ctx.allColumns[0])).toBe(true);
-    });
-    it('biases to not-editable when the predicate throws', () => {
-        const { ctx, ed } = editingFor({
-            columns: [
-                {
-                    id: 'a',
-                    field: 'a',
-                    editable: () => {
-                        throw new Error('boom');
-                    },
-                },
-            ],
-            data: [{ a: 1 }],
-        });
-        expect(ed.isCellEditable(ctx.allColumns[0], ctx.allRows[0])).toBe(false);
-    });
-});
-describe('isCellEditableAt', () => {
-    it('resolves row/column by index then defers to isCellEditable', () => {
-        const { ed } = editingFor({
-            columns: [
-                { id: 'a', field: 'a', editable: true },
-                { id: 'b', field: 'b', editable: false },
-            ],
-            data: [{ a: 1, b: 2 }],
-        });
-        expect(ed.isCellEditableAt(0, 0)).toBe(true);
-        expect(ed.isCellEditableAt(0, 1)).toBe(false);
-    });
-    it('returns false when the column index is out of range', () => {
-        const { ed } = editingFor();
-        expect(ed.isCellEditableAt(0, 99)).toBe(false);
-    });
-});
-describe('getRowColumnValue', () => {
-    it('reads the base value when the column id is known', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a' }],
-            data: [{ a: 'x' }],
-        });
-        expect(ed.getRowColumnValue(ctx.allRows[0], 'a')).toBe('x');
-    });
-    it('falls back to row.getCellValueByColumnId for an unknown column', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a' }],
-            data: [{ a: 'x', ghost: 'g' }],
-        });
-        expect(ed.getRowColumnValue(ctx.allRows[0], 'ghost')).toBe('g');
-    });
-});
-describe('getCellDisplayValue', () => {
-    it('returns the base value when there is no pending edit', () => {
-        const { ed } = editingFor();
-        expect(ed.getCellDisplayValue('0', 'a', 'base')).toBe('base');
-    });
-    it('prefers an edited override keyed by rowId:colId', () => {
-        const { ctx, ed } = editingFor();
-        ctx.editedCellValues['0:a'] = 'edited';
-        expect(ed.getCellDisplayValue('0', 'a', 'base')).toBe('edited');
-    });
-    it('treats an explicit undefined override as present', () => {
-        const { ctx, ed } = editingFor();
-        ctx.editedCellValues['0:a'] = undefined;
-        expect(ed.getCellDisplayValue('0', 'a', 'base')).toBeUndefined();
-    });
-});
-describe('startEditingWithChar', () => {
-    it('seeds the editor with the typed character and sets active/selection', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'x' }],
-        });
-        expect(ed.startEditingWithChar(0, 0, 'Z')).toBe(true);
-        expect(ctx.editingCell).toEqual({
-            rowId: '0',
-            columnId: 'a',
-            editorType: 'text',
-            value: 'Z',
-        });
-        expect(ctx.editorSelectAll).toBe(false);
-        expect(ctx.activeCalls).toEqual([[0, 0]]);
-        expect(ctx.selectionCalls).toEqual([[0, 0]]);
-    });
-    it('defaults the editor type to text when none is declared', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a' }],
-            data: [{ a: 'x' }],
-        });
-        ed.startEditingWithChar(0, 0, 'k');
-        expect(ctx.editingCell.editorType).toBe('text');
-    });
-    it('returns false when editing is globally disabled', () => {
-        const { ctx, ed } = editingFor({ editingEnabled: false });
-        expect(ed.startEditingWithChar(0, 0, 'a')).toBe(false);
-        expect(ctx.editingCell).toBeNull();
-    });
-    it('returns false for a missing row or column', () => {
-        const { ed } = editingFor();
-        expect(ed.startEditingWithChar(99, 0, 'a')).toBe(false);
-        expect(ed.startEditingWithChar(0, 99, 'a')).toBe(false);
-    });
-    it('returns false for a group row', () => {
-        const { ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'x' }],
-            groupRows: new Set([0]),
-        });
-        expect(ed.startEditingWithChar(0, 0, 'a')).toBe(false);
-    });
-    it('returns false for a non-editable cell', () => {
-        const { ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editable: false, editorType: 'text' }],
-            data: [{ a: 'x' }],
-        });
-        expect(ed.startEditingWithChar(0, 0, 'a')).toBe(false);
-    });
-    it('rejects type-to-edit for checkbox/date/datetime/list/chips editors', () => {
-        for (const editorType of ['checkbox', 'date', 'datetime', 'list', 'chips']) {
-            const { ed } = editingFor({
-                columns: [{ id: 'a', field: 'a', editorType }],
-                data: [{ a: 'x' }],
-            });
-            expect(ed.startEditingWithChar(0, 0, 'a')).toBe(false);
-        }
-    });
-    it('rejects a non-numeric character on a number editor', () => {
-        const { ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'number' }],
-            data: [{ a: 1 }],
-        });
-        expect(ed.startEditingWithChar(0, 0, 'x')).toBe(false);
-    });
-    it('accepts a numeric character on a number editor', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'number' }],
-            data: [{ a: 1 }],
-        });
-        expect(ed.startEditingWithChar(0, 0, '7')).toBe(true);
-        expect(ctx.editingCell.value).toBe('7');
-    });
-});
-describe('saveEditingCell', () => {
-    it('does nothing when there is no editing cell', () => {
-        const { ctx, ed } = editingFor();
-        ed.saveEditingCell();
-        expect(ctx.grid.store.setState).not.toHaveBeenCalled();
-    });
-    it('parses, writes original, records edited value, and clears editing', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'b', field: 'b', editorType: 'number' }],
-            data: [{ b: 0 }],
-        });
-        ctx.editingCell = { rowId: '0', columnId: 'b', editorType: 'number', value: '42' };
-        ed.saveEditingCell();
-        expect(ctx.internalData[0].b).toBe(42); // parsed to number, written to original
-        expect(ctx.editedCellValues['0:b']).toBe(42);
-        expect(ctx.editingCell).toBeNull();
-        expect(ctx.grid.store.setState).toHaveBeenCalled();
-    });
-    it('coerces an unparseable number to null', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'b', field: 'b', editorType: 'number' }],
-            data: [{ b: 5 }],
-        });
-        ctx.editingCell = { rowId: '0', columnId: 'b', editorType: 'number', value: 'abc' };
-        ed.saveEditingCell();
-        expect(ctx.internalData[0].b).toBeNull();
-    });
-    it('respects editorMultiple when parsing list editors', () => {
-        const { ctx, ed } = editingFor({
-            columns: [
-                { id: 'a', field: 'a', editorType: 'list', editorMultiple: true },
-            ],
-            data: [{ a: [] }],
-        });
-        ctx.editingCell = {
-            rowId: '0',
-            columnId: 'a',
-            editorType: 'list',
-            value: ['x', 'y'],
-        };
-        ed.saveEditingCell();
-        expect(ctx.internalData[0].a).toEqual(['x', 'y']);
-    });
-    it('pushes a history step and bumps the version on a real change', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'old' }],
-        });
-        ctx.editingCell = { rowId: '0', columnId: 'a', editorType: 'text', value: 'new' };
-        ed.saveEditingCell();
-        expect(ctx.history).toHaveLength(1);
-        expect(ctx.history[0]).toMatchObject({
-            rowId: '0',
-            columnId: 'a',
-            field: 'a',
-            before: 'old',
-            after: 'new',
-        });
-        expect(ctx.historyPtr).toBe(0);
-        expect(ctx.historyVersion).toBe(1);
-    });
-    it('does not push history when the value is unchanged', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'same' }],
-        });
-        ctx.editingCell = { rowId: '0', columnId: 'a', editorType: 'text', value: 'same' };
-        ed.saveEditingCell();
-        expect(ctx.history).toHaveLength(0);
-        expect(ctx.historyVersion).toBe(0);
-    });
-    it('truncates forward (redo) history when editing after an undo', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'v0' }],
-        });
-        // Pretend there is forward history the user could have redone.
-        ctx.history = [
-            { rowId: '0', columnId: 'a', field: 'a', before: 'x', after: 'y' },
-            { rowId: '0', columnId: 'a', field: 'a', before: 'y', after: 'z' },
-        ];
-        ctx.historyPtr = 0; // pointer is behind the tail
-        ctx.editingCell = { rowId: '0', columnId: 'a', editorType: 'text', value: 'v1' };
-        ed.saveEditingCell();
-        // Forward step (index 1) dropped, new step appended at index 1.
-        expect(ctx.history).toHaveLength(2);
-        expect(ctx.history[1].after).toBe('v1');
-        expect(ctx.historyPtr).toBe(1);
-    });
-    it('caps the history at UNDO_LIMIT dropping the oldest entries', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'start' }],
-        });
-        ctx.UNDO_LIMIT = 3;
-        ctx.history = [
-            { rowId: '0', columnId: 'a', field: 'a', before: '0', after: '1' },
-            { rowId: '0', columnId: 'a', field: 'a', before: '1', after: '2' },
-            { rowId: '0', columnId: 'a', field: 'a', before: '2', after: '3' },
-        ];
-        ctx.historyPtr = 2;
-        ctx.editingCell = { rowId: '0', columnId: 'a', editorType: 'text', value: 'final' };
-        ed.saveEditingCell();
-        expect(ctx.history).toHaveLength(3); // capped
-        expect(ctx.history[2].after).toBe('final'); // newest kept
-        expect(ctx.history[0].after).toBe('2'); // oldest dropped
-        expect(ctx.historyPtr).toBe(2);
-    });
-    it('fires onCellValueChange with the post-write payload', () => {
-        const onCellValueChange = vi.fn();
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'before' }],
-        });
-        ctx.props.onCellValueChange = onCellValueChange;
-        ctx.editingCell = { rowId: '0', columnId: 'a', editorType: 'text', value: 'after' };
-        ed.saveEditingCell();
-        expect(onCellValueChange).toHaveBeenCalledWith(expect.objectContaining({
-            rowIndex: 0,
-            columnId: 'a',
-            oldValue: 'before',
-            newValue: 'after',
-        }));
-    });
-    it('clears editing even when row/column cannot be resolved', () => {
-        const { ctx, ed } = editingFor();
-        ctx.editingCell = {
-            rowId: 'missing',
-            columnId: 'missing',
-            editorType: 'text',
-            value: 'x',
-        };
-        ed.saveEditingCell();
-        expect(ctx.editingCell).toBeNull();
-        expect(ctx.history).toHaveLength(0);
-    });
-});
-describe('applyHistoryStep', () => {
-    const step = {
-        rowId: '0',
-        columnId: 'a',
-        field: 'a',
-        before: 'B',
-        after: 'A',
-    };
-    it('applies the before value on undo', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'A' }],
-        });
-        ed.applyHistoryStep(step, 'undo');
-        expect(ctx.internalData[0].a).toBe('B');
-        expect(ctx.editedCellValues['0:a']).toBe('B');
-        expect(ctx.grid.store.setState).toHaveBeenCalled();
-    });
-    it('applies the after value on redo', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'B' }],
-        });
-        ed.applyHistoryStep(step, 'redo');
-        expect(ctx.internalData[0].a).toBe('A');
-    });
-    it('fires onCellValueChange with swapped old/new on undo', () => {
-        const onCellValueChange = vi.fn();
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'A' }],
-        });
-        ctx.props.onCellValueChange = onCellValueChange;
-        ed.applyHistoryStep(step, 'undo');
-        expect(onCellValueChange).toHaveBeenCalledWith(expect.objectContaining({ oldValue: 'A', newValue: 'B' }));
-    });
-    it('is a no-op when the row or column is missing', () => {
-        const { ctx, ed } = editingFor();
-        ed.applyHistoryStep({ rowId: 'nope', columnId: 'a', field: 'a', before: 1, after: 2 }, 'undo');
-        expect(ctx.grid.store.setState).not.toHaveBeenCalled();
-    });
-});
-describe('updateEditingCellValue', () => {
-    it('updates the value while preserving the rest of the editing cell', () => {
-        const { ctx, ed } = editingFor();
-        ctx.editingCell = { rowId: '0', columnId: 'a', editorType: 'text', value: 'old' };
-        ed.updateEditingCellValue('new');
-        expect(ctx.editingCell).toEqual({
-            rowId: '0',
-            columnId: 'a',
-            editorType: 'text',
-            value: 'new',
-        });
-    });
-    it('leaves a null editing cell untouched', () => {
-        const { ctx, ed } = editingFor();
-        ed.updateEditingCellValue('x');
-        expect(ctx.editingCell).toBeNull();
-    });
-});
-describe('onEditorKeyDown', () => {
-    function fakeEvent(key) {
-        return {
-            key,
-            stopPropagation: vi.fn(),
-            preventDefault: vi.fn(),
-        };
-    }
-    it('Enter saves the cell and refocuses the grid root', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'old' }],
-        });
-        const focus = vi.fn();
-        ctx.gridRootEl = { focus };
-        ctx.editingCell = { rowId: '0', columnId: 'a', editorType: 'text', value: 'new' };
-        const ev = fakeEvent('Enter');
-        ed.onEditorKeyDown(ev);
-        expect(ev.stopPropagation).toHaveBeenCalled();
-        expect(ev.preventDefault).toHaveBeenCalled();
-        expect(ctx.internalData[0].a).toBe('new');
-        expect(ctx.editingCell).toBeNull();
-        expect(focus).toHaveBeenCalledWith({ preventScroll: true });
-    });
-    it('Escape cancels without saving and refocuses the grid root', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'old' }],
-        });
-        const focus = vi.fn();
-        ctx.gridRootEl = { focus };
-        ctx.editingCell = { rowId: '0', columnId: 'a', editorType: 'text', value: 'discard' };
-        const ev = fakeEvent('Escape');
-        ed.onEditorKeyDown(ev);
-        expect(ctx.internalData[0].a).toBe('old'); // unchanged
-        expect(ctx.editingCell).toBeNull();
-        expect(focus).toHaveBeenCalled();
-    });
-    it('stops propagation for other keys without saving or cancelling', () => {
-        const { ctx, ed } = editingFor();
-        ctx.editingCell = { rowId: '0', columnId: 'a', editorType: 'text', value: 'x' };
-        const ev = fakeEvent('a');
-        ed.onEditorKeyDown(ev);
-        expect(ev.stopPropagation).toHaveBeenCalled();
-        expect(ev.preventDefault).not.toHaveBeenCalled();
-        expect(ctx.editingCell).not.toBeNull();
-    });
-    it('tolerates a null gridRootEl on Escape', () => {
-        const { ctx, ed } = editingFor();
-        ctx.gridRootEl = null;
-        ctx.editingCell = { rowId: '0', columnId: 'a', editorType: 'text', value: 'x' };
-        expect(() => ed.onEditorKeyDown(fakeEvent('Escape'))).not.toThrow();
-        expect(ctx.editingCell).toBeNull();
-    });
-});
-describe('focusOnMount', () => {
-    let rafCb = null;
-    beforeEach(() => {
-        rafCb = null;
-        vi.stubGlobal('requestAnimationFrame', (cb) => {
-            rafCb = cb;
-            return 1;
-        });
-    });
-    function fakeInput(value) {
-        return {
-            value,
-            focus: vi.fn(),
-            select: vi.fn(),
-            setSelectionRange: vi.fn(),
-        };
-    }
-    it('selects all when editorSelectAll is set', () => {
-        const { ctx, ed } = editingFor();
-        ctx.editorSelectAll = true;
-        const node = fakeInput('hello');
-        ed.focusOnMount(node);
-        rafCb?.(0);
-        expect(node.focus).toHaveBeenCalledWith({ preventScroll: true });
-        expect(node.select).toHaveBeenCalled();
-        expect(node.setSelectionRange).not.toHaveBeenCalled();
-    });
-    it('places the caret at the end when not selecting all', () => {
-        const { ctx, ed } = editingFor();
-        ctx.editorSelectAll = false;
-        const node = fakeInput('hello');
-        ed.focusOnMount(node);
-        rafCb?.(0);
-        expect(node.setSelectionRange).toHaveBeenCalledWith(5, 5);
-        expect(node.select).not.toHaveBeenCalled();
-    });
-    it('swallows errors from inputs that reject selection ranges', () => {
-        const { ctx, ed } = editingFor();
-        ctx.editorSelectAll = false;
-        const node = {
-            value: '2020-01-01',
-            focus: vi.fn(),
-            select: vi.fn(),
-            setSelectionRange: () => {
-                throw new Error('unsupported');
-            },
-        };
-        ed.focusOnMount(node);
-        expect(() => rafCb?.(0)).not.toThrow();
-        expect(node.focus).toHaveBeenCalled();
-    });
-});
-describe('onCellDoubleClick', () => {
-    it('enters edit mode seeded with the current display value', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'val' }],
-        });
-        ed.onCellDoubleClick(0, 0);
-        expect(ctx.editorSelectAll).toBe(true);
-        expect(ctx.editingCell).toEqual({
-            rowId: '0',
-            columnId: 'a',
-            editorType: 'text',
-            value: 'val',
-        });
-        expect(ctx.activeCalls).toEqual([[0, 0]]);
-        expect(ctx.selectionCalls).toEqual([[0, 0]]);
-    });
-    it('prefers an edited override as the seed value', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'base' }],
-        });
-        ctx.editedCellValues['0:a'] = 'override';
-        ed.onCellDoubleClick(0, 0);
-        expect(ctx.editingCell.value).toBe('override');
-    });
-    it('returns early when editing is disabled', () => {
-        const { ctx, ed } = editingFor({ editingEnabled: false });
-        ed.onCellDoubleClick(0, 0);
-        expect(ctx.editingCell).toBeNull();
-    });
-    it('returns early for missing row/column or group rows', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'x' }],
-            groupRows: new Set([0]),
-        });
-        ed.onCellDoubleClick(99, 0);
-        ed.onCellDoubleClick(0, 99);
-        ed.onCellDoubleClick(0, 0); // group row
-        expect(ctx.editingCell).toBeNull();
-    });
-    it('returns early for a non-editable cell', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editable: false, editorType: 'text' }],
-            data: [{ a: 'x' }],
-        });
-        ed.onCellDoubleClick(0, 0);
-        expect(ctx.editingCell).toBeNull();
-    });
-    it('is a no-op when already editing the same cell', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'text' }],
-            data: [{ a: 'x' }],
-        });
-        ctx.editingCell = { rowId: '0', columnId: 'a', editorType: 'text', value: 'mid-edit' };
-        ed.onCellDoubleClick(0, 0);
-        expect(ctx.editingCell.value).toBe('mid-edit'); // untouched
-        expect(ctx.activeCalls).toEqual([]); // setActiveCell not called
-    });
-    it('seeds a multi-select list editor with an array', () => {
-        const { ctx, ed } = editingFor({
-            columns: [
-                { id: 'a', field: 'a', editorType: 'list', editorMultiple: true },
-            ],
-            data: [{ a: 'one' }],
-        });
-        ed.onCellDoubleClick(0, 0);
-        expect(Array.isArray(ctx.editingCell.value)).toBe(true);
-        expect(ctx.editingCell.value).toEqual(['one']);
-    });
-    it('unwraps an array seed for a single-select list editor', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'list' }],
-            data: [{ a: ['first', 'second'] }],
-        });
-        ed.onCellDoubleClick(0, 0);
-        expect(ctx.editingCell.value).toBe('first');
-    });
-    it('uses empty string for a single-select chips editor seeded from an empty array', () => {
-        const { ctx, ed } = editingFor({
-            columns: [{ id: 'a', field: 'a', editorType: 'chips' }],
-            data: [{ a: [] }],
-        });
-        ed.onCellDoubleClick(0, 0);
-        expect(ctx.editingCell.value).toBe('');
-    });
-});
-describe('clipboard fallbacks (non-paste branches only)', () => {
-    // onGridPaste and pasteFromClipboard guard on navigator.clipboard.readText.
-    // The actual paste transformation is covered by clipboard.test.ts; here we
-    // only assert the early-return guards so we do not duplicate that coverage.
-    it('pasteFromClipboard returns early when the async API is unavailable', async () => {
-        Object.defineProperty(navigator, 'clipboard', {
-            value: undefined,
-            configurable: true,
-        });
-        const { ctx, ed } = editingFor();
-        await ed.pasteFromClipboard();
-        expect(ctx.grid.store.setState).not.toHaveBeenCalled();
-    });
-    it('pasteFromClipboard swallows a rejected readText', async () => {
-        Object.defineProperty(navigator, 'clipboard', {
-            value: { readText: vi.fn().mockRejectedValue(new Error('denied')) },
-            configurable: true,
-        });
-        const { ctx, ed } = editingFor();
-        await expect(ed.pasteFromClipboard()).resolves.toBeUndefined();
-        expect(ctx.grid.store.setState).not.toHaveBeenCalled();
-    });
-    it('onGridPaste ignores the native event when the async API is present', () => {
-        Object.defineProperty(navigator, 'clipboard', {
-            value: { readText: vi.fn() },
-            configurable: true,
-        });
-        const { ctx, ed } = editingFor();
-        const ev = {
-            clipboardData: { getData: () => 'a\tb' },
-            preventDefault: vi.fn(),
-        };
-        ed.onGridPaste(ev);
-        expect(ev.preventDefault).not.toHaveBeenCalled();
-        expect(ctx.grid.store.setState).not.toHaveBeenCalled();
-    });
-    it('onGridPaste returns early on empty clipboard text in the fallback path', () => {
-        Object.defineProperty(navigator, 'clipboard', {
-            value: undefined,
-            configurable: true,
-        });
-        const { ctx, ed } = editingFor();
-        const ev = {
-            clipboardData: { getData: () => '' },
-            preventDefault: vi.fn(),
-        };
-        ed.onGridPaste(ev);
-        expect(ev.preventDefault).not.toHaveBeenCalled();
-        expect(ctx.grid.store.setState).not.toHaveBeenCalled();
-    });
-    it('onGridPaste applies pasted text via the fallback path', () => {
-        Object.defineProperty(navigator, 'clipboard', {
-            value: undefined,
-            configurable: true,
-        });
-        const { ctx, ed } = editingFor({
-            columns: [
-                { id: 'a', field: 'a', editorType: 'text', editable: true },
-                { id: 'b', field: 'b', editorType: 'text', editable: true },
-            ],
-            data: [
-                { a: '', b: '' },
-                { a: '', b: '' },
-            ],
-        });
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 0 },
-        };
-        const ev = {
-            clipboardData: { getData: () => 'X\tY\nZ\tW' },
-            preventDefault: vi.fn(),
-        };
-        ed.onGridPaste(ev);
-        expect(ev.preventDefault).toHaveBeenCalled();
-        expect(ctx.internalData[0]).toMatchObject({ a: 'X', b: 'Y' });
-        expect(ctx.internalData[1]).toMatchObject({ a: 'Z', b: 'W' });
-    });
-});