@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,985 @@
+import { __assign, __awaiter, __generator, __read, __rest, __spreadArray, __values } from "tslib";
+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 var buildDestinationRowAssignments = function (sheetId, startRowIndex, endRowIndex, rowSpan, isRowHidden) {
+    var assignments = [];
+    var effectiveRowSpan = Math.max(rowSpan, 1);
+    var rowCursor = 0;
+    for (var rowIndex = startRowIndex; rowIndex <= endRowIndex; rowIndex++, rowCursor++) {
+        var hidden = isRowHidden(sheetId, rowIndex);
+        if (hidden) {
+            continue;
+        }
+        var dataRowIndex = rowCursor % effectiveRowSpan;
+        assignments.push({ rowIndex: rowIndex, dataRowIndex: dataRowIndex });
+    }
+    return assignments;
+};
+export var useOnPaste = function (_a) {
+    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, sheetData = _a.sheetData, currentTables = _a.tables, _b = _a.maxRowCount, maxRowCount = _b === void 0 ? MAX_ROW_COUNT : _b, _c = _a.maxColumnCount, maxColumnCount = _c === void 0 ? MAX_COLUMN_COUNT : _c, isHiddenByFilterRow = _a.isHiddenByFilterRow, onRequestFonts = _a.onRequestFonts, idCreationStrategy = _a.idCreationStrategy, createHistory = _a.createHistory, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, enqueueGraphOperation = _a.enqueueGraphOperation, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeEmbeds = _a.onChangeEmbeds, onChangeSelections = _a.onChangeSelections, onChangeActiveCell = _a.onChangeActiveCell, getDependents = _a.getDependents, getActiveCell = _a.getActiveCell, getUserEnteredValue = _a.getUserEnteredValue, onChangeDataValidations = _a.onChangeDataValidations, _d = _a.preserveFormatting, preserveFormatting = _d === void 0 ? true : _d, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getDataValidationById = _a.getDataValidationById, getSheetName = _a.getSheetName, onError = _a.onError, citations = _a.citations, onChangeCitations = _a.onChangeCitations, sanitizeHtml = _a.sanitizeHtml, onCommand = _a.onCommand, generatedNames = _a.generatedNames;
+    var canEditCellRange = useCanEditCellRange();
+    // Allowed values
+    var getEffectiveValuesFromRange = useGetEffectiveValuesFromRange();
+    var focusEmbedOrChart = useFocusEmbedOrChart();
+    var onChangeCalculatedColumn = useOnChangeCalculatedColumn({
+        locale: locale,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        getUserEnteredValue: getUserEnteredValue,
+        onChangeSheetData: onChangeSheetData,
+        onChangeTables: onChangeTables,
+        getSheetName: getSheetName,
+        onCommand: onCommand,
+    });
+    var onChangeTableColumn = useOnChangeTableColumn({
+        locale: locale,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        enqueueGraphOperation: enqueueGraphOperation,
+        onChangeSheetData: onChangeSheetData,
+        onChangeTables: onChangeTables,
+        getDependents: getDependents,
+        onCommand: onCommand,
+        generatedNames: generatedNames,
+    });
+    var redrawGrid = useRedrawGrid();
+    var getFinalRowHeight = useGetFinalRowHeight();
+    var _e = useCalculationQueue({ enqueueCalculation: enqueueCalculation }), enqueue = _e.enqueue, processQueue = _e.processQueue;
+    return useCallback(function (e, sourceSheetId, destinationSheetId, copiedSelections, activeCell, selections, finalSelections, isCutOperation) { return __awaiter(void 0, void 0, void 0, function () {
+        var pasteSpecialType, pasteEvent, forcePlainText, activeSheetName, from, merges, embeds, tables, columnWidths, rowHeights, selectedRowValues, rowIndex, start, end, pasteResults, saveHistory, dataValidationTargets, fontFamilies, fontFamiliesWithWeights, err_1, _a, rowSpan, colSpan, to, rowDelta, columnDelta, _b, adjacentTable, isRowExpansion, isColumnExpansion, currentTable, nextSelections, existingTable, destinationRows, visibleRowIndexes, tableHeaderColumnIndex, cellValue, formattedValue, sharedStrings, sharedStringValue, activeCellValue, recalcCells, newEndRowIndex_1, pastedSheetData, values, rowIndex, row, columnIndex, cell, ue, firstEmbedId_1, citationIdMap_1, dataRowIndex, rowData, dataColumnIndex, cellValue_1, newCitations_1, citationIdRemap_1, _loop_1, _c, _d, _e, oldCitationId, _f, sourceRowIndex, sourceColumnIndex;
+        var e_1, _g;
+        var _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
+        return __generator(this, function (_1) {
+            switch (_1.label) {
+                case 0:
+                    pasteSpecialType = (_h = e === null || e === void 0 ? void 0 : e.clipboardData) === null || _h === void 0 ? void 0 : _h.getData("pasteSpecialType");
+                    pasteEvent = e;
+                    forcePlainText = Boolean((pasteEvent === null || pasteEvent === void 0 ? void 0 : pasteEvent.__forcePlainText) ||
+                        ((pasteEvent === null || pasteEvent === void 0 ? void 0 : pasteEvent.shiftKey) &&
+                            ((pasteEvent === null || pasteEvent === void 0 ? void 0 : pasteEvent.metaKey) || (pasteEvent === null || pasteEvent === void 0 ? void 0 : pasteEvent.ctrlKey))));
+                    activeSheetName = getSheetName(destinationSheetId);
+                    from = copiedSelections === null || copiedSelections === void 0 ? void 0 : copiedSelections[0];
+                    selectedRowValues = [];
+                    if (!(isCutOperation && from && !isNil(sourceSheetId))) return [3 /*break*/, 1];
+                    for (rowIndex = from.range.startRowIndex; rowIndex <= from.range.endRowIndex; rowIndex++) {
+                        start = from.range.startColumnIndex;
+                        end = start + from.range.endColumnIndex - from.range.startColumnIndex + 1;
+                        selectedRowValues.push((_m = (_l = (_k = (_j = sheetData === null || sheetData === void 0 ? void 0 : sheetData[sourceSheetId]) === null || _j === void 0 ? void 0 : _j[rowIndex]) === null || _k === void 0 ? void 0 : _k.values) === null || _l === void 0 ? void 0 : _l.slice(start, end)) !== null && _m !== void 0 ? _m : []);
+                    }
+                    return [3 /*break*/, 3];
+                case 1: return [4 /*yield*/, generateDataFromClipboard(e, activeCell, destinationSheetId, activeSheetName, preserveFormatting, locale, idCreationStrategy, forcePlainText, sanitizeHtml, generatedNames)];
+                case 2:
+                    pasteResults = _1.sent();
+                    selectedRowValues = (_o = pasteResults === null || pasteResults === void 0 ? void 0 : pasteResults.results) !== null && _o !== void 0 ? _o : [];
+                    merges = pasteResults === null || pasteResults === void 0 ? void 0 : pasteResults.merges;
+                    embeds = pasteResults === null || pasteResults === void 0 ? void 0 : pasteResults.embeds;
+                    tables = pasteResults === null || pasteResults === void 0 ? void 0 : pasteResults.tables;
+                    rowHeights = pasteResults === null || pasteResults === void 0 ? void 0 : pasteResults.rowHeights;
+                    columnWidths = pasteResults === null || pasteResults === void 0 ? void 0 : pasteResults.columnWidths;
+                    _1.label = 3;
+                case 3:
+                    // No data,
+                    if (isNil(selectedRowValues)) {
+                        return [2 /*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);
+                    }
+                    saveHistory = createHistory();
+                    dataValidationTargets = new Map();
+                    fontFamilies = extractFontFamily(selectedRowValues);
+                    if (!(fontFamilies.length && preserveFormatting)) return [3 /*break*/, 10];
+                    fontFamiliesWithWeights = fontFamilies
+                        .map(function (family) { return ["".concat(family, ":400"), "".concat(family, ":700")]; })
+                        .flat();
+                    _1.label = 4;
+                case 4:
+                    _1.trys.push([4, 9, , 10]);
+                    if (!onRequestFonts) return [3 /*break*/, 6];
+                    return [4 /*yield*/, onRequestFonts(fontFamilies)];
+                case 5:
+                    _1.sent();
+                    return [3 /*break*/, 8];
+                case 6: return [4 /*yield*/, loadWebFont(fontFamiliesWithWeights)];
+                case 7:
+                    _1.sent();
+                    _1.label = 8;
+                case 8:
+                    redrawGrid === null || redrawGrid === void 0 ? void 0 : redrawGrid();
+                    return [3 /*break*/, 10];
+                case 9:
+                    err_1 = _1.sent();
+                    error("Error loading webfonts", fontFamilies, err_1);
+                    return [3 /*break*/, 10];
+                case 10:
+                    _a = __read([
+                        (_p = selectedRowValues === null || selectedRowValues === void 0 ? void 0 : selectedRowValues.length) !== null && _p !== void 0 ? _p : 0,
+                        // For cut operations, use range dimensions since data may be sparse
+                        isCutOperation && from
+                            ? from.range.endColumnIndex - from.range.startColumnIndex + 1
+                            : (_r = (_q = selectedRowValues[0]) === null || _q === void 0 ? void 0 : _q.length) !== null && _r !== void 0 ? _r : 0,
+                    ], 2), rowSpan = _a[0], colSpan = _a[1];
+                    to = (_s = selections === null || selections === void 0 ? void 0 : selections[(selections === null || selections === void 0 ? void 0 : selections.length) - 1]) !== null && _s !== void 0 ? _s : selectionFromActiveCell(activeCell)[0];
+                    rowDelta = from && to ? to.range.startRowIndex - from.range.startRowIndex : -1;
+                    columnDelta = from && to
+                        ? to.range.startColumnIndex - from.range.startColumnIndex
+                        : -1;
+                    _b = __read(findAdjacentTable(destinationSheetId, activeCell, currentTables, getUserEnteredValue), 3), adjacentTable = _b[0], isRowExpansion = _b[1], isColumnExpansion = _b[2];
+                    currentTable = isColumnExpansion && adjacentTable
+                        ? adjacentTable
+                        : findActiveTableWithinCell(destinationSheetId, activeCell, currentTables);
+                    nextSelections = (finalSelections === null || finalSelections === void 0 ? void 0 : 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 [2 /*return*/];
+                    }
+                    // Check if pasting a table would overlap with an existing table
+                    if (tables === null || tables === void 0 ? void 0 : tables.length) {
+                        existingTable = currentTables === null || currentTables === void 0 ? void 0 : currentTables.find(function (table) {
+                            return table.sheetId === destinationSheetId &&
+                                areaIntersects(to.range, table.range);
+                        });
+                        if (existingTable) {
+                            onError === null || onError === void 0 ? void 0 : onError("Cannot paste a table over another table. The paste range overlaps with an existing table.");
+                            return [2 /*return*/];
+                        }
+                    }
+                    destinationRows = buildDestinationRowAssignments(destinationSheetId, to.range.startRowIndex, to.range.endRowIndex, rowSpan, isHiddenByFilterRow);
+                    if (!destinationRows.length) {
+                        return [2 /*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 === null || enqueueStructureChange === void 0 ? void 0 : 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 === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+                            kind: "invalidate-range",
+                            sheetId: sourceSheetId,
+                            startRowIndex: from.range.startRowIndex,
+                            endRowIndex: from.range.endRowIndex,
+                            startColumnIndex: from.range.startColumnIndex,
+                            endColumnIndex: from.range.endColumnIndex,
+                        });
+                    }
+                    visibleRowIndexes = destinationRows.map(function (_a) {
+                        var rowIndex = _a.rowIndex;
+                        return rowIndex;
+                    });
+                    tableHeaderColumnIndex = findTableColumnIndex(destinationSheetId, activeCell, currentTables);
+                    cellValue = (_t = selectedRowValues === null || selectedRowValues === void 0 ? void 0 : selectedRowValues[0]) === null || _t === void 0 ? void 0 : _t[0];
+                    formattedValue = getCellFormattedValue(cellValue);
+                    sharedStrings = sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.getSharedStrings();
+                    sharedStringValue = (cellValue === null || cellValue === void 0 ? void 0 : cellValue.ss) == null || !sharedStrings
+                        ? undefined
+                        : sharedStrings.get(String(cellValue.ss));
+                    activeCellValue = typeof formattedValue === "string"
+                        ? formattedValue
+                        : typeof sharedStringValue === "string"
+                            ? sharedStringValue
+                            : undefined;
+                    recalcCells = new Map();
+                    // Expand table if user is pasting
+                    // table data
+                    // Same undo history
+                    if (!isNil(currentTable) && !isRowExpansion) {
+                        newEndRowIndex_1 = Math.max(currentTable.range.endRowIndex, activeCell.rowIndex + rowSpan - 1 + (currentTable.totalRow ? 1 : 0));
+                        // Update table range
+                        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTableData) {
+                            var _a = __read(produceWithPatches(prevTableData, function (draft) {
+                                var _a;
+                                var table = draft.find(function (table) { return (currentTable === null || currentTable === void 0 ? void 0 : currentTable.id) === table.id; });
+                                if (table) {
+                                    table.range.endRowIndex = newEndRowIndex_1;
+                                    // Update table name
+                                    if (!isNil(tableHeaderColumnIndex)) {
+                                        if ((_a = table.columns) === null || _a === void 0 ? void 0 : _a.length) {
+                                            if (!table.columns[tableHeaderColumnIndex]) {
+                                                table.columns[tableHeaderColumnIndex] = {
+                                                    name: String(activeCellValue),
+                                                };
+                                            }
+                                            else {
+                                                // Update name
+                                                table.columns[tableHeaderColumnIndex].name =
+                                                    String(activeCellValue);
+                                            }
+                                        }
+                                    }
+                                }
+                            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                            saveHistory({
+                                tables: { patches: patches, inversePatches: inversePatches },
+                            });
+                            return nextState;
+                        });
+                    }
+                    if (selectedRowValues.length) {
+                        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+                            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                                var e_2, _a, e_3, _b, e_4, _c, e_5, _d, e_6, _e;
+                                var _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+                                // For cut operation
+                                var movedKeys = new Set();
+                                /**
+                                 * If user is deleting source cells,
+                                 * let update its dependents and mark it as dirty
+                                 */
+                                if (isCutOperation && from && to && !isNil(sourceSheetId)) {
+                                    var sheetId = sourceSheetId;
+                                    try {
+                                        for (var _y = __values(iterateCellsInRange(from.range)), _z = _y.next(); !_z.done; _z = _y.next()) {
+                                            var _0 = __read(_z.value, 2), rowIndex = _0[0], columnIndex = _0[1];
+                                            // Process dependents
+                                            processSideEffectDependentCells({
+                                                draft: draft,
+                                                rowIndex: rowIndex,
+                                                columnIndex: columnIndex,
+                                                sheetId: sheetId,
+                                                destinationSheetId: destinationSheetId,
+                                                columnDelta: columnDelta,
+                                                enqueueGraphOperation: enqueueGraphOperation,
+                                                enqueueCalculation: enqueue,
+                                                getDependents: getDependents,
+                                                recalcCells: recalcCells,
+                                                rowDelta: rowDelta,
+                                                sourceRange: from.range,
+                                                movedKeys: movedKeys,
+                                                locale: locale,
+                                                rowCount: rowCount,
+                                                columnCount: columnCount,
+                                            });
+                                        }
+                                    }
+                                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                    finally {
+                                        try {
+                                            if (_z && !_z.done && (_a = _y.return)) _a.call(_y);
+                                        }
+                                        finally { if (e_2) throw e_2.error; }
+                                    }
+                                    // 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.
+                                    var movedRowValues = [];
+                                    var sourceStartColumn = from.range.startColumnIndex;
+                                    var sourceEndColumn = from.range.endColumnIndex + 1;
+                                    for (var rowIndex = from.range.startRowIndex; rowIndex <= from.range.endRowIndex; rowIndex++) {
+                                        movedRowValues.push(((_j = (_h = (_g = (_f = draft[sheetId]) === null || _f === void 0 ? void 0 : _f[rowIndex]) === null || _g === void 0 ? void 0 : _g.values) === null || _h === void 0 ? void 0 : _h.slice(sourceStartColumn, sourceEndColumn)) !== null && _j !== void 0 ? _j : []));
+                                    }
+                                    // Delete source if required
+                                    // Move values
+                                    for (var rowIndex = from.range.startRowIndex; rowIndex <= from.range.endRowIndex; rowIndex++) {
+                                        for (var columnIndex = from.range.startColumnIndex; columnIndex <= from.range.endColumnIndex; columnIndex++) {
+                                            if (!((_l = (_k = draft[sheetId][rowIndex]) === null || _k === void 0 ? void 0 : _k.values) === null || _l === void 0 ? void 0 : _l[columnIndex])) {
+                                                continue;
+                                            }
+                                            draft[sheetId][rowIndex].values[columnIndex] =
+                                                {};
+                                        }
+                                    }
+                                    try {
+                                        for (var destinationRows_1 = __values(destinationRows), destinationRows_1_1 = destinationRows_1.next(); !destinationRows_1_1.done; destinationRows_1_1 = destinationRows_1.next()) {
+                                            var _1 = destinationRows_1_1.value, rowIndex = _1.rowIndex, dataRowIndex = _1.dataRowIndex;
+                                            var currentSheet = createSheetDraft(draft, destinationSheetId, rowIndex);
+                                            var columnCursor = 0;
+                                            for (var columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++, columnCursor++) {
+                                                var dataColumnIndex = colSpan > 0 ? columnCursor % colSpan : 0;
+                                                currentSheet[rowIndex].values[columnIndex] =
+                                                    (_m = movedRowValues[dataRowIndex]) === null || _m === void 0 ? void 0 : _m[dataColumnIndex];
+                                                try {
+                                                    for (var _2 = (e_4 = void 0, __values(getDependents({
+                                                        rowIndex: rowIndex,
+                                                        columnIndex: columnIndex,
+                                                        sheetId: destinationSheetId,
+                                                    }))), _3 = _2.next(); !_3.done; _3 = _2.next()) {
+                                                        var dependent = _3.value;
+                                                        if (isStaticNode(dependent)) {
+                                                            continue;
+                                                        }
+                                                        var position = dependent.position;
+                                                        enqueue({
+                                                            type: "add",
+                                                            position: position,
+                                                            force: true,
+                                                        });
+                                                        recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), position);
+                                                    }
+                                                }
+                                                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                                                finally {
+                                                    try {
+                                                        if (_3 && !_3.done && (_c = _2.return)) _c.call(_2);
+                                                    }
+                                                    finally { if (e_4) throw e_4.error; }
+                                                }
+                                                collectDataValidationTarget(dataValidationTargets, destinationSheetId, rowIndex, columnIndex, currentSheet[rowIndex].values[columnIndex]);
+                                            }
+                                        }
+                                    }
+                                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                    finally {
+                                        try {
+                                            if (destinationRows_1_1 && !destinationRows_1_1.done && (_b = destinationRows_1.return)) _b.call(destinationRows_1);
+                                        }
+                                        finally { if (e_3) throw e_3.error; }
+                                    }
+                                }
+                                if (currentTable && !isRowExpansion) {
+                                    addCalculatedColumnsForRowExpansion({
+                                        sheetId: destinationSheetId,
+                                        currentTable: currentTable,
+                                        draft: draft,
+                                        enqueueCalculation: enqueue,
+                                        recalcCells: recalcCells,
+                                        locale: locale,
+                                        range: to.range,
+                                        getDependents: getDependents,
+                                    });
+                                }
+                                // TBD: Move totalrow for tables
+                                // We are doing pure paste operation
+                                if (!isCutOperation) {
+                                    var sheetCell = new SheetCell();
+                                    var sourceCell = {
+                                        rowIndex: to.range.startRowIndex,
+                                        columnIndex: to.range.startColumnIndex,
+                                    };
+                                    try {
+                                        for (var destinationRows_2 = __values(destinationRows), destinationRows_2_1 = destinationRows_2.next(); !destinationRows_2_1.done; destinationRows_2_1 = destinationRows_2.next()) {
+                                            var _4 = destinationRows_2_1.value, rowIndex = _4.rowIndex, dataRowIndex = _4.dataRowIndex;
+                                            var currentSheet = createSheetDraft(draft, destinationSheetId, rowIndex);
+                                            var columnCursor = 0;
+                                            for (var columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++, columnCursor++) {
+                                                var dataColumnIndex = colSpan > 0 ? columnCursor % colSpan : 0;
+                                                var cellValue_2 = (_o = selectedRowValues[dataRowIndex]) === null || _o === void 0 ? void 0 : _o[dataColumnIndex];
+                                                if (pasteSpecialType === "Formatting") {
+                                                    var existingCellData = (_r = (_q = (_p = prevSheetData[destinationSheetId]) === null || _p === void 0 ? void 0 : _p[rowIndex]) === null || _q === void 0 ? void 0 : _q.values) === null || _r === void 0 ? void 0 : _r[columnIndex];
+                                                    cellValue_2 = __assign(__assign({}, existingCellData), cellValue_2);
+                                                    sheetCell.extendCellData(cellValue_2);
+                                                }
+                                                if (pasteSpecialType === "Value" || forcePlainText) {
+                                                    var existingCellData = (_u = (_t = (_s = prevSheetData[destinationSheetId]) === null || _s === void 0 ? void 0 : _s[rowIndex]) === null || _t === void 0 ? void 0 : _t.values) === null || _u === void 0 ? void 0 : _u[columnIndex];
+                                                    // Remove ss from existingCellData since we're replacing the value
+                                                    var _5 = existingCellData !== null && existingCellData !== void 0 ? existingCellData : {}, _ss = _5.ss, existingWithoutSs = __rest(_5, ["ss"]);
+                                                    cellValue_2 = __assign(__assign({}, existingWithoutSs), cellValue_2);
+                                                    sheetCell.extendCellData(cellValue_2);
+                                                }
+                                                if (pasteSpecialType === "Transposed") {
+                                                    sheetCell.assign(destinationSheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, (_x = (_w = (_v = prevSheetData[destinationSheetId]) === null || _v === void 0 ? void 0 : _v[rowIndex]) === null || _w === void 0 ? void 0 : _w.values) === null || _x === void 0 ? void 0 : _x[columnIndex], {
+                                                        locale: locale,
+                                                        cellXfsRegistry: cellXfsRegistry,
+                                                        getDataValidationById: getDataValidationById,
+                                                        sharedStringRegistry: sharedStringRegistry,
+                                                    });
+                                                    var existingCellData = sheetCell.getUserCellData();
+                                                    cellValue_2 = __assign(__assign({}, existingCellData), cellValue_2);
+                                                    sheetCell.extendCellData(cellValue_2);
+                                                }
+                                                else {
+                                                    sheetCell.assign(destinationSheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, typeof cellValue_2 === "object"
+                                                        ? cellValue_2
+                                                        : undefined, {
+                                                        getRangeValues: getEffectiveValuesFromRange,
+                                                        locale: locale,
+                                                        cellXfsRegistry: cellXfsRegistry,
+                                                        getDataValidationById: getDataValidationById,
+                                                        sharedStringRegistry: sharedStringRegistry,
+                                                    });
+                                                }
+                                                if (pasteSpecialType === "Formatting") {
+                                                    sheetCell.refreshFormattedValue();
+                                                }
+                                                if (sheetCell.isFormula()) {
+                                                    if (dataRowIndex === 0 && dataColumnIndex === 0) {
+                                                        sheetCell.moveFormula(sourceCell, {
+                                                            rowIndex: rowIndex,
+                                                            columnIndex: columnIndex,
+                                                        }, activeSheetName, { preserveAbsolutes: true });
+                                                    }
+                                                    sheetCell.setLoading();
+                                                    enqueue({
+                                                        type: "add",
+                                                        position: {
+                                                            rowIndex: rowIndex,
+                                                            columnIndex: columnIndex,
+                                                            sheetId: destinationSheetId,
+                                                        },
+                                                        force: true,
+                                                    });
+                                                    recalcCells.set(createSheetCellIdentifier(destinationSheetId, rowIndex, columnIndex), {
+                                                        rowIndex: rowIndex,
+                                                        columnIndex: columnIndex,
+                                                        sheetId: destinationSheetId,
+                                                    });
+                                                }
+                                                try {
+                                                    for (var _6 = (e_6 = void 0, __values(getDependents({
+                                                        rowIndex: rowIndex,
+                                                        columnIndex: columnIndex,
+                                                        sheetId: destinationSheetId,
+                                                    }))), _7 = _6.next(); !_7.done; _7 = _6.next()) {
+                                                        var dependent = _7.value;
+                                                        if (isStaticNode(dependent)) {
+                                                            continue;
+                                                        }
+                                                        var position = dependent.position;
+                                                        enqueue({
+                                                            type: "add",
+                                                            position: position,
+                                                            force: true,
+                                                        });
+                                                        recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), position);
+                                                    }
+                                                }
+                                                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                                                finally {
+                                                    try {
+                                                        if (_7 && !_7.done && (_e = _6.return)) _e.call(_6);
+                                                    }
+                                                    finally { if (e_6) throw e_6.error; }
+                                                }
+                                                sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.registerCell(sheetCell);
+                                                currentSheet[rowIndex].values[columnIndex] =
+                                                    sheetCell.getCellData();
+                                                collectDataValidationTarget(dataValidationTargets, destinationSheetId, rowIndex, columnIndex, currentSheet[rowIndex].values[columnIndex]);
+                                                cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.registerCellXfs(sheetCell);
+                                            }
+                                        }
+                                    }
+                                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                                    finally {
+                                        try {
+                                            if (destinationRows_2_1 && !destinationRows_2_1.done && (_d = destinationRows_2.return)) _d.call(destinationRows_2);
+                                        }
+                                        finally { if (e_5) throw e_5.error; }
+                                    }
+                                }
+                            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                            saveHistory({
+                                sheetData: { patches: patches, inversePatches: 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 === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.getPatches(saveHistory);
+                        sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.getPatches(saveHistory);
+                        // Update row or column count
+                        // Change sheets
+                        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+                            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                                var e_7, _a, e_8, _b, e_9, _c;
+                                var _d, _e, _f, _g, _h;
+                                var sheet = draft.find(function (sheet) { return sheet.sheetId === destinationSheetId; });
+                                if (sheet) {
+                                    sheet.rowCount = Math.min(maxRowCount, Math.max((_d = sheet.rowCount) !== null && _d !== void 0 ? _d : DEFAULT_ROW_COUNT, to.range.endRowIndex));
+                                    sheet.columnCount = Math.min(maxColumnCount, Math.max((_e = sheet.columnCount) !== null && _e !== void 0 ? _e : DEFAULT_COLUMN_COUNT, to.range.endColumnIndex));
+                                    // Handle merges for cut operations
+                                    var mergesToAdd = merges;
+                                    if (isCutOperation && from && !isNil(sourceSheetId)) {
+                                        var sourceSheet = prevSheets.find(function (s) { return s.sheetId === sourceSheetId; });
+                                        if (sourceSheet === null || sourceSheet === void 0 ? void 0 : sourceSheet.merges) {
+                                            // Extract merged cells from source range
+                                            var cutMerges = [];
+                                            try {
+                                                for (var _j = __values(sourceSheet.merges), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                                    var merge = _k.value;
+                                                    // 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,
+                                                        });
+                                                    }
+                                                }
+                                            }
+                                            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                                            finally {
+                                                try {
+                                                    if (_k && !_k.done && (_a = _j.return)) _a.call(_j);
+                                                }
+                                                finally { if (e_7) throw e_7.error; }
+                                            }
+                                            if (cutMerges.length > 0) {
+                                                mergesToAdd = cutMerges;
+                                            }
+                                            // Remove merges from source sheet
+                                            var sourceSheetDraft = draft.find(function (s) { return s.sheetId === sourceSheetId; });
+                                            if (sourceSheetDraft === null || sourceSheetDraft === void 0 ? void 0 : sourceSheetDraft.merges) {
+                                                sourceSheetDraft.merges = sourceSheetDraft.merges.filter(function (merge) { return !areaIntersects(merge, from.range); });
+                                            }
+                                        }
+                                    }
+                                    // Update merges
+                                    if (mergesToAdd) {
+                                        sheet.merges = (_f = sheet.merges) !== null && _f !== void 0 ? _f : [];
+                                        var _loop_2 = function (merge) {
+                                            var exists = sheet.merges.find(function (range) {
+                                                return isAreasEqual(range, merge);
+                                            });
+                                            if (!exists) {
+                                                sheet.merges.push(merge);
+                                            }
+                                        };
+                                        try {
+                                            for (var mergesToAdd_1 = __values(mergesToAdd), mergesToAdd_1_1 = mergesToAdd_1.next(); !mergesToAdd_1_1.done; mergesToAdd_1_1 = mergesToAdd_1.next()) {
+                                                var merge = mergesToAdd_1_1.value;
+                                                _loop_2(merge);
+                                            }
+                                        }
+                                        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                                        finally {
+                                            try {
+                                                if (mergesToAdd_1_1 && !mergesToAdd_1_1.done && (_b = mergesToAdd_1.return)) _b.call(mergesToAdd_1);
+                                            }
+                                            finally { if (e_8) throw e_8.error; }
+                                        }
+                                    }
+                                    // Row heights
+                                    var clipboardSizedRows = new Set();
+                                    if (rowHeights) {
+                                        if (!sheet.rowMetadata) {
+                                            sheet.rowMetadata = [];
+                                        }
+                                        for (var index = 0; index < rowHeights.length; index++) {
+                                            var curHeight = rowHeights[index];
+                                            if (isNil(curHeight) || curHeight === 0) {
+                                                continue;
+                                            }
+                                            var 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.
+                                    var skipAutoResize = pasteSpecialType === "Formatting" ||
+                                        pasteSpecialType === "Value" ||
+                                        pasteSpecialType === "Formula" ||
+                                        pasteSpecialType === "Transposed";
+                                    if (!skipAutoResize &&
+                                        getFinalRowHeight &&
+                                        selectedRowValues.length &&
+                                        colSpan > 0) {
+                                        try {
+                                            for (var destinationRows_3 = __values(destinationRows), destinationRows_3_1 = destinationRows_3.next(); !destinationRows_3_1.done; destinationRows_3_1 = destinationRows_3.next()) {
+                                                var _l = destinationRows_3_1.value, rowIndex = _l.rowIndex, dataRowIndex = _l.dataRowIndex;
+                                                // Clipboard-provided row heights win.
+                                                if (clipboardSizedRows.has(rowIndex))
+                                                    continue;
+                                                var 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.
+                                                var bestLines = 1;
+                                                var bestColumnIndex = void 0;
+                                                var bestCell = void 0;
+                                                var bestHasWrap = false;
+                                                var columnCursor = 0;
+                                                for (var columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++, columnCursor++) {
+                                                    var dataColumnIndex = columnCursor % colSpan;
+                                                    var cellValue_3 = rowData[dataColumnIndex];
+                                                    if (!cellValue_3 || typeof cellValue_3 !== "object")
+                                                        continue;
+                                                    var ue_1 = getCellUserEnteredValue(cellValue_3);
+                                                    var text = getExtendedValueString(ue_1);
+                                                    var lines = typeof text === "string" && text.includes("\n")
+                                                        ? text.split("\n").length
+                                                        : 1;
+                                                    var uf_1 = getCellUserEnteredFormat(cellValue_3);
+                                                    var wrap = (uf_1 === null || uf_1 === void 0 ? void 0 : uf_1.wrapStrategy) === "wrap";
+                                                    if (lines > bestLines ||
+                                                        (lines === bestLines && wrap && !bestHasWrap)) {
+                                                        bestLines = lines;
+                                                        bestCell = cellValue_3;
+                                                        bestColumnIndex = columnIndex;
+                                                        bestHasWrap = wrap;
+                                                    }
+                                                }
+                                                if (!bestCell ||
+                                                    bestColumnIndex === undefined ||
+                                                    (bestLines === 1 && !bestHasWrap)) {
+                                                    continue;
+                                                }
+                                                var ue = getCellUserEnteredValue(bestCell);
+                                                var overrideText = (_g = getExtendedValueString(ue)) !== null && _g !== void 0 ? _g : "";
+                                                var uf = getCellUserEnteredFormat(bestCell);
+                                                var height = getFinalRowHeight(destinationSheetId, rowIndex, bestColumnIndex, {
+                                                    textOverride: String(overrideText),
+                                                    textFormatOverride: uf === null || uf === void 0 ? void 0 : 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;
+                                                }
+                                            }
+                                        }
+                                        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                                        finally {
+                                            try {
+                                                if (destinationRows_3_1 && !destinationRows_3_1.done && (_c = destinationRows_3.return)) _c.call(destinationRows_3);
+                                            }
+                                            finally { if (e_9) throw e_9.error; }
+                                        }
+                                    }
+                                    // column widths
+                                    if (columnWidths) {
+                                        if (!sheet.columnMetadata) {
+                                            sheet.columnMetadata = [];
+                                        }
+                                        for (var index = 0; index < columnWidths.length; index++) {
+                                            var curWidth = columnWidths[index];
+                                            if (isNil(curWidth) || curWidth === 0) {
+                                                continue;
+                                            }
+                                            var columnIndex = to.range.startColumnIndex + index;
+                                            if (!((_h = sheet.columnMetadata) === null || _h === void 0 ? void 0 : _h[columnIndex])) {
+                                                sheet.columnMetadata[columnIndex] = {};
+                                            }
+                                            sheet.columnMetadata[columnIndex].size =
+                                                columnWidths[index];
+                                        }
+                                    }
+                                }
+                            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                            saveHistory({
+                                sheets: { patches: patches, inversePatches: inversePatches },
+                            });
+                            return nextState;
+                        });
+                        // For row expansions, add columns
+                        onChangeTableColumn(destinationSheetId, activeCell, activeCellValue !== null && activeCellValue !== void 0 ? activeCellValue : undefined, adjacentTable, isRowExpansion, isColumnExpansion, to.range);
+                        // Add calculated column
+                        onChangeCalculatedColumn(destinationSheetId, activeCell, activeCellValue !== null && activeCellValue !== void 0 ? activeCellValue : undefined, currentTable);
+                        // Update new selections
+                        if (!isSelectionACell(nextSelections)) {
+                            onChangeSelections === null || onChangeSelections === void 0 ? void 0 : onChangeSelections(destinationSheetId, [to]);
+                        }
+                        // Update active cell
+                        onChangeActiveCell(destinationSheetId, __assign({}, 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) {
+                            values = [];
+                            for (rowIndex = to.range.startRowIndex; rowIndex <= to.range.endRowIndex; rowIndex++) {
+                                row = [];
+                                for (columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++) {
+                                    cell = (_w = (_v = (_u = pastedSheetData[destinationSheetId]) === null || _u === void 0 ? void 0 : _u[rowIndex]) === null || _v === void 0 ? void 0 : _v.values) === null || _w === void 0 ? void 0 : _w[columnIndex];
+                                    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((_0 = (_z = (_y = (_x = getExtendedValueFormula(ue)) !== null && _x !== void 0 ? _x : getExtendedValueString(ue)) !== null && _y !== void 0 ? _y : getExtendedValueNumber(ue)) !== null && _z !== void 0 ? _z : getExtendedValueBool(ue)) !== null && _0 !== void 0 ? _0 : null);
+                                }
+                                values.push(row);
+                            }
+                            onCommand({
+                                command: "change-batch",
+                                sheetId: destinationSheetId,
+                                ranges: to.range,
+                                values: 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 === null || embeds === void 0 ? void 0 : embeds.length) {
+                        firstEmbedId_1 = embeds[0].embedId;
+                        onChangeEmbeds === null || onChangeEmbeds === void 0 ? void 0 : onChangeEmbeds(function (prevEmbeds) {
+                            var _a = __read(produceWithPatches(prevEmbeds, function (draft) {
+                                draft.push.apply(draft, __spreadArray([], __read(embeds), false));
+                            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                            saveHistory({
+                                embeds: { patches: patches, inversePatches: inversePatches },
+                                selectedEmbedOrChart: { redo: firstEmbedId_1, undo: undefined },
+                            });
+                            return nextState;
+                        });
+                        // Selected first embed
+                        focusEmbedOrChart(embeds[0].embedId);
+                    }
+                    // Tables
+                    if (tables === null || tables === void 0 ? void 0 : tables.length) {
+                        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+                            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                                draft.push.apply(draft, __spreadArray([], __read(tables), false));
+                            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                            saveHistory({
+                                tables: { patches: patches, inversePatches: inversePatches },
+                            });
+                            return nextState;
+                        });
+                    }
+                    // Handle citations
+                    if (selectedRowValues.length && onChangeCitations) {
+                        citationIdMap_1 = new Map();
+                        for (dataRowIndex = 0; dataRowIndex < rowSpan; dataRowIndex++) {
+                            rowData = selectedRowValues[dataRowIndex];
+                            if (!rowData)
+                                continue;
+                            for (dataColumnIndex = 0; dataColumnIndex < colSpan; dataColumnIndex++) {
+                                cellValue_1 = rowData[dataColumnIndex];
+                                if (cellValue_1 &&
+                                    typeof cellValue_1 === "object" &&
+                                    "citationId" in cellValue_1 &&
+                                    cellValue_1.citationId) {
+                                    citationIdMap_1.set(cellValue_1.citationId, {
+                                        sourceRowIndex: dataRowIndex,
+                                        sourceColumnIndex: dataColumnIndex,
+                                    });
+                                }
+                            }
+                        }
+                        if (citationIdMap_1.size > 0) {
+                            if (isCutOperation && from && !isNil(sourceSheetId)) {
+                                // For cut operation: Move citations to new position
+                                onChangeCitations(function (prevCitations) {
+                                    var _a = __read(produceWithPatches(prevCitations, function (draft) {
+                                        var e_10, _a;
+                                        var _loop_3 = function (citationId) {
+                                            var citation = draft.find(function (c) { return 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;
+                                            }
+                                        };
+                                        try {
+                                            for (var _b = __values(citationIdMap_1.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                                var citationId = _c.value;
+                                                _loop_3(citationId);
+                                            }
+                                        }
+                                        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                                        finally {
+                                            try {
+                                                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                                            }
+                                            finally { if (e_10) throw e_10.error; }
+                                        }
+                                    }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                                    saveHistory({
+                                        citations: { patches: patches, inversePatches: inversePatches },
+                                    });
+                                    return nextState;
+                                });
+                            }
+                            else if (!isCutOperation) {
+                                newCitations_1 = [];
+                                citationIdRemap_1 = new Map();
+                                _loop_1 = function (oldCitationId, sourceRowIndex, sourceColumnIndex) {
+                                    var originalCitation = citations === null || citations === void 0 ? void 0 : citations.find(function (c) { return c.id === oldCitationId; });
+                                    if (originalCitation) {
+                                        var newId = uuidString();
+                                        citationIdRemap_1.set(oldCitationId, newId);
+                                        // Calculate the new range based on paste destination
+                                        var newCitation = __assign(__assign({}, 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_1.push(newCitation);
+                                    }
+                                };
+                                try {
+                                    for (_c = __values(citationIdMap_1.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                        _e = __read(_d.value, 2), oldCitationId = _e[0], _f = _e[1], sourceRowIndex = _f.sourceRowIndex, sourceColumnIndex = _f.sourceColumnIndex;
+                                        _loop_1(oldCitationId, sourceRowIndex, sourceColumnIndex);
+                                    }
+                                }
+                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                finally {
+                                    try {
+                                        if (_d && !_d.done && (_g = _c.return)) _g.call(_c);
+                                    }
+                                    finally { if (e_1) throw e_1.error; }
+                                }
+                                if (newCitations_1.length > 0) {
+                                    // Add new citations
+                                    onChangeCitations(function (prevCitations) {
+                                        var _a = __read(produceWithPatches(prevCitations, function (draft) {
+                                            draft.push.apply(draft, __spreadArray([], __read(newCitations_1), false));
+                                        }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                                        saveHistory({
+                                            citations: { patches: patches, inversePatches: inversePatches },
+                                        });
+                                        return nextState;
+                                    });
+                                    // Update cell citationIds to point to new citations
+                                    onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+                                        var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                                            var e_11, _a;
+                                            var _b, _c, _d;
+                                            try {
+                                                for (var destinationRows_4 = __values(destinationRows), destinationRows_4_1 = destinationRows_4.next(); !destinationRows_4_1.done; destinationRows_4_1 = destinationRows_4.next()) {
+                                                    var rowIndex = destinationRows_4_1.value.rowIndex;
+                                                    for (var columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++) {
+                                                        var cellData = (_d = (_c = (_b = draft[destinationSheetId]) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[columnIndex];
+                                                        if (cellData === null || cellData === void 0 ? void 0 : cellData.citationId) {
+                                                            var newCitationId = citationIdRemap_1.get(cellData.citationId);
+                                                            if (newCitationId) {
+                                                                cellData.citationId = newCitationId;
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                                            finally {
+                                                try {
+                                                    if (destinationRows_4_1 && !destinationRows_4_1.done && (_a = destinationRows_4.return)) _a.call(destinationRows_4);
+                                                }
+                                                finally { if (e_11) throw e_11.error; }
+                                            }
+                                        }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                                        saveHistory({
+                                            sheetData: { patches: patches, inversePatches: inversePatches },
+                                        });
+                                        return nextState;
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); }, [
+        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,
+    ]);
+};