@visactor/vtable 1.22.11-alpha.7 → 1.22.11-alpha.8

package/dist/vtable.js

@@ -36018,6 +36018,47 @@
             }
         };
     }
+    function cancellableThrottle(func, delay) {
+        let timer = null;
+        let lastArgs = null;
+        let context = null;
+        const throttled = function (...args) {
+            lastArgs = args;
+            context = this;
+            if (!timer) {
+                timer = setTimeout(() => {
+                    if (lastArgs) {
+                        func.apply(context, lastArgs);
+                    }
+                    timer = null;
+                    lastArgs = null;
+                    context = null;
+                }, delay);
+            }
+        };
+        const cancel = () => {
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+                lastArgs = null;
+                context = null;
+            }
+        };
+        const flush = () => {
+            if (timer && lastArgs) {
+                clearTimeout(timer);
+                func.apply(context, lastArgs);
+                timer = null;
+                lastArgs = null;
+                context = null;
+            }
+        };
+        return {
+            throttled,
+            cancel,
+            flush
+        };
+    }
     function pad(num, totalChars) {
         const pad = '0';
         num = `${num}`;
@@ -36410,7 +36451,6 @@
         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',
-        CHANGE_CELL_VALUES: 'change_cell_values',
         DRAG_FILL_HANDLE_END: 'drag_fill_handle_end',
         MOUSEDOWN_FILL_HANDLE: 'mousedown_fill_handle',
         DBLCLICK_FILL_HANDLE: 'dblclick_fill_handle',
@@ -38933,48 +38973,6 @@
                 }
             }
         }
-        changeFieldValueByRecordIndex(value, recordIndex, field, table) {
-            if (field === null) {
-                return undefined;
-            }
-            if (recordIndex === undefined || recordIndex === null) {
-                return;
-            }
-            const rawKey = recordIndex.toString();
-            if (!this.beforeChangedRecordsMap.has(rawKey)) {
-                const rawRecords = Array.isArray(this.dataSourceObj?.records)
-                    ? this.dataSourceObj.records
-                    : null;
-                const originRecord = rawRecords
-                    ? Array.isArray(recordIndex)
-                        ? getValueFromDeepArray(rawRecords, recordIndex)
-                        : rawRecords[recordIndex]
-                    : undefined;
-                this.beforeChangedRecordsMap.set(rawKey, cloneDeep(originRecord, undefined, ['vtable_gantt_linkedFrom', 'vtable_gantt_linkedTo']) ?? {});
-            }
-            if (typeof field === 'string' || typeof field === 'number') {
-                const beforeChangedValue = this.beforeChangedRecordsMap.get(rawKey)?.[field];
-                const rawRecords = Array.isArray(this.dataSourceObj?.records)
-                    ? this.dataSourceObj.records
-                    : null;
-                const record = rawRecords
-                    ? Array.isArray(recordIndex)
-                        ? getValueFromDeepArray(rawRecords, recordIndex)
-                        : rawRecords[recordIndex]
-                    : undefined;
-                let formatValue = value;
-                if (typeof beforeChangedValue === 'number' && isAllDigits(value)) {
-                    formatValue = parseFloat(value);
-                }
-                if (record) {
-                    record[field] = formatValue;
-                }
-                else if (rawRecords && typeof recordIndex === 'number') {
-                    rawRecords[recordIndex] = this.addRecordRule === 'Array' ? [] : {};
-                    rawRecords[recordIndex][field] = formatValue;
-                }
-            }
-        }
         cacheBeforeChangedRecord(dataIndex, table) {
             if (!this.beforeChangedRecordsMap.has(dataIndex.toString())) {
                 const originRecord = this.getOriginalRecord(dataIndex);
@@ -39000,150 +38998,69 @@
                 }
             }
         }
-        _getRawRecordsArray() {
-            const rawRecords = this.dataSourceObj?.records;
-            return Array.isArray(rawRecords) ? rawRecords : null;
-        }
-        _hasFilterInEffect() {
-            return (this.dataConfig?.filterRules?.length ?? 0) >= 1 || (this.lastFilterRules?.length ?? 0) >= 1;
-        }
-        _normalizeInsertIndex(index, length) {
-            if (index === undefined || index === null) {
-                return length;
-            }
-            if (index > length) {
-                return length;
-            }
-            if (index < 0) {
-                return 0;
-            }
-            return index;
-        }
-        _mapViewInsertIndexToRawInsertIndex(rawRecords, viewIndex) {
-            if (viewIndex >= this.records.length) {
-                return rawRecords.length;
-            }
-            if (viewIndex <= 0) {
-                return 0;
-            }
-            const prevRecord = this.records[viewIndex - 1];
-            const rawIndex = rawRecords.indexOf(prevRecord);
-            return rawIndex >= 0 ? rawIndex + 1 : rawRecords.length;
-        }
-        _resetIndexingFromViewRecords() {
-            this._sourceLength = this.records.length;
-            this.currentIndexedData = Array.from({ length: this._sourceLength }, (_, i) => i);
-            if (this.rowHierarchyType === 'tree') {
-                this.initTreeHierarchyState();
-            }
-            if (this.userPagination) {
-                this.pagination.totalCount = this._sourceLength;
-                this.updatePagerData();
-                return;
-            }
-            this.pagination.perPageCount = this._sourceLength;
-            this.pagination.totalCount = this._sourceLength;
-            this.updatePagerData();
-        }
-        addRecord(record, index, syncToOriginalRecords = false) {
-            if (!syncToOriginalRecords) {
-                if (Array.isArray(this.records)) {
-                    this.records.splice(index, 0, record);
-                    this.adjustBeforeChangedRecordsMap(index, 1);
-                    this.currentIndexedData.push(this.currentIndexedData.length);
-                    this._sourceLength += 1;
-                    for (let i = 0; i < this.fieldAggregators.length; i++) {
-                        this.fieldAggregators[i].push(record);
-                    }
-                    if (this.rowHierarchyType === 'tree') {
-                        this.initTreeHierarchyState();
-                    }
-                    if (this.userPagination) {
-                        this.pagination.totalCount = this._sourceLength;
-                        const { perPageCount, currentPage } = this.pagination;
-                        const startIndex = perPageCount * (currentPage || 0);
-                        const endIndex = startIndex + perPageCount;
-                        if (index < endIndex) {
-                            this.updatePagerData();
-                        }
-                    }
-                    else {
-                        this.pagination.perPageCount = this._sourceLength;
-                        this.pagination.totalCount = this._sourceLength;
+        addRecord(record, index) {
+            if (Array.isArray(this.records)) {
+                this.records.splice(index, 0, record);
+                this.adjustBeforeChangedRecordsMap(index, 1);
+                this.currentIndexedData.push(this.currentIndexedData.length);
+                this._sourceLength += 1;
+                for (let i = 0; i < this.fieldAggregators.length; i++) {
+                    this.fieldAggregators[i].push(record);
+                }
+                if (this.rowHierarchyType === 'tree') {
+                    this.initTreeHierarchyState();
+                }
+                if (this.userPagination) {
+                    this.pagination.totalCount = this._sourceLength;
+                    const { perPageCount, currentPage } = this.pagination;
+                    const startIndex = perPageCount * (currentPage || 0);
+                    const endIndex = startIndex + perPageCount;
+                    if (index < endIndex) {
                         this.updatePagerData();
                     }
-                    if (this.dataSourceObj?.added) {
-                        this.dataSourceObj.added(index, 1);
-                    }
                 }
-                return;
-            }
-            const rawRecords = this._getRawRecordsArray();
-            if (!rawRecords) {
-                return;
-            }
-            const viewInsertIndex = this._normalizeInsertIndex(index, this.records.length);
-            const rawInsertIndex = this._hasFilterInEffect()
-                ? this._mapViewInsertIndexToRawInsertIndex(rawRecords, viewInsertIndex)
-                : this._normalizeInsertIndex(viewInsertIndex, rawRecords.length);
-            rawRecords.splice(rawInsertIndex, 0, record);
-            this.beforeChangedRecordsMap.clear();
-            this.sortedIndexMap.clear();
-            this.updateFilterRules(this.dataConfig?.filterRules);
-            if (this.dataSourceObj?.added) {
-                this.dataSourceObj.added(rawInsertIndex, 1);
+                else {
+                    this.pagination.perPageCount = this._sourceLength;
+                    this.pagination.totalCount = this._sourceLength;
+                    this.updatePagerData();
+                }
+                if (this.dataSourceObj?.added) {
+                    this.dataSourceObj.added(index, 1);
+                }
             }
         }
-        addRecords(recordArr, index, syncToOriginalRecords = false) {
-            if (!syncToOriginalRecords) {
-                if (Array.isArray(this.records)) {
-                    if (Array.isArray(recordArr)) {
-                        this.records.splice(index, 0, ...recordArr);
-                        this.adjustBeforeChangedRecordsMap(index, recordArr.length);
-                        for (let i = 0; i < recordArr.length; i++) {
-                            this.currentIndexedData.push(this.currentIndexedData.length);
-                        }
-                        this._sourceLength += recordArr.length;
-                        for (let i = 0; i < this.fieldAggregators.length; i++) {
-                            for (let j = 0; j < recordArr.length; j++) {
-                                this.fieldAggregators[i].push(recordArr[j]);
-                            }
-                        }
+        addRecords(recordArr, index) {
+            if (Array.isArray(this.records)) {
+                if (Array.isArray(recordArr)) {
+                    this.records.splice(index, 0, ...recordArr);
+                    this.adjustBeforeChangedRecordsMap(index, recordArr.length);
+                    for (let i = 0; i < recordArr.length; i++) {
+                        this.currentIndexedData.push(this.currentIndexedData.length);
                     }
-                    if (this.userPagination) {
-                        this.pagination.totalCount = this._sourceLength;
-                        const { perPageCount, currentPage } = this.pagination;
-                        const startIndex = perPageCount * (currentPage || 0);
-                        const endIndex = startIndex + perPageCount;
-                        if (index < endIndex) {
-                            this.updatePagerData();
+                    this._sourceLength += recordArr.length;
+                    for (let i = 0; i < this.fieldAggregators.length; i++) {
+                        for (let j = 0; j < recordArr.length; j++) {
+                            this.fieldAggregators[i].push(recordArr[j]);
                         }
                     }
-                    else {
-                        this.pagination.perPageCount = this._sourceLength;
-                        this.pagination.totalCount = this._sourceLength;
+                }
+                if (this.userPagination) {
+                    this.pagination.totalCount = this._sourceLength;
+                    const { perPageCount, currentPage } = this.pagination;
+                    const startIndex = perPageCount * (currentPage || 0);
+                    const endIndex = startIndex + perPageCount;
+                    if (index < endIndex) {
                         this.updatePagerData();
                     }
-                    if (this.dataSourceObj?.added) {
-                        this.dataSourceObj.added(index, recordArr.length);
-                    }
                 }
-                return;
-            }
-            const rawRecords = this._getRawRecordsArray();
-            if (!rawRecords || !Array.isArray(recordArr) || recordArr.length === 0) {
-                return;
-            }
-            const viewInsertIndex = this._normalizeInsertIndex(index, this.records.length);
-            const rawInsertIndex = this._hasFilterInEffect()
-                ? this._mapViewInsertIndexToRawInsertIndex(rawRecords, viewInsertIndex)
-                : this._normalizeInsertIndex(viewInsertIndex, rawRecords.length);
-            rawRecords.splice(rawInsertIndex, 0, ...recordArr);
-            this.beforeChangedRecordsMap.clear();
-            this.sortedIndexMap.clear();
-            this.updateFilterRules(this.dataConfig?.filterRules);
-            if (this.dataSourceObj?.added) {
-                this.dataSourceObj.added(rawInsertIndex, recordArr.length);
+                else {
+                    this.pagination.perPageCount = this._sourceLength;
+                    this.pagination.totalCount = this._sourceLength;
+                    this.updatePagerData();
+                }
+                if (this.dataSourceObj?.added) {
+                    this.dataSourceObj.added(index, recordArr.length);
+                }
             }
         }
         addRecordForSorted(record) {
@@ -39177,84 +39094,46 @@
             }
         }
         adjustBeforeChangedRecordsMap(insertIndex, insertCount, type = 'add') {
-            const delta = type === 'add' ? insertCount : -insertCount;
-            const numericKeys = [];
-            this.beforeChangedRecordsMap.forEach((_, key) => {
-                const numKey = Number(key);
-                if (Number.isInteger(numKey) && numKey.toString() === key && numKey >= insertIndex) {
-                    numericKeys.push(numKey);
-                }
-            });
-            numericKeys.sort((a, b) => (type === 'add' ? b - a : a - b));
-            for (let i = 0; i < numericKeys.length; i++) {
-                const key = numericKeys[i];
+            const length = this.beforeChangedRecordsMap.size;
+            for (let key = length - 1; key >= insertIndex; key--) {
                 const record = this.beforeChangedRecordsMap.get(key.toString());
                 this.beforeChangedRecordsMap.delete(key.toString());
-                this.beforeChangedRecordsMap.set((key + delta).toString(), record);
+                this.beforeChangedRecordsMap.set((key + (type === 'add' ? insertCount : -insertCount)).toString(), record);
             }
         }
-        deleteRecords(recordIndexs, syncToOriginalRecords = false) {
-            if (!syncToOriginalRecords) {
-                if (Array.isArray(this.records)) {
-                    const realDeletedRecordIndexs = [];
-                    const recordIndexsMaxToMin = recordIndexs.sort((a, b) => b - a);
-                    for (let index = 0; index < recordIndexsMaxToMin.length; index++) {
-                        const recordIndex = recordIndexsMaxToMin[index];
-                        if (recordIndex >= this._sourceLength || recordIndex < 0) {
-                            continue;
-                        }
-                        this.adjustBeforeChangedRecordsMap(recordIndex, 1, 'delete');
-                        realDeletedRecordIndexs.push(recordIndex);
-                        const deletedRecord = this.records[recordIndex];
-                        for (let i = 0; i < this.fieldAggregators.length; i++) {
-                            this.fieldAggregators[i].deleteRecord(deletedRecord);
-                        }
-                        this.records.splice(recordIndex, 1);
-                        this.currentIndexedData.pop();
-                        this._sourceLength -= 1;
-                    }
-                    if (this.userPagination) {
-                        this.updatePagerData();
-                    }
-                    else {
-                        this.pagination.perPageCount = this._sourceLength;
-                        this.pagination.totalCount = this._sourceLength;
-                        this.updatePagerData();
+        deleteRecords(recordIndexs) {
+            if (Array.isArray(this.records)) {
+                const realDeletedRecordIndexs = [];
+                const recordIndexsMaxToMin = recordIndexs.sort((a, b) => b - a);
+                for (let index = 0; index < recordIndexsMaxToMin.length; index++) {
+                    const recordIndex = recordIndexsMaxToMin[index];
+                    if (recordIndex >= this._sourceLength || recordIndex < 0) {
+                        continue;
                     }
-                    if (this.dataSourceObj?.deleted) {
-                        this.dataSourceObj.deleted(realDeletedRecordIndexs);
+                    this.adjustBeforeChangedRecordsMap(recordIndex, 1, 'delete');
+                    realDeletedRecordIndexs.push(recordIndex);
+                    const deletedRecord = this.records[recordIndex];
+                    for (let i = 0; i < this.fieldAggregators.length; i++) {
+                        this.fieldAggregators[i].deleteRecord(deletedRecord);
                     }
-                    return realDeletedRecordIndexs;
+                    this.records.splice(recordIndex, 1);
+                    this.currentIndexedData.pop();
+                    this._sourceLength -= 1;
                 }
-                return [];
-            }
-            const rawRecords = this._getRawRecordsArray();
-            if (!rawRecords || !Array.isArray(this.records)) {
-                return [];
-            }
-            const realDeletedRecordIndexs = [];
-            const recordIndexsMaxToMin = recordIndexs.slice().sort((a, b) => b - a);
-            const rawDeletedIndexs = [];
-            for (let index = 0; index < recordIndexsMaxToMin.length; index++) {
-                const viewIndex = recordIndexsMaxToMin[index];
-                if (viewIndex >= this.records.length || viewIndex < 0) {
-                    continue;
+                if (this.userPagination) {
+                    this.updatePagerData();
                 }
-                const deletedRecord = this.records[viewIndex];
-                const rawIndex = rawRecords.indexOf(deletedRecord);
-                if (rawIndex >= 0) {
-                    rawRecords.splice(rawIndex, 1);
-                    rawDeletedIndexs.push(rawIndex);
+                else {
+                    this.pagination.perPageCount = this._sourceLength;
+                    this.pagination.totalCount = this._sourceLength;
+                    this.updatePagerData();
                 }
-                realDeletedRecordIndexs.push(viewIndex);
-            }
-            this.beforeChangedRecordsMap.clear();
-            this.sortedIndexMap.clear();
-            this.updateFilterRules(this.dataConfig?.filterRules);
-            if (this.dataSourceObj?.deleted) {
-                this.dataSourceObj.deleted(rawDeletedIndexs);
+                if (this.dataSourceObj?.deleted) {
+                    this.dataSourceObj.deleted(realDeletedRecordIndexs);
+                }
+                return realDeletedRecordIndexs;
             }
-            return realDeletedRecordIndexs;
+            return [];
         }
         deleteRecordsForSorted(recordIndexs) {
             if (Array.isArray(this.records)) {
@@ -39276,71 +39155,36 @@
                 this.beforeChangedRecordsMap.clear();
             }
         }
-        updateRecords(records, recordIndexs, syncToOriginalRecords = false) {
-            if (!syncToOriginalRecords) {
-                const realDeletedRecordIndexs = [];
-                for (let index = 0; index < recordIndexs.length; index++) {
-                    const recordIndex = recordIndexs[index];
-                    if (Array.isArray(recordIndex)) {
-                        this.beforeChangedRecordsMap.delete(recordIndex.toString());
-                        realDeletedRecordIndexs.push(recordIndex);
-                        recordIndex.slice(0, -1).reduce((acc, key) => {
-                            if (acc[key] === undefined) {
-                                acc[key] = {};
-                            }
-                            return acc[key].children;
-                        }, this.records)[recordIndex[recordIndex.length - 1]] = records[index];
-                    }
-                    else {
-                        if (recordIndex >= this._sourceLength || recordIndex < 0) {
-                            continue;
-                        }
-                        this.beforeChangedRecordsMap.delete(recordIndex.toString());
-                        realDeletedRecordIndexs.push(recordIndex);
-                        for (let i = 0; i < this.fieldAggregators.length; i++) {
-                            this.fieldAggregators[i].updateRecord(this.records[recordIndex], records[index]);
-                        }
-                        this.records[recordIndex] = records[index];
-                    }
-                }
-                if (this.userPagination) {
-                    this.updatePagerData();
-                }
-                return realDeletedRecordIndexs;
-            }
-            const rawRecords = this._getRawRecordsArray();
-            if (!rawRecords || !Array.isArray(this.records)) {
-                return [];
-            }
-            const realUpdatedIndexs = [];
+        updateRecords(records, recordIndexs) {
+            const realDeletedRecordIndexs = [];
             for (let index = 0; index < recordIndexs.length; index++) {
                 const recordIndex = recordIndexs[index];
                 if (Array.isArray(recordIndex)) {
                     this.beforeChangedRecordsMap.delete(recordIndex.toString());
-                    realUpdatedIndexs.push(recordIndex);
+                    realDeletedRecordIndexs.push(recordIndex);
                     recordIndex.slice(0, -1).reduce((acc, key) => {
                         if (acc[key] === undefined) {
                             acc[key] = {};
                         }
                         return acc[key].children;
-                    }, rawRecords)[recordIndex[recordIndex.length - 1]] = records[index];
+                    }, this.records)[recordIndex[recordIndex.length - 1]] = records[index];
                 }
                 else {
-                    if (recordIndex >= this.records.length || recordIndex < 0) {
+                    if (recordIndex >= this._sourceLength || recordIndex < 0) {
                         continue;
                     }
-                    const oldRecord = this.records[recordIndex];
-                    const rawIndex = rawRecords.indexOf(oldRecord);
-                    if (rawIndex >= 0) {
-                        rawRecords[rawIndex] = records[index];
+                    this.beforeChangedRecordsMap.delete(recordIndex.toString());
+                    realDeletedRecordIndexs.push(recordIndex);
+                    for (let i = 0; i < this.fieldAggregators.length; i++) {
+                        this.fieldAggregators[i].updateRecord(this.records[recordIndex], records[index]);
                     }
-                    realUpdatedIndexs.push(recordIndex);
+                    this.records[recordIndex] = records[index];
                 }
             }
-            this.beforeChangedRecordsMap.clear();
-            this.sortedIndexMap.clear();
-            this.updateFilterRules(this.dataConfig?.filterRules);
-            return realUpdatedIndexs;
+            if (this.userPagination) {
+                this.updatePagerData();
+            }
+            return realDeletedRecordIndexs;
         }
         updateRecordsForSorted(records, recordIndexs) {
             for (let index = 0; index < recordIndexs.length; index++) {
@@ -39421,11 +39265,7 @@
                 }
             }
             if (!filedMapArray.length) {
-                filedMapArray = states.map(() => ({
-                    asc: [],
-                    desc: [],
-                    normal: []
-                }));
+                filedMapArray = states.map(() => ({ asc: [], desc: [], normal: [] }));
                 for (let index = 0; index < states.length; index++) {
                     this.sortedIndexMap.set(states[index].field, filedMapArray[index]);
                 }
@@ -49175,9 +49015,27 @@
         return hoverMode;
     }
 
+    let brushingChartInstance;
+    let brushingChartInstanceCellPos = { col: -1, row: -1 };
+    function setBrushingChartInstance(chartInstance, col, row) {
+        brushingChartInstance = chartInstance;
+        brushingChartInstanceCellPos = { col, row };
+    }
+    function clearBrushingChartInstance() {
+        brushingChartInstance = undefined;
+        brushingChartInstanceCellPos = { col: -1, row: -1 };
+    }
+    function getBrushingChartInstance() {
+        return brushingChartInstance;
+    }
+    function getBrushingChartInstanceCellPos() {
+        return brushingChartInstanceCellPos;
+    }
     const chartInstanceListColumnByColumnDirection = {};
     const chartInstanceListRowByRowDirection = {};
+    const delayRunDimensionHoverTimer = [];
     function generateChartInstanceListByColumnDirection(col, dimensionValueOrXValue, positionValueOrYValue, canvasXY, table, hideTooltip = false, isScatter = false) {
+        clearDelayRunDimensionHoverTimers();
         if (!isValid$1(chartInstanceListColumnByColumnDirection[col])) {
             chartInstanceListColumnByColumnDirection[col] = {};
         }
@@ -49187,9 +49045,9 @@
         for (let i = rowStart; i <= rowEnd; i++) {
             const cellGroup = table.scenegraph.getCell(col, i);
             const chartNode = cellGroup?.getChildren()?.[0];
-            chartNode.addUpdateShapeAndBoundsTag();
             if (chartInstanceListColumnByColumnDirection[col][i]) ;
             else if (isValid$1(chartNode)) {
+                chartNode.addUpdateShapeAndBoundsTag();
                 if (chartNode.activeChartInstance) {
                     chartInstanceListColumnByColumnDirection[col][i] = chartNode.activeChartInstance;
                 }
@@ -49198,44 +49056,13 @@
                     chartInstanceListColumnByColumnDirection[col][i] = chartNode.activeChartInstance;
                 }
             }
-            setTimeout(() => {
+            const timer = setTimeout(() => {
                 if (chartInstanceListColumnByColumnDirection[col]?.[i]) {
                     const chartDimensionLinkage = table.options.chartDimensionLinkage;
                     let isShowTooltip = !isScatter;
                     if (!isScatter && typeof chartDimensionLinkage === 'object') {
                         isShowTooltip = chartDimensionLinkage.showTooltip ?? true;
-                        if (i === rowEnd && isShowTooltip) {
-                            const heightLimitToShowTooltipForEdgeRow = chartDimensionLinkage.heightLimitToShowTooltipForEdgeRow ?? 0;
-                            const { rowEnd: rowEnd1 } = table.getBodyVisibleRowRange(0, -heightLimitToShowTooltipForEdgeRow);
-                            if (rowEnd1 === rowEnd) {
-                                isShowTooltip = true;
-                            }
-                            else {
-                                const { rowEnd: rowEnd2 } = table.getBodyVisibleRowRange(0, 5);
-                                if (rowEnd2 !== rowEnd) {
-                                    isShowTooltip = true;
-                                }
-                                else {
-                                    isShowTooltip = false;
-                                }
-                            }
-                        }
-                        else if (i === rowStart && isShowTooltip) {
-                            const heightLimitToShowTooltipForEdgeRow = chartDimensionLinkage.heightLimitToShowTooltipForEdgeRow ?? 0;
-                            const { rowStart: rowStart1 } = table.getBodyVisibleRowRange(heightLimitToShowTooltipForEdgeRow, 0);
-                            if (rowStart1 === rowStart) {
-                                isShowTooltip = true;
-                            }
-                            else {
-                                const { rowStart: rowStart2 } = table.getBodyVisibleRowRange(0, -5);
-                                if (rowStart2 !== rowStart) {
-                                    isShowTooltip = true;
-                                }
-                                else {
-                                    isShowTooltip = false;
-                                }
-                            }
-                        }
+                        isShowTooltip = isShowTooltip && checkIsShowTooltipForEdgeRow(i, table);
                     }
                     if (isScatter) {
                         if (table.stateManager.hover.cellPos.col !== col || table.stateManager.hover.cellPos.row !== i) {
@@ -49248,6 +49075,7 @@
                         }
                     }
                     else {
+                        const cellBoundry = table.getCellRelativeRect(col, i);
                         const bodyBoundryTop = table.frozenRowCount
                             ? table.getCellRelativeRect(col, table.frozenRowCount - 1).bottom
                             : 0;
@@ -49258,43 +49086,32 @@
                             }
                             chartInstanceListColumnByColumnDirection[col][i].setDimensionIndex(dimensionValueOrXValue, {
                                 tooltip: false,
-                                showTooltipOption: { x: canvasXY.x, y: absolutePositionTop, activeType: 'dimension' }
+                                showTooltipOption: {
+                                    x: canvasXY.x - cellBoundry.left,
+                                    y: absolutePositionTop - cellBoundry.top,
+                                    activeType: 'dimension'
+                                }
                             });
                         }
                         else {
                             chartInstanceListColumnByColumnDirection[col][i].setDimensionIndex(dimensionValueOrXValue, {
                                 tooltip: isShowTooltip,
-                                showTooltipOption: { x: canvasXY.x, y: absolutePositionTop, activeType: 'dimension' }
+                                showTooltipOption: {
+                                    x: canvasXY.x - cellBoundry.left,
+                                    y: absolutePositionTop - cellBoundry.top,
+                                    activeType: 'dimension'
+                                }
                             });
                         }
                     }
                 }
             }, 0);
+            delayRunDimensionHoverTimer.push(timer);
             table.scenegraph.updateNextFrame();
         }
     }
-    function clearChartInstanceListByColumnDirection(col, excludedRow, table) {
-        if (isValid$1(chartInstanceListColumnByColumnDirection[col])) {
-            for (const i in chartInstanceListColumnByColumnDirection[col]) {
-                if (isValid$1(excludedRow) && Number(i) === excludedRow) {
-                    continue;
-                }
-                const cellGroup = table.scenegraph.getCell(col, Number(i));
-                const chartNode = cellGroup?.getChildren()?.[0];
-                chartNode.addUpdateShapeAndBoundsTag();
-                if (isValid$1(chartNode)) {
-                    chartNode.deactivate(table, {
-                        releaseChartInstance: true,
-                        releaseColumnChartInstance: false,
-                        releaseRowChartInstance: false
-                    });
-                    chartInstanceListColumnByColumnDirection[col][i] = null;
-                }
-            }
-            delete chartInstanceListColumnByColumnDirection[col];
-        }
-    }
     function generateChartInstanceListByRowDirection(row, dimensionValueOrXValue, positionValueOrYValue, canvasXY, table, hideTooltip = false, isScatter = false) {
+        clearDelayRunDimensionHoverTimers();
         if (!isValid$1(chartInstanceListRowByRowDirection[row])) {
             chartInstanceListRowByRowDirection[row] = {};
         }
@@ -49304,9 +49121,9 @@
         for (let i = colStart; i <= colEnd; i++) {
             const cellGroup = table.scenegraph.getCell(i, row);
             const chartNode = cellGroup?.getChildren()?.[0];
-            chartNode.addUpdateShapeAndBoundsTag();
             if (chartInstanceListRowByRowDirection[row][i]) ;
             else if (isValid$1(chartNode)) {
+                chartNode.addUpdateShapeAndBoundsTag();
                 if (chartNode.activeChartInstance) {
                     chartInstanceListRowByRowDirection[row][i] = chartNode.activeChartInstance;
                 }
@@ -49315,44 +49132,13 @@
                     chartInstanceListRowByRowDirection[row][i] = chartNode.activeChartInstance;
                 }
             }
-            setTimeout(() => {
+            const timer = setTimeout(() => {
                 if (chartInstanceListRowByRowDirection[row]?.[i]) {
                     const chartDimensionLinkage = table.options.chartDimensionLinkage;
                     let isShowTooltip = !isScatter;
                     if (!isScatter && typeof chartDimensionLinkage === 'object') {
                         isShowTooltip = chartDimensionLinkage.showTooltip ?? true;
-                        if (i === colEnd && isShowTooltip) {
-                            const widthLimitToShowTooltipForEdgeColumn = chartDimensionLinkage.widthLimitToShowTooltipForEdgeColumn;
-                            const { colEnd: colEnd1 } = table.getBodyVisibleColRange(0, -widthLimitToShowTooltipForEdgeColumn);
-                            if (colEnd1 === colEnd) {
-                                isShowTooltip = true;
-                            }
-                            else {
-                                const { colEnd: colEnd2 } = table.getBodyVisibleColRange(0, 5);
-                                if (colEnd2 !== colEnd) {
-                                    isShowTooltip = true;
-                                }
-                                else {
-                                    isShowTooltip = false;
-                                }
-                            }
-                        }
-                        else if (i === colStart && isShowTooltip) {
-                            const widthLimitToShowTooltipForEdgeColumn = chartDimensionLinkage.widthLimitToShowTooltipForEdgeColumn;
-                            const { colStart: colStart1 } = table.getBodyVisibleColRange(widthLimitToShowTooltipForEdgeColumn, 0);
-                            if (colStart1 === colStart) {
-                                isShowTooltip = true;
-                            }
-                            else {
-                                const { colStart: colStart2 } = table.getBodyVisibleColRange(0, -5);
-                                if (colStart2 !== colStart) {
-                                    isShowTooltip = true;
-                                }
-                                else {
-                                    isShowTooltip = false;
-                                }
-                            }
-                        }
+                        isShowTooltip = isShowTooltip && checkIsShowTooltipForEdgeColumn(i, table);
                     }
                     if (isScatter) {
                         if (table.stateManager.hover.cellPos.col !== i || table.stateManager.hover.cellPos.row !== row) {
@@ -49365,6 +49151,7 @@
                         }
                     }
                     else {
+                        const cellBoundry = table.getCellRelativeRect(i, row);
                         const bodyBoundryLeft = table.frozenColCount
                             ? table.getCellRelativeRect(table.frozenColCount - 1, row).right
                             : 0;
@@ -49375,22 +49162,188 @@
                             }
                             chartInstanceListRowByRowDirection[row][i].setDimensionIndex(dimensionValueOrXValue, {
                                 tooltip: false,
-                                showTooltipOption: { x: absolutePositionLeft, y: canvasXY.y, activeType: 'dimension' }
+                                showTooltipOption: {
+                                    x: absolutePositionLeft - cellBoundry.left,
+                                    y: canvasXY.y - cellBoundry.top,
+                                    activeType: 'dimension'
+                                }
                             });
                         }
                         else {
                             chartInstanceListRowByRowDirection[row][i].setDimensionIndex(dimensionValueOrXValue, {
                                 tooltip: isShowTooltip,
-                                showTooltipOption: { x: absolutePositionLeft, y: canvasXY.y, activeType: 'dimension' }
+                                showTooltipOption: {
+                                    x: absolutePositionLeft - cellBoundry.left,
+                                    y: canvasXY.y - cellBoundry.top,
+                                    activeType: 'dimension'
+                                }
                             });
                         }
                     }
                 }
             }, 0);
+            delayRunDimensionHoverTimer.push(timer);
             table.scenegraph.updateNextFrame();
         }
     }
-    function clearChartInstanceListByRowDirection(row, excludedCol, table) {
+    function generateChartInstanceListByViewRange(datum, table, deactivate = false) {
+        clearDelayRunDimensionHoverTimers();
+        const { rowStart } = table.getBodyVisibleRowRange();
+        let rowEnd = table.getBodyVisibleRowRange().rowEnd;
+        rowEnd = Math.min(table.rowCount - 1 - table.bottomFrozenRowCount, rowEnd);
+        const { colStart } = table.getBodyVisibleColRange();
+        let colEnd = table.getBodyVisibleColRange().colEnd;
+        colEnd = Math.min(table.colCount - 1 - table.rightFrozenColCount, colEnd);
+        for (let col = colStart; col <= colEnd; col++) {
+            if (!isValid$1(chartInstanceListColumnByColumnDirection[col])) {
+                chartInstanceListColumnByColumnDirection[col] = {};
+            }
+            for (let i = rowStart; i <= rowEnd; i++) {
+                const cellGroup = table.scenegraph.getCell(col, i);
+                const chartNode = cellGroup?.getChildren()?.[0];
+                if (chartInstanceListColumnByColumnDirection[col][i]) ;
+                else if (isValid$1(chartNode)) {
+                    chartNode.addUpdateShapeAndBoundsTag();
+                    if (chartNode.activeChartInstance) {
+                        chartInstanceListColumnByColumnDirection[col][i] = chartNode.activeChartInstance;
+                    }
+                    else {
+                        if (chartNode.attribute.spec.type === 'pie') {
+                            chartNode.activate(table);
+                            chartInstanceListColumnByColumnDirection[col][i] = chartNode.activeChartInstance;
+                        }
+                    }
+                }
+                const timer = setTimeout(() => {
+                    if (chartInstanceListColumnByColumnDirection[col]?.[i]) {
+                        const chartDimensionLinkage = table.options.chartDimensionLinkage;
+                        let isShowTooltip = true;
+                        if (typeof chartDimensionLinkage === 'object') {
+                            if (deactivate) {
+                                chartInstanceListColumnByColumnDirection[col][i].setHovered();
+                                chartInstanceListColumnByColumnDirection[col][i].hideTooltip();
+                            }
+                            else {
+                                isShowTooltip = chartDimensionLinkage.showTooltip ?? true;
+                                isShowTooltip = isShowTooltip && checkIsShowTooltipForEdgeRow(i, table);
+                                isShowTooltip = isShowTooltip && checkIsShowTooltipForEdgeColumn(col, table);
+                                chartInstanceListColumnByColumnDirection[col][i].setHovered(datum);
+                                isShowTooltip &&
+                                    chartInstanceListColumnByColumnDirection[col][i].showTooltip(datum, {
+                                        activeType: 'mark'
+                                    });
+                            }
+                        }
+                    }
+                }, 0);
+                delayRunDimensionHoverTimer.push(timer);
+                table.scenegraph.updateNextFrame();
+            }
+        }
+    }
+    function checkIsShowTooltipForEdgeRow(row, table) {
+        let isShowTooltip = true;
+        const { rowStart } = table.getBodyVisibleRowRange();
+        let rowEnd = table.getBodyVisibleRowRange().rowEnd;
+        rowEnd = Math.min(table.rowCount - 1 - table.bottomFrozenRowCount, rowEnd);
+        const chartDimensionLinkage = table.options.chartDimensionLinkage;
+        if (row === rowEnd && isShowTooltip) {
+            const heightLimitToShowTooltipForEdgeRow = chartDimensionLinkage.heightLimitToShowTooltipForEdgeRow ?? 0;
+            const { rowEnd: rowEnd1 } = table.getBodyVisibleRowRange(0, -heightLimitToShowTooltipForEdgeRow);
+            if (rowEnd1 === rowEnd) {
+                isShowTooltip = true;
+            }
+            else {
+                const { rowEnd: rowEnd2 } = table.getBodyVisibleRowRange(0, 5);
+                if (rowEnd2 !== rowEnd) {
+                    isShowTooltip = true;
+                }
+                else {
+                    isShowTooltip = false;
+                }
+            }
+        }
+        else if (row === rowStart && isShowTooltip) {
+            const heightLimitToShowTooltipForEdgeRow = chartDimensionLinkage.heightLimitToShowTooltipForEdgeRow ?? 0;
+            const { rowStart: rowStart1 } = table.getBodyVisibleRowRange(heightLimitToShowTooltipForEdgeRow, 0);
+            if (rowStart1 === rowStart) {
+                isShowTooltip = true;
+            }
+            else {
+                const { rowStart: rowStart2 } = table.getBodyVisibleRowRange(0, -5);
+                if (rowStart2 !== rowStart) {
+                    isShowTooltip = true;
+                }
+                else {
+                    isShowTooltip = false;
+                }
+            }
+        }
+        return isShowTooltip;
+    }
+    function checkIsShowTooltipForEdgeColumn(col, table) {
+        let isShowTooltip = true;
+        const { colStart } = table.getBodyVisibleColRange();
+        let colEnd = table.getBodyVisibleColRange().colEnd;
+        colEnd = Math.min(table.colCount - 1 - table.rightFrozenColCount, colEnd);
+        const chartDimensionLinkage = table.options.chartDimensionLinkage;
+        if (col === colEnd && isShowTooltip) {
+            const widthLimitToShowTooltipForEdgeColumn = chartDimensionLinkage.widthLimitToShowTooltipForEdgeColumn;
+            const { colEnd: colEnd1 } = table.getBodyVisibleColRange(0, -widthLimitToShowTooltipForEdgeColumn);
+            if (colEnd1 === colEnd) {
+                isShowTooltip = true;
+            }
+            else {
+                const { colEnd: colEnd2 } = table.getBodyVisibleColRange(0, 5);
+                if (colEnd2 !== colEnd) {
+                    isShowTooltip = true;
+                }
+                else {
+                    isShowTooltip = false;
+                }
+            }
+        }
+        else if (col === colStart && isShowTooltip) {
+            const widthLimitToShowTooltipForEdgeColumn = chartDimensionLinkage.widthLimitToShowTooltipForEdgeColumn;
+            const { colStart: colStart1 } = table.getBodyVisibleColRange(widthLimitToShowTooltipForEdgeColumn, 0);
+            if (colStart1 === colStart) {
+                isShowTooltip = true;
+            }
+            else {
+                const { colStart: colStart2 } = table.getBodyVisibleColRange(0, -5);
+                if (colStart2 !== colStart) {
+                    isShowTooltip = true;
+                }
+                else {
+                    isShowTooltip = false;
+                }
+            }
+        }
+        return isShowTooltip;
+    }
+    function clearChartInstanceListByColumnDirection(col, excludedRow, table, forceRelease = false) {
+        if (isValid$1(chartInstanceListColumnByColumnDirection[col])) {
+            for (const i in chartInstanceListColumnByColumnDirection[col]) {
+                if (isValid$1(excludedRow) && Number(i) === excludedRow) {
+                    continue;
+                }
+                const cellGroup = table.scenegraph.getCell(col, Number(i));
+                const chartNode = cellGroup?.getChildren()?.[0];
+                if (isValid$1(chartNode)) {
+                    chartNode.addUpdateShapeAndBoundsTag();
+                    chartNode.deactivate(table, {
+                        forceRelease: forceRelease,
+                        releaseChartInstance: true,
+                        releaseColumnChartInstance: false,
+                        releaseRowChartInstance: false
+                    });
+                    chartInstanceListColumnByColumnDirection[col][i] = null;
+                }
+            }
+            delete chartInstanceListColumnByColumnDirection[col];
+        }
+    }
+    function clearChartInstanceListByRowDirection(row, excludedCol, table, forceRelease = false) {
         if (isValid$1(chartInstanceListRowByRowDirection[row])) {
             for (const i in chartInstanceListRowByRowDirection[row]) {
                 if (isValid$1(excludedCol) && Number(i) === excludedCol) {
@@ -49398,9 +49351,10 @@
                 }
                 const cellGroup = table.scenegraph.getCell(Number(i), row);
                 const chartNode = cellGroup?.getChildren()?.[0];
-                chartNode.addUpdateShapeAndBoundsTag();
                 if (isValid$1(chartNode)) {
+                    chartNode.addUpdateShapeAndBoundsTag();
                     chartNode.deactivate(table, {
+                        forceRelease: forceRelease,
                         releaseChartInstance: true,
                         releaseColumnChartInstance: false,
                         releaseRowChartInstance: false
@@ -49411,6 +49365,54 @@
         }
         delete chartInstanceListRowByRowDirection[row];
     }
+    function clearDelayRunDimensionHoverTimers() {
+        for (const timer of delayRunDimensionHoverTimer) {
+            clearTimeout(timer);
+        }
+        delayRunDimensionHoverTimer.length = 0;
+    }
+    function clearAllChartInstanceList(table, forceRelease = false) {
+        clearDelayRunDimensionHoverTimers();
+        for (const col in chartInstanceListColumnByColumnDirection) {
+            clearChartInstanceListByColumnDirection(Number(col), undefined, table, forceRelease);
+        }
+        for (const row in chartInstanceListRowByRowDirection) {
+            clearChartInstanceListByRowDirection(Number(row), undefined, table, forceRelease);
+        }
+    }
+    let disabledShowTooltipToAllChartInstances = false;
+    function isDisabledShowTooltipToAllChartInstances() {
+        return disabledShowTooltipToAllChartInstances;
+    }
+    function disableTooltipToAllChartInstances() {
+        disabledShowTooltipToAllChartInstances = true;
+        clearDelayRunDimensionHoverTimers();
+        for (const col in chartInstanceListColumnByColumnDirection) {
+            for (const row in chartInstanceListColumnByColumnDirection[col]) {
+                chartInstanceListColumnByColumnDirection[col][row].disableTooltip(true);
+                chartInstanceListColumnByColumnDirection[col][row].hideTooltip();
+            }
+        }
+        for (const row in chartInstanceListRowByRowDirection) {
+            for (const col in chartInstanceListRowByRowDirection[row]) {
+                chartInstanceListRowByRowDirection[row][col].disableTooltip(true);
+                chartInstanceListRowByRowDirection[row][col].hideTooltip();
+            }
+        }
+    }
+    function enableTooltipToAllChartInstances() {
+        disabledShowTooltipToAllChartInstances = false;
+        for (const col in chartInstanceListColumnByColumnDirection) {
+            for (const row in chartInstanceListColumnByColumnDirection[col]) {
+                chartInstanceListColumnByColumnDirection[col][row].disableTooltip(false);
+            }
+        }
+        for (const row in chartInstanceListRowByRowDirection) {
+            for (const col in chartInstanceListRowByRowDirection[row]) {
+                chartInstanceListRowByRowDirection[row][col].disableTooltip(false);
+            }
+        }
+    }
 
     function isValidAlignDomain(domain) {
         return domain.length === 2 && isValidNumber$1(domain[0]) && isValidNumber$1(domain[1]) && domain[1] >= domain[0];
@@ -50370,6 +50372,7 @@
         type = 'chart';
         chartInstance;
         activeChartInstance;
+        activeChartInstanceLastViewBox = null;
         activeChartInstanceHoverOnMark = null;
         justShowMarkTooltip = undefined;
         justShowMarkTooltipTimer = Date.now();
@@ -50414,7 +50417,6 @@
                 y1: y1 - table.scrollTop,
                 y2: y2 - table.scrollTop
             });
-            this.activeChartInstance?.release();
             this.attribute.ClassType.globalConfig.uniqueTooltip = false;
             this.activeChartInstance = new this.attribute.ClassType(this.attribute.spec, merge({}, this.attribute.tableChartOption, {
                 renderCanvas: this.attribute.canvas,
@@ -50467,7 +50469,7 @@
                         }
                     }
                 },
-                componentShowContent: table.options.chartDimensionLinkage &&
+                componentShowContent: table.options.chartDimensionLinkage?.showTooltip &&
                     this.attribute.spec.type !== 'scatter'
                     ? {
                         tooltip: {
@@ -50488,21 +50490,54 @@
             table.internalProps.layoutMap?.updateDataStateToActiveChartInstance?.(this.activeChartInstance);
             this.activeChartInstance.on('click', (params) => {
                 if (this.attribute.spec.select?.enable === false) {
-                    table.scenegraph.updateChartState(null);
+                    table.scenegraph.updateChartState(null, undefined);
                 }
                 else if (Chart.temp) {
-                    table.scenegraph.updateChartState(params?.datum);
+                    table.scenegraph.updateChartState(params?.datum, 'click');
+                }
+            });
+            let brushChangeThrottle;
+            if (table.options.chartDimensionLinkage?.listenBrushChange) {
+                brushChangeThrottle = cancellableThrottle(table.scenegraph.updateChartState.bind(table.scenegraph), table.options.chartDimensionLinkage?.brushChangeDelay ?? 100);
+                this.activeChartInstance.on('brushChange', (params) => {
+                    brushChangeThrottle.throttled(params?.value?.inBrushData, 'brush');
+                });
+            }
+            this.activeChartInstance.on('brushStart', (params) => {
+                const brushingChartInstance = getBrushingChartInstance();
+                if (brushingChartInstance !== this.activeChartInstance) {
+                    if (brushingChartInstance) {
+                        brushingChartInstance.getChart().getComponentsByKey('brush')[0].clearBrushStateAndMask();
+                    }
+                    setBrushingChartInstance(this.activeChartInstance, col, row);
                 }
             });
             this.activeChartInstance.on('brushEnd', (params) => {
-                table.scenegraph.updateChartState(params?.value?.inBrushData);
+                brushChangeThrottle?.cancel();
+                table.scenegraph.updateChartState(params?.value?.inBrushData, 'brush');
                 Chart.temp = 0;
                 setTimeout(() => {
                     Chart.temp = 1;
                 }, 0);
             });
-            if (table.options.chartDimensionLinkage) {
+            if (table.options.chartDimensionLinkage?.showTooltip) {
+                if (this.attribute.spec.type === 'pie') {
+                    this.activeChartInstance.on('pointerover', { markName: 'pie' }, (params) => {
+                        const categoryField = this.attribute.spec.categoryField;
+                        const datum = { [categoryField]: params?.datum?.[categoryField] };
+                        generateChartInstanceListByViewRange(datum, table, false);
+                    });
+                    this.activeChartInstance.on('pointerout', { markName: 'pie' }, (params) => {
+                        const categoryField = this.attribute.spec.categoryField;
+                        const datum = { [categoryField]: params?.datum?.[categoryField] };
+                        generateChartInstanceListByViewRange(datum, table, true);
+                    });
+                }
                 this.activeChartInstance.on('dimensionHover', (params) => {
+                    if (isDisabledShowTooltipToAllChartInstances()) {
+                        return;
+                    }
+                    this.activeChartInstance.disableTooltip(false);
                     const dimensionInfo = params?.dimensionInfo[0];
                     const canvasXY = params?.event?.canvas;
                     const viewport = params?.event?.viewport;
@@ -50553,13 +50588,11 @@
                             }
                             else if (prev_justShowMarkTooltip === false && justShowMarkTooltip === true) {
                                 delayRunDimensionHover = false;
-                                clearTimeout(this.delayRunDimensionHoverTimer);
-                                this.delayRunDimensionHoverTimer = undefined;
+                                this.clearDelayRunDimensionHoverTimer();
                             }
                             else if (prev_justShowMarkTooltip === true && justShowMarkTooltip === true) {
                                 delayRunDimensionHover = false;
-                                clearTimeout(this.delayRunDimensionHoverTimer);
-                                this.delayRunDimensionHoverTimer = undefined;
+                                this.clearDelayRunDimensionHoverTimer();
                             }
                             if (params.action === 'enter' ||
                                 params.action === 'move' ||
@@ -50575,8 +50608,11 @@
                                     }
                                 }
                                 else {
-                                    clearTimeout(this.delayRunDimensionHoverTimer);
+                                    this.clearDelayRunDimensionHoverTimer();
                                     this.delayRunDimensionHoverTimer = setTimeout(() => {
+                                        if (isDisabledShowTooltipToAllChartInstances()) {
+                                            return;
+                                        }
                                         if (indicatorsAsCol) {
                                             generateChartInstanceListByRowDirection(row, dimensionValue, null, canvasXY, table, justShowMarkTooltip, false);
                                         }
@@ -50637,23 +50673,31 @@
                 });
             }
             table._bindChartEvent?.(this.activeChartInstance);
+            if (isDisabledShowTooltipToAllChartInstances()) {
+                this.activeChartInstance.disableTooltip(true);
+            }
         }
         static temp = 1;
-        deactivate(table, { releaseChartInstance = true, releaseColumnChartInstance = true, releaseRowChartInstance = true } = {}) {
+        clearDelayRunDimensionHoverTimer() {
+            clearTimeout(this.delayRunDimensionHoverTimer);
+            this.delayRunDimensionHoverTimer = undefined;
+        }
+        deactivate(table, { forceRelease = false, releaseChartInstance = true, releaseColumnChartInstance = true, releaseRowChartInstance = true, releaseAllChartInstance = false } = {}) {
             this.activeChartInstanceHoverOnMark = null;
             this.justShowMarkTooltip = undefined;
             this.justShowMarkTooltipTimer = Date.now();
-            clearTimeout(this.delayRunDimensionHoverTimer);
-            this.delayRunDimensionHoverTimer = undefined;
+            this.clearDelayRunDimensionHoverTimer();
             if (releaseChartInstance) {
-                this.activeChartInstance?.updateViewBox({
-                    x1: -1000,
-                    x2: -800,
-                    y1: -1000,
-                    y2: -800
-                }, false, false);
-                this.activeChartInstance?.release();
-                this.activeChartInstance = null;
+                if (forceRelease || !getBrushingChartInstance() || getBrushingChartInstance() !== this.activeChartInstance) {
+                    this.activeChartInstance?.updateViewBox({
+                        x1: -1000,
+                        x2: -800,
+                        y1: -1000,
+                        y2: -800
+                    }, false, false);
+                    this.activeChartInstance?.release();
+                    this.activeChartInstance = null;
+                }
                 const { col, row } = this.parent;
                 table.internalProps.layoutMap.isAxisCell(table.rowHeaderLevelCount - 1, row) &&
                     table.scenegraph.getCell(table.rowHeaderLevelCount - 1, row).firstChild?.hideLabelHoverOnAxis?.();
@@ -50673,11 +50717,16 @@
                         table.scenegraph.getCell(table.rowHeaderLevelCount - 1, row).firstChild?.hideLabelHoverOnAxis?.();
                 }
             }
-            if (releaseColumnChartInstance) {
-                clearChartInstanceListByColumnDirection(this.parent.col, this.attribute.spec.type === 'scatter' ? this.parent.row : undefined, table);
+            if (releaseAllChartInstance) {
+                clearAllChartInstanceList(table, forceRelease);
             }
-            if (releaseRowChartInstance) {
-                clearChartInstanceListByRowDirection(this.parent.row, this.attribute.spec.type === 'scatter' ? this.parent.col : undefined, table);
+            else {
+                if (releaseColumnChartInstance) {
+                    clearChartInstanceListByColumnDirection(this.parent.col, this.attribute.spec.type === 'scatter' ? this.parent.row : undefined, table, forceRelease);
+                }
+                if (releaseRowChartInstance) {
+                    clearChartInstanceListByRowDirection(this.parent.row, this.attribute.spec.type === 'scatter' ? this.parent.col : undefined, table, forceRelease);
+                }
             }
         }
         updateData(data) {
@@ -50688,12 +50737,19 @@
             const padding = this.attribute.cellPadding;
             const table = this.stage.table;
             const { x1, y1, x2, y2 } = cellGroup.globalAABBBounds;
-            return {
+            const viewBox = {
                 x1: Math.ceil(x1 + padding[3] + table.scrollLeft + (table.options.viewBox?.x1 ?? 0)),
                 x2: Math.ceil(x1 + cellGroup.attribute.width - padding[1] + table.scrollLeft + (table.options.viewBox?.x1 ?? 0)),
                 y1: Math.ceil(y1 + padding[0] + table.scrollTop + (table.options.viewBox?.y1 ?? 0)),
                 y2: Math.ceil(y1 + cellGroup.attribute.height - padding[2] + table.scrollTop + (table.options.viewBox?.y1 ?? 0))
             };
+            if (this.activeChartInstance) {
+                this.activeChartInstanceLastViewBox = viewBox;
+            }
+            else {
+                this.activeChartInstanceLastViewBox = null;
+            }
+            return viewBox;
         }
     }
     function getTableBounds(col, row, table) {
@@ -50962,7 +51018,6 @@
         drawShape(chart, context, x, y, drawContext, params, fillCb, strokeCb) {
             const groupAttribute = getTheme(chart, params?.theme).group;
             const { dataId, data, spec } = chart.attribute;
-            chart.getViewBox();
             const { width = groupAttribute.width, height = groupAttribute.height } = chart.attribute;
             const { table } = chart.getRootNode();
             const { cacheCanvas, activeChartInstance } = chart;
@@ -50985,13 +51040,20 @@
                         activeChartInstance.updateSpecSync(spec, false, { reuse: false, morph: false });
                     }
                 }
+                const lastViewBox = chart.activeChartInstanceLastViewBox;
                 const viewBox = chart.getViewBox();
-                activeChartInstance.updateViewBox({
-                    x1: 0,
-                    x2: viewBox.x2 - viewBox.x1,
-                    y1: 0,
-                    y2: viewBox.y2 - viewBox.y1
-                }, false, false);
+                if (!(lastViewBox &&
+                    viewBox.x1 === lastViewBox.x1 &&
+                    viewBox.x2 === lastViewBox.x2 &&
+                    viewBox.y1 === lastViewBox.y1 &&
+                    viewBox.y2 === lastViewBox.y2)) {
+                    activeChartInstance.updateViewBox({
+                        x1: 0,
+                        x2: viewBox.x2 - viewBox.x1,
+                        y1: 0,
+                        y2: viewBox.y2 - viewBox.y1
+                    }, false, false);
+                }
                 const chartStage = activeChartInstance.getStage();
                 chartStage.needRender = true;
                 const matrix = chart.globalTransMatrix.clone();
@@ -57107,9 +57169,10 @@
         updateTableAxes(scenegraph.rightFrozenGroup, scenegraph.table);
         updateTableAxes(scenegraph.bottomFrozenGroup, scenegraph.table);
     }
-    function updateChartState(scenegraph, datum) {
+    function updateChartState(scenegraph, datum, selectedDataMode) {
         const table = scenegraph.table;
         if (table.isPivotChart()) {
+            table._selectedDataMode = selectedDataMode;
             const preSelectItemsCount = table._selectedDataItemsInChart.length;
             if ((datum === null || datum === undefined || datum?.length === 0 || Object.keys(datum).length === 0) &&
                 preSelectItemsCount === 0) {
@@ -58376,38 +58439,73 @@
         resetResidentHoverIcon(col, row) {
             resetResidentHoverIcon(col, row, this);
         }
-        deactivateChart(col, row) {
+        deactivateChart(col, row, forceRelease = false) {
             if (col === -1 || row === -1) {
+                if (forceRelease) {
+                    const brushingChartInstanceCellPos = getBrushingChartInstanceCellPos();
+                    const brushingChartInstance = getBrushingChartInstance();
+                    if (brushingChartInstanceCellPos && brushingChartInstance) {
+                        const cellGroup = this.getCell(brushingChartInstanceCellPos.col, brushingChartInstanceCellPos.row);
+                        if (cellGroup?.firstChild?.deactivate) {
+                            clearBrushingChartInstance();
+                            cellGroup?.firstChild?.deactivate?.(this.table, {
+                                forceRelease: true,
+                                releaseChartInstance: true,
+                                releaseColumnChartInstance: true,
+                                releaseRowChartInstance: true,
+                                releaseAllChartInstance: true
+                            });
+                        }
+                    }
+                }
                 return;
             }
             const cellGroup = this.getCell(col, row);
             if (cellGroup?.firstChild?.deactivate) {
+                if (forceRelease) {
+                    clearBrushingChartInstance();
+                    cellGroup?.firstChild?.deactivate?.(this.table, {
+                        forceRelease: true,
+                        releaseChartInstance: true,
+                        releaseColumnChartInstance: true,
+                        releaseRowChartInstance: true,
+                        releaseAllChartInstance: true
+                    });
+                    return;
+                }
                 const chartNode = cellGroup?.firstChild;
                 const chartType = chartNode.attribute.spec.type;
-                cellGroup?.firstChild?.deactivate?.(this.table, this.table.options.chartDimensionLinkage
+                cellGroup?.firstChild?.deactivate?.(this.table, this.table.options.chartDimensionLinkage?.showTooltip
                     ? {
-                        releaseChartInstance: chartType === 'scatter'
-                            ? (col !== this.table.stateManager.hover.cellPos.col &&
-                                row !== this.table.stateManager.hover.cellPos.row) ||
+                        releaseChartInstance: chartType === 'pie'
+                            ? false
+                            : chartType === 'scatter'
+                                ? (col !== this.table.stateManager.hover.cellPos.col &&
+                                    row !== this.table.stateManager.hover.cellPos.row) ||
+                                    this.table.stateManager.hover.cellPos.row < this.table.frozenRowCount ||
+                                    this.table.stateManager.hover.cellPos.row >
+                                        this.table.rowCount - 1 - this.table.bottomFrozenRowCount ||
+                                    this.table.stateManager.hover.cellPos.col < this.table.frozenColCount ||
+                                    this.table.stateManager.hover.cellPos.col > this.table.colCount - 1 - this.table.rightFrozenColCount
+                                : this.table.options.indicatorsAsCol
+                                    ? row !== this.table.stateManager.hover.cellPos.row ||
+                                        this.table.stateManager.hover.cellPos.col < this.table.frozenColCount ||
+                                        this.table.stateManager.hover.cellPos.col > this.table.colCount - 1 - this.table.rightFrozenColCount
+                                    : col !== this.table.stateManager.hover.cellPos.col ||
+                                        this.table.stateManager.hover.cellPos.row < this.table.frozenRowCount ||
+                                        this.table.stateManager.hover.cellPos.row >
+                                            this.table.rowCount - 1 - this.table.bottomFrozenRowCount,
+                        releaseColumnChartInstance: chartType === 'pie'
+                            ? false
+                            : col !== this.table.stateManager.hover.cellPos.col ||
                                 this.table.stateManager.hover.cellPos.row < this.table.frozenRowCount ||
                                 this.table.stateManager.hover.cellPos.row >
-                                    this.table.rowCount - 1 - this.table.bottomFrozenRowCount ||
+                                    this.table.rowCount - 1 - this.table.bottomFrozenRowCount,
+                        releaseRowChartInstance: chartType === 'pie'
+                            ? false
+                            : row !== this.table.stateManager.hover.cellPos.row ||
                                 this.table.stateManager.hover.cellPos.col < this.table.frozenColCount ||
                                 this.table.stateManager.hover.cellPos.col > this.table.colCount - 1 - this.table.rightFrozenColCount
-                            : this.table.options.indicatorsAsCol
-                                ? row !== this.table.stateManager.hover.cellPos.row ||
-                                    this.table.stateManager.hover.cellPos.col < this.table.frozenColCount ||
-                                    this.table.stateManager.hover.cellPos.col > this.table.colCount - 1 - this.table.rightFrozenColCount
-                                : col !== this.table.stateManager.hover.cellPos.col ||
-                                    this.table.stateManager.hover.cellPos.row < this.table.frozenRowCount ||
-                                    this.table.stateManager.hover.cellPos.row >
-                                        this.table.rowCount - 1 - this.table.bottomFrozenRowCount,
-                        releaseColumnChartInstance: col !== this.table.stateManager.hover.cellPos.col ||
-                            this.table.stateManager.hover.cellPos.row < this.table.frozenRowCount ||
-                            this.table.stateManager.hover.cellPos.row > this.table.rowCount - 1 - this.table.bottomFrozenRowCount,
-                        releaseRowChartInstance: row !== this.table.stateManager.hover.cellPos.row ||
-                            this.table.stateManager.hover.cellPos.col < this.table.frozenColCount ||
-                            this.table.stateManager.hover.cellPos.col > this.table.colCount - 1 - this.table.rightFrozenColCount
                     }
                     : undefined);
             }
@@ -58464,8 +58562,17 @@
         updateChartSizeForResizeRowHeight(row) {
             updateChartSizeForResizeRowHeight(this, row);
         }
-        updateChartState(datum) {
-            this.table.isPivotChart() && updateChartState(this, datum);
+        updateChartState(datum, selectedDataMode) {
+            if (this.table.isPivotChart()) {
+                if (datum === null || datum === undefined || datum?.length === 0 || Object.keys(datum).length === 0) {
+                    const brushingChartInstance = getBrushingChartInstance();
+                    if (brushingChartInstance) {
+                        brushingChartInstance.getChart().getComponentsByKey('brush')[0].clearBrushStateAndMask();
+                    }
+                    this.table.options.chartDimensionLinkage?.clearChartState?.();
+                }
+                updateChartState(this, datum, selectedDataMode);
+            }
         }
         updateCheckboxCellState(col, row, checked) {
             if (this.table.transpose) {
@@ -63752,7 +63859,8 @@
                 return;
             }
             if (table.isPivotChart() && eventArgsSet?.eventArgs?.target.type !== 'chart') {
-                table.scenegraph.updateChartState(null);
+                table.scenegraph.updateChartState(null, undefined);
+                table.scenegraph.deactivateChart(-1, -1, true);
             }
             if (eventArgsSet.eventArgs?.target !== stateManager.residentHoverIcon?.icon) {
                 stateManager.hideMenu();
@@ -63821,7 +63929,8 @@
                     else {
                         if (!eventManager.checkCellFillhandle(eventArgsSet) &&
                             (eventManager.checkColumnResize(eventArgsSet, true) || eventManager.checkRowResize(eventArgsSet, true))) {
-                            table.scenegraph.updateChartState(null);
+                            table.scenegraph.updateChartState(null, undefined);
+                            table.scenegraph.deactivateChart(-1, -1, true);
                             stateManager.updateInteractionState(InteractionState.grabing);
                             return;
                         }
@@ -64066,7 +64175,8 @@
                     !eventManager.checkCellFillhandle(eventArgsSet) &&
                     !stateManager.columnResize.resizing &&
                     eventManager.checkColumnResize(eventArgsSet, true)) {
-                    table.scenegraph.updateChartState(null);
+                    table.scenegraph.updateChartState(null, undefined);
+                    table.scenegraph.deactivateChart(-1, -1, true);
                     stateManager.updateInteractionState(InteractionState.grabing);
                     const { eventArgs } = eventArgsSet;
                     if (!eventArgs?.targetCell) {
@@ -64113,7 +64223,8 @@
                 }
                 stateManager.endSelectCells(true, isHasSelected);
                 stateManager.updateCursor();
-                table.scenegraph.updateChartState(null);
+                table.scenegraph.updateChartState(null, undefined);
+                table.scenegraph.deactivateChart(-1, -1, true);
             }
             else if (table.eventManager.isDraging && stateManager.isSelecting()) {
                 stateManager.endSelectCells();
@@ -64304,6 +64415,10 @@
             const legend = e.path.find(node => node.name === 'legend');
             if (!legend) {
                 table.editorManager?.completeEdit();
+                const { cellPos } = table.stateManager.hover;
+                const prevHoverCellCol = cellPos.col;
+                const prevHoverCellRow = cellPos.row;
+                table.scenegraph.deactivateChart(prevHoverCellCol, prevHoverCellRow, true);
                 if (table.eventManager._enableTableScroll) {
                     handleWhell(e, stateManager);
                 }
@@ -64497,6 +64612,9 @@
             if (stateManager.interactionState !== InteractionState.scrolling) {
                 stateManager.updateInteractionState(InteractionState.scrolling);
             }
+            scenegraph.table.stateManager.hideMenu();
+            scenegraph.table.editorManager?.completeEdit();
+            table.scenegraph.deactivateChart(-1, -1, true);
             const ratio = e.detail.value[0] / (1 - e.detail.value[1] + e.detail.value[0]);
             throttleVerticalWheel(ratio, e);
         });
@@ -64508,6 +64626,9 @@
             if (stateManager.interactionState !== InteractionState.scrolling) {
                 stateManager.updateInteractionState(InteractionState.scrolling);
             }
+            scenegraph.table.stateManager.hideMenu();
+            scenegraph.table.editorManager?.completeEdit();
+            table.scenegraph.deactivateChart(-1, -1, true);
             const ratio = e.detail.value[0] / (1 - e.detail.value[1] + e.detail.value[0]);
             throttleHorizontalWheel(ratio);
         });
@@ -64813,6 +64934,8 @@
                         stateManager.endSelectCells(true, isHasSelected);
                     }
                 });
+                table.scenegraph.updateChartState(null, undefined);
+                table.scenegraph.deactivateChart(-1, -1, true);
             }
         };
         eventManager.globalEventListeners.push({
@@ -65656,7 +65779,6 @@
         cutOperationTime = 0;
         lastClipboardContent = '';
         cutCellRange = null;
-        cutRanges = null;
         copySourceRange = null;
         constructor(table) {
             this.table = table;
@@ -66176,10 +66298,6 @@
             this.handleCopy(e, true);
             this.cutWaitPaste = true;
             this.cutCellRange = this.table.getSelectedCellInfos();
-            this.cutRanges = this.table.stateManager.select.ranges?.map(r => ({
-                start: { col: r.start.col, row: r.start.row },
-                end: { col: r.end.col, row: r.end.row }
-            }));
             if (this.clipboardCheckTimer) {
                 clearTimeout(this.clipboardCheckTimer);
             }
@@ -66187,7 +66305,6 @@
                 if (this.cutWaitPaste) {
                     this.cutWaitPaste = false;
                     this.cutCellRange = null;
-                    this.cutRanges = null;
                     this.clipboardCheckTimer = null;
                 }
             }, 30000);
@@ -66207,7 +66324,6 @@
                 if (this.cutWaitPaste) {
                     this.cutWaitPaste = false;
                     this.cutCellRange = null;
-                    this.cutRanges = null;
                     if (this.clipboardCheckTimer) {
                         clearTimeout(this.clipboardCheckTimer);
                         this.clipboardCheckTimer = null;
@@ -66323,11 +66439,17 @@
         }
         clearCutArea(table) {
             try {
-                const ranges = this.cutRanges;
-                if (!ranges || ranges.length === 0) {
+                const selectCells = this.cutCellRange;
+                if (!selectCells || selectCells.length === 0) {
                     return;
                 }
-                table.changeCellValuesByIds(ranges, '');
+                for (let i = 0; i < selectCells.length; i++) {
+                    for (let j = 0; j < selectCells[i].length; j++) {
+                        if (selectCells[i][j]) {
+                            table.changeCellValue(selectCells[i][j].col, selectCells[i][j].row, undefined);
+                        }
+                    }
+                }
             }
             catch (error) {
             }
@@ -69849,15 +69971,6 @@
             this.customCellStyle = customCellStyle;
             this.customCellStyleArrangement = customCellStyleArrangement;
         }
-        clearCustomCellStyleArrangement() {
-            this.customCellStyleArrangement = [];
-        }
-        addCustomCellStyleArrangement(cellPosition, customStyleId) {
-            this.customCellStyleArrangement.push({
-                cellPosition,
-                customStyleId
-            });
-        }
         getCustomCellStyle(col, row) {
             const customStyleIds = this.getCustomCellStyleIds(col, row);
             if (customStyleIds.length) {
@@ -70386,7 +70499,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.22.11-alpha.7";
+        version = "1.22.11-alpha.8";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -76424,10 +76537,9 @@
         return { addRecordRule };
     }
 
-    function listTableChangeCellValue(col, row, value, workOnEditableCell, triggerEvent, table, silentChangeCellValuesEvent) {
+    function listTableChangeCellValue(col, row, value, workOnEditableCell, triggerEvent, table) {
         if ((workOnEditableCell && table.isHasEditorDefine(col, row)) || workOnEditableCell === false) {
-            const recordShowIndex = table.getRecordShowIndexByCell(col, row);
-            const recordIndex = recordShowIndex >= 0 ? table.dataSource.getIndexKey(recordShowIndex) : undefined;
+            const recordIndex = table.getRecordShowIndexByCell(col, row);
             const { field } = table.internalProps.layoutMap.getBody(col, row);
             const beforeChangeValue = table.getCellRawValue(col, row);
             const oldValue = table.getCellOriginValue(col, row);
@@ -76435,7 +76547,7 @@
                 table.internalProps.layoutMap.updateColumnTitle(col, row, value);
             }
             else {
-                table.dataSource.changeFieldValue(value, recordShowIndex, field, col, row, table);
+                table.dataSource.changeFieldValue(value, recordIndex, field, col, row, table);
             }
             const range = table.getCellRange(col, row);
             const aggregators = table.internalProps.layoutMap.getAggregatorsByCell(col, row);
@@ -76488,24 +76600,18 @@
             }
             const changedValue = table.getCellOriginValue(col, row);
             if (oldValue !== changedValue && triggerEvent) {
-                const changeValue = {
+                table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, {
                     col,
                     row,
-                    recordIndex,
-                    field,
                     rawValue: beforeChangeValue,
                     currentValue: oldValue,
                     changedValue
-                };
-                table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, changeValue);
-                if (!silentChangeCellValuesEvent) {
-                    table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUES, { values: [changeValue] });
-                }
+                });
             }
             table.scenegraph.updateNextFrame();
         }
     }
-    async function listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, table, silentChangeCellValuesEvent) {
+    async function listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, table) {
         const changedCellResults = [];
         let pasteColEnd = startCol;
         let pasteRowEnd = startRow;
@@ -76532,7 +76638,6 @@
                 oldRowValues.push(oldValue);
             }
         }
-        const resultChangeValues = [];
         for (let i = 0; i < values.length; i++) {
             if (startRow + i > table.rowCount - 1) {
                 break;
@@ -76572,8 +76677,7 @@
                 if (isCanChange) {
                     changedCellResults[i][j] = true;
                     const value = rowValues[j];
-                    const recordShowIndex = table.getRecordShowIndexByCell(startCol + j, startRow + i);
-                    const recordIndex = recordShowIndex >= 0 ? table.dataSource.getIndexKey(recordShowIndex) : undefined;
+                    const recordIndex = table.getRecordShowIndexByCell(startCol + j, startRow + i);
                     const { field } = table.internalProps.layoutMap.getBody(startCol + j, startRow + i);
                     const beforeChangeValue = beforeChangeValues[i][j];
                     const oldValue = oldValues[i][j];
@@ -76581,21 +76685,17 @@
                         table.internalProps.layoutMap.updateColumnTitle(startCol + j, startRow + i, value);
                     }
                     else {
-                        table.dataSource.changeFieldValue(value, recordShowIndex, field, startCol + j, startRow + i, table);
+                        table.dataSource.changeFieldValue(value, recordIndex, field, startCol + j, startRow + i, table);
                     }
                     const changedValue = table.getCellOriginValue(startCol + j, startRow + i);
                     if (oldValue !== changedValue && triggerEvent) {
-                        const changeValue = {
+                        table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, {
                             col: startCol + j,
                             row: startRow + i,
-                            recordIndex,
-                            field,
                             rawValue: beforeChangeValue,
                             currentValue: oldValue,
                             changedValue
-                        };
-                        table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, changeValue);
-                        resultChangeValues.push(changeValue);
+                        });
                     }
                 }
                 else {
@@ -76604,9 +76704,6 @@
             }
             pasteColEnd = Math.max(pasteColEnd, thisRowPasteColEnd);
         }
-        if (!silentChangeCellValuesEvent) {
-            table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUES, { values: resultChangeValues });
-        }
         const startRange = table.getCellRange(startCol, startRow);
         const range = table.getCellRange(pasteColEnd, pasteRowEnd);
         const aggregators = table.internalProps.layoutMap.getAggregatorsByCellRange(startRange.start.col, startRange.start.row, range.end.col, range.end.row);
@@ -76679,68 +76776,6 @@
         table.scenegraph.updateNextFrame();
         return changedCellResults;
     }
-    async function listTableChangeCellValuesByIds(ranges, value, workOnEditableCell, triggerEvent, table, silentChangeCellValuesEvent) {
-        const resultChangeValues = [];
-        const processed = new Set();
-        const nextValue = (value ?? '');
-        for (let i = 0; i < (ranges?.length ?? 0); i++) {
-            const range = ranges[i];
-            const startCol = Math.min(range.start.col, range.end.col);
-            const endCol = Math.max(range.start.col, range.end.col);
-            const startRow = Math.min(range.start.row, range.end.row);
-            const endRow = Math.max(range.start.row, range.end.row);
-            if (startCol > endCol || startRow > endRow) {
-                continue;
-            }
-            const values = [];
-            const oldValues = [];
-            for (let row = startRow; row <= endRow; row++) {
-                const rowValues = [];
-                const rowOldValues = [];
-                for (let col = startCol; col <= endCol; col++) {
-                    rowValues.push(nextValue);
-                    rowOldValues.push(table.getCellOriginValue(col, row));
-                }
-                values.push(rowValues);
-                oldValues.push(rowOldValues);
-            }
-            const changedCellResults = await listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, table, true);
-            for (let r = 0; r < values.length; r++) {
-                for (let c = 0; c < values[r].length; c++) {
-                    const col = startCol + c;
-                    const row = startRow + r;
-                    const key = `${col},${row}`;
-                    if (processed.has(key)) {
-                        continue;
-                    }
-                    processed.add(key);
-                    if (!triggerEvent || !changedCellResults?.[r]?.[c]) {
-                        continue;
-                    }
-                    const oldValue = oldValues[r][c];
-                    const changedValue = table.getCellOriginValue(col, row);
-                    if (oldValue === changedValue) {
-                        continue;
-                    }
-                    const recordShowIndex = table.getRecordShowIndexByCell(col, row);
-                    const recordIndex = recordShowIndex >= 0 ? table.dataSource.getIndexKey(recordShowIndex) : undefined;
-                    const { field } = table.internalProps.layoutMap.getBody(col, row);
-                    resultChangeValues.push({
-                        col,
-                        row,
-                        recordIndex,
-                        field,
-                        rawValue: oldValue,
-                        currentValue: oldValue,
-                        changedValue
-                    });
-                }
-            }
-        }
-        if (!silentChangeCellValuesEvent && triggerEvent) {
-            table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUES, { values: resultChangeValues });
-        }
-    }
     function getCellUpdateType(col, row, table, oldCellUpdateType) {
         if (oldCellUpdateType === 'group') {
             return oldCellUpdateType;
@@ -76794,13 +76829,7 @@
                 table.scenegraph.createSceneGraph();
             }
             else if (table.sortState) {
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                if (syncToOriginalRecords) {
-                    table.dataSource.addRecord(record, table.dataSource.records.length, true);
-                }
-                else {
-                    table.dataSource.addRecordForSorted(record);
-                }
+                table.dataSource.addRecordForSorted(record);
                 table.stateManager.checkedState.clear();
                 sortRecords(table);
                 table.refreshRowColCount();
@@ -76813,16 +76842,8 @@
                     recordIndex = table.dataSource.sourceLength;
                 }
                 const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                table.dataSource.addRecord(record, recordIndex, syncToOriginalRecords);
+                table.dataSource.addRecord(record, recordIndex);
                 adjustCheckBoxStateMapWithAddRecordIndex(table, recordIndex, 1);
-                if (syncToOriginalRecords) {
-                    table.refreshRowColCount();
-                    table.internalProps.layoutMap.clearCellRangeMap();
-                    table.scenegraph.clearCells();
-                    table.scenegraph.createSceneGraph();
-                    return true;
-                }
                 const oldRowCount = table.rowCount;
                 table.refreshRowColCount();
                 if (table.scenegraph.proxy.totalActualBodyRowCount === 0) {
@@ -76934,13 +76955,7 @@
                 table.scenegraph.createSceneGraph();
             }
             else if (table.sortState) {
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                if (syncToOriginalRecords) {
-                    table.dataSource.addRecords(records, table.dataSource.records.length, true);
-                }
-                else {
-                    table.dataSource.addRecordsForSorted(records);
-                }
+                table.dataSource.addRecordsForSorted(records);
                 sortRecords(table);
                 table.refreshRowColCount();
                 table.scenegraph.clearCells();
@@ -76955,16 +76970,8 @@
                     recordIndex = 0;
                 }
                 const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                table.dataSource.addRecords(records, recordIndex, syncToOriginalRecords);
+                table.dataSource.addRecords(records, recordIndex);
                 adjustCheckBoxStateMapWithAddRecordIndex(table, recordIndex, records.length);
-                if (syncToOriginalRecords) {
-                    table.refreshRowColCount();
-                    table.internalProps.layoutMap.clearCellRangeMap();
-                    table.scenegraph.clearCells();
-                    table.scenegraph.createSceneGraph();
-                    return true;
-                }
                 const oldRowCount = table.transpose ? table.colCount : table.rowCount;
                 table.refreshRowColCount();
                 if (table.scenegraph.proxy.totalActualBodyRowCount === 0) {
@@ -77080,34 +77087,20 @@
                 table.scenegraph.createSceneGraph();
             }
             else if (table.sortState) {
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                if (syncToOriginalRecords) {
-                    table.dataSource.deleteRecords(recordIndexs, true);
-                }
-                else {
-                    table.dataSource.deleteRecordsForSorted(recordIndexs);
-                }
+                table.dataSource.deleteRecordsForSorted(recordIndexs);
                 sortRecords(table);
                 table.refreshRowColCount();
                 table.scenegraph.clearCells();
                 table.scenegraph.createSceneGraph();
             }
             else {
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                const deletedRecordIndexs = table.dataSource.deleteRecords(recordIndexs, syncToOriginalRecords);
+                const deletedRecordIndexs = table.dataSource.deleteRecords(recordIndexs);
                 if (deletedRecordIndexs.length === 0) {
                     return;
                 }
                 for (let index = 0; index < deletedRecordIndexs.length; index++) {
                     adjustCheckBoxStateMapWithDeleteRecordIndex(table, deletedRecordIndexs[index], 1);
                 }
-                if (syncToOriginalRecords) {
-                    table.refreshRowColCount();
-                    table.internalProps.layoutMap.clearCellRangeMap();
-                    table.scenegraph.clearCells();
-                    table.scenegraph.createSceneGraph();
-                    return;
-                }
                 const oldRowCount = table.transpose ? table.colCount : table.rowCount;
                 table.refreshRowColCount();
                 const newRowCount = table.transpose ? table.colCount : table.rowCount;
@@ -77225,32 +77218,18 @@
                 table.scenegraph.createSceneGraph();
             }
             else if (table.sortState) {
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                if (syncToOriginalRecords) {
-                    table.dataSource.updateRecords(records, recordIndexs, true);
-                }
-                else {
-                    table.dataSource.updateRecordsForSorted(records, recordIndexs);
-                }
+                table.dataSource.updateRecordsForSorted(records, recordIndexs);
                 sortRecords(table);
                 table.refreshRowColCount();
                 table.scenegraph.clearCells();
                 table.scenegraph.createSceneGraph();
             }
             else {
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                const updateRecordIndexs = table.dataSource.updateRecords(records, recordIndexs, syncToOriginalRecords);
+                const updateRecordIndexs = table.dataSource.updateRecords(records, recordIndexs);
                 if (updateRecordIndexs.length === 0) {
                     return;
                 }
-                if (syncToOriginalRecords) {
-                    table.refreshRowColCount();
-                    table.internalProps.layoutMap.clearCellRangeMap();
-                    table.scenegraph.clearCells();
-                    table.scenegraph.createSceneGraph();
-                    return;
-                }
-                const bodyRowIndex = updateRecordIndexs.map((index) => table.getBodyRowIndexByRecordIndex(index));
+                const bodyRowIndex = updateRecordIndexs.map(index => table.getBodyRowIndexByRecordIndex(index));
                 const recordIndexsMinToMax = bodyRowIndex.sort((a, b) => a - b);
                 if (table.pagination) {
                     const { perPageCount, currentPage } = table.pagination;
@@ -78647,182 +78626,17 @@
             }
             return isValid$1(editorDefine);
         }
-        changeCellValue(col, row, value, workOnEditableCell = false, triggerEvent = true, silentChangeCellValuesEvent) {
-            return listTableChangeCellValue(col, row, value, workOnEditableCell, triggerEvent, this, silentChangeCellValuesEvent);
-        }
-        changeCellValues(startCol, startRow, values, workOnEditableCell = false, triggerEvent = true, silentChangeCellValuesEvent) {
-            return listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, this, silentChangeCellValuesEvent);
-        }
-        changeCellValuesByIds(ranges, value, workOnEditableCell = false, triggerEvent = true, silentChangeCellValuesEvent) {
-            return listTableChangeCellValuesByIds(ranges, value, workOnEditableCell, triggerEvent, this, silentChangeCellValuesEvent);
-        }
-        changeSourceCellValue(recordIndex, field, value) {
-            const tableIndex = this.getTableIndexByRecordIndex(recordIndex);
-            const cellAddr = this.getCellAddrByFieldRecord(field, recordIndex);
-            if (tableIndex < 0 || cellAddr.col < 0 || cellAddr.row < 0) {
-                return;
-            }
-            this.dataSource.changeFieldValue(value, tableIndex, field, cellAddr.col, cellAddr.row, this);
-            const beforeChangeValue = this.getCellRawValue(cellAddr.col, cellAddr.row);
-            const oldValue = this.getCellOriginValue(cellAddr.col, cellAddr.row);
-            const changedValue = this.getCellOriginValue(cellAddr.col, cellAddr.row);
-            if (oldValue !== changedValue) {
-                const changeValue = {
-                    col: cellAddr.col,
-                    row: cellAddr.row,
-                    recordIndex,
-                    field,
-                    rawValue: beforeChangeValue,
-                    currentValue: oldValue,
-                    changedValue
-                };
-                this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, changeValue);
-                this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUES, { values: [changeValue] });
-            }
-        }
-        changeCellValueByRecord(recordIndex, field, value, options) {
-            const triggerEvent = options?.triggerEvent ?? true;
-            const silentChangeCellValuesEvent = options?.silentChangeCellValuesEvent;
-            const autoRefresh = options?.autoRefresh ?? true;
-            const records = this.dataSource.dataSourceObj?.records;
-            let record;
-            let oldValue;
-            if (Array.isArray(records) && (typeof field === 'string' || typeof field === 'number')) {
-                record = Array.isArray(recordIndex) ? getValueFromDeepArray(records, recordIndex) : records[recordIndex];
-                oldValue = record?.[field];
-            }
-            this.dataSource.changeFieldValueByRecordIndex(value, recordIndex, field, this);
-            if (!triggerEvent) {
-                return;
-            }
-            const changedValue = record && (typeof field === 'string' || typeof field === 'number') ? record?.[field] : value;
-            if (oldValue !== changedValue) {
-                const cellAddr = this.getCellAddrByFieldRecord(field, recordIndex);
-                const changeValue = {
-                    col: cellAddr?.col ?? -1,
-                    row: cellAddr?.row ?? -1,
-                    recordIndex,
-                    field,
-                    rawValue: oldValue,
-                    currentValue: oldValue,
-                    changedValue
-                };
-                this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, changeValue);
-                if (!silentChangeCellValuesEvent) {
-                    this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUES, { values: [changeValue] });
-                }
-            }
-            if (autoRefresh) {
-                this.refreshAfterSourceChange();
-            }
-        }
-        changeCellValueBySource(recordIndex, field, value, triggerEvent = true, silentChangeCellValuesEvent) {
-            return this.changeCellValueByRecord(recordIndex, field, value, {
-                triggerEvent,
-                silentChangeCellValuesEvent,
-                autoRefresh: true
-            });
-        }
-        changeCellValuesByRecords(changeValues, options) {
-            const triggerEvent = options?.triggerEvent ?? true;
-            const silentChangeCellValuesEvent = options?.silentChangeCellValuesEvent;
-            const autoRefresh = options?.autoRefresh ?? true;
-            const resultChangeValues = [];
-            for (let i = 0; i < changeValues.length; i++) {
-                const { recordIndex, field, value } = changeValues[i];
-                const records = this.dataSource.dataSourceObj?.records;
-                let record;
-                let oldValue;
-                if (Array.isArray(records) && (typeof field === 'string' || typeof field === 'number')) {
-                    record = Array.isArray(recordIndex) ? getValueFromDeepArray(records, recordIndex) : records[recordIndex];
-                    oldValue = record?.[field];
-                }
-                this.dataSource.changeFieldValueByRecordIndex(value, recordIndex, field, this);
-                if (triggerEvent) {
-                    const changedValue = record && (typeof field === 'string' || typeof field === 'number') ? record?.[field] : value;
-                    if (oldValue !== changedValue) {
-                        const changeValue = {
-                            col: (this.getCellAddrByFieldRecord(field, recordIndex)?.col ?? -1),
-                            row: (this.getCellAddrByFieldRecord(field, recordIndex)?.row ?? -1),
-                            recordIndex,
-                            field,
-                            rawValue: oldValue,
-                            currentValue: oldValue,
-                            changedValue
-                        };
-                        this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, changeValue);
-                        resultChangeValues.push(changeValue);
-                    }
-                }
-            }
-            if (!silentChangeCellValuesEvent && resultChangeValues.length && triggerEvent) {
-                this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUES, { values: resultChangeValues });
-            }
-            if (autoRefresh) {
-                this.refreshAfterSourceChange();
-            }
-        }
-        changeCellValuesBySource(changeValues, triggerEvent = true, silentChangeCellValuesEvent) {
-            return this.changeCellValuesByRecords(changeValues, {
-                triggerEvent,
-                silentChangeCellValuesEvent,
-                autoRefresh: true
-            });
+        changeCellValue(col, row, value, workOnEditableCell = false, triggerEvent = true) {
+            return listTableChangeCellValue(col, row, value, workOnEditableCell, triggerEvent, this);
         }
-        refreshAfterSourceChange(options) {
-            const reapplyFilter = options?.reapplyFilter ?? true;
-            const reapplySort = options?.reapplySort ?? true;
-            const clearRowHeightCache = options?.clearRowHeightCache ?? true;
-            this.scenegraph.clearCells();
-            if (this.sortState && reapplySort) {
-                this.dataSource.clearSortedIndexMap?.();
-                this.dataSource.sortedIndexMap?.clear?.();
-            }
-            if (reapplyFilter) {
-                if (this.sortState && reapplySort) {
-                    this.dataSource.updateFilterRulesForSorted(this.dataSource.dataConfig?.filterRules);
-                    sortRecords(this);
-                }
-                else {
-                    this.dataSource.updateFilterRules(this.dataSource.dataConfig?.filterRules);
-                }
-            }
-            else if (this.sortState && reapplySort) {
-                sortRecords(this);
-            }
-            const traverseColumns = (columns) => {
-                for (let i = 0; i < (columns?.length ?? 0); i++) {
-                    const column = columns[i];
-                    const aggregators = column?.vtable_aggregator;
-                    if (aggregators) {
-                        if (Array.isArray(aggregators)) {
-                            for (let j = 0; j < aggregators.length; j++) {
-                                aggregators[j]?.recalculate?.();
-                            }
-                        }
-                        else {
-                            aggregators?.recalculate?.();
-                        }
-                    }
-                    if (column?.columns) {
-                        traverseColumns(column.columns);
-                    }
-                }
-            };
-            traverseColumns(this.internalProps.columns);
-            this.refreshRowColCount();
-            this.internalProps.layoutMap.clearCellRangeMap();
-            this.internalProps.useOneRowHeightFillAll = false;
-            this.stateManager.initCheckedState(this.records);
-            this.scenegraph.createSceneGraph(!clearRowHeightCache);
-            this.internalProps.emptyTip?.resetVisible();
-            this.resize();
+        changeCellValues(startCol, startRow, values, workOnEditableCell = false, triggerEvent = true) {
+            return listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, this);
         }
-        addRecord(record, recordIndex, triggerEvent = true) {
+        addRecord(record, recordIndex) {
             const success = listTableAddRecord(record, recordIndex, this);
             adjustHeightResizedRowMapWithAddRecordIndex(this, recordIndex, [record]);
             this.internalProps.emptyTip?.resetVisible();
-            if (triggerEvent && success) {
+            if (success) {
                 this.fireListeners(TABLE_EVENT_TYPE.ADD_RECORD, {
                     records: [record],
                     recordIndex,
@@ -78830,13 +78644,13 @@
                 });
             }
         }
-        addRecords(records, recordIndex, triggerEvent = true) {
+        addRecords(records, recordIndex) {
             const success = listTableAddRecords(records, recordIndex, this);
             if (typeof recordIndex === 'number') {
                 adjustHeightResizedRowMapWithAddRecordIndex(this, recordIndex, records);
             }
             this.internalProps.emptyTip?.resetVisible();
-            if (triggerEvent && success) {
+            if (success) {
                 this.fireListeners(TABLE_EVENT_TYPE.ADD_RECORD, {
                     records,
                     recordIndex,
@@ -78844,20 +78658,7 @@
                 });
             }
         }
-        deleteRecords(recordIndexs, triggerEvent = true) {
-            const deletedRecords = [];
-            if (recordIndexs?.length > 0) {
-                recordIndexs.forEach(index => {
-                    let record = null;
-                    if (typeof index === 'number') {
-                        record = this.dataSource.get(index);
-                    }
-                    else {
-                        record = [];
-                    }
-                    deletedRecords.push(record);
-                });
-            }
+        deleteRecords(recordIndexs) {
             listTableDeleteRecords(recordIndexs, this);
             adjustHeightResizedRowMapWithDeleteRecordIndex(this, recordIndexs);
             this.internalProps.emptyTip?.resetVisible();
@@ -78865,26 +78666,21 @@
             for (let i = 0; i < recordIndexs.length; i++) {
                 rowIndexs.push(this.getBodyRowIndexByRecordIndex(recordIndexs[i]) + this.columnHeaderLevelCount);
             }
-            if (triggerEvent) {
-                this.fireListeners(TABLE_EVENT_TYPE.DELETE_RECORD, {
-                    recordIndexs,
-                    records: deletedRecords,
-                    rowIndexs,
-                    deletedCount: Array.isArray(recordIndexs[0])
-                        ? recordIndexs.length
-                        : recordIndexs.length
-                });
-            }
+            this.fireListeners(TABLE_EVENT_TYPE.DELETE_RECORD, {
+                recordIndexs,
+                rowIndexs,
+                deletedCount: Array.isArray(recordIndexs[0])
+                    ? recordIndexs.length
+                    : recordIndexs.length
+            });
         }
-        updateRecords(records, recordIndexs, triggerEvent = true) {
+        updateRecords(records, recordIndexs) {
             listTableUpdateRecords(records, recordIndexs, this);
-            if (triggerEvent) {
-                this.fireListeners(TABLE_EVENT_TYPE.UPDATE_RECORD, {
-                    records,
-                    recordIndexs,
-                    updateCount: records.length
-                });
-            }
+            this.fireListeners(TABLE_EVENT_TYPE.UPDATE_RECORD, {
+                records,
+                recordIndexs,
+                updateCount: records.length
+            });
         }
         _hasCustomRenderOrLayout() {
             const { headerObjects } = this.internalProps.layoutMap;
@@ -87781,53 +87577,93 @@
             return null;
         }
         _generateChartState() {
+            const select_filter = (datum) => {
+                if (this._table._selectedDataItemsInChart.length >= 1) {
+                    const match = this._table._selectedDataItemsInChart.find(item => {
+                        for (const itemKey in item) {
+                            if (typeof item[itemKey] !== 'object' && item[itemKey] !== datum[itemKey]) {
+                                return false;
+                            }
+                        }
+                        return true;
+                    });
+                    return !!match;
+                }
+                else if (this._table._selectedDimensionInChart?.length) {
+                    const match = this._table._selectedDimensionInChart.every(item => {
+                        if (typeof item.value !== 'object' && datum[item.key] !== item.value) {
+                            return false;
+                        }
+                        return true;
+                    });
+                    return !!match;
+                }
+                return false;
+            };
+            const selected_reverse = (datum) => {
+                if (this._table._selectedDataItemsInChart.length >= 1) {
+                    const match = this._table._selectedDataItemsInChart.find(item => {
+                        for (const itemKey in item) {
+                            if (typeof item[itemKey] !== 'object' && item[itemKey] !== datum[itemKey]) {
+                                return false;
+                            }
+                        }
+                        return true;
+                    });
+                    return !match;
+                }
+                else if (this._table._selectedDimensionInChart?.length) {
+                    const match = this._table._selectedDimensionInChart.every(item => {
+                        if (typeof item.value !== 'object' && datum[item.key] !== item.value) {
+                            return false;
+                        }
+                        return true;
+                    });
+                    return !match;
+                }
+                return false;
+            };
             const state = {
                 vtable_selected: {
                     filter: (datum) => {
-                        if (this._table._selectedDataItemsInChart.length >= 1) {
-                            const match = this._table._selectedDataItemsInChart.find(item => {
-                                for (const itemKey in item) {
-                                    if (typeof item[itemKey] !== 'object' && item[itemKey] !== datum[itemKey]) {
-                                        return false;
-                                    }
-                                }
-                                return true;
-                            });
-                            return !!match;
+                        if (this._table.options.chartDimensionLinkage?.selectedStateFilter) {
+                            return this._table.options.chartDimensionLinkage.selectedStateFilter(datum);
                         }
-                        else if (this._table._selectedDimensionInChart?.length) {
-                            const match = this._table._selectedDimensionInChart.every(item => {
-                                if (typeof item.value !== 'object' && datum[item.key] !== item.value) {
-                                    return false;
-                                }
-                                return true;
-                            });
-                            return !!match;
+                        if (this._table._selectedDataMode === 'click') {
+                            return select_filter(datum);
                         }
                         return false;
                     }
                 },
                 vtable_selected_reverse: {
                     filter: (datum) => {
-                        if (this._table._selectedDataItemsInChart.length >= 1) {
-                            const match = this._table._selectedDataItemsInChart.find(item => {
-                                for (const itemKey in item) {
-                                    if (typeof item[itemKey] !== 'object' && item[itemKey] !== datum[itemKey]) {
-                                        return false;
-                                    }
-                                }
-                                return true;
-                            });
-                            return !match;
+                        if (this._table.options.chartDimensionLinkage?.selectedReverseStateFilter) {
+                            return this._table.options.chartDimensionLinkage.selectedReverseStateFilter(datum);
                         }
-                        else if (this._table._selectedDimensionInChart?.length) {
-                            const match = this._table._selectedDimensionInChart.every(item => {
-                                if (typeof item.value !== 'object' && datum[item.key] !== item.value) {
-                                    return false;
-                                }
-                                return true;
-                            });
-                            return !match;
+                        if (this._table._selectedDataMode === 'click') {
+                            return selected_reverse(datum);
+                        }
+                        return false;
+                    }
+                },
+                inBrush: {
+                    filter: (datum) => {
+                        if (this._table.options.chartDimensionLinkage?.inBrushStateFilter) {
+                            return this._table.options.chartDimensionLinkage.inBrushStateFilter(datum);
+                        }
+                        if (this._table._selectedDataMode === 'brush') {
+                            return select_filter(datum);
+                        }
+                        return false;
+                    }
+                },
+                outOfBrush: {
+                    filter: (datum) => {
+                        if (this._table.options.chartDimensionLinkage?.outOfBrushStateFilter) {
+                            return this._table.options.chartDimensionLinkage.outOfBrushStateFilter(datum);
+                        }
+                        if (this._table._selectedDataMode === 'brush') {
+                            return selected_reverse(datum);
                         }
                         return false;
                     }
@@ -92099,6 +91935,7 @@
         pivotSortState;
         dataset;
         _selectedDataItemsInChart = [];
+        _selectedDataMode = 'click';
         _selectedDimensionInChart = [];
         _chartEventMap = {};
         _axes;
@@ -93288,6 +93125,12 @@
             const headerNodes = layoutMap.getCellHeaderPathsWithTreeNode(col, row);
             return headerNodes;
         }
+        disableTooltipToAllChartInstances() {
+            disableTooltipToAllChartInstances();
+        }
+        enableTooltipToAllChartInstances() {
+            enableTooltipToAllChartInstances();
+        }
     }
 
     class Circle extends Circle$1 {
@@ -93849,7 +93692,7 @@
     }
 
     registerForVrender();
-    const version = "1.22.11-alpha.7";
+    const version = "1.22.11-alpha.8";
     function getIcons() {
         return get$2();
     }