@svgrid/grid 1.1.1 → 1.2.1

package/dist/clipboard.test.js

@@ -1,700 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { createClipboard } from './clipboard';
-function makeCtx(opts = {}) {
-    const columns = opts.columns ?? [
-        { id: 'a', field: 'a', editable: true, editorType: 'text' },
-        { id: 'b', field: 'b', editable: true, editorType: 'text' },
-    ];
-    const data = (opts.data ?? [
-        { a: 'a0', b: 'b0' },
-        { a: 'a1', b: 'b1' },
-    ]).map((d) => ({ ...d }));
-    const allColumns = columns.map((c) => ({
-        id: c.id,
-        columnDef: {
-            field: c.field,
-            editable: c.editable,
-            editorType: c.editorType,
-        },
-    }));
-    // allRows mirror internalData by index; row.id === index as a string.
-    const buildRows = () => data.map((row, index) => ({
-        id: String(index),
-        original: row,
-        getCanExpand: () => opts.groupRows?.has(index) ?? false,
-        getCellValueByColumnId: (colId) => row[colId],
-    }));
-    let activeCell = null;
-    const ctx = {
-        internalData: data,
-        allColumns,
-        get allRows() {
-            // Recompute from current internalData so writeCellRaw's
-            // `r.original === row` lookup stays consistent with internalData.
-            return ctx._rows;
-        },
-        _rows: buildRows(),
-        selectionRange: { anchor: null, focus: null },
-        selectionRanges: [],
-        // Mirrors the real controller's getSelectionRects: committed ranges + active.
-        getSelectionRects() {
-            const rects = [];
-            const norm = (r) => r?.anchor && r?.focus
-                ? {
-                    minRow: Math.min(r.anchor.rowIndex, r.focus.rowIndex),
-                    maxRow: Math.max(r.anchor.rowIndex, r.focus.rowIndex),
-                    minCol: Math.min(r.anchor.colIndex, r.focus.colIndex),
-                    maxCol: Math.max(r.anchor.colIndex, r.focus.colIndex),
-                }
-                : null;
-            for (const r of ctx.selectionRanges) {
-                const n = norm(r);
-                if (n)
-                    rects.push(n);
-            }
-            const active = norm(ctx.selectionRange);
-            if (active)
-                rects.push(active);
-            return rects;
-        },
-        fillDrag: null,
-        editedCellValues: {},
-        userHasActivatedCell: false,
-        gridRootEl: null,
-        props: {},
-        findColumnById: (id) => allColumns.find((c) => c.id === id),
-        isCellEditableAt: opts.editableAt ?? (() => true),
-        getCellDisplayValue: vi.fn((_rowId, _colId, base) => base),
-        grid: {
-            getState: () => ({ activeCell }),
-            store: { setState: vi.fn() },
-        },
-        _setActiveCell: (c) => {
-            activeCell = c;
-        },
-    };
-    // Keep _rows pointing at the live internalData objects whenever it is
-    // reassigned by writeCellRaw / clearSelectedCells.
-    let backing = data;
-    Object.defineProperty(ctx, 'internalData', {
-        get: () => backing,
-        set: (next) => {
-            backing = next;
-            ctx._rows = next.map((row, index) => ({
-                id: String(index),
-                original: row,
-                getCanExpand: () => opts.groupRows?.has(index) ?? false,
-                getCellValueByColumnId: (colId) => row[colId],
-            }));
-        },
-    });
-    return ctx;
-}
-describe('readCellRaw', () => {
-    it('reads the underlying field value', () => {
-        const ctx = makeCtx();
-        const cb = createClipboard(ctx);
-        expect(cb.readCellRaw(0, 'a')).toBe('a0');
-        expect(cb.readCellRaw(1, 'b')).toBe('b1');
-    });
-    it('returns undefined when the row is missing', () => {
-        const ctx = makeCtx();
-        const cb = createClipboard(ctx);
-        expect(cb.readCellRaw(99, 'a')).toBeUndefined();
-    });
-    it('returns undefined when the column has no field', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'noField' }],
-            data: [{ a: 1 }],
-        });
-        const cb = createClipboard(ctx);
-        expect(cb.readCellRaw(0, 'noField')).toBeUndefined();
-    });
-});
-describe('writeCellRaw', () => {
-    it('writes a new value and fires onCellValueChange', () => {
-        const onCellValueChange = vi.fn();
-        const ctx = makeCtx();
-        ctx.props.onCellValueChange = onCellValueChange;
-        const cb = createClipboard(ctx);
-        cb.writeCellRaw(0, 'a', 'X');
-        expect(ctx.internalData[0].a).toBe('X');
-        // Original array object was replaced (immutable update).
-        expect(onCellValueChange).toHaveBeenCalledWith(expect.objectContaining({
-            rowIndex: 0,
-            columnId: 'a',
-            oldValue: 'a0',
-            newValue: 'X',
-        }));
-    });
-    it('records the edit in editedCellValues keyed by rowId:colId', () => {
-        const ctx = makeCtx();
-        const cb = createClipboard(ctx);
-        cb.writeCellRaw(1, 'b', 'Y');
-        expect(ctx.editedCellValues['1:b']).toBe('Y');
-    });
-    it('is a no-op when the value is unchanged', () => {
-        const onCellValueChange = vi.fn();
-        const ctx = makeCtx();
-        ctx.props.onCellValueChange = onCellValueChange;
-        const cb = createClipboard(ctx);
-        cb.writeCellRaw(0, 'a', 'a0');
-        expect(onCellValueChange).not.toHaveBeenCalled();
-    });
-    it('does nothing when the row is missing', () => {
-        const ctx = makeCtx();
-        const cb = createClipboard(ctx);
-        cb.writeCellRaw(99, 'a', 'Z');
-        expect(ctx.internalData).toHaveLength(2);
-    });
-    it('does nothing when the column has no field', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'noField' }],
-            data: [{ a: 1 }],
-        });
-        const cb = createClipboard(ctx);
-        cb.writeCellRaw(0, 'noField', 5);
-        expect(ctx.internalData[0]).toEqual({ a: 1 });
-    });
-});
-describe('clearSelectedCellValues', () => {
-    it('nulls every editable cell in the selection range', () => {
-        const ctx = makeCtx();
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 1, colIndex: 1 },
-        };
-        const cb = createClipboard(ctx);
-        cb.clearSelectedCellValues();
-        expect(ctx.internalData[0]).toEqual({ a: null, b: null });
-        expect(ctx.internalData[1]).toEqual({ a: null, b: null });
-    });
-    it('skips non-editable cells', () => {
-        const ctx = makeCtx({ editableAt: (r, c) => !(r === 0 && c === 0) });
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 1 },
-        };
-        const cb = createClipboard(ctx);
-        cb.clearSelectedCellValues();
-        expect(ctx.internalData[0].a).toBe('a0'); // untouched
-        expect(ctx.internalData[0].b).toBeNull();
-    });
-    it('clears just the active cell when no range is selected', () => {
-        const ctx = makeCtx();
-        ctx.userHasActivatedCell = true;
-        ctx._setActiveCell({ rowIndex: 1, colIndex: 1 });
-        const cb = createClipboard(ctx);
-        cb.clearSelectedCellValues();
-        expect(ctx.internalData[1].b).toBeNull();
-        expect(ctx.internalData[0].a).toBe('a0');
-    });
-    it('does nothing for the active cell when not activated', () => {
-        const ctx = makeCtx();
-        ctx.userHasActivatedCell = false;
-        ctx._setActiveCell({ rowIndex: 1, colIndex: 1 });
-        const cb = createClipboard(ctx);
-        cb.clearSelectedCellValues();
-        expect(ctx.internalData[1].b).toBe('b1');
-    });
-});
-describe('startFillDrag', () => {
-    function fakeEvent() {
-        return {
-            stopPropagation: vi.fn(),
-            preventDefault: vi.fn(),
-        };
-    }
-    it('seeds the drag from the selection range', () => {
-        const ctx = makeCtx();
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 1, colIndex: 1 },
-        };
-        const cb = createClipboard(ctx);
-        cb.startFillDrag(fakeEvent(), 2, 1);
-        expect(ctx.fillDrag).toEqual({
-            sourceMinRow: 0,
-            sourceMaxRow: 1,
-            sourceMinCol: 0,
-            sourceMaxCol: 1,
-            targetRow: 2,
-            targetCol: 1,
-        });
-    });
-    it('seeds a 1x1 drag from the active cell when no range', () => {
-        const ctx = makeCtx();
-        const cb = createClipboard(ctx);
-        const event = fakeEvent();
-        cb.startFillDrag(event, 3, 4);
-        expect(ctx.fillDrag).toEqual({
-            sourceMinRow: 3,
-            sourceMaxRow: 3,
-            sourceMinCol: 4,
-            sourceMaxCol: 4,
-            targetRow: 3,
-            targetCol: 4,
-        });
-        expect(event.stopPropagation).toHaveBeenCalled();
-        expect(event.preventDefault).toHaveBeenCalled();
-    });
-});
-describe('onFillPointerMove', () => {
-    it('does nothing when there is no active fillDrag', () => {
-        const ctx = makeCtx();
-        const cb = createClipboard(ctx);
-        cb.onFillPointerMove({ clientX: 0, clientY: 0 });
-        expect(ctx.fillDrag).toBeNull();
-    });
-    it('updates the target when a cell is found under the pointer', () => {
-        const ctx = makeCtx();
-        ctx.fillDrag = {
-            sourceMinRow: 0,
-            sourceMaxRow: 0,
-            sourceMinCol: 0,
-            sourceMaxCol: 0,
-            targetRow: 0,
-            targetCol: 0,
-        };
-        const cb = createClipboard(ctx);
-        const td = document.createElement('td');
-        td.setAttribute('data-svgrid-row', '2');
-        td.setAttribute('data-svgrid-col', '1');
-        document.elementFromPoint = () => td;
-        cb.onFillPointerMove({ clientX: 5, clientY: 5 });
-        expect(ctx.fillDrag.targetRow).toBe(2);
-        expect(ctx.fillDrag.targetCol).toBe(1);
-    });
-    it('does not re-set the drag when hovering the same target', () => {
-        const ctx = makeCtx();
-        const original = {
-            sourceMinRow: 0,
-            sourceMaxRow: 0,
-            sourceMinCol: 0,
-            sourceMaxCol: 0,
-            targetRow: 1,
-            targetCol: 1,
-        };
-        ctx.fillDrag = original;
-        const cb = createClipboard(ctx);
-        const td = document.createElement('td');
-        td.setAttribute('data-svgrid-row', '1');
-        td.setAttribute('data-svgrid-col', '1');
-        document.elementFromPoint = () => td;
-        cb.onFillPointerMove({ clientX: 5, clientY: 5 });
-        expect(ctx.fillDrag).toBe(original); // unchanged reference
-    });
-    it('ignores a pointer that is not over a grid cell', () => {
-        const ctx = makeCtx();
-        const original = {
-            sourceMinRow: 0,
-            sourceMaxRow: 0,
-            sourceMinCol: 0,
-            sourceMaxCol: 0,
-            targetRow: 0,
-            targetCol: 0,
-        };
-        ctx.fillDrag = original;
-        const cb = createClipboard(ctx);
-        document.elementFromPoint = () => document.createElement('div');
-        cb.onFillPointerMove({ clientX: 5, clientY: 5 });
-        expect(ctx.fillDrag).toBe(original);
-    });
-});
-describe('onFillPointerUp / applyFillPattern', () => {
-    it('does nothing when there is no fillDrag', () => {
-        const ctx = makeCtx();
-        const cb = createClipboard(ctx);
-        cb.onFillPointerUp();
-        expect(ctx.selectionRange).toEqual({ anchor: null, focus: null });
-    });
-    it('fills downward from a numeric source pattern', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a', editable: true, editorType: 'number' }],
-            data: [{ a: 1 }, { a: 2 }, { a: 0 }, { a: 0 }],
-        });
-        ctx.fillDrag = {
-            sourceMinRow: 0,
-            sourceMaxRow: 1,
-            sourceMinCol: 0,
-            sourceMaxCol: 0,
-            targetRow: 3,
-            targetCol: 0,
-        };
-        const cb = createClipboard(ctx);
-        cb.onFillPointerUp();
-        // 1,2 -> linear pattern continues 3,4
-        expect(ctx.internalData[2].a).toBe(3);
-        expect(ctx.internalData[3].a).toBe(4);
-        expect(ctx.fillDrag).toBeNull();
-        expect(ctx.selectionRange.focus).toEqual({ rowIndex: 3, colIndex: 0 });
-    });
-    it('fills upward, reverse-extrapolating the pattern', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a', editable: true, editorType: 'number' }],
-            data: [{ a: 0 }, { a: 0 }, { a: 10 }, { a: 20 }],
-        });
-        ctx.fillDrag = {
-            sourceMinRow: 2,
-            sourceMaxRow: 3,
-            sourceMinCol: 0,
-            sourceMaxCol: 0,
-            targetRow: 0,
-            targetCol: 0,
-        };
-        const cb = createClipboard(ctx);
-        cb.applyFillPattern();
-        // reversed source 20,10 -> continues 0,-10 going up; row1=0, row0=-10
-        expect(ctx.internalData[1].a).toBe(0);
-        expect(ctx.internalData[0].a).toBe(-10);
-    });
-    it('skips columns that are not editable', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a', editable: false, editorType: 'number' }],
-            data: [{ a: 1 }, { a: 2 }, { a: 0 }],
-        });
-        ctx.fillDrag = {
-            sourceMinRow: 0,
-            sourceMaxRow: 1,
-            sourceMinCol: 0,
-            sourceMaxCol: 0,
-            targetRow: 2,
-            targetCol: 0,
-        };
-        const cb = createClipboard(ctx);
-        cb.applyFillPattern();
-        expect(ctx.internalData[2].a).toBe(0); // untouched
-    });
-    it('fills horizontally to the right', () => {
-        const ctx = makeCtx({
-            columns: [
-                { id: 'a', field: 'a', editable: true, editorType: 'number' },
-                { id: 'b', field: 'b', editable: true, editorType: 'number' },
-                { id: 'c', field: 'c', editable: true, editorType: 'number' },
-            ],
-            data: [{ a: 2, b: 4, c: 0 }],
-        });
-        ctx.fillDrag = {
-            sourceMinRow: 0,
-            sourceMaxRow: 0,
-            sourceMinCol: 0,
-            sourceMaxCol: 1,
-            targetRow: 0,
-            targetCol: 2,
-        };
-        const cb = createClipboard(ctx);
-        cb.applyFillPattern();
-        // 2,4 -> next is 6
-        expect(ctx.internalData[0].c).toBe(6);
-    });
-    it('fills horizontally to the left', () => {
-        const ctx = makeCtx({
-            columns: [
-                { id: 'a', field: 'a', editable: true, editorType: 'number' },
-                { id: 'b', field: 'b', editable: true, editorType: 'number' },
-                { id: 'c', field: 'c', editable: true, editorType: 'number' },
-            ],
-            data: [{ a: 0, b: 10, c: 20 }],
-        });
-        ctx.fillDrag = {
-            sourceMinRow: 0,
-            sourceMaxRow: 0,
-            sourceMinCol: 1,
-            sourceMaxCol: 2,
-            targetRow: 0,
-            targetCol: 0,
-        };
-        const cb = createClipboard(ctx);
-        cb.applyFillPattern();
-        // reversed 20,10 -> next going left is 0
-        expect(ctx.internalData[0].a).toBe(0);
-    });
-});
-describe('toggleBooleanCell', () => {
-    it('flips a falsy cell to true and records the edit', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a', editable: true }],
-            data: [{ a: false }],
-        });
-        const cb = createClipboard(ctx);
-        cb.toggleBooleanCell(0, 0);
-        expect(ctx.internalData[0].a).toBe(true);
-        expect(ctx.editedCellValues['0:a']).toBe(true);
-        expect(ctx.grid.store.setState).toHaveBeenCalled();
-    });
-    it('flips a truthy cell to false', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a', editable: true }],
-            data: [{ a: true }],
-        });
-        const cb = createClipboard(ctx);
-        cb.toggleBooleanCell(0, 0);
-        expect(ctx.internalData[0].a).toBe(false);
-    });
-    it('does nothing when the row or column is missing', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a' }],
-            data: [{ a: true }],
-        });
-        const cb = createClipboard(ctx);
-        cb.toggleBooleanCell(99, 0);
-        cb.toggleBooleanCell(0, 99);
-        expect(ctx.internalData[0].a).toBe(true);
-    });
-    it('does nothing when the column has no field', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a' }],
-            data: [{ a: true }],
-        });
-        const cb = createClipboard(ctx);
-        cb.toggleBooleanCell(0, 0);
-        expect(ctx.grid.store.setState).not.toHaveBeenCalled();
-    });
-});
-describe('copySelectionToClipboard', () => {
-    let writeText;
-    beforeEach(() => {
-        writeText = vi.fn().mockResolvedValue(undefined);
-        Object.defineProperty(navigator, 'clipboard', {
-            value: { writeText },
-            configurable: true,
-        });
-    });
-    it('does nothing when there is no selection', () => {
-        const ctx = makeCtx();
-        const cb = createClipboard(ctx);
-        cb.copySelectionToClipboard();
-        expect(writeText).not.toHaveBeenCalled();
-    });
-    it('writes the selection as tab/newline separated text', () => {
-        const ctx = makeCtx({
-            data: [
-                { a: 'a0', b: 'b0' },
-                { a: 'a1', b: 'b1' },
-            ],
-        });
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 1, colIndex: 1 },
-        };
-        const cb = createClipboard(ctx);
-        cb.copySelectionToClipboard();
-        expect(writeText).toHaveBeenCalledWith('a0\tb0\na1\tb1');
-    });
-    it('prepends a header row when copyHeadersToClipboard is set', () => {
-        const ctx = makeCtx({
-            data: [
-                { a: 'a0', b: 'b0' },
-                { a: 'a1', b: 'b1' },
-            ],
-        });
-        ctx.props.copyHeadersToClipboard = true;
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 1, colIndex: 1 },
-        };
-        const cb = createClipboard(ctx);
-        cb.copySelectionToClipboard();
-        expect(writeText).toHaveBeenCalledWith('a\tb\na0\tb0\na1\tb1');
-    });
-    it('runs each value through processCellForClipboard', () => {
-        const ctx = makeCtx({
-            data: [{ a: 'a0', b: 'b0' }],
-        });
-        ctx.props.processCellForClipboard = ({ value }) => `[${value}]`;
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 1 },
-        };
-        const cb = createClipboard(ctx);
-        cb.copySelectionToClipboard();
-        expect(writeText).toHaveBeenCalledWith('[a0]\t[b0]');
-    });
-    it('emits empty strings for missing columns and nullish values', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a' }],
-            data: [{ a: null }],
-        });
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 1 }, // col 1 doesn't exist
-        };
-        const cb = createClipboard(ctx);
-        cb.copySelectionToClipboard();
-        expect(writeText).toHaveBeenCalledWith('\t');
-    });
-    it('skips group rows', () => {
-        const ctx = makeCtx({
-            data: [
-                { a: 'g', b: 'g' },
-                { a: 'a1', b: 'b1' },
-            ],
-            groupRows: new Set([0]),
-        });
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 1, colIndex: 1 },
-        };
-        const cb = createClipboard(ctx);
-        cb.copySelectionToClipboard();
-        expect(writeText).toHaveBeenCalledWith('a1\tb1');
-    });
-    it('falls back to legacy copy when clipboard API is absent', () => {
-        Object.defineProperty(navigator, 'clipboard', {
-            value: undefined,
-            configurable: true,
-        });
-        const execCommand = vi.fn().mockReturnValue(true);
-        // @ts-expect-error - jsdom lacks execCommand by default
-        document.execCommand = execCommand;
-        const ctx = makeCtx();
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 0 },
-        };
-        const cb = createClipboard(ctx);
-        cb.copySelectionToClipboard();
-        expect(execCommand).toHaveBeenCalledWith('copy');
-    });
-    it('swallows an execCommand error in the legacy path', () => {
-        Object.defineProperty(navigator, 'clipboard', {
-            value: undefined,
-            configurable: true,
-        });
-        // @ts-expect-error - override execCommand to throw
-        document.execCommand = () => {
-            throw new Error('blocked');
-        };
-        const ctx = makeCtx();
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 0 },
-        };
-        const cb = createClipboard(ctx);
-        // Must not throw even though execCommand blows up.
-        expect(() => cb.copySelectionToClipboard()).not.toThrow();
-    });
-});
-describe('clearSelectedCells', () => {
-    it('returns false when there is no anchor or active cell', () => {
-        const ctx = makeCtx();
-        const cb = createClipboard(ctx);
-        expect(cb.clearSelectedCells()).toBe(false);
-    });
-    it('clears a text cell to empty string and returns true', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a', editable: true, editorType: 'text' }],
-            data: [{ a: 'hello' }],
-        });
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 0 },
-        };
-        const cb = createClipboard(ctx);
-        expect(cb.clearSelectedCells()).toBe(true);
-        expect(ctx.internalData[0].a).toBe('');
-        expect(ctx.grid.store.setState).toHaveBeenCalled();
-    });
-    it('clears a number cell via parseEditorValue coercion', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a', editable: true, editorType: 'number' }],
-            data: [{ a: 5 }],
-        });
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 0 },
-        };
-        const cb = createClipboard(ctx);
-        cb.clearSelectedCells();
-        // parseEditorValue('number', '') coerces '' -> 0 (Number('') is finite).
-        expect(ctx.internalData[0].a).toBe(0);
-    });
-    it('falls back to the active cell when no selection range', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a', editable: true, editorType: 'text' }],
-            data: [{ a: 'x' }],
-        });
-        ctx._setActiveCell({ rowIndex: 0, colIndex: 0 });
-        const cb = createClipboard(ctx);
-        expect(cb.clearSelectedCells()).toBe(true);
-        expect(ctx.internalData[0].a).toBe('');
-    });
-    it('skips group rows and non-editable cells, returning false when nothing changed', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a', editable: true, editorType: 'text' }],
-            data: [{ a: 'g' }],
-            groupRows: new Set([0]),
-        });
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 0 },
-        };
-        const cb = createClipboard(ctx);
-        expect(cb.clearSelectedCells()).toBe(false);
-        expect(ctx.internalData[0].a).toBe('g');
-    });
-    it('skips cells with no field', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a' }],
-            data: [{ a: 'x' }],
-        });
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 0 },
-        };
-        const cb = createClipboard(ctx);
-        expect(cb.clearSelectedCells()).toBe(false);
-    });
-    it('skips non-editable cells', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a', editable: true, editorType: 'text' }],
-            data: [{ a: 'x' }],
-            editableAt: () => false,
-        });
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 0 },
-        };
-        const cb = createClipboard(ctx);
-        expect(cb.clearSelectedCells()).toBe(false);
-        expect(ctx.internalData[0].a).toBe('x');
-    });
-    it('skips rows whose id maps outside the data bounds', () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a', editable: true, editorType: 'text' }],
-            data: [{ a: 'x' }],
-        });
-        // Force the row's id to a non-numeric value so Number(id) is NaN
-        // and the integer/bounds guard skips it.
-        ctx._rows[0].id = 'not-a-number';
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 0 },
-        };
-        const cb = createClipboard(ctx);
-        expect(cb.clearSelectedCells()).toBe(false);
-        expect(ctx.internalData[0].a).toBe('x');
-    });
-});
-describe('cutSelectionToClipboard', () => {
-    beforeEach(() => {
-        Object.defineProperty(navigator, 'clipboard', {
-            value: { writeText: vi.fn().mockResolvedValue(undefined) },
-            configurable: true,
-        });
-    });
-    it('copies then clears the selection', async () => {
-        const ctx = makeCtx({
-            columns: [{ id: 'a', field: 'a', editable: true, editorType: 'text' }],
-            data: [{ a: 'hello' }],
-        });
-        ctx.selectionRange = {
-            anchor: { rowIndex: 0, colIndex: 0 },
-            focus: { rowIndex: 0, colIndex: 0 },
-        };
-        const cb = createClipboard(ctx);
-        await cb.cutSelectionToClipboard();
-        expect(navigator.clipboard.writeText).toHaveBeenCalledWith('hello');
-        expect(ctx.internalData[0].a).toBe('');
-    });
-});

package/dist/collaboration.coverage.test.d.ts

@@ -1 +0,0 @@
-export {};