@visactor/vtable-plugins 1.23.3-alpha.0 → 1.24.0

package/dist/vtable-plugins.js

@@ -200,7 +200,7 @@
     };
     var isNumber$3 = isNumber$2;
 
-    function cloneDeep$1(value, ignoreWhen, excludeKeys) {
+    function cloneDeep$2(value, ignoreWhen, excludeKeys) {
       let result;
       if (!isValid$2(value) || "object" != typeof value || ignoreWhen && ignoreWhen(value)) return value;
       const isArr = isArray$6(value),
@@ -211,18 +211,11 @@
       if (result) for (; ++index < (props || value).length;) {
         const key = props ? props[index] : index,
           subValue = value[key];
-        excludeKeys && excludeKeys.includes(key.toString()) ? result[key] = subValue : result[key] = cloneDeep$1(subValue, ignoreWhen, excludeKeys);
+        excludeKeys && excludeKeys.includes(key.toString()) ? result[key] = subValue : result[key] = cloneDeep$2(subValue, ignoreWhen, excludeKeys);
       }
       return result;
     }
 
-    function arrayEqual(a, b) {
-      if (!isArray$6(a) || !isArray$6(b)) return !1;
-      if (a.length !== b.length) return !1;
-      for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return !1;
-      return !0;
-    }
-
     var InteractionState;
     !function (InteractionState) {
       InteractionState.default = "default", InteractionState.grabing = "grabing", InteractionState.scrolling = "scrolling";
@@ -2096,7 +2089,7 @@
             const domRect = this.getElement().getBoundingClientRect();
             const x1 = domRect.top;
             const y1 = viewPortWidth - domRect.right;
-            const matrix = vrender.matrixAllocate.allocate(1, 0, 0, 1, 0, 0);
+            const matrix = VTable.matrixAllocate.allocate(1, 0, 0, 1, 0, 0);
             matrix.translate(x1, y1);
             const centerX = rotateCenter - x1;
             const centerY = rotateCenter - y1;
@@ -2109,13 +2102,13 @@
             }
             return matrix;
         };
-        vrender.registerGlobalEventTransformer(vrender.vglobal, this.getElement(), getMatrix, getRect, vrender.transformPointForCanvas);
-        vrender.registerWindowEventTransformer(this.scenegraph.stage.window, this.getElement(), getMatrix, getRect, vrender.transformPointForCanvas);
+        VTable.registerGlobalEventTransformer(VTable.vglobal, this.getElement(), getMatrix, getRect, VTable.transformPointForCanvas);
+        VTable.registerWindowEventTransformer(this.scenegraph.stage.window, this.getElement(), getMatrix, getRect, VTable.transformPointForCanvas);
         const rotateRablePlugin = this.pluginManager.getPluginByName('Rotate Table');
         if (rotateRablePlugin) {
-            rotateRablePlugin.vglobal_mapToCanvasPoint = vrender.vglobal.mapToCanvasPoint;
+            rotateRablePlugin.vglobal_mapToCanvasPoint = VTable.vglobal.mapToCanvasPoint;
         }
-        vrender.vglobal.mapToCanvasPoint = vrender.mapToCanvasPointForCanvas;
+        VTable.vglobal.mapToCanvasPoint = VTable.mapToCanvasPointForCanvas;
     }
     function cancelTransform(rotateDom) {
         this.rotateDegree = 0;
@@ -2135,15 +2128,15 @@
             };
         };
         const getMatrix = () => {
-            const matrix = vrender.matrixAllocate.allocate(1, 0, 0, 1, 0, 0);
+            const matrix = VTable.matrixAllocate.allocate(1, 0, 0, 1, 0, 0);
             matrix.translate(x1, y1);
             return matrix;
         };
-        vrender.registerGlobalEventTransformer(vrender.vglobal, this.getElement(), getMatrix, getRect, vrender.transformPointForCanvas);
-        vrender.registerWindowEventTransformer(this.scenegraph.stage.window, this.getElement(), getMatrix, getRect, vrender.transformPointForCanvas);
+        VTable.registerGlobalEventTransformer(VTable.vglobal, this.getElement(), getMatrix, getRect, VTable.transformPointForCanvas);
+        VTable.registerWindowEventTransformer(this.scenegraph.stage.window, this.getElement(), getMatrix, getRect, VTable.transformPointForCanvas);
         const rotateRablePlugin = this.pluginManager.getPluginByName('Rotate Table');
         if (rotateRablePlugin) {
-            vrender.vglobal.mapToCanvasPoint = rotateRablePlugin.vglobal_mapToCanvasPoint;
+            VTable.vglobal.mapToCanvasPoint = rotateRablePlugin.vglobal_mapToCanvasPoint;
         }
     }
 
@@ -10451,6 +10444,11 @@ ${recordsStr}
             table.updateFilterRules([...this.filterFuncRule, ...this.filterValueRule], {
                 clearRowHeightCache: false,
                 onFilterRecordsEnd: this.pluginOptions?.onFilterRecordsEnd
+                    ? (records) => {
+                        this.pluginOptions.onFilterRecordsEnd?.(records);
+                        return records;
+                    }
+                    : undefined
             });
         }
         createFilterFunction(filter) {
@@ -10580,6 +10578,119 @@ ${recordsStr}
         getAllFilterStates() {
             return this.state;
         }
+        getSnapshot() {
+            const filters = [];
+            this.state.filters.forEach(v => {
+                const next = { ...v };
+                if (next && next.type === 'byValue' && Array.isArray(next.values)) {
+                    next.values = next.values.slice().sort((a, b) => String(a).localeCompare(String(b)));
+                }
+                if (next && Array.isArray(next.condition) && next.condition.length > 2) {
+                    next.condition = next.condition.slice();
+                }
+                filters.push(next);
+            });
+            filters.sort((a, b) => String(a.field).localeCompare(String(b.field)));
+            return { filters };
+        }
+        applySnapshot(snapshot, actionType = exports.FilterActionType.APPLY_FILTERS) {
+            const next = new Map();
+            (snapshot?.filters ?? []).forEach(cfg => {
+                if (!cfg) {
+                    return;
+                }
+                const cloned = { ...cfg };
+                if (cloned && cloned.type === 'byValue' && Array.isArray(cloned.values)) {
+                    cloned.values = cloned.values.slice();
+                }
+                if (cloned && Array.isArray(cloned.condition)) {
+                    cloned.condition = cloned.condition.slice();
+                }
+                next.set(cloned.field, cloned);
+            });
+            this.state = { ...this.state, filters: next };
+            this.applyFilters();
+            this.notifyListeners({ type: actionType, payload: { fromSnapshot: true } });
+        }
+        shiftFieldsOnAddColumns(columnIndex, columnCount) {
+            if (!Number.isFinite(columnIndex) || !Number.isFinite(columnCount) || columnCount <= 0) {
+                return;
+            }
+            const next = new Map();
+            this.state.filters.forEach((cfg, key) => {
+                let newKey = key;
+                const cloned = { ...cfg };
+                if (typeof newKey === 'number' && newKey >= columnIndex) {
+                    newKey = newKey + columnCount;
+                }
+                if (typeof cloned.field === 'number' && cloned.field >= columnIndex) {
+                    cloned.field = cloned.field + columnCount;
+                }
+                if (cloned && cloned.type === 'byValue' && Array.isArray(cloned.values)) {
+                    cloned.values = cloned.values.slice();
+                }
+                if (cloned && Array.isArray(cloned.condition)) {
+                    cloned.condition = cloned.condition.slice();
+                }
+                next.set(newKey, cloned);
+            });
+            this.state = { ...this.state, filters: next };
+        }
+        shiftFieldsOnDeleteColumns(deleteColIndexs) {
+            if (!Array.isArray(deleteColIndexs) || deleteColIndexs.length === 0) {
+                return;
+            }
+            const sorted = deleteColIndexs
+                .slice()
+                .filter(n => Number.isFinite(n))
+                .sort((a, b) => a - b);
+            const deleteIndexNums = sorted.map((idx, i) => idx - i);
+            const next = new Map();
+            this.state.filters.forEach((cfg, key) => {
+                let newKey = key;
+                const cloned = { ...cfg };
+                let removed = false;
+                if (typeof newKey === 'number') {
+                    let k = newKey;
+                    for (let i = 0; i < deleteIndexNums.length; i++) {
+                        const d = deleteIndexNums[i];
+                        if (k === d) {
+                            removed = true;
+                            break;
+                        }
+                        if (k > d) {
+                            k -= 1;
+                        }
+                    }
+                    newKey = k;
+                }
+                if (typeof cloned.field === 'number') {
+                    let f = cloned.field;
+                    for (let i = 0; i < deleteIndexNums.length; i++) {
+                        const d = deleteIndexNums[i];
+                        if (f === d) {
+                            removed = true;
+                            break;
+                        }
+                        if (f > d) {
+                            f -= 1;
+                        }
+                    }
+                    cloned.field = f;
+                }
+                if (removed) {
+                    return;
+                }
+                if (cloned && cloned.type === 'byValue' && Array.isArray(cloned.values)) {
+                    cloned.values = cloned.values.slice();
+                }
+                if (cloned && Array.isArray(cloned.condition)) {
+                    cloned.condition = cloned.condition.slice();
+                }
+                next.set(newKey, cloned);
+            });
+            this.state = { ...this.state, filters: next };
+        }
         reapplyCurrentFilters() {
             const activeFields = this.getActiveFilterFields();
             if (activeFields.length > 0) {
@@ -10947,7 +11058,7 @@ ${recordsStr}
             this.toUnformattedCache.set(candidateField, toUnformatted);
         }
         toggleSelectAll(fieldId, selected) {
-            const options = this.valueFilterOptionList.get(fieldId);
+            const options = this.valueFilterOptionList.get(fieldId) || [];
             options.forEach(option => {
                 if (option.itemContainer.style.display !== 'none') {
                     option.checkbox.checked = selected;
@@ -10962,7 +11073,7 @@ ${recordsStr}
             this.selectAllCheckbox.indeterminate = !allChecked && !noneChecked;
         }
         onSearch(fieldId, value) {
-            const items = this.valueFilterOptionList.get(fieldId);
+            const items = this.valueFilterOptionList.get(fieldId) || [];
             const filterKeywords = value
                 .toUpperCase()
                 .split(' ')
@@ -10975,7 +11086,6 @@ ${recordsStr}
             }
         }
         syncSingleStateFromTableData(fieldId) {
-            const selectedValues = new Set();
             const originalValues = new Set();
             const originalRecords = this.table.internalProps.records;
             originalRecords.forEach(record => {
@@ -10983,56 +11093,23 @@ ${recordsStr}
                     originalValues.add(record[fieldId]);
                 }
             });
-            const syncFilterItemsState = this.pluginOptions?.syncFilterItemsState ?? true;
-            const hasFiltered = !arrayEqual(Array.from(originalValues), Array.from(selectedValues));
-            if (syncFilterItemsState) {
-                if (hasFiltered) {
-                    this.selectedKeys.set(fieldId, selectedValues);
-                    this.filterStateManager.dispatch({
-                        type: exports.FilterActionType.UPDATE_FILTER,
-                        payload: {
-                            field: fieldId,
-                            values: Array.from(selectedValues),
-                            enable: true
-                        }
-                    });
-                    const hasFiltered = !arrayEqual(Array.from(originalValues), Array.from(selectedValues));
-                    if (hasFiltered) {
-                        this.selectedKeys.set(fieldId, selectedValues);
-                        this.filterStateManager.dispatch({
-                            type: exports.FilterActionType.ADD_FILTER,
-                            payload: {
-                                field: fieldId,
-                                type: 'byValue',
-                                values: Array.from(selectedValues),
-                                enable: true
-                            }
-                        });
-                    }
-                }
+            const current = this.filterStateManager.getFilterState(fieldId);
+            if (current?.type === 'byValue' && Array.isArray(current.values)) {
+                this.selectedKeys.set(fieldId, new Set(current.values));
+                return;
             }
-            else {
-                const selectedRules = this.filterStateManager.getFilterState(fieldId)?.values;
-                if (selectedRules) {
-                    const hasFiltered = !arrayEqual(Array.from(originalValues), selectedRules);
-                    if (hasFiltered) {
-                        this.selectedKeys.set(fieldId, new Set(selectedRules));
-                        this.filterStateManager.dispatch({
-                            type: exports.FilterActionType.ADD_FILTER,
-                            payload: {
-                                field: fieldId,
-                                type: 'byValue',
-                                values: selectedRules,
-                                enable: true,
-                                shouldKeepUnrelatedState: true
-                            }
-                        });
+            if (current?.type === 'byCondition' && current.enable) {
+                const visibleValues = new Set();
+                const visibleRecords = this.getRecords(this.table, false);
+                visibleRecords.forEach(record => {
+                    if (isValid$2(record)) {
+                        visibleValues.add(record[fieldId]);
                     }
-                }
-                else {
-                    this.selectedKeys.set(fieldId, originalValues);
-                }
+                });
+                this.selectedKeys.set(fieldId, visibleValues);
+                return;
             }
+            this.selectedKeys.set(fieldId, originalValues);
         }
         applyFilter(fieldId = this.selectedField) {
             const options = this.valueFilterOptionList.get(fieldId);
@@ -11633,12 +11710,14 @@ ${recordsStr}
         clearFilterOptionLink;
         cancelFilterButton;
         applyFilterButton;
+        pluginId;
         constructor(table, filterStateManager, pluginOptions) {
             this.table = table;
             this.filterStateManager = filterStateManager;
             this.valueFilter = new ValueFilter(this.table, this.filterStateManager, pluginOptions);
             this.conditionFilter = new ConditionFilter(this.table, this.filterStateManager, pluginOptions, this.hide);
             this.pluginOptions = pluginOptions;
+            this.pluginId = pluginOptions?.id ?? 'filter';
             this.filterMenuWidth = 300;
             this.filterStateManager.subscribe(state => {
                 if (this.isVisible && this.selectedField !== null) {
@@ -11687,6 +11766,24 @@ ${recordsStr}
             }
             this.hide();
         }
+        recordHistory(before, after) {
+            const beforeKey = JSON.stringify(before);
+            const afterKey = JSON.stringify(after);
+            if (beforeKey === afterKey) {
+                return;
+            }
+            const pm = this.table.pluginManager;
+            const history = pm?.getPlugin?.('history-plugin') ??
+                pm?.getPluginByName?.('History') ??
+                pm?.getPlugin?.('history') ??
+                pm?.getPluginByName?.('history');
+            history?.recordExternalCommand?.({
+                type: 'filter',
+                pluginId: this.pluginId,
+                oldSnapshot: before,
+                newSnapshot: after
+            });
+        }
         updateClearFilterButtonState(field) {
             const currentFilter = this.filterStateManager.getFilterState(field);
             const hasActiveFilter = currentFilter && currentFilter.enable;
@@ -11761,10 +11858,16 @@ ${recordsStr}
             this.cancelFilterButton.addEventListener('click', () => this.hide());
             this.clearFilterOptionLink.addEventListener('click', e => {
                 e.preventDefault();
+                const before = this.filterStateManager.getSnapshot();
                 this.clearFilter(this.selectedField);
+                const after = this.filterStateManager.getSnapshot();
+                this.recordHistory(before, after);
             });
             this.applyFilterButton.addEventListener('click', () => {
+                const before = this.filterStateManager.getSnapshot();
                 this.applyFilter(this.selectedField);
+                const after = this.filterStateManager.getSnapshot();
+                this.recordHistory(before, after);
             });
             document.addEventListener('click', () => {
                 if (this.isVisible) {
@@ -11828,7 +11931,7 @@ ${recordsStr}
             if (currentFilter && currentFilter.type === 'byCondition') {
                 this.onTabSwitch('byCondition');
             }
-            else {
+            else if (this.filterModes.includes('byValue')) {
                 this.onTabSwitch('byValue');
             }
             this.updateClearFilterButtonState(field);
@@ -21331,7 +21434,9 @@ ${recordsStr}
             VTable.TABLE_EVENT_TYPE.CHANGE_CELL_VALUE,
             VTable.TABLE_EVENT_TYPE.UPDATE_RECORD,
             VTable.TABLE_EVENT_TYPE.ADD_RECORD,
-            VTable.TABLE_EVENT_TYPE.DELETE_RECORD
+            VTable.TABLE_EVENT_TYPE.DELETE_RECORD,
+            VTable.TABLE_EVENT_TYPE.ADD_COLUMN,
+            VTable.TABLE_EVENT_TYPE.DELETE_COLUMN
         ];
         pluginOptions;
         table;
@@ -21415,10 +21520,6 @@ ${recordsStr}
                 }
                 else {
                     this.filterToolbar.show(col, row, this.pluginOptions.filterModes);
-                    this.table.fireListeners(VTable.TABLE_EVENT_TYPE.FILTER_MENU_SHOW, {
-                        col: eventArgs.col,
-                        row: eventArgs.row
-                    });
                 }
             }
             else if (runtime === VTable.TABLE_EVENT_TYPE.SCROLL) {
@@ -21434,11 +21535,31 @@ ${recordsStr}
                 this.syncFilterWithTableData();
             }
             else if (runtime === VTable.TABLE_EVENT_TYPE.ADD_RECORD) {
+                const hasActiveFilter = this.filterStateManager?.getActiveFilterFields?.().length > 0;
+                if (hasActiveFilter && Array.isArray(eventArgs?.records)) {
+                    const ds = this.table.dataSource;
+                    eventArgs.records.forEach((r) => ds?.markForceVisibleRecord?.(r));
+                }
                 this.syncFilterWithTableData();
             }
             else if (runtime === VTable.TABLE_EVENT_TYPE.DELETE_RECORD) {
                 this.syncFilterWithTableData();
             }
+            else if (runtime === VTable.TABLE_EVENT_TYPE.ADD_COLUMN) {
+                const columnIndex = eventArgs?.columnIndex;
+                const columnCount = eventArgs?.columnCount;
+                if (typeof columnIndex === 'number' && typeof columnCount === 'number' && columnCount > 0) {
+                    this.filterStateManager?.shiftFieldsOnAddColumns?.(columnIndex, columnCount);
+                }
+                this.reapplyActiveFilters();
+            }
+            else if (runtime === VTable.TABLE_EVENT_TYPE.DELETE_COLUMN) {
+                const deleteColIndexs = eventArgs?.deleteColIndexs;
+                if (Array.isArray(deleteColIndexs) && deleteColIndexs.length > 0) {
+                    this.filterStateManager?.shiftFieldsOnDeleteColumns?.(deleteColIndexs);
+                }
+                this.reapplyActiveFilters();
+            }
         }
         updatePluginOptions(pluginOptions) {
             this.pluginOptions = lodashExports.merge(this.pluginOptions, pluginOptions);
@@ -21447,6 +21568,12 @@ ${recordsStr}
                 clearRowHeightCache: false
             });
         }
+        getFilterSnapshot() {
+            return this.filterStateManager?.getSnapshot?.() ?? { filters: [] };
+        }
+        applyFilterSnapshot(snapshot) {
+            this.filterStateManager?.applySnapshot?.(snapshot, exports.FilterActionType.APPLY_FILTERS);
+        }
         update() {
             if (this.filterStateManager) {
                 this.reapplyActiveFilters();
@@ -21964,7 +22091,7 @@ ${recordsStr}
     }
 
     function handlePaginationExport(table, exportAllData) {
-        const pagination = cloneDeep$1(table.pagination);
+        const pagination = cloneDeep$2(table.pagination);
         const isPivot = table.isPivotTable();
         const layoutMap = table.internalProps.layoutMap;
         let maxRow = table.rowCount - 1;
@@ -23602,10 +23729,10 @@ ${recordsStr}
      * console.log(deep[0] === objects[0]);
      * // => false
      */
-    function cloneDeep(value) {
+    function cloneDeep$1(value) {
       return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
     }
-    var cloneDeep_1 = cloneDeep;
+    var cloneDeep_1 = cloneDeep$1;
     var deepClone = /*@__PURE__*/getDefaultExportFromCjs(cloneDeep_1);
 
     const chnNumChar = { 零: 0, 一: 1, 二: 2, 三: 3, 四: 4, 五: 5, 六: 6, 七: 7, 八: 8, 九: 9 };
@@ -24199,8 +24326,9 @@ ${recordsStr}
                 format: 'yyyy年M月d日',
                 parser: (value) => {
                     const match = value.match(/(\d{4})年(\d{1,2})月(\d{1,2})/);
-                    if (!match)
+                    if (!match) {
                         throw new Error('无效的中文日期格式');
+                    }
                     return new Date(+match[1], +match[2] - 1, +match[3]);
                 }
             }
@@ -24229,19 +24357,22 @@ ${recordsStr}
             let date;
             let formatMeta;
             if (value instanceof Date) {
-                if (!isValid(value))
+                if (!isValid(value)) {
                     throw new Error('无效的日期对象');
+                }
                 date = value;
                 formatMeta = 'yyyy-MM-dd';
             }
             else {
                 const str = value.trim();
                 const matchedFormat = this.dateFormats.find(rule => rule.pattern.test(str));
-                if (!matchedFormat)
+                if (!matchedFormat) {
                     throw new Error(`不支持的日期格式: ${str}`);
+                }
                 date = matchedFormat.parser ? matchedFormat.parser(str) : parse(str, matchedFormat.format, new Date());
-                if (!isValid(date))
+                if (!isValid(date)) {
                     throw new Error(`无效的日期值: ${str}`);
+                }
                 formatMeta = matchedFormat.format;
             }
             return {
@@ -25203,6 +25334,1695 @@ ${recordsStr}
         }
     }
 
+    function makeCellKey(sheetKey, row, col) {
+        return `${sheetKey}:${row}:${col}`;
+    }
+    function parseA1Notation(a1) {
+        const match = a1.match(/^([A-Z]+)([0-9]+)$/i);
+        if (!match) {
+            return null;
+        }
+        const letters = match[1].toUpperCase();
+        const rowNumber = parseInt(match[2], 10);
+        if (!rowNumber || rowNumber < 1) {
+            return null;
+        }
+        let col = 0;
+        for (let i = 0; i < letters.length; i++) {
+            col = col * 26 + (letters.charCodeAt(i) - 64);
+        }
+        return { row: rowNumber - 1, col: col - 1 };
+    }
+    function captureCellPreChangeContent(args) {
+        const { sheetKey, row, col, currentValue, formulaManager, store } = args;
+        if (!sheetKey) {
+            return;
+        }
+        const cellKey = makeCellKey(sheetKey, row, col);
+        if (formulaManager?.getCellFormula) {
+            try {
+                const oldFormula = formulaManager.getCellFormula({ sheet: sheetKey, row, col });
+                if (oldFormula) {
+                    const normalized = typeof oldFormula === 'string' && !oldFormula.startsWith('=') ? `=${oldFormula}` : oldFormula;
+                    store.set(cellKey, normalized);
+                    return;
+                }
+            }
+            catch {
+            }
+        }
+        store.set(cellKey, currentValue == null ? '' : currentValue);
+    }
+    function popCellPreChangeContent(args) {
+        const { sheetKey, row, col, fallbackOldContent, store } = args;
+        if (!sheetKey) {
+            return fallbackOldContent;
+        }
+        const cellKey = makeCellKey(sheetKey, row, col);
+        const oldContent = store.get(cellKey);
+        store.delete(cellKey);
+        return typeof oldContent !== 'undefined' ? oldContent : fallbackOldContent;
+    }
+    function applyCellContent(args) {
+        const { table, sheetKey, row, col, content, formulaManager } = args;
+        if (sheetKey && formulaManager?.setCellContent && formulaManager?.getCellValue) {
+            try {
+                formulaManager.setCellContent({ sheet: sheetKey, row, col }, content);
+            }
+            catch {
+                table.changeCellValue(col, row, content, false, false, true);
+                return;
+            }
+            const isFormula = typeof content === 'string' && content.startsWith('=');
+            if (isFormula) {
+                const result = formulaManager.getCellValue({ sheet: sheetKey, row, col });
+                const display = result?.error ? '#ERROR!' : result?.value;
+                table.changeCellValue(col, row, display, false, false, true);
+                refreshDependentDisplays({ table, sheetKey, startCell: { sheet: sheetKey, row, col }, formulaManager });
+                return;
+            }
+            table.changeCellValue(col, row, content, false, false, true);
+            refreshDependentDisplays({ table, sheetKey, startCell: { sheet: sheetKey, row, col }, formulaManager });
+            return;
+        }
+        table.changeCellValue(col, row, content, false, false, true);
+    }
+    function refreshDependentDisplays(args) {
+        const { table, sheetKey, startCell, formulaManager } = args;
+        const maxCells = args.maxCells ?? 5000;
+        if (!formulaManager?.getCellDependents || !formulaManager?.getCellValue) {
+            return;
+        }
+        const visited = new Set();
+        const queue = [...(formulaManager.getCellDependents(startCell) || [])];
+        let processed = 0;
+        while (queue.length) {
+            const cell = queue.shift();
+            if (!cell || cell.sheet !== sheetKey) {
+                continue;
+            }
+            const key = makeCellKey(cell.sheet, cell.row, cell.col);
+            if (visited.has(key)) {
+                continue;
+            }
+            visited.add(key);
+            processed++;
+            if (processed > maxCells) {
+                break;
+            }
+            const result = formulaManager.getCellValue(cell);
+            const display = result?.error ? '#ERROR!' : result?.value;
+            table.changeCellValue(cell.col, cell.row, display, false, false, true);
+            const deps = formulaManager.getCellDependents(cell) || [];
+            deps.forEach((d) => queue.push(d));
+        }
+    }
+
+    function cloneMergeConfig(input) {
+        if (Array.isArray(input)) {
+            return input.map(i => ({
+                ...i,
+                range: i?.range
+                    ? {
+                        start: { ...i.range.start },
+                        end: { ...i.range.end }
+                    }
+                    : i?.range
+            }));
+        }
+        return input;
+    }
+    function getCustomMergeCellFunc(customMergeCell) {
+        if (typeof customMergeCell === 'function') {
+            return customMergeCell;
+        }
+        if (Array.isArray(customMergeCell)) {
+            return (col, row) => {
+                return customMergeCell.find(item => {
+                    return (item.range.start.col <= col &&
+                        item.range.end.col >= col &&
+                        item.range.start.row <= row &&
+                        item.range.end.row >= row);
+                });
+            };
+        }
+        return undefined;
+    }
+    function applyMergeConfig(table, customMergeCell) {
+        if (!table?.options || !table?.internalProps) {
+            return;
+        }
+        table.options.customMergeCell = cloneMergeConfig(customMergeCell);
+        table.internalProps.customMergeCell = getCustomMergeCellFunc(table.options.customMergeCell);
+    }
+    function cloneSortState(input) {
+        if (!input) {
+            return null;
+        }
+        if (Array.isArray(input)) {
+            return input.filter(Boolean).map((s) => ({
+                field: s.field,
+                order: s.order
+            }));
+        }
+        return {
+            field: input.field,
+            order: input.order
+        };
+    }
+    function replayCommand(args) {
+        const { table, vtableSheet, cmd, direction, deleteRecordsByReference } = args;
+        switch (cmd.type) {
+            case 'cell':
+            case 'cells': {
+                const sheetKey = cmd.sheetKey;
+                const cells = cmd.cells;
+                cells.forEach(c => {
+                    const content = direction === 'undo' ? c.oldContent : c.newContent;
+                    applyCellContent({
+                        table,
+                        sheetKey,
+                        row: c.row,
+                        col: c.col,
+                        content,
+                        formulaManager: vtableSheet?.formulaManager
+                    });
+                });
+                break;
+            }
+            case 'merge_cells': {
+                const c = cmd;
+                const next = direction === 'undo' ? c.oldCustomMergeCell : c.newCustomMergeCell;
+                applyMergeConfig(table, next);
+                const sg = table.scenegraph;
+                if (sg?.updateCellContent) {
+                    for (let i = c.startCol; i <= c.endCol; i++) {
+                        for (let j = c.startRow; j <= c.endRow; j++) {
+                            sg.updateCellContent(i, j);
+                        }
+                    }
+                    sg.updateNextFrame?.();
+                }
+                else if (typeof table.renderWithRecreateCells === 'function') {
+                    table.renderWithRecreateCells();
+                }
+                break;
+            }
+            case 'filter': {
+                const c = cmd;
+                const pluginId = c.pluginId;
+                const snapshot = direction === 'undo' ? c.oldSnapshot : c.newSnapshot;
+                const pm = table.pluginManager;
+                const filterPlugin = pm?.getPlugin?.(pluginId) ??
+                    pm?.getPluginByName?.('Filter') ??
+                    pm?.getPlugin?.('filter') ??
+                    pm?.getPluginByName?.('filter');
+                if (filterPlugin?.applyFilterSnapshot) {
+                    filterPlugin.applyFilterSnapshot(snapshot);
+                }
+                break;
+            }
+            case 'sort': {
+                const c = cmd;
+                const next = direction === 'undo' ? c.oldSortState : c.newSortState;
+                table.updateSortState?.(cloneSortState(next) ?? null, true);
+                break;
+            }
+            case 'add_record': {
+                const c = cmd;
+                if (direction === 'undo') {
+                    const ds = table?.internalProps?.dataSource;
+                    const rawRecords = ds?.dataSourceObj?.records;
+                    let deletedByRaw = false;
+                    if (Array.isArray(rawRecords) && typeof c.rawInsertIndex === 'number' && c.recordCount > 0) {
+                        const idx = c.rawInsertIndex;
+                        if (idx >= 0 && idx < rawRecords.length) {
+                            rawRecords.splice(idx, c.recordCount);
+                            deletedByRaw = true;
+                        }
+                    }
+                    if (Array.isArray(rawRecords) && Array.isArray(c.records) && c.records.length) {
+                        for (let i = 0; i < c.records.length; i++) {
+                            const rawIndex = rawRecords.indexOf(c.records[i]);
+                            if (rawIndex >= 0) {
+                                rawRecords.splice(rawIndex, 1);
+                                deletedByRaw = true;
+                            }
+                        }
+                    }
+                    if (!deletedByRaw && Array.isArray(rawRecords) && typeof c.recordCount === 'number' && c.recordCount > 0) {
+                        const before = c.anchorBefore;
+                        const after = c.anchorAfter;
+                        const beforeIndex = before ? rawRecords.indexOf(before) : -1;
+                        const afterIndex = after ? rawRecords.indexOf(after) : -1;
+                        if (beforeIndex >= 0) {
+                            rawRecords.splice(beforeIndex + 1, c.recordCount);
+                            deletedByRaw = true;
+                        }
+                        else if (afterIndex >= 0) {
+                            rawRecords.splice(Math.max(0, afterIndex - c.recordCount), c.recordCount);
+                            deletedByRaw = true;
+                        }
+                    }
+                    if (deletedByRaw) {
+                        ds?.beforeChangedRecordsMap?.clear?.();
+                        ds?.sortedIndexMap?.clear?.();
+                        if (typeof table.updateFilterRules === 'function') {
+                            table.updateFilterRules(ds?.dataConfig?.filterRules, {
+                                clearRowHeightCache: false
+                            });
+                        }
+                        else {
+                            ds?.updateFilterRules?.(ds?.dataConfig?.filterRules);
+                        }
+                    }
+                    if (!deletedByRaw) {
+                        if (typeof c.recordIndex === 'number' && c.recordCount > 0) {
+                            const indexs = [];
+                            for (let i = 0; i < c.recordCount; i++) {
+                                indexs.push(c.recordIndex + i);
+                            }
+                            table.deleteRecords?.(indexs);
+                        }
+                        else {
+                            deleteRecordsByReference(c.records);
+                        }
+                    }
+                }
+                else {
+                    if (c.records.length) {
+                        table.addRecords?.(c.records, c.recordIndex);
+                    }
+                }
+                break;
+            }
+            case 'delete_record': {
+                const c = cmd;
+                if (direction === 'undo') {
+                    if (table.addRecord && Array.isArray(c.records) && Array.isArray(c.recordIndexs)) {
+                        const pairs = [];
+                        for (let i = 0; i < c.recordIndexs.length; i++) {
+                            const idx = c.recordIndexs[i];
+                            if (typeof idx === 'number') {
+                                pairs.push({ idx, record: c.records[i] });
+                            }
+                        }
+                        pairs.sort((a, b) => a.idx - b.idx);
+                        for (const p of pairs) {
+                            table.addRecord(p.record, p.idx);
+                        }
+                    }
+                    if (c.deletedRowHeights && typeof table.setRowHeight === 'function') {
+                        const headerCount = table.transpose
+                            ? table.rowHeaderLevelCount
+                            : table.columnHeaderLevelCount;
+                        Object.keys(c.deletedRowHeights).forEach(k => {
+                            const idx = Number(k);
+                            const height = c.deletedRowHeights[k];
+                            if (!Number.isFinite(idx) || typeof height !== 'number') {
+                                return;
+                            }
+                            table.setRowHeight(idx + (headerCount ?? 0), height);
+                        });
+                    }
+                }
+                else {
+                    if (table.deleteRecords) {
+                        table.deleteRecords(c.recordIndexs);
+                    }
+                }
+                const hasMergeSnapshot = 'oldCustomMergeCell' in c || 'newCustomMergeCell' in c;
+                if (hasMergeSnapshot) {
+                    const target = direction === 'undo' ? c.oldCustomMergeCell : c.newCustomMergeCell;
+                    applyMergeConfig(table, target);
+                    const sg = table.scenegraph;
+                    if (sg?.updateCellContent) {
+                        const prevRanges = Array.isArray(c.oldCustomMergeCell)
+                            ? c.oldCustomMergeCell.map(i => i?.range).filter(Boolean)
+                            : [];
+                        const nextRanges = Array.isArray(c.newCustomMergeCell)
+                            ? c.newCustomMergeCell.map(i => i?.range).filter(Boolean)
+                            : [];
+                        const refreshRanges = [...prevRanges, ...nextRanges];
+                        refreshRanges.forEach(r => {
+                            if (!r?.start) {
+                                return;
+                            }
+                            for (let col = r.start.col; col <= r.end.col; col++) {
+                                for (let row = r.start.row; row <= r.end.row; row++) {
+                                    sg.updateCellContent(col, row);
+                                }
+                            }
+                        });
+                        sg.updateNextFrame?.();
+                    }
+                    else if (typeof table.renderWithRecreateCells === 'function') {
+                        table.renderWithRecreateCells();
+                    }
+                }
+                break;
+            }
+            case 'update_record': {
+                const c = cmd;
+                if (table.updateRecords) {
+                    if (direction === 'undo') {
+                        table.updateRecords(c.oldRecords, c.recordIndexs);
+                    }
+                    else {
+                        table.updateRecords(c.newRecords, c.recordIndexs);
+                    }
+                }
+                break;
+            }
+            case 'add_column': {
+                const c = cmd;
+                if (direction === 'undo') {
+                    const deleteIndexs = [];
+                    for (let i = 0; i < c.columnCount; i++) {
+                        deleteIndexs.push(c.columnIndex + i);
+                    }
+                    table.deleteColumns?.(deleteIndexs, true);
+                }
+                else {
+                    table.addColumns?.(c.columns, c.columnIndex, true);
+                }
+                break;
+            }
+            case 'delete_column': {
+                const c = cmd;
+                if (direction === 'undo') {
+                    const items = c.deleteColIndexs.map((idx, i) => ({ idx, column: c.columns[i] })).sort((a, b) => a.idx - b.idx);
+                    items.forEach(item => {
+                        table.addColumns?.([item.column], item.idx, true);
+                    });
+                    if (c.deletedColWidths && typeof table.setColWidth === 'function') {
+                        Object.entries(c.deletedColWidths).forEach(([k, width]) => {
+                            const idx = Number(k);
+                            if (!Number.isFinite(idx) || typeof width !== 'number') {
+                                return;
+                            }
+                            table.setColWidth(idx, width);
+                        });
+                    }
+                    if (Array.isArray(c.deletedRecordValues) && c.deletedRecordValues.length) {
+                        const records = table.records;
+                        if (Array.isArray(records) && records.length) {
+                            const recordIndexs = [];
+                            const newRecords = [];
+                            for (let i = 0; i < records.length; i++) {
+                                const rec = records[i];
+                                const rowValues = c.deletedRecordValues[i];
+                                if (!Array.isArray(rec) || !Array.isArray(rowValues) || rowValues.length !== c.deleteColIndexs.length) {
+                                    continue;
+                                }
+                                const next = rec.slice();
+                                for (let k = 0; k < c.deleteColIndexs.length; k++) {
+                                    next[c.deleteColIndexs[k]] = rowValues[k];
+                                }
+                                recordIndexs.push(i);
+                                newRecords.push(next);
+                            }
+                            if (recordIndexs.length) {
+                                table.updateRecords?.(newRecords, recordIndexs, false);
+                            }
+                        }
+                    }
+                    if (c.sheetKey) {
+                        const fm = vtableSheet?.formulaManager;
+                        const engine = fm?.formulaEngine;
+                        if (fm?.normalizeSheetData && engine?.updateSheetData) {
+                            try {
+                                const normalized = fm.normalizeSheetData(table.records || [], table);
+                                engine.updateSheetData(c.sheetKey, normalized);
+                            }
+                            catch {
+                            }
+                        }
+                    }
+                    if (c.sheetKey && c.deletedFormulas) {
+                        const entries = Object.entries(c.deletedFormulas);
+                        entries.forEach(([cellRef, formula]) => {
+                            const parsed = parseA1Notation(cellRef);
+                            if (!parsed) {
+                                return;
+                            }
+                            applyCellContent({
+                                table,
+                                sheetKey: c.sheetKey,
+                                row: parsed.row,
+                                col: parsed.col,
+                                content: formula,
+                                formulaManager: vtableSheet?.formulaManager
+                            });
+                        });
+                    }
+                }
+                else {
+                    table.deleteColumns?.(c.deleteColIndexs, true);
+                }
+                break;
+            }
+            case 'change_header_position': {
+                const c = cmd;
+                const moving = c.moving;
+                const from = direction === 'undo' ? c.targetIndex : c.sourceIndex;
+                const to = direction === 'undo' ? c.sourceIndex : c.targetIndex;
+                if (moving === 'column') {
+                    table.changeHeaderPosition?.({
+                        source: { col: from, row: 0 },
+                        target: { col: to, row: 0 },
+                        movingColumnOrRow: 'column'
+                    });
+                }
+                else {
+                    table.changeHeaderPosition?.({
+                        source: { col: 0, row: from },
+                        target: { col: 0, row: to },
+                        movingColumnOrRow: 'row'
+                    });
+                }
+                break;
+            }
+            case 'resize_row': {
+                const c = cmd;
+                const height = direction === 'undo' ? c.oldHeight : c.newHeight;
+                table.setRowHeight?.(c.row, height);
+                break;
+            }
+            case 'resize_column': {
+                const c = cmd;
+                const width = direction === 'undo' ? c.oldWidth : c.newWidth;
+                table.setColWidth?.(c.col, width);
+                break;
+            }
+        }
+    }
+
+    function cloneDeep(input, cache = new WeakMap()) {
+        if (input === null || input === undefined) {
+            return input;
+        }
+        const t = typeof input;
+        if (t === 'function' || t !== 'object') {
+            return input;
+        }
+        const obj = input;
+        if (obj instanceof Date) {
+            return new Date(obj.getTime());
+        }
+        if (obj instanceof RegExp) {
+            return new RegExp(obj);
+        }
+        if (cache.has(obj)) {
+            return cache.get(obj);
+        }
+        if (Array.isArray(obj)) {
+            const arr = [];
+            cache.set(obj, arr);
+            for (let i = 0; i < obj.length; i++) {
+                arr[i] = cloneDeep(obj[i], cache);
+            }
+            return arr;
+        }
+        const out = {};
+        cache.set(obj, out);
+        Object.keys(obj).forEach(key => {
+            out[key] = cloneDeep(obj[key], cache);
+        });
+        return out;
+    }
+    function captureSnapshot(table, state, options) {
+        const tableOptions = table.options || {};
+        const columns = tableOptions.columns;
+        if (Array.isArray(columns)) {
+            state.prevColumnsSnapshot = columns.map(c => cloneDeep(c));
+        }
+        else {
+            state.prevColumnsSnapshot = null;
+        }
+        const merge = tableOptions.customMergeCell;
+        if (Array.isArray(merge)) {
+            state.prevMergeSnapshot = merge.map(m => ({
+                ...m,
+                range: {
+                    start: { ...m.range.start },
+                    end: { ...m.range.end }
+                }
+            }));
+        }
+        else {
+            state.prevMergeSnapshot = merge;
+        }
+        const records = (table.records || []);
+        if (Array.isArray(records)) {
+            state.prevRecordsSnapshot = records.map(r => cloneRecord(r));
+        }
+        else {
+            state.prevRecordsSnapshot = null;
+        }
+        try {
+            const resizedRowIndexs = Array.from(table.internalProps?._heightResizedRowMap?.keys?.() ?? []);
+            if (resizedRowIndexs.length && typeof table.getRowHeight === 'function') {
+                const map = {};
+                resizedRowIndexs.forEach((rowIndex) => {
+                    if (typeof rowIndex !== 'number') {
+                        return;
+                    }
+                    const h = table.getRowHeight(rowIndex);
+                    if (typeof h === 'number') {
+                        map[rowIndex] = h;
+                    }
+                });
+                state.prevResizedRowHeightsSnapshot = map;
+            }
+            else {
+                state.prevResizedRowHeightsSnapshot = null;
+            }
+        }
+        catch {
+            state.prevResizedRowHeightsSnapshot = null;
+        }
+        try {
+            const resizedColIndexs = Array.from(table.internalProps?._widthResizedColMap?.keys?.() ?? []);
+            if (resizedColIndexs.length && typeof table.getColWidth === 'function') {
+                const map = {};
+                resizedColIndexs.forEach((colIndex) => {
+                    if (typeof colIndex !== 'number') {
+                        return;
+                    }
+                    const w = table.getColWidth(colIndex);
+                    if (typeof w === 'number') {
+                        map[colIndex] = w;
+                    }
+                });
+                state.prevResizedColWidthsSnapshot = map;
+            }
+            else {
+                state.prevResizedColWidthsSnapshot = null;
+            }
+        }
+        catch {
+            state.prevResizedColWidthsSnapshot = null;
+        }
+        if (options?.formulaManager?.exportFormulas && options.sheetKey) {
+            try {
+                const formulas = options.formulaManager.exportFormulas(options.sheetKey);
+                state.prevFormulasSnapshot = formulas ? { ...formulas } : null;
+            }
+            catch {
+                state.prevFormulasSnapshot = null;
+            }
+        }
+        else {
+            state.prevFormulasSnapshot = null;
+        }
+    }
+    function cloneRecord(record) {
+        if (Array.isArray(record)) {
+            return record.slice();
+        }
+        if (record && typeof record === 'object') {
+            return { ...record };
+        }
+        return record;
+    }
+
+    function resolveSheetKey(args) {
+        const { vtableSheet, table, cached } = args;
+        if (!vtableSheet) {
+            return { sheetKey: undefined, cached: undefined };
+        }
+        if (cached) {
+            return { sheetKey: cached, cached };
+        }
+        try {
+            const workSheetInstances = vtableSheet.workSheetInstances;
+            if (workSheetInstances && table) {
+                for (const [sheetKey, worksheet] of workSheetInstances.entries()) {
+                    if (worksheet?.tableInstance === table) {
+                        return { sheetKey, cached: sheetKey };
+                    }
+                }
+            }
+            const active = vtableSheet.getActiveSheet?.();
+            if (active?.getKey) {
+                const key = active.getKey();
+                return { sheetKey: key, cached: key };
+            }
+            const activeDefine = vtableSheet.sheetManager?.getActiveSheet?.();
+            const key = activeDefine?.sheetKey;
+            return { sheetKey: key, cached: key };
+        }
+        catch {
+            return { sheetKey: undefined, cached: undefined };
+        }
+    }
+
+    class HistoryPlugin {
+        id = 'history-plugin';
+        name = 'History';
+        runTime = [
+            VTable.TABLE_EVENT_TYPE.BEFORE_INIT,
+            VTable.TABLE_EVENT_TYPE.INITIALIZED,
+            VTable.TABLE_EVENT_TYPE.BEFORE_KEYDOWN,
+            VTable.TABLE_EVENT_TYPE.CHANGE_CELL_VALUE,
+            VTable.TABLE_EVENT_TYPE.CHANGE_CELL_VALUES,
+            VTable.TABLE_EVENT_TYPE.PASTED_DATA,
+            VTable.TABLE_EVENT_TYPE.MERGE_CELLS,
+            VTable.TABLE_EVENT_TYPE.UNMERGE_CELLS,
+            VTable.TABLE_EVENT_TYPE.ADD_RECORD,
+            VTable.TABLE_EVENT_TYPE.DELETE_RECORD,
+            VTable.TABLE_EVENT_TYPE.UPDATE_RECORD,
+            VTable.TABLE_EVENT_TYPE.ADD_COLUMN,
+            VTable.TABLE_EVENT_TYPE.DELETE_COLUMN,
+            VTable.TABLE_EVENT_TYPE.CHANGE_HEADER_POSITION,
+            VTable.TABLE_EVENT_TYPE.SORT_CLICK,
+            VTable.TABLE_EVENT_TYPE.RESIZE_ROW,
+            VTable.TABLE_EVENT_TYPE.RESIZE_ROW_END,
+            VTable.TABLE_EVENT_TYPE.RESIZE_COLUMN,
+            VTable.TABLE_EVENT_TYPE.RESIZE_COLUMN_END
+        ];
+        table = null;
+        vtableSheet;
+        resolvedSheetKey;
+        undoStack = [];
+        redoStack = [];
+        currentTransaction = null;
+        isReplaying = false;
+        maxHistory;
+        enableCompression;
+        onTransactionPushed;
+        prevColumnsSnapshot = null;
+        prevMergeSnapshot;
+        prevRecordsSnapshot = null;
+        prevFormulasSnapshot = null;
+        prevResizedRowHeightsSnapshot = null;
+        prevResizedColWidthsSnapshot = null;
+        lastKnownSortState = null;
+        sortStartSnapshot = null;
+        sortPending = false;
+        sortEventBound = false;
+        sortChangeOrderListenerId;
+        cellPreChangeContent = new Map();
+        formulaCache = new Map();
+        formulaEventBound = false;
+        formulaEventManager;
+        onFormulaAddedHandler;
+        resizeRowStartHeight = new Map();
+        resizeColStartWidth = new Map();
+        filterEventBound = false;
+        filterUnsubscribe = null;
+        filterSnapshotCache;
+        filterPluginId;
+        filterPluginRef;
+        filterApplySnapshotOriginal;
+        filterApplyingSnapshot = false;
+        constructor(options) {
+            this.id = options?.id ?? this.id;
+            this.maxHistory = options?.maxHistory ?? 100;
+            this.enableCompression = options?.enableCompression ?? false;
+            this.onTransactionPushed = options?.onTransactionPushed;
+        }
+        run(...args) {
+            const eventArgs = args[0];
+            const runtime = args[1];
+            const table = args[2];
+            if (!table) {
+                return;
+            }
+            if (!this.table) {
+                this.table = table;
+                this.vtableSheet = table.__vtableSheet;
+                if (runtime !== VTable.TABLE_EVENT_TYPE.BEFORE_INIT && table.internalProps?.dataSource) {
+                    const state = this.getSnapshotState();
+                    const sheetKey = this.getSheetKey();
+                    captureSnapshot(table, state, {
+                        formulaManager: this.vtableSheet?.formulaManager,
+                        sheetKey
+                    });
+                    this.setSnapshotState(state);
+                    this.lastKnownSortState = this.normalizeSortState(table.internalProps?.sortState);
+                }
+            }
+            else if (!this.vtableSheet) {
+                this.vtableSheet = table.__vtableSheet;
+            }
+            this.ensureFilterEventBindings();
+            if (runtime === VTable.TABLE_EVENT_TYPE.BEFORE_INIT) {
+                return;
+            }
+            this.ensureFormulaEventBindings();
+            this.ensureSortEventBindings();
+            const workbookReplaying = this.table?.__vtableSheet?.__workbookHistoryReplaying;
+            if (this.isReplaying || workbookReplaying) {
+                return;
+            }
+            switch (runtime) {
+                case VTable.TABLE_EVENT_TYPE.INITIALIZED:
+                    break;
+                case VTable.TABLE_EVENT_TYPE.BEFORE_KEYDOWN:
+                    this.handleBeforeKeydown(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.CHANGE_CELL_VALUE:
+                    this.handleChangeCellValue(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.CHANGE_CELL_VALUES:
+                    this.handleChangeCellValues(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.PASTED_DATA:
+                    break;
+                case VTable.TABLE_EVENT_TYPE.MERGE_CELLS:
+                    this.handleMergeCells(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.UNMERGE_CELLS:
+                    this.handleUnmergeCells(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.ADD_RECORD:
+                    this.handleAddRecord(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.DELETE_RECORD:
+                    this.handleDeleteRecord(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.UPDATE_RECORD:
+                    this.handleUpdateRecord(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.ADD_COLUMN:
+                    this.handleAddColumn(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.DELETE_COLUMN:
+                    this.handleDeleteColumn(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.CHANGE_HEADER_POSITION:
+                    this.handleChangeHeaderPosition(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.SORT_CLICK:
+                    this.handleSortClick(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.RESIZE_ROW:
+                    this.handleResizeRow(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.RESIZE_ROW_END:
+                    this.handleResizeRowEnd(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.RESIZE_COLUMN:
+                    this.handleResizeColumn(eventArgs);
+                    break;
+                case VTable.TABLE_EVENT_TYPE.RESIZE_COLUMN_END:
+                    this.handleResizeColumnEnd(eventArgs);
+                    break;
+            }
+            if (this.table) {
+                const state = this.getSnapshotState();
+                const sheetKey = this.getSheetKey();
+                captureSnapshot(this.table, state, {
+                    formulaManager: this.vtableSheet?.formulaManager,
+                    sheetKey
+                });
+                this.setSnapshotState(state);
+            }
+        }
+        startTransaction() {
+            if (this.currentTransaction) {
+                return;
+            }
+            this.currentTransaction = { commands: [] };
+        }
+        endTransaction() {
+            if (!this.currentTransaction || this.currentTransaction.commands.length === 0) {
+                this.currentTransaction = null;
+                return;
+            }
+            this.pushTransaction(this.currentTransaction);
+            this.currentTransaction = null;
+        }
+        undo() {
+            if (!this.table || this.undoStack.length === 0) {
+                return;
+            }
+            const transaction = this.undoStack.pop();
+            this.isReplaying = true;
+            try {
+                for (let i = transaction.commands.length - 1; i >= 0; i--) {
+                    this.applyCommand(transaction.commands[i], 'undo');
+                }
+            }
+            finally {
+                this.isReplaying = false;
+            }
+            this.redoStack.push(transaction);
+            if (this.table) {
+                const state = this.getSnapshotState();
+                const sheetKey = this.getSheetKey();
+                captureSnapshot(this.table, state, {
+                    formulaManager: this.vtableSheet?.formulaManager,
+                    sheetKey
+                });
+                this.setSnapshotState(state);
+            }
+        }
+        redo() {
+            if (!this.table || this.redoStack.length === 0) {
+                return;
+            }
+            const transaction = this.redoStack.pop();
+            this.isReplaying = true;
+            try {
+                for (const cmd of transaction.commands) {
+                    this.applyCommand(cmd, 'redo');
+                }
+            }
+            finally {
+                this.isReplaying = false;
+            }
+            this.undoStack.push(transaction);
+            if (this.table) {
+                const state = this.getSnapshotState();
+                const sheetKey = this.getSheetKey();
+                captureSnapshot(this.table, state, {
+                    formulaManager: this.vtableSheet?.formulaManager,
+                    sheetKey
+                });
+                this.setSnapshotState(state);
+            }
+        }
+        clear() {
+            this.undoStack = [];
+            this.redoStack = [];
+            this.currentTransaction = null;
+        }
+        updateOptions(options) {
+            if (options.maxHistory != null) {
+                this.maxHistory = options.maxHistory;
+                this.trimHistory();
+            }
+            if (options.enableCompression != null) {
+                this.enableCompression = options.enableCompression;
+            }
+            if (options.onTransactionPushed) {
+                this.onTransactionPushed = options.onTransactionPushed;
+            }
+        }
+        release() {
+            this.clear();
+            this.unbindFormulaEvents();
+            this.unbindSortEvents();
+            this.unbindFilterEvents();
+            this.table = null;
+            this.vtableSheet = null;
+            this.resolvedSheetKey = undefined;
+            this.prevColumnsSnapshot = null;
+            this.prevMergeSnapshot = undefined;
+            this.prevRecordsSnapshot = null;
+            this.prevFormulasSnapshot = null;
+            this.prevResizedRowHeightsSnapshot = null;
+            this.prevResizedColWidthsSnapshot = null;
+            this.lastKnownSortState = null;
+            this.sortStartSnapshot = null;
+            this.sortPending = false;
+            this.sortEventBound = false;
+            this.sortChangeOrderListenerId = undefined;
+            this.cellPreChangeContent.clear();
+            this.formulaCache.clear();
+            this.resizeRowStartHeight.clear();
+            this.resizeColStartWidth.clear();
+            this.filterEventBound = false;
+            this.filterUnsubscribe = null;
+            this.filterSnapshotCache = undefined;
+            this.filterPluginId = undefined;
+        }
+        ensureFilterEventBindings() {
+            if (!this.table) {
+                return;
+            }
+            const pm = this.table.pluginManager;
+            const filterPlugin = pm?.getPlugin?.('filter') ??
+                pm?.getPluginByName?.('Filter') ??
+                pm?.getPlugin?.('filter-plugin') ??
+                pm?.getPluginByName?.('filter-plugin');
+            if (!filterPlugin?.getFilterSnapshot || !filterPlugin?.applyFilterSnapshot) {
+                return;
+            }
+            if (!this.filterEventBound) {
+                this.filterEventBound = true;
+                this.filterPluginRef = filterPlugin;
+                this.filterPluginId = filterPlugin.id ?? 'filter';
+                this.filterSnapshotCache = cloneDeep(filterPlugin.getFilterSnapshot());
+            }
+            if (!this.filterApplySnapshotOriginal) {
+                this.filterApplySnapshotOriginal = filterPlugin.applyFilterSnapshot?.bind(filterPlugin);
+                if (this.filterApplySnapshotOriginal) {
+                    filterPlugin.applyFilterSnapshot = (snapshot) => {
+                        if (this.isReplaying) {
+                            return this.filterApplySnapshotOriginal(snapshot);
+                        }
+                        const oldSnapshot = this.filterSnapshotCache ?? filterPlugin.getFilterSnapshot();
+                        this.filterApplyingSnapshot = true;
+                        try {
+                            return this.filterApplySnapshotOriginal(snapshot);
+                        }
+                        finally {
+                            this.filterApplyingSnapshot = false;
+                            const newSnapshot = filterPlugin.getFilterSnapshot();
+                            if (JSON.stringify(oldSnapshot) !== JSON.stringify(newSnapshot)) {
+                                const cmd = {
+                                    type: 'filter',
+                                    sheetKey: this.getSheetKey(),
+                                    pluginId: this.filterPluginId ?? 'filter',
+                                    oldSnapshot,
+                                    newSnapshot
+                                };
+                                this.pushCommand(cmd);
+                                this.filterSnapshotCache = cloneDeep(newSnapshot);
+                            }
+                            else {
+                                this.filterSnapshotCache = cloneDeep(newSnapshot);
+                            }
+                        }
+                    };
+                }
+            }
+            const stateManager = filterPlugin?.filterStateManager;
+            if (!this.filterUnsubscribe && stateManager?.subscribe) {
+                this.filterUnsubscribe = stateManager.subscribe((_state, action) => {
+                    if (this.isReplaying) {
+                        return;
+                    }
+                    if (this.filterApplyingSnapshot) {
+                        this.filterSnapshotCache = cloneDeep(filterPlugin.getFilterSnapshot());
+                        return;
+                    }
+                    const t = action?.type;
+                    if (t !== exports.FilterActionType.APPLY_FILTERS &&
+                        t !== exports.FilterActionType.CLEAR_ALL_FILTERS &&
+                        t !== exports.FilterActionType.REMOVE_FILTER &&
+                        t !== exports.FilterActionType.DISABLE_FILTER) {
+                        return;
+                    }
+                    const oldSnapshot = this.filterSnapshotCache ?? filterPlugin.getFilterSnapshot();
+                    const newSnapshot = filterPlugin.getFilterSnapshot();
+                    if (JSON.stringify(oldSnapshot) === JSON.stringify(newSnapshot)) {
+                        return;
+                    }
+                    const cmd = {
+                        type: 'filter',
+                        sheetKey: this.getSheetKey(),
+                        pluginId: this.filterPluginId ?? 'filter',
+                        oldSnapshot,
+                        newSnapshot
+                    };
+                    this.pushCommand(cmd);
+                    this.filterSnapshotCache = cloneDeep(newSnapshot);
+                });
+            }
+        }
+        unbindFilterEvents() {
+            this.filterUnsubscribe?.();
+            this.filterUnsubscribe = null;
+            this.filterEventBound = false;
+            if (this.filterPluginRef && this.filterApplySnapshotOriginal) {
+                this.filterPluginRef.applyFilterSnapshot = this.filterApplySnapshotOriginal;
+            }
+            this.filterPluginRef = null;
+            this.filterApplySnapshotOriginal = null;
+            this.filterApplyingSnapshot = false;
+        }
+        getSheetKey() {
+            const resolved = resolveSheetKey({
+                vtableSheet: this.vtableSheet,
+                table: this.table,
+                cached: this.resolvedSheetKey
+            });
+            this.resolvedSheetKey = resolved.cached;
+            return resolved.sheetKey;
+        }
+        getSnapshotState() {
+            return {
+                prevColumnsSnapshot: this.prevColumnsSnapshot,
+                prevMergeSnapshot: this.prevMergeSnapshot,
+                prevRecordsSnapshot: this.prevRecordsSnapshot,
+                prevFormulasSnapshot: this.prevFormulasSnapshot,
+                prevResizedRowHeightsSnapshot: this.prevResizedRowHeightsSnapshot,
+                prevResizedColWidthsSnapshot: this.prevResizedColWidthsSnapshot
+            };
+        }
+        setSnapshotState(next) {
+            this.prevColumnsSnapshot = next.prevColumnsSnapshot;
+            this.prevMergeSnapshot = next.prevMergeSnapshot;
+            this.prevRecordsSnapshot = next.prevRecordsSnapshot;
+            this.prevFormulasSnapshot = next.prevFormulasSnapshot ?? null;
+            this.prevResizedRowHeightsSnapshot = next.prevResizedRowHeightsSnapshot ?? null;
+            this.prevResizedColWidthsSnapshot = next.prevResizedColWidthsSnapshot ?? null;
+        }
+        pushTransaction(tx) {
+            if (tx.commands.length === 0) {
+                return;
+            }
+            this.undoStack.push(tx);
+            this.redoStack = [];
+            this.trimHistory();
+            if (this.onTransactionPushed && !this.isReplaying) {
+                const workbookReplaying = this.table?.__vtableSheet?.__workbookHistoryReplaying;
+                if (!workbookReplaying) {
+                    this.onTransactionPushed({ tx, sheetKey: this.getSheetKey(), table: this.table ?? undefined });
+                }
+            }
+        }
+        trimHistory() {
+            if (this.undoStack.length > this.maxHistory) {
+                this.undoStack.splice(0, this.undoStack.length - this.maxHistory);
+            }
+        }
+        pushCommand(cmd) {
+            if (this.currentTransaction) {
+                this.currentTransaction.commands.push(cmd);
+                return;
+            }
+            this.pushTransaction({ commands: [cmd] });
+        }
+        recordExternalCommand(cmd) {
+            if (this.isReplaying) {
+                return;
+            }
+            this.pushCommand(cmd);
+        }
+        tryCompressCellChange(change, sheetKey) {
+            if (!this.enableCompression) {
+                return false;
+            }
+            const targetTx = this.currentTransaction || this.undoStack[this.undoStack.length - 1];
+            if (!targetTx || targetTx.commands.length === 0) {
+                return false;
+            }
+            const last = targetTx.commands[targetTx.commands.length - 1];
+            if ((last.type === 'cell' || last.type === 'cells') && last.sheetKey === sheetKey) {
+                const cells = last.cells;
+                if (cells.length === 1 && cells[0].row === change.row && cells[0].col === change.col) {
+                    cells[0].newContent = change.newContent;
+                    return true;
+                }
+            }
+            return false;
+        }
+        handleBeforeKeydown(eventArgs) {
+            const e = eventArgs.event;
+            if (!e || !this.table) {
+                return;
+            }
+            const isCtrlOrMeta = e.ctrlKey || e.metaKey;
+            if (!isCtrlOrMeta) {
+                return;
+            }
+            const formulaManager = this.vtableSheet?.formulaManager;
+            if (formulaManager?.formulaWorkingOnCell) {
+                return;
+            }
+            if (this.table.editorManager?.editingEditor) {
+                return;
+            }
+            const key = e.key.toLowerCase();
+            if (key === 'z') {
+                const workbookHistory = this.vtableSheet?.getWorkbookHistoryManager?.();
+                if (e.shiftKey) {
+                    workbookHistory ? workbookHistory.redo() : this.redo();
+                }
+                else {
+                    workbookHistory ? workbookHistory.undo() : this.undo();
+                }
+                e.preventDefault();
+                e.stopPropagation();
+            }
+            else if (key === 'y') {
+                const workbookHistory = this.vtableSheet?.getWorkbookHistoryManager?.();
+                workbookHistory ? workbookHistory.redo() : this.redo();
+                e.preventDefault();
+                e.stopPropagation();
+            }
+        }
+        handleChangeCellValue(eventArgs) {
+            captureCellPreChangeContent({
+                sheetKey: this.getSheetKey(),
+                row: eventArgs.row,
+                col: eventArgs.col,
+                currentValue: eventArgs.currentValue,
+                formulaManager: this.vtableSheet?.formulaManager,
+                store: this.cellPreChangeContent
+            });
+        }
+        handleChangeCellValues(eventArgs) {
+            if (!this.table) {
+                return;
+            }
+            const sheetKey = this.getSheetKey();
+            const formulaManager = this.vtableSheet?.formulaManager;
+            const cells = eventArgs.values
+                .map(v => {
+                const oldContent = popCellPreChangeContent({
+                    sheetKey,
+                    row: v.row,
+                    col: v.col,
+                    fallbackOldContent: v.currentValue,
+                    store: this.cellPreChangeContent
+                });
+                const normalizedOld = oldContent == null ? '' : oldContent;
+                const normalizedNew = v.changedValue == null ? '' : v.changedValue;
+                return { row: v.row, col: v.col, oldContent: normalizedOld, newContent: normalizedNew };
+            })
+                .filter(c => {
+                if (c.oldContent === c.newContent) {
+                    return false;
+                }
+                if (!sheetKey || !formulaManager?.getCellFormula || !formulaManager?.getCellValue) {
+                    return true;
+                }
+                if (typeof c.newContent === 'string' && c.newContent.startsWith('=')) {
+                    return false;
+                }
+                const formula = formulaManager.getCellFormula({ sheet: sheetKey, row: c.row, col: c.col });
+                if (!formula) {
+                    return true;
+                }
+                const result = formulaManager.getCellValue({ sheet: sheetKey, row: c.row, col: c.col });
+                const display = result?.error ? '#ERROR!' : result?.value;
+                if (display === c.newContent) {
+                    return false;
+                }
+                if (display != null && c.newContent != null && String(display) === String(c.newContent)) {
+                    return false;
+                }
+                return true;
+            });
+            if (!cells.length) {
+                return;
+            }
+            if (sheetKey && cells.length === 1 && this.tryCompressCellChange(cells[0], sheetKey)) {
+                return;
+            }
+            const cmd = { type: 'cells', sheetKey, cells };
+            this.pushCommand(cmd);
+        }
+        ensureFormulaEventBindings() {
+            if (!this.table || !this.vtableSheet || this.formulaEventBound) {
+                return;
+            }
+            const sheetKey = this.getSheetKey();
+            if (!sheetKey) {
+                return;
+            }
+            const worksheet = this.vtableSheet.getWorkSheetByKey?.(sheetKey) ?? this.vtableSheet.workSheetInstances?.get?.(sheetKey);
+            const eventManager = worksheet?.eventManager;
+            if (!eventManager?.on || !eventManager?.off) {
+                return;
+            }
+            this.formulaEventBound = true;
+            this.formulaEventManager = eventManager;
+            this.onFormulaAddedHandler = (event) => {
+                if (this.isReplaying) {
+                    return;
+                }
+                const cell = event?.cell;
+                const formula = event?.formula;
+                if (!cell || typeof cell.row !== 'number' || typeof cell.col !== 'number') {
+                    return;
+                }
+                if (typeof formula !== 'string' || !formula.length) {
+                    return;
+                }
+                const normalized = formula.startsWith('=') ? formula : `=${formula}`;
+                const key = `${sheetKey}:${cell.row}:${cell.col}`;
+                const prev = this.formulaCache.get(key);
+                const oldContent = popCellPreChangeContent({
+                    sheetKey,
+                    row: cell.row,
+                    col: cell.col,
+                    fallbackOldContent: typeof prev !== 'undefined' ? prev : '',
+                    store: this.cellPreChangeContent
+                });
+                if (oldContent === normalized) {
+                    this.formulaCache.set(key, normalized);
+                    return;
+                }
+                const cmd = {
+                    type: 'cells',
+                    sheetKey,
+                    cells: [{ row: cell.row, col: cell.col, oldContent, newContent: normalized }]
+                };
+                this.pushCommand(cmd);
+                this.formulaCache.set(key, normalized);
+            };
+            eventManager.on('formula_added', this.onFormulaAddedHandler);
+        }
+        ensureSortEventBindings() {
+            if (!this.table || this.sortEventBound) {
+                return;
+            }
+            const ds = this.table.internalProps?.dataSource;
+            if (!ds?.on || !ds?.off) {
+                return;
+            }
+            this.sortEventBound = true;
+            this.sortChangeOrderListenerId = ds.on('change_order', () => {
+                if (this.isReplaying || !this.table || !this.sortPending) {
+                    return;
+                }
+                const sheetKey = this.getSheetKey();
+                const oldSortState = this.sortStartSnapshot;
+                this.sortStartSnapshot = null;
+                this.sortPending = false;
+                const newSortState = this.normalizeSortState(this.table.internalProps?.sortState);
+                if (JSON.stringify(oldSortState) === JSON.stringify(newSortState)) {
+                    this.lastKnownSortState = newSortState;
+                    return;
+                }
+                const cmd = {
+                    type: 'sort',
+                    sheetKey,
+                    oldSortState: oldSortState,
+                    newSortState: newSortState
+                };
+                this.pushCommand(cmd);
+                this.lastKnownSortState = newSortState;
+            });
+        }
+        unbindSortEvents() {
+            if (!this.sortEventBound) {
+                return;
+            }
+            const ds = this.table?.internalProps?.dataSource;
+            try {
+                if (ds?.off && this.sortChangeOrderListenerId) {
+                    ds.off(this.sortChangeOrderListenerId);
+                }
+            }
+            catch {
+            }
+            finally {
+                this.sortEventBound = false;
+                this.sortChangeOrderListenerId = undefined;
+                this.sortPending = false;
+                this.sortStartSnapshot = null;
+            }
+        }
+        unbindFormulaEvents() {
+            if (!this.formulaEventBound || !this.formulaEventManager) {
+                return;
+            }
+            try {
+                if (this.onFormulaAddedHandler) {
+                    this.formulaEventManager.off('formula_added', this.onFormulaAddedHandler);
+                }
+            }
+            catch {
+            }
+            finally {
+                this.formulaEventBound = false;
+                this.formulaEventManager = undefined;
+                this.onFormulaAddedHandler = undefined;
+            }
+        }
+        cloneMergeConfig(input) {
+            if (Array.isArray(input)) {
+                return input.map(i => cloneDeep(i));
+            }
+            return input;
+        }
+        isSameMergeConfig(a, b) {
+            const normalize = (v) => {
+                if (v == null) {
+                    return [];
+                }
+                if (Array.isArray(v)) {
+                    return v;
+                }
+                return v;
+            };
+            const aa = normalize(a);
+            const bb = normalize(b);
+            if (aa === bb) {
+                return true;
+            }
+            if (Array.isArray(aa) && Array.isArray(bb)) {
+                if (aa.length !== bb.length) {
+                    return false;
+                }
+                for (let i = 0; i < aa.length; i++) {
+                    const ra = aa[i]?.range;
+                    const rb = bb[i]?.range;
+                    if (!ra ||
+                        !rb ||
+                        ra.start?.col !== rb.start?.col ||
+                        ra.start?.row !== rb.start?.row ||
+                        ra.end?.col !== rb.end?.col ||
+                        ra.end?.row !== rb.end?.row ||
+                        aa[i]?.text !== bb[i]?.text) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+        handleMergeCells(eventArgs) {
+            this.handleMergeConfigChanged(eventArgs);
+        }
+        handleUnmergeCells(eventArgs) {
+            this.handleMergeConfigChanged(eventArgs);
+        }
+        handleMergeConfigChanged(eventArgs) {
+            if (!this.table) {
+                return;
+            }
+            const { startCol, startRow, endCol, endRow } = eventArgs;
+            const before = this.cloneMergeConfig(this.prevMergeSnapshot);
+            const after = this.cloneMergeConfig(this.table.options?.customMergeCell);
+            if (this.isSameMergeConfig(before, after)) {
+                return;
+            }
+            const cmd = {
+                type: 'merge_cells',
+                sheetKey: this.getSheetKey(),
+                startCol,
+                startRow,
+                endCol,
+                endRow,
+                oldCustomMergeCell: before,
+                newCustomMergeCell: after
+            };
+            this.pushCommand(cmd);
+        }
+        handleAddRecord(eventArgs) {
+            const sheetKey = this.getSheetKey();
+            const cmd = {
+                type: 'add_record',
+                sheetKey,
+                records: Array.isArray(eventArgs.records) ? eventArgs.records.slice() : [],
+                recordIndex: eventArgs.recordIndex,
+                recordCount: eventArgs.recordCount ?? (Array.isArray(eventArgs.records) ? eventArgs.records.length : 0)
+            };
+            if (this.table && typeof eventArgs.recordIndex === 'number') {
+                const start = eventArgs.recordIndex;
+                const count = cmd.recordCount;
+                const ds = this.table?.internalProps?.dataSource;
+                const rawRecords = ds?.dataSourceObj?.records;
+                const viewRecords = this.table.records;
+                if (Array.isArray(viewRecords) && viewRecords.length) {
+                    cmd.anchorBefore = start > 0 ? viewRecords[start - 1] : undefined;
+                    cmd.anchorAfter = viewRecords[start + count];
+                }
+                if (Array.isArray(rawRecords) && Array.isArray(viewRecords)) {
+                    let rawInsertIndex = rawRecords.length;
+                    if (viewRecords.length === 0) {
+                        rawInsertIndex = rawRecords.length;
+                    }
+                    else if (start <= 0) {
+                        const first = viewRecords[0];
+                        const idx = rawRecords.indexOf(first);
+                        rawInsertIndex = idx >= 0 ? idx : 0;
+                    }
+                    else if (start >= viewRecords.length) {
+                        const last = viewRecords[viewRecords.length - 1];
+                        const idx = rawRecords.indexOf(last);
+                        rawInsertIndex = idx >= 0 ? idx + 1 : rawRecords.length;
+                    }
+                    else {
+                        const prev = viewRecords[start - 1];
+                        const idx = rawRecords.indexOf(prev);
+                        rawInsertIndex = idx >= 0 ? idx + 1 : rawRecords.length;
+                    }
+                    cmd.rawInsertIndex = rawInsertIndex;
+                }
+            }
+            this.pushCommand(cmd);
+        }
+        handleDeleteRecord(eventArgs) {
+            const sheetKey = this.getSheetKey();
+            const recordIndexs = Array.isArray(eventArgs.recordIndexs)
+                ? eventArgs.recordIndexs.slice()
+                : [eventArgs.recordIndexs];
+            let deletedRowHeights;
+            if (this.table && this.prevResizedRowHeightsSnapshot) {
+                const headerCount = this.table.transpose
+                    ? this.table.rowHeaderLevelCount
+                    : this.table.columnHeaderLevelCount;
+                recordIndexs.forEach(idx => {
+                    if (typeof idx !== 'number') {
+                        return;
+                    }
+                    const rowIndex = idx + (headerCount ?? 0);
+                    const height = this.prevResizedRowHeightsSnapshot?.[rowIndex];
+                    if (typeof height === 'number') {
+                        if (!deletedRowHeights) {
+                            deletedRowHeights = {};
+                        }
+                        deletedRowHeights[idx] = height;
+                    }
+                });
+            }
+            const oldCustomMergeCell = this.cloneMergeConfig(this.prevMergeSnapshot);
+            const newCustomMergeCell = this.cloneMergeConfig(this.table?.options?.customMergeCell);
+            const cmd = {
+                type: 'delete_record',
+                sheetKey,
+                records: Array.isArray(eventArgs.records) ? eventArgs.records.slice() : [],
+                recordIndexs,
+                deletedRowHeights,
+                oldCustomMergeCell,
+                newCustomMergeCell
+            };
+            this.pushCommand(cmd);
+        }
+        handleUpdateRecord(eventArgs) {
+            if (!this.table) {
+                return;
+            }
+            const sheetKey = this.getSheetKey();
+            const recordIndexs = (eventArgs.recordIndexs || []);
+            const newRecords = Array.isArray(eventArgs.records) ? eventArgs.records.slice() : [];
+            if (!this.prevRecordsSnapshot || !Array.isArray(this.prevRecordsSnapshot) || !recordIndexs.length) {
+                return;
+            }
+            const oldRecords = [];
+            recordIndexs.forEach(idx => {
+                if (typeof idx === 'number') {
+                    const rec = this.prevRecordsSnapshot[idx];
+                    oldRecords.push(rec !== undefined ? cloneRecord(rec) : undefined);
+                }
+                else {
+                    oldRecords.push(undefined);
+                }
+            });
+            const cmd = { type: 'update_record', sheetKey, oldRecords, newRecords, recordIndexs };
+            this.pushCommand(cmd);
+        }
+        handleAddColumn(eventArgs) {
+            if (!this.table) {
+                return;
+            }
+            const sheetKey = this.getSheetKey();
+            const { columnIndex, columnCount, columns } = eventArgs;
+            const addedColumns = columns
+                .slice(columnIndex, columnIndex + columnCount)
+                .map(c => cloneDeep(c));
+            const cmd = { type: 'add_column', sheetKey, columnIndex, columnCount, columns: addedColumns };
+            this.pushCommand(cmd);
+        }
+        handleDeleteColumn(eventArgs) {
+            if (!this.table) {
+                return;
+            }
+            const sheetKey = this.getSheetKey();
+            const deleteColIndexs = (eventArgs.deleteColIndexs || []).slice();
+            const deletedColumnsFromEvent = eventArgs.deletedColumns;
+            const prevColumns = this.prevColumnsSnapshot || [];
+            const deletedColumns = Array.isArray(deletedColumnsFromEvent)
+                ? deletedColumnsFromEvent.map(c => cloneDeep(c))
+                : [];
+            if (!deletedColumns.length) {
+                deleteColIndexs.forEach(idx => {
+                    if (idx >= 0 && idx < prevColumns.length) {
+                        deletedColumns.push(cloneDeep(prevColumns[idx]));
+                    }
+                });
+            }
+            let deletedRecordValues = eventArgs.deletedRecordValues;
+            if (!Array.isArray(deletedRecordValues) || !deletedRecordValues.length) {
+                deletedRecordValues = undefined;
+                if (Array.isArray(this.prevRecordsSnapshot) && this.prevRecordsSnapshot.length) {
+                    deletedRecordValues = this.prevRecordsSnapshot.map(rec => {
+                        if (Array.isArray(rec)) {
+                            return deleteColIndexs.map(idx => rec[idx]);
+                        }
+                        return [];
+                    });
+                    if (deletedRecordValues.every(v => v.length === 0)) {
+                        deletedRecordValues = undefined;
+                    }
+                }
+            }
+            let deletedFormulas;
+            if (this.prevFormulasSnapshot && deleteColIndexs.length) {
+                const entries = Object.entries(this.prevFormulasSnapshot);
+                entries.forEach(([cellRef, formula]) => {
+                    const parsed = parseA1Notation(cellRef);
+                    if (parsed && deleteColIndexs.includes(parsed.col)) {
+                        if (!deletedFormulas) {
+                            deletedFormulas = {};
+                        }
+                        deletedFormulas[cellRef] = formula;
+                    }
+                });
+            }
+            let deletedColWidths;
+            if (this.prevResizedColWidthsSnapshot && deleteColIndexs.length) {
+                deleteColIndexs.forEach(idx => {
+                    const w = this.prevResizedColWidthsSnapshot?.[idx];
+                    if (typeof w === 'number') {
+                        if (!deletedColWidths) {
+                            deletedColWidths = {};
+                        }
+                        deletedColWidths[idx] = w;
+                    }
+                });
+            }
+            const cmd = {
+                type: 'delete_column',
+                sheetKey,
+                deleteColIndexs,
+                columns: deletedColumns,
+                deletedRecordValues,
+                deletedFormulas,
+                deletedColWidths
+            };
+            this.pushCommand(cmd);
+        }
+        handleChangeHeaderPosition(eventArgs) {
+            const sheetKey = this.getSheetKey();
+            const moving = eventArgs.movingColumnOrRow ?? 'column';
+            const sourceIndex = moving === 'column' ? eventArgs.source.col : eventArgs.source.row;
+            const targetIndex = moving === 'column' ? eventArgs.target.col : eventArgs.target.row;
+            const cmd = {
+                type: 'change_header_position',
+                sheetKey,
+                moving,
+                sourceIndex,
+                targetIndex
+            };
+            this.pushCommand(cmd);
+        }
+        normalizeSortState(input) {
+            if (!input) {
+                return null;
+            }
+            if (Array.isArray(input)) {
+                const list = input
+                    .filter(Boolean)
+                    .map((s) => ({ field: s.field, order: s.order }))
+                    .filter((s) => typeof s.field !== 'undefined' && s.order && s.order !== 'normal');
+                return list.length ? list : null;
+            }
+            const s = input;
+            if (typeof s.field === 'undefined' || !s.order || s.order === 'normal') {
+                return null;
+            }
+            return { field: s.field, order: s.order };
+        }
+        handleSortClick(_eventArgs) {
+            if (!this.table) {
+                return;
+            }
+            this.sortStartSnapshot = this.lastKnownSortState;
+            this.sortPending = true;
+            setTimeout(() => {
+                if (this.sortPending) {
+                    this.sortPending = false;
+                    this.sortStartSnapshot = null;
+                }
+            }, 0);
+        }
+        handleResizeRow(eventArgs) {
+            if (!this.table) {
+                return;
+            }
+            const row = eventArgs.row;
+            if (!this.resizeRowStartHeight.has(row)) {
+                const oldHeight = this.table.getRowHeight?.(row);
+                if (typeof oldHeight === 'number') {
+                    this.resizeRowStartHeight.set(row, oldHeight);
+                }
+            }
+        }
+        handleResizeRowEnd(eventArgs) {
+            if (!this.table) {
+                return;
+            }
+            const sheetKey = this.getSheetKey();
+            const row = eventArgs.row;
+            const newHeight = eventArgs.rowHeight;
+            const oldHeight = this.resizeRowStartHeight.get(row) ?? newHeight;
+            this.resizeRowStartHeight.delete(row);
+            if (typeof oldHeight === 'number' && typeof newHeight === 'number' && oldHeight === newHeight) {
+                return;
+            }
+            const cmd = { type: 'resize_row', sheetKey, row, oldHeight, newHeight };
+            this.pushCommand(cmd);
+        }
+        handleResizeColumn(eventArgs) {
+            if (!this.table) {
+                return;
+            }
+            const col = eventArgs.col;
+            if (!this.resizeColStartWidth.has(col)) {
+                const oldWidth = this.table.getColWidth?.(col);
+                if (typeof oldWidth === 'number') {
+                    this.resizeColStartWidth.set(col, oldWidth);
+                }
+            }
+        }
+        handleResizeColumnEnd(eventArgs) {
+            if (!this.table) {
+                return;
+            }
+            const sheetKey = this.getSheetKey();
+            const col = eventArgs.col;
+            const colWidths = eventArgs.colWidths || [];
+            const newWidth = colWidths[col] ?? this.table.getColWidth?.(col);
+            const oldWidth = this.resizeColStartWidth.get(col) ?? newWidth;
+            this.resizeColStartWidth.delete(col);
+            if (typeof oldWidth === 'number' && typeof newWidth === 'number' && oldWidth === newWidth) {
+                return;
+            }
+            const cmd = { type: 'resize_column', sheetKey, col, oldWidth, newWidth };
+            this.pushCommand(cmd);
+        }
+        applyCommand(cmd, direction) {
+            if (!this.table) {
+                return;
+            }
+            replayCommand({
+                table: this.table,
+                vtableSheet: this.vtableSheet,
+                cmd,
+                direction,
+                deleteRecordsByReference: (records) => this.deleteRecordsByReference(records)
+            });
+        }
+        deleteRecordsByReference(records) {
+            if (!this.table || !records?.length) {
+                return;
+            }
+            const tableRecords = (this.table.records || []);
+            const indexs = [];
+            records.forEach(rec => {
+                const idx = tableRecords.indexOf(rec);
+                if (idx >= 0) {
+                    indexs.push(idx);
+                }
+            });
+            if (indexs.length && this.table.deleteRecords) {
+                this.table.deleteRecords(indexs);
+            }
+        }
+    }
+
     exports.AddRowColumnPlugin = AddRowColumnPlugin;
     exports.AutoFillPlugin = AutoFillPlugin;
     exports.CarouselAnimationPlugin = CarouselAnimationPlugin;
@@ -25226,6 +27046,7 @@ ${recordsStr}
     exports.FocusHighlightPlugin = FocusHighlightPlugin;
     exports.HeaderHighlightPlugin = HeaderHighlightPlugin;
     exports.HighlightHeaderWhenSelectCellPlugin = HighlightHeaderWhenSelectCellPlugin;
+    exports.HistoryPlugin = HistoryPlugin;
     exports.InvertHighlightPlugin = InvertHighlightPlugin;
     exports.MENU_CONTAINER_CLASS = MENU_CONTAINER_CLASS;
     exports.MENU_ITEM_CLASS = MENU_ITEM_CLASS;
@@ -25259,6 +27080,7 @@ ${recordsStr}
     exports.loopSeriesRule = loopSeriesRule;
     exports.numberRule = numberRule;
     exports.otherRule = otherRule;
+    exports.replayCommand = replayCommand;
     exports.reverseIfNeed = reverseIfNeed;
     exports.rotate90WithTransform = rotate90WithTransform;