@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/hooks/use-on-paste.js

@@ -0,0 +1,868 @@
+import { isStaticNode } from "@rowsncolumns/dag";
+import { areaIntersects, isAreasEqual } from "@rowsncolumns/grid";
+import { selectionFromActiveCell } from "@rowsncolumns/grid";
+import { DEFAULT_COLUMN_COUNT, DEFAULT_ROW_COUNT, findActiveTableWithinCell, loadWebFont, MAX_COLUMN_COUNT, MAX_ROW_COUNT, useFocusEmbedOrChart, useGetFinalRowHeight, useRedrawGrid, } from "@rowsncolumns/spreadsheet";
+import { isSelectionACell, useGetEffectiveValuesFromRange, } from "@rowsncolumns/spreadsheet";
+import { error, getCellFormattedValue, getCellUserEnteredFormat, getCellUserEnteredValue, getExtendedValueBool, getExtendedValueFormula, getExtendedValueNumber, getExtendedValueString, isNil, iterateCellsInRange, uuidString, } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { processSideEffectDependentCells } from "../api/dependency";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { findAdjacentTable, findTableColumnIndex } from "../api/table";
+import { addCalculatedColumnsForRowExpansion } from "../interface/change-table-column";
+import { collectDataValidationTarget, extendDataValidationRanges, } from "../interface/data-validation-utils";
+import { SheetCell } from "../sheet-cell";
+import { extractFontFamily, generateDataFromClipboard, pickFormatting, pickFormula, pickValue, transpose, } from "./../api/copy-paste";
+import { useCalculationQueue } from "./use-calculation-queue";
+import { useCanEditCellRange } from "./use-can-edit-cellrange";
+import { useOnChangeCalculatedColumn } from "./use-on-change-calculated-column";
+import { useOnChangeTableColumn } from "./use-on-change-table-column";
+export const buildDestinationRowAssignments = (sheetId, startRowIndex, endRowIndex, rowSpan, isRowHidden) => {
+    const assignments = [];
+    const effectiveRowSpan = Math.max(rowSpan, 1);
+    let rowCursor = 0;
+    for (let rowIndex = startRowIndex; rowIndex <= endRowIndex; rowIndex++, rowCursor++) {
+        const hidden = isRowHidden(sheetId, rowIndex);
+        if (hidden) {
+            continue;
+        }
+        const dataRowIndex = rowCursor % effectiveRowSpan;
+        assignments.push({ rowIndex, dataRowIndex });
+    }
+    return assignments;
+};
+export const useOnPaste = ({ rowCount, columnCount, locale, sheetData, tables: currentTables, maxRowCount = MAX_ROW_COUNT, maxColumnCount = MAX_COLUMN_COUNT, isHiddenByFilterRow, onRequestFonts, idCreationStrategy, createHistory, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, onChangeSheetData, onChangeSheets, onChangeTables, onChangeEmbeds, onChangeSelections, onChangeActiveCell, getDependents, getActiveCell, getUserEnteredValue, onChangeDataValidations, preserveFormatting = true, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getSheetName, onError, citations, onChangeCitations, sanitizeHtml, onCommand, generatedNames, }) => {
+    const canEditCellRange = useCanEditCellRange();
+    // Allowed values
+    const getEffectiveValuesFromRange = useGetEffectiveValuesFromRange();
+    const focusEmbedOrChart = useFocusEmbedOrChart();
+    const onChangeCalculatedColumn = useOnChangeCalculatedColumn({
+        locale,
+        createHistory,
+        enqueueCalculation,
+        getUserEnteredValue,
+        onChangeSheetData,
+        onChangeTables,
+        getSheetName,
+        onCommand,
+    });
+    const onChangeTableColumn = useOnChangeTableColumn({
+        locale,
+        createHistory,
+        enqueueCalculation,
+        enqueueGraphOperation,
+        onChangeSheetData,
+        onChangeTables,
+        getDependents,
+        onCommand,
+        generatedNames,
+    });
+    const redrawGrid = useRedrawGrid();
+    const getFinalRowHeight = useGetFinalRowHeight();
+    const { enqueue, processQueue } = useCalculationQueue({ enqueueCalculation });
+    return useCallback(async (e, sourceSheetId, destinationSheetId, copiedSelections, activeCell, selections, finalSelections, isCutOperation) => {
+        const pasteSpecialType = e?.clipboardData?.getData("pasteSpecialType");
+        const pasteEvent = e;
+        const forcePlainText = Boolean(pasteEvent?.__forcePlainText ||
+            (pasteEvent?.shiftKey &&
+                (pasteEvent?.metaKey || pasteEvent?.ctrlKey)));
+        const activeSheetName = getSheetName(destinationSheetId);
+        const from = copiedSelections?.[0];
+        // Merges
+        let merges;
+        // Embeds
+        let embeds;
+        // Tables
+        let tables;
+        // columnwidths
+        let columnWidths;
+        // rowHeights
+        let rowHeights;
+        // Delete source if required
+        // Move values
+        let selectedRowValues = [];
+        if (isCutOperation && from && !isNil(sourceSheetId)) {
+            for (let rowIndex = from.range.startRowIndex; rowIndex <= from.range.endRowIndex; rowIndex++) {
+                // const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                const start = from.range.startColumnIndex;
+                const end = start + from.range.endColumnIndex - from.range.startColumnIndex + 1;
+                selectedRowValues.push(sheetData?.[sourceSheetId]?.[rowIndex]?.values?.slice(start, end) ??
+                    []);
+            }
+        }
+        else {
+            const pasteResults = await generateDataFromClipboard(e, activeCell, destinationSheetId, activeSheetName, preserveFormatting, locale, idCreationStrategy, forcePlainText, sanitizeHtml, generatedNames);
+            selectedRowValues = pasteResults?.results ?? [];
+            merges = pasteResults?.merges;
+            embeds = pasteResults?.embeds;
+            tables = pasteResults?.tables;
+            rowHeights = pasteResults?.rowHeights;
+            columnWidths = pasteResults?.columnWidths;
+        }
+        // No data,
+        if (isNil(selectedRowValues)) {
+            return;
+        }
+        if (pasteSpecialType === "Transposed") {
+            selectedRowValues = transpose(selectedRowValues);
+        }
+        else if (pasteSpecialType === "Formatting") {
+            selectedRowValues = pickFormatting(selectedRowValues);
+        }
+        else if (pasteSpecialType === "Formula") {
+            selectedRowValues = pickFormula(selectedRowValues, destinationSheetId, locale);
+        }
+        else if (pasteSpecialType === "Value") {
+            selectedRowValues = pickValue(selectedRowValues, destinationSheetId, locale);
+        }
+        const saveHistory = createHistory();
+        const dataValidationTargets = new Map();
+        const fontFamilies = extractFontFamily(selectedRowValues);
+        // Wait for fonts to load
+        if (fontFamilies.length && preserveFormatting) {
+            const fontFamiliesWithWeights = fontFamilies
+                .map((family) => [`${family}:400`, `${family}:700`])
+                .flat();
+            try {
+                if (onRequestFonts) {
+                    await onRequestFonts(fontFamilies);
+                }
+                else {
+                    await loadWebFont(fontFamiliesWithWeights);
+                }
+                redrawGrid?.();
+            }
+            catch (err) {
+                error("Error loading webfonts", fontFamilies, err);
+            }
+        }
+        const [rowSpan, colSpan] = [
+            selectedRowValues?.length ?? 0,
+            // For cut operations, use range dimensions since data may be sparse
+            isCutOperation && from
+                ? from.range.endColumnIndex - from.range.startColumnIndex + 1
+                : selectedRowValues[0]?.length ?? 0,
+        ];
+        const to = selections?.[selections?.length - 1] ??
+            selectionFromActiveCell(activeCell)[0];
+        const rowDelta = from && to ? to.range.startRowIndex - from.range.startRowIndex : -1;
+        const columnDelta = from && to
+            ? to.range.startColumnIndex - from.range.startColumnIndex
+            : -1;
+        // When user enters a value in the last row of a
+        // table and if the entire row is empty
+        const [adjacentTable, isRowExpansion, isColumnExpansion] = findAdjacentTable(destinationSheetId, activeCell, currentTables, getUserEnteredValue);
+        const currentTable = isColumnExpansion && adjacentTable
+            ? adjacentTable
+            : findActiveTableWithinCell(destinationSheetId, activeCell, currentTables);
+        // Next selections
+        const nextSelections = finalSelections?.length ? finalSelections : [to];
+        // Update range based on length of data
+        to.range.endRowIndex = Math.min(maxRowCount, Math.max(to.range.endRowIndex, to.range.startRowIndex + rowSpan - 1));
+        to.range.endColumnIndex = Math.min(maxColumnCount, Math.max(to.range.endColumnIndex, to.range.startColumnIndex + colSpan - 1));
+        // Check for protected range
+        if (!canEditCellRange(destinationSheetId, to.range)) {
+            console.debug("Protected range, You cannot paste on to protected cells.");
+            return;
+        }
+        // Check if pasting a table would overlap with an existing table
+        if (tables?.length) {
+            const existingTable = currentTables?.find((table) => table.sheetId === destinationSheetId &&
+                areaIntersects(to.range, table.range));
+            if (existingTable) {
+                onError?.("Cannot paste a table over another table. The paste range overlaps with an existing table.");
+                return;
+            }
+        }
+        const destinationRows = buildDestinationRowAssignments(destinationSheetId, to.range.startRowIndex, to.range.endRowIndex, rowSpan, isHiddenByFilterRow);
+        if (!destinationRows.length) {
+            return;
+        }
+        // Paste writes through `onChangeSheetData` directly, so the
+        // calculator's per-cell invalidation never fires for the
+        // destination cells. Invalidate the destination rect — and the
+        // source on cut, since those cells are cleared too.
+        enqueueStructureChange?.({
+            kind: "invalidate-range",
+            sheetId: destinationSheetId,
+            startRowIndex: to.range.startRowIndex,
+            endRowIndex: to.range.endRowIndex,
+            startColumnIndex: to.range.startColumnIndex,
+            endColumnIndex: to.range.endColumnIndex,
+        });
+        if (isCutOperation && from && !isNil(sourceSheetId)) {
+            enqueueStructureChange?.({
+                kind: "invalidate-range",
+                sheetId: sourceSheetId,
+                startRowIndex: from.range.startRowIndex,
+                endRowIndex: from.range.endRowIndex,
+                startColumnIndex: from.range.startColumnIndex,
+                endColumnIndex: from.range.endColumnIndex,
+            });
+        }
+        const visibleRowIndexes = destinationRows.map(({ rowIndex }) => rowIndex);
+        // Check if the user is editing a table column
+        const tableHeaderColumnIndex = findTableColumnIndex(destinationSheetId, activeCell, currentTables);
+        // Adds new column to table and cell to sheet
+        const cellValue = selectedRowValues?.[0]?.[0];
+        const formattedValue = getCellFormattedValue(cellValue);
+        const sharedStrings = sharedStringRegistry?.getSharedStrings();
+        const sharedStringValue = cellValue?.ss == null || !sharedStrings
+            ? undefined
+            : sharedStrings.get(String(cellValue.ss));
+        const activeCellValue = typeof formattedValue === "string"
+            ? formattedValue
+            : typeof sharedStringValue === "string"
+                ? sharedStringValue
+                : undefined;
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        // Expand table if user is pasting
+        // table data
+        // Same undo history
+        if (!isNil(currentTable) && !isRowExpansion) {
+            const newEndRowIndex = Math.max(currentTable.range.endRowIndex, activeCell.rowIndex + rowSpan - 1 + (currentTable.totalRow ? 1 : 0));
+            // Update table range
+            onChangeTables?.((prevTableData) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevTableData, (draft) => {
+                    const table = draft.find((table) => currentTable?.id === table.id);
+                    if (table) {
+                        table.range.endRowIndex = newEndRowIndex;
+                        // Update table name
+                        if (!isNil(tableHeaderColumnIndex)) {
+                            if (table.columns?.length) {
+                                if (!table.columns[tableHeaderColumnIndex]) {
+                                    table.columns[tableHeaderColumnIndex] = {
+                                        name: String(activeCellValue),
+                                    };
+                                }
+                                else {
+                                    // Update name
+                                    table.columns[tableHeaderColumnIndex].name =
+                                        String(activeCellValue);
+                                }
+                            }
+                        }
+                    }
+                });
+                saveHistory({
+                    tables: { patches, inversePatches },
+                });
+                return nextState;
+            });
+        }
+        // Update sheetdata
+        // Capture the produced state so we can stream the exact written cells to an engine
+        // consumer afterwards (branch-agnostic across cut / pure-paste / paste-special).
+        let pastedSheetData;
+        if (selectedRowValues.length) {
+            onChangeSheetData?.((prevSheetData) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                    // For cut operation
+                    const movedKeys = new Set();
+                    /**
+                     * If user is deleting source cells,
+                     * let update its dependents and mark it as dirty
+                     */
+                    if (isCutOperation && from && to && !isNil(sourceSheetId)) {
+                        const sheetId = sourceSheetId;
+                        for (const [rowIndex, columnIndex] of iterateCellsInRange(from.range)) {
+                            // Process dependents
+                            processSideEffectDependentCells({
+                                draft,
+                                rowIndex,
+                                columnIndex,
+                                sheetId,
+                                destinationSheetId,
+                                columnDelta,
+                                enqueueGraphOperation,
+                                enqueueCalculation: enqueue,
+                                getDependents,
+                                recalcCells,
+                                rowDelta,
+                                sourceRange: from.range,
+                                movedKeys,
+                                locale,
+                                rowCount,
+                                columnCount,
+                            });
+                        }
+                        // Snapshot source after dependent/formula rewrites, before
+                        // clearing it. The pre-cut clipboard snapshot still contains
+                        // stale formulas, so writing that snapshot would discard the
+                        // reference updates performed above.
+                        const movedRowValues = [];
+                        const sourceStartColumn = from.range.startColumnIndex;
+                        const sourceEndColumn = from.range.endColumnIndex + 1;
+                        for (let rowIndex = from.range.startRowIndex; rowIndex <= from.range.endRowIndex; rowIndex++) {
+                            movedRowValues.push((draft[sheetId]?.[rowIndex]?.values?.slice(sourceStartColumn, sourceEndColumn) ?? []));
+                        }
+                        // Delete source if required
+                        // Move values
+                        for (let rowIndex = from.range.startRowIndex; rowIndex <= from.range.endRowIndex; rowIndex++) {
+                            for (let columnIndex = from.range.startColumnIndex; columnIndex <= from.range.endColumnIndex; columnIndex++) {
+                                if (!draft[sheetId][rowIndex]?.values?.[columnIndex]) {
+                                    continue;
+                                }
+                                draft[sheetId][rowIndex].values[columnIndex] =
+                                    {};
+                            }
+                        }
+                        for (const { rowIndex, dataRowIndex } of destinationRows) {
+                            const currentSheet = createSheetDraft(draft, destinationSheetId, rowIndex);
+                            let columnCursor = 0;
+                            for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++, columnCursor++) {
+                                const dataColumnIndex = colSpan > 0 ? columnCursor % colSpan : 0;
+                                currentSheet[rowIndex].values[columnIndex] =
+                                    movedRowValues[dataRowIndex]?.[dataColumnIndex];
+                                for (const dependent of getDependents({
+                                    rowIndex,
+                                    columnIndex,
+                                    sheetId: destinationSheetId,
+                                })) {
+                                    if (isStaticNode(dependent)) {
+                                        continue;
+                                    }
+                                    const { position } = dependent;
+                                    enqueue({
+                                        type: "add",
+                                        position,
+                                        force: true,
+                                    });
+                                    recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), position);
+                                }
+                                collectDataValidationTarget(dataValidationTargets, destinationSheetId, rowIndex, columnIndex, currentSheet[rowIndex].values[columnIndex]);
+                            }
+                        }
+                    }
+                    if (currentTable && !isRowExpansion) {
+                        addCalculatedColumnsForRowExpansion({
+                            sheetId: destinationSheetId,
+                            currentTable,
+                            draft,
+                            enqueueCalculation: enqueue,
+                            recalcCells,
+                            locale,
+                            range: to.range,
+                            getDependents,
+                        });
+                    }
+                    // TBD: Move totalrow for tables
+                    // We are doing pure paste operation
+                    if (!isCutOperation) {
+                        const sheetCell = new SheetCell();
+                        const sourceCell = {
+                            rowIndex: to.range.startRowIndex,
+                            columnIndex: to.range.startColumnIndex,
+                        };
+                        for (const { rowIndex, dataRowIndex } of destinationRows) {
+                            const currentSheet = createSheetDraft(draft, destinationSheetId, rowIndex);
+                            let columnCursor = 0;
+                            for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++, columnCursor++) {
+                                const dataColumnIndex = colSpan > 0 ? columnCursor % colSpan : 0;
+                                let cellValue = selectedRowValues[dataRowIndex]?.[dataColumnIndex];
+                                if (pasteSpecialType === "Formatting") {
+                                    const existingCellData = prevSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex];
+                                    cellValue = { ...existingCellData, ...cellValue };
+                                    sheetCell.extendCellData(cellValue);
+                                }
+                                if (pasteSpecialType === "Value" || forcePlainText) {
+                                    const existingCellData = prevSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex];
+                                    // Remove ss from existingCellData since we're replacing the value
+                                    const { ss: _ss, ...existingWithoutSs } = existingCellData ?? {};
+                                    cellValue = { ...existingWithoutSs, ...cellValue };
+                                    sheetCell.extendCellData(cellValue);
+                                }
+                                if (pasteSpecialType === "Transposed") {
+                                    sheetCell.assign(destinationSheetId, { rowIndex, columnIndex }, prevSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex], {
+                                        locale,
+                                        cellXfsRegistry,
+                                        getDataValidationById,
+                                        sharedStringRegistry,
+                                    });
+                                    const existingCellData = sheetCell.getUserCellData();
+                                    cellValue = { ...existingCellData, ...cellValue };
+                                    sheetCell.extendCellData(cellValue);
+                                }
+                                else {
+                                    sheetCell.assign(destinationSheetId, { rowIndex, columnIndex }, typeof cellValue === "object"
+                                        ? cellValue
+                                        : undefined, {
+                                        getRangeValues: getEffectiveValuesFromRange,
+                                        locale,
+                                        cellXfsRegistry,
+                                        getDataValidationById,
+                                        sharedStringRegistry,
+                                    });
+                                }
+                                if (pasteSpecialType === "Formatting") {
+                                    sheetCell.refreshFormattedValue();
+                                }
+                                if (sheetCell.isFormula()) {
+                                    if (dataRowIndex === 0 && dataColumnIndex === 0) {
+                                        sheetCell.moveFormula(sourceCell, {
+                                            rowIndex,
+                                            columnIndex,
+                                        }, activeSheetName, { preserveAbsolutes: true });
+                                    }
+                                    sheetCell.setLoading();
+                                    enqueue({
+                                        type: "add",
+                                        position: {
+                                            rowIndex,
+                                            columnIndex,
+                                            sheetId: destinationSheetId,
+                                        },
+                                        force: true,
+                                    });
+                                    recalcCells.set(createSheetCellIdentifier(destinationSheetId, rowIndex, columnIndex), {
+                                        rowIndex,
+                                        columnIndex,
+                                        sheetId: destinationSheetId,
+                                    });
+                                }
+                                for (const dependent of getDependents({
+                                    rowIndex,
+                                    columnIndex,
+                                    sheetId: destinationSheetId,
+                                })) {
+                                    if (isStaticNode(dependent)) {
+                                        continue;
+                                    }
+                                    const { position } = dependent;
+                                    enqueue({
+                                        type: "add",
+                                        position,
+                                        force: true,
+                                    });
+                                    recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), position);
+                                }
+                                sharedStringRegistry?.registerCell(sheetCell);
+                                currentSheet[rowIndex].values[columnIndex] =
+                                    sheetCell.getCellData();
+                                collectDataValidationTarget(dataValidationTargets, destinationSheetId, rowIndex, columnIndex, currentSheet[rowIndex].values[columnIndex]);
+                                cellXfsRegistry?.registerCellXfs(sheetCell);
+                            }
+                        }
+                    }
+                });
+                saveHistory({
+                    sheetData: { patches, inversePatches },
+                    recalcCells: { undo: recalcCells, redo: recalcCells },
+                    activeCell: {
+                        undo: getActiveCell(),
+                        redo: getActiveCell(),
+                    },
+                    selections: {
+                        undo: undefined,
+                        redo: isSelectionACell(nextSelections) ? undefined : [to],
+                    },
+                });
+                extendDataValidationRanges(dataValidationTargets, onChangeDataValidations, saveHistory);
+                processQueue();
+                pastedSheetData = nextState;
+                return nextState;
+            });
+            // Save registries
+            cellXfsRegistry?.getPatches(saveHistory);
+            sharedStringRegistry?.getPatches(saveHistory);
+            // Update row or column count
+            // Change sheets
+            onChangeSheets?.((prevSheets) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                    const sheet = draft.find((sheet) => sheet.sheetId === destinationSheetId);
+                    if (sheet) {
+                        sheet.rowCount = Math.min(maxRowCount, Math.max(sheet.rowCount ?? DEFAULT_ROW_COUNT, to.range.endRowIndex));
+                        sheet.columnCount = Math.min(maxColumnCount, Math.max(sheet.columnCount ?? DEFAULT_COLUMN_COUNT, to.range.endColumnIndex));
+                        // Handle merges for cut operations
+                        let mergesToAdd = merges;
+                        if (isCutOperation && from && !isNil(sourceSheetId)) {
+                            const sourceSheet = prevSheets.find((s) => s.sheetId === sourceSheetId);
+                            if (sourceSheet?.merges) {
+                                // Extract merged cells from source range
+                                const cutMerges = [];
+                                for (const merge of sourceSheet.merges) {
+                                    // Check if merge intersects with the cut range
+                                    if (areaIntersects(merge, from.range)) {
+                                        // Calculate new merge coordinates relative to destination
+                                        cutMerges.push({
+                                            startRowIndex: merge.startRowIndex + rowDelta,
+                                            startColumnIndex: merge.startColumnIndex + columnDelta,
+                                            endRowIndex: merge.endRowIndex + rowDelta,
+                                            endColumnIndex: merge.endColumnIndex + columnDelta,
+                                        });
+                                    }
+                                }
+                                if (cutMerges.length > 0) {
+                                    mergesToAdd = cutMerges;
+                                }
+                                // Remove merges from source sheet
+                                const sourceSheetDraft = draft.find((s) => s.sheetId === sourceSheetId);
+                                if (sourceSheetDraft?.merges) {
+                                    sourceSheetDraft.merges = sourceSheetDraft.merges.filter((merge) => !areaIntersects(merge, from.range));
+                                }
+                            }
+                        }
+                        // Update merges
+                        if (mergesToAdd) {
+                            sheet.merges = sheet.merges ?? [];
+                            for (const merge of mergesToAdd) {
+                                const exists = sheet.merges.find((range) => isAreasEqual(range, merge));
+                                if (!exists) {
+                                    sheet.merges.push(merge);
+                                }
+                            }
+                        }
+                        // Row heights
+                        const clipboardSizedRows = new Set();
+                        if (rowHeights) {
+                            if (!sheet.rowMetadata) {
+                                sheet.rowMetadata = [];
+                            }
+                            for (let index = 0; index < rowHeights.length; index++) {
+                                const curHeight = rowHeights[index];
+                                if (isNil(curHeight) || curHeight === 0) {
+                                    continue;
+                                }
+                                const rowIndex = visibleRowIndexes[index];
+                                if (isNil(rowIndex)) {
+                                    break;
+                                }
+                                if (!sheet.rowMetadata[rowIndex]) {
+                                    sheet.rowMetadata[rowIndex] = {};
+                                }
+                                sheet.rowMetadata[rowIndex].size = curHeight;
+                                clipboardSizedRows.add(rowIndex);
+                            }
+                        }
+                        // Auto-resize rows whose pasted content needs more room
+                        // (multi-line text or wrap). Mirrors use-on-change's
+                        // adjustRowHeight, but batched into this immer pass so the
+                        // whole paste collapses to one undo entry. Skip conditions
+                        // make the common single-line-text paste do zero work.
+                        // Skipped for paste-special variants since the destination
+                        // cell ends up as a merge of existing + pasted data, not
+                        // the raw pasted value we can read from selectedRowValues.
+                        const skipAutoResize = pasteSpecialType === "Formatting" ||
+                            pasteSpecialType === "Value" ||
+                            pasteSpecialType === "Formula" ||
+                            pasteSpecialType === "Transposed";
+                        if (!skipAutoResize &&
+                            getFinalRowHeight &&
+                            selectedRowValues.length &&
+                            colSpan > 0) {
+                            for (const { rowIndex, dataRowIndex } of destinationRows) {
+                                // Clipboard-provided row heights win.
+                                if (clipboardSizedRows.has(rowIndex))
+                                    continue;
+                                const rowData = selectedRowValues[dataRowIndex];
+                                if (!rowData)
+                                    continue;
+                                // Find the cell most likely to drive row height —
+                                // most lines first, then any wrap. If no cell in
+                                // the row needs more than one line and no cell is
+                                // wrapped, the row's existing height already fits.
+                                let bestLines = 1;
+                                let bestColumnIndex;
+                                let bestCell;
+                                let bestHasWrap = false;
+                                let columnCursor = 0;
+                                for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++, columnCursor++) {
+                                    const dataColumnIndex = columnCursor % colSpan;
+                                    const cellValue = rowData[dataColumnIndex];
+                                    if (!cellValue || typeof cellValue !== "object")
+                                        continue;
+                                    const ue = getCellUserEnteredValue(cellValue);
+                                    const text = getExtendedValueString(ue);
+                                    const lines = typeof text === "string" && text.includes("\n")
+                                        ? text.split("\n").length
+                                        : 1;
+                                    const uf = getCellUserEnteredFormat(cellValue);
+                                    const wrap = uf
+                                        ?.wrapStrategy === "wrap";
+                                    if (lines > bestLines ||
+                                        (lines === bestLines && wrap && !bestHasWrap)) {
+                                        bestLines = lines;
+                                        bestCell = cellValue;
+                                        bestColumnIndex = columnIndex;
+                                        bestHasWrap = wrap;
+                                    }
+                                }
+                                if (!bestCell ||
+                                    bestColumnIndex === undefined ||
+                                    (bestLines === 1 && !bestHasWrap)) {
+                                    continue;
+                                }
+                                const ue = getCellUserEnteredValue(bestCell);
+                                const overrideText = getExtendedValueString(ue) ?? "";
+                                const uf = getCellUserEnteredFormat(bestCell);
+                                const height = getFinalRowHeight(destinationSheetId, rowIndex, bestColumnIndex, {
+                                    textOverride: String(overrideText),
+                                    textFormatOverride: uf?.textFormat,
+                                    shouldWrapOverride: bestHasWrap,
+                                });
+                                if (typeof height === "number" && height > 0) {
+                                    if (!sheet.rowMetadata)
+                                        sheet.rowMetadata = [];
+                                    if (!sheet.rowMetadata[rowIndex]) {
+                                        sheet.rowMetadata[rowIndex] = {};
+                                    }
+                                    sheet.rowMetadata[rowIndex].size = height;
+                                    sheet.rowMetadata[rowIndex].resizedByUser = false;
+                                }
+                            }
+                        }
+                        // column widths
+                        if (columnWidths) {
+                            if (!sheet.columnMetadata) {
+                                sheet.columnMetadata = [];
+                            }
+                            for (let index = 0; index < columnWidths.length; index++) {
+                                const curWidth = columnWidths[index];
+                                if (isNil(curWidth) || curWidth === 0) {
+                                    continue;
+                                }
+                                const columnIndex = to.range.startColumnIndex + index;
+                                if (!sheet.columnMetadata?.[columnIndex]) {
+                                    sheet.columnMetadata[columnIndex] = {};
+                                }
+                                sheet.columnMetadata[columnIndex].size =
+                                    columnWidths[index];
+                            }
+                        }
+                    }
+                });
+                saveHistory({
+                    sheets: { patches, inversePatches },
+                });
+                return nextState;
+            });
+            // For row expansions, add columns
+            onChangeTableColumn(destinationSheetId, activeCell, activeCellValue ?? undefined, adjacentTable, isRowExpansion, isColumnExpansion, to.range);
+            // Add calculated column
+            onChangeCalculatedColumn(destinationSheetId, activeCell, activeCellValue ?? undefined, currentTable);
+            // Update new selections
+            if (!isSelectionACell(nextSelections)) {
+                onChangeSelections?.(destinationSheetId, [to]);
+            }
+            // Update active cell
+            onChangeActiveCell(destinationSheetId, { ...getActiveCell() });
+            // Stream the paste to an engine consumer. The clipboard is a bounded payload (not
+            // windowed), so paste can resolve the destination cells UI-side; we read back the
+            // user-entered values the paste actually produced — relocated formulas, paste-special
+            // merges, shared-string text — and replay them as a `change-batch` the engine recomputes
+            // from. Reading the produced state (rather than re-deriving) keeps this correct across the
+            // cut / pure-paste / paste-special branches without duplicating their logic.
+            if (onCommand && pastedSheetData) {
+                const values = [];
+                for (let rowIndex = to.range.startRowIndex; rowIndex <= to.range.endRowIndex; rowIndex++) {
+                    const row = [];
+                    for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++) {
+                        const cell = pastedSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex];
+                        const ue = cell ? getCellUserEnteredValue(cell) : undefined;
+                        // Formula text wins (e.g. "=SUM(A1:A2)"), else the literal string / number / bool.
+                        // `??` (not `||`) so 0 and false survive; `null` clears the cell.
+                        row.push(getExtendedValueFormula(ue) ??
+                            getExtendedValueString(ue) ??
+                            getExtendedValueNumber(ue) ??
+                            getExtendedValueBool(ue) ??
+                            null);
+                    }
+                    values.push(row);
+                }
+                onCommand({
+                    command: "change-batch",
+                    sheetId: destinationSheetId,
+                    ranges: to.range,
+                    values,
+                });
+                // On cut, the source cells were cleared — mirror that so the engine drops them too.
+                if (isCutOperation && from && !isNil(sourceSheetId)) {
+                    onCommand({
+                        command: "delete-cells",
+                        sheetId: sourceSheetId,
+                        activeCell: {
+                            rowIndex: from.range.startRowIndex,
+                            columnIndex: from.range.startColumnIndex,
+                        },
+                        selections: [{ range: from.range }],
+                    });
+                }
+            }
+        }
+        // Embeds
+        if (embeds?.length) {
+            const firstEmbedId = embeds[0].embedId;
+            onChangeEmbeds?.((prevEmbeds) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevEmbeds, (draft) => {
+                    draft.push(...embeds);
+                });
+                saveHistory({
+                    embeds: { patches, inversePatches },
+                    selectedEmbedOrChart: { redo: firstEmbedId, undo: undefined },
+                });
+                return nextState;
+            });
+            // Selected first embed
+            focusEmbedOrChart(embeds[0].embedId);
+        }
+        // Tables
+        if (tables?.length) {
+            onChangeTables?.((prevTables) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                    draft.push(...tables);
+                });
+                saveHistory({
+                    tables: { patches, inversePatches },
+                });
+                return nextState;
+            });
+        }
+        // Handle citations
+        if (selectedRowValues.length && onChangeCitations) {
+            // Collect citationIds from pasted cells
+            const citationIdMap = new Map();
+            for (let dataRowIndex = 0; dataRowIndex < rowSpan; dataRowIndex++) {
+                const rowData = selectedRowValues[dataRowIndex];
+                if (!rowData)
+                    continue;
+                for (let dataColumnIndex = 0; dataColumnIndex < colSpan; dataColumnIndex++) {
+                    const cellValue = rowData[dataColumnIndex];
+                    if (cellValue &&
+                        typeof cellValue === "object" &&
+                        "citationId" in cellValue &&
+                        cellValue.citationId) {
+                        citationIdMap.set(cellValue.citationId, {
+                            sourceRowIndex: dataRowIndex,
+                            sourceColumnIndex: dataColumnIndex,
+                        });
+                    }
+                }
+            }
+            if (citationIdMap.size > 0) {
+                if (isCutOperation && from && !isNil(sourceSheetId)) {
+                    // For cut operation: Move citations to new position
+                    onChangeCitations((prevCitations) => {
+                        const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                            for (const citationId of citationIdMap.keys()) {
+                                const citation = draft.find((c) => c.id === citationId);
+                                if (citation) {
+                                    // Update citation range to new position
+                                    citation.range.sheetId = destinationSheetId;
+                                    citation.range.startRowIndex += rowDelta;
+                                    citation.range.endRowIndex += rowDelta;
+                                    citation.range.startColumnIndex += columnDelta;
+                                    citation.range.endColumnIndex += columnDelta;
+                                }
+                            }
+                        });
+                        saveHistory({
+                            citations: { patches, inversePatches },
+                        });
+                        return nextState;
+                    });
+                }
+                else if (!isCutOperation) {
+                    // For paste (copy) operation: Create new citations with new IDs
+                    const newCitations = [];
+                    const citationIdRemap = new Map();
+                    for (const [oldCitationId, { sourceRowIndex, sourceColumnIndex },] of citationIdMap.entries()) {
+                        const originalCitation = citations?.find((c) => c.id === oldCitationId);
+                        if (originalCitation) {
+                            const newId = uuidString();
+                            citationIdRemap.set(oldCitationId, newId);
+                            // Calculate the new range based on paste destination
+                            const newCitation = {
+                                ...originalCitation,
+                                id: newId,
+                                range: {
+                                    sheetId: destinationSheetId,
+                                    startRowIndex: to.range.startRowIndex + sourceRowIndex,
+                                    endRowIndex: to.range.startRowIndex + sourceRowIndex,
+                                    startColumnIndex: to.range.startColumnIndex + sourceColumnIndex,
+                                    endColumnIndex: to.range.startColumnIndex + sourceColumnIndex,
+                                },
+                            };
+                            newCitations.push(newCitation);
+                        }
+                    }
+                    if (newCitations.length > 0) {
+                        // Add new citations
+                        onChangeCitations((prevCitations) => {
+                            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                                draft.push(...newCitations);
+                            });
+                            saveHistory({
+                                citations: { patches, inversePatches },
+                            });
+                            return nextState;
+                        });
+                        // Update cell citationIds to point to new citations
+                        onChangeSheetData?.((prevSheetData) => {
+                            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                                for (const { rowIndex } of destinationRows) {
+                                    for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++) {
+                                        const cellData = draft[destinationSheetId]?.[rowIndex]?.values?.[columnIndex];
+                                        if (cellData?.citationId) {
+                                            const newCitationId = citationIdRemap.get(cellData.citationId);
+                                            if (newCitationId) {
+                                                cellData.citationId = newCitationId;
+                                            }
+                                        }
+                                    }
+                                }
+                            });
+                            saveHistory({
+                                sheetData: { patches, inversePatches },
+                            });
+                            return nextState;
+                        });
+                    }
+                }
+            }
+        }
+    }, [
+        rowCount,
+        columnCount,
+        locale,
+        sheetData,
+        preserveFormatting,
+        maxRowCount,
+        maxColumnCount,
+        cellXfsRegistry,
+        currentTables,
+        sharedStringRegistry,
+        onChangeDataValidations,
+        getDataValidationById,
+        onRequestFonts,
+        idCreationStrategy,
+        createHistory,
+        enqueueStructureChange,
+        enqueueGraphOperation,
+        onChangeCalculatedColumn,
+        onChangeTableColumn,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeTables,
+        getDependents,
+        getActiveCell,
+        onChangeSelections,
+        onChangeEmbeds,
+        onChangeActiveCell,
+        canEditCellRange,
+        getEffectiveValuesFromRange,
+        getUserEnteredValue,
+        focusEmbedOrChart,
+        redrawGrid,
+        processQueue,
+        enqueue,
+        isHiddenByFilterRow,
+        getSheetName,
+        citations,
+        onChangeCitations,
+        getFinalRowHeight,
+        onCommand,
+        generatedNames,
+    ]);
+};