@visactor/vtable-sheet 1.21.1-alpha.0 → 1.22.0

package/dist/vtable-sheet.js

@@ -142,9 +142,15 @@
             this.sheets.set(sheetKey, sheetId);
             this.reverseSheets.set(sheetId, sheetKey);
             const sheetData = data || [['']];
-            this.sheetData.set(sheetId, this.normalizeData(sheetData));
+            this.sheetData.set(sheetId, sheetData);
             return sheetId;
         }
+        updateSheetData(sheetKey, data) {
+            const sheetId = this.sheets.get(sheetKey);
+            if (sheetId !== undefined && sheetId !== null) {
+                this.sheetData.set(sheetId, data);
+            }
+        }
         normalizeData(data) {
             if (!Array.isArray(data) || data.length === 0) {
                 return [['']];
@@ -177,6 +183,57 @@
             }
             return sheetId;
         }
+        getFormulaString(cell) {
+            const cellKey = this.getCellKey(cell);
+            return this.formulaCells.get(cellKey) || null;
+        }
+        clearDependencies(cellKey) {
+            const oldDeps = this.dependencies.get(cellKey) || new Set();
+            for (const dep of oldDeps) {
+                const depDependents = this.dependents.get(dep) || new Set();
+                depDependents.delete(cellKey);
+                if (depDependents.size === 0) {
+                    this.dependents.delete(dep);
+                }
+                else {
+                    this.dependents.set(dep, depDependents);
+                }
+            }
+            this.dependencies.delete(cellKey);
+        }
+        setCellContentWithoutDependencyUpdate(cell, value) {
+            if (!cell || cell.sheet === undefined || cell.row === undefined || cell.col === undefined) {
+                throw new Error('Invalid cell parameter');
+            }
+            if (cell.row < 0 || cell.col < 0) {
+                throw new Error(`Cell coordinates out of bounds: row=${cell.row}, col=${cell.col}`);
+            }
+            const sheetId = this.getSheetId(cell.sheet);
+            if (!this.sheetData.has(sheetId)) {
+                this.sheetData.set(sheetId, [['']]);
+            }
+            const sheet = this.sheetData.get(sheetId);
+            if (!sheet) {
+                throw new Error(`Sheet data not found for ID: ${sheetId}`);
+            }
+            while (sheet.length <= cell.row) {
+                sheet.push([]);
+            }
+            while (sheet[cell.row].length <= cell.col) {
+                sheet[cell.row].push('');
+            }
+            let processedValue = value;
+            if (processedValue === null || processedValue === undefined) {
+                processedValue = '';
+            }
+            if (typeof processedValue === 'string' && !processedValue.startsWith('=')) {
+                const numericValue = Number(processedValue);
+                if (!isNaN(numericValue) && processedValue.trim() !== '') {
+                    processedValue = numericValue;
+                }
+            }
+            sheet[cell.row][cell.col] = processedValue;
+        }
         setCellContent(cell, value) {
             if (!cell || cell.sheet === undefined || cell.row === undefined || cell.col === undefined) {
                 throw new Error('Invalid cell parameter');
@@ -261,6 +318,9 @@
                     return { value: formula, error: undefined };
                 }
                 const expression = formula.substring(1).trim();
+                if (expression.includes('#REF!')) {
+                    return { value: '#REF!', error: undefined };
+                }
                 const result = this.parseExpression(expression);
                 return result;
             }
@@ -1405,11 +1465,356 @@
             }
             return result;
         }
+        adjustFormulaReferences(sheetKey, type, dimension, index, count, totalColCount, totalRowCount) {
+            try {
+                const adjustedFormulas = [];
+                const movedFormulas = [];
+                const deletedCells = new Set();
+                if (type === 'delete') {
+                    for (let i = 0; i < count; i++) {
+                        if (dimension === 'row') {
+                            for (let col = 0; col < totalColCount; col++) {
+                                const deletedCell = { sheet: sheetKey, row: index + i, col };
+                                const deletedCellKey = this.getCellKey(deletedCell);
+                                deletedCells.add(deletedCellKey);
+                            }
+                        }
+                        else if (dimension === 'column') {
+                            for (let row = 0; row < totalRowCount; row++) {
+                                const deletedCell = { sheet: sheetKey, row, col: index + i };
+                                const deletedCellKey = this.getCellKey(deletedCell);
+                                deletedCells.add(deletedCellKey);
+                            }
+                        }
+                    }
+                }
+                for (const [cellKey, formula] of Array.from(this.formulaCells.entries())) {
+                    const cell = this.parseCellKey(cellKey);
+                    if (!cell || cell.sheet !== sheetKey) {
+                        continue;
+                    }
+                    const newCell = { ...cell };
+                    let cellNeedsMove = false;
+                    if (dimension === 'row') {
+                        if (type === 'insert' && cell.row >= index) {
+                            newCell.row = cell.row + count;
+                            cellNeedsMove = true;
+                        }
+                        else if (type === 'delete' && cell.row > index) {
+                            newCell.row = cell.row - count;
+                            cellNeedsMove = true;
+                        }
+                        else if (type === 'delete' && cell.row >= index && cell.row < index + count) {
+                            this.formulaCells.delete(cellKey);
+                            continue;
+                        }
+                    }
+                    else if (dimension === 'column') {
+                        if (type === 'insert' && cell.col >= index) {
+                            newCell.col = cell.col + count;
+                            cellNeedsMove = true;
+                        }
+                        else if (type === 'delete' && cell.col > index) {
+                            newCell.col = cell.col - count;
+                            cellNeedsMove = true;
+                        }
+                        else if (type === 'delete' && cell.col >= index && cell.col < index + count) {
+                            this.formulaCells.delete(cellKey);
+                            continue;
+                        }
+                    }
+                    const newFormula = this.adjustFormulaReference(formula, type, dimension, index, count);
+                    if (cellNeedsMove) {
+                        movedFormulas.push({ oldCellKey: cellKey, newCell, formula: newFormula });
+                        this.formulaCells.delete(cellKey);
+                        this.clearDependencies(cellKey);
+                    }
+                    else if (newFormula !== formula) {
+                        adjustedFormulas.push({ cell, oldFormula: formula, newFormula });
+                        this.clearDependencies(cellKey);
+                    }
+                }
+                for (const { newCell, formula } of movedFormulas) {
+                    const newCellKey = this.getCellKey(newCell);
+                    this.formulaCells.set(newCellKey, formula);
+                    this.updateDependencies(newCellKey, formula);
+                    this.setCellContentWithoutDependencyUpdate(newCell, formula);
+                }
+                for (const { cell, newFormula } of adjustedFormulas) {
+                    const cellKey = this.getCellKey(cell);
+                    this.formulaCells.set(cellKey, newFormula);
+                    this.updateDependencies(cellKey, newFormula);
+                    this.setCellContentWithoutDependencyUpdate(cell, newFormula);
+                }
+                const totalChanges = adjustedFormulas.length + movedFormulas.length;
+                if (totalChanges > 0) {
+                }
+                const adjustedCells = adjustedFormulas.map(item => item.cell);
+                const movedCells = movedFormulas.map(item => item.newCell);
+                return { adjustedCells, movedCells };
+            }
+            catch (error) {
+                return { adjustedCells: [], movedCells: [] };
+            }
+        }
+        adjustFormulaReference(formula, type, dimension, index, count) {
+            if (!formula || !formula.startsWith('=')) {
+                return formula;
+            }
+            const expression = formula.substring(1);
+            const cellRefRegex = /([A-Z]+)([0-9]+)/g;
+            const rangeRefRegex = /([A-Z]+[0-9]+):([A-Z]+[0-9]+)/g;
+            let newExpression = expression;
+            let match;
+            const replacements = [];
+            while ((match = rangeRefRegex.exec(expression)) !== null) {
+                const fullRangeMatch = match[0];
+                const startCell = match[1];
+                const endCell = match[2];
+                if (type === 'delete') {
+                    const rangeContainsDeletedCells = this.rangeContainsDeletedCells(startCell, endCell, dimension, index, count);
+                    if (rangeContainsDeletedCells) {
+                        const newRange = this.adjustRangeForDeletion(startCell, endCell, dimension, index, count);
+                        if (newRange !== fullRangeMatch) {
+                            replacements.push({
+                                start: match.index,
+                                end: match.index + fullRangeMatch.length,
+                                replacement: newRange
+                            });
+                        }
+                    }
+                }
+            }
+            cellRefRegex.lastIndex = 0;
+            while ((match = cellRefRegex.exec(expression)) !== null) {
+                const fullMatch = match[0];
+                const colLetters = match[1];
+                const rowNumber = parseInt(match[2], 10);
+                const currentMatchIndex = match.index;
+                const isPartOfRange = replacements.some(replacement => currentMatchIndex >= replacement.start && currentMatchIndex < replacement.end);
+                if (isPartOfRange) {
+                    continue;
+                }
+                let needsAdjustment = false;
+                let newRowNumber = rowNumber;
+                let newColLetters = colLetters;
+                if (dimension === 'row') {
+                    const zeroBasedRowNumber = rowNumber - 1;
+                    if (type === 'insert' && zeroBasedRowNumber >= index) {
+                        newRowNumber = rowNumber + count;
+                        needsAdjustment = true;
+                    }
+                    else if (type === 'delete' && zeroBasedRowNumber >= index) {
+                        if (zeroBasedRowNumber >= index + count) {
+                            newRowNumber = rowNumber - count;
+                            needsAdjustment = true;
+                        }
+                        else if (zeroBasedRowNumber >= index && zeroBasedRowNumber < index + count) {
+                            newRowNumber = index;
+                            needsAdjustment = true;
+                        }
+                    }
+                }
+                else if (dimension === 'column') {
+                    const colIndex = this.columnLettersToIndex(colLetters);
+                    if (type === 'insert' && colIndex >= index) {
+                        newColLetters = this.indexToColumnLetters(colIndex + count);
+                        needsAdjustment = true;
+                    }
+                    else if (type === 'delete' && colIndex >= index) {
+                        if (colIndex >= index + count) {
+                            newColLetters = this.indexToColumnLetters(colIndex - count);
+                            needsAdjustment = true;
+                        }
+                        else if (colIndex >= index && colIndex < index + count) {
+                            newColLetters = this.indexToColumnLetters(index);
+                            needsAdjustment = true;
+                        }
+                    }
+                }
+                if (needsAdjustment) {
+                    let replacement;
+                    if (dimension === 'row' && newRowNumber === index) {
+                        replacement = '#REF!';
+                    }
+                    else if (dimension === 'column' &&
+                        this.indexToColumnLetters(this.columnLettersToIndex(newColLetters)) === this.indexToColumnLetters(index)) {
+                        replacement = '#REF!';
+                    }
+                    else {
+                        replacement = newColLetters + newRowNumber;
+                    }
+                    replacements.push({
+                        start: match.index,
+                        end: match.index + fullMatch.length,
+                        replacement: replacement
+                    });
+                }
+            }
+            replacements.sort((a, b) => b.start - a.start);
+            for (const { start, end, replacement } of replacements) {
+                newExpression = newExpression.substring(0, start) + replacement + newExpression.substring(end);
+            }
+            return '=' + newExpression;
+        }
+        columnLettersToIndex(letters) {
+            let index = 0;
+            for (let i = 0; i < letters.length; i++) {
+                index = index * 26 + (letters.charCodeAt(i) - 64);
+            }
+            return index - 1;
+        }
+        indexToColumnLetters(index) {
+            let letters = '';
+            do {
+                letters = String.fromCharCode(65 + (index % 26)) + letters;
+                index = Math.floor(index / 26) - 1;
+            } while (index >= 0);
+            return letters;
+        }
+        rangeContainsDeletedCells(startCell, endCell, dimension, index, count) {
+            try {
+                const start = this.parseA1Notation(startCell);
+                const end = this.parseA1Notation(endCell);
+                const minRow = Math.min(start.row, end.row);
+                const maxRow = Math.max(start.row, end.row);
+                const minCol = Math.min(start.col, end.col);
+                const maxCol = Math.max(start.col, end.col);
+                if (dimension === 'row') {
+                    const deleteStartRow = index;
+                    const deleteEndRow = index + count - 1;
+                    if (deleteEndRow >= minRow && deleteStartRow <= maxRow) {
+                        return true;
+                    }
+                }
+                else if (dimension === 'column') {
+                    const deleteStartCol = index;
+                    const deleteEndCol = index + count - 1;
+                    if (deleteEndCol >= minCol && deleteStartCol <= maxCol) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            catch {
+                return false;
+            }
+        }
+        adjustRangeForDeletion(startCell, endCell, dimension, index, count) {
+            try {
+                const start = this.parseA1Notation(startCell);
+                const end = this.parseA1Notation(endCell);
+                const minRow = Math.min(start.row, end.row);
+                const maxRow = Math.max(start.row, end.row);
+                const minCol = Math.min(start.col, end.col);
+                const maxCol = Math.max(start.col, end.col);
+                let newMinRow = minRow;
+                let newMaxRow = maxRow;
+                let newMinCol = minCol;
+                let newMaxCol = maxCol;
+                if (dimension === 'row') {
+                    const deleteStartRow = index;
+                    const deleteEndRow = index + count - 1;
+                    if (minRow >= deleteStartRow && minRow <= deleteEndRow) {
+                        newMinRow = deleteStartRow > 0 ? deleteStartRow - 1 : 0;
+                    }
+                    else if (minRow > deleteEndRow) {
+                        newMinRow = minRow - count;
+                        if (newMinRow < 0) {
+                            newMinRow = 0;
+                        }
+                    }
+                    if (maxRow >= deleteStartRow && maxRow <= deleteEndRow) {
+                        newMaxRow = deleteStartRow > 0 ? deleteStartRow - 1 : 0;
+                    }
+                    else if (maxRow > deleteEndRow) {
+                        newMaxRow = maxRow - count;
+                        if (newMaxRow < 0) {
+                            newMaxRow = 0;
+                        }
+                    }
+                    if (newMinRow > newMaxRow) {
+                        return '#REF!';
+                    }
+                }
+                else if (dimension === 'column') {
+                    const deleteStartCol = index;
+                    const deleteEndCol = index + count - 1;
+                    if (minCol >= deleteStartCol && minCol <= deleteEndCol) {
+                        newMinCol = deleteStartCol > 0 ? deleteStartCol - 1 : 0;
+                    }
+                    else if (minCol > deleteEndCol) {
+                        newMinCol = minCol - count;
+                        if (newMinCol < 0) {
+                            newMinCol = 0;
+                        }
+                    }
+                    if (maxCol >= deleteStartCol && maxCol <= deleteEndCol) {
+                        newMaxCol = deleteStartCol > 0 ? deleteStartCol - 1 : 0;
+                    }
+                    else if (maxCol > deleteEndCol) {
+                        newMaxCol = maxCol - count;
+                        if (newMaxCol < 0) {
+                            newMaxCol = 0;
+                        }
+                    }
+                    if (newMinCol > newMaxCol) {
+                        return '#REF!';
+                    }
+                    if (newMinCol === -1 || newMaxCol === -1) {
+                        return '#REF!';
+                    }
+                }
+                if ((dimension === 'row' && newMinRow === -1 && newMaxRow === -1) ||
+                    (dimension === 'column' && newMinCol === -1 && newMaxCol === -1)) {
+                    return '#REF!';
+                }
+                let newStartCell;
+                let newEndCell;
+                if (dimension === 'row') {
+                    if (newMinRow === -1) {
+                        newStartCell = '#REF!';
+                    }
+                    else {
+                        newStartCell = this.getA1Notation(newMinRow, newMinCol);
+                    }
+                    if (newMaxRow === -1) {
+                        newEndCell = '#REF!';
+                    }
+                    else {
+                        newEndCell = this.getA1Notation(newMaxRow, newMaxCol);
+                    }
+                }
+                else {
+                    if (newMinCol === -1) {
+                        newStartCell = '#REF!';
+                    }
+                    else {
+                        newStartCell = this.getA1Notation(newMinRow, newMinCol);
+                    }
+                    if (newMaxCol === -1) {
+                        newEndCell = '#REF!';
+                    }
+                    else {
+                        newEndCell = this.getA1Notation(newMaxRow, newMaxCol);
+                    }
+                }
+                if (newStartCell === newEndCell) {
+                    return newStartCell;
+                }
+                return `${newStartCell}:${newEndCell}`;
+            }
+            catch {
+                return '#REF!';
+            }
+        }
     }
     class FormulaError {
         message;
-        constructor(message) {
+        type;
+        constructor(message, type = 'VALUE') {
             this.message = message;
+            this.type = type;
         }
     }
 
@@ -37668,6 +38073,8 @@
       AFTER_RENDER: "after_render",
       INITIALIZED: "initialized",
       UPDATED: "updated",
+      AFTER_UPDATE_CELL_CONTENT_WIDTH: "after_update_cell_content_width",
+      AFTER_UPDATE_SELECT_BORDER_HEIGHT: "after_update_select_border_height",
       CHANGE_CELL_VALUE: "change_cell_value",
       DRAG_FILL_HANDLE_END: "drag_fill_handle_end",
       MOUSEDOWN_FILL_HANDLE: "mousedown_fill_handle",
@@ -37677,7 +38084,12 @@
       BUTTON_CLICK: "button_click",
       BEFORE_CACHE_CHART_IMAGE: "before_cache_chart_image",
       PASTED_DATA: "pasted_data",
-      PLUGIN_EVENT: "plugin_event"
+      PLUGIN_EVENT: "plugin_event",
+      ADD_RECORD: "add_record",
+      DELETE_RECORD: "delete_record",
+      UPDATE_RECORD: "update_record",
+      ADD_COLUMN: "add_column",
+      DELETE_COLUMN: "delete_column"
     };
 
     const judgeType = value => {
@@ -41443,7 +41855,7 @@
       }
       constructor(opt, dataConfig, pagination, columns, rowHierarchyType, hierarchyExpandLevel) {
         let _isGrouped;
-        isArray$a(null == dataConfig ? void 0 : dataConfig.groupByRules) && (rowHierarchyType = "tree", _isGrouped = !0), super(opt, dataConfig, pagination, columns, rowHierarchyType, hierarchyExpandLevel), this._isGrouped = _isGrouped, this._recordCache = [], this._fieldCache = {};
+        isArray$a(null == dataConfig ? void 0 : dataConfig.groupByRules) && (_isGrouped = !0), super(opt, dataConfig, pagination, columns, rowHierarchyType, hierarchyExpandLevel), this._isGrouped = _isGrouped, this._recordCache = [], this._fieldCache = {};
       }
       getOriginalRecord(index) {
         return isNumber$4(index) && this._recordCache && this._recordCache[index] ? this._recordCache[index] : super.getOriginalRecord(index);
@@ -42059,9 +42471,13 @@
       })];
     }
     function _setRecords(table, records = []) {
+      const tableWithPlugins = table;
       _dealWithUpdateDataSource(table, () => {
+        var _a;
         table.internalProps.records = records;
-        const newDataSource = table.internalProps.dataSource = CachedDataSource.ofArray(records, table.internalProps.dataConfig, table.pagination, table.internalProps.columns, table.internalProps.layoutMap.rowHierarchyType, getHierarchyExpandLevel(table));
+        let rowHierarchyType = table.internalProps.layoutMap.rowHierarchyType;
+        isArray$a(null === (_a = table.internalProps.dataConfig) || void 0 === _a ? void 0 : _a.groupByRules) && (rowHierarchyType = "tree"), tableWithPlugins.pluginManager.getPluginByName("Master Detail Plugin") && (rowHierarchyType = "grid");
+        const newDataSource = table.internalProps.dataSource = CachedDataSource.ofArray(records, table.internalProps.dataConfig, table.pagination, table.internalProps.columns, rowHierarchyType, getHierarchyExpandLevel(table));
         table.addReleaseObj(newDataSource);
       });
     }
@@ -43553,14 +43969,28 @@
         } else "mark" === child.name && child.setAttribute("x", cellGroup.attribute.width);
       }), autoRowHeight) {
         let newHeight = Math.max(leftIconHeight, contentHeight, rightIconHeight);
-        if (isCellHeightUpdate(scene, cellGroup, Math.round(newHeight + padding[0] + padding[2]), oldCellHeight)) return !0;
+        if (isCellHeightUpdate(scene, cellGroup, Math.round(newHeight + padding[0] + padding[2]), oldCellHeight)) return scene.table.hasListeners(TABLE_EVENT_TYPE.AFTER_UPDATE_CELL_CONTENT_WIDTH) && scene.table.fireListeners(TABLE_EVENT_TYPE.AFTER_UPDATE_CELL_CONTENT_WIDTH, {
+          col: cellGroup.col,
+          row: cellGroup.row,
+          cellHeight: cellHeight,
+          cellGroup: cellGroup,
+          padding: padding,
+          textBaseline: textBaseline
+        }), !0;
         newHeight = (null !== (_d = cellGroup.contentHeight) && void 0 !== _d ? _d : cellHeight) - (padding[0] + padding[2]), cellGroup.forEachChildren(child => {
           "rect" !== child.type && "chart" !== child.type && child.name !== CUSTOM_CONTAINER_NAME && ("mark" === child.name ? child.setAttribute("y", 0) : "middle" === textBaseline ? child.setAttribute("y", padding[0] + (newHeight - child.AABBBounds.height()) / 2) : "bottom" === textBaseline ? child.setAttribute("y", padding[0] + newHeight - child.AABBBounds.height()) : child.setAttribute("y", padding[0]));
         });
       } else "middle" !== textBaseline && "bottom" !== textBaseline || cellGroup.forEachChildren(child => {
         "rect" !== child.type && "chart" !== child.type && child.name !== CUSTOM_CONTAINER_NAME && ("mark" === child.name ? child.setAttribute("y", 0) : "middle" === textBaseline ? child.setAttribute("y", (cellHeight - padding[2] + padding[0] - child.AABBBounds.height()) / 2) : "bottom" === textBaseline ? child.setAttribute("y", cellHeight - child.AABBBounds.height() - padding[2]) : child.setAttribute("y", padding[0]));
       });
-      return !1;
+      return scene.table.hasListeners(TABLE_EVENT_TYPE.AFTER_UPDATE_CELL_CONTENT_WIDTH) && scene.table.fireListeners(TABLE_EVENT_TYPE.AFTER_UPDATE_CELL_CONTENT_WIDTH, {
+        col: cellGroup.col,
+        row: cellGroup.row,
+        cellHeight: cellHeight,
+        cellGroup: cellGroup,
+        padding: padding,
+        textBaseline: textBaseline
+      }), !1;
     }
     function updateCellContentHeight(cellGroup, distHeight, detaY, autoRowHeight, padding, textAlign, textBaseline, table) {
       var _a;
@@ -49157,7 +49587,8 @@
         } else if (this.rowEnd === this.bodyBottomRow) {
           const cellGroup = this.table.scenegraph.highPerformanceGetCell(this.colStart, this.rowEnd, !0);
           if ("cell" === cellGroup.role) {
-            const deltaY = cellGroup.attribute.y + cellGroup.attribute.height - (this.table.getAllRowsHeight() - this.table.getFrozenRowsHeight() - this.table.getBottomFrozenRowsHeight());
+            const actualRowHeight = this.table.getRowHeight(this.rowEnd),
+              deltaY = cellGroup.attribute.y + actualRowHeight - (this.table.getAllRowsHeight() - this.table.getFrozenRowsHeight() - this.table.getBottomFrozenRowsHeight());
             this.deltaY = -deltaY;
           }
         } else if (isValid$4(screenTopY) && isValid$4(screenTopRow)) {
@@ -49298,6 +49729,11 @@
         width: colsWidth,
         height: rowsHeight,
         visible: !0
+      }), table.hasListeners(TABLE_EVENT_TYPE.AFTER_UPDATE_SELECT_BORDER_HEIGHT) && table.fireListeners(TABLE_EVENT_TYPE.AFTER_UPDATE_SELECT_BORDER_HEIGHT, {
+        startRow: computeRectCellRangeStartRow,
+        endRow: computeRectCellRangeEndRow,
+        currentHeight: rowsHeight,
+        selectComp: selectComp
       }), selectComp.fillhandle) {
         const fillHandle = null === (_a = scene.table.options.excelOptions) || void 0 === _a ? void 0 : _a.fillHandle;
         let lastCellBound,
@@ -51327,7 +51763,7 @@
         var _a, _b, _c, _d, _e, _f;
         const firstBodyCell = null !== (_b = null === (_a = this.bodyGroup.firstChild) || void 0 === _a ? void 0 : _a.firstChild) && void 0 !== _b ? _b : null === (_c = this.rowHeaderGroup.firstChild) || void 0 === _c ? void 0 : _c.firstChild,
           lastBodyCell = null !== (_e = null === (_d = this.bodyGroup.firstChild) || void 0 === _d ? void 0 : _d.lastChild) && void 0 !== _e ? _e : null === (_f = this.rowHeaderGroup.firstChild) || void 0 === _f ? void 0 : _f.lastChild;
-        0 === y && firstBodyCell && firstBodyCell.row === this.table.frozenRowCount && firstBodyCell.attribute.y + y < 0 ? y = -firstBodyCell.attribute.y : lastBodyCell && this.table.tableNoFrameHeight < this.table.getAllRowsHeight() && lastBodyCell.row === this.table.rowCount - this.table.bottomFrozenRowCount - 1 && lastBodyCell.attribute.y + lastBodyCell.attribute.height + y < this.table.tableNoFrameHeight - this.table.getFrozenRowsHeight() - this.table.getBottomFrozenRowsHeight() && (y = this.table.tableNoFrameHeight - this.table.getFrozenRowsHeight() - this.table.getBottomFrozenRowsHeight() - lastBodyCell.attribute.y - lastBodyCell.attribute.height), this.colHeaderGroup.attribute.height + y !== this.bodyGroup.attribute.y && (this.bodyGroup.setAttribute("y", this.colHeaderGroup.attribute.height + y), this.rowHeaderGroup.setAttribute("y", this.cornerHeaderGroup.attribute.height + y), this.table.rightFrozenColCount > 0 && this.rightFrozenGroup.setAttribute("y", this.rightTopCornerGroup.attribute.height + y), this.updateNextFrame());
+        0 === y && firstBodyCell && firstBodyCell.row === this.table.frozenRowCount && firstBodyCell.attribute.y + y < 0 ? y = -firstBodyCell.attribute.y : lastBodyCell && this.table.tableNoFrameHeight < this.table.getAllRowsHeight() && lastBodyCell.row === this.table.rowCount - this.table.bottomFrozenRowCount - 1 && lastBodyCell.attribute.y + this.table.getRowHeight(lastBodyCell.row) + y < this.table.tableNoFrameHeight - this.table.getFrozenRowsHeight() - this.table.getBottomFrozenRowsHeight() && (y = this.table.tableNoFrameHeight - this.table.getFrozenRowsHeight() - this.table.getBottomFrozenRowsHeight() - lastBodyCell.attribute.y - this.table.getRowHeight(lastBodyCell.row)), this.colHeaderGroup.attribute.height + y !== this.bodyGroup.attribute.y && (this.bodyGroup.setAttribute("y", this.colHeaderGroup.attribute.height + y), this.rowHeaderGroup.setAttribute("y", this.cornerHeaderGroup.attribute.height + y), this.table.rightFrozenColCount > 0 && this.rightFrozenGroup.setAttribute("y", this.rightTopCornerGroup.attribute.height + y), this.updateNextFrame());
       }
       setBodyAndColHeaderX(x) {
         const firstBodyCol = this.bodyGroup.firstChild,
@@ -54329,8 +54765,9 @@
           (null === (_b = table.options.customConfig) || void 0 === _b ? void 0 : _b.cancelSelectCellHook) ? (null === (_c = table.options.customConfig) || void 0 === _c ? void 0 : _c.cancelSelectCellHook(e)) && eventManager.dealTableSelect() : (null === (_e = null === (_d = table.options.select) || void 0 === _d ? void 0 : _d.blankAreaClickDeselect) || void 0 === _e || _e) && eventManager.dealTableSelect(), stateManager.endSelectCells(!0, isHasSelected), stateManager.updateCursor(), table.scenegraph.updateChartState(null);
         }
       }), table.scenegraph.stage.addEventListener("pointermove", e => {
+        var _a, _b, _c;
         const eventArgsSet = getCellEventArgsSet(e);
-        stateManager.isResizeCol() || eventManager.checkColumnResize(eventArgsSet) ? table.stateManager.select && eventManager.checkCellFillhandle(eventArgsSet) ? stateManager.updateCursor("crosshair") : stateManager.updateCursor("col-resize") : stateManager.isResizeRow() || eventManager.checkRowResize(eventArgsSet) ? table.stateManager.select && eventManager.checkCellFillhandle(eventArgsSet) ? stateManager.updateCursor("crosshair") : stateManager.updateCursor("row-resize") : stateManager.isMoveCol() || stateManager.updateCursor();
+        null !== (_c = null === (_b = null === (_a = e.target) || void 0 === _a ? void 0 : _a.isDescendantsOf) || void 0 === _b ? void 0 : _b.call(_a, table.scenegraph.tableGroup)) && void 0 !== _c && _c && (stateManager.isResizeCol() || eventManager.checkColumnResize(eventArgsSet) ? table.stateManager.select && eventManager.checkCellFillhandle(eventArgsSet) ? stateManager.updateCursor("crosshair") : stateManager.updateCursor("col-resize") : stateManager.isResizeRow() || eventManager.checkRowResize(eventArgsSet) ? table.stateManager.select && eventManager.checkCellFillhandle(eventArgsSet) ? stateManager.updateCursor("crosshair") : stateManager.updateCursor("row-resize") : stateManager.isMoveCol() || stateManager.updateCursor());
       }), table.scenegraph.tableGroup.addEventListener("checkbox_state_change", e => {
         var _a, _b;
         const eventArgsSet = getCellEventArgsSet(e),
@@ -58351,7 +58788,7 @@
       }
       constructor(container, options = {}) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
-        if (super(), this.showFrozenIcon = !0, this.version = "1.21.1-alpha.0", this.id = `VTable${Date.now()}`, this.isReleased = !1, this._chartEventMap = {}, this.throttleInvalidate = throttle2(this.render.bind(this), 200), "node" === Env$1.mode ? (options = container, container = null) : container instanceof HTMLElement || (options = container, container = container.container ? container.container : null), !container && "node" !== options.mode && !options.canvas) throw new Error("vtable's container is undefined");
+        if (super(), this.showFrozenIcon = !0, this.version = "1.22.0", this.id = `VTable${Date.now()}`, this.isReleased = !1, this._chartEventMap = {}, this.throttleInvalidate = throttle2(this.render.bind(this), 200), "node" === Env$1.mode ? (options = container, container = null) : container instanceof HTMLElement || (options = container, container = container.container ? container.container : null), !container && "node" !== options.mode && !options.canvas) throw new Error("vtable's container is undefined");
         this.pluginManager = new PluginManager(this, options), this.fireListeners(TABLE_EVENT_TYPE.BEFORE_INIT, {
           options: options,
           container: container
@@ -63006,140 +63443,152 @@
     }
     function listTableAddRecord(record, recordIndex, table) {
       var _a, _b, _c, _d;
-      if (table.internalProps.groupBy) null === (_b = (_a = table.dataSource).addRecordsForGroup) || void 0 === _b || _b.call(_a, [record], recordIndex), table.refreshRowColCount(), table.internalProps.layoutMap.clearCellRangeMap(), table.sortState && sortRecords(table), table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else if ("tree" === table.dataSource.rowHierarchyType) null === (_d = (_c = table.dataSource).addRecordsForTree) || void 0 === _d || _d.call(_c, [record], recordIndex), adjustCheckBoxStateMapWithAddRecordIndex(table, recordIndex, 1), table.refreshRowColCount(), table.internalProps.layoutMap.clearCellRangeMap(), table.sortState && sortRecords(table), table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else if (table.sortState) table.dataSource.addRecordForSorted(record), table.stateManager.checkedState.clear(), sortRecords(table), table.refreshRowColCount(), table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else {
-        (void 0 === recordIndex || recordIndex > table.dataSource.sourceLength) && (recordIndex = table.dataSource.sourceLength);
-        const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
-        table.dataSource.addRecord(record, recordIndex), adjustCheckBoxStateMapWithAddRecordIndex(table, recordIndex, 1);
-        const oldRowCount = table.rowCount;
-        if (table.refreshRowColCount(), 0 === table.scenegraph.proxy.totalActualBodyRowCount) return table.scenegraph.clearCells(), void table.scenegraph.createSceneGraph();
-        const newRowCount = table.transpose ? table.colCount : table.rowCount;
-        if (table.pagination) {
-          const {
-              perPageCount: perPageCount,
-              currentPage: currentPage
-            } = table.pagination,
-            endIndex = perPageCount * (currentPage || 0) + perPageCount;
-          if (recordIndex < endIndex) if (recordIndex < endIndex - perPageCount) table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else {
-            const rowNum = recordIndex - (endIndex - perPageCount) + headerCount;
-            if (oldRowCount - headerCount === table.pagination.perPageCount) {
-              const updateRows = [];
-              for (let row = rowNum; row < newRowCount; row++) table.transpose ? updateRows.push({
-                col: row,
-                row: 0
-              }) : updateRows.push({
-                col: 0,
-                row: row
-              });
-              table.transpose ? table.scenegraph.updateCol([], [], updateRows) : table.scenegraph.updateRow([], [], updateRows);
-            } else {
-              const addRows = [];
-              for (let row = rowNum; row < Math.min(newRowCount, rowNum + 1); row++) table.transpose ? addRows.push({
-                col: row,
-                row: 0
-              }) : addRows.push({
-                col: 0,
-                row: row
-              });
-              table.transpose ? table.scenegraph.updateCol([], addRows, []) : table.scenegraph.updateRow([], addRows, []);
+      try {
+        if (!record) return !1;
+        if (table.internalProps.groupBy) null === (_b = (_a = table.dataSource).addRecordsForGroup) || void 0 === _b || _b.call(_a, [record], recordIndex), table.refreshRowColCount(), table.internalProps.layoutMap.clearCellRangeMap(), table.sortState && sortRecords(table), table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else if ("tree" === table.dataSource.rowHierarchyType) null === (_d = (_c = table.dataSource).addRecordsForTree) || void 0 === _d || _d.call(_c, [record], recordIndex), adjustCheckBoxStateMapWithAddRecordIndex(table, recordIndex, 1), table.refreshRowColCount(), table.internalProps.layoutMap.clearCellRangeMap(), table.sortState && sortRecords(table), table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else if (table.sortState) table.dataSource.addRecordForSorted(record), table.stateManager.checkedState.clear(), sortRecords(table), table.refreshRowColCount(), table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else {
+          (void 0 === recordIndex || recordIndex > table.dataSource.sourceLength) && (recordIndex = table.dataSource.sourceLength);
+          const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
+          table.dataSource.addRecord(record, recordIndex), adjustCheckBoxStateMapWithAddRecordIndex(table, recordIndex, 1);
+          const oldRowCount = table.rowCount;
+          if (table.refreshRowColCount(), 0 === table.scenegraph.proxy.totalActualBodyRowCount) return table.scenegraph.clearCells(), table.scenegraph.createSceneGraph(), !0;
+          const newRowCount = table.transpose ? table.colCount : table.rowCount;
+          if (table.pagination) {
+            const {
+                perPageCount: perPageCount,
+                currentPage: currentPage
+              } = table.pagination,
+              endIndex = perPageCount * (currentPage || 0) + perPageCount;
+            if (recordIndex < endIndex) if (recordIndex < endIndex - perPageCount) table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else {
+              const rowNum = recordIndex - (endIndex - perPageCount) + headerCount;
+              if (oldRowCount - headerCount === table.pagination.perPageCount) {
+                const updateRows = [];
+                for (let row = rowNum; row < newRowCount; row++) table.transpose ? updateRows.push({
+                  col: row,
+                  row: 0
+                }) : updateRows.push({
+                  col: 0,
+                  row: row
+                });
+                table.transpose ? table.scenegraph.updateCol([], [], updateRows) : table.scenegraph.updateRow([], [], updateRows);
+              } else {
+                const addRows = [];
+                for (let row = rowNum; row < Math.min(newRowCount, rowNum + 1); row++) table.transpose ? addRows.push({
+                  col: row,
+                  row: 0
+                }) : addRows.push({
+                  col: 0,
+                  row: row
+                });
+                table.transpose ? table.scenegraph.updateCol([], addRows, []) : table.scenegraph.updateRow([], addRows, []);
+              }
             }
+          } else {
+            const addRows = [];
+            for (let row = recordIndex + headerCount; row < recordIndex + headerCount + 1; row++) table.transpose ? addRows.push({
+              col: row,
+              row: 0
+            }) : addRows.push({
+              col: 0,
+              row: row
+            });
+            const updateRows = [],
+              topAggregationCount = table.internalProps.layoutMap.hasAggregationOnTopCount,
+              bottomAggregationCount = table.internalProps.layoutMap.hasAggregationOnBottomCount;
+            for (let row = headerCount; row < headerCount + topAggregationCount; row++) table.transpose ? updateRows.push({
+              col: row,
+              row: 0
+            }) : updateRows.push({
+              col: 0,
+              row: row
+            });
+            for (let row = (table.transpose ? table.colCount : table.rowCount) - bottomAggregationCount; row < (table.transpose ? table.colCount : table.rowCount); row++) table.transpose ? updateRows.push({
+              col: row,
+              row: 0
+            }) : updateRows.push({
+              col: 0,
+              row: row
+            });
+            table.transpose ? table.scenegraph.updateCol([], addRows, []) : table.scenegraph.updateRow([], addRows, []);
           }
-        } else {
-          const addRows = [];
-          for (let row = recordIndex + headerCount; row < recordIndex + headerCount + 1; row++) table.transpose ? addRows.push({
-            col: row,
-            row: 0
-          }) : addRows.push({
-            col: 0,
-            row: row
-          });
-          const updateRows = [],
-            topAggregationCount = table.internalProps.layoutMap.hasAggregationOnTopCount,
-            bottomAggregationCount = table.internalProps.layoutMap.hasAggregationOnBottomCount;
-          for (let row = headerCount; row < headerCount + topAggregationCount; row++) table.transpose ? updateRows.push({
-            col: row,
-            row: 0
-          }) : updateRows.push({
-            col: 0,
-            row: row
-          });
-          for (let row = (table.transpose ? table.colCount : table.rowCount) - bottomAggregationCount; row < (table.transpose ? table.colCount : table.rowCount); row++) table.transpose ? updateRows.push({
-            col: row,
-            row: 0
-          }) : updateRows.push({
-            col: 0,
-            row: row
-          });
-          table.transpose ? table.scenegraph.updateCol([], addRows, []) : table.scenegraph.updateRow([], addRows, []);
         }
+        return !0;
+      } catch (error) {
+        return !1;
       }
     }
     function listTableAddRecords(records, recordIndex, table) {
       var _a, _b, _c, _d;
-      if (table.internalProps.groupBy) null === (_b = (_a = table.dataSource).addRecordsForGroup) || void 0 === _b || _b.call(_a, records, recordIndex), table.refreshRowColCount(), table.internalProps.layoutMap.clearCellRangeMap(), table.sortState && sortRecords(table), table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else if ("tree" === table.dataSource.rowHierarchyType) null === (_d = (_c = table.dataSource).addRecordsForTree) || void 0 === _d || _d.call(_c, records, recordIndex), adjustCheckBoxStateMapWithAddRecordIndex(table, recordIndex, records.length), table.refreshRowColCount(), table.internalProps.layoutMap.clearCellRangeMap(), table.sortState && sortRecords(table), table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else if (table.sortState) table.dataSource.addRecordsForSorted(records), sortRecords(table), table.refreshRowColCount(), table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else {
-        void 0 === recordIndex || recordIndex > table.dataSource.sourceLength ? recordIndex = table.dataSource.sourceLength : recordIndex < 0 && (recordIndex = 0);
-        const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
-        table.dataSource.addRecords(records, recordIndex), adjustCheckBoxStateMapWithAddRecordIndex(table, recordIndex, records.length);
-        const oldRowCount = table.transpose ? table.colCount : table.rowCount;
-        if (table.refreshRowColCount(), 0 === table.scenegraph.proxy.totalActualBodyRowCount) return table.scenegraph.clearCells(), void table.scenegraph.createSceneGraph();
-        const newRowCount = table.transpose ? table.colCount : table.rowCount;
-        if (table.pagination) {
-          const {
-              perPageCount: perPageCount,
-              currentPage: currentPage
-            } = table.pagination,
-            endIndex = perPageCount * (currentPage || 0) + perPageCount;
-          if (recordIndex < endIndex) if (recordIndex < endIndex - perPageCount) table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else {
-            const rowNum = recordIndex - (endIndex - perPageCount) + headerCount;
-            if (oldRowCount - headerCount === table.pagination.perPageCount) {
-              const updateRows = [];
-              for (let row = rowNum; row < newRowCount; row++) table.transpose ? updateRows.push({
-                col: row,
-                row: 0
-              }) : updateRows.push({
-                col: 0,
-                row: row
-              });
-              table.transpose ? table.scenegraph.updateCol([], [], updateRows) : table.scenegraph.updateRow([], [], updateRows);
-            } else {
-              const addRows = [];
-              for (let row = rowNum; row < Math.min(newRowCount, rowNum + (Array.isArray(records) ? records.length : 1)); row++) table.transpose ? addRows.push({
-                col: row,
-                row: 0
-              }) : addRows.push({
-                col: 0,
-                row: row
-              });
-              table.transpose ? table.scenegraph.updateCol([], addRows, []) : table.scenegraph.updateRow([], addRows, []);
+      try {
+        if (!records || 0 === records.length) return !1;
+        if (table.internalProps.groupBy) null === (_b = (_a = table.dataSource).addRecordsForGroup) || void 0 === _b || _b.call(_a, records, recordIndex), table.refreshRowColCount(), table.internalProps.layoutMap.clearCellRangeMap(), table.sortState && sortRecords(table), table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else if ("tree" === table.dataSource.rowHierarchyType) null === (_d = (_c = table.dataSource).addRecordsForTree) || void 0 === _d || _d.call(_c, records, recordIndex), adjustCheckBoxStateMapWithAddRecordIndex(table, recordIndex, records.length), table.refreshRowColCount(), table.internalProps.layoutMap.clearCellRangeMap(), table.sortState && sortRecords(table), table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else if (table.sortState) table.dataSource.addRecordsForSorted(records), sortRecords(table), table.refreshRowColCount(), table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else {
+          void 0 === recordIndex || recordIndex > table.dataSource.sourceLength ? recordIndex = table.dataSource.sourceLength : recordIndex < 0 && (recordIndex = 0);
+          const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
+          table.dataSource.addRecords(records, recordIndex), adjustCheckBoxStateMapWithAddRecordIndex(table, recordIndex, records.length);
+          const oldRowCount = table.transpose ? table.colCount : table.rowCount;
+          if (table.refreshRowColCount(), 0 === table.scenegraph.proxy.totalActualBodyRowCount) return table.scenegraph.clearCells(), table.scenegraph.createSceneGraph(), !0;
+          const newRowCount = table.transpose ? table.colCount : table.rowCount;
+          if (table.pagination) {
+            const {
+                perPageCount: perPageCount,
+                currentPage: currentPage
+              } = table.pagination,
+              endIndex = perPageCount * (currentPage || 0) + perPageCount;
+            if (recordIndex < endIndex) if (recordIndex < endIndex - perPageCount) table.scenegraph.clearCells(), table.scenegraph.createSceneGraph();else {
+              const rowNum = recordIndex - (endIndex - perPageCount) + headerCount;
+              if (oldRowCount - headerCount === table.pagination.perPageCount) {
+                const updateRows = [];
+                for (let row = rowNum; row < newRowCount; row++) table.transpose ? updateRows.push({
+                  col: row,
+                  row: 0
+                }) : updateRows.push({
+                  col: 0,
+                  row: row
+                });
+                table.transpose ? table.scenegraph.updateCol([], [], updateRows) : table.scenegraph.updateRow([], [], updateRows);
+              } else {
+                const addRows = [];
+                for (let row = rowNum; row < Math.min(newRowCount, rowNum + (Array.isArray(records) ? records.length : 1)); row++) table.transpose ? addRows.push({
+                  col: row,
+                  row: 0
+                }) : addRows.push({
+                  col: 0,
+                  row: row
+                });
+                table.transpose ? table.scenegraph.updateCol([], addRows, []) : table.scenegraph.updateRow([], addRows, []);
+              }
             }
+          } else {
+            const addRows = [];
+            for (let row = recordIndex + headerCount; row < recordIndex + headerCount + (Array.isArray(records) ? records.length : 1); row++) table.transpose ? addRows.push({
+              col: row,
+              row: 0
+            }) : addRows.push({
+              col: 0,
+              row: row
+            });
+            const topAggregationCount = table.internalProps.layoutMap.hasAggregationOnTopCount,
+              bottomAggregationCount = table.internalProps.layoutMap.hasAggregationOnBottomCount,
+              updateRows = [];
+            for (let row = headerCount; row < headerCount + topAggregationCount; row++) table.transpose ? updateRows.push({
+              col: row,
+              row: 0
+            }) : updateRows.push({
+              col: 0,
+              row: row
+            });
+            for (let row = (table.transpose ? table.colCount : table.rowCount) - bottomAggregationCount; row < (table.transpose ? table.colCount : table.rowCount); row++) table.transpose ? updateRows.push({
+              col: row,
+              row: 0
+            }) : updateRows.push({
+              col: 0,
+              row: row
+            });
+            table.transpose ? table.scenegraph.updateCol([], addRows, updateRows) : table.scenegraph.updateRow([], addRows, updateRows);
           }
-        } else {
-          const addRows = [];
-          for (let row = recordIndex + headerCount; row < recordIndex + headerCount + (Array.isArray(records) ? records.length : 1); row++) table.transpose ? addRows.push({
-            col: row,
-            row: 0
-          }) : addRows.push({
-            col: 0,
-            row: row
-          });
-          const topAggregationCount = table.internalProps.layoutMap.hasAggregationOnTopCount,
-            bottomAggregationCount = table.internalProps.layoutMap.hasAggregationOnBottomCount,
-            updateRows = [];
-          for (let row = headerCount; row < headerCount + topAggregationCount; row++) table.transpose ? updateRows.push({
-            col: row,
-            row: 0
-          }) : updateRows.push({
-            col: 0,
-            row: row
-          });
-          for (let row = (table.transpose ? table.colCount : table.rowCount) - bottomAggregationCount; row < (table.transpose ? table.colCount : table.rowCount); row++) table.transpose ? updateRows.push({
-            col: row,
-            row: 0
-          }) : updateRows.push({
-            col: 0,
-            row: row
-          });
-          table.transpose ? table.scenegraph.updateCol([], addRows, updateRows) : table.scenegraph.updateRow([], addRows, updateRows);
         }
+        return !0;
+      } catch (error) {
+        return !1;
       }
     }
     function listTableDeleteRecords(recordIndexs, table) {
@@ -63549,21 +63998,33 @@
         };
         this._hasAutoImageColumn = void 0, this.refreshHeader(), this.records && checkHasAggregationOnColumnDefine(this.internalProps.columns) && this.dataSource.processRecords(null !== (_b = null === (_a = this.dataSource.dataSourceObj) || void 0 === _a ? void 0 : _a.records) && void 0 !== _b ? _b : this.dataSource.dataSourceObj), this.internalProps.useOneRowHeightFillAll = !1, this.headerStyleCache = new Map(), this.bodyStyleCache = new Map(), this.bodyBottomStyleCache = new Map(), this._updateSize(), this.scenegraph.createSceneGraph(), this.stateManager.updateHoverPos(oldHoverState.col, oldHoverState.row), this.renderAsync(), this.eventManager.updateEventBinder();
       }
-      addColumn(column, colIndex, isMaintainArrayData = !0) {
+      addColumns(toAddColumns, colIndex, isMaintainArrayData = !0) {
         const columns = this.options.columns;
-        if (void 0 === colIndex) columns.push(column);else {
-          if (isMaintainArrayData) for (let i = 0; i < columns.length; i++) "number" == typeof columns[i].field && columns[i].field >= colIndex && (columns[i].field = columns[i].field + 1);
-          columns.splice(colIndex, 0, column);
-        }
-        if (isMaintainArrayData) for (let i = 0; i < this.records.length; i++) {
-          const record = this.records[i];
-          Array.isArray(record) && record.splice(colIndex, 0, void 0);
+        if (void 0 === colIndex ? (colIndex = columns.length, columns.push(...toAddColumns)) : columns.splice(colIndex, 0, ...toAddColumns), isMaintainArrayData) {
+          for (let i = 0; i < columns.length; i++) columns[i].field = i;
+          for (let i = 0; i < this.records.length; i++) {
+            const record = this.records[i];
+            Array.isArray(record) && record.splice(colIndex, 0, ...Array(toAddColumns.length).fill(void 0));
+          }
         }
-        this.updateColumns(columns);
+        this.updateColumns(columns), this.fireListeners(TABLE_EVENT_TYPE.ADD_COLUMN, {
+          columnIndex: colIndex,
+          columnCount: toAddColumns.length,
+          columns: columns
+        });
       }
-      deleteColumn(colIndex) {
+      deleteColumns(deleteColIndexs, isMaintainArrayData = !0) {
         const columns = this.options.columns;
-        columns.splice(colIndex, 1), this.updateColumns(columns);
+        deleteColIndexs.sort((a, b) => b - a);
+        for (let i = 0; i < deleteColIndexs.length; i++) if (columns.splice(deleteColIndexs[i], 1), isMaintainArrayData) for (let j = 0; j < this.records.length; j++) {
+          const record = this.records[j];
+          Array.isArray(record) && record.splice(deleteColIndexs[i], 1);
+        }
+        if (isMaintainArrayData) for (let i = 0; i < columns.length; i++) columns[i].field = i;
+        this.updateColumns(columns), this.fireListeners(TABLE_EVENT_TYPE.DELETE_COLUMN, {
+          deleteColIndexs: deleteColIndexs,
+          columns: columns
+        });
       }
       get columns() {
         return this.internalProps.layoutMap.columnTree.getCopiedTree();
@@ -63965,6 +64426,9 @@
       updateFilterRules(filterRules) {
         this.scenegraph.clearCells(), this.sortState ? (this.dataSource.updateFilterRulesForSorted(filterRules), sortRecords(this)) : this.dataSource.updateFilterRules(filterRules), this.refreshRowColCount(), this.stateManager.initCheckedState(this.records), this.scenegraph.createSceneGraph(), this.resize();
       }
+      getFilteredRecords() {
+        return this.dataSource.records;
+      }
       getCheckboxState(field) {
         if (this.stateManager.checkedState.size < this.rowCount - this.columnHeaderLevelCount && this.stateManager.initLeftRecordsCheckState(this.records), isValid$4(field)) {
           let stateArr = Array.from(this.stateManager.checkedState.keys()).sort((a, b) => {
@@ -64104,18 +64568,39 @@
       }
       addRecord(record, recordIndex) {
         var _a;
-        listTableAddRecord(record, recordIndex, this), null === (_a = this.internalProps.emptyTip) || void 0 === _a || _a.resetVisible();
+        const success = listTableAddRecord(record, recordIndex, this);
+        null === (_a = this.internalProps.emptyTip) || void 0 === _a || _a.resetVisible(), success && this.fireListeners(TABLE_EVENT_TYPE.ADD_RECORD, {
+          records: [record],
+          recordIndex: recordIndex,
+          recordCount: 1
+        });
       }
       addRecords(records, recordIndex) {
         var _a;
-        listTableAddRecords(records, recordIndex, this), null === (_a = this.internalProps.emptyTip) || void 0 === _a || _a.resetVisible();
+        const success = listTableAddRecords(records, recordIndex, this);
+        null === (_a = this.internalProps.emptyTip) || void 0 === _a || _a.resetVisible(), success && this.fireListeners(TABLE_EVENT_TYPE.ADD_RECORD, {
+          records: records,
+          recordIndex: recordIndex,
+          recordCount: records.length
+        });
       }
       deleteRecords(recordIndexs) {
         var _a;
         listTableDeleteRecords(recordIndexs, this), null === (_a = this.internalProps.emptyTip) || void 0 === _a || _a.resetVisible();
+        const rowIndexs = [];
+        for (let i = 0; i < recordIndexs.length; i++) rowIndexs.push(this.getBodyRowIndexByRecordIndex(recordIndexs[i]) + this.columnHeaderLevelCount);
+        this.fireListeners(TABLE_EVENT_TYPE.DELETE_RECORD, {
+          recordIndexs: recordIndexs,
+          rowIndexs: rowIndexs,
+          deletedCount: (Array.isArray(recordIndexs[0]), recordIndexs.length)
+        });
       }
       updateRecords(records, recordIndexs) {
-        listTableUpdateRecords(records, recordIndexs, this);
+        listTableUpdateRecords(records, recordIndexs, this), this.fireListeners(TABLE_EVENT_TYPE.UPDATE_RECORD, {
+          records: records,
+          recordIndexs: recordIndexs,
+          updateCount: records.length
+        });
       }
       _hasCustomRenderOrLayout() {
         var _a, _b, _c, _d;
@@ -68329,7 +68814,7 @@
     }
 
     function createProgressBarCell(progressBarDefine, style, width, value, dataValue, col, row, padding, table, range) {
-      var _a, _b, _c, _d, _e;
+      var _a, _b, _c, _d, _e, _f;
       if (progressBarDefine.dependField) {
         const dependField = getOrApply(progressBarDefine.dependField, {
           col: col,
@@ -68366,7 +68851,14 @@
           cellHeaderPaths: void 0
         })) && void 0 !== _e ? _e : min + 100;
       let height = 0;
-      height = range ? table.getRowsHeight(range.start.row, range.end.row) : table.getRowHeight(row);
+      if (height = range ? table.getRowsHeight(range.start.row, range.end.row) : table.getRowHeight(row), table.pluginManager) {
+        if (table.pluginManager.getPluginByName("Master Detail Plugin")) {
+          const bodyRowIndex = row - table.columnHeaderLevelCount,
+            internalProps = table.internalProps,
+            originalHeight = null === (_f = null == internalProps ? void 0 : internalProps.originalRowHeights) || void 0 === _f ? void 0 : _f.get(bodyRowIndex);
+          void 0 !== originalHeight && originalHeight > 0 && (height = originalHeight);
+        }
+      }
       let contentWidth = width,
         contentHeight = height,
         _contentOffset = 0;
@@ -69150,11 +69642,11 @@
           const isLeft = "left" === this.addIconForAddColumn.dataset.addIconType,
             col = (this.table.options.columns, this.hoverCell.col),
             addColIndex = isLeft ? col : col + 1;
-          this.pluginOptions.addColumnCallback ? this.pluginOptions.addColumnCallback(addColIndex, this.table) : this.table.addColumn({
+          this.pluginOptions.addColumnCallback ? this.pluginOptions.addColumnCallback(addColIndex, this.table) : this.table.addColumns([{
             field: addColIndex,
             title: `New Column ${col}`,
             width: 100
-          }, addColIndex, !0), this.delayHideAllForAddColumn(0);
+          }], addColIndex, !0), this.delayHideAllForAddColumn(0);
         });
       }
       showDotForAddColumn(top, left, right, isShowLeft = !0, isShowRight = !0) {
@@ -70852,14 +71344,22 @@
         if (void 0 !== rowIndex && "function" == typeof table.addRecord) for (let i = 0; i < count; i++) table.addRecord([], rowIndex + i);
       }
       handleInsertColumnLeft(table, colIndex, count = 1) {
-        if (void 0 !== colIndex && "function" == typeof table.addColumn) for (let i = 0; i < count; i++) table.addColumn({
-          field: colIndex
-        }, colIndex, !0);
+        if (void 0 !== colIndex && "function" == typeof table.addColumns) {
+          const toAddColumns = [];
+          for (let i = 0; i < count; i++) toAddColumns.push({
+            field: colIndex - i
+          });
+          table.addColumns(toAddColumns, colIndex, !0);
+        }
       }
       handleInsertColumnRight(table, colIndex, count = 1) {
-        if (void 0 !== colIndex && "function" == typeof table.addColumn) for (let i = 0; i < count; i++) table.addColumn({
-          field: colIndex + 1
-        }, colIndex + 1, !0);
+        if (void 0 !== colIndex && "function" == typeof table.addColumns) {
+          const toAddColumns = [];
+          for (let i = 0; i < count; i++) toAddColumns.push({
+            field: colIndex + 1
+          });
+          table.addColumns(toAddColumns, colIndex + 1, !0);
+        }
       }
       handleDeleteRow(table, rowIndex) {
         if (void 0 !== rowIndex && "function" == typeof table.deleteRecords) {
@@ -70877,15 +71377,14 @@
         }
       }
       handleDeleteColumn(table, colIndex) {
-        if (void 0 !== colIndex && "function" == typeof table.deleteColumn) {
+        if (void 0 !== colIndex && "function" == typeof table.deleteColumns) {
           const selectRanges = table.stateManager.select.ranges,
             deleteColIndexs = [];
           for (let i = 0; i < selectRanges.length; i++) {
             const range = selectRanges[i];
             for (let j = range.start.col; j <= range.end.col; j++) deleteColIndexs.includes(j) || deleteColIndexs.push(j);
           }
-          deleteColIndexs.sort((a, b) => b - a);
-          for (let i = 0; i < deleteColIndexs.length; i++) table.deleteColumn(deleteColIndexs[i]);
+          table.deleteColumns(deleteColIndexs, !0);
         }
       }
       handleHideColumn(table, colIndex) {
@@ -75222,7 +75721,7 @@
                                     return cell;
                                 }
                                 const num = Number(cell);
-                                return !isNaN(num) ? num : cell;
+                                return !isNaN(num) && cell.trim() !== '' ? num : cell;
                             }
                             return cell ?? '';
                         })
@@ -75355,17 +75854,81 @@
                 throw new Error('Batch update failed');
             }
         }
-        addRows(_sheetKey, rowIndex, numberOfRows = 1) {
+        addRows(sheetKey, rowIndex, numberOfRows = 1) {
             this.ensureInitialized();
+            try {
+                const { adjustedCells, movedCells } = this.formulaEngine.adjustFormulaReferences(sheetKey, 'insert', 'row', rowIndex, numberOfRows, this.sheet.getSheet(sheetKey).columnCount, this.sheet.getSheet(sheetKey).rowCount);
+                [...adjustedCells, ...movedCells].forEach(cell => {
+                    const result = this.sheet.formulaManager.getCellValue({
+                        sheet: sheetKey,
+                        row: cell.row,
+                        col: cell.col
+                    });
+                    this.sheet
+                        .getActiveSheet()
+                        .tableInstance?.changeCellValue(cell.col, cell.row, result.error ? '#ERROR!' : result.value);
+                });
+            }
+            catch (error) {
+                throw new Error(`Failed to add ${numberOfRows} rows at index ${rowIndex}`);
+            }
         }
-        removeRows(_sheetKey, rowIndex, numberOfRows = 1) {
+        removeRows(sheetKey, rowIndex, numberOfRows = 1) {
             this.ensureInitialized();
+            try {
+                const { adjustedCells, movedCells } = this.formulaEngine.adjustFormulaReferences(sheetKey, 'delete', 'row', rowIndex, numberOfRows, this.sheet.getSheet(sheetKey).columnCount, this.sheet.getSheet(sheetKey).rowCount);
+                [...adjustedCells, ...movedCells].forEach(cell => {
+                    const result = this.sheet.formulaManager.getCellValue({
+                        sheet: sheetKey,
+                        row: cell.row,
+                        col: cell.col
+                    });
+                    this.sheet
+                        .getActiveSheet()
+                        .tableInstance?.changeCellValue(cell.col, cell.row, result.error ? '#ERROR!' : result.value);
+                });
+            }
+            catch (error) {
+                throw new Error(`Failed to remove ${numberOfRows} rows at index ${rowIndex}`);
+            }
         }
-        addColumns(_sheetKey, columnIndex, numberOfColumns = 1) {
+        addColumns(sheetKey, columnIndex, numberOfColumns = 1) {
             this.ensureInitialized();
+            try {
+                const { adjustedCells, movedCells } = this.formulaEngine.adjustFormulaReferences(sheetKey, 'insert', 'column', columnIndex, numberOfColumns, this.sheet.getSheet(sheetKey).columnCount, this.sheet.getSheet(sheetKey).rowCount);
+                [...adjustedCells, ...movedCells].forEach(cell => {
+                    const result = this.sheet.formulaManager.getCellValue({
+                        sheet: sheetKey,
+                        row: cell.row,
+                        col: cell.col
+                    });
+                    this.sheet
+                        .getActiveSheet()
+                        .tableInstance?.changeCellValue(cell.col, cell.row, result.error ? '#ERROR!' : result.value);
+                });
+            }
+            catch (error) {
+                throw new Error(`Failed to add ${numberOfColumns} columns at index ${columnIndex}`);
+            }
         }
-        removeColumns(_sheetKey, columnIndex, numberOfColumns = 1) {
+        removeColumns(sheetKey, columnIndex, numberOfColumns = 1) {
             this.ensureInitialized();
+            try {
+                const { adjustedCells, movedCells } = this.formulaEngine.adjustFormulaReferences(sheetKey, 'delete', 'column', columnIndex, numberOfColumns, this.sheet.getSheet(sheetKey).columnCount, this.sheet.getSheet(sheetKey).rowCount);
+                [...adjustedCells, ...movedCells].forEach(cell => {
+                    const result = this.sheet.formulaManager.getCellValue({
+                        sheet: sheetKey,
+                        row: cell.row,
+                        col: cell.col
+                    });
+                    this.sheet
+                        .getActiveSheet()
+                        .tableInstance?.changeCellValue(cell.col, cell.row, result.error ? '#ERROR!' : result.value);
+                });
+            }
+            catch (error) {
+                throw new Error(`Failed to remove ${numberOfColumns} columns at index ${columnIndex}`);
+            }
         }
         getSheetSerialized(sheetKey) {
             this.ensureInitialized();
@@ -75384,9 +75947,6 @@
                 return Object.entries(formulas);
             }
         }
-        setSheetContent(sheetKey, _normalizedData) {
-            this.ensureInitialized();
-        }
         hasCircularReference() {
             try {
                 return false;
@@ -76020,6 +76580,18 @@
                 this.tableInstance.on('change_cell_value', (event) => {
                     this.handleCellValueChanged(event);
                 });
+                this.tableInstance.on('add_record', (event) => {
+                    this.handleDataRecordsChanged('add', event);
+                });
+                this.tableInstance.on('delete_record', (event) => {
+                    this.handleDataRecordsChanged('delete', event);
+                });
+                this.tableInstance.on('add_column', (event) => {
+                    this.handleColumnsChanged('add', event);
+                });
+                this.tableInstance.on('delete_column', (event) => {
+                    this.handleColumnsChanged('delete', event);
+                });
                 this.tableInstance.on('click_cell', () => {
                     this.element.classList.add('vtable-excel-cursor');
                 });
@@ -76090,6 +76662,59 @@
             };
             this.fire(WorkSheetEventType.CELL_VALUE_CHANGED, cellValueChangedEvent);
         }
+        handleDataRecordsChanged(type, event) {
+            try {
+                const sheetKey = this.getKey();
+                const normalizedData = this.vtableSheet.formulaManager.normalizeSheetData(this.tableInstance.records, this.tableInstance);
+                this.vtableSheet.formulaManager.formulaEngine.updateSheetData(sheetKey, normalizedData);
+                if (type === 'add') {
+                    const { recordIndex, recordCount } = event;
+                    if (recordIndex !== undefined && recordCount > 0) {
+                        this.vtableSheet.formulaManager.addRows(sheetKey, recordIndex, recordCount);
+                    }
+                    else {
+                        const currentRowCount = this.getRowCount();
+                        this.vtableSheet.formulaManager.addRows(sheetKey, currentRowCount, recordCount);
+                    }
+                }
+                else if (type === 'delete') {
+                    const { rowIndexs, deletedCount } = event;
+                    if (rowIndexs && rowIndexs.length > 0) {
+                        const minIndex = Math.min(...rowIndexs.flat());
+                        this.vtableSheet.formulaManager.removeRows(sheetKey, minIndex, deletedCount);
+                    }
+                }
+            }
+            catch (error) {
+            }
+        }
+        handleColumnsChanged(type, event) {
+            try {
+                const sheetKey = this.getKey();
+                const normalizedData = this.vtableSheet.formulaManager.normalizeSheetData(this.tableInstance.records, this.tableInstance);
+                this.vtableSheet.formulaManager.formulaEngine.updateSheetData(sheetKey, normalizedData);
+                if (type === 'add') {
+                    const { columnIndex, columnCount } = event;
+                    if (columnIndex !== undefined && columnCount > 0) {
+                        this.vtableSheet.formulaManager.addColumns(sheetKey, columnIndex, columnCount);
+                    }
+                    else {
+                        const currentColumnCount = this.getColumnCount();
+                        this.vtableSheet.formulaManager.addColumns(sheetKey, currentColumnCount, columnCount);
+                    }
+                }
+                else if (type === 'delete') {
+                    const { deleteColIndexs } = event;
+                    if (deleteColIndexs && deleteColIndexs.length > 0) {
+                        const minIndex = Math.min(...deleteColIndexs.flat());
+                        const deletedCount = deleteColIndexs.length;
+                        this.vtableSheet.formulaManager.removeColumns(sheetKey, minIndex, deletedCount);
+                    }
+                }
+            }
+            catch (error) {
+            }
+        }
         fireEvent(eventName, eventData) {
             this.fire(eventName, eventData);
         }
@@ -76159,22 +76784,6 @@
         getCopiedData() {
             return this.getData().map(row => (Array.isArray(row) ? row.slice() : []));
         }
-        setData(data) {
-            this.options.data = data;
-            if (this.tableInstance) {
-                this.tableInstance.updateOption({
-                    records: data
-                });
-                if (this.vtableSheet?.formulaManager) {
-                    try {
-                        const normalizedData = this.vtableSheet.formulaManager.normalizeSheetData(data, this.tableInstance);
-                        this.vtableSheet.formulaManager.setSheetContent(this.sheetKey, normalizedData);
-                    }
-                    catch (e) {
-                    }
-                }
-            }
-        }
         getCellValue(row, col) {
             if (this.tableInstance) {
                 try {
@@ -79161,7 +79770,7 @@
         importStyle();
     }
 
-    const version = "1.21.1-alpha.0";
+    const version = "1.22.0";
     importStyles();
 
     exports.TYPES = index;