@affino/datagrid-vue 0.3.2 → 0.3.4

package/dist/app/useDataGridAppCellSelection.js

@@ -0,0 +1,290 @@
+import { createGridSelectionRange } from "../advanced";
+export function useDataGridAppCellSelection(options) {
+    const supportsCellSelectionMode = () => {
+        return options.mode.value === "base" || options.mode.value === "worker";
+    };
+    const resolveAnchorColumnIndex = (anchor) => {
+        return "columnIndex" in anchor ? anchor.columnIndex : anchor.colIndex;
+    };
+    const resolveSelectionAnchorCoord = () => {
+        const explicitAnchor = options.selectionAnchor.value;
+        if (explicitAnchor) {
+            return {
+                rowIndex: explicitAnchor.rowIndex,
+                columnIndex: resolveAnchorColumnIndex(explicitAnchor),
+            };
+        }
+        const snapshot = options.selectionSnapshot.value;
+        if (!snapshot || snapshot.ranges.length === 0) {
+            return null;
+        }
+        const activeIndex = snapshot.activeRangeIndex ?? 0;
+        const range = snapshot.ranges[activeIndex] ?? snapshot.ranges[0];
+        if (!range?.anchor) {
+            return null;
+        }
+        return {
+            rowIndex: range.anchor.rowIndex,
+            columnIndex: range.anchor.colIndex,
+        };
+    };
+    const buildSelectionContext = () => {
+        return {
+            grid: {
+                rowCount: options.totalRows.value,
+                colCount: options.visibleColumns.value.length,
+            },
+            getRowIdByIndex: (rowIndex) => options.runtime.getBodyRowAtIndex(rowIndex)?.rowId ?? null,
+        };
+    };
+    const buildSelectionSnapshot = (range, activeCell) => {
+        return {
+            ranges: [
+                {
+                    startRow: range.startRow,
+                    endRow: range.endRow,
+                    startCol: range.startCol,
+                    endCol: range.endCol,
+                    startRowId: range.startRowId ?? null,
+                    endRowId: range.endRowId ?? null,
+                    anchor: {
+                        rowIndex: range.anchor.rowIndex,
+                        colIndex: range.anchor.colIndex,
+                        rowId: range.anchor.rowId ?? null,
+                    },
+                    focus: {
+                        rowIndex: range.focus.rowIndex,
+                        colIndex: range.focus.colIndex,
+                        rowId: range.focus.rowId ?? null,
+                    },
+                },
+            ],
+            activeRangeIndex: 0,
+            activeCell: {
+                rowIndex: activeCell.rowIndex,
+                colIndex: activeCell.colIndex,
+                rowId: activeCell.rowId ?? null,
+            },
+        };
+    };
+    const normalizeRowId = (value) => {
+        return typeof value === "string" || typeof value === "number" ? value : null;
+    };
+    const normalizeCellCoord = (coord) => {
+        const rowCount = options.totalRows.value;
+        const colCount = options.visibleColumns.value.length;
+        if (rowCount <= 0 || colCount <= 0) {
+            return null;
+        }
+        const rowIndex = Math.max(0, Math.min(rowCount - 1, Math.trunc(coord.rowIndex)));
+        const columnIndex = Math.max(0, Math.min(colCount - 1, Math.trunc(coord.columnIndex)));
+        return {
+            rowIndex,
+            columnIndex,
+            rowId: options.runtime.getBodyRowAtIndex(rowIndex)?.rowId ?? null,
+        };
+    };
+    const normalizeSelectionRange = (range) => {
+        const rowCount = options.totalRows.value;
+        const columnCount = options.visibleColumns.value.length;
+        if (rowCount <= 0 || columnCount <= 0) {
+            return null;
+        }
+        const startRow = Math.max(0, Math.min(rowCount - 1, Math.trunc(Math.min(range.startRow, range.endRow))));
+        const endRow = Math.max(0, Math.min(rowCount - 1, Math.trunc(Math.max(range.startRow, range.endRow))));
+        const startColumn = Math.max(0, Math.min(columnCount - 1, Math.trunc(Math.min(range.startColumn, range.endColumn))));
+        const endColumn = Math.max(0, Math.min(columnCount - 1, Math.trunc(Math.max(range.startColumn, range.endColumn))));
+        if (startRow > endRow || startColumn > endColumn) {
+            return null;
+        }
+        return {
+            startRow,
+            endRow,
+            startColumn,
+            endColumn,
+        };
+    };
+    const resolveSelectionRange = () => {
+        const snapshot = options.selectionSnapshot.value;
+        if (!snapshot || snapshot.ranges.length === 0) {
+            return null;
+        }
+        const activeIndex = snapshot.activeRangeIndex ?? 0;
+        const range = snapshot.ranges[activeIndex] ?? snapshot.ranges[0];
+        if (!range) {
+            return null;
+        }
+        return normalizeSelectionRange({
+            startRow: range.startRow,
+            endRow: range.endRow,
+            startColumn: range.startCol,
+            endColumn: range.endCol,
+        });
+    };
+    const resolveCurrentCellCoord = () => {
+        const activeCell = options.selectionSnapshot.value?.activeCell;
+        if (!activeCell) {
+            return null;
+        }
+        const normalized = normalizeCellCoord({
+            rowIndex: activeCell.rowIndex,
+            columnIndex: activeCell.colIndex,
+            rowId: normalizeRowId(activeCell.rowId),
+        });
+        if (!normalized) {
+            return null;
+        }
+        return {
+            rowIndex: normalized.rowIndex,
+            columnIndex: normalized.columnIndex,
+        };
+    };
+    const applySelectionRange = (range) => {
+        const normalized = normalizeSelectionRange(range);
+        if (!normalized || !options.runtime.api.selection.hasSupport()) {
+            return;
+        }
+        const context = buildSelectionContext();
+        const anchor = {
+            rowIndex: normalized.startRow,
+            colIndex: normalized.startColumn,
+            rowId: options.runtime.getBodyRowAtIndex(normalized.startRow)?.rowId ?? null,
+        };
+        const focus = {
+            rowIndex: normalized.endRow,
+            colIndex: normalized.endColumn,
+            rowId: options.runtime.getBodyRowAtIndex(normalized.endRow)?.rowId ?? null,
+        };
+        const createdRange = createGridSelectionRange(anchor, focus, context);
+        const snapshot = buildSelectionSnapshot(createdRange, {
+            rowIndex: createdRange.focus.rowIndex,
+            colIndex: createdRange.focus.colIndex,
+            rowId: createdRange.focus.rowId ?? null,
+        });
+        options.selectionAnchor.value = {
+            rowIndex: createdRange.anchor.rowIndex,
+            colIndex: createdRange.anchor.colIndex,
+            rowId: createdRange.anchor.rowId ?? null,
+        };
+        options.selectionSnapshot.value = snapshot;
+        options.runtime.api.selection.setSnapshot(snapshot);
+    };
+    const applyCellSelectionByCoord = (coord, extend, fallbackAnchor) => {
+        if (!supportsCellSelectionMode() || !options.runtime.api.selection.hasSupport()) {
+            return;
+        }
+        const normalizedCoord = normalizeCellCoord(coord);
+        if (!normalizedCoord) {
+            return;
+        }
+        const context = buildSelectionContext();
+        const rawAnchor = extend
+            ? (options.selectionAnchor.value ?? fallbackAnchor ?? normalizedCoord)
+            : normalizedCoord;
+        const normalizedAnchor = normalizeCellCoord({
+            rowIndex: rawAnchor.rowIndex,
+            columnIndex: resolveAnchorColumnIndex(rawAnchor),
+            rowId: normalizeRowId(rawAnchor.rowId),
+        });
+        if (!normalizedAnchor) {
+            return;
+        }
+        const range = createGridSelectionRange({
+            rowIndex: normalizedAnchor.rowIndex,
+            colIndex: normalizedAnchor.columnIndex,
+            rowId: normalizedAnchor.rowId,
+        }, {
+            rowIndex: normalizedCoord.rowIndex,
+            colIndex: normalizedCoord.columnIndex,
+            rowId: normalizedCoord.rowId,
+        }, context);
+        const snapshot = buildSelectionSnapshot(range, {
+            rowIndex: normalizedCoord.rowIndex,
+            colIndex: normalizedCoord.columnIndex,
+            rowId: normalizedCoord.rowId,
+        });
+        options.selectionAnchor.value = {
+            rowIndex: range.anchor.rowIndex,
+            colIndex: range.anchor.colIndex,
+            rowId: range.anchor.rowId ?? null,
+        };
+        options.selectionSnapshot.value = snapshot;
+        options.runtime.api.selection.setSnapshot(snapshot);
+    };
+    const setCellSelection = (row, rowOffset, columnIndex, extend) => {
+        if (options.isEditingCell(row, options.visibleColumns.value[columnIndex]?.key ?? "")) {
+            return;
+        }
+        applyCellSelectionByCoord({
+            rowIndex: options.viewportRowStart.value + rowOffset,
+            columnIndex,
+            rowId: row.rowId ?? null,
+        }, extend);
+    };
+    const clearCellSelection = () => {
+        options.selectionAnchor.value = null;
+        options.selectionSnapshot.value = null;
+        options.runtime.api.selection.clear();
+    };
+    const isCellSelected = (rowOffset, columnIndex) => {
+        const range = resolveSelectionRange();
+        if (!range) {
+            return false;
+        }
+        const rowIndex = options.viewportRowStart.value + rowOffset;
+        return (rowIndex >= range.startRow
+            && rowIndex <= range.endRow
+            && columnIndex >= range.startColumn
+            && columnIndex <= range.endColumn);
+    };
+    const isSelectionAnchorCell = (rowOffset, columnIndex) => {
+        const anchor = resolveSelectionAnchorCoord();
+        if (!anchor) {
+            return false;
+        }
+        const rowIndex = options.viewportRowStart.value + rowOffset;
+        return rowIndex === anchor.rowIndex && columnIndex === anchor.columnIndex;
+    };
+    const shouldHighlightSelectedCell = (rowOffset, columnIndex) => {
+        const range = resolveSelectionRange();
+        if (!range || !isCellSelected(rowOffset, columnIndex)) {
+            return false;
+        }
+        const isSingleCell = range.startRow === range.endRow && range.startColumn === range.endColumn;
+        if (isSingleCell) {
+            return false;
+        }
+        return !isSelectionAnchorCell(rowOffset, columnIndex);
+    };
+    const isCellOnSelectionEdge = (rowOffset, columnIndex, edge) => {
+        const range = resolveSelectionRange();
+        if (!range || !isCellSelected(rowOffset, columnIndex)) {
+            return false;
+        }
+        const rowIndex = options.viewportRowStart.value + rowOffset;
+        switch (edge) {
+            case "top":
+                return rowIndex === range.startRow;
+            case "right":
+                return columnIndex === range.endColumn;
+            case "bottom":
+                return rowIndex === range.endRow;
+            case "left":
+                return columnIndex === range.startColumn;
+        }
+    };
+    return {
+        normalizeRowId,
+        normalizeCellCoord,
+        resolveSelectionRange,
+        resolveCurrentCellCoord,
+        applySelectionRange,
+        applyCellSelectionByCoord,
+        setCellSelection,
+        clearCellSelection,
+        isCellSelected,
+        isSelectionAnchorCell,
+        shouldHighlightSelectedCell,
+        isCellOnSelectionEdge,
+    };
+}

package/dist/app/useDataGridAppClipboard.d.ts

@@ -0,0 +1,49 @@
+import { type Ref } from "vue";
+import type { DataGridColumnSnapshot, DataGridRowNode } from "@affino/datagrid-core";
+import type { DataGridCopyRange } from "../advanced";
+import type { UseDataGridRuntimeResult } from "../composables/useDataGridRuntime";
+import type { DataGridAppMode } from "./useDataGridAppControls";
+export type DataGridAppPendingClipboardOperation = "none" | "copy" | "cut";
+export type DataGridAppPendingClipboardEdge = "top" | "right" | "bottom" | "left";
+export interface UseDataGridAppClipboardOptions<TRow, TSnapshot> {
+    mode: Ref<DataGridAppMode>;
+    runtime: Pick<UseDataGridRuntimeResult<TRow>, "api" | "getBodyRowAtIndex">;
+    totalRows: Ref<number>;
+    visibleColumns: Ref<readonly DataGridColumnSnapshot[]>;
+    viewportRowStart: Ref<number>;
+    resolveSelectionRange: () => DataGridCopyRange | null;
+    resolveCurrentCellCoord: () => {
+        rowIndex: number;
+        columnIndex: number;
+    } | null;
+    applySelectionRange: (range: DataGridCopyRange) => void;
+    clearCellSelection: () => void;
+    captureRowsSnapshot: () => TSnapshot;
+    recordEditTransaction: (beforeSnapshot: TSnapshot) => void;
+    readCell: (row: DataGridRowNode<TRow>, columnKey: string) => string;
+    readClipboardCell?: (row: DataGridRowNode<TRow>, columnKey: string) => string;
+    isCellEditable: (row: DataGridRowNode<TRow>, rowIndex: number, columnKey: string, columnIndex: number) => boolean;
+    syncViewport: () => void;
+    applyClipboardEdits?: (range: DataGridCopyRange, matrix: string[][], options?: {
+        recordHistory?: boolean;
+    }) => number;
+    buildFillMatrixFromRange?: (range: DataGridCopyRange) => string[][];
+}
+export interface UseDataGridAppClipboardResult {
+    pendingClipboardOperation: Ref<DataGridAppPendingClipboardOperation>;
+    pendingClipboardRange: Ref<DataGridCopyRange | null>;
+    normalizeClipboardRange: (range: DataGridCopyRange) => DataGridCopyRange | null;
+    applyClipboardEdits: (range: DataGridCopyRange, matrix: string[][], options?: {
+        recordHistory?: boolean;
+    }) => number;
+    rangesEqual: (left: DataGridCopyRange | null, right: DataGridCopyRange | null) => boolean;
+    buildFillMatrixFromRange: (range: DataGridCopyRange) => string[][];
+    clearPendingClipboardOperation: (clearSelection: boolean, clearBufferedClipboardPayload?: boolean) => boolean;
+    copySelectedCells: (trigger?: "keyboard" | "context-menu") => Promise<boolean>;
+    pasteSelectedCells: (trigger?: "keyboard" | "context-menu") => Promise<boolean>;
+    cutSelectedCells: (trigger?: "keyboard" | "context-menu") => Promise<boolean>;
+    isCellInPendingClipboardRange: (rowOffset: number, columnIndex: number) => boolean;
+    isCellOnPendingClipboardEdge: (rowOffset: number, columnIndex: number, edge: DataGridAppPendingClipboardEdge) => boolean;
+}
+export declare function useDataGridAppClipboard<TRow, TSnapshot>(options: UseDataGridAppClipboardOptions<TRow, TSnapshot>): UseDataGridAppClipboardResult;
+//# sourceMappingURL=useDataGridAppClipboard.d.ts.map

package/dist/app/useDataGridAppClipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridAppClipboard.d.ts","sourceRoot":"","sources":["../../src/app/useDataGridAppClipboard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AACnC,OAAO,KAAK,EAA0B,sBAAsB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5G,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAA;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE/D,MAAM,MAAM,oCAAoC,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAA;AAC1E,MAAM,MAAM,+BAA+B,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEjF,MAAM,WAAW,8BAA8B,CAAC,IAAI,EAAE,SAAS;IAC7D,IAAI,EAAE,GAAG,CAAC,eAAe,CAAC,CAAA;IAC1B,OAAO,EAAE,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,KAAK,GAAG,mBAAmB,CAAC,CAAA;IAC1E,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACtB,cAAc,EAAE,GAAG,CAAC,SAAS,sBAAsB,EAAE,CAAC,CAAA;IACtD,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC7B,qBAAqB,EAAE,MAAM,iBAAiB,GAAG,IAAI,CAAA;IACrD,uBAAuB,EAAE,MAAM;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IAC/E,mBAAmB,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAA;IACvD,kBAAkB,EAAE,MAAM,IAAI,CAAA;IAC9B,mBAAmB,EAAE,MAAM,SAAS,CAAA;IACpC,qBAAqB,EAAE,CAAC,cAAc,EAAE,SAAS,KAAK,IAAI,CAAA;IAC1D,QAAQ,EAAE,CAAC,GAAG,EAAE,eAAe,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IACnE,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IAC7E,cAAc,EAAE,CACd,GAAG,EAAE,eAAe,CAAC,IAAI,CAAC,EAC1B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,KAChB,OAAO,CAAA;IACZ,YAAY,EAAE,MAAM,IAAI,CAAA;IACxB,mBAAmB,CAAC,EAAE,CACpB,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,OAAO,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,OAAO,CAAA;KAAE,KAClC,MAAM,CAAA;IACX,wBAAwB,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,MAAM,EAAE,EAAE,CAAA;CACpE;AAED,MAAM,WAAW,6BAA6B;IAC5C,yBAAyB,EAAE,GAAG,CAAC,oCAAoC,CAAC,CAAA;IACpE,qBAAqB,EAAE,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAA;IACpD,uBAAuB,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,iBAAiB,GAAG,IAAI,CAAA;IAC/E,mBAAmB,EAAE,CACnB,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,OAAO,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,OAAO,CAAA;KAAE,KAClC,MAAM,CAAA;IACX,WAAW,EAAE,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,EAAE,KAAK,EAAE,iBAAiB,GAAG,IAAI,KAAK,OAAO,CAAA;IACzF,wBAAwB,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,MAAM,EAAE,EAAE,CAAA;IAClE,8BAA8B,EAAE,CAAC,cAAc,EAAE,OAAO,EAAE,6BAA6B,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;IAC7G,iBAAiB,EAAE,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC9E,kBAAkB,EAAE,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC/E,gBAAgB,EAAE,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC7E,6BAA6B,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAA;IAClF,4BAA4B,EAAE,CAC5B,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,+BAA+B,KAClC,OAAO,CAAA;CACb;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,SAAS,EACrD,OAAO,EAAE,8BAA8B,CAAC,IAAI,EAAE,SAAS,CAAC,GACvD,6BAA6B,CAuS/B"}

package/dist/app/useDataGridAppClipboard.js

@@ -0,0 +1,258 @@
+import { ref } from "vue";
+import { useDataGridClipboardBridge, useDataGridCopyRangeHelpers } from "../advanced";
+export function useDataGridAppClipboard(options) {
+    const getBodyRowAtIndex = (rowIndex) => {
+        const runtime = options.runtime;
+        return runtime.getBodyRowAtIndex?.(rowIndex) ?? options.runtime.api.rows.get(rowIndex) ?? undefined;
+    };
+    const copiedSelectionRange = ref(null);
+    const lastCopiedPayload = ref("");
+    const pendingClipboardOperation = ref("none");
+    const pendingClipboardRange = ref(null);
+    const normalizeClipboardRange = (range) => {
+        const rowCount = options.totalRows.value;
+        const columnCount = options.visibleColumns.value.length;
+        if (rowCount <= 0 || columnCount <= 0) {
+            return null;
+        }
+        const startRow = Math.max(0, Math.min(rowCount - 1, Math.trunc(Math.min(range.startRow, range.endRow))));
+        const endRow = Math.max(0, Math.min(rowCount - 1, Math.trunc(Math.max(range.startRow, range.endRow))));
+        const startColumn = Math.max(0, Math.min(columnCount - 1, Math.trunc(Math.min(range.startColumn, range.endColumn))));
+        const endColumn = Math.max(0, Math.min(columnCount - 1, Math.trunc(Math.max(range.startColumn, range.endColumn))));
+        if (startRow > endRow || startColumn > endColumn) {
+            return null;
+        }
+        return {
+            startRow,
+            endRow,
+            startColumn,
+            endColumn,
+        };
+    };
+    const copyRangeHelpers = useDataGridCopyRangeHelpers({
+        resolveSelectionRange: options.resolveSelectionRange,
+        resolveCurrentCellCoord: options.resolveCurrentCellCoord,
+    });
+    const clipboardBridge = useDataGridClipboardBridge({
+        copiedSelectionRange,
+        lastCopiedPayload,
+        resolveCopyRange: copyRangeHelpers.resolveCopyRange,
+        getRowAtIndex: rowIndex => getBodyRowAtIndex(rowIndex),
+        getColumnKeyAtIndex: columnIndex => options.visibleColumns.value[columnIndex]?.key ?? null,
+        getCellValue: (row, columnKey) => (options.readClipboardCell
+            ? options.readClipboardCell(row, columnKey)
+            : options.readCell(row, columnKey)),
+        setLastAction: () => undefined,
+        closeContextMenu: () => undefined,
+    });
+    const applyClipboardEdits = options.applyClipboardEdits ?? ((range, matrix, applyOptions = {}) => {
+        const normalized = normalizeClipboardRange(range);
+        if (!normalized) {
+            return 0;
+        }
+        const matrixHeight = Math.max(1, matrix.length);
+        const matrixWidth = Math.max(1, matrix[0]?.length ?? 1);
+        const editsByRowId = new Map();
+        for (let rowIndex = normalized.startRow; rowIndex <= normalized.endRow; rowIndex += 1) {
+            const row = getBodyRowAtIndex(rowIndex);
+            if (!row || row.rowId == null || row.kind === "group") {
+                continue;
+            }
+            for (let columnIndex = normalized.startColumn; columnIndex <= normalized.endColumn; columnIndex += 1) {
+                const columnKey = options.visibleColumns.value[columnIndex]?.key;
+                if (!columnKey) {
+                    continue;
+                }
+                if (!options.isCellEditable(row, rowIndex, columnKey, columnIndex)) {
+                    continue;
+                }
+                const rowOffset = rowIndex - normalized.startRow;
+                const columnOffset = columnIndex - normalized.startColumn;
+                const value = matrix[rowOffset % matrixHeight]?.[columnOffset % matrixWidth] ?? "";
+                const current = editsByRowId.get(row.rowId) ?? {};
+                current[columnKey] = value;
+                editsByRowId.set(row.rowId, current);
+            }
+        }
+        if (editsByRowId.size === 0) {
+            return 0;
+        }
+        const beforeSnapshot = applyOptions.recordHistory === false ? null : options.captureRowsSnapshot();
+        const updates = Array.from(editsByRowId.entries(), ([rowId, data]) => ({
+            rowId,
+            data: data,
+        }));
+        options.runtime.api.rows.applyEdits(updates);
+        options.applySelectionRange(normalized);
+        if (beforeSnapshot != null) {
+            options.recordEditTransaction(beforeSnapshot);
+        }
+        return editsByRowId.size;
+    });
+    const rangesEqual = (left, right) => {
+        if (!left || !right) {
+            return left === right;
+        }
+        return (left.startRow === right.startRow
+            && left.endRow === right.endRow
+            && left.startColumn === right.startColumn
+            && left.endColumn === right.endColumn);
+    };
+    const buildFillMatrixFromRange = options.buildFillMatrixFromRange ?? ((range) => {
+        const matrix = [];
+        for (let rowIndex = range.startRow; rowIndex <= range.endRow; rowIndex += 1) {
+            const row = getBodyRowAtIndex(rowIndex);
+            if (!row || row.kind === "group") {
+                matrix.push([]);
+                continue;
+            }
+            const rowValues = [];
+            for (let columnIndex = range.startColumn; columnIndex <= range.endColumn; columnIndex += 1) {
+                const columnKey = options.visibleColumns.value[columnIndex]?.key;
+                rowValues.push(columnKey ? options.readCell(row, columnKey) : "");
+            }
+            matrix.push(rowValues);
+        }
+        return matrix;
+    });
+    const clearPendingClipboardOperation = (clearSelection, clearBufferedClipboardPayload = false) => {
+        if (pendingClipboardOperation.value === "none" && !pendingClipboardRange.value) {
+            return false;
+        }
+        pendingClipboardOperation.value = "none";
+        pendingClipboardRange.value = null;
+        if (clearBufferedClipboardPayload) {
+            copiedSelectionRange.value = null;
+            lastCopiedPayload.value = "";
+        }
+        clipboardBridge.clearCopiedSelectionFlash();
+        if (clearSelection) {
+            options.clearCellSelection();
+        }
+        return true;
+    };
+    const stageClipboardOperation = async (operation, trigger) => {
+        if (options.mode.value !== "base") {
+            return false;
+        }
+        const copied = await clipboardBridge.copySelection(trigger);
+        if (!copied) {
+            return false;
+        }
+        const rawSourceRange = copyRangeHelpers.resolveCopyRange() ?? copiedSelectionRange.value;
+        const sourceRange = rawSourceRange ? normalizeClipboardRange(rawSourceRange) : null;
+        if (!sourceRange) {
+            return false;
+        }
+        pendingClipboardOperation.value = operation;
+        pendingClipboardRange.value = sourceRange;
+        return true;
+    };
+    const copySelectedCells = async (trigger = "keyboard") => {
+        return stageClipboardOperation("copy", trigger);
+    };
+    const pasteSelectedCells = async (trigger = "keyboard") => {
+        if (options.mode.value !== "base") {
+            return false;
+        }
+        const activeCoord = options.resolveCurrentCellCoord();
+        if (!activeCoord) {
+            return false;
+        }
+        const payload = await clipboardBridge.readClipboardPayload();
+        if (!payload.trim()) {
+            return false;
+        }
+        const matrix = clipboardBridge.parseClipboardMatrix(payload);
+        const matrixHeight = Math.max(1, matrix.length);
+        const matrixWidth = Math.max(1, matrix[0]?.length ?? 1);
+        const pendingOperation = pendingClipboardOperation.value;
+        const rawPendingSourceRange = pendingClipboardRange.value ?? copiedSelectionRange.value;
+        const pendingSourceRange = rawPendingSourceRange ? normalizeClipboardRange(rawPendingSourceRange) : null;
+        const selected = options.resolveSelectionRange();
+        const targetRange = selected && matrixHeight === 1 && matrixWidth === 1 && copyRangeHelpers.isMultiCellSelection(selected)
+            ? selected
+            : {
+                startRow: activeCoord.rowIndex,
+                endRow: activeCoord.rowIndex + matrixHeight - 1,
+                startColumn: activeCoord.columnIndex,
+                endColumn: activeCoord.columnIndex + matrixWidth - 1,
+            };
+        const normalizedTargetRange = normalizeClipboardRange(targetRange);
+        if (!normalizedTargetRange) {
+            return false;
+        }
+        if (pendingOperation === "cut" && pendingSourceRange && rangesEqual(pendingSourceRange, normalizedTargetRange)) {
+            clearPendingClipboardOperation(false);
+            void trigger;
+            return true;
+        }
+        const beforeSnapshot = options.captureRowsSnapshot();
+        if (pendingOperation === "cut" && pendingSourceRange) {
+            applyClipboardEdits(pendingSourceRange, [[""]], { recordHistory: false });
+        }
+        const appliedRows = applyClipboardEdits(targetRange, matrix, { recordHistory: false });
+        if (appliedRows <= 0) {
+            return false;
+        }
+        options.recordEditTransaction(beforeSnapshot);
+        if (pendingOperation !== "none") {
+            clearPendingClipboardOperation(false);
+        }
+        options.applySelectionRange(normalizedTargetRange);
+        options.syncViewport();
+        void trigger;
+        return true;
+    };
+    const cutSelectedCells = async (trigger = "keyboard") => {
+        return stageClipboardOperation("cut", trigger);
+    };
+    const isCellInPendingClipboardRange = (rowOffset, columnIndex) => {
+        if (options.mode.value !== "base" || pendingClipboardOperation.value === "none") {
+            return false;
+        }
+        const range = pendingClipboardRange.value;
+        if (!range) {
+            return false;
+        }
+        const rowIndex = options.viewportRowStart.value + rowOffset;
+        return (rowIndex >= range.startRow
+            && rowIndex <= range.endRow
+            && columnIndex >= range.startColumn
+            && columnIndex <= range.endColumn);
+    };
+    const isCellOnPendingClipboardEdge = (rowOffset, columnIndex, edge) => {
+        if (!isCellInPendingClipboardRange(rowOffset, columnIndex)) {
+            return false;
+        }
+        const range = pendingClipboardRange.value;
+        if (!range) {
+            return false;
+        }
+        const rowIndex = options.viewportRowStart.value + rowOffset;
+        if (edge === "top") {
+            return rowIndex === range.startRow;
+        }
+        if (edge === "right") {
+            return columnIndex === range.endColumn;
+        }
+        if (edge === "bottom") {
+            return rowIndex === range.endRow;
+        }
+        return columnIndex === range.startColumn;
+    };
+    return {
+        pendingClipboardOperation,
+        pendingClipboardRange,
+        normalizeClipboardRange,
+        applyClipboardEdits,
+        rangesEqual,
+        buildFillMatrixFromRange,
+        clearPendingClipboardOperation,
+        copySelectedCells,
+        pasteSelectedCells,
+        cutSelectedCells,
+        isCellInPendingClipboardRange,
+        isCellOnPendingClipboardEdge,
+    };
+}

package/dist/app/useDataGridAppColumnLayoutPanel.d.ts

@@ -0,0 +1,19 @@
+import { type ComputedRef } from "vue";
+import type { DataGridAppApplyColumnLayoutPayload, DataGridAppColumnLayoutDraftColumn, DataGridAppColumnLayoutPanelItem, DataGridAppColumnLayoutVisibilityPatch } from "./columnLayoutPanel.types";
+interface UseDataGridAppColumnLayoutPanelOptions {
+    resolveColumns: () => readonly DataGridAppColumnLayoutDraftColumn[];
+    applyColumnLayout: (payload: DataGridAppApplyColumnLayoutPayload) => void;
+}
+export interface UseDataGridAppColumnLayoutPanelResult {
+    isColumnLayoutPanelOpen: ComputedRef<boolean>;
+    columnLayoutPanelItems: ComputedRef<readonly DataGridAppColumnLayoutPanelItem[]>;
+    openColumnLayoutPanel: () => void;
+    cancelColumnLayoutPanel: () => void;
+    applyColumnLayoutPanel: () => void;
+    moveColumnUp: (key: string) => void;
+    moveColumnDown: (key: string) => void;
+    updateColumnVisibility: (patch: DataGridAppColumnLayoutVisibilityPatch) => void;
+}
+export declare function useDataGridAppColumnLayoutPanel(options: UseDataGridAppColumnLayoutPanelOptions): UseDataGridAppColumnLayoutPanelResult;
+export {};
+//# sourceMappingURL=useDataGridAppColumnLayoutPanel.d.ts.map

package/dist/app/useDataGridAppColumnLayoutPanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridAppColumnLayoutPanel.d.ts","sourceRoot":"","sources":["../../src/app/useDataGridAppColumnLayoutPanel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,KAAK,CAAA;AACrD,OAAO,KAAK,EACV,mCAAmC,EACnC,kCAAkC,EAClC,gCAAgC,EAChC,sCAAsC,EACvC,MAAM,2BAA2B,CAAA;AAElC,UAAU,sCAAsC;IAC9C,cAAc,EAAE,MAAM,SAAS,kCAAkC,EAAE,CAAA;IACnE,iBAAiB,EAAE,CAAC,OAAO,EAAE,mCAAmC,KAAK,IAAI,CAAA;CAC1E;AAED,MAAM,WAAW,qCAAqC;IACpD,uBAAuB,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC7C,sBAAsB,EAAE,WAAW,CAAC,SAAS,gCAAgC,EAAE,CAAC,CAAA;IAChF,qBAAqB,EAAE,MAAM,IAAI,CAAA;IACjC,uBAAuB,EAAE,MAAM,IAAI,CAAA;IACnC,sBAAsB,EAAE,MAAM,IAAI,CAAA;IAClC,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;IACrC,sBAAsB,EAAE,CAAC,KAAK,EAAE,sCAAsC,KAAK,IAAI,CAAA;CAChF;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,sCAAsC,GAC9C,qCAAqC,CAqFvC"}