@visactor/vtable 1.26.7 → 1.26.8

package/cjs/event/event.js

@@ -35,10 +35,14 @@ const vrender_1 = require("./../vrender"), TABLE_EVENT_TYPE_1 = require("../core
 class EventManager {
     constructor(table) {
         this.isDown = !1, this.isDraging = !1, this.globalEventListeners = [], this._enableTableScroll = !0, 
-        this.cutWaitPaste = !1, this.clipboardCheckTimer = null, this.cutOperationTime = 0, 
-        this.lastClipboardContent = "", this.cutCellRange = null, this.cutRanges = null, 
-        this.copySourceRange = null, this.table = table, this.handleTextStickBindId = [], 
-        this.inertiaScroll = new scroll_1.InertiaScroll(table.stateManager), "node" === env_1.Env.mode || table.options.disableInteraction || (this.bindOuterEvent(), 
+        this.cutWaitPaste = !1, this.clipboardCheckTimer = null, this.cutOperationId = 0, 
+        this.clipboardOperationId = 0, this.pasteOperationId = 0, this.pasteWriteInProgress = !1, 
+        this.pasteWritePromise = Promise.resolve(), this.clipboardWritePromise = Promise.resolve(), 
+        this.lastCopiedClipboardData = null, this.internalFormulaHtmlMarkerId = 0, this.fieldKeyIds = new WeakMap, 
+        this.fieldKeyId = 0, this.activeCutState = null, this.lastClipboardContent = "", 
+        this.cutCellRange = null, this.cutRanges = null, this.copySourceRange = null, this.table = table, 
+        this.handleTextStickBindId = [], this.inertiaScroll = new scroll_1.InertiaScroll(table.stateManager), 
+        "node" === env_1.Env.mode || table.options.disableInteraction || (this.bindOuterEvent(), 
         setTimeout((() => {
             this.bindSelfEvent();
         }), 0));
@@ -245,7 +249,8 @@ class EventManager {
     }
     release() {
         var _a;
-        null === (_a = this.gesture) || void 0 === _a || _a.release(), this.globalEventListeners.forEach((item => {
+        this.clipboardOperationId++, this.pasteOperationId++, this.resetCutState(), null === (_a = this.gesture) || void 0 === _a || _a.release(), 
+        this.globalEventListeners.forEach((item => {
             "document" === item.env ? document.removeEventListener(item.name, item.callback) : "body" === item.env ? document.body.removeEventListener(item.name, item.callback) : "window" === item.env ? window.removeEventListener(item.name, item.callback) : "vglobal" === item.env && vrender_1.vglobal.removeEventListener(item.name, item.callback);
         })), this.globalEventListeners = [];
     }
@@ -258,65 +263,329 @@ class EventManager {
     handleCopy(e, isCut = !1) {
         var _a, _b, _c, _d, _e, _f;
         return __awaiter(this, void 0, void 0, (function*() {
-            const table = this.table;
-            !isCut && (this.cutWaitPaste = !1), this.copySourceRange = null;
-            const sourceRanges = table.stateManager.select.ranges;
-            if (sourceRanges && 1 === sourceRanges.length) {
-                const sourceRange = sourceRanges[0];
-                this.copySourceRange = {
-                    startCol: Math.min(sourceRange.start.col, sourceRange.end.col),
-                    startRow: Math.min(sourceRange.start.row, sourceRange.end.row)
-                };
-            } else if (!(null == sourceRanges ? void 0 : sourceRanges.length)) return void (this.copySourceRange = null);
+            const table = this.table, operationId = ++this.clipboardOperationId;
+            this.pasteOperationId++, isCut || this.resetCutState();
+            const copySnapshot = this.getCopySnapshot(isCut);
+            if (this.copySourceRange = null, this.lastCopiedClipboardData = null, !copySnapshot) return this.copySourceRange = null, 
+            null;
             const data = this.table.getCopyValue(null === (_b = null === (_a = table.options.keyboardOptions) || void 0 === _a ? void 0 : _a.getCopyCellValue) || void 0 === _b ? void 0 : _b.value);
-            if ((0, vutils_1.isValid)(data)) {
+            if (!(0, vutils_1.isValid)(data)) return null;
+            {
                 e.preventDefault();
+                let copySucceeded = !1, copiedClipboardData = null;
+                const canUseAsyncClipboard = window.isSecureContext && !!(null === (_c = navigator.clipboard) || void 0 === _c ? void 0 : _c.writeText), canWriteRichClipboard = window.isSecureContext && !!(null === (_d = navigator.clipboard) || void 0 === _d ? void 0 : _d.write) && !!window.ClipboardItem, hasEventClipboard = !!e.clipboardData, dataHTML = !canUseAsyncClipboard || canWriteRichClipboard || hasEventClipboard ? this.getCopyDataHTML(data) : null, formulaClipboardData = this.getCopyFormulaPlainData(data, isCut);
+                if (null === formulaClipboardData) return null;
+                const plainClipboardData = data, internalFormulaText = formulaClipboardData !== plainClipboardData ? formulaClipboardData : void 0, internalFormulaHtmlMarker = internalFormulaText ? this.createInternalFormulaHtmlMarker() : void 0, clipboardHTML = dataHTML && internalFormulaHtmlMarker ? this.attachInternalFormulaHtmlMarker(dataHTML, internalFormulaHtmlMarker) : dataHTML, eventClipboardWriteData = hasEventClipboard ? this.setCopyDataToEventClipboard(plainClipboardData, clipboardHTML, e, internalFormulaText, internalFormulaHtmlMarker) : null;
+                if (eventClipboardWriteData) return copiedClipboardData = eventClipboardWriteData, 
+                this.lastCopiedClipboardData = copiedClipboardData, isCut && (this.lastClipboardContent = this.getClipboardSignature(copiedClipboardData), 
+                copySnapshot.clipboardData = copiedClipboardData, copySnapshot.clipboardSignature = this.lastClipboardContent), 
+                this.copySourceRange = copySnapshot.copySourceRange, this.afterCopyData(data, isCut, copySnapshot, !isCut), 
+                isCut && (null === (_e = table.keyboardOptions) || void 0 === _e ? void 0 : _e.showCopyCellBorder) && window.setTimeout((() => {
+                    this.isClipboardOperationCurrent(operationId) && ((0, style_1.setActiveCellRangeState)(table, copySnapshot.ranges), 
+                    table.clearSelected());
+                }), 0), copySnapshot;
                 const element = table.getElement();
-                element && element !== document.activeElement && (element.focus(), yield new Promise((resolve => setTimeout(resolve, 10))));
+                if (element && element !== document.activeElement && (element.focus(), yield new Promise((resolve => setTimeout(resolve, 10))), 
+                !this.isClipboardOperationCurrent(operationId))) return null;
                 try {
                     if (navigator.clipboard && navigator.clipboard.writeText) {
                         let hasPermission = !0;
                         if (navigator.permissions && navigator.permissions.query) try {
-                            hasPermission = "granted" === (yield navigator.permissions.query({
+                            if (hasPermission = "granted" === (yield navigator.permissions.query({
                                 name: "clipboard-write"
-                            })).state;
+                            })).state, !this.isClipboardOperationCurrent(operationId)) return null;
                         } catch (permissionError) {
                             hasPermission = !0;
                         }
                         if (hasPermission) try {
-                            if (window.ClipboardItem) {
-                                let htmlValues = data;
-                                1 === table.stateManager.select.ranges.length && (null === (_d = null === (_c = table.options.keyboardOptions) || void 0 === _c ? void 0 : _c.getCopyCellValue) || void 0 === _d ? void 0 : _d.html) && (htmlValues = this.table.getCopyValue(null === (_e = table.options.keyboardOptions) || void 0 === _e ? void 0 : _e.getCopyCellValue.html));
-                                const dataHTML = (0, util_1.setDataToHTML)(htmlValues);
-                                yield navigator.clipboard.write([ new ClipboardItem({
-                                    "text/html": new Blob([ dataHTML ], {
+                            if (!this.isClipboardOperationCurrent(operationId)) return null;
+                            copiedClipboardData = yield this.queueClipboardWrite((() => __awaiter(this, void 0, void 0, (function*() {
+                                return this.isClipboardOperationCurrent(operationId) ? canWriteRichClipboard && clipboardHTML ? (yield navigator.clipboard.write([ new ClipboardItem({
+                                    "text/html": new Blob([ clipboardHTML ], {
                                         type: "text/html"
                                     }),
-                                    "text/plain": new Blob([ data ], {
+                                    "text/plain": new Blob([ plainClipboardData ], {
                                         type: "text/plain"
                                     })
-                                }) ]);
-                            } else yield navigator.clipboard.writeText(data);
+                                }) ]), {
+                                    html: clipboardHTML,
+                                    text: plainClipboardData,
+                                    hasHtml: !0,
+                                    hasText: !0,
+                                    internalFormulaText: internalFormulaText,
+                                    internalFormulaHtmlMarker: internalFormulaHtmlMarker
+                                }) : (yield navigator.clipboard.writeText(plainClipboardData), {
+                                    html: "",
+                                    text: plainClipboardData,
+                                    hasText: !0,
+                                    internalFormulaText: internalFormulaText
+                                }) : null;
+                            })))), copiedClipboardData && (copySucceeded = !0);
                         } catch (clipboardError) {
-                            this.fallbackCopyToClipboard(data, e);
-                        } else this.fallbackCopyToClipboard(data, e);
-                    } else this.fallbackCopyToClipboard(data, e);
-                    table.fireListeners(TABLE_EVENT_TYPE_1.TABLE_EVENT_TYPE.COPY_DATA, {
-                        cellRange: table.stateManager.select.ranges,
-                        copyData: data,
-                        isCut: isCut
+                            if (!this.isClipboardOperationCurrent(operationId)) return null;
+                            if (copySucceeded = this.fallbackCopyToClipboard(plainClipboardData), !this.isClipboardOperationCurrent(operationId)) return null;
+                            copySucceeded && (copiedClipboardData = {
+                                html: "",
+                                text: plainClipboardData,
+                                hasText: !0,
+                                internalFormulaText: internalFormulaText
+                            });
+                        } else copySucceeded = this.fallbackCopyToClipboard(plainClipboardData), copySucceeded && (copiedClipboardData = {
+                            html: "",
+                            text: plainClipboardData,
+                            hasText: !0,
+                            internalFormulaText: internalFormulaText
+                        });
+                    } else copySucceeded = this.fallbackCopyToClipboard(plainClipboardData), copySucceeded && (copiedClipboardData = {
+                        html: "",
+                        text: plainClipboardData,
+                        hasText: !0,
+                        internalFormulaText: internalFormulaText
                     });
+                    if (!copySucceeded) return null;
+                    if (!this.isClipboardOperationCurrent(operationId)) return null;
+                    this.lastCopiedClipboardData = copiedClipboardData, isCut && (this.lastClipboardContent = this.getClipboardSignature(copiedClipboardData), 
+                    copySnapshot.clipboardData = copiedClipboardData, copySnapshot.clipboardSignature = this.lastClipboardContent), 
+                    this.copySourceRange = copySnapshot.copySourceRange, this.afterCopyData(data, isCut, copySnapshot, !1);
                 } catch (error) {
-                    this.fallbackCopyToClipboard(data, e);
+                    if (!this.isClipboardOperationCurrent(operationId)) return null;
+                    if (!this.fallbackCopyToClipboard(plainClipboardData)) return null;
+                    if (!this.isClipboardOperationCurrent(operationId)) return null;
+                    this.lastCopiedClipboardData = {
+                        html: "",
+                        text: plainClipboardData,
+                        hasText: !0,
+                        internalFormulaText: internalFormulaText
+                    }, isCut && (this.lastClipboardContent = this.getClipboardSignature(this.lastCopiedClipboardData), 
+                    copySnapshot.clipboardData = this.lastCopiedClipboardData, copySnapshot.clipboardSignature = this.lastClipboardContent), 
+                    this.copySourceRange = copySnapshot.copySourceRange, this.afterCopyData(data, isCut, copySnapshot, !1);
                 }
             }
-            (null === (_f = table.keyboardOptions) || void 0 === _f ? void 0 : _f.showCopyCellBorder) && ((0, 
-            style_1.setActiveCellRangeState)(table), table.clearSelected());
+            return (null === (_f = table.keyboardOptions) || void 0 === _f ? void 0 : _f.showCopyCellBorder) && ((0, 
+            style_1.setActiveCellRangeState)(table, copySnapshot.ranges), table.clearSelected()), 
+            copySnapshot;
+        }));
+    }
+    afterCopyData(data, isCut, copySnapshot, updateCopyCellBorder = !0) {
+        var _a;
+        const table = this.table;
+        try {
+            table.fireListeners(TABLE_EVENT_TYPE_1.TABLE_EVENT_TYPE.COPY_DATA, {
+                cellRange: this.cloneRanges(copySnapshot.ranges),
+                copyData: data,
+                isCut: isCut
+            });
+        } catch (error) {}
+        updateCopyCellBorder && (null === (_a = table.keyboardOptions) || void 0 === _a ? void 0 : _a.showCopyCellBorder) && ((0, 
+        style_1.setActiveCellRangeState)(table, copySnapshot.ranges), table.clearSelected());
+    }
+    getCopySnapshot(includeCellInfos) {
+        const ranges = this.table.stateManager.select.ranges;
+        if (!(null == ranges ? void 0 : ranges.length)) return null;
+        const clonedRanges = ranges.map((range => ({
+            start: {
+                col: range.start.col,
+                row: range.start.row
+            },
+            end: {
+                col: range.end.col,
+                row: range.end.row
+            }
+        }))), sourceRange = 1 === ranges.length ? ranges[0] : null, sourceCellMatrix = this.getSourceCellMatrix(clonedRanges), sourceCells = this.getSourceCells(sourceCellMatrix), sourceSize = this.getSourceSize(clonedRanges, sourceCellMatrix);
+        return {
+            ranges: clonedRanges,
+            copySourceRange: sourceRange ? {
+                startCol: Math.min(sourceRange.start.col, sourceRange.end.col),
+                startRow: Math.min(sourceRange.start.row, sourceRange.end.row)
+            } : null,
+            cellInfos: includeCellInfos ? this.table.getSelectedCellInfos() : null,
+            sourceCells: sourceCells,
+            sourceCellMatrix: sourceCellMatrix,
+            sourceColCount: sourceSize.colCount,
+            sourceRowCount: sourceSize.rowCount,
+            clipboardData: null,
+            clipboardSignature: ""
+        };
+    }
+    cloneRanges(ranges) {
+        return ranges.map((range => ({
+            start: {
+                col: range.start.col,
+                row: range.start.row
+            },
+            end: {
+                col: range.end.col,
+                row: range.end.row
+            }
+        })));
+    }
+    getSourceCellMatrix(ranges) {
+        const table = this.table, createSourceCell = (col, row) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const recordShowIndex = null === (_a = table.getRecordShowIndexByCell) || void 0 === _a ? void 0 : _a.call(table, col, row);
+            return {
+                col: col,
+                row: row,
+                recordIndex: recordShowIndex >= 0 ? null === (_c = null === (_b = table.dataSource) || void 0 === _b ? void 0 : _b.getIndexKey) || void 0 === _c ? void 0 : _c.call(_b, recordShowIndex) : void 0,
+                field: null === (_g = null === (_f = null === (_e = null === (_d = table.internalProps) || void 0 === _d ? void 0 : _d.layoutMap) || void 0 === _e ? void 0 : _e.getBody) || void 0 === _f ? void 0 : _f.call(_e, col, row)) || void 0 === _g ? void 0 : _g.field,
+                value: null === (_h = table.getCellOriginValue) || void 0 === _h ? void 0 : _h.call(table, col, row)
+            };
+        };
+        if (1 === ranges.length) {
+            const range = ranges[0], startCol = Math.min(range.start.col, range.end.col), endCol = Math.max(range.start.col, range.end.col), startRow = Math.min(range.start.row, range.end.row), endRow = Math.max(range.start.row, range.end.row), sourceCellMatrix = [];
+            for (let row = startRow; row <= endRow; row++) {
+                const rowCells = [];
+                for (let col = startCol; col <= endCol; col++) rowCells.push(createSourceCell(col, row));
+                sourceCellMatrix.push(rowCells);
+            }
+            return sourceCellMatrix;
+        }
+        let minCol = Math.min(ranges[0].start.col, ranges[0].end.col), maxCol = Math.max(ranges[0].start.col, ranges[0].end.col), minRow = Math.min(ranges[0].start.row, ranges[0].end.row), maxRow = Math.max(ranges[0].start.row, ranges[0].end.row);
+        ranges.forEach((range => {
+            minCol = Math.min(minCol, range.start.col, range.end.col), maxCol = Math.max(maxCol, range.start.col, range.end.col), 
+            minRow = Math.min(minRow, range.start.row, range.end.row), maxRow = Math.max(maxRow, range.start.row, range.end.row);
+        }));
+        const isExistDataInRow = row => ranges.some((range => {
+            const startRow = Math.min(range.start.row, range.end.row), endRow = Math.max(range.start.row, range.end.row);
+            return startRow <= row && endRow >= row;
+        })), isExistDataInCol = col => ranges.some((range => {
+            const startCol = Math.min(range.start.col, range.end.col), endCol = Math.max(range.start.col, range.end.col);
+            return startCol <= col && endCol >= col;
+        })), getRangeExistDataInCell = (col, row) => ranges.some((range => {
+            const startRow = Math.min(range.start.row, range.end.row), endRow = Math.max(range.start.row, range.end.row), startCol = Math.min(range.start.col, range.end.col), endCol = Math.max(range.start.col, range.end.col);
+            return startCol <= col && endCol >= col && startRow <= row && endRow >= row;
+        })), sourceCellMatrix = [];
+        for (let row = minRow; row <= maxRow; row++) {
+            if (!isExistDataInRow(row)) continue;
+            const rowCells = [];
+            for (let col = minCol; col <= maxCol; col++) isExistDataInCol(col) && rowCells.push(getRangeExistDataInCell(col, row) ? createSourceCell(col, row) : null);
+            sourceCellMatrix.push(rowCells);
+        }
+        return sourceCellMatrix;
+    }
+    getSourceCells(sourceCellMatrix) {
+        const sourceCells = [];
+        for (let row = 0; row < sourceCellMatrix.length; row++) for (let col = 0; col < sourceCellMatrix[row].length; col++) {
+            const sourceCell = sourceCellMatrix[row][col];
+            sourceCell && sourceCells.push(sourceCell);
+        }
+        return sourceCells;
+    }
+    getSourceSize(ranges, sourceCellMatrix) {
+        var _a, _b;
+        if (sourceCellMatrix.length) return {
+            colCount: null !== (_b = null === (_a = sourceCellMatrix[0]) || void 0 === _a ? void 0 : _a.length) && void 0 !== _b ? _b : 0,
+            rowCount: sourceCellMatrix.length
+        };
+        if (1 === ranges.length) {
+            const range = ranges[0];
+            return {
+                colCount: Math.abs(range.end.col - range.start.col) + 1,
+                rowCount: Math.abs(range.end.row - range.start.row) + 1
+            };
+        }
+        return {
+            colCount: 0,
+            rowCount: 0
+        };
+    }
+    getClipboardSignature(data) {
+        return data ? JSON.stringify({
+            html: data.hasHtml ? data.html : null,
+            text: data.hasText ? data.text : null
+        }) : "";
+    }
+    isClipboardOperationCurrent(operationId) {
+        return operationId === this.clipboardOperationId && !this.table.isReleased;
+    }
+    isPasteOperationCurrent(operationId) {
+        return (void 0 === operationId || operationId === this.pasteOperationId) && !this.table.isReleased;
+    }
+    queueClipboardWrite(write) {
+        return __awaiter(this, void 0, void 0, (function*() {
+            const previousWrite = this.clipboardWritePromise;
+            let settleCurrentWrite = () => {};
+            this.clipboardWritePromise = previousWrite.catch((() => {})).then((() => new Promise((resolve => {
+                settleCurrentWrite = resolve;
+            })))), yield previousWrite.catch((() => {}));
+            try {
+                return yield write();
+            } finally {
+                settleCurrentWrite();
+            }
         }));
     }
-    fallbackCopyToClipboard(data, e) {
+    isClipboardDataChanged(clipboardData, cutState) {
+        if (!clipboardData || clipboardData.readFailed) return null;
+        const sourceData = cutState.clipboardData;
+        if (!sourceData) return this.getClipboardSignature(clipboardData) !== cutState.clipboardSignature;
+        if (sourceData.hasHtml && !clipboardData.hasHtml) return null;
+        if (sourceData.hasText && !clipboardData.hasText) return null;
+        let hasComparableType = !1;
+        return !(!clipboardData.hasHtml || !sourceData.hasHtml || (hasComparableType = !0, 
+        clipboardData.html === sourceData.html)) || (!(!clipboardData.hasText || !sourceData.hasText || (hasComparableType = !0, 
+        clipboardData.text === sourceData.text)) || !hasComparableType && null);
+    }
+    isClipboardDataSameAsLastCopy(clipboardData) {
+        const sourceData = this.lastCopiedClipboardData;
+        return !(!clipboardData || clipboardData.readFailed || !sourceData) && this.isClipboardDataSameBySignature(clipboardData, sourceData);
+    }
+    isClipboardDataSameBySignature(clipboardData, sourceData) {
+        return !(sourceData.hasHtml !== clipboardData.hasHtml || sourceData.hasText !== clipboardData.hasText || sourceData.hasHtml && sourceData.html !== clipboardData.html || sourceData.hasText && sourceData.text !== clipboardData.text);
+    }
+    getCopyFormulaPlainData(data, isCut) {
+        var _a, _b;
+        const table = this.table;
+        if (1 !== table.stateManager.select.ranges.length || !(null === (_b = null === (_a = table.options.keyboardOptions) || void 0 === _a ? void 0 : _a.getCopyCellValue) || void 0 === _b ? void 0 : _b.html)) return data;
+        try {
+            return this.table.getCopyValue(table.options.keyboardOptions.getCopyCellValue.html);
+        } catch (error) {
+            return isCut ? null : data;
+        }
+    }
+    getCopyDataHTML(data) {
+        var _a, _b, _c;
+        const table = this.table;
+        let htmlValues = data;
+        try {
+            return 1 === table.stateManager.select.ranges.length && (null === (_b = null === (_a = table.options.keyboardOptions) || void 0 === _a ? void 0 : _a.getCopyCellValue) || void 0 === _b ? void 0 : _b.html) && (htmlValues = this.table.getCopyValue(null === (_c = table.options.keyboardOptions) || void 0 === _c ? void 0 : _c.getCopyCellValue.html)), 
+            (0, util_1.setDataToHTML)(htmlValues);
+        } catch (error) {
+            try {
+                return (0, util_1.setDataToHTML)(data);
+            } catch (fallbackError) {
+                return null;
+            }
+        }
+    }
+    createInternalFormulaHtmlMarker() {
+        return `vtable-formula-${Date.now()}-${++this.internalFormulaHtmlMarkerId}`;
+    }
+    attachInternalFormulaHtmlMarker(html, marker) {
+        return `${html}\x3c!--${marker}--\x3e`;
+    }
+    setCopyDataToEventClipboard(data, dataHTML, e, internalFormulaText, internalFormulaHtmlMarker) {
+        const clipboardData = e.clipboardData;
+        if (!clipboardData) return null;
+        try {
+            clipboardData.setData("text/plain", data);
+            const copiedClipboardData = {
+                html: "",
+                text: data,
+                hasText: !0,
+                internalFormulaText: internalFormulaText
+            };
+            if (dataHTML) try {
+                clipboardData.setData("text/html", dataHTML), copiedClipboardData.html = dataHTML, 
+                copiedClipboardData.hasHtml = !0, copiedClipboardData.internalFormulaHtmlMarker = internalFormulaHtmlMarker;
+            } catch (error) {}
+            return copiedClipboardData;
+        } catch (error) {
+            return null;
+        }
+    }
+    fallbackCopyToClipboard(data) {
         try {
-            if (e.clipboardData) return void e.clipboardData.setData("text/plain", data);
             document.activeElement && document.activeElement !== document.body && document.activeElement.blur();
             const textArea = document.createElement("textarea");
             textArea.value = data, textArea.style.position = "fixed", textArea.style.left = "-999999px", 
@@ -324,198 +593,432 @@ class EventManager {
             textArea.setAttribute("aria-hidden", "true"), document.body.appendChild(textArea), 
             textArea.focus(), textArea.select(), textArea.setSelectionRange(0, data.length);
             try {
-                document.execCommand("copy");
+                const successful = document.execCommand("copy");
+                return successful;
             } catch (execError) {} finally {
                 document.body.removeChild(textArea);
             }
         } catch (error) {}
+        return !1;
     }
     handleCut(e) {
-        var _a;
         return __awaiter(this, void 0, void 0, (function*() {
-            this.handleCopy(e, !0), this.cutWaitPaste = !0, this.cutCellRange = this.table.getSelectedCellInfos(), 
-            this.cutRanges = null === (_a = this.table.stateManager.select.ranges) || void 0 === _a ? void 0 : _a.map((r => ({
-                start: {
-                    col: r.start.col,
-                    row: r.start.row
-                },
-                end: {
-                    col: r.end.col,
-                    row: r.end.row
-                }
-            }))), this.clipboardCheckTimer && clearTimeout(this.clipboardCheckTimer), this.clipboardCheckTimer = window.setTimeout((() => {
-                this.cutWaitPaste && (this.cutWaitPaste = !1, this.cutCellRange = null, this.cutRanges = null, 
-                this.clipboardCheckTimer = null);
-            }), 3e4), this.saveClipboardContent();
+            const copySnapshot = yield this.handleCopy(e, !0);
+            if (!copySnapshot) return;
+            const cutState = {
+                id: ++this.cutOperationId,
+                ranges: this.cloneRanges(copySnapshot.ranges),
+                cellInfos: copySnapshot.cellInfos,
+                sourceCells: copySnapshot.sourceCells,
+                sourceCellMatrix: copySnapshot.sourceCellMatrix,
+                sourceColCount: copySnapshot.sourceColCount,
+                sourceRowCount: copySnapshot.sourceRowCount,
+                clipboardData: copySnapshot.clipboardData,
+                clipboardSignature: copySnapshot.clipboardSignature,
+                copySourceRange: copySnapshot.copySourceRange,
+                isSingleRange: 1 === copySnapshot.ranges.length
+            };
+            this.cutWaitPaste = !0, this.activeCutState = cutState, this.cutCellRange = cutState.cellInfos, 
+            this.cutRanges = cutState.ranges, this.clipboardCheckTimer && clearTimeout(this.clipboardCheckTimer), 
+            this.clipboardCheckTimer = window.setTimeout((() => {
+                this.cutWaitPaste && this.resetCutState();
+            }), 3e4), this.lastClipboardContent = cutState.clipboardSignature;
         }));
     }
     handlePaste(e) {
-        this.cutWaitPaste ? this.checkClipboardChanged().then((changed => {
-            this.executePaste(e), changed || this.clearCutArea(this.table), this.cutWaitPaste && (this.cutWaitPaste = !1, 
-            this.cutCellRange = null, this.cutRanges = null, this.clipboardCheckTimer && (clearTimeout(this.clipboardCheckTimer), 
-            this.clipboardCheckTimer = null));
-        })).catch((() => {
-            this.executePaste(e), this.cutWaitPaste && (this.cutWaitPaste = !1, this.cutCellRange = null, 
-            this.clipboardCheckTimer && (clearTimeout(this.clipboardCheckTimer), this.clipboardCheckTimer = null));
-        })) : this.executePaste(e);
-    }
-    executePaste(e) {
-        var _a, _b, _c;
+        const pasteOperationId = ++this.pasteOperationId, pasteRange = this.getPasteRange();
+        if (!pasteRange) return;
+        const eventClipboardData = this.getEventClipboardData(e), pasteCopySourceRange = this.copySourceRange;
+        if (!this.cutWaitPaste) return void this.readClipboardDataForPaste(eventClipboardData).then((clipboardData => {
+            if (!this.isPasteOperationCurrent(pasteOperationId)) return;
+            const copySourceRange = this.isClipboardDataSameAsLastCopy(clipboardData) ? pasteCopySourceRange : null;
+            this.executePaste(clipboardData, {
+                pasteRange: pasteRange,
+                copySourceRange: copySourceRange,
+                pasteOperationId: pasteOperationId
+            });
+        })).catch((error => {}));
+        const cutState = this.activeCutState;
+        cutState ? this.readClipboardDataForPaste(eventClipboardData).then((clipboardData => __awaiter(this, void 0, void 0, (function*() {
+            var _a, _b, _c, _d, _e;
+            if (!this.isPasteOperationCurrent(pasteOperationId) || (null === (_a = this.activeCutState) || void 0 === _a ? void 0 : _a.id) !== cutState.id) return;
+            const changed = this.isClipboardDataChanged(clipboardData, cutState);
+            if (null === changed) return void (yield this.executePaste(clipboardData, {
+                pasteRange: pasteRange,
+                copySourceRange: this.isClipboardDataSameAsLastCopy(clipboardData) ? pasteCopySourceRange : null,
+                pasteOperationId: pasteOperationId
+            }));
+            const pasteResult = yield this.executePaste(clipboardData, {
+                pasteRange: pasteRange,
+                copySourceRange: changed ? null : cutState.copySourceRange,
+                cutState: changed ? null : cutState,
+                pasteOperationId: pasteOperationId
+            });
+            if (this.isPasteOperationCurrent(pasteOperationId) && (null === (_b = this.activeCutState) || void 0 === _b ? void 0 : _b.id) === cutState.id) if (changed || !pasteResult.pasted || (null === (_c = this.activeCutState) || void 0 === _c ? void 0 : _c.id) !== cutState.id) changed && (null === (_e = this.activeCutState) || void 0 === _e ? void 0 : _e.id) === cutState.id && this.resetCutState(); else if (pasteResult.migratedSourceCells.length === cutState.sourceCells.length) {
+                if (!(yield this.clearCutArea(pasteResult.migratedSourceCells, pasteResult.changedCells))) return void this.resetCutState();
+                (null === (_d = this.activeCutState) || void 0 === _d ? void 0 : _d.id) === cutState.id && this.resetCutState();
+            }
+        })))).catch((() => __awaiter(this, void 0, void 0, (function*() {
+            this.isPasteOperationCurrent(pasteOperationId) && (yield this.executePaste(eventClipboardData, {
+                pasteRange: pasteRange,
+                copySourceRange: this.isClipboardDataSameAsLastCopy(eventClipboardData) ? pasteCopySourceRange : null,
+                pasteOperationId: pasteOperationId
+            }));
+        })))) : this.executePaste(eventClipboardData, {
+            pasteRange: pasteRange,
+            copySourceRange: this.isClipboardDataSameAsLastCopy(eventClipboardData) ? pasteCopySourceRange : null,
+            pasteOperationId: pasteOperationId
+        });
+    }
+    executePaste(clipboardData, pasteContext) {
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, (function*() {
-            const table = this.table;
-            if (!(null === (_a = table.editorManager) || void 0 === _a ? void 0 : _a.editingEditor)) {
-                if (table.changeCellValues && (null === (_b = table.stateManager.select.ranges) || void 0 === _b ? void 0 : _b.length) > 0) try {
-                    if (navigator.clipboard && navigator.clipboard.read) try {
-                        const clipboardItems = yield navigator.clipboard.read();
-                        let handled = !1;
-                        for (const item of clipboardItems) {
-                            if (item.types.includes("text/html")) {
-                                yield this.pasteHtmlToTable(item), handled = !0;
-                                break;
-                            }
-                            if (item.types.includes("text/plain")) {
-                                yield this.pasteTextToTable(item), handled = !0;
-                                break;
-                            }
-                        }
-                        handled || (yield this.fallbackPasteFromClipboard(e));
-                    } catch (clipboardError) {
-                        yield this.fallbackPasteFromClipboard(e);
-                    } else yield this.fallbackPasteFromClipboard(e);
+            const table = this.table, emptyResult = this.getEmptyPasteResult(), pasteClipboardData = this.getPasteClipboardData(clipboardData, pasteContext);
+            if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId) || (null === (_a = table.editorManager) || void 0 === _a ? void 0 : _a.editingEditor)) return emptyResult;
+            if (this.pasteWriteInProgress && (yield this.pasteWritePromise.catch((() => {})), 
+            !this.isPasteOperationCurrent(pasteContext.pasteOperationId) || (null === (_b = table.editorManager) || void 0 === _b ? void 0 : _b.editingEditor))) return emptyResult;
+            let pasteResult = emptyResult, settlePasteWrite = () => {};
+            this.pasteWritePromise = new Promise((resolve => {
+                settlePasteWrite = resolve;
+            })), this.pasteWriteInProgress = !0;
+            try {
+                if (table.changeCellValues) try {
+                    if (null == pasteClipboardData ? void 0 : pasteClipboardData.html) try {
+                        const htmlResult = yield this.processPastedHTML(pasteClipboardData.html, pasteContext);
+                        if (htmlResult.pasted) return pasteResult = htmlResult, pasteResult;
+                    } catch (error) {
+                        if (/<table\b/i.test(pasteClipboardData.html)) return emptyResult;
+                    }
+                    if ((null == pasteClipboardData ? void 0 : pasteClipboardData.hasText) || (null == pasteClipboardData ? void 0 : pasteClipboardData.text)) return pasteResult = yield this.processPastedText(null !== (_c = pasteClipboardData.internalFormulaText) && void 0 !== _c ? _c : pasteClipboardData.text, pasteContext), 
+                    pasteResult;
                 } catch (error) {
-                    yield this.fallbackPasteFromClipboard(e);
+                    pasteContext.cutState && this.resetCutState();
                 }
-                (null === (_c = table.keyboardOptions) || void 0 === _c ? void 0 : _c.showCopyCellBorder) && (0, 
+                return pasteResult;
+            } finally {
+                this.pasteWriteInProgress = !1, settlePasteWrite(), !pasteContext.cutState && (null === (_d = table.keyboardOptions) || void 0 === _d ? void 0 : _d.showCopyCellBorder) && (0, 
                 style_1.clearActiveCellRangeState)(table);
             }
         }));
     }
-    fallbackPasteFromClipboard(e) {
+    getPasteClipboardData(clipboardData, pasteContext) {
+        var _a, _b;
+        if (!clipboardData || !pasteContext.copySourceRange) return clipboardData;
+        const sourceData = null !== (_b = null === (_a = pasteContext.cutState) || void 0 === _a ? void 0 : _a.clipboardData) && void 0 !== _b ? _b : this.lastCopiedClipboardData;
+        return (null == sourceData ? void 0 : sourceData.internalFormulaText) && sourceData.internalFormulaHtmlMarker && sourceData.hasHtml && clipboardData.hasHtml && this.isClipboardDataSameBySignature(clipboardData, sourceData) && clipboardData.html.includes(sourceData.internalFormulaHtmlMarker) ? Object.assign(Object.assign({}, clipboardData), {
+            internalFormulaText: sourceData.internalFormulaText
+        }) : clipboardData;
+    }
+    getPasteRange() {
+        const ranges = this.table.stateManager.select.ranges;
+        if (!(null == ranges ? void 0 : ranges.length)) return null;
+        const range = ranges[ranges.length - 1];
+        return {
+            col: Math.min(range.start.col, range.end.col),
+            row: Math.min(range.start.row, range.end.row),
+            maxCol: Math.max(range.start.col, range.end.col),
+            maxRow: Math.max(range.start.row, range.end.row)
+        };
+    }
+    getEventClipboardData(e) {
+        var _a;
+        const clipboardData = e.clipboardData || window.clipboardData;
+        if (!clipboardData) return null;
+        try {
+            const types = Array.from(null !== (_a = clipboardData.types) && void 0 !== _a ? _a : []), html = clipboardData.getData("text/html") || "", text = clipboardData.getData("text/plain") || clipboardData.getData("text") || clipboardData.getData("Text") || "", hasHtml = types.includes("text/html") || !!html;
+            return {
+                html: html,
+                text: text,
+                hasHtml: hasHtml,
+                hasText: types.includes("text/plain") || types.includes("text") || types.includes("Text") || !!text
+            };
+        } catch (error) {
+            return {
+                html: "",
+                text: "",
+                readFailed: !0
+            };
+        }
+    }
+    readClipboardDataForPaste(eventClipboardData) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, (function*() {
-            const table = this.table, ranges = table.stateManager.select.ranges, col = Math.min(ranges[0].start.col, ranges[0].end.col), row = Math.min(ranges[0].start.row, ranges[0].end.row);
-            try {
-                const element = table.getElement();
-                element && element !== document.activeElement && (element.focus(), yield new Promise((resolve => setTimeout(resolve, 10))));
-                const clipboardData = e.clipboardData || window.clipboardData || window.Clipboard;
-                if (clipboardData) {
-                    const pastedData = clipboardData.getData("text") || clipboardData.getData("Text");
-                    if (pastedData) return void (yield this.processPastedText(pastedData, col, row));
+            if ((null == eventClipboardData ? void 0 : eventClipboardData.readFailed) || (null == eventClipboardData ? void 0 : eventClipboardData.hasHtml) || (null == eventClipboardData ? void 0 : eventClipboardData.hasText)) return eventClipboardData;
+            if (null === (_a = navigator.clipboard) || void 0 === _a ? void 0 : _a.read) try {
+                const clipboardItems = yield navigator.clipboard.read(), clipboardData = {
+                    html: "",
+                    text: ""
+                };
+                for (const item of clipboardItems) {
+                    if (!clipboardData.html && item.types.includes("text/html")) try {
+                        clipboardData.html = yield (yield item.getType("text/html")).text(), clipboardData.hasHtml = !0;
+                    } catch (error) {}
+                    if (!clipboardData.text && item.types.includes("text/plain")) try {
+                        clipboardData.text = yield (yield item.getType("text/plain")).text(), clipboardData.hasText = !0;
+                    } catch (error) {}
                 }
+                if (clipboardData.hasHtml || clipboardData.hasText) return clipboardData;
             } catch (error) {}
+            if (null === (_b = navigator.clipboard) || void 0 === _b ? void 0 : _b.readText) try {
+                return {
+                    html: "",
+                    text: yield navigator.clipboard.readText(),
+                    hasText: !0
+                };
+            } catch (error) {}
+            return null != eventClipboardData ? eventClipboardData : {
+                html: "",
+                text: "",
+                readFailed: !0
+            };
         }));
     }
-    processPastedText(pastedData, col, row) {
+    decodeHTMLCellValue(cellHTML) {
         var _a;
-        return __awaiter(this, void 0, void 0, (function*() {
-            const table = this.table, rows = pastedData.split("\n"), values = [];
-            let processedValues;
-            rows.forEach((function(rowCells) {
-                const cells = rowCells.split("\t"), rowValues = [];
-                values.push(rowValues), cells.forEach((function(cell, cellIndex) {
-                    cellIndex === cells.length - 1 && (cell = cell.trim()), rowValues.push(cell);
-                }));
-            })), (null === (_a = table.options.keyboardOptions) || void 0 === _a ? void 0 : _a.processFormulaBeforePaste) && this.copySourceRange && (processedValues = table.options.keyboardOptions.processFormulaBeforePaste(values, this.copySourceRange.startCol, this.copySourceRange.startRow, col, row));
-            const changedCellResults = yield table.changeCellValues(col, row, processedValues || values, !0);
-            table.hasListeners(TABLE_EVENT_TYPE_1.TABLE_EVENT_TYPE.PASTED_DATA) && table.fireListeners(TABLE_EVENT_TYPE_1.TABLE_EVENT_TYPE.PASTED_DATA, {
-                col: col,
-                row: row,
-                pasteData: processedValues || values,
-                changedCellResults: changedCellResults
-            });
-        }));
+        const template = document.createElement("template");
+        return template.innerHTML = cellHTML.replace(/<br\b[^>]*>(?:\r\n|\r|\n)?/gim, "\n").replace(/&nbsp;/gi, " "), 
+        null !== (_a = template.content.textContent) && void 0 !== _a ? _a : "";
     }
-    clearCutArea(table) {
-        try {
-            const ranges = this.cutRanges;
-            if (!ranges || 0 === ranges.length) return;
-            table.changeCellValuesByRanges(ranges, "");
-        } catch (error) {}
-    }
-    checkClipboardChanged() {
+    processPastedHTML(pastedData, pasteContext) {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, (function*() {
-            if (!navigator.clipboard || !navigator.clipboard.readText) return !1;
-            try {
-                return (yield navigator.clipboard.readText()) !== this.lastClipboardContent;
-            } catch (err) {
-                return !1;
+            const cellRegex = /<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/gi, table = this.table, pasteRange = pasteContext.pasteRange, {col: col, row: row, maxCol: maxCol, maxRow: maxRow} = pasteRange;
+            let pasteValuesColCount = 0, pasteValuesRowCount = 0, values = [];
+            if (!pastedData || !/<table\b/i.test(pastedData)) return this.getEmptyPasteResult();
+            const matches = Array.from(pastedData.matchAll(/<tr[^>]*>([\s\S]*?)<\/tr>/gi));
+            for (const match of matches) {
+                const rowContent = match[1], cellMatches = Array.from(rowContent.matchAll(cellRegex));
+                if (!cellMatches.length) continue;
+                const rowValues = cellMatches.map((cellMatch => this.decodeHTMLCellValue(cellMatch[1])));
+                values.push(rowValues), pasteValuesColCount = Math.max(pasteValuesColCount, null !== (_a = null == rowValues ? void 0 : rowValues.length) && void 0 !== _a ? _a : 0);
             }
+            if (pasteValuesRowCount = null !== (_b = values.length) && void 0 !== _b ? _b : 0, 
+            !pasteValuesRowCount || !pasteValuesColCount) return this.getEmptyPasteResult();
+            let processedValues;
+            values = this.handlePasteValues(values, pasteValuesRowCount, pasteValuesColCount, maxRow - row + 1, maxCol - col + 1), 
+            (null === (_c = table.options.keyboardOptions) || void 0 === _c ? void 0 : _c.processFormulaBeforePaste) && pasteContext.copySourceRange && (processedValues = table.options.keyboardOptions.processFormulaBeforePaste(values, pasteContext.copySourceRange.startCol, pasteContext.copySourceRange.startRow, col, row));
+            const valuesToPaste = processedValues || values, targetCells = this.getPasteTargetCells(pasteRange, valuesToPaste);
+            if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId)) return this.getEmptyPasteResult();
+            if (pasteContext.cutState) {
+                const validatedCellResults = yield this.validatePasteTargetCells(pasteRange, valuesToPaste);
+                if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId)) return this.getEmptyPasteResult();
+                if (!this.isFullPasteAllowed(valuesToPaste, validatedCellResults)) return this.getEmptyPasteResult(validatedCellResults);
+            }
+            const rawChangedCellResults = yield table.changeCellValues(col, row, valuesToPaste, !pasteContext.cutState, !0, void 0, (() => !this.isPasteOperationCurrent(pasteContext.pasteOperationId)));
+            if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId)) return this.getEmptyPasteResult();
+            const changedCellResults = this.normalizeChangedCellResults(rawChangedCellResults, pasteRange, valuesToPaste), changedCells = this.getChangedCells(targetCells, changedCellResults), migratedSourceCells = this.getMigratedSourceCells(pasteContext.cutState, changedCellResults);
+            return changedCells.length ? (this.firePastedDataEvent(col, row, valuesToPaste, changedCellResults), 
+            {
+                pasted: !0,
+                changedCellResults: changedCellResults,
+                changedCells: changedCells,
+                migratedSourceCells: migratedSourceCells
+            }) : this.getEmptyPasteResult(changedCellResults);
         }));
     }
-    saveClipboardContent() {
-        navigator.clipboard && navigator.clipboard.readText && setTimeout((() => {
-            navigator.clipboard.readText().then((text => {
-                this.lastClipboardContent = text;
-            })).catch((err => {}));
-        }), 50);
-    }
-    pasteHtmlToTable(item) {
-        const regex = /<tr[^>]*>([\s\S]*?)<\/tr>/g, cellRegex = /<td[^>]*>([\s\S]*?)<\/td>/g, table = this.table, ranges = table.stateManager.select.ranges, selectRangeLength = ranges.length, col = Math.min(ranges[selectRangeLength - 1].start.col, ranges[selectRangeLength - 1].end.col), row = Math.min(ranges[selectRangeLength - 1].start.row, ranges[selectRangeLength - 1].end.row), maxCol = Math.max(ranges[selectRangeLength - 1].start.col, ranges[selectRangeLength - 1].end.col), maxRow = Math.max(ranges[selectRangeLength - 1].start.row, ranges[selectRangeLength - 1].end.row);
-        let pasteValuesColCount = 0, pasteValuesRowCount = 0, values = [];
-        item.getType("text/html").then((blob => {
-            blob.text().then((pastedData => __awaiter(this, void 0, void 0, (function*() {
-                var _a, _b, _c;
-                if (pastedData && /(<table)|(<TABLE)/g.test(pastedData)) {
-                    const matches = Array.from(pastedData.matchAll(regex));
-                    for (const match of matches) {
-                        const rowContent = match[1], rowValues = Array.from(rowContent.matchAll(cellRegex)).map((cellMatch => cellMatch[1].replace(/(<(?!br)([^>]+)>)/gi, "").replace(/<br(\s*|\/)>[\r\n]?/gim, "\n").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&#9;/gi, "\t").replace(/&nbsp;/g, " ")));
-                        values.push(rowValues), pasteValuesColCount = Math.max(pasteValuesColCount, null !== (_a = null == rowValues ? void 0 : rowValues.length) && void 0 !== _a ? _a : 0);
-                    }
-                    let processedValues;
-                    pasteValuesRowCount = null !== (_b = values.length) && void 0 !== _b ? _b : 0, values = this.handlePasteValues(values, pasteValuesRowCount, pasteValuesColCount, maxRow - row + 1, maxCol - col + 1), 
-                    (null === (_c = table.options.keyboardOptions) || void 0 === _c ? void 0 : _c.processFormulaBeforePaste) && this.copySourceRange && (processedValues = table.options.keyboardOptions.processFormulaBeforePaste(values, this.copySourceRange.startCol, this.copySourceRange.startRow, col, row));
-                    const changedCellResults = yield table.changeCellValues(col, row, processedValues || values, !0);
-                    table.hasListeners(TABLE_EVENT_TYPE_1.TABLE_EVENT_TYPE.PASTED_DATA) && table.fireListeners(TABLE_EVENT_TYPE_1.TABLE_EVENT_TYPE.PASTED_DATA, {
-                        col: col,
-                        row: row,
-                        pasteData: processedValues || values,
-                        changedCellResults: changedCellResults
-                    });
-                } else navigator.clipboard.read().then((clipboardItems => {
-                    for (const item of clipboardItems) item.types.includes("text/plain") && item.getType("text/plain").then((blob => {
-                        blob.text().then((data => this._pasteValue(data)));
-                    }));
-                }));
-            }))));
-        }));
-    }
-    _pasteValue(pastedData) {
-        var _a, _b;
+    processPastedText(pastedData, pasteContext) {
+        var _a;
         return __awaiter(this, void 0, void 0, (function*() {
-            const table = this.table, ranges = table.stateManager.select.ranges, selectRangeLength = ranges.length, col = Math.min(ranges[selectRangeLength - 1].start.col, ranges[selectRangeLength - 1].end.col), row = Math.min(ranges[selectRangeLength - 1].start.row, ranges[selectRangeLength - 1].end.row), maxCol = Math.max(ranges[selectRangeLength - 1].start.col, ranges[selectRangeLength - 1].end.col), maxRow = Math.max(ranges[selectRangeLength - 1].start.row, ranges[selectRangeLength - 1].end.row);
-            let pasteValuesColCount = 0, pasteValuesRowCount = 0, values = [];
+            const table = this.table, pasteRange = pasteContext.pasteRange, {col: col, row: row, maxCol: maxCol, maxRow: maxRow} = pasteRange;
+            let values = this.parsePlainTextPastedData(pastedData);
+            const pasteValuesRowCount = values.length, pasteValuesColCount = Math.max(...values.map((rowValues => rowValues.length)));
+            if (!pasteValuesRowCount || !pasteValuesColCount) return this.getEmptyPasteResult();
             let processedValues;
-            pastedData.split("\n").forEach((function(rowCells, rowIndex) {
-                var _a;
-                const cells = rowCells.split("\t"), rowValues = [];
-                values.push(rowValues), cells.forEach((function(cell, cellIndex) {
-                    cellIndex === cells.length - 1 && (cell = cell.trim()), rowValues.push(cell);
-                })), pasteValuesColCount = Math.max(pasteValuesColCount, null !== (_a = null == rowValues ? void 0 : rowValues.length) && void 0 !== _a ? _a : 0);
-            })), pasteValuesRowCount = null !== (_a = values.length) && void 0 !== _a ? _a : 0, 
             values = this.handlePasteValues(values, pasteValuesRowCount, pasteValuesColCount, maxRow - row + 1, maxCol - col + 1), 
-            (null === (_b = table.options.keyboardOptions) || void 0 === _b ? void 0 : _b.processFormulaBeforePaste) && this.copySourceRange && (processedValues = table.options.keyboardOptions.processFormulaBeforePaste(values, this.copySourceRange.startCol, this.copySourceRange.startRow, col, row));
-            const changedCellResults = yield table.changeCellValues(col, row, processedValues || values, !0);
-            table.hasListeners(TABLE_EVENT_TYPE_1.TABLE_EVENT_TYPE.PASTED_DATA) && table.fireListeners(TABLE_EVENT_TYPE_1.TABLE_EVENT_TYPE.PASTED_DATA, {
+            (null === (_a = table.options.keyboardOptions) || void 0 === _a ? void 0 : _a.processFormulaBeforePaste) && pasteContext.copySourceRange && (processedValues = table.options.keyboardOptions.processFormulaBeforePaste(values, pasteContext.copySourceRange.startCol, pasteContext.copySourceRange.startRow, col, row));
+            const valuesToPaste = processedValues || values, targetCells = this.getPasteTargetCells(pasteRange, valuesToPaste);
+            if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId)) return this.getEmptyPasteResult();
+            if (pasteContext.cutState) {
+                const validatedCellResults = yield this.validatePasteTargetCells(pasteRange, valuesToPaste);
+                if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId)) return this.getEmptyPasteResult();
+                if (!this.isFullPasteAllowed(valuesToPaste, validatedCellResults)) return this.getEmptyPasteResult(validatedCellResults);
+            }
+            const rawChangedCellResults = yield table.changeCellValues(col, row, valuesToPaste, !pasteContext.cutState, !0, void 0, (() => !this.isPasteOperationCurrent(pasteContext.pasteOperationId)));
+            if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId)) return this.getEmptyPasteResult();
+            const changedCellResults = this.normalizeChangedCellResults(rawChangedCellResults, pasteRange, valuesToPaste), changedCells = this.getChangedCells(targetCells, changedCellResults), migratedSourceCells = this.getMigratedSourceCells(pasteContext.cutState, changedCellResults);
+            return changedCells.length ? (this.firePastedDataEvent(col, row, valuesToPaste, changedCellResults), 
+            {
+                pasted: !0,
+                changedCellResults: changedCellResults,
+                changedCells: changedCells,
+                migratedSourceCells: migratedSourceCells
+            }) : this.getEmptyPasteResult(changedCellResults);
+        }));
+    }
+    firePastedDataEvent(col, row, pasteData, changedCellResults) {
+        const table = this.table;
+        if (table.hasListeners(TABLE_EVENT_TYPE_1.TABLE_EVENT_TYPE.PASTED_DATA)) try {
+            table.fireListeners(TABLE_EVENT_TYPE_1.TABLE_EVENT_TYPE.PASTED_DATA, {
                 col: col,
                 row: row,
-                pasteData: processedValues || values,
+                pasteData: pasteData,
                 changedCellResults: changedCellResults
             });
+        } catch (error) {}
+    }
+    getEmptyPasteResult(changedCellResults = []) {
+        return {
+            pasted: !1,
+            changedCellResults: changedCellResults,
+            changedCells: [],
+            migratedSourceCells: []
+        };
+    }
+    getPasteTargetCells(pasteRange, values) {
+        const targetCells = [];
+        for (let rowIndex = 0; rowIndex < values.length; rowIndex++) {
+            targetCells[rowIndex] = [];
+            for (let colIndex = 0; colIndex < values[rowIndex].length; colIndex++) targetCells[rowIndex][colIndex] = this.getCellIdentity(pasteRange.col + colIndex, pasteRange.row + rowIndex);
+        }
+        return targetCells;
+    }
+    getChangedCells(targetCells, changedCellResults) {
+        var _a, _b, _c;
+        const changedCells = [];
+        for (let rowIndex = 0; rowIndex < changedCellResults.length; rowIndex++) for (let colIndex = 0; colIndex < (null !== (_b = null === (_a = changedCellResults[rowIndex]) || void 0 === _a ? void 0 : _a.length) && void 0 !== _b ? _b : 0); colIndex++) changedCellResults[rowIndex][colIndex] && (null === (_c = targetCells[rowIndex]) || void 0 === _c ? void 0 : _c[colIndex]) && changedCells.push(targetCells[rowIndex][colIndex]);
+        return changedCells;
+    }
+    normalizeChangedCellResults(changedCellResults, pasteRange, values) {
+        if (Array.isArray(changedCellResults)) return changedCellResults;
+        const table = this.table;
+        return values.map(((rowValues, rowIndex) => rowValues.map(((_value, colIndex) => {
+            const targetCol = pasteRange.col + colIndex, targetRow = pasteRange.row + rowIndex;
+            return targetCol < table.colCount && targetRow < table.rowCount && (!table.isHasEditorDefine || table.isHasEditorDefine(targetCol, targetRow));
+        }))));
+    }
+    validatePasteTargetCells(pasteRange, values) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, (function*() {
+            const table = this.table, changedCellResults = [];
+            for (let rowIndex = 0; rowIndex < values.length; rowIndex++) {
+                changedCellResults[rowIndex] = [];
+                for (let colIndex = 0; colIndex < values[rowIndex].length; colIndex++) {
+                    const targetCol = pasteRange.col + colIndex, targetRow = pasteRange.row + rowIndex, tableAny = table;
+                    let canChange = targetCol < tableAny.colCount && targetRow < tableAny.rowCount && (!tableAny.isHasEditorDefine || tableAny.isHasEditorDefine(targetCol, targetRow));
+                    if (canChange) {
+                        const editor = null === (_a = tableAny.getEditor) || void 0 === _a ? void 0 : _a.call(tableAny, targetCol, targetRow), oldValue = null === (_b = table.getCellOriginValue) || void 0 === _b ? void 0 : _b.call(table, targetCol, targetRow), validateResult = null === (_d = null === (_c = null == editor ? void 0 : editor.validateValue) || void 0 === _c ? void 0 : _c.call(editor, values[rowIndex][colIndex], oldValue, {
+                            col: targetCol,
+                            row: targetRow
+                        }, table)) || void 0 === _d || _d, resolvedValidateResult = validateResult && "function" == typeof validateResult.then ? yield validateResult : validateResult;
+                        canChange = !0 === resolvedValidateResult || "validate-exit" === resolvedValidateResult || "validate-not-exit" === resolvedValidateResult;
+                    }
+                    changedCellResults[rowIndex][colIndex] = canChange;
+                }
+            }
+            return changedCellResults;
         }));
     }
-    pasteTextToTable(item) {
+    isFullPasteAllowed(values, changedCellResults) {
+        return values.every(((rowValues, rowIndex) => rowValues.every(((_value, colIndex) => {
+            var _a;
+            return !0 === (null === (_a = changedCellResults[rowIndex]) || void 0 === _a ? void 0 : _a[colIndex]);
+        }))));
+    }
+    getMigratedSourceCells(cutState, changedCellResults) {
+        var _a, _b, _c, _d, _e;
+        if (!(null == cutState ? void 0 : cutState.sourceCells.length) || !cutState.sourceColCount || !cutState.sourceRowCount) return [];
+        const migratedSourceCells = [], migratedKeys = new Set;
+        if (!cutState.isSingleRange) {
+            for (let rowIndex = 0; rowIndex < changedCellResults.length; rowIndex++) for (let colIndex = 0; colIndex < (null !== (_b = null === (_a = changedCellResults[rowIndex]) || void 0 === _a ? void 0 : _a.length) && void 0 !== _b ? _b : 0); colIndex++) {
+                if (!changedCellResults[rowIndex][colIndex]) continue;
+                const sourceRow = rowIndex % cutState.sourceRowCount, sourceCol = colIndex % cutState.sourceColCount, sourceCell = null === (_c = cutState.sourceCellMatrix[sourceRow]) || void 0 === _c ? void 0 : _c[sourceCol];
+                if (!sourceCell) continue;
+                const sourceKey = this.getCellKey(sourceCell);
+                migratedKeys.has(sourceKey) || (migratedKeys.add(sourceKey), migratedSourceCells.push(sourceCell));
+            }
+            return migratedSourceCells.length === cutState.sourceCells.length ? migratedSourceCells : [];
+        }
+        for (let rowIndex = 0; rowIndex < changedCellResults.length; rowIndex++) for (let colIndex = 0; colIndex < (null !== (_e = null === (_d = changedCellResults[rowIndex]) || void 0 === _d ? void 0 : _d.length) && void 0 !== _e ? _e : 0); colIndex++) {
+            if (!changedCellResults[rowIndex][colIndex]) continue;
+            const sourceRow = rowIndex % cutState.sourceRowCount, sourceCol = colIndex % cutState.sourceColCount, sourceIndex = sourceRow * cutState.sourceColCount + sourceCol, sourceCell = cutState.sourceCells[sourceIndex];
+            if (!sourceCell) continue;
+            const sourceKey = this.getCellKey(sourceCell);
+            migratedKeys.has(sourceKey) || (migratedKeys.add(sourceKey), migratedSourceCells.push(sourceCell));
+        }
+        return migratedSourceCells;
+    }
+    getCellIdentity(col, row) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const table = this.table, recordShowIndex = null === (_a = table.getRecordShowIndexByCell) || void 0 === _a ? void 0 : _a.call(table, col, row);
+        return {
+            col: col,
+            row: row,
+            recordIndex: recordShowIndex >= 0 ? null === (_c = null === (_b = table.dataSource) || void 0 === _b ? void 0 : _b.getIndexKey) || void 0 === _c ? void 0 : _c.call(_b, recordShowIndex) : void 0,
+            field: null === (_g = null === (_f = null === (_e = null === (_d = table.internalProps) || void 0 === _d ? void 0 : _d.layoutMap) || void 0 === _e ? void 0 : _e.getBody) || void 0 === _f ? void 0 : _f.call(_e, col, row)) || void 0 === _g ? void 0 : _g.field
+        };
+    }
+    clearCutArea(migratedSourceCells, changedTargetCells) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, (function*() {
-            const table = this.table, ranges = table.stateManager.select.ranges, selectRangeLength = ranges.length, col = Math.min(ranges[selectRangeLength - 1].start.col, ranges[selectRangeLength - 1].end.col), row = Math.min(ranges[selectRangeLength - 1].start.row, ranges[selectRangeLength - 1].end.row), maxCol = Math.max(ranges[selectRangeLength - 1].start.col, ranges[selectRangeLength - 1].end.col), maxRow = Math.max(ranges[selectRangeLength - 1].start.row, ranges[selectRangeLength - 1].end.row);
             try {
-                const blob = yield item.getType("text/plain"), pastedData = yield blob.text(), values = this.parsePastedData(pastedData), pasteValuesRowCount = values.length, pasteValuesColCount = Math.max(...values.map((row => row.length)), 0), processedValues = this.handlePasteValues(values, pasteValuesRowCount, pasteValuesColCount, maxRow - row + 1, maxCol - col + 1), changedCellResults = yield table.changeCellValues(col, row, processedValues, !0);
-                table.hasListeners(TABLE_EVENT_TYPE_1.TABLE_EVENT_TYPE.PASTED_DATA) && table.fireListeners(TABLE_EVENT_TYPE_1.TABLE_EVENT_TYPE.PASTED_DATA, {
-                    col: col,
-                    row: row,
-                    pasteData: processedValues,
-                    changedCellResults: changedCellResults
+                const table = this.table, changedTargetKeys = new Set;
+                changedTargetCells.forEach((cell => {
+                    changedTargetKeys.add(this.getCellKey(cell)), changedTargetKeys.add(this.getCoordKey(cell));
+                }));
+                const clearedKeys = new Set, sourceChanges = [], coordChanges = [];
+                for (let i = 0; i < migratedSourceCells.length; i++) {
+                    const sourceCell = migratedSourceCells[i], sourceKey = this.getCellKey(sourceCell);
+                    if (clearedKeys.has(sourceKey) || changedTargetKeys.has(sourceKey) || changedTargetKeys.has(this.getCoordKey(sourceCell))) continue;
+                    const currentAddress = this.getCurrentCellAddress(sourceCell);
+                    currentAddress && (this.isSourceCellUnchanged(sourceCell, currentAddress) && (void 0 !== sourceCell.recordIndex && void 0 !== sourceCell.field && table.changeCellValuesByRecords ? sourceChanges.push({
+                        recordIndex: sourceCell.recordIndex,
+                        field: sourceCell.field,
+                        value: ""
+                    }) : coordChanges.push(currentAddress), clearedKeys.add(sourceKey)));
+                }
+                sourceChanges.length && table.changeCellValuesByRecords(sourceChanges, {
+                    triggerEvent: !0,
+                    autoRefresh: !1
                 });
-            } catch (error) {}
+                for (let i = 0; i < coordChanges.length; i++) yield table.changeCellValues(coordChanges[i].col, coordChanges[i].row, [ [ "" ] ], !1);
+                return sourceChanges.length && (null === (_b = (_a = table).refreshAfterSourceChange) || void 0 === _b || _b.call(_a)), 
+                !0;
+            } catch (error) {
+                return !1;
+            }
         }));
     }
+    isSourceCellUnchanged(sourceCell, currentAddress) {
+        var _a;
+        const table = this.table;
+        return Object.is(null === (_a = table.getCellOriginValue) || void 0 === _a ? void 0 : _a.call(table, currentAddress.col, currentAddress.row), sourceCell.value);
+    }
+    getCurrentCellAddress(sourceCell) {
+        const table = this.table;
+        if (void 0 !== sourceCell.recordIndex && void 0 !== sourceCell.field && table.getCellAddrByFieldRecord) {
+            const address = table.getCellAddrByFieldRecord(sourceCell.field, sourceCell.recordIndex);
+            return address && address.col >= 0 && address.row >= 0 ? address : null;
+        }
+        return {
+            col: sourceCell.col,
+            row: sourceCell.row
+        };
+    }
+    getCellKey(cell) {
+        return void 0 !== cell.recordIndex && void 0 !== cell.field ? `record:${this.getStableKeyPart(cell.recordIndex)}:${this.getStableKeyPart(cell.field)}` : this.getCoordKey(cell);
+    }
+    getCoordKey(cell) {
+        return `coord:${cell.col}:${cell.row}`;
+    }
+    getStableKeyPart(value) {
+        if (null === value) return "null";
+        const valueType = typeof value;
+        if ("string" === valueType || "number" === valueType || "boolean" === valueType) return `${valueType}:${JSON.stringify(value)}`;
+        if (Array.isArray(value)) return `array:[${value.map((item => this.getStableKeyPart(item))).join(",")}]`;
+        if ("object" === valueType || "function" === valueType) {
+            let id = this.fieldKeyIds.get(value);
+            return void 0 === id && (id = ++this.fieldKeyId, this.fieldKeyIds.set(value, id)), 
+            `${valueType}:#${id}`;
+        }
+        return `${valueType}:${String(value)}`;
+    }
+    resetCutState() {
+        var _a;
+        this.cutWaitPaste = !1, this.activeCutState = null, this.cutCellRange = null, this.cutRanges = null, 
+        (null === (_a = this.table.keyboardOptions) || void 0 === _a ? void 0 : _a.showCopyCellBorder) && (0, 
+        style_1.clearActiveCellRangeState)(this.table), this.clipboardCheckTimer && (clearTimeout(this.clipboardCheckTimer), 
+        this.clipboardCheckTimer = null);
+    }
     parsePastedData(pastedData) {
         const rows = pastedData.replace(/\r(?!\n)/g, "\r\n").split("\r\n"), values = [];
         return rows.length > 1 && "" === rows[rows.length - 1] && rows.pop(), rows.forEach((rowCells => {
@@ -523,6 +1026,10 @@ class EventManager {
             values.push(rowValues);
         })), values;
     }
+    parsePlainTextPastedData(pastedData) {
+        const rows = pastedData.replace(/\r\n|\r/g, "\n").split("\n");
+        return rows.length > 1 && "" === rows[rows.length - 1] && rows.pop(), rows.map((rowCells => rowCells.split("\t")));
+    }
     processCellValue(cell) {
         cell.includes("\n") && (cell = cell.replace(/^"(.*)"$/, "$1").replace(/["]*/g, (match => new Array(Math.floor(match.length / 2)).fill('"').join(""))));
         const numValue = Number(cell);
@@ -549,4 +1056,4 @@ class EventManager {
 }
 
 exports.EventManager = EventManager;
-//# sourceMappingURL=event.js.map
+//# sourceMappingURL=event.js.map