@visactor/vtable 0.23.0-alpha.0 → 0.23.0

package/dist/vtable.js

@@ -21687,6 +21687,7 @@
         _padding;
         _defaultPadding = [10, 16, 10, 16];
         _textStick;
+        _textStickBaseOnAlign;
         _textOverflow;
         _textAlign;
         _textBaseline;
@@ -21725,6 +21726,7 @@
             this._borderColor = style?.borderColor ?? bodyStyle?.borderColor;
             this._textOverflow = style?.textOverflow ?? bodyStyle?.textOverflow;
             this._textStick = style.textStick ?? bodyStyle?.textStick ?? false;
+            this._textStickBaseOnAlign = style.textStickBaseOnAlign ?? bodyStyle?.textStickBaseOnAlign ?? false;
             this._bgColor = style?.bgColor ?? bodyStyle?.bgColor;
             this._lineHeight = style?.lineHeight ?? bodyStyle?.lineHeight;
             this._underline = style?.underline ?? bodyStyle?.underline;
@@ -21806,6 +21808,12 @@
         set textStick(textStick) {
             this._textStick = textStick;
         }
+        get textStickBaseOnAlign() {
+            return this._textStickBaseOnAlign;
+        }
+        set textStickBaseOnAlign(textStickBaseOnAlign) {
+            this._textStickBaseOnAlign = textStickBaseOnAlign;
+        }
         get textAlign() {
             return this._textAlign;
         }
@@ -22089,6 +22097,7 @@
         _padding;
         _defaultPadding = [10, 16, 10, 16];
         _textStick;
+        _textStickBaseOnAlign;
         _marked;
         _textAlign;
         _textBaseline;
@@ -22122,6 +22131,7 @@
             this._fontStyle = style.fontStyle ?? headerStyle?.fontStyle;
             this._textOverflow = (style.textOverflow ?? headerStyle?.textOverflow) || 'ellipsis';
             this._textStick = style.textStick ?? headerStyle?.textStick ?? false;
+            this._textStickBaseOnAlign = style.textStickBaseOnAlign ?? headerStyle?.textStickBaseOnAlign ?? false;
             this._marked = style.marked ?? headerStyle?.marked ?? false;
             this._textAlign = (style.textAlign ?? headerStyle?.textAlign) || 'left';
             this._textBaseline = (style.textBaseline ?? headerStyle?.textBaseline) || 'middle';
@@ -22207,6 +22217,12 @@
         set textStick(textStick) {
             this._textStick = textStick;
         }
+        get textStickBaseOnAlign() {
+            return this._textStickBaseOnAlign;
+        }
+        set textStickBaseOnAlign(textStickBaseOnAlign) {
+            this._textStickBaseOnAlign = textStickBaseOnAlign;
+        }
         get marked() {
             return this._marked;
         }
@@ -22779,22 +22795,6 @@
         }
         return res;
     }
-    function getValueFromDeepArray(array, index) {
-        let result = array;
-        for (let i = 0; i < index.length; i++) {
-            const currentIdx = index[i];
-            if (result[currentIdx]) {
-                result = result[currentIdx];
-            }
-            else {
-                return undefined;
-            }
-            if (result && result.children && i + 1 < index.length) {
-                result = result.children;
-            }
-        }
-        return result;
-    }
     function isAllDigits(str) {
         const pattern = /^-?\d+(\.\d+)?$/;
         return pattern.test(str);
@@ -23031,6 +23031,8 @@
         SORT_CLICK: 'sort_click',
         FREEZE_CLICK: 'freeze_click',
         SCROLL: 'scroll',
+        SCROLL_HORIZONTAL_END: 'scroll_horizontal_end',
+        SCROLL_VERTICAL_END: 'scroll_vertical_end',
         DROPDOWN_MENU_CLICK: 'dropdown_menu_click',
         MOUSEOVER_CHART_SYMBOL: 'mouseover_chart_symbol',
         DRAG_SELECT_END: 'drag_select_end',
@@ -24109,9 +24111,9 @@
     };
 
     function getProp$1(obj, superObj, names, defNames) {
-        return (getChainSafe(obj, ...names) ||
-            getChainSafe(superObj, ...names) ||
-            (defNames && getChainSafe(obj, ...defNames)) ||
+        return (getChainSafe(obj, ...names) ??
+            getChainSafe(superObj, ...names) ??
+            (defNames && getChainSafe(obj, ...defNames)) ??
             (defNames && getChainSafe(superObj, ...defNames)));
     }
     class TableTheme {
@@ -24153,7 +24155,7 @@
         }
         get cellInnerBorder() {
             const { obj, superTheme } = this.internalTheme;
-            return !!getProp$1(obj, superTheme, ['cellInnerBorder']);
+            return getProp$1(obj, superTheme, ['cellInnerBorder']) ?? true;
         }
         get cellBorderClipDirection() {
             const { obj, superTheme } = this.internalTheme;
@@ -24419,6 +24421,9 @@
                     },
                     get hoverOn() {
                         return scroll.hoverOn ?? true;
+                    },
+                    get barToSide() {
+                        return scroll.barToSide ?? false;
                     }
                 };
             }
@@ -33563,16 +33568,18 @@
         hasHierarchyStateExpand = false;
         beforeChangedRecordsMap = [];
         registedAggregators = {};
+        rowHierarchyType;
         fieldAggregators = [];
         layoutColumnObjects = [];
+        lastFilterRules;
         constructor(dataSourceObj, dataConfig, pagination, columnObjs, rowHierarchyType, hierarchyExpandLevel) {
             super();
             this.registerAggregators();
             this.dataSourceObj = dataSourceObj;
             this.dataConfig = dataConfig;
-            this._get = dataSourceObj?.get.bind(dataSourceObj) || undefined;
+            this._get = dataSourceObj?.get;
             this.layoutColumnObjects = columnObjs;
-            this._source = this.processRecords(dataSourceObj?.source ?? dataSourceObj);
+            this._source = dataSourceObj?.records ? this.processRecords(dataSourceObj?.records) : dataSourceObj;
             this._sourceLength = this._source?.length || 0;
             this.sortedIndexMap = new Map();
             this._currentPagerIndexedData = [];
@@ -33589,6 +33596,7 @@
             if (rowHierarchyType === 'tree') {
                 this.initTreeHierarchyState();
             }
+            this.rowHierarchyType = rowHierarchyType;
             this.updatePagerData();
         }
         initTreeHierarchyState() {
@@ -33597,7 +33605,8 @@
             for (let i = 0; i < nodeLength; i++) {
                 const indexKey = this.currentIndexedData[i];
                 const nodeData = this.getOriginalRecord(indexKey);
-                if (nodeData.children?.length > 0) {
+                const children = nodeData.filteredChildren ?? nodeData.children;
+                if (children?.length > 0) {
                     if (this.hierarchyExpandLevel > 1) {
                         !nodeData.hierarchyState && (nodeData.hierarchyState = HierarchyState.expand);
                     }
@@ -33661,26 +33670,46 @@
             this._generateFieldAggragations();
             const filteredRecords = [];
             const isHasAggregation = this.fieldAggregators.length >= 1;
-            const isHasFilterRule = this.dataConfig?.filterRules?.length >= 1;
+            const isHasFilterRule = this.dataConfig?.filterRules?.length >= 1 || this.lastFilterRules?.length >= 1;
             if (isHasFilterRule || isHasAggregation) {
                 for (let i = 0, len = records.length; i < len; i++) {
                     const record = records[i];
-                    if (isHasFilterRule) {
+                    if (this.dataConfig?.filterRules?.length >= 1) {
                         if (this.filterRecord(record)) {
                             filteredRecords.push(record);
+                            if (this.rowHierarchyType === 'tree' && record.children) {
+                                record.filteredChildren = this.filteredChildren(record.children);
+                            }
                             isHasAggregation && this.processRecord(record);
                         }
                     }
+                    else if (this.lastFilterRules?.length >= 1) {
+                        this.clearFilteredChildren(record);
+                        isHasAggregation && this.processRecord(record);
+                    }
                     else if (isHasAggregation) {
                         this.processRecord(record);
                     }
                 }
-                if (isHasFilterRule) {
+                if (this.dataConfig?.filterRules?.length >= 1) {
                     return filteredRecords;
                 }
             }
             return records;
         }
+        filteredChildren(records) {
+            const filteredRecords = [];
+            for (let i = 0, len = records.length; i < len; i++) {
+                const record = records[i];
+                if (this.filterRecord(record)) {
+                    filteredRecords.push(record);
+                    if (record.children) {
+                        record.filteredChildren = this.filteredChildren(record.children);
+                    }
+                }
+            }
+            return filteredRecords;
+        }
         processRecord(record) {
             for (let i = 0; i < this.fieldAggregators.length; i++) {
                 const aggregator = this.fieldAggregators[i];
@@ -33689,17 +33718,17 @@
         }
         initChildrenNodeHierarchy(indexKey, hierarchyExpandLevel, currentLevel, nodeData) {
             let childTotalLength = 0;
-            const nodeLength = nodeData.children?.length ?? 0;
+            const nodeLength = nodeData.filteredChildren ? nodeData.filteredChildren.length : nodeData.children?.length ?? 0;
             for (let j = 0; j < nodeLength; j++) {
                 if (currentLevel <= hierarchyExpandLevel || nodeData.hierarchyState === HierarchyState.expand) {
                     childTotalLength += 1;
                 }
-                const childNodeData = nodeData.children[j];
+                const childNodeData = nodeData.filteredChildren ? nodeData.filteredChildren[j] : nodeData.children[j];
                 const childIndexKey = Array.isArray(indexKey) ? indexKey.concat(j) : [indexKey, j];
                 if (currentLevel <= hierarchyExpandLevel || nodeData.hierarchyState === HierarchyState.expand) {
                     this.currentIndexedData.splice(this.currentIndexedData.indexOf(indexKey) + childTotalLength, 0, childIndexKey);
                 }
-                if (childNodeData.children?.length > 0) {
+                if (childNodeData.filteredChildren ? childNodeData.filteredChildren.length > 0 : childNodeData.children?.length > 0) {
                     if (currentLevel < hierarchyExpandLevel || childNodeData.hierarchyState === HierarchyState.expand) {
                         !childNodeData.hierarchyState && (childNodeData.hierarchyState = HierarchyState.expand);
                         this.hasHierarchyStateExpand = true;
@@ -33747,6 +33776,9 @@
                 throw new Error(`currentIndexedData should has values!`);
             }
         }
+        get records() {
+            return Array.isArray(this._source) ? this._source : [];
+        }
         get source() {
             return this._source;
         }
@@ -33795,11 +33827,12 @@
                     if (!hierarchyState || hierarchyState === HierarchyState.collapse || hierarchyState === HierarchyState.none) {
                         return;
                     }
-                    if (nodeData.children) {
-                        for (let i = 0; i < nodeData.children.length; i++) {
+                    const children = nodeData.filteredChildren ? nodeData.filteredChildren : nodeData.children;
+                    if (children) {
+                        for (let i = 0; i < children.length; i++) {
                             childrenLength += 1;
                             const childIndex = Array.isArray(indexKey) ? indexKey.concat([i]) : [indexKey, i];
-                            computeChildrenNodeLength(childIndex, nodeData.children[i].hierarchyState, nodeData.children[i]);
+                            computeChildrenNodeLength(childIndex, children[i].hierarchyState, children[i]);
                         }
                     }
                 };
@@ -33816,8 +33849,9 @@
                 return 0;
             }
             let childrenLength = 0;
-            if (nodeData.children) {
-                const subNodeSortedIndexArray = Array.from({ length: nodeData.children.length }, (_, i) => i);
+            const children = nodeData.filteredChildren ? nodeData.filteredChildren : nodeData.children;
+            if (children) {
+                const subNodeSortedIndexArray = Array.from({ length: children.length }, (_, i) => i);
                 this.lastOrder &&
                     this.lastOrder !== 'normal' &&
                     this.lastOrderField &&
@@ -33825,7 +33859,7 @@
                         ? subNodeSortedIndexArray[index]
                         : (subNodeSortedIndexArray[index] = index), (index, rel) => {
                         subNodeSortedIndexArray[index] = rel;
-                    }, nodeData.children.length, this.lastOrderFn, this.lastOrder, index => this.getOriginalField(Array.isArray(indexKey) ? indexKey.concat([index]) : [indexKey, index], this.lastOrderField));
+                    }, children.length, this.lastOrderFn, this.lastOrder, index => this.getOriginalField(Array.isArray(indexKey) ? indexKey.concat([index]) : [indexKey, index], this.lastOrderField));
                 for (let i = 0; i < subNodeSortedIndexArray.length; i++) {
                     childrenLength += 1;
                     const childIndex = Array.isArray(indexKey)
@@ -33833,10 +33867,10 @@
                         : [indexKey, subNodeSortedIndexArray[i]];
                     this.currentIndexedData.splice(this.currentIndexedData.indexOf(indexKey) + childrenLength, 0, childIndex);
                     const childData = this.getOriginalRecord(childIndex);
-                    if (!nodeData.children[i].hierarchyState && childData.children) {
-                        nodeData.children[i].hierarchyState = HierarchyState.collapse;
+                    if (!childData.hierarchyState && (childData.filteredChildren ?? childData.children)) {
+                        childData.hierarchyState = HierarchyState.collapse;
                     }
-                    childrenLength += this.pushChildrenNode(childIndex, nodeData.children[i].hierarchyState, nodeData.children[subNodeSortedIndexArray[i]]);
+                    childrenLength += this.pushChildrenNode(childIndex, childData.hierarchyState, children[subNodeSortedIndexArray[i]]);
                 }
             }
             return childrenLength;
@@ -33873,121 +33907,153 @@
             }
         }
         setRecord(record, index) {
-            const indexed = this.getIndexKey(index);
-            if (!Array.isArray(indexed)) {
-                this.source.splice(indexed, 1, record);
+            let isAdd = true;
+            if (this.dataConfig?.filterRules?.length >= 1) {
+                if (this.filterRecord(record)) {
+                    if (this.rowHierarchyType === 'tree' && record.children) {
+                        record.filteredChildren = this.filteredChildren(record.children);
+                    }
+                }
+                else {
+                    isAdd = false;
+                }
             }
-            else {
-                const c_node_index = indexed[indexed.length - 1];
-                const p_node = this.getOriginalRecord(indexed.slice(0, indexed.length - 1));
-                p_node.children.splice(c_node_index, 1, record);
+            if (isAdd && Array.isArray(this.records)) {
+                const indexed = this.getIndexKey(index);
+                if (!Array.isArray(indexed)) {
+                    this.records.splice(indexed, 1, record);
+                }
             }
         }
         addRecord(record, index) {
-            this.source.splice(index, 0, record);
-            this.currentIndexedData.push(this.currentIndexedData.length);
-            this._sourceLength += 1;
-            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) {
+            if (Array.isArray(this.records)) {
+                this.records.splice(index, 0, record);
+                this.currentIndexedData.push(this.currentIndexedData.length);
+                this._sourceLength += 1;
+                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;
                     this.updatePagerData();
                 }
-            }
-            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) {
-            if (Array.isArray(recordArr)) {
-                this.source.splice(index, 0, ...recordArr);
-                for (let i = 0; i < recordArr.length; i++) {
-                    this.currentIndexedData.push(this.currentIndexedData.length);
+            if (Array.isArray(this.records)) {
+                if (Array.isArray(recordArr)) {
+                    this.records.splice(index, 0, ...recordArr);
+                    for (let i = 0; i < recordArr.length; i++) {
+                        this.currentIndexedData.push(this.currentIndexedData.length);
+                    }
+                    this._sourceLength += recordArr.length;
                 }
-                this._sourceLength += recordArr.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) {
+                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;
                     this.updatePagerData();
                 }
-            }
-            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) {
-            this.source.push(record);
-            this.currentIndexedData.push(this.currentIndexedData.length);
-            this._sourceLength += 1;
-            this.sortedIndexMap.clear();
-            if (!this.userPagination) {
-                this.pagination.perPageCount = this._sourceLength;
-                this.pagination.totalCount = this._sourceLength;
+            if (Array.isArray(this.records)) {
+                this.records.push(record);
+                this.currentIndexedData.push(this.currentIndexedData.length);
+                this._sourceLength += 1;
+                this.sortedIndexMap.clear();
+                if (!this.userPagination) {
+                    this.pagination.perPageCount = this._sourceLength;
+                    this.pagination.totalCount = this._sourceLength;
+                }
             }
         }
         addRecordsForSorted(recordArr) {
-            if (Array.isArray(recordArr)) {
-                this.source.push(...recordArr);
-                for (let i = 0; i < recordArr.length; i++) {
-                    this.currentIndexedData.push(this.currentIndexedData.length);
+            if (Array.isArray(this.records)) {
+                if (Array.isArray(recordArr)) {
+                    this.records.push(...recordArr);
+                    for (let i = 0; i < recordArr.length; i++) {
+                        this.currentIndexedData.push(this.currentIndexedData.length);
+                    }
+                    this._sourceLength += recordArr.length;
+                    this.sortedIndexMap.clear();
+                }
+                if (!this.userPagination) {
+                    this.pagination.perPageCount = this._sourceLength;
+                    this.pagination.totalCount = this._sourceLength;
                 }
-                this._sourceLength += recordArr.length;
-                this.sortedIndexMap.clear();
-            }
-            if (!this.userPagination) {
-                this.pagination.perPageCount = this._sourceLength;
-                this.pagination.totalCount = this._sourceLength;
             }
         }
         deleteRecords(recordIndexs) {
-            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 (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;
+                    }
+                    realDeletedRecordIndexs.push(recordIndex);
+                    this.records.splice(recordIndex, 1);
+                    this.currentIndexedData.pop();
+                    this._sourceLength -= 1;
                 }
-                realDeletedRecordIndexs.push(recordIndex);
-                this.source.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();
+                if (this.userPagination) {
+                    this.updatePagerData();
+                }
+                else {
+                    this.pagination.perPageCount = this._sourceLength;
+                    this.pagination.totalCount = this._sourceLength;
+                    this.updatePagerData();
+                }
+                if (this.dataSourceObj?.deleted) {
+                    this.dataSourceObj.deleted(realDeletedRecordIndexs);
+                }
+                return realDeletedRecordIndexs;
             }
-            return realDeletedRecordIndexs;
+            return [];
         }
         deleteRecordsForSorted(recordIndexs) {
-            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 (Array.isArray(this.records)) {
+                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;
+                    }
+                    const rawIndex = this.currentIndexedData[recordIndex];
+                    this.records.splice(rawIndex, 1);
+                    this._sourceLength -= 1;
+                }
+                this.sortedIndexMap.clear();
+                if (!this.userPagination) {
+                    this.pagination.perPageCount = this._sourceLength;
+                    this.pagination.totalCount = this._sourceLength;
                 }
-                const rawIndex = this.currentIndexedData[recordIndex];
-                this.source.splice(rawIndex, 1);
-                this._sourceLength -= 1;
-            }
-            this.sortedIndexMap.clear();
-            if (!this.userPagination) {
-                this.pagination.perPageCount = this._sourceLength;
-                this.pagination.totalCount = this._sourceLength;
             }
         }
         updateRecords(records, recordIndexs) {
@@ -33998,7 +34064,7 @@
                     continue;
                 }
                 realDeletedRecordIndexs.push(recordIndex);
-                this.source[recordIndex] = records[index];
+                this.records[recordIndex] = records[index];
             }
             if (this.userPagination) {
                 this.updatePagerData();
@@ -34015,7 +34081,7 @@
                 if (typeof rawIndex !== 'number') {
                     return;
                 }
-                this.source[rawIndex] = records[index];
+                this.records[rawIndex] = records[index];
             }
             this.sortedIndexMap.clear();
         }
@@ -34066,9 +34132,15 @@
             this.updatePagerData();
             this.fireListeners(EVENT_TYPE.CHANGE_ORDER, null);
         }
+        clearFilteredChildren(record) {
+            record.filteredChildren = undefined;
+            for (let i = 0; i < record.children?.length ?? 0; i++) {
+                this.clearFilteredChildren(record.children[i]);
+            }
+        }
         filterRecord(record) {
             let isReserved = true;
-            for (let i = 0; i < this.dataConfig.filterRules.length; i++) {
+            for (let i = 0; i < this.dataConfig.filterRules?.length; i++) {
                 const filterRule = this.dataConfig?.filterRules[i];
                 if (filterRule.filterKey) {
                     const filterValue = record[filterRule.filterKey];
@@ -34085,8 +34157,9 @@
             return isReserved;
         }
         updateFilterRulesForSorted(filterRules) {
+            this.lastFilterRules = this.dataConfig.filterRules;
             this.dataConfig.filterRules = filterRules;
-            this._source = this.processRecords(this.dataSourceObj?.source ?? this.dataSourceObj);
+            this._source = this.processRecords(this.dataSourceObj?.records ?? this.dataSourceObj);
             this._sourceLength = this._source?.length || 0;
             this.sortedIndexMap.clear();
             this.currentIndexedData = Array.from({ length: this._sourceLength }, (_, i) => i);
@@ -34096,8 +34169,9 @@
             }
         }
         updateFilterRules(filterRules) {
+            this.lastFilterRules = this.dataConfig.filterRules;
             this.dataConfig.filterRules = filterRules;
-            this._source = this.processRecords(this.dataSourceObj?.source ?? this.dataSourceObj);
+            this._source = this.processRecords(this.dataSourceObj?.records ?? this.dataSourceObj);
             this._sourceLength = this._source?.length || 0;
             this.currentIndexedData = Array.from({ length: this._sourceLength }, (_, i) => i);
             if (this.userPagination) {
@@ -34106,6 +34180,9 @@
             else {
                 this.pagination.perPageCount = this._sourceLength;
                 this.pagination.totalCount = this._sourceLength;
+                if (this.rowHierarchyType === 'tree') {
+                    this.initTreeHierarchyState();
+                }
                 this.updatePagerData();
             }
         }
@@ -34154,6 +34231,7 @@
         }
         release() {
             super.release?.();
+            this.lastFilterRules = null;
         }
         clearSortedMap() {
             this.currentIndexedData && (this.currentIndexedData.length = 0);
@@ -34169,10 +34247,19 @@
             this.currentPagerIndexedData.length = 0;
         }
         getOriginalRecord(dataIndex) {
-            if (this.dataConfig?.filterRules) {
-                return this.source[dataIndex];
+            let data;
+            if (!this.dataSourceObj.records) {
+                data = this._get(dataIndex);
+            }
+            else {
+                if (Array.isArray(dataIndex)) {
+                    data = getValueFromDeepArray(this.records, dataIndex);
+                }
+                else {
+                    data = this.records[dataIndex];
+                }
             }
-            return getValue(this._get(dataIndex), (val) => {
+            return getValue(data, (val) => {
                 this.recordPromiseCallBack(dataIndex, val);
             });
         }
@@ -34180,7 +34267,19 @@
             if (this.beforeChangedRecordsMap?.[dataIndex]) {
                 return this.beforeChangedRecordsMap[dataIndex];
             }
-            return getValue(this._get(dataIndex), (val) => {
+            let data;
+            if (!this.dataSourceObj.records) {
+                data = this._get(dataIndex);
+            }
+            else {
+                if (Array.isArray(dataIndex)) {
+                    data = getValueFromDeepArray(this.records, dataIndex);
+                }
+                else {
+                    data = this.records[dataIndex];
+                }
+            }
+            return getValue(data, (val) => {
                 this.recordPromiseCallBack(dataIndex, val);
             });
         }
@@ -34304,30 +34403,32 @@
                         targetI = targetIndexs.splice(targetIndexs.length - 1, 1)[0];
                         if (sourceIndexs.length >= 1) {
                             const parent = this.getOriginalRecord(sourceIndexs);
-                            const sourceIds = parent.children.splice(sourceI, 1);
+                            const sourceIds = parent.filteredChildren
+                                ? parent.filteredChildren.splice(sourceI, 1)
+                                : parent.children.splice(sourceI, 1);
                             sourceIds.unshift(targetI, 0);
-                            Array.prototype.splice.apply(parent.children, sourceIds);
+                            Array.prototype.splice.apply(parent.filteredChildren ?? parent.children, sourceIds);
                         }
                         else {
-                            const sourceIds = this.source.splice(sourceI, 1);
+                            const sourceIds = this.records.splice(sourceI, 1);
                             sourceIds.unshift(targetI, 0);
-                            Array.prototype.splice.apply(this.source, sourceIds);
+                            Array.prototype.splice.apply(this.records, sourceIds);
                         }
                     }
                     else {
                         sourceI = this.currentPagerIndexedData[sourceIndex];
                         targetI = this.currentPagerIndexedData[targetIndex];
-                        const records = this.source.splice(sourceI, 1);
+                        const records = this.records.splice(sourceI, 1);
                         records.unshift(targetI, 0);
-                        Array.prototype.splice.apply(this.source, records);
+                        Array.prototype.splice.apply(this.records, records);
                     }
                     this.restoreTreeHierarchyState();
                     this.updatePagerData();
                 }
                 else {
-                    const records = this.source.splice(sourceIndex, 1);
+                    const records = this.records.splice(sourceIndex, 1);
                     records.unshift(targetIndex, 0);
-                    Array.prototype.splice.apply(this.source, records);
+                    Array.prototype.splice.apply(this.records, records);
                 }
             }
         }
@@ -34335,14 +34436,16 @@
             if (this.hierarchyExpandLevel) {
                 for (let i = 0; i < this._sourceLength; i++) {
                     const nodeData = this.getOriginalRecord(i);
-                    nodeData.children && !nodeData.hierarchyState && (nodeData.hierarchyState = HierarchyState.collapse);
+                    const children = nodeData.filteredChildren ?? nodeData.children;
+                    children && !nodeData.hierarchyState && (nodeData.hierarchyState = HierarchyState.collapse);
                 }
                 this.currentIndexedData = Array.from({ length: this._sourceLength }, (_, i) => i);
                 let nodeLength = this._sourceLength;
                 for (let i = 0; i < nodeLength; i++) {
                     const indexKey = this.currentIndexedData[i];
                     const nodeData = this.getOriginalRecord(indexKey);
-                    if (nodeData.children?.length > 0 && nodeData.hierarchyState === HierarchyState.expand) {
+                    const children = nodeData.filteredChildren ?? nodeData.children;
+                    if (children?.length > 0 && nodeData.hierarchyState === HierarchyState.expand) {
                         this.hasHierarchyStateExpand = true;
                         const childrenLength = this.restoreChildrenNodeHierarchy(indexKey, nodeData);
                         i += childrenLength;
@@ -34356,12 +34459,13 @@
         }
         restoreChildrenNodeHierarchy(indexKey, nodeData) {
             let childTotalLength = 0;
-            const nodeLength = nodeData.children?.length ?? 0;
+            const children = nodeData.filteredChildren ?? nodeData.children;
+            const nodeLength = children?.length ?? 0;
             for (let j = 0; j < nodeLength; j++) {
                 if (nodeData.hierarchyState === HierarchyState.expand) {
                     childTotalLength += 1;
                 }
-                const childNodeData = nodeData.children[j];
+                const childNodeData = children[j];
                 const childIndexKey = Array.isArray(indexKey) ? indexKey.concat(j) : [indexKey, j];
                 if (nodeData.hierarchyState === HierarchyState.expand) {
                     this.currentIndexedData.splice(this.currentIndexedData.indexOf(indexKey) + childTotalLength, 0, childIndexKey);
@@ -34371,6 +34475,23 @@
             return childTotalLength;
         }
     }
+    function getValueFromDeepArray(array, index) {
+        let result = array;
+        for (let i = 0; i < index.length; i++) {
+            const currentIdx = index[i];
+            if (result[currentIdx]) {
+                result = result[currentIdx];
+            }
+            else {
+                return undefined;
+            }
+            const children = result.filteredChildren ?? result?.children;
+            if (children && i + 1 < index.length) {
+                result = children;
+            }
+        }
+        return result;
+    }
 
     function _setFieldCache(fCache, index, field, value) {
         const recCache = fCache[index] || (fCache[index] = new Map());
@@ -34385,18 +34506,15 @@
         static ofArray(array, dataConfig, pagination, columnObjs, rowHierarchyType, hierarchyExpandLevel) {
             return new CachedDataSource({
                 get: (index) => {
-                    if (Array.isArray(index)) {
-                        return getValueFromDeepArray(array, index);
-                    }
                     return array[index];
                 },
                 length: array.length,
-                source: array
+                records: array
             }, dataConfig, pagination, columnObjs, rowHierarchyType, hierarchyExpandLevel);
         }
         constructor(opt, dataConfig, pagination, columnObjs, rowHierarchyType, hierarchyExpandLevel) {
             super(opt, dataConfig, pagination, columnObjs, rowHierarchyType, hierarchyExpandLevel);
-            this._recordCache = {};
+            this._recordCache = [];
             this._fieldCache = {};
         }
         getOriginalRecord(index) {
@@ -34417,7 +34535,7 @@
         }
         clearCache() {
             if (this._recordCache) {
-                this._recordCache = {};
+                this._recordCache = [];
             }
             if (this._fieldCache) {
                 this._fieldCache = {};
@@ -34429,8 +34547,13 @@
         recordPromiseCallBack(index, record) {
             this._recordCache[index] = record;
         }
+        get records() {
+            return Array.isArray(this._recordCache) && this._recordCache.length > 0 ? this._recordCache : super.records;
+        }
         release() {
             super.release?.();
+            this._recordCache = null;
+            this._fieldCache = null;
         }
     }
 
@@ -34913,9 +35036,8 @@
     }
     function _setRecords(table, records = []) {
         _dealWithUpdateDataSource(table, () => {
-            const data = records;
             table.internalProps.records = records;
-            const newDataSource = (table.internalProps.dataSource = CachedDataSource.ofArray(data, table.internalProps.dataConfig, table.pagination, table.internalProps.layoutMap.columnObjects, table.internalProps.layoutMap.rowHierarchyType, table.options.hierarchyExpandLevel ?? (table._hasHierarchyTreeHeader?.() ? 1 : undefined)));
+            const newDataSource = (table.internalProps.dataSource = CachedDataSource.ofArray(records, table.internalProps.dataConfig, table.pagination, table.internalProps.layoutMap.columnObjects, table.internalProps.layoutMap.rowHierarchyType, table.options.hierarchyExpandLevel ?? (table._hasHierarchyTreeHeader?.() ? 1 : undefined)));
             table.addReleaseObj(newDataSource);
         });
     }
@@ -36149,11 +36271,12 @@
     }
 
     function getCellBorderStrokeWidth(col, row, cellTheme, table) {
+        const frameBorderLineWidths = style.toBoxArray(table.internalProps.theme.frameStyle?.borderLineWidth ?? [null]);
         let strokeArrayWidth = cellTheme?.group?.strokeArrayWidth ?? undefined;
-        if (!table.theme.cellInnerBorder) {
+        if (table.theme.cellInnerBorder) {
             return strokeArrayWidth;
         }
-        if (col === 0) {
+        if (col === 0 && frameBorderLineWidths[3]) {
             strokeArrayWidth = strokeArrayWidth ?? [
                 cellTheme?.group?.lineWidth,
                 cellTheme?.group?.lineWidth,
@@ -36162,7 +36285,7 @@
             ];
             strokeArrayWidth[3] = 0;
         }
-        if (col === table.colCount - 1) {
+        if (col === table.colCount - 1 && frameBorderLineWidths[1]) {
             strokeArrayWidth = strokeArrayWidth ?? [
                 cellTheme?.group?.lineWidth,
                 cellTheme?.group?.lineWidth,
@@ -36171,7 +36294,7 @@
             ];
             strokeArrayWidth[1] = 0;
         }
-        if (row === 0) {
+        if (row === 0 && frameBorderLineWidths[0]) {
             strokeArrayWidth = strokeArrayWidth ?? [
                 cellTheme?.group?.lineWidth,
                 cellTheme?.group?.lineWidth,
@@ -36180,7 +36303,7 @@
             ];
             strokeArrayWidth[0] = 0;
         }
-        if (row === table.rowCount - 1) {
+        if (row === table.rowCount - 1 && frameBorderLineWidths[2]) {
             strokeArrayWidth = strokeArrayWidth ?? [
                 cellTheme?.group?.lineWidth,
                 cellTheme?.group?.lineWidth,
@@ -36457,14 +36580,34 @@
             dataValue = table.getCellOriginRecord(col, row)?.[progressBarDefine.dependField] ?? dataValue;
         }
         progressBarDefine.barType = progressBarDefine.barType ?? 'default';
-        progressBarDefine.min = progressBarDefine.min ?? 0;
-        progressBarDefine.max = progressBarDefine.max ?? progressBarDefine.min + 100;
+        progressBarDefine.min =
+            getOrApply(progressBarDefine.min, {
+                col,
+                row,
+                table,
+                value,
+                dataValue,
+                cellHeaderPaths: undefined
+            }) ?? 0;
+        progressBarDefine.max =
+            getOrApply(progressBarDefine.max, {
+                col,
+                row,
+                table,
+                value,
+                dataValue,
+                cellHeaderPaths: undefined
+            }) ?? progressBarDefine.min + 100;
         const height = table.getRowHeight(row);
         let contentWidth = width;
         let contentHeight = height;
+        let _contentOffset = 0;
+        if (isNumber$4(table.theme._contentOffset)) {
+            _contentOffset = table.theme._contentOffset;
+        }
         const percentCompleteBarGroup = new Group$1({
-            x: 0,
-            y: 0,
+            x: -_contentOffset,
+            y: -_contentOffset,
             width: contentWidth,
             height: contentHeight
         });
@@ -37673,9 +37816,9 @@
                 textConfig[0].textAlign = textAlign;
                 const text = new RichText({
                     width: autoColWidth ? 0 : cellWidth - (padding[1] + padding[3]) - leftIconWidth - rightIconWidth,
-                    height: autoRowHeight ? 0 : cellHeight - (padding[0] + padding[2]),
+                    height: autoRowHeight && autoWrapText ? 0 : Math.ceil(cellHeight - (padding[0] + padding[2])),
                     textConfig,
-                    verticalDirection: autoRowHeight ? 'top' : textBaseline,
+                    verticalDirection: autoRowHeight && autoWrapText ? 'top' : textBaseline,
                     ellipsis: textOption.ellipsis
                 });
                 text.name = 'text';
@@ -37793,7 +37936,7 @@
         }
         iconAttribute.marginLeft = (icon.marginLeft ?? 0) + hierarchyOffset;
         iconAttribute.marginRight = icon.marginRight ?? 0;
-        if (icon.interactive) {
+        if (icon.interactive === false) {
             iconAttribute.pickable = false;
         }
         if (icon.hover) {
@@ -37881,7 +38024,7 @@
             cellContent.updateWidth(distWidth - leftIconWidth - rightIconHeight - (padding[1] + padding[3]));
             contentHeight = cellContent.AABBBounds.height();
         }
-        const oldCellHeight = Math.max(leftIconHeight, rightIconHeight, oldTextHeight) + padding[0] + padding[2];
+        const oldCellHeight = Math.round(Math.max(leftIconHeight, rightIconHeight, oldTextHeight) + padding[0] + padding[2]);
         cellGroup.forEachChildren((child) => {
             if (child.role === 'icon-left') ;
             else if (child.role === 'icon-right') {
@@ -38696,7 +38839,7 @@
                 });
             }
         });
-        const lineWidth = cellGroup.attribute.lineWidth;
+        const lineWidth = cellGroup.attribute.strokeArrayWidth ?? cellGroup.attribute.lineWidth;
         const isLineWidthArray = isArray$3(lineWidth);
         const newLineWidth = [0, 0, 0, 0];
         if (col === range.start.col) {
@@ -39915,7 +40058,7 @@
         }
     }
     function computeRowHeight(row, startCol, endCol, table) {
-        let maxHeight = 0;
+        let maxHeight;
         if (table.isPivotChart() &&
             row >= table.columnHeaderLevelCount &&
             row < table.rowCount - table.bottomFrozenRowCount) {
@@ -39935,7 +40078,7 @@
         for (let col = startCol; col <= endCol; col++) {
             const customHeight = computeCustomRenderHeight(col, row, table);
             if (customHeight) {
-                maxHeight = Math.max(customHeight.height, maxHeight);
+                maxHeight = isValid$3(maxHeight) ? Math.max(customHeight.height, maxHeight) : customHeight.height;
                 if (!customHeight.renderDefault) {
                     continue;
                 }
@@ -39946,7 +40089,7 @@
                 if (axisConfig) {
                     const axisWidth = computeAxisComponentHeight(axisConfig, table);
                     if (typeof axisWidth === 'number') {
-                        maxHeight = Math.max(axisWidth, maxHeight);
+                        maxHeight = isValid$3(maxHeight) ? Math.max(axisWidth, maxHeight) : axisWidth;
                         continue;
                     }
                 }
@@ -39959,19 +40102,14 @@
             const cellType = table.isHeader(col, row)
                 ? table._getHeaderLayoutMap(col, row)?.headerType
                 : table.getBodyColumnType(col, row);
-            if (isValid$3(cellType) &&
-                cellType !== 'text' &&
-                cellType !== 'link' &&
-                cellType !== 'progressbar' &&
-                cellType !== 'checkbox') {
-                const defaultHeight = table.getDefaultRowHeight(row);
-                maxHeight = Math.max(maxHeight, isNumber$4(defaultHeight) ? defaultHeight : table.defaultRowHeight);
-                continue;
-            }
             const textHeight = computeTextHeight(col, row, cellType, table);
-            maxHeight = Math.max(textHeight, maxHeight);
+            maxHeight = isValid$3(maxHeight) ? Math.max(textHeight, maxHeight) : textHeight;
         }
-        return maxHeight;
+        if (isValid$3(maxHeight)) {
+            return maxHeight;
+        }
+        const defaultHeight = table.getDefaultRowHeight(row);
+        return isNumber$4(defaultHeight) ? defaultHeight : table.defaultRowHeight;
     }
     function checkFixedStyleAndNoWrap(table) {
         const { layoutMap } = table.internalProps;
@@ -40167,87 +40305,108 @@
         const fontFamily = getProp('fontFamily', actStyle, col, row, table);
         const autoWrapText = getProp('autoWrapText', actStyle, col, row, table);
         let text;
-        if (cellType === 'checkbox') {
-            text = isObject$4(cellValue) ? cellValue.text : cellValue;
+        if (cellType !== 'text' && cellType !== 'link' && cellType !== 'progressbar' && cellType !== 'checkbox') {
+            maxHeight = lineHeight;
         }
         else {
-            text = cellValue;
-        }
-        const lines = validToString(text).split('\n') || [];
-        const cellWidth = table.getColsWidth(col, endCol);
-        if (cellType === 'checkbox') {
-            const size = getProp('size', actStyle, col, row, table);
-            if (autoWrapText) {
-                const spaceBetweenTextAndIcon = getProp('spaceBetweenTextAndIcon', actStyle, col, row, table);
-                const maxLineWidth = cellWidth - (padding[1] + padding[3]) - iconWidth - size - spaceBetweenTextAndIcon;
-                utilCheckBoxMark.setAttributes({
-                    text: {
-                        maxLineWidth,
-                        text: lines,
+            if (cellType === 'checkbox') {
+                text = isObject$4(cellValue) ? cellValue.text : cellValue;
+            }
+            else {
+                text = cellValue;
+            }
+            const lines = validToString(text).split('\n') || [];
+            const cellWidth = table.getColsWidth(col, endCol);
+            if (cellType === 'checkbox') {
+                const size = getProp('size', actStyle, col, row, table);
+                if (autoWrapText) {
+                    const spaceBetweenTextAndIcon = getProp('spaceBetweenTextAndIcon', actStyle, col, row, table);
+                    const maxLineWidth = cellWidth - (padding[1] + padding[3]) - iconWidth - size - spaceBetweenTextAndIcon;
+                    utilCheckBoxMark.setAttributes({
+                        text: {
+                            maxLineWidth,
+                            text: lines,
+                            fontSize,
+                            fontStyle,
+                            fontWeight,
+                            fontFamily,
+                            lineHeight,
+                            wordBreak: 'break-word'
+                        },
+                        icon: {
+                            width: Math.floor(size / 1.4),
+                            height: Math.floor(size / 1.4)
+                        },
+                        box: {
+                            width: size,
+                            height: size
+                        },
+                        spaceBetweenTextAndIcon
+                    });
+                    utilCheckBoxMark.render();
+                    maxHeight = utilTextMark.AABBBounds.height();
+                }
+                else {
+                    maxHeight = Math.max(size, lines.length * lineHeight);
+                }
+            }
+            else if (iconInlineFront.length || iconInlineEnd.length) {
+                if (autoWrapText) {
+                    const textOption = Object.assign({
+                        text: cellValue?.toString(),
+                        fontFamily,
                         fontSize,
                         fontStyle,
                         fontWeight,
-                        fontFamily,
-                        lineHeight,
-                        wordBreak: 'break-word'
-                    },
-                    icon: {
-                        width: Math.floor(size / 1.4),
-                        height: Math.floor(size / 1.4)
-                    },
-                    box: {
-                        width: size,
-                        height: size
-                    },
-                    spaceBetweenTextAndIcon
+                        lineHeight
+                    });
+                    textOption.textBaseline = 'middle';
+                    const textConfig = [
+                        ...iconInlineFront.map(icon => dealWithRichTextIcon(icon)),
+                        textOption,
+                        ...iconInlineEnd.map(icon => dealWithRichTextIcon(icon))
+                    ];
+                    utilRichTextMark.setAttributes({
+                        width: cellWidth - (padding[1] + padding[3]) - iconWidth,
+                        height: 0,
+                        textConfig
+                    });
+                    maxHeight = utilRichTextMark.AABBBounds.height();
+                }
+                else {
+                    maxHeight = 0;
+                    lines.forEach((line, index) => {
+                        if (index === 0 && iconInlineFront.length) {
+                            maxHeight += Math.max(lineHeight, iconInlineFrontHeight);
+                        }
+                        else if (index === lines.length - 1 && iconInlineEnd.length) {
+                            maxHeight += Math.max(lineHeight, iconInlineEndHeight);
+                        }
+                        else {
+                            maxHeight += lineHeight;
+                        }
+                    });
+                }
+            }
+            else if (autoWrapText) {
+                const maxLineWidth = cellWidth - (padding[1] + padding[3]) - iconWidth;
+                utilTextMark.setAttributes({
+                    maxLineWidth,
+                    text: lines,
+                    fontSize,
+                    fontStyle,
+                    fontWeight,
+                    fontFamily,
+                    lineHeight,
+                    wordBreak: 'break-word',
+                    whiteSpace: lines.length === 1 && !autoWrapText ? 'no-wrap' : 'normal'
                 });
-                utilCheckBoxMark.render();
-                maxHeight = utilTextMark.AABBBounds.height();
+                maxHeight = utilTextMark.AABBBounds.height() || (typeof lineHeight === 'number' ? lineHeight : fontSize);
             }
             else {
-                maxHeight = Math.max(size, lines.length * lineHeight);
+                maxHeight = lines.length * lineHeight;
             }
         }
-        else if (iconInlineFront.length || iconInlineEnd.length) {
-            const textOption = Object.assign({
-                text: cellValue?.toString(),
-                fontFamily,
-                fontSize,
-                fontStyle,
-                fontWeight,
-                lineHeight
-            });
-            textOption.textBaseline = 'middle';
-            const textConfig = [
-                ...iconInlineFront.map(icon => dealWithRichTextIcon(icon)),
-                textOption,
-                ...iconInlineEnd.map(icon => dealWithRichTextIcon(icon))
-            ];
-            utilRichTextMark.setAttributes({
-                width: cellWidth - (padding[1] + padding[3]) - iconWidth,
-                height: 0,
-                textConfig
-            });
-            maxHeight = utilRichTextMark.AABBBounds.height();
-        }
-        else if (autoWrapText) {
-            const maxLineWidth = cellWidth - (padding[1] + padding[3]) - iconWidth;
-            utilTextMark.setAttributes({
-                maxLineWidth,
-                text: lines,
-                fontSize,
-                fontStyle,
-                fontWeight,
-                fontFamily,
-                lineHeight,
-                wordBreak: 'break-word',
-                whiteSpace: lines.length === 1 && !autoWrapText ? 'no-wrap' : 'normal'
-            });
-            maxHeight = utilTextMark.AABBBounds.height() || (typeof lineHeight === 'number' ? lineHeight : fontSize);
-        }
-        else {
-            maxHeight = lines.length * lineHeight;
-        }
         return (Math.max(maxHeight, iconHeight) + padding[0] + padding[2]) / spanRow;
     }
     function getCellRect$1(col, row, table) {
@@ -40398,7 +40557,13 @@
                     if (customLayout || customRender) {
                         const style = scene.table._getCellStyle(col, row);
                         const padding = getQuadProps(getProp('padding', style, col, row, scene.table));
-                        const customResult = dealWithCustom(customLayout, customRender, col, row, cell.attribute.width, cell.attribute.height, false, scene.table.heightMode === 'autoHeight', padding, scene.table);
+                        let width = cell.attribute.width;
+                        let height = cell.attribute.height;
+                        if (isMergeCellGroup(cell)) {
+                            width = scene.table.getColsWidth(cell.mergeStartCol, cell.mergeEndCol);
+                            height = scene.table.getRowsHeight(cell.mergeStartRow, cell.mergeEndRow);
+                        }
+                        const customResult = dealWithCustom(customLayout, customRender, col, row, width, height, false, scene.table.heightMode === 'autoHeight', padding, scene.table);
                         customElementsGroup = customResult.elementsGroup;
                         renderDefault = customResult.renderDefault;
                     }
@@ -40410,13 +40575,10 @@
                     }
                 }
             }
-            if (renderDefault) {
-                const style = scene.table._getCellStyle(col, row);
-                updateMergeCellContentHeight(cell, distHeight, detaY, scene.table.heightMode === 'autoHeight', getQuadProps(style.padding), style.textAlign, style.textBaseline, scene.table);
-            }
+            updateMergeCellContentHeight(cell, distHeight, detaY, scene.table.heightMode === 'autoHeight', renderDefault, scene.table);
         }
     }
-    function updateMergeCellContentHeight(cellGroup, distHeight, detaY, autoRowHeight, padding, textAlign, textBaseline, table) {
+    function updateMergeCellContentHeight(cellGroup, distHeight, detaY, autoRowHeight, renderDefault, table) {
         if (isMergeCellGroup(cellGroup)) {
             distHeight = 0;
             for (let row = cellGroup.mergeStartRow; row <= cellGroup.mergeEndRow; row++) {
@@ -40432,7 +40594,10 @@
                             dy: 0
                         });
                     });
-                    updateCellContentHeight(singleCellGroup, distHeight, detaY, autoRowHeight, padding, textAlign, textBaseline);
+                    if (renderDefault) {
+                        const style = table._getCellStyle(col, row);
+                        updateCellContentHeight(singleCellGroup, distHeight, detaY, autoRowHeight, getQuadProps(style.padding), style.textAlign, style.textBaseline);
+                    }
                     const rangeHeight = table.getRowHeight(row);
                     const rangeWidth = table.getColWidth(col);
                     singleCellGroup.contentHeight = distHeight;
@@ -40453,7 +40618,8 @@
             }
         }
         else {
-            updateCellContentHeight(cellGroup, distHeight, detaY, autoRowHeight, padding, textAlign, textBaseline);
+            const style = table._getCellStyle(cellGroup.col, cellGroup.row);
+            updateCellContentHeight(cellGroup, distHeight, detaY, autoRowHeight, getQuadProps(style.padding), style.textAlign, style.textBaseline);
         }
     }
 
@@ -40698,7 +40864,13 @@
                     if (customLayout || customRender) {
                         const style = scene.table._getCellStyle(col, row);
                         const padding = getQuadProps(getProp('padding', style, col, row, scene.table));
-                        const customResult = dealWithCustom(customLayout, customRender, col, row, cellGroup.attribute.width, cellGroup.attribute.height, false, scene.table.heightMode === 'autoHeight', padding, scene.table);
+                        let width = cellGroup.attribute.width;
+                        let height = cellGroup.attribute.height;
+                        if (isMergeCellGroup(cellGroup)) {
+                            width = scene.table.getColsWidth(cellGroup.mergeStartCol, cellGroup.mergeEndCol);
+                            height = scene.table.getRowsHeight(cellGroup.mergeStartRow, cellGroup.mergeEndRow);
+                        }
+                        const customResult = dealWithCustom(customLayout, customRender, col, row, width, height, false, scene.table.heightMode === 'autoHeight', padding, scene.table);
                         customElementsGroup = customResult.elementsGroup;
                         renderDefault = customResult.renderDefault;
                         isHeightChange = true;
@@ -40711,14 +40883,12 @@
                     }
                 }
             }
-            if (renderDefault) {
-                const style = scene.table._getCellStyle(col, row);
-                isHeightChange = updateMergeCellContentWidth(cellGroup, distWidth, detaX, autoRowHeight, getQuadProps(style.padding), style.textAlign, style.textBaseline, scene.table);
-            }
+            const cellChange = updateMergeCellContentWidth(cellGroup, distWidth, detaX, autoRowHeight, renderDefault, scene.table);
+            isHeightChange = isHeightChange || cellChange;
         }
         return autoRowHeight && autoWrapText ? isHeightChange : false;
     }
-    function updateMergeCellContentWidth(cellGroup, distWidth, detaX, autoRowHeight, padding, textAlign, textBaseline, table) {
+    function updateMergeCellContentWidth(cellGroup, distWidth, detaX, autoRowHeight, renderDefault, table) {
         if (isMergeCellGroup(cellGroup)) {
             distWidth = 0;
             let isHeightChange = false;
@@ -40732,6 +40902,9 @@
             const { colStart, colEnd, rowStart, rowEnd } = getCellMergeRange(cellGroup, table.scenegraph);
             for (let col = colStart; col <= colEnd; col++) {
                 for (let row = rowStart; row <= rowEnd; row++) {
+                    if (col === cellGroup.col && row !== cellGroup.row) {
+                        continue;
+                    }
                     const singleCellGroup = table.scenegraph.getCell(col, row);
                     singleCellGroup.forEachChildren((child) => {
                         child.setAttributes({
@@ -40739,13 +40912,20 @@
                             dy: 0
                         });
                     });
-                    const changed = updateCellContentWidth(singleCellGroup, distWidth, cellHeight, detaX, autoRowHeight, padding, textAlign, textBaseline, table.scenegraph);
-                    const hierarchyOffset = getHierarchyOffset(singleCellGroup.col, singleCellGroup.row, table);
-                    if (hierarchyOffset) {
-                        const text = singleCellGroup.getChildByName('text');
-                        const icon = singleCellGroup.getChildByName('expand') || singleCellGroup.getChildByName('collapse');
-                        if (icon?.role !== 'icon-left' && text) {
-                            text.setAttribute('dx', hierarchyOffset);
+                    let changed = false;
+                    if (renderDefault) {
+                        const style = table._getCellStyle(col, row);
+                        const padding = getQuadProps(style.padding);
+                        const textAlign = style.textAlign;
+                        const textBaseline = style.textBaseline;
+                        changed = updateCellContentWidth(singleCellGroup, distWidth, cellHeight, detaX, autoRowHeight, padding, textAlign, textBaseline, table.scenegraph);
+                        const hierarchyOffset = getHierarchyOffset(singleCellGroup.col, singleCellGroup.row, table);
+                        if (hierarchyOffset) {
+                            const text = singleCellGroup.getChildByName('text');
+                            const icon = singleCellGroup.getChildByName('expand') || singleCellGroup.getChildByName('collapse');
+                            if (icon?.role !== 'icon-left' && text) {
+                                text.setAttribute('dx', hierarchyOffset);
+                            }
                         }
                     }
                     const rangeHeight = table.getRowHeight(row);
@@ -40769,6 +40949,10 @@
             }
             return isHeightChange;
         }
+        const style = table._getCellStyle(cellGroup.col, cellGroup.row);
+        const padding = getQuadProps(style.padding);
+        const textAlign = style.textAlign;
+        const textBaseline = style.textBaseline;
         return updateCellContentWidth(cellGroup, distWidth, table.getRowHeight(cellGroup.row), detaX, autoRowHeight, padding, textAlign, textBaseline, table.scenegraph);
     }
     function resetRowHeight(scene, row) {
@@ -41385,7 +41569,8 @@
             componentGroup.addChild(this.columnResizeBgLine);
             componentGroup.addChild(this.columnResizeLine);
             componentGroup.addChild(this.columnResizeLabel);
-            if (this.table.theme.scrollStyle.hoverOn) {
+            const hoverOn = this.table.theme.scrollStyle.hoverOn;
+            if (hoverOn && !this.table.theme.scrollStyle.barToSide) {
                 componentGroup.addChild(this.hScrollBar);
                 componentGroup.addChild(this.vScrollBar);
             }
@@ -41456,9 +41641,17 @@
             if (totalWidth > tableWidth) {
                 const y = Math.min(tableHeight, totalHeight);
                 const rangeEnd = Math.max(0.05, (tableWidth - frozenColsWidth) / (totalWidth - frozenColsWidth));
+                const hoverOn = this.table.theme.scrollStyle.hoverOn;
+                let attrY = 0;
+                if (this.table.theme.scrollStyle.barToSide) {
+                    attrY = this.table.tableNoFrameHeight - (hoverOn ? width : -this.table.scenegraph.tableGroup.attribute.y);
+                }
+                else {
+                    attrY = y - (hoverOn ? width : -this.table.scenegraph.tableGroup.attribute.y);
+                }
                 this.hScrollBar.setAttributes({
-                    x: frozenColsWidth + (!this.table.theme.scrollStyle.hoverOn ? this.table.scenegraph.tableGroup.attribute.x : 0),
-                    y: y - (this.table.theme.scrollStyle.hoverOn ? width : -this.table.scenegraph.tableGroup.attribute.y),
+                    x: frozenColsWidth + (!hoverOn ? this.table.scenegraph.tableGroup.attribute.x : 0),
+                    y: attrY,
                     width: tableWidth - frozenColsWidth - rightFrozenColsWidth,
                     range: [0, rangeEnd],
                     visible: visible === 'always'
@@ -41483,9 +41676,17 @@
             if (totalHeight > tableHeight) {
                 const x = Math.min(tableWidth, totalWidth);
                 const rangeEnd = Math.max(0.05, (tableHeight - frozenRowsHeight) / (totalHeight - frozenRowsHeight));
+                let attrX = 0;
+                const hoverOn = this.table.theme.scrollStyle.hoverOn;
+                if (this.table.theme.scrollStyle.barToSide) {
+                    attrX = this.table.tableNoFrameWidth - (hoverOn ? width : -this.table.scenegraph.tableGroup.attribute.x);
+                }
+                else {
+                    attrX = x - (hoverOn ? width : -this.table.scenegraph.tableGroup.attribute.x);
+                }
                 this.vScrollBar.setAttributes({
-                    x: x - (this.table.theme.scrollStyle.hoverOn ? width : -this.table.scenegraph.tableGroup.attribute.x),
-                    y: frozenRowsHeight + (!this.table.theme.scrollStyle.hoverOn ? this.table.scenegraph.tableGroup.attribute.y : 0),
+                    x: attrX,
+                    y: frozenRowsHeight + (!hoverOn ? this.table.scenegraph.tableGroup.attribute.y : 0),
                     height: tableHeight - frozenRowsHeight - bottomFrozenRowsHeight,
                     range: [0, rangeEnd],
                     visible: visible === 'always'
@@ -41584,7 +41785,7 @@
                 this.frozenShadowLine.setAttributes({
                     visible: true,
                     x: colX,
-                    height: this.table.getRowsHeight(0, this.table.rowCount - 1)
+                    height: this.table.tableNoFrameHeight
                 });
             }
         }
@@ -42377,7 +42578,10 @@
                 if ((typeof lineWidth === 'number' && lineWidth & 1) ||
                     (Array.isArray(strokeArrayWidth) && strokeArrayWidth.some(width => width & 1))) {
                     const table = group.stage.table;
-                    const bottomRight = table.theme.cellBorderClipDirection === 'bottom-right';
+                    if (!table) {
+                        return;
+                    }
+                    const bottomRight = table?.theme.cellBorderClipDirection === 'bottom-right';
                     let deltaWidth = 0;
                     let deltaHeight = 0;
                     if (bottomRight) {
@@ -42614,7 +42818,10 @@
             let heightForStroke;
             if (lineWidth & 1) {
                 const table = group.stage.table;
-                const bottomRight = table.theme.cellBorderClipDirection === 'bottom-right';
+                if (!table) {
+                    return;
+                }
+                const bottomRight = table?.theme.cellBorderClipDirection === 'bottom-right';
                 let deltaWidth = 0;
                 let deltaHeight = 0;
                 if (bottomRight) {
@@ -42706,7 +42913,10 @@
                 const { width: widthFroDraw, height: heightFroDraw } = getCellSizeForDraw(group, Math.ceil(width), Math.ceil(height));
                 context.beginPath();
                 const table = group.stage.table;
-                const bottomRight = table.theme.cellBorderClipDirection === 'bottom-right';
+                if (!table) {
+                    return;
+                }
+                const bottomRight = table?.theme.cellBorderClipDirection === 'bottom-right';
                 let deltaWidth = 0;
                 let deltaHeight = 0;
                 if (bottomRight) {
@@ -42748,7 +42958,7 @@
         drawShape(group, context, x, y, doFill, doStroke, fVisible, sVisible, groupAttribute, drawContext, fillCb, strokeCb, doFillOrStroke) {
             if (group.role === 'cell') {
                 const table = group.stage.table;
-                if (table.stateManager.interactionState !== InteractionState.scrolling) {
+                if (table && table.stateManager.interactionState !== InteractionState.scrolling) {
                     const hoverColor = getCellHoverColor(group, table);
                     if (hoverColor) {
                         group.attribute._vtableHoverFill = hoverColor;
@@ -42787,6 +42997,9 @@
         order = 0;
         drawShape(group, context, x, y, doFill, doStroke, fVisible, sVisible, groupAttribute, drawContext, fillCb, strokeCb, doFillOrStroke) {
             const table = group.stage.table;
+            if (!table) {
+                return;
+            }
             if (group.role === 'body') {
                 const x = -(group.attribute.x ?? 0) + table.getFrozenColsWidth();
                 const y = -(group.attribute.y ?? 0) + table.getFrozenRowsHeight();
@@ -42899,10 +43112,10 @@
             }
         }
         else if (group.role === 'corner-frozen') {
-            if (table.scrollLeft) {
+            if (table && table.scrollLeft) {
                 width -= 1;
             }
-            if (table.scrollTop) {
+            if (table && table.scrollTop) {
                 height -= 1;
             }
         }
@@ -43035,6 +43248,7 @@
     }
 
     let customAlphabetCharSet = '';
+    let textMeasureMode = 'quick';
     const textMeasureModule = new ContainerModule((bind, unbind, isBound, rebind) => {
         if (isBound(TextMeasureContribution)) {
             rebind(TextMeasureContribution).to(FastTextMeasureContribution).inSingletonScope();
@@ -43082,13 +43296,13 @@
         measureTextWidth(text, options) {
             const { fontSize, fontFamily = 'Arial,sans-serif', fontWeight = 'normal', fontStyle = 'normal' } = options;
             const fastTextMeasure = getFastTextMeasure(fontSize, fontWeight, fontFamily, fontStyle);
-            const textMeasure = fastTextMeasure.measure(text);
+            const textMeasure = fastTextMeasure.measure(text, textMeasureMode);
             return textMeasure.width;
         }
         measureText(text, options) {
             const { fontSize, fontFamily = 'Arial,sans-serif', fontWeight = 'normal', fontStyle = 'normal' } = options;
             const fastTextMeasure = getFastTextMeasure(fontSize, fontWeight, fontFamily, fontStyle);
-            const textMeasure = fastTextMeasure.measure(text);
+            const textMeasure = fastTextMeasure.measure(text, textMeasureMode);
             return textMeasure;
         }
     }
@@ -43096,13 +43310,13 @@
         measureText(text, options) {
             const { fontSize, fontFamily = 'Arial,sans-serif', fontWeight = 'normal', fontStyle = 'normal' } = options;
             const fastTextMeasure = getFastTextMeasure(fontSize, fontWeight, fontFamily, fontStyle);
-            const textMeasure = fastTextMeasure.measure(text);
+            const textMeasure = fastTextMeasure.measure(text, textMeasureMode);
             return textMeasure;
         }
         measureTextWidth(text, options) {
             const { fontSize, fontFamily = 'Arial,sans-serif', fontWeight = 'normal', fontStyle = 'normal' } = options;
             const fastTextMeasure = getFastTextMeasure(fontSize, fontWeight, fontFamily, fontStyle);
-            const textMeasure = fastTextMeasure.measure(text);
+            const textMeasure = fastTextMeasure.measure(text, textMeasureMode);
             return textMeasure.width;
         }
         clipText(text, options, width) {
@@ -43176,6 +43390,7 @@
         fastTextMeasureCache.clear();
     }
     function restoreMeasureText() {
+        textMeasureMode = 'canvas';
         container.load(restoreTextMeasureModule);
     }
 
@@ -43341,7 +43556,8 @@
         for (let col = colStart; col <= colEnd; col++) {
             let maxWidth;
             if (!table.internalProps.transpose &&
-                table.internalProps.layoutMap.columnWidths?.[col]?.columnWidthComputeMode === 'only-header' &&
+                (table.internalProps.layoutMap.columnWidths?.[col]?.columnWidthComputeMode === 'only-header' ||
+                    table.columnWidthComputeMode === 'only-header') &&
                 'showHeader' in table.internalProps.layoutMap) {
                 const temp = table.internalProps.layoutMap.showHeader;
                 table.internalProps.layoutMap.showHeader = true;
@@ -43349,7 +43565,8 @@
                 table.internalProps.layoutMap.showHeader = temp;
             }
             else if (!table.internalProps.transpose &&
-                table.internalProps.layoutMap.columnWidths?.[col]?.columnWidthComputeMode === 'only-body') {
+                (table.internalProps.layoutMap.columnWidths?.[col]?.columnWidthComputeMode === 'only-body' ||
+                    table.columnWidthComputeMode === 'only-body')) {
                 maxWidth = computeColWidth(col, table.internalProps.layoutMap.getBodyRange().start.row, table.internalProps.layoutMap.getBodyRange().end.row, table);
             }
             else {
@@ -43419,7 +43636,13 @@
         }
     }
     function computeColWidth(col, startRow, endRow, table, forceCompute = false) {
-        const width = getColWidthDefinedWidthResizedWidth(col, table);
+        let width = getColWidthDefinedWidthResizedWidth(col, table);
+        if (table.internalProps.transpose &&
+            width === 'auto' &&
+            ((table.columnWidthComputeMode === 'only-header' && col >= table.rowHeaderLevelCount) ||
+                (table.columnWidthComputeMode === 'only-body' && col < table.rowHeaderLevelCount))) {
+            width = table.getDefaultColumnWidth(col);
+        }
         if (forceCompute && !table.internalProps.transpose) {
             return computeAutoColWidth(width, col, startRow, endRow, forceCompute, table);
         }
@@ -43560,8 +43783,9 @@
                 if (customLayoutObj.rootContainer instanceof Group$2) {
                     customLayoutObj.rootContainer = decodeReactDom(customLayoutObj.rootContainer);
                     dealPercentCalc(customLayoutObj.rootContainer, 0, table.getRowHeight(row));
+                    const setedWidth = customLayoutObj.rootContainer.attribute.width;
                     customLayoutObj.rootContainer.setStage(table.scenegraph.stage);
-                    width = customLayoutObj.rootContainer.AABBBounds.width() ?? 0;
+                    width = setedWidth > 0 ? setedWidth : customLayoutObj.rootContainer.AABBBounds.width() ?? 0;
                     renderDefault = customLayoutObj.renderDefault;
                     enableCellPadding = customLayoutObj.enableCellPadding;
                 }
@@ -43900,7 +44124,8 @@
         proxy.setParamsForColumn();
         let distCol;
         let distRow;
-        if (table.widthMode === 'adaptive') {
+        if (table.widthMode === 'adaptive' ||
+            (table.options.autoWrapText && (table.heightMode === 'adaptive' || table.heightMode === 'autoHeight'))) {
             distCol = table.colCount - 1;
         }
         else {
@@ -46398,6 +46623,9 @@
         if (!scene.isPivot && !scene.table.transpose) {
             scene.component.setFrozenColumnShadow(scene.table.frozenColCount - 1);
         }
+        else if (scene.table.options.frozenColCount) {
+            scene.component.setFrozenColumnShadow(scene.table.frozenColCount - 1);
+        }
         scene.hasFrozen = true;
         scene.frozenColCount = scene.table.frozenColCount;
         scene.frozenRowCount = scene.colHeaderGroup.firstChild?.childrenCount ?? 0;
@@ -46434,6 +46662,9 @@
         if (!scene.isPivot && !scene.table.transpose) {
             scene.component.setFrozenColumnShadow(scene.table.frozenColCount - 1);
         }
+        else if (scene.table.options.frozenColCount) {
+            scene.component.setFrozenColumnShadow(scene.table.frozenColCount - 1);
+        }
         scene.hasFrozen = true;
     }
     function moveColumnFromBodyToRowHeader(scene) {
@@ -48286,6 +48517,9 @@
             if (!this.isPivot && !this.table.transpose) {
                 this.component.setFrozenColumnShadow(this.table.frozenColCount - 1);
             }
+            else if (this.table.options.frozenColCount) {
+                this.component.setFrozenColumnShadow(this.table.frozenColCount - 1);
+            }
             this.table.stateManager.checkFrozen();
             this.updateContainer();
             this.createFrameBorder();
@@ -48702,6 +48936,9 @@
             if (!this.isPivot && !this.table.transpose) {
                 this.component.setFrozenColumnShadow(this.table.frozenColCount - 1);
             }
+            else if (this.table.options.frozenColCount) {
+                this.component.setFrozenColumnShadow(this.table.frozenColCount - 1);
+            }
             this.component.updateScrollBar();
             this.updateNextFrame();
         }
@@ -48713,6 +48950,9 @@
             if (!this.isPivot && !this.table.transpose) {
                 this.component.setFrozenColumnShadow(this.table.frozenColCount - 1);
             }
+            else if (this.table.options.frozenColCount) {
+                this.component.setFrozenColumnShadow(this.table.frozenColCount - 1);
+            }
             this.component.updateScrollBar();
             this.updateNextFrame();
         }
@@ -49147,10 +49387,76 @@
                     };
                 }
                 else {
-                    currentRange.end = {
-                        col,
-                        row
-                    };
+                    if (state.fillHandle.isFilling) {
+                        if (state.fillHandle.direction === 'top') {
+                            if (row === state.fillHandle.beforeFillMinRow && row === state.fillHandle.beforeFillMaxRow) {
+                                currentRange.start.row = currentRange.end.row = row;
+                            }
+                            else if (row <= state.fillHandle.beforeFillMinRow) {
+                                if (currentRange.start.row < currentRange.end.row) {
+                                    const temp = currentRange.start.row;
+                                    currentRange.start.row = currentRange.end.row;
+                                    currentRange.end.row = temp;
+                                }
+                                currentRange.end.row = row;
+                            }
+                            else if (row === state.fillHandle.beforeFillMaxRow) {
+                                if (currentRange.start.row > currentRange.end.row) {
+                                    currentRange.start.row = row;
+                                }
+                                else {
+                                    currentRange.end.row = row;
+                                }
+                            }
+                        }
+                        else if (state.fillHandle.direction === 'bottom') {
+                            if (row >= state.fillHandle.beforeFillMaxRow) {
+                                if (currentRange.start.row > currentRange.end.row) {
+                                    const temp = currentRange.start.row;
+                                    currentRange.start.row = currentRange.end.row;
+                                    currentRange.end.row = temp;
+                                }
+                                currentRange.end.row = row;
+                            }
+                        }
+                        else if (state.fillHandle.direction === 'left') {
+                            if (col === state.fillHandle.beforeFillMinCol && col === state.fillHandle.beforeFillMaxCol) {
+                                currentRange.start.col = currentRange.end.col = col;
+                            }
+                            else if (col <= state.fillHandle.beforeFillMinCol) {
+                                if (currentRange.start.col < currentRange.end.col) {
+                                    const temp = currentRange.start.col;
+                                    currentRange.start.col = currentRange.end.col;
+                                    currentRange.end.col = temp;
+                                }
+                                currentRange.end.col = col;
+                            }
+                            else if (col === state.fillHandle.beforeFillMaxCol) {
+                                if (currentRange.start.col > currentRange.end.col) {
+                                    currentRange.start.col = col;
+                                }
+                                else {
+                                    currentRange.end.col = col;
+                                }
+                            }
+                        }
+                        else if (state.fillHandle.direction === 'right') {
+                            if (col >= state.fillHandle.beforeFillMaxCol) {
+                                if (currentRange.start.col > currentRange.end.col) {
+                                    const temp = currentRange.start.col;
+                                    currentRange.start.col = currentRange.end.col;
+                                    currentRange.end.col = temp;
+                                }
+                                currentRange.end.col = col;
+                            }
+                        }
+                    }
+                    else {
+                        currentRange.end = {
+                            col,
+                            row
+                        };
+                    }
                 }
                 scenegraph.updateCellSelectBorder(currentRange.start.col, currentRange.start.row, currentRange.end.col, currentRange.end.row, extendSelectRange);
             }
@@ -49516,6 +49822,9 @@
             !state.table.transpose) {
             state.table.scenegraph.component.setFrozenColumnShadow(state.table.frozenColCount - 1, state.columnResize.isRightFrozen);
         }
+        else if (state.table.options.frozenColCount) {
+            state.table.scenegraph.component.setFrozenColumnShadow(state.table.frozenColCount - 1);
+        }
         state.table.scenegraph.updateNextFrame();
     }
     function clearWidthsAndHeightsCache(colMin, colMax, rowMin, rowMax, table) {
@@ -49640,6 +49949,9 @@
             !state.table.transpose) {
             state.table.scenegraph.component.setFrozenColumnShadow(state.table.frozenColCount - 1, state.columnResize.isRightFrozen);
         }
+        else if (state.table.options.frozenColCount) {
+            state.table.scenegraph.component.setFrozenColumnShadow(state.table.frozenColCount - 1);
+        }
         state.table.scenegraph.updateNextFrame();
     }
     function updateResizeColForColumn(detaX, state) {
@@ -50069,23 +50381,40 @@
             this.columnResize.x = x;
             this.columnResize.isRightFrozen = isRightFrozen;
             this.table.scenegraph.component.showResizeCol(col, y, isRightFrozen);
-            this.table.stateManager.updateSelectPos(-1, -1);
+            this.updateSelectPos(-1, -1);
             this.table.scenegraph.updateNextFrame();
         }
         startFillSelect(x, y) {
             this.fillHandle.isFilling = true;
             this.fillHandle.startX = x;
             this.fillHandle.startY = y;
-            this.table.scenegraph.updateNextFrame();
+            const currentRange = this.select.ranges[this.select.ranges.length - 1];
+            this.fillHandle.beforeFillMinCol = Math.min(currentRange.start.col, currentRange.end.col);
+            this.fillHandle.beforeFillMinRow = Math.min(currentRange.start.row, currentRange.end.row);
+            this.fillHandle.beforeFillMaxCol = Math.max(currentRange.start.col, currentRange.end.col);
+            this.fillHandle.beforeFillMaxRow = Math.max(currentRange.start.row, currentRange.end.row);
             this.table.fireListeners(TABLE_EVENT_TYPE.MOUSEDOWN_FILL_HANDLE, {});
         }
         endFillSelect() {
             this.fillHandle.isFilling = false;
             this.fillHandle.startX = undefined;
             this.fillHandle.startY = undefined;
-            this.table.stateManager.fillHandle.directionRow = undefined;
-            this.table.eventManager.isDraging &&
-                this.table.fireListeners(TABLE_EVENT_TYPE.DRAG_FILL_HANDLE_END, { direction: this.fillHandle.direction });
+            this.fillHandle.directionRow = undefined;
+            const currentMinCol = Math.min(this.select.ranges[0].start.col, this.select.ranges[0].end.col);
+            const currentMinRow = Math.min(this.select.ranges[0].start.row, this.select.ranges[0].end.row);
+            const currentMaxCol = Math.max(this.select.ranges[0].start.col, this.select.ranges[0].end.col);
+            const currentMaxRow = Math.max(this.select.ranges[0].start.row, this.select.ranges[0].end.row);
+            if (this.fillHandle.beforeFillMinCol !== currentMinCol ||
+                this.fillHandle.beforeFillMinRow !== currentMinRow ||
+                this.fillHandle.beforeFillMaxCol !== currentMaxCol ||
+                this.fillHandle.beforeFillMaxRow !== currentMaxRow) {
+                this.table.eventManager.isDraging &&
+                    this.table.fireListeners(TABLE_EVENT_TYPE.DRAG_FILL_HANDLE_END, { direction: this.fillHandle.direction });
+            }
+            this.fillHandle.beforeFillMaxCol = undefined;
+            this.fillHandle.beforeFillMaxRow = undefined;
+            this.fillHandle.beforeFillMinCol = undefined;
+            this.fillHandle.beforeFillMinRow = undefined;
         }
         updateResizeCol(xInTable, yInTable) {
             updateResizeColumn(xInTable, yInTable, this);
@@ -50132,13 +50461,44 @@
                 this.table.scenegraph.updateFrozenIcon(0, this.table.colCount - 1);
             }
         }
+        checkVerticalScrollBarEnd() {
+            const totalHeight = this.table.getAllRowsHeight();
+            const scrollTop = this.scroll.verticalBarPos;
+            const viewHeight = this.table.tableNoFrameHeight;
+            if (scrollTop + viewHeight >= totalHeight) {
+                this.table.fireListeners(TABLE_EVENT_TYPE.SCROLL_VERTICAL_END, {
+                    scrollTop,
+                    scrollLeft: this.scroll.horizontalBarPos,
+                    scrollHeight: this.table.theme.scrollStyle?.width,
+                    scrollWidth: this.table.theme.scrollStyle?.width,
+                    viewHeight,
+                    viewWidth: this.table.tableNoFrameWidth
+                });
+            }
+        }
+        checkHorizontalScrollBarEnd() {
+            const totalWidth = this.table.getAllColsWidth();
+            const scrollLeft = this.scroll.horizontalBarPos;
+            const viewWidth = this.table.tableNoFrameWidth;
+            if (scrollLeft + viewWidth >= totalWidth) {
+                this.table.fireListeners(TABLE_EVENT_TYPE.SCROLL_HORIZONTAL_END, {
+                    scrollTop: this.scroll.verticalBarPos,
+                    scrollLeft,
+                    scrollHeight: this.table.theme.scrollStyle?.width,
+                    scrollWidth: this.table.theme.scrollStyle?.width,
+                    viewHeight: this.table.tableNoFrameHeight,
+                    viewWidth
+                });
+            }
+        }
         updateVerticalScrollBar(yRatio) {
             const totalHeight = this.table.getAllRowsHeight();
+            const oldVerticalBarPos = this.scroll.verticalBarPos;
             this.scroll.verticalBarPos = Math.ceil(yRatio * (totalHeight - this.table.scenegraph.height));
             this.table.scenegraph.setY(-this.scroll.verticalBarPos, yRatio === 1);
             this.scroll.verticalBarPos -= this.table.scenegraph.proxy.deltaY;
             this.table.scenegraph.proxy.deltaY = 0;
-            this.table.stateManager.updateHoverPos(-1, -1);
+            this.updateHoverPos(-1, -1);
             this.table.fireListeners(TABLE_EVENT_TYPE.SCROLL, {
                 scrollTop: this.scroll.verticalBarPos,
                 scrollLeft: this.scroll.horizontalBarPos,
@@ -50149,14 +50509,18 @@
                 scrollDirection: 'vertical',
                 scrollRatioY: yRatio
             });
+            if (oldVerticalBarPos !== this.scroll.verticalBarPos) {
+                this.checkVerticalScrollBarEnd();
+            }
         }
         updateHorizontalScrollBar(xRatio) {
             const totalWidth = this.table.getAllColsWidth();
+            const oldHorizontalBarPos = this.scroll.horizontalBarPos;
             this.scroll.horizontalBarPos = Math.ceil(xRatio * (totalWidth - this.table.scenegraph.width));
             this.table.scenegraph.setX(-this.scroll.horizontalBarPos, xRatio === 1);
             this.scroll.horizontalBarPos -= this.table.scenegraph.proxy.deltaX;
             this.table.scenegraph.proxy.deltaX = 0;
-            this.table.stateManager.updateHoverPos(-1, -1);
+            this.updateHoverPos(-1, -1);
             this.table.fireListeners(TABLE_EVENT_TYPE.SCROLL, {
                 scrollTop: this.scroll.verticalBarPos,
                 scrollLeft: this.scroll.horizontalBarPos,
@@ -50167,14 +50531,18 @@
                 scrollDirection: 'horizontal',
                 scrollRatioX: xRatio
             });
+            if (oldHorizontalBarPos !== this.scroll.horizontalBarPos) {
+                this.checkHorizontalScrollBarEnd();
+            }
         }
         setScrollTop(top) {
             const totalHeight = this.table.getAllRowsHeight();
             top = Math.max(0, Math.min(top, totalHeight - this.table.scenegraph.height));
             top = Math.ceil(top);
             if (top !== this.scroll.verticalBarPos || this.table.isPivotChart()) {
-                this.table.stateManager.updateHoverPos(-1, -1);
+                this.updateHoverPos(-1, -1);
             }
+            const oldVerticalBarPos = this.scroll.verticalBarPos;
             this.scroll.verticalBarPos = top;
             this.table.scenegraph.setY(-top);
             const yRatio = top / (totalHeight - this.table.scenegraph.height);
@@ -50189,6 +50557,9 @@
                 scrollDirection: 'vertical',
                 scrollRatioY: yRatio
             });
+            if (oldVerticalBarPos !== top) {
+                this.checkVerticalScrollBarEnd();
+            }
         }
         setScrollLeft(left) {
             const totalWidth = this.table.getAllColsWidth();
@@ -50196,8 +50567,9 @@
             left = Math.max(0, Math.min(left, totalWidth - this.table.scenegraph.width));
             left = Math.ceil(left);
             if (left !== this.scroll.horizontalBarPos) {
-                this.table.stateManager.updateHoverPos(-1, -1);
+                this.updateHoverPos(-1, -1);
             }
+            const oldHorizontalBarPos = this.scroll.horizontalBarPos;
             this.scroll.horizontalBarPos = left;
             this.table.scenegraph.setX(-left);
             const xRatio = left / (totalWidth - this.table.scenegraph.width);
@@ -50212,6 +50584,9 @@
                 scrollDirection: 'horizontal',
                 scrollRatioX: xRatio
             });
+            if (oldHorizontalBarPos !== left) {
+                this.checkHorizontalScrollBarEnd();
+            }
         }
         hideVerticalScrollBar() {
             this.table.scenegraph.component.hideVerticalScrollBar();
@@ -51131,7 +51506,7 @@
                             target: { col: eventArgsSet.eventArgs.col, row: eventArgsSet.eventArgs.row },
                             source: {
                                 col: table.stateManager.columnMove.colSource,
-                                row: table.stateManager.columnMove.colSource
+                                row: table.stateManager.columnMove.rowSource
                             }
                         });
                     }
@@ -51142,7 +51517,9 @@
                         table.stateManager.endFillSelect();
                     }
                     const eventArgsSet = getCellEventArgsSet(e);
-                    if (eventArgsSet.eventArgs && table.hasListeners(TABLE_EVENT_TYPE.DRAG_SELECT_END)) {
+                    if (table.eventManager.isDraging &&
+                        eventArgsSet.eventArgs &&
+                        table.hasListeners(TABLE_EVENT_TYPE.DRAG_SELECT_END)) {
                         const cellsEvent = {
                             event: e.nativeEvent,
                             cells: [],
@@ -52289,6 +52666,7 @@
                     }
                     else if (this.table._canResizeColumn(resizeCol.col, resizeCol.row) && resizeCol.col >= 0) {
                         this.table.scenegraph.updateAutoColWidth(resizeCol.col);
+                        this.table.internalProps._widthResizedColMap.add(resizeCol.col);
                         this.table.scenegraph.updateChartSize(resizeCol.col);
                         const state = this.table.stateManager;
                         if (state.columnResize.col < state.table.frozenColCount &&
@@ -52296,6 +52674,14 @@
                             !state.table.transpose) {
                             state.table.scenegraph.component.setFrozenColumnShadow(state.table.frozenColCount - 1, state.columnResize.isRightFrozen);
                         }
+                        const colWidths = [];
+                        for (let col = 0; col < this.table.colCount; col++) {
+                            colWidths.push(this.table.getColWidth(col));
+                        }
+                        this.table.fireListeners(TABLE_EVENT_TYPE.RESIZE_COLUMN_END, {
+                            col: resizeCol.col,
+                            colWidths
+                        });
                     }
                 }
             });
@@ -52376,21 +52762,26 @@
                             if (Math.abs(this.table.stateManager.fillHandle.startY - eventArgsSet.abstractPos.y) >=
                                 Math.abs(this.table.stateManager.fillHandle.startX - eventArgsSet.abstractPos.x)) {
                                 this.table.stateManager.fillHandle.directionRow = true;
-                                if (this.table.stateManager.fillHandle.startY - eventArgsSet.abstractPos.y > 0) {
-                                    this.table.stateManager.fillHandle.direction = 'top';
-                                }
-                                else {
-                                    this.table.stateManager.fillHandle.direction = 'bottom';
-                                }
                             }
                             else {
                                 this.table.stateManager.fillHandle.directionRow = false;
-                                if (this.table.stateManager.fillHandle.startX - eventArgsSet.abstractPos.x > 0) {
-                                    this.table.stateManager.fillHandle.direction = 'left';
-                                }
-                                else {
-                                    this.table.stateManager.fillHandle.direction = 'right';
-                                }
+                            }
+                        }
+                        if (Math.abs(this.table.stateManager.fillHandle.startY - eventArgsSet.abstractPos.y) >=
+                            Math.abs(this.table.stateManager.fillHandle.startX - eventArgsSet.abstractPos.x)) {
+                            if (this.table.stateManager.fillHandle.startY - eventArgsSet.abstractPos.y > 0) {
+                                this.table.stateManager.fillHandle.direction = 'top';
+                            }
+                            else {
+                                this.table.stateManager.fillHandle.direction = 'bottom';
+                            }
+                        }
+                        else {
+                            if (this.table.stateManager.fillHandle.startX - eventArgsSet.abstractPos.x > 0) {
+                                this.table.stateManager.fillHandle.direction = 'left';
+                            }
+                            else {
+                                this.table.stateManager.fillHandle.direction = 'right';
                             }
                         }
                         if (this.table.stateManager.fillHandle.directionRow) {
@@ -52434,8 +52825,8 @@
                 const { eventArgs } = eventArgsSet;
                 if (eventArgs) {
                     if (this.table.stateManager.select?.ranges?.length) {
-                        const lastCol = this.table.stateManager.select.ranges[this.table.stateManager.select.ranges.length - 1].end.col;
-                        const lastRow = this.table.stateManager.select.ranges[this.table.stateManager.select.ranges.length - 1].end.row;
+                        const lastCol = Math.max(this.table.stateManager.select.ranges[this.table.stateManager.select.ranges.length - 1].start.col, this.table.stateManager.select.ranges[this.table.stateManager.select.ranges.length - 1].end.col);
+                        const lastRow = Math.max(this.table.stateManager.select.ranges[this.table.stateManager.select.ranges.length - 1].start.row, this.table.stateManager.select.ranges[this.table.stateManager.select.ranges.length - 1].end.row);
                         const lastCellBound = this.table.scenegraph.highPerformanceGetCell(lastCol, lastRow).globalAABBBounds;
                         const distanceX = Math.abs(eventArgsSet.abstractPos.x - lastCellBound.x2);
                         const distanceY = Math.abs(eventArgsSet.abstractPos.y - lastCellBound.y2);
@@ -54833,7 +55224,7 @@
             this.orient = option.orient ?? 'left';
             this.visible = option.visible ?? true;
             this.position = option.position ?? 'middle';
-            this.selectedData = option.defaultSelected ?? [];
+            this.selectedData = option.defaultSelected ?? null;
             this.createComponent();
             this.initEvent();
         }
@@ -55135,7 +55526,7 @@
             this.orient = option.orient ?? 'left';
             this.visible = option.visible ?? true;
             this.position = option.position ?? 'middle';
-            this.selectedData = option.defaultSelected ?? [];
+            this.selectedData = option.defaultSelected ?? null;
             this.createComponent();
             this.initEvent();
         }
@@ -55742,7 +56133,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "0.23.0-alpha.0";
+        version = "0.23.0";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -55752,6 +56143,7 @@
         isReleased = false;
         _chartEventMap = {};
         customCellStylePlugin;
+        columnWidthComputeMode;
         constructor(container, options = {}) {
             super();
             if (!container && options.mode !== 'node') {
@@ -55785,6 +56177,7 @@
             this.tableNoFrameHeight = 0;
             this.canvasWidth = canvasWidth;
             this.canvasHeight = canvasHeight;
+            this.columnWidthComputeMode = options.columnWidthComputeMode ?? 'normal';
             const internalProps = (this.internalProps = {});
             showFrozenIcon !== undefined && (this.showFrozenIcon = showFrozenIcon);
             if (typeof allowFrozenColCount === 'number' && allowFrozenColCount <= 0) {
@@ -56218,6 +56611,22 @@
             }
             return this.defaultRowHeight;
         }
+        getDefaultColumnWidth(col) {
+            if (this.isRowHeader(col, 0) || this.isCornerHeader(col, 0)) {
+                return Array.isArray(this.defaultHeaderColWidth)
+                    ? this.defaultHeaderColWidth[col] ?? this.defaultColWidth
+                    : this.defaultHeaderColWidth;
+            }
+            else if (this.isRightFrozenColumn(col, this.columnHeaderLevelCount)) {
+                if (this.isPivotTable()) {
+                    return Array.isArray(this.defaultHeaderColWidth)
+                        ? this.defaultHeaderColWidth[this.rowHeaderLevelCount - this.rightFrozenColCount] ?? this.defaultColWidth
+                        : this.defaultHeaderColWidth;
+                }
+                return this.defaultColWidth;
+            }
+            return this.defaultColWidth;
+        }
         getDefaultRowHeight(row) {
             if (this.isColumnHeader(0, row) || this.isCornerHeader(0, row)) {
                 return Array.isArray(this.defaultHeaderRowHeight)
@@ -56272,32 +56681,14 @@
             else if (width) {
                 return width;
             }
-            else if (this.isRowHeader(col, 0) || this.isCornerHeader(col, 0)) {
-                return Array.isArray(this.defaultHeaderColWidth)
-                    ? this.defaultHeaderColWidth[col] ?? this.defaultColWidth
-                    : this.defaultHeaderColWidth;
-            }
-            else if (this.isRightFrozenColumn(col, this.columnHeaderLevelCount)) {
-                if (this.isPivotTable()) {
-                    return Array.isArray(this.defaultHeaderColWidth)
-                        ? this.defaultHeaderColWidth[this.rowHeaderLevelCount - this.rightFrozenColCount] ?? this.defaultColWidth
-                        : this.defaultHeaderColWidth;
-                }
-                return this.defaultColWidth;
-            }
-            return this.defaultColWidth;
+            return this.getDefaultColumnWidth(col);
         }
         getColWidthDefinedNumber(col) {
             const width = this.getColWidthDefined(col);
             return this._adjustColWidth(col, this._colWidthDefineToPxWidth(width));
         }
         getColWidth(col) {
-            const width = this.colWidthsMap.get(col) ??
-                (col < this.rowHeaderLevelCount
-                    ? Array.isArray(this.defaultHeaderColWidth)
-                        ? this.defaultHeaderColWidth[col] ?? this.defaultColWidth
-                        : this.defaultHeaderColWidth
-                    : this.defaultColWidth);
+            const width = this.colWidthsMap.get(col) ?? this.getDefaultColumnWidth(col);
             if ((this.widthMode === 'adaptive' && typeof width === 'number') ||
                 (this.transpose && typeof width === 'number')) {
                 return this._colWidthDefineToPxWidth(width);
@@ -56955,14 +57346,20 @@
         }
         getBottomFrozenRowsHeight() {
             if (this.bottomFrozenRowCount > 0) {
-                const height = this.getRowsHeight(this.rowCount - this.bottomFrozenRowCount, this.rowCount - 1);
+                let height = 0;
+                for (let row = this.rowCount - this.bottomFrozenRowCount; row <= this.rowCount - 1; row++) {
+                    height += this.getRowHeight(row);
+                }
                 return height;
             }
             return 0;
         }
         getRightFrozenColsWidth() {
             if (this.rightFrozenColCount > 0) {
-                const width = this.getColsWidth(this.colCount - this.rightFrozenColCount, this.colCount - 1);
+                let width = 0;
+                for (let col = this.colCount - this.rightFrozenColCount; col <= this.colCount - 1; col++) {
+                    width += this.getColWidth(col);
+                }
                 return width;
             }
             return 0;
@@ -58008,13 +58405,23 @@
             return customLayout;
         }
         hasAutoImageColumn() {
-            return this.internalProps.layoutMap.columnObjects.find((column) => {
-                if ((column.cellType === 'image' || typeof column.cellType === 'function') &&
+            const bodyColumn = this.internalProps.layoutMap.columnObjects.find((column) => {
+                if ((column.cellType === 'image' || column.cellType === 'video' || typeof column.cellType === 'function') &&
                     column.define.imageAutoSizing) {
                     return true;
                 }
                 return false;
             });
+            const headerObj = this.internalProps.layoutMap.headerObjects.find((column) => {
+                if (column) {
+                    if ((column.headerType === 'image' || column.headerType === 'video' || typeof column.headerType === 'function') &&
+                        column.define.imageAutoSizing) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+            return bodyColumn || headerObj;
         }
         _getActiveChartInstance() {
             const cellGroup = this.scenegraph.getCell(this.stateManager.hover?.cellPos?.col, this.stateManager.hover?.cellPos?.row);
@@ -59372,11 +59779,32 @@
         get hasAggregationOnBottomCount() {
             return this._hasAggregationOnBottomCount;
         }
-        getAggregators(col, row) {
+        getAggregatorsByCell(col, row) {
             const column = this.getBody(col, row);
             const aggregators = column.aggregator;
             return aggregators;
         }
+        getAggregatorsByCellRange(startCol, startRow, endCol, endRow) {
+            let aggregators = [];
+            if (this.transpose) {
+                for (let i = startRow; i <= endRow; i++) {
+                    const column = this.getBody(startCol, i);
+                    if (column.aggregator) {
+                        aggregators = aggregators.concat(Array.isArray(column.aggregator) ? column.aggregator : [column.aggregator]);
+                    }
+                }
+            }
+            else {
+                for (let i = startCol; i <= endCol; i++) {
+                    const column = this.getBody(i, startRow);
+                    if (column.aggregator) {
+                        aggregators = aggregators.concat(Array.isArray(column.aggregator) ? column.aggregator : [column.aggregator]);
+                    }
+                }
+                return aggregators;
+            }
+            return [];
+        }
         getAggregatorOnTop(col, row) {
             const column = this.getBody(col, row);
             const aggregators = column.aggregator;
@@ -59427,26 +59855,34 @@
             }
             return null;
         }
-        getCellAddressHasAggregator(col, row) {
+        getAggregatorCellAddress(startCol, startRow, endCol, endRow) {
             const cellAddrs = [];
+            const topCount = this.hasAggregationOnTopCount;
+            const bottomCount = this.hasAggregationOnBottomCount;
             if (this.transpose) {
-                const topCount = this.hasAggregationOnTopCount;
-                for (let i = 0; i < topCount; i++) {
-                    cellAddrs.push({ col: this.headerLevelCount + i, row });
-                }
-                const bottomCount = this.hasAggregationOnBottomCount;
-                for (let i = 0; i < bottomCount; i++) {
-                    cellAddrs.push({ col: this.rowCount - bottomCount + i, row });
+                for (let row = startRow; row <= endRow; row++) {
+                    const column = this.getBody(startCol, row);
+                    if (column.aggregator) {
+                        for (let i = 0; i < topCount; i++) {
+                            cellAddrs.push({ col: this.headerLevelCount + i, row });
+                        }
+                        for (let i = 0; i < bottomCount; i++) {
+                            cellAddrs.push({ col: this.rowCount - bottomCount + i, row });
+                        }
+                    }
                 }
             }
             else {
-                const topCount = this.hasAggregationOnTopCount;
-                for (let i = 0; i < topCount; i++) {
-                    cellAddrs.push({ col, row: this.headerLevelCount + i });
-                }
-                const bottomCount = this.hasAggregationOnBottomCount;
-                for (let i = 0; i < bottomCount; i++) {
-                    cellAddrs.push({ col, row: this.rowCount - bottomCount + i });
+                for (let col = startCol; col <= endCol; col++) {
+                    const column = this.getBody(col, startRow);
+                    if (column.aggregator) {
+                        for (let i = 0; i < topCount; i++) {
+                            cellAddrs.push({ col, row: this.headerLevelCount + i });
+                        }
+                        for (let i = 0; i < bottomCount; i++) {
+                            cellAddrs.push({ col, row: this.rowCount - bottomCount + i });
+                        }
+                    }
                 }
             }
             return cellAddrs;
@@ -60540,8 +60976,10 @@
                 if (this.table.internalProps.layoutMap?.isAggregation?.(col, row)) {
                     return;
                 }
+                if (!this.editingEditor) {
+                    this.editCell = { col, row };
+                }
                 this.editingEditor = editor;
-                this.editCell = { col, row };
                 const dataValue = this.table.getCellOriginValue(col, row);
                 const rect = this.table.getCellRangeRelativeRect(this.table.getCellRange(col, row));
                 const referencePosition = { rect: { left: rect.left, top: rect.top, width: rect.width, height: rect.height } };
@@ -60580,12 +61018,14 @@
                 }
             }
             if (!this.editingEditor.getValue) ;
-            const changedValue = this.editingEditor.getValue?.();
-            this.table.changeCellValue(this.editCell.col, this.editCell.row, changedValue);
-            this.editingEditor.exit && (void 0);
-            this.editingEditor.exit?.();
-            this.editingEditor.onEnd?.();
-            this.editingEditor = null;
+            if (!this.editingEditor.validateValue || this.editingEditor.validateValue?.()) {
+                const changedValue = this.editingEditor.getValue?.();
+                this.table.changeCellValue(this.editCell.col, this.editCell.row, changedValue);
+                this.editingEditor.exit && (void 0);
+                this.editingEditor.exit?.();
+                this.editingEditor.onEnd?.();
+                this.editingEditor = null;
+            }
         }
         cancelEdit() {
             if (this.editingEditor) {
@@ -60665,10 +61105,10 @@
             return this.internalProps.sortState;
         }
         get records() {
-            return this.dataSource?.source;
+            return this.dataSource?.records;
         }
         get recordsCount() {
-            return this.dataSource.source.length;
+            return this.dataSource.records.length;
         }
         updateColumns(columns) {
             const oldHoverState = { col: this.stateManager.hover.cellPos.col, row: this.stateManager.hover.cellPos.row };
@@ -61233,7 +61673,6 @@
         }
         updateFilterRules(filterRules) {
             this.scenegraph.clearCells();
-            this.internalProps.dataConfig.filterRules = filterRules;
             if (this.sortState) {
                 this.dataSource.updateFilterRulesForSorted(filterRules);
                 sortRecords(this);
@@ -61266,6 +61705,9 @@
             return undefined;
         }
         setRecords(records, option) {
+            this.internalProps.dataSource?.release();
+            this.internalProps.releaseList = this.internalProps.releaseList?.filter((item) => !item.dataSourceObj);
+            this.internalProps.dataSource = null;
             let sort;
             if (Array.isArray(option) || option?.order) {
                 sort = option;
@@ -61379,69 +61821,72 @@
             }
             return isValid$3(editorDefine);
         }
-        changeCellValue(col, row, value) {
-            const recordIndex = this.getRecordShowIndexByCell(col, row);
-            const { field } = this.internalProps.layoutMap.getBody(col, row);
-            const beforeChangeValue = this.getCellRawValue(col, row);
-            if (this.isHeader(col, row)) {
-                this.internalProps.layoutMap.updateColumnTitle(col, row, value);
-            }
-            else {
-                this.dataSource.changeFieldValue(value, recordIndex, field, col, row, this);
-            }
-            const aggregators = this.internalProps.layoutMap.getAggregators(col, row);
-            if (aggregators) {
-                if (Array.isArray(aggregators)) {
-                    for (let i = 0; i < aggregators?.length; i++) {
-                        aggregators[i].recalculate();
-                    }
+        changeCellValue(col, row, value, workOnEditableCell = false) {
+            if ((workOnEditableCell && this.isHasEditorDefine(col, row)) || workOnEditableCell === false) {
+                const recordIndex = this.getRecordShowIndexByCell(col, row);
+                const { field } = this.internalProps.layoutMap.getBody(col, row);
+                const beforeChangeValue = this.getCellRawValue(col, row);
+                if (this.isHeader(col, row)) {
+                    this.internalProps.layoutMap.updateColumnTitle(col, row, value);
                 }
                 else {
-                    aggregators.recalculate();
-                }
-                const aggregatorCells = this.internalProps.layoutMap.getCellAddressHasAggregator(col, row);
-                for (let i = 0; i < aggregatorCells.length; i++) {
-                    const range = this.getCellRange(aggregatorCells[i].col, aggregatorCells[i].row);
-                    for (let sCol = range.start.col; sCol <= range.end.col; sCol++) {
-                        for (let sRow = range.start.row; sRow <= range.end.row; sRow++) {
-                            this.scenegraph.updateCellContent(sCol, sRow);
+                    this.dataSource.changeFieldValue(value, recordIndex, field, col, row, this);
+                }
+                const range = this.getCellRange(col, row);
+                const aggregators = this.internalProps.layoutMap.getAggregatorsByCell(col, row);
+                if (aggregators) {
+                    if (Array.isArray(aggregators)) {
+                        for (let i = 0; i < aggregators?.length; i++) {
+                            aggregators[i].recalculate();
+                        }
+                    }
+                    else {
+                        aggregators.recalculate();
+                    }
+                    const aggregatorCells = this.internalProps.layoutMap.getAggregatorCellAddress(range.start.col, range.start.row, range.end.col, range.end.row);
+                    for (let i = 0; i < aggregatorCells.length; i++) {
+                        const range = this.getCellRange(aggregatorCells[i].col, aggregatorCells[i].row);
+                        for (let sCol = range.start.col; sCol <= range.end.col; sCol++) {
+                            for (let sRow = range.start.row; sRow <= range.end.row; sRow++) {
+                                this.scenegraph.updateCellContent(sCol, sRow);
+                            }
                         }
                     }
                 }
-            }
-            const range = this.getCellRange(col, row);
-            for (let sCol = range.start.col; sCol <= range.end.col; sCol++) {
-                for (let sRow = range.start.row; sRow <= range.end.row; sRow++) {
-                    this.scenegraph.updateCellContent(sCol, sRow);
+                for (let sCol = range.start.col; sCol <= range.end.col; sCol++) {
+                    for (let sRow = range.start.row; sRow <= range.end.row; sRow++) {
+                        this.scenegraph.updateCellContent(sCol, sRow);
+                    }
                 }
-            }
-            if (this.widthMode === 'adaptive' || (this.autoFillWidth && this.getAllColsWidth() <= this.tableNoFrameWidth)) {
-                if (this.internalProps._widthResizedColMap.size === 0) {
-                    this.scenegraph.recalculateColWidths();
+                if (this.widthMode === 'adaptive' || (this.autoFillWidth && this.getAllColsWidth() <= this.tableNoFrameWidth)) {
+                    if (this.internalProps._widthResizedColMap.size === 0) {
+                        this.scenegraph.recalculateColWidths();
+                    }
                 }
-            }
-            else if (!this.internalProps._widthResizedColMap.has(col)) {
-                const oldWidth = this.getColWidth(col);
-                const newWidth = computeColWidth(col, 0, this.rowCount - 1, this, false);
-                if (newWidth !== oldWidth) {
-                    this.scenegraph.updateColWidth(col, newWidth - oldWidth);
+                else if (!this.internalProps._widthResizedColMap.has(col)) {
+                    const oldWidth = this.getColWidth(col);
+                    const newWidth = computeColWidth(col, 0, this.rowCount - 1, this, false);
+                    if (newWidth !== oldWidth) {
+                        this.scenegraph.updateColWidth(col, newWidth - oldWidth);
+                    }
                 }
+                if (this.heightMode === 'adaptive' ||
+                    (this.autoFillHeight && this.getAllRowsHeight() <= this.tableNoFrameHeight)) {
+                    this.scenegraph.recalculateRowHeights();
+                }
+                else if (this.heightMode === 'autoHeight') {
+                    const oldHeight = this.getRowHeight(row);
+                    const newHeight = computeRowHeight(row, 0, this.colCount - 1, this);
+                    this.scenegraph.updateRowHeight(row, newHeight - oldHeight);
+                }
+                this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, {
+                    col,
+                    row,
+                    rawValue: beforeChangeValue,
+                    changedValue: this.getCellOriginValue(col, row)
+                });
+                this.scenegraph.updateNextFrame();
             }
-            if (this.heightMode === 'adaptive' || (this.autoFillHeight && this.getAllRowsHeight() <= this.tableNoFrameHeight)) {
-                this.scenegraph.recalculateRowHeights();
-            }
-            else if (this.heightMode === 'autoHeight') {
-                const oldHeight = this.getRowHeight(row);
-                const newHeight = computeRowHeight(row, 0, this.colCount - 1, this);
-                this.scenegraph.updateRowHeight(row, newHeight - oldHeight);
-            }
-            this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, {
-                col,
-                row,
-                rawValue: beforeChangeValue,
-                changedValue: this.getCellOriginValue(col, row)
-            });
-            this.scenegraph.updateNextFrame();
         }
         changeCellValues(startCol, startRow, values, workOnEditableCell = false) {
             let pasteColEnd = startCol;
@@ -61482,6 +61927,21 @@
             }
             const startRange = this.getCellRange(startCol, startRow);
             const range = this.getCellRange(pasteColEnd, pasteRowEnd);
+            const aggregators = this.internalProps.layoutMap.getAggregatorsByCellRange(startRange.start.col, startRange.start.row, range.end.col, range.end.row);
+            if (aggregators) {
+                for (let i = 0; i < aggregators?.length; i++) {
+                    aggregators[i].recalculate();
+                }
+                const aggregatorCells = this.internalProps.layoutMap.getAggregatorCellAddress(startRange.start.col, startRange.start.row, range.end.col, range.end.row);
+                for (let i = 0; i < aggregatorCells.length; i++) {
+                    const range = this.getCellRange(aggregatorCells[i].col, aggregatorCells[i].row);
+                    for (let sCol = range.start.col; sCol <= range.end.col; sCol++) {
+                        for (let sRow = range.start.row; sRow <= range.end.row; sRow++) {
+                            this.scenegraph.updateCellContent(sCol, sRow);
+                        }
+                    }
+                }
+            }
             for (let sCol = startRange.start.col; sCol <= range.end.col; sCol++) {
                 for (let sRow = startRange.start.row; sRow <= range.end.row; sRow++) {
                     this.scenegraph.updateCellContent(sCol, sRow);
@@ -62009,7 +62469,13 @@
                 this.hasTwoIndicatorAxes = this._indicators.some(indicatorObject => {
                     if (indicatorObject.chartSpec &&
                         indicatorObject.chartSpec.series &&
-                        indicatorObject.chartSpec.series.length > 1) {
+                        indicatorObject.chartSpec.series.length > 1 &&
+                        indicatorObject.chartSpec.axes?.every((axis) => {
+                            if (axis.orient === (this.indicatorsAsCol ? 'top' : 'right') && axis.visible === false) {
+                                return false;
+                            }
+                            return true;
+                        })) {
                         return true;
                     }
                     return false;
@@ -66259,41 +66725,44 @@
             }
             return isValid$3(editorDefine);
         }
-        changeCellValue(col, row, value) {
-            let newValue = value;
-            const rawValue = this.getCellRawValue(col, row);
-            if (typeof rawValue === 'number' && isAllDigits(value)) {
-                newValue = parseFloat(value);
-            }
-            this._changeCellValueToDataSet(col, row, newValue);
-            this.scenegraph.updateCellContent(col, row);
-            if (this.widthMode === 'adaptive' || (this.autoFillWidth && this.getAllColsWidth() <= this.tableNoFrameWidth)) {
-                if (this.internalProps._widthResizedColMap.size === 0) {
-                    this.scenegraph.recalculateColWidths();
+        changeCellValue(col, row, value, workOnEditableCell = false) {
+            if ((workOnEditableCell && this.isHasEditorDefine(col, row)) || workOnEditableCell === false) {
+                let newValue = value;
+                const rawValue = this.getCellRawValue(col, row);
+                if (typeof rawValue === 'number' && isAllDigits(value)) {
+                    newValue = parseFloat(value);
                 }
-            }
-            else if (!this.internalProps._widthResizedColMap.has(col)) {
-                const oldWidth = this.getColWidth(col);
-                const newWidth = computeColWidth(col, 0, this.rowCount - 1, this, false);
-                if (newWidth !== oldWidth) {
-                    this.scenegraph.updateColWidth(col, newWidth - oldWidth);
+                this._changeCellValueToDataSet(col, row, newValue);
+                this.scenegraph.updateCellContent(col, row);
+                if (this.widthMode === 'adaptive' || (this.autoFillWidth && this.getAllColsWidth() <= this.tableNoFrameWidth)) {
+                    if (this.internalProps._widthResizedColMap.size === 0) {
+                        this.scenegraph.recalculateColWidths();
+                    }
                 }
+                else if (!this.internalProps._widthResizedColMap.has(col)) {
+                    const oldWidth = this.getColWidth(col);
+                    const newWidth = computeColWidth(col, 0, this.rowCount - 1, this, false);
+                    if (newWidth !== oldWidth) {
+                        this.scenegraph.updateColWidth(col, newWidth - oldWidth);
+                    }
+                }
+                if (this.heightMode === 'adaptive' ||
+                    (this.autoFillHeight && this.getAllRowsHeight() <= this.tableNoFrameHeight)) {
+                    this.scenegraph.recalculateRowHeights();
+                }
+                else if (this.heightMode === 'autoHeight') {
+                    const oldHeight = this.getRowHeight(row);
+                    const newHeight = computeRowHeight(row, 0, this.colCount - 1, this);
+                    this.scenegraph.updateRowHeight(row, newHeight - oldHeight);
+                }
+                this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, {
+                    col,
+                    row,
+                    rawValue: this.getCellRawValue(col, row),
+                    changedValue: newValue
+                });
+                this.scenegraph.updateNextFrame();
             }
-            if (this.heightMode === 'adaptive' || (this.autoFillHeight && this.getAllRowsHeight() <= this.tableNoFrameHeight)) {
-                this.scenegraph.recalculateRowHeights();
-            }
-            else if (this.heightMode === 'autoHeight') {
-                const oldHeight = this.getRowHeight(row);
-                const newHeight = computeRowHeight(row, 0, this.colCount - 1, this);
-                this.scenegraph.updateRowHeight(row, newHeight - oldHeight);
-            }
-            this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, {
-                col,
-                row,
-                rawValue: this.getCellRawValue(col, row),
-                changedValue: newValue
-            });
-            this.scenegraph.updateNextFrame();
         }
         changeCellValues(startCol, startRow, values, workOnEditableCell = false) {
             let pasteColEnd = startCol;
@@ -67830,7 +68299,7 @@
     }
 
     registerForVrender();
-    const version = "0.23.0-alpha.0";
+    const version = "0.23.0";
     function getIcons() {
         return get$2();
     }