@affino/datagrid-orchestration 0.1.0

package/dist/src/useDataGridCellVisualStatePredicates.js

@@ -0,0 +1,126 @@
+export function useDataGridCellVisualStatePredicates(options) {
+    const selectColumnKey = options.selectColumnKey ?? "select";
+    function resolveRowColumn(row, columnKey) {
+        if (columnKey === selectColumnKey) {
+            return null;
+        }
+        const columnIndex = options.resolveColumnIndex(columnKey);
+        if (columnIndex < 0) {
+            return null;
+        }
+        return {
+            rowIndex: options.resolveRowIndex(row),
+            columnIndex,
+        };
+    }
+    function isCellInSelection(row, columnKey) {
+        const range = options.resolveSelectionRange();
+        if (!range) {
+            return false;
+        }
+        const indexes = resolveRowColumn(row, columnKey);
+        if (!indexes) {
+            return false;
+        }
+        return options.isCellWithinRange(indexes.rowIndex, indexes.columnIndex, range);
+    }
+    function isCellInCopiedRange(row, columnKey) {
+        const range = options.resolveCopiedRange();
+        if (!range) {
+            return false;
+        }
+        const indexes = resolveRowColumn(row, columnKey);
+        if (!indexes) {
+            return false;
+        }
+        return options.isCellWithinRange(indexes.rowIndex, indexes.columnIndex, range);
+    }
+    function isAnchorCell(row, columnKey) {
+        const anchor = options.resolveAnchorCoord();
+        if (!anchor) {
+            return false;
+        }
+        const indexes = resolveRowColumn(row, columnKey);
+        if (!indexes) {
+            return false;
+        }
+        return indexes.rowIndex === anchor.rowIndex && indexes.columnIndex === anchor.columnIndex;
+    }
+    function isActiveCell(row, columnKey) {
+        const active = options.resolveActiveCoord();
+        if (!active) {
+            return false;
+        }
+        const indexes = resolveRowColumn(row, columnKey);
+        if (!indexes) {
+            return false;
+        }
+        return indexes.rowIndex === active.rowIndex && indexes.columnIndex === active.columnIndex;
+    }
+    function isRangeEndCell(row, columnKey) {
+        const range = options.resolveSelectionRange();
+        if (!range) {
+            return false;
+        }
+        const indexes = resolveRowColumn(row, columnKey);
+        if (!indexes) {
+            return false;
+        }
+        return indexes.rowIndex === range.endRow && indexes.columnIndex === range.endColumn;
+    }
+    function isCellInFillPreview(row, columnKey) {
+        const preview = options.resolveFillPreviewRange();
+        if (!options.isFillDragging() || !preview) {
+            return false;
+        }
+        const indexes = resolveRowColumn(row, columnKey);
+        if (!indexes) {
+            return false;
+        }
+        if (!options.isCellWithinRange(indexes.rowIndex, indexes.columnIndex, preview)) {
+            return false;
+        }
+        const base = options.resolveFillBaseRange();
+        if (!base) {
+            return true;
+        }
+        return !options.isCellWithinRange(indexes.rowIndex, indexes.columnIndex, base);
+    }
+    function isCellInMovePreview(row, columnKey) {
+        const preview = options.resolveMovePreviewRange();
+        if (!options.isRangeMoving() || !preview) {
+            return false;
+        }
+        const indexes = resolveRowColumn(row, columnKey);
+        if (!indexes) {
+            return false;
+        }
+        if (!options.isCellWithinRange(indexes.rowIndex, indexes.columnIndex, preview)) {
+            return false;
+        }
+        const base = options.resolveMoveBaseRange();
+        if (!base) {
+            return true;
+        }
+        return !options.isCellWithinRange(indexes.rowIndex, indexes.columnIndex, base);
+    }
+    function shouldShowFillHandle(row, columnKey) {
+        if (options.isFillDragging()) {
+            return false;
+        }
+        if (options.isInlineEditorOpen?.()) {
+            return false;
+        }
+        return isRangeEndCell(row, columnKey);
+    }
+    return {
+        isCellInSelection,
+        isCellInCopiedRange,
+        isAnchorCell,
+        isActiveCell,
+        isRangeEndCell,
+        isCellInFillPreview,
+        isCellInMovePreview,
+        shouldShowFillHandle,
+    };
+}

package/dist/src/useDataGridClearSelectionLifecycle.d.ts

@@ -0,0 +1,27 @@
+export interface UseDataGridClearSelectionLifecycleOptions<TCoord, TRange> {
+    setCellAnchor: (coord: TCoord | null) => void;
+    setCellFocus: (coord: TCoord | null) => void;
+    setActiveCell: (coord: TCoord | null) => void;
+    setDragSelecting: (value: boolean) => void;
+    setFillDragging: (value: boolean) => void;
+    setDragPointer: (pointer: {
+        clientX: number;
+        clientY: number;
+    } | null) => void;
+    setFillPointer: (pointer: {
+        clientX: number;
+        clientY: number;
+    } | null) => void;
+    setFillBaseRange: (range: TRange | null) => void;
+    setFillPreviewRange: (range: TRange | null) => void;
+    clearLastDragCoord: () => void;
+    closeContextMenu: () => void;
+    stopRangeMove: (applyPreview: boolean) => void;
+    stopColumnResize: () => void;
+    stopAutoScrollFrameIfIdle: () => void;
+}
+export interface UseDataGridClearSelectionLifecycleResult {
+    clearCellSelection: () => void;
+}
+export declare function useDataGridClearSelectionLifecycle<TCoord, TRange>(options: UseDataGridClearSelectionLifecycleOptions<TCoord, TRange>): UseDataGridClearSelectionLifecycleResult;
+//# sourceMappingURL=useDataGridClearSelectionLifecycle.d.ts.map

package/dist/src/useDataGridClearSelectionLifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridClearSelectionLifecycle.d.ts","sourceRoot":"","sources":["../../src/useDataGridClearSelectionLifecycle.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yCAAyC,CAAC,MAAM,EAAE,MAAM;IACvE,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IAC7C,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IAC5C,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IAC7C,gBAAgB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IAC1C,eAAe,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IACzC,cAAc,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,KAAK,IAAI,CAAA;IAC9E,cAAc,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,KAAK,IAAI,CAAA;IAC9E,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IAChD,mBAAmB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IACnD,kBAAkB,EAAE,MAAM,IAAI,CAAA;IAC9B,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,aAAa,EAAE,CAAC,YAAY,EAAE,OAAO,KAAK,IAAI,CAAA;IAC9C,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,yBAAyB,EAAE,MAAM,IAAI,CAAA;CACtC;AAED,MAAM,WAAW,wCAAwC;IACvD,kBAAkB,EAAE,MAAM,IAAI,CAAA;CAC/B;AAED,wBAAgB,kCAAkC,CAAC,MAAM,EAAE,MAAM,EAC/D,OAAO,EAAE,yCAAyC,CAAC,MAAM,EAAE,MAAM,CAAC,GACjE,wCAAwC,CAqB1C"}

package/dist/src/useDataGridClearSelectionLifecycle.js

@@ -0,0 +1,21 @@
+export function useDataGridClearSelectionLifecycle(options) {
+    function clearCellSelection() {
+        options.setCellAnchor(null);
+        options.setCellFocus(null);
+        options.setActiveCell(null);
+        options.setDragSelecting(false);
+        options.setFillDragging(false);
+        options.setDragPointer(null);
+        options.setFillPointer(null);
+        options.setFillBaseRange(null);
+        options.setFillPreviewRange(null);
+        options.clearLastDragCoord();
+        options.closeContextMenu();
+        options.stopRangeMove(false);
+        options.stopColumnResize();
+        options.stopAutoScrollFrameIfIdle();
+    }
+    return {
+        clearCellSelection,
+    };
+}

package/dist/src/useDataGridClipboardBridge.d.ts

@@ -0,0 +1,31 @@
+import type { DataGridWritableRef } from "./dataGridWritableRef";
+export interface DataGridClipboardRange {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+}
+export interface UseDataGridClipboardBridgeOptions<TRow, TRange extends DataGridClipboardRange = DataGridClipboardRange> {
+    copiedSelectionRange: DataGridWritableRef<TRange | null>;
+    lastCopiedPayload: DataGridWritableRef<string>;
+    resolveCopyRange: () => TRange | null;
+    getRowAtIndex: (rowIndex: number) => TRow | undefined;
+    getColumnKeyAtIndex: (columnIndex: number) => string | null;
+    getCellValue: (row: TRow, columnKey: string) => unknown;
+    setLastAction: (message: string) => void;
+    closeContextMenu: () => void;
+    copiedSelectionFlashMs?: number;
+    isColumnCopyable?: (columnKey: string) => boolean;
+    writeClipboardText?: (payload: string) => Promise<void>;
+    readClipboardText?: () => Promise<string>;
+}
+export interface UseDataGridClipboardBridgeResult<TRange extends DataGridClipboardRange = DataGridClipboardRange> {
+    copySelection: (trigger: "keyboard" | "context-menu") => Promise<boolean>;
+    readClipboardPayload: () => Promise<string>;
+    parseClipboardMatrix: (payload: string) => string[][];
+    clearCopiedSelectionFlash: () => void;
+    flashCopiedSelection: (range: TRange) => void;
+    dispose: () => void;
+}
+export declare function useDataGridClipboardBridge<TRow, TRange extends DataGridClipboardRange = DataGridClipboardRange>(options: UseDataGridClipboardBridgeOptions<TRow, TRange>): UseDataGridClipboardBridgeResult<TRange>;
+//# sourceMappingURL=useDataGridClipboardBridge.d.ts.map

package/dist/src/useDataGridClipboardBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridClipboardBridge.d.ts","sourceRoot":"","sources":["../../src/useDataGridClipboardBridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,iCAAiC,CAChD,IAAI,EACJ,MAAM,SAAS,sBAAsB,GAAG,sBAAsB;IAE9D,oBAAoB,EAAE,mBAAmB,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IACxD,iBAAiB,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAAA;IAC9C,gBAAgB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IACrC,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,SAAS,CAAA;IACrD,mBAAmB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IAC3D,YAAY,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;IACvD,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACxC,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,gBAAgB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;IACjD,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACvD,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;CAC1C;AAED,MAAM,WAAW,gCAAgC,CAC/C,MAAM,SAAS,sBAAsB,GAAG,sBAAsB;IAE9D,aAAa,EAAE,CAAC,OAAO,EAAE,UAAU,GAAG,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACzE,oBAAoB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;IAC3C,oBAAoB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,EAAE,EAAE,CAAA;IACrD,yBAAyB,EAAE,MAAM,IAAI,CAAA;IACrC,oBAAoB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7C,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAWD,wBAAgB,0BAA0B,CACxC,IAAI,EACJ,MAAM,SAAS,sBAAsB,GAAG,sBAAsB,EAE9D,OAAO,EAAE,iCAAiC,CAAC,IAAI,EAAE,MAAM,CAAC,GACvD,gCAAgC,CAAC,MAAM,CAAC,CA8I1C"}

package/dist/src/useDataGridClipboardBridge.js

@@ -0,0 +1,138 @@
+const DEFAULT_FLASH_MS = 1200;
+function normalizeClipboardValue(value) {
+    if (typeof value === "undefined" || value === null) {
+        return "";
+    }
+    return String(value);
+}
+export function useDataGridClipboardBridge(options) {
+    let copiedSelectionResetTimer = null;
+    const flashMs = Number.isFinite(options.copiedSelectionFlashMs)
+        ? Math.max(0, Math.trunc(options.copiedSelectionFlashMs))
+        : DEFAULT_FLASH_MS;
+    const canCopyColumn = options.isColumnCopyable ?? (columnKey => columnKey !== "select");
+    function clearCopiedSelectionFlash() {
+        options.copiedSelectionRange.value = null;
+        if (copiedSelectionResetTimer !== null) {
+            clearTimeout(copiedSelectionResetTimer);
+            copiedSelectionResetTimer = null;
+        }
+    }
+    function flashCopiedSelection(range) {
+        options.copiedSelectionRange.value = { ...range };
+        if (copiedSelectionResetTimer !== null) {
+            clearTimeout(copiedSelectionResetTimer);
+        }
+        if (flashMs === 0) {
+            return;
+        }
+        copiedSelectionResetTimer = setTimeout(() => {
+            options.copiedSelectionRange.value = null;
+            copiedSelectionResetTimer = null;
+        }, flashMs);
+    }
+    function buildCopyPayload(range) {
+        const rows = [];
+        for (let rowIndex = range.startRow; rowIndex <= range.endRow; rowIndex += 1) {
+            const row = options.getRowAtIndex(rowIndex);
+            if (!row) {
+                continue;
+            }
+            const cells = [];
+            for (let columnIndex = range.startColumn; columnIndex <= range.endColumn; columnIndex += 1) {
+                const columnKey = options.getColumnKeyAtIndex(columnIndex);
+                if (!columnKey || !canCopyColumn(columnKey)) {
+                    continue;
+                }
+                cells.push(normalizeClipboardValue(options.getCellValue(row, columnKey)));
+            }
+            rows.push(cells.join("\t"));
+        }
+        return rows.join("\n");
+    }
+    async function writeClipboardPayload(payload) {
+        if (options.writeClipboardText) {
+            await options.writeClipboardText(payload);
+            return;
+        }
+        if (typeof navigator !== "undefined" &&
+            navigator.clipboard &&
+            typeof navigator.clipboard.writeText === "function") {
+            await navigator.clipboard.writeText(payload);
+            return;
+        }
+        throw new Error("Clipboard API unavailable");
+    }
+    async function copySelection(trigger) {
+        const range = options.resolveCopyRange();
+        if (!range) {
+            options.setLastAction("Copy skipped: no active selection");
+            return false;
+        }
+        const payload = buildCopyPayload(range);
+        if (!payload) {
+            options.setLastAction("Copy skipped: empty selection");
+            return false;
+        }
+        try {
+            await writeClipboardPayload(payload);
+        }
+        catch {
+            // Clipboard permissions can be unavailable in some environments.
+        }
+        options.lastCopiedPayload.value = payload;
+        flashCopiedSelection(range);
+        options.closeContextMenu();
+        const rows = range.endRow - range.startRow + 1;
+        const columns = range.endColumn - range.startColumn + 1;
+        options.setLastAction(`Copied ${rows}x${columns} cells (${trigger})`);
+        return true;
+    }
+    async function readClipboardPayload() {
+        if (options.readClipboardText) {
+            try {
+                const payload = await options.readClipboardText();
+                if (typeof payload === "string") {
+                    return payload;
+                }
+            }
+            catch {
+                // Fallback to in-memory payload.
+            }
+            return options.lastCopiedPayload.value;
+        }
+        if (typeof navigator !== "undefined" &&
+            navigator.clipboard &&
+            typeof navigator.clipboard.readText === "function") {
+            try {
+                return await navigator.clipboard.readText();
+            }
+            catch {
+                // Fallback to in-memory payload.
+            }
+        }
+        return options.lastCopiedPayload.value;
+    }
+    function parseClipboardMatrix(payload) {
+        const normalized = payload.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        const rows = normalized
+            .split("\n")
+            .filter(row => row.length > 0)
+            .map(row => row.split("\t"));
+        return rows.length ? rows : [[]];
+    }
+    function dispose() {
+        if (copiedSelectionResetTimer !== null) {
+            clearTimeout(copiedSelectionResetTimer);
+            copiedSelectionResetTimer = null;
+        }
+    }
+    return {
+        copySelection,
+        readClipboardPayload,
+        parseClipboardMatrix,
+        clearCopiedSelectionFlash,
+        flashCopiedSelection,
+        dispose,
+    };
+}

package/dist/src/useDataGridClipboardMutations.d.ts

@@ -0,0 +1,47 @@
+import type { DataGridClipboardRange } from "./useDataGridClipboardBridge";
+import type { DataGridWritableRef } from "./dataGridWritableRef";
+export interface DataGridClipboardCoord {
+    rowIndex: number;
+    columnIndex: number;
+}
+export interface DataGridClipboardMutationResult<TRange extends DataGridClipboardRange = DataGridClipboardRange> {
+    applied: number;
+    blocked: number;
+    range: TRange;
+}
+export interface UseDataGridClipboardMutationsOptions<TRow, TColumnKey extends string, TRange extends DataGridClipboardRange = DataGridClipboardRange, TCoord extends DataGridClipboardCoord = DataGridClipboardCoord, TSnapshot = unknown> {
+    sourceRows: DataGridWritableRef<readonly TRow[]>;
+    setSourceRows: (rows: readonly TRow[]) => void;
+    cloneRow: (row: TRow) => TRow;
+    resolveRowId: (row: TRow) => string;
+    resolveCopyRange: () => TRange | null;
+    resolveCurrentCellCoord: () => TCoord | null;
+    normalizeCellCoord: (coord: TCoord) => TCoord | null;
+    normalizeSelectionRange: (range: TRange) => TRange | null;
+    resolveRowAtViewIndex: (rowIndex: number) => TRow | undefined;
+    resolveColumnKeyAtIndex: (columnIndex: number) => TColumnKey | null;
+    isEditableColumn: (columnKey: TColumnKey) => boolean;
+    canApplyPastedValue: (columnKey: TColumnKey, value: string) => boolean;
+    applyEditedValue: (row: TRow, columnKey: TColumnKey, value: string) => void;
+    clearValueForCut: (row: TRow, columnKey: TColumnKey) => boolean;
+    finalizeMutableRows?: (rowsById: Map<string, TRow>) => void;
+    applySelectionRange: (range: TRange) => void;
+    closeContextMenu: () => void;
+    setLastAction: (message: string) => void;
+    readClipboardPayload: () => Promise<string>;
+    parseClipboardMatrix: (payload: string) => string[][];
+    copySelection: (trigger: "keyboard" | "context-menu") => Promise<boolean>;
+    captureBeforeSnapshot?: () => TSnapshot;
+    recordIntentTransaction?: (descriptor: {
+        intent: "paste" | "clear" | "cut";
+        label: string;
+        affectedRange: TRange;
+    }, beforeSnapshot: TSnapshot) => Promise<void>;
+}
+export interface UseDataGridClipboardMutationsResult<TRange extends DataGridClipboardRange = DataGridClipboardRange> {
+    pasteSelection: (trigger: "keyboard" | "context-menu") => Promise<boolean>;
+    clearCurrentSelection: (trigger: "keyboard" | "context-menu") => Promise<boolean>;
+    cutSelection: (trigger: "keyboard" | "context-menu") => Promise<boolean>;
+}
+export declare function useDataGridClipboardMutations<TRow, TColumnKey extends string, TRange extends DataGridClipboardRange = DataGridClipboardRange, TCoord extends DataGridClipboardCoord = DataGridClipboardCoord, TSnapshot = unknown>(options: UseDataGridClipboardMutationsOptions<TRow, TColumnKey, TRange, TCoord, TSnapshot>): UseDataGridClipboardMutationsResult<TRange>;
+//# sourceMappingURL=useDataGridClipboardMutations.d.ts.map

package/dist/src/useDataGridClipboardMutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridClipboardMutations.d.ts","sourceRoot":"","sources":["../../src/useDataGridClipboardMutations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAA;AAC1E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAMhE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,+BAA+B,CAAC,MAAM,SAAS,sBAAsB,GAAG,sBAAsB;IAC7G,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,oCAAoC,CACnD,IAAI,EACJ,UAAU,SAAS,MAAM,EACzB,MAAM,SAAS,sBAAsB,GAAG,sBAAsB,EAC9D,MAAM,SAAS,sBAAsB,GAAG,sBAAsB,EAC9D,SAAS,GAAG,OAAO;IAEnB,UAAU,EAAE,mBAAmB,CAAC,SAAS,IAAI,EAAE,CAAC,CAAA;IAChD,aAAa,EAAE,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,KAAK,IAAI,CAAA;IAC9C,QAAQ,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,IAAI,CAAA;IAC7B,YAAY,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,MAAM,CAAA;IAEnC,gBAAgB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IACrC,uBAAuB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IAC5C,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IACpD,uBAAuB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IAEzD,qBAAqB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,SAAS,CAAA;IAC7D,uBAAuB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,UAAU,GAAG,IAAI,CAAA;IACnE,gBAAgB,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,OAAO,CAAA;IACpD,mBAAmB,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;IACtE,gBAAgB,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3E,gBAAgB,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,KAAK,OAAO,CAAA;IAC/D,mBAAmB,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,IAAI,CAAA;IAE3D,mBAAmB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC5C,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IAExC,oBAAoB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;IAC3C,oBAAoB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,EAAE,EAAE,CAAA;IACrD,aAAa,EAAE,CAAC,OAAO,EAAE,UAAU,GAAG,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAEzE,qBAAqB,CAAC,EAAE,MAAM,SAAS,CAAA;IACvC,uBAAuB,CAAC,EAAE,CACxB,UAAU,EAAE;QAAE,MAAM,EAAE,OAAO,GAAG,OAAO,GAAG,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,EACvF,cAAc,EAAE,SAAS,KACtB,OAAO,CAAC,IAAI,CAAC,CAAA;CACnB;AAED,MAAM,WAAW,mCAAmC,CAClD,MAAM,SAAS,sBAAsB,GAAG,sBAAsB;IAE9D,cAAc,EAAE,CAAC,OAAO,EAAE,UAAU,GAAG,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC1E,qBAAqB,EAAE,CAAC,OAAO,EAAE,UAAU,GAAG,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACjF,YAAY,EAAE,CAAC,OAAO,EAAE,UAAU,GAAG,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CACzE;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EACJ,UAAU,SAAS,MAAM,EACzB,MAAM,SAAS,sBAAsB,GAAG,sBAAsB,EAC9D,MAAM,SAAS,sBAAsB,GAAG,sBAAsB,EAC9D,SAAS,GAAG,OAAO,EAEnB,OAAO,EAAE,oCAAoC,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,GACzF,mCAAmC,CAAC,MAAM,CAAC,CA0P7C"}

package/dist/src/useDataGridClipboardMutations.js

@@ -0,0 +1,216 @@
+import { createDataGridMutableRowStore, forEachDataGridRangeCell, } from "./dataGridRangeMutationKernel";
+export function useDataGridClipboardMutations(options) {
+    function resolvePasteStartCoord() {
+        const selected = options.resolveCopyRange();
+        if (selected) {
+            return options.normalizeCellCoord({
+                rowIndex: selected.startRow,
+                columnIndex: selected.startColumn,
+            });
+        }
+        const current = options.resolveCurrentCellCoord();
+        if (!current) {
+            return null;
+        }
+        return options.normalizeCellCoord(current);
+    }
+    function resolvePasteTargets(matrix, start) {
+        const rowCount = Math.max(1, matrix.length);
+        const columnCount = Math.max(1, matrix[0]?.length ?? 1);
+        const selected = options.resolveCopyRange();
+        if (selected &&
+            rowCount === 1 &&
+            columnCount === 1 &&
+            (selected.endRow !== selected.startRow || selected.endColumn !== selected.startColumn)) {
+            return selected;
+        }
+        return options.normalizeSelectionRange({
+            startRow: start.rowIndex,
+            endRow: start.rowIndex + rowCount - 1,
+            startColumn: start.columnIndex,
+            endColumn: start.columnIndex + columnCount - 1,
+        });
+    }
+    async function maybeRecordTransaction(descriptor, beforeSnapshot) {
+        if (!options.recordIntentTransaction || beforeSnapshot === null) {
+            return;
+        }
+        await options.recordIntentTransaction(descriptor, beforeSnapshot);
+    }
+    async function pasteSelection(trigger) {
+        const start = resolvePasteStartCoord();
+        if (!start) {
+            options.closeContextMenu();
+            options.setLastAction("Paste skipped: no active target");
+            return false;
+        }
+        const payload = await options.readClipboardPayload();
+        if (!payload.trim()) {
+            options.closeContextMenu();
+            options.setLastAction("Paste skipped: clipboard empty");
+            return false;
+        }
+        const matrix = options.parseClipboardMatrix(payload);
+        const targetRange = resolvePasteTargets(matrix, start);
+        if (!targetRange) {
+            options.closeContextMenu();
+            options.setLastAction("Paste skipped: target out of range");
+            return false;
+        }
+        const beforeSnapshot = options.captureBeforeSnapshot ? options.captureBeforeSnapshot() : null;
+        const rowStore = createDataGridMutableRowStore({
+            rows: options.sourceRows.value,
+            resolveRowId: options.resolveRowId,
+            cloneRow: options.cloneRow,
+        });
+        const { mutableById, getMutableRow } = rowStore;
+        let applied = 0;
+        let blocked = 0;
+        const matrixHeight = matrix.length;
+        const matrixWidth = Math.max(1, matrix[0]?.length ?? 1);
+        forEachDataGridRangeCell(targetRange, ({ rowIndex, columnIndex, rowOffset, columnOffset }) => {
+            const targetRow = options.resolveRowAtViewIndex(rowIndex);
+            if (!targetRow) {
+                blocked += 1;
+                return;
+            }
+            const targetColumnKey = options.resolveColumnKeyAtIndex(columnIndex);
+            if (!targetColumnKey || !options.isEditableColumn(targetColumnKey)) {
+                blocked += 1;
+                return;
+            }
+            const sourceValue = matrix[rowOffset % matrixHeight]?.[columnOffset % matrixWidth] ?? "";
+            if (!options.canApplyPastedValue(targetColumnKey, sourceValue)) {
+                blocked += 1;
+                return;
+            }
+            const mutable = getMutableRow(options.resolveRowId(targetRow));
+            if (!mutable) {
+                blocked += 1;
+                return;
+            }
+            options.applyEditedValue(mutable, targetColumnKey, sourceValue);
+            applied += 1;
+        });
+        if (applied === 0) {
+            options.closeContextMenu();
+            options.setLastAction(`Paste blocked (${blocked} cells)`);
+            return false;
+        }
+        options.finalizeMutableRows?.(mutableById);
+        options.setSourceRows(rowStore.commitRows(options.sourceRows.value));
+        options.applySelectionRange(targetRange);
+        await maybeRecordTransaction({
+            intent: "paste",
+            label: blocked > 0
+                ? `Paste ${applied} cells (blocked ${blocked})`
+                : `Paste ${applied} cells`,
+            affectedRange: targetRange,
+        }, beforeSnapshot);
+        options.closeContextMenu();
+        options.setLastAction(blocked > 0
+            ? `Pasted ${applied} cells (${trigger}), blocked ${blocked}`
+            : `Pasted ${applied} cells (${trigger})`);
+        return true;
+    }
+    function clearSelectionValues(range) {
+        const rowStore = createDataGridMutableRowStore({
+            rows: options.sourceRows.value,
+            resolveRowId: options.resolveRowId,
+            cloneRow: options.cloneRow,
+        });
+        const { mutableById, getMutableRow } = rowStore;
+        let applied = 0;
+        let blocked = 0;
+        forEachDataGridRangeCell(range, ({ rowIndex, columnIndex }) => {
+            const targetRow = options.resolveRowAtViewIndex(rowIndex);
+            if (!targetRow) {
+                blocked += 1;
+                return;
+            }
+            const targetColumnKey = options.resolveColumnKeyAtIndex(columnIndex);
+            if (!targetColumnKey || !options.isEditableColumn(targetColumnKey)) {
+                blocked += 1;
+                return;
+            }
+            const mutable = getMutableRow(options.resolveRowId(targetRow));
+            if (!mutable) {
+                blocked += 1;
+                return;
+            }
+            const didClear = options.clearValueForCut(mutable, targetColumnKey);
+            if (!didClear) {
+                blocked += 1;
+                return;
+            }
+            applied += 1;
+        });
+        if (applied > 0) {
+            options.finalizeMutableRows?.(mutableById);
+            options.setSourceRows(rowStore.commitRows(options.sourceRows.value));
+            options.applySelectionRange(range);
+        }
+        return { applied, blocked, range };
+    }
+    async function clearCurrentSelection(trigger) {
+        const range = options.resolveCopyRange();
+        if (!range) {
+            options.closeContextMenu();
+            options.setLastAction("Clear skipped: no active selection");
+            return false;
+        }
+        const beforeSnapshot = options.captureBeforeSnapshot ? options.captureBeforeSnapshot() : null;
+        const result = clearSelectionValues(range);
+        options.closeContextMenu();
+        if (result.applied === 0) {
+            options.setLastAction(`Clear blocked (${result.blocked} cells)`);
+            return false;
+        }
+        await maybeRecordTransaction({
+            intent: "clear",
+            label: result.blocked > 0
+                ? `Clear ${result.applied} cells (blocked ${result.blocked})`
+                : `Clear ${result.applied} cells`,
+            affectedRange: range,
+        }, beforeSnapshot);
+        options.setLastAction(result.blocked > 0
+            ? `Cleared ${result.applied} cells (${trigger}), blocked ${result.blocked}`
+            : `Cleared ${result.applied} cells (${trigger})`);
+        return true;
+    }
+    async function cutSelection(trigger) {
+        const range = options.resolveCopyRange();
+        if (!range) {
+            options.closeContextMenu();
+            options.setLastAction("Cut skipped: no active selection");
+            return false;
+        }
+        const copied = await options.copySelection(trigger);
+        if (!copied) {
+            return false;
+        }
+        const beforeSnapshot = options.captureBeforeSnapshot ? options.captureBeforeSnapshot() : null;
+        const result = clearSelectionValues(range);
+        options.closeContextMenu();
+        if (result.applied === 0) {
+            options.setLastAction(`Cut blocked (${result.blocked} cells)`);
+            return false;
+        }
+        await maybeRecordTransaction({
+            intent: "cut",
+            label: result.blocked > 0
+                ? `Cut ${result.applied} cells (blocked ${result.blocked})`
+                : `Cut ${result.applied} cells`,
+            affectedRange: range,
+        }, beforeSnapshot);
+        options.setLastAction(result.blocked > 0
+            ? `Cut ${result.applied} cells (${trigger}), blocked ${result.blocked}`
+            : `Cut ${result.applied} cells (${trigger})`);
+        return true;
+    }
+    return {
+        pasteSelection,
+        clearCurrentSelection,
+        cutSelection,
+    };
+}

package/dist/src/useDataGridClipboardValuePolicy.d.ts

@@ -0,0 +1,5 @@
+export interface UseDataGridClipboardValuePolicyResult {
+    normalizeClipboardValue: (value: unknown) => string;
+}
+export declare function useDataGridClipboardValuePolicy(): UseDataGridClipboardValuePolicyResult;
+//# sourceMappingURL=useDataGridClipboardValuePolicy.d.ts.map

package/dist/src/useDataGridClipboardValuePolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridClipboardValuePolicy.d.ts","sourceRoot":"","sources":["../../src/useDataGridClipboardValuePolicy.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qCAAqC;IACpD,uBAAuB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAA;CACpD;AAED,wBAAgB,+BAA+B,IAAI,qCAAqC,CAcvF"}

package/dist/src/useDataGridClipboardValuePolicy.js

@@ -0,0 +1,14 @@
+export function useDataGridClipboardValuePolicy() {
+    function normalizeClipboardValue(value) {
+        if (typeof value === "undefined" || value === null) {
+            return "";
+        }
+        if (typeof value === "number" || typeof value === "boolean") {
+            return String(value);
+        }
+        return String(value);
+    }
+    return {
+        normalizeClipboardValue,
+    };
+}