@visactor/vtable 1.7.8-alpha.4 → 1.7.8

package/dist/vtable.js

@@ -28900,6 +28900,28 @@
                     this.records.push(record);
                 }
             }
+            this.clearCacheValue();
+        }
+        deleteRecord(record) {
+            if (record) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.filter(item => item !== record);
+                }
+            }
+            this.clearCacheValue();
+        }
+        updateRecord(oldRecord, newRecord) {
+            if (oldRecord && newRecord) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.map(item => {
+                        if (item === oldRecord) {
+                            return newRecord;
+                        }
+                        return item;
+                    });
+                }
+                this.clearCacheValue();
+            }
         }
         value() {
             return this.records;
@@ -28923,6 +28945,34 @@
                     this.fieldValue = record[this.field];
                 }
             }
+            this.clearCacheValue();
+        }
+        deleteRecord(record) {
+            if (record) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.filter(item => item !== record);
+                }
+                if (this.field && this.records.length) {
+                    this.fieldValue = this.records[this.records.length - 1][this.field];
+                }
+            }
+            this.clearCacheValue();
+        }
+        updateRecord(oldRecord, newRecord) {
+            if (oldRecord && newRecord) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.map(item => {
+                        if (item === oldRecord) {
+                            return newRecord;
+                        }
+                        return item;
+                    });
+                }
+                if (this.field && this.records.length) {
+                    this.fieldValue = this.records[this.records.length - 1][this.field];
+                }
+                this.clearCacheValue();
+            }
         }
         value() {
             return this.fieldValue;
@@ -28958,6 +29008,34 @@
                     this.values.push(record[this.field]);
                 }
             }
+            this.clearCacheValue();
+        }
+        updateRecord(oldRecord, newRecord) {
+            if (oldRecord && newRecord) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.map(item => {
+                        if (item === oldRecord) {
+                            return newRecord;
+                        }
+                        return item;
+                    });
+                }
+                if (this.field && this.records.length) {
+                    this.values = this.records.map(item => item[this.field]);
+                }
+                this.clearCacheValue();
+            }
+        }
+        deleteRecord(record) {
+            if (record) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.filter(item => item !== record);
+                }
+                if (this.field && this.records.length) {
+                    this.values = this.records.map(item => item[this.field]);
+                }
+            }
+            this.clearCacheValue();
         }
         value() {
             if (!this.fieldValue) {
@@ -28994,6 +29072,28 @@
                     this.records.push(record);
                 }
             }
+            this.clearCacheValue();
+        }
+        deleteRecord(record) {
+            if (record) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.filter(item => item !== record);
+                }
+            }
+            this.clearCacheValue();
+        }
+        updateRecord(oldRecord, newRecord) {
+            if (oldRecord && newRecord) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.map(item => {
+                        if (item === oldRecord) {
+                            return newRecord;
+                        }
+                        return item;
+                    });
+                }
+                this.clearCacheValue();
+            }
         }
         value() {
             if (!this.fieldValue) {
@@ -29054,6 +29154,90 @@
                     }
                 }
             }
+            this.clearCacheValue();
+        }
+        deleteRecord(record) {
+            if (record) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.filter(item => item !== record);
+                }
+                if (record.className === 'Aggregator') {
+                    const value = record.value();
+                    this.sum -= value ?? 0;
+                    if (this.needSplitPositiveAndNegativeForSum) {
+                        if (value > 0) {
+                            this.positiveSum -= value;
+                        }
+                        else if (value < 0) {
+                            this.nagetiveSum -= value;
+                        }
+                    }
+                }
+                else if (this.field && !isNaN(parseFloat(record[this.field]))) {
+                    const value = parseFloat(record[this.field]);
+                    this.sum -= value;
+                    if (this.needSplitPositiveAndNegativeForSum) {
+                        if (value > 0) {
+                            this.positiveSum -= value;
+                        }
+                        else if (value < 0) {
+                            this.nagetiveSum -= value;
+                        }
+                    }
+                }
+            }
+            this.clearCacheValue();
+        }
+        updateRecord(oldRecord, newRecord) {
+            if (oldRecord && newRecord) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.map(item => {
+                        if (item === oldRecord) {
+                            return newRecord;
+                        }
+                        return item;
+                    });
+                }
+                if (oldRecord.className === 'Aggregator') {
+                    const oldValue = oldRecord.value();
+                    const newValue = newRecord.value();
+                    this.sum += newValue - oldValue;
+                    if (this.needSplitPositiveAndNegativeForSum) {
+                        if (oldValue > 0) {
+                            this.positiveSum -= oldValue;
+                        }
+                        else if (oldValue < 0) {
+                            this.nagetiveSum -= oldValue;
+                        }
+                        if (newValue > 0) {
+                            this.positiveSum += newValue;
+                        }
+                        else if (newValue < 0) {
+                            this.nagetiveSum += newValue;
+                        }
+                    }
+                }
+                else if (this.field && !isNaN(parseFloat(oldRecord[this.field]))) {
+                    const oldValue = parseFloat(oldRecord[this.field]);
+                    const newValue = parseFloat(newRecord[this.field]);
+                    this.sum += newValue - oldValue;
+                    if (this.needSplitPositiveAndNegativeForSum) {
+                        if (oldValue > 0) {
+                            this.positiveSum -= oldValue;
+                        }
+                        else if (oldValue < 0) {
+                            this.nagetiveSum -= oldValue;
+                        }
+                        if (newValue > 0) {
+                            this.positiveSum += newValue;
+                        }
+                        else if (newValue < 0) {
+                            this.nagetiveSum += newValue;
+                        }
+                    }
+                }
+                this.clearCacheValue();
+            }
         }
         value() {
             return this.records?.length >= 1 ? this.sum : undefined;
@@ -29123,6 +29307,36 @@
                     this.count++;
                 }
             }
+            this.clearCacheValue();
+        }
+        deleteRecord(record) {
+            if (record) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.filter(item => item !== record);
+                }
+                if (record.className === 'Aggregator') {
+                    this.count -= record.value();
+                }
+                else {
+                    this.count--;
+                }
+            }
+            this.clearCacheValue();
+        }
+        updateRecord(oldRecord, newRecord) {
+            if (oldRecord && newRecord) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.map(item => {
+                        if (item === oldRecord) {
+                            return newRecord;
+                        }
+                        return item;
+                    });
+                }
+                if (oldRecord.className === 'Aggregator') {
+                    this.count += newRecord.value() - oldRecord.value();
+                }
+            }
         }
         value() {
             return this.count;
@@ -29170,6 +29384,43 @@
                     this.count++;
                 }
             }
+            this.clearCacheValue();
+        }
+        deleteRecord(record) {
+            if (record) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.filter(item => item !== record);
+                }
+                if (record.className === 'Aggregator' && record.type === AggregationType.AVG) {
+                    this.sum -= record.sum;
+                    this.count -= record.count;
+                }
+                else if (this.field && !isNaN(parseFloat(record[this.field]))) {
+                    this.sum -= parseFloat(record[this.field]);
+                    this.count--;
+                }
+            }
+            this.clearCacheValue();
+        }
+        updateRecord(oldRecord, newRecord) {
+            if (oldRecord && newRecord) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.map(item => {
+                        if (item === oldRecord) {
+                            return newRecord;
+                        }
+                        return item;
+                    });
+                }
+                if (oldRecord.className === 'Aggregator' && oldRecord.type === AggregationType.AVG) {
+                    this.sum += newRecord.sum - oldRecord.sum;
+                    this.count += newRecord.count - oldRecord.count;
+                }
+                else if (this.field && !isNaN(parseFloat(oldRecord[this.field]))) {
+                    this.sum += parseFloat(newRecord[this.field]) - parseFloat(oldRecord[this.field]);
+                }
+                this.clearCacheValue();
+            }
         }
         value() {
             return this.records?.length >= 1 ? this.sum / this.count : undefined;
@@ -29224,6 +29475,28 @@
                     this.max = parseFloat(record[this.field]) > this.max ? parseFloat(record[this.field]) : this.max;
                 }
             }
+            this.clearCacheValue();
+        }
+        deleteRecord(record) {
+            if (record) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.filter(item => item !== record);
+                }
+                this.recalculate();
+            }
+        }
+        updateRecord(oldRecord, newRecord) {
+            if (oldRecord && newRecord) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.map(item => {
+                        if (item === oldRecord) {
+                            return newRecord;
+                        }
+                        return item;
+                    });
+                }
+                this.recalculate();
+            }
         }
         value() {
             return this.records?.length >= 1 ? this.max : undefined;
@@ -29277,6 +29550,28 @@
                     this.min = record[this.field] < this.min ? record[this.field] : this.min;
                 }
             }
+            this.clearCacheValue();
+        }
+        deleteRecord(record) {
+            if (record) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.filter(item => item !== record);
+                }
+                this.recalculate();
+            }
+        }
+        updateRecord(oldRecord, newRecord) {
+            if (oldRecord && newRecord) {
+                if (this.isRecord && this.records) {
+                    this.records = this.records.map(item => {
+                        if (item === oldRecord) {
+                            return newRecord;
+                        }
+                        return item;
+                    });
+                }
+                this.recalculate();
+            }
         }
         value() {
             return this.records?.length >= 1 ? this.min : undefined;
@@ -29530,15 +29825,15 @@
         registedAggregators = {};
         rowHierarchyType;
         fieldAggregators = [];
-        layoutColumnObjects = [];
+        columns;
         lastFilterRules;
-        constructor(dataSourceObj, dataConfig, pagination, columnObjs, rowHierarchyType, hierarchyExpandLevel) {
+        constructor(dataSourceObj, dataConfig, pagination, columns, rowHierarchyType, hierarchyExpandLevel) {
             super();
             this.registerAggregators();
             this.dataSourceObj = dataSourceObj;
             this.dataConfig = dataConfig;
             this._get = dataSourceObj?.get;
-            this.layoutColumnObjects = columnObjs;
+            this.columns = columns;
             this._source = dataSourceObj?.records ? this.processRecords(dataSourceObj?.records) : dataSourceObj;
             this._sourceLength = this._source?.length || 0;
             this.sortedIndexMap = new Map();
@@ -29600,9 +29895,9 @@
             this.registerAggregator(AggregationType.CUSTOM, CustomAggregator);
         }
         _generateFieldAggragations() {
-            const columnObjs = this.layoutColumnObjects;
+            const columnObjs = this.columns;
             for (let i = 0; i < columnObjs?.length; i++) {
-                columnObjs[i].aggregator = null;
+                delete columnObjs[i].vtable_aggregator;
                 const field = columnObjs[i].field;
                 const aggragation = columnObjs[i].aggregation;
                 if (!aggragation) {
@@ -29618,10 +29913,10 @@
                             aggregationFun: item.aggregationFun
                         });
                         this.fieldAggregators.push(aggregator);
-                        if (!columnObjs[i].aggregator) {
-                            columnObjs[i].aggregator = [];
+                        if (!columnObjs[i].vtable_aggregator) {
+                            columnObjs[i].vtable_aggregator = [];
                         }
-                        columnObjs[i].aggregator.push(aggregator);
+                        columnObjs[i].vtable_aggregator.push(aggregator);
                     }
                 }
                 else {
@@ -29632,7 +29927,7 @@
                         aggregationFun: aggragation.aggregationFun
                     });
                     this.fieldAggregators.push(aggregator);
-                    columnObjs[i].aggregator = aggregator;
+                    columnObjs[i].vtable_aggregator = aggregator;
                 }
             }
         }
@@ -29710,6 +30005,9 @@
                 if (childNodeData.hierarchyState === HierarchyState.expand) {
                     childTotalLength += this.initChildrenNodeHierarchy(childIndexKey, hierarchyExpandLevel, currentLevel + 1, childNodeData);
                 }
+                if (childNodeData.children === true) {
+                    !childNodeData.hierarchyState && (childNodeData.hierarchyState = HierarchyState.collapse);
+                }
             }
             return childTotalLength;
         }
@@ -29921,6 +30219,9 @@
                 this.adjustBeforeChangedRecordsMap(index, 1);
                 this.currentIndexedData.push(this.currentIndexedData.length);
                 this._sourceLength += 1;
+                for (let i = 0; i < this.fieldAggregators.length; i++) {
+                    this.fieldAggregators[i].push(record);
+                }
                 if (this.rowHierarchyType === 'tree') {
                     this.initTreeHierarchyState();
                 }
@@ -29952,6 +30253,11 @@
                         this.currentIndexedData.push(this.currentIndexedData.length);
                     }
                     this._sourceLength += recordArr.length;
+                    for (let i = 0; i < this.fieldAggregators.length; i++) {
+                        for (let j = 0; j < recordArr.length; j++) {
+                            this.fieldAggregators[i].push(recordArr[j]);
+                        }
+                    }
                 }
                 if (this.userPagination) {
                     this.pagination.totalCount = this._sourceLength;
@@ -30021,6 +30327,10 @@
                     }
                     delete this.beforeChangedRecordsMap[recordIndex];
                     realDeletedRecordIndexs.push(recordIndex);
+                    const deletedRecord = this.records[recordIndex];
+                    for (let i = 0; i < this.fieldAggregators.length; i++) {
+                        this.fieldAggregators[i].deleteRecord(deletedRecord);
+                    }
                     this.records.splice(recordIndex, 1);
                     this.currentIndexedData.pop();
                     this._sourceLength -= 1;
@@ -30069,6 +30379,9 @@
                 }
                 delete this.beforeChangedRecordsMap[recordIndex];
                 realDeletedRecordIndexs.push(recordIndex);
+                for (let i = 0; i < this.fieldAggregators.length; i++) {
+                    this.fieldAggregators[i].updateRecord(this.records[recordIndex], records[index]);
+                }
                 this.records[recordIndex] = records[index];
             }
             if (this.userPagination) {
@@ -30093,8 +30406,8 @@
         }
         sort(states) {
             states = (Array.isArray(states) ? states : [states]).filter(state => {
-                let column = this.layoutColumnObjects.find(obj => obj.field == state.field);
-                return column?.define?.sort !== false && state.order !== 'normal';
+                const column = this.columns.find(obj => obj.field === state.field);
+                return column?.sort !== false && state.order !== 'normal';
             });
             this.lastSortStates = states;
             let filedMapArray = states.map(state => this.sortedIndexMap.get(state?.field) || { asc: [], desc: [], normal: [] });
@@ -30527,20 +30840,20 @@
         static get EVENT_TYPE() {
             return DataSource.EVENT_TYPE;
         }
-        static ofArray(array, dataConfig, pagination, columnObjs, rowHierarchyType, hierarchyExpandLevel) {
+        static ofArray(array, dataConfig, pagination, columns, rowHierarchyType, hierarchyExpandLevel) {
             return new CachedDataSource({
                 get: (index) => {
                     return array[index];
                 },
                 length: array.length,
                 records: array
-            }, dataConfig, pagination, columnObjs, rowHierarchyType, hierarchyExpandLevel);
+            }, dataConfig, pagination, columns, rowHierarchyType, hierarchyExpandLevel);
         }
-        constructor(opt, dataConfig, pagination, columnObjs, rowHierarchyType, hierarchyExpandLevel) {
+        constructor(opt, dataConfig, pagination, columns, rowHierarchyType, hierarchyExpandLevel) {
             if (isArray$1(dataConfig?.groupByRules)) {
                 rowHierarchyType = 'tree';
             }
-            super(opt, dataConfig, pagination, columnObjs, rowHierarchyType, hierarchyExpandLevel);
+            super(opt, dataConfig, pagination, columns, rowHierarchyType, hierarchyExpandLevel);
             this._recordCache = [];
             this._fieldCache = {};
         }
@@ -31212,7 +31525,7 @@
     function _setRecords(table, records = []) {
         _dealWithUpdateDataSource(table, () => {
             table.internalProps.records = records;
-            const newDataSource = (table.internalProps.dataSource = CachedDataSource.ofArray(records, table.internalProps.dataConfig, table.pagination, table.internalProps.layoutMap.columnObjects, table.internalProps.layoutMap.rowHierarchyType, getHierarchyExpandLevel(table)));
+            const newDataSource = (table.internalProps.dataSource = CachedDataSource.ofArray(records, table.internalProps.dataConfig, table.pagination, table.internalProps.columns, table.internalProps.layoutMap.rowHierarchyType, getHierarchyExpandLevel(table)));
             table.addReleaseObj(newDataSource);
         });
     }
@@ -31516,6 +31829,36 @@
         }
         return undefined;
     }
+    function generateAggregationForColumn(table) {
+        for (let col = 0; col < table.internalProps.columns.length; col++) {
+            const colDef = table.internalProps.columns[col];
+            if (colDef.aggregation) ;
+            else if (table.options.aggregation) {
+                let aggregation;
+                if (typeof table.options.aggregation === 'function') {
+                    aggregation = table.options.aggregation({
+                        col: col,
+                        field: colDef.field
+                    });
+                }
+                else {
+                    aggregation = table.options.aggregation;
+                }
+                if (aggregation) {
+                    if (Array.isArray(aggregation)) {
+                        const aggregations = [];
+                        aggregation.forEach(item => {
+                            aggregations.push(Object.assign({ showOnTop: false }, item));
+                        });
+                        colDef.aggregation = aggregations;
+                    }
+                    else {
+                        colDef.aggregation = Object.assign({ showOnTop: false }, aggregation);
+                    }
+                }
+            }
+        }
+    }
 
     let Icon$1 = class Icon extends Image$2 {
         role;
@@ -32248,9 +32591,9 @@
             return {
                 type: 'svg',
                 svg: '<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">' +
-                    ' <path d="M4.6665 9H11.3332L7.99984 13.1667L4.6665 9Z" fill="#282F38" fill-opacity="0.35"/>' +
-                    '<path d="M11.3335 7L4.66683 7L8.00016 2.83333L11.3335 7Z" fill="#416EFF"/>' +
-                    ' </svg>',
+                    ' <path d="M4.6665 9H11.3332L7.99984 13.1667L4.6665 9Z" fill="#416EFF"/>' +
+                    '<path d="M11.3335 7L4.66683 7L8.00016 2.83333L11.3335 7Z" fill="#282F38" fill-opacity="0.35"/>' +
+                    '</svg> ',
                 width: 16,
                 height: 16,
                 funcType: IconFuncTypeEnum.sort,
@@ -32269,9 +32612,9 @@
             return {
                 type: 'svg',
                 svg: '<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">' +
-                    ' <path d="M4.6665 9H11.3332L7.99984 13.1667L4.6665 9Z" fill="#416EFF"/>' +
-                    '<path d="M11.3335 7L4.66683 7L8.00016 2.83333L11.3335 7Z" fill="#282F38" fill-opacity="0.35"/>' +
-                    '</svg> ',
+                    ' <path d="M4.6665 9H11.3332L7.99984 13.1667L4.6665 9Z" fill="#282F38" fill-opacity="0.35"/>' +
+                    '<path d="M11.3335 7L4.66683 7L8.00016 2.83333L11.3335 7Z" fill="#416EFF"/>' +
+                    ' </svg>',
                 width: 16,
                 height: 16,
                 funcType: IconFuncTypeEnum.sort,
@@ -34657,7 +35000,7 @@
                 fontSize: DefaultTextStyle.fontSize
             },
             getTextBounds: useNaiveCanvas ? undefined : getTextBounds,
-            specialCharSet: `{}()//&-/: .,@%'"~…=${TextMeasure.ALPHABET_CHAR_SET}${TextMeasure.ALPHABET_CHAR_SET.toUpperCase()}0123456789${customAlphabetCharSet}`,
+            specialCharSet: `{}()//&-/: .,@%'"~…=——${TextMeasure.ALPHABET_CHAR_SET}${TextMeasure.ALPHABET_CHAR_SET.toUpperCase()}0123456789${customAlphabetCharSet}`,
             ...(option ?? {})
         }, textSpec);
     };
@@ -38298,6 +38641,16 @@
                     if (bottomRight) {
                         x = Math.floor(x) - 0.5;
                         y = Math.floor(y) - 0.5;
+                        if (group.role === 'cell') {
+                            const col = group.col;
+                            const row = group.row;
+                            if (col === 0) {
+                                x += 1;
+                            }
+                            if (row === 0) {
+                                y += 1;
+                            }
+                        }
                     }
                     else {
                         x = Math.floor(x) + 0.5;
@@ -38574,6 +38927,16 @@
                 if (bottomRight) {
                     x = Math.floor(x) - 0.5;
                     y = Math.floor(y) - 0.5;
+                    if (group.role === 'cell') {
+                        const col = group.col;
+                        const row = group.row;
+                        if (col === 0) {
+                            x += 1;
+                        }
+                        if (row === 0) {
+                            y += 1;
+                        }
+                    }
                 }
                 else {
                     x = Math.floor(x) + 0.5;
@@ -38668,6 +39031,16 @@
                 if (bottomRight) {
                     x = Math.floor(x) - 0.5;
                     y = Math.floor(y) - 0.5;
+                    if (group.role === 'cell') {
+                        const col = group.col;
+                        const row = group.row;
+                        if (col === 0) {
+                            x += 1;
+                        }
+                        if (row === 0) {
+                            y += 1;
+                        }
+                    }
                 }
                 else {
                     x = Math.floor(x) + 0.5;
@@ -38824,6 +39197,9 @@
     }
     function getCellSizeForDraw(group, width, height, bottomRight) {
         const table = group.stage.table;
+        if (!table) {
+            return { width, height };
+        }
         if (group.role === 'cell') {
             let col = group.col;
             let row = group.row;
@@ -38832,24 +39208,30 @@
                 col = mergeInfo.end.col;
                 row = mergeInfo.end.row;
             }
-            if (table && col === table.colCount - 1 && !bottomRight) {
+            if (col === table.colCount - 1 && !bottomRight) {
                 width -= 1;
             }
-            else if (table && col === table.frozenColCount - 1 && table.scrollLeft && !bottomRight) {
+            else if (col === table.frozenColCount - 1 && table.scrollLeft && !bottomRight) {
                 width -= 1;
             }
-            if (table && row === table.rowCount - 1 && !bottomRight) {
+            else if (col === 0 && bottomRight) {
+                width -= 1;
+            }
+            if (row === table.rowCount - 1 && !bottomRight) {
+                height -= 1;
+            }
+            else if (row === table.frozenRowCount - 1 && table.scrollTop && !bottomRight) {
                 height -= 1;
             }
-            else if (table && row === table.frozenRowCount - 1 && table.scrollTop && !bottomRight) {
+            else if (row === 0 && bottomRight) {
                 height -= 1;
             }
         }
         else if (group.role === 'corner-frozen') {
-            if (table && table.scrollLeft && !bottomRight) {
+            if (table.scrollLeft && !bottomRight) {
                 width -= 1;
             }
-            if (table && table.scrollTop && !bottomRight) {
+            if (table.scrollTop && !bottomRight) {
                 height -= 1;
             }
         }
@@ -42664,6 +43046,174 @@
         }
     }
 
+    function createReactContainer(table) {
+        const { internalProps } = table;
+        internalProps.bodyDomContainer = document.createElement('div');
+        internalProps.bodyDomContainer.id = 'vtable-body-dom-container';
+        internalProps.bodyDomContainer.classList.add('table-component-container');
+        internalProps.element.appendChild(internalProps.bodyDomContainer);
+        internalProps.headerDomContainer = document.createElement('div');
+        internalProps.headerDomContainer.id = 'vtable-header-dom-container';
+        internalProps.headerDomContainer.classList.add('table-component-container');
+        internalProps.element.appendChild(internalProps.headerDomContainer);
+        internalProps.frozenBodyDomContainer = document.createElement('div');
+        internalProps.frozenBodyDomContainer.id = 'vtable-frozen-body-dom-container';
+        internalProps.frozenBodyDomContainer.classList.add('table-component-container');
+        internalProps.element.appendChild(internalProps.frozenBodyDomContainer);
+        internalProps.frozenHeaderDomContainer = document.createElement('div');
+        internalProps.frozenHeaderDomContainer.id = 'vtable-frozen-header-dom-container';
+        internalProps.frozenHeaderDomContainer.classList.add('table-component-container');
+        internalProps.element.appendChild(internalProps.frozenHeaderDomContainer);
+        internalProps.rightFrozenBodyDomContainer = document.createElement('div');
+        internalProps.rightFrozenBodyDomContainer.id = 'vtable-right-frozen-body-dom-container';
+        internalProps.rightFrozenBodyDomContainer.classList.add('table-component-container');
+        internalProps.element.appendChild(internalProps.rightFrozenBodyDomContainer);
+        internalProps.rightFrozenHeaderDomContainer = document.createElement('div');
+        internalProps.rightFrozenHeaderDomContainer.id = 'vtable-right-frozen-header-dom-container';
+        internalProps.rightFrozenHeaderDomContainer.classList.add('table-component-container');
+        internalProps.element.appendChild(internalProps.rightFrozenHeaderDomContainer);
+        internalProps.frozenBottomDomContainer = document.createElement('div');
+        internalProps.frozenBottomDomContainer.id = 'vtable-frozen-bottom-dom-container';
+        internalProps.frozenBottomDomContainer.classList.add('table-component-container');
+        internalProps.element.appendChild(internalProps.frozenBottomDomContainer);
+        internalProps.bottomDomContainer = document.createElement('div');
+        internalProps.bottomDomContainer.id = 'vtable-bottom-dom-container';
+        internalProps.bottomDomContainer.classList.add('table-component-container');
+        internalProps.element.appendChild(internalProps.bottomDomContainer);
+        internalProps.rightFrozenBottomDomContainer = document.createElement('div');
+        internalProps.rightFrozenBottomDomContainer.id = 'vtable-right-frozen-bottom-dom-container';
+        internalProps.rightFrozenBottomDomContainer.classList.add('table-component-container');
+        internalProps.element.appendChild(internalProps.rightFrozenBottomDomContainer);
+    }
+    function updateReactContainer(table) {
+        const { headerDomContainer, bodyDomContainer, frozenBodyDomContainer, frozenHeaderDomContainer, rightFrozenBodyDomContainer, rightFrozenHeaderDomContainer, bottomDomContainer, frozenBottomDomContainer, rightFrozenBottomDomContainer } = table.internalProps;
+        if (!headerDomContainer &&
+            !bodyDomContainer &&
+            !frozenBodyDomContainer &&
+            !frozenHeaderDomContainer &&
+            !rightFrozenBodyDomContainer &&
+            !rightFrozenHeaderDomContainer &&
+            !bottomDomContainer &&
+            !frozenBottomDomContainer &&
+            !rightFrozenBottomDomContainer) {
+            return;
+        }
+        const allColsWidth = table.getAllColsWidth();
+        const frozenColsWidth = table.getFrozenColsWidth();
+        const rightFrozenColsWidth = table.getRightFrozenColsWidth();
+        const totalFrozenColsWidth = frozenColsWidth + rightFrozenColsWidth;
+        const bodyWidth = Math.min(allColsWidth - totalFrozenColsWidth, table.tableNoFrameWidth - totalFrozenColsWidth);
+        const allRowsHeight = table.getAllRowsHeight();
+        const frozenRowsHeight = table.getFrozenRowsHeight();
+        const bottomFrozenRowsHeight = table.getBottomFrozenRowsHeight();
+        const totalFrozenRowsHeight = frozenRowsHeight + bottomFrozenRowsHeight;
+        const bodyHeight = Math.min(allRowsHeight - totalFrozenRowsHeight, table.tableNoFrameHeight - totalFrozenRowsHeight);
+        if (table.frozenColCount > 0) {
+            headerDomContainer.style.left = `${table.tableX + frozenColsWidth}px`;
+            bodyDomContainer.style.left = `${table.tableX + frozenColsWidth}px`;
+            bottomDomContainer.style.left = `${table.tableX + frozenColsWidth}px`;
+        }
+        else if (table.frozenColCount === 0) {
+            headerDomContainer.style.left = `${table.tableX}px`;
+            bodyDomContainer.style.left = `${table.tableX}px`;
+            bottomDomContainer.style.left = `${table.tableX}px`;
+        }
+        frozenBodyDomContainer.style.left = `${table.tableX}px`;
+        frozenHeaderDomContainer.style.left = `${table.tableX}px`;
+        headerDomContainer.style.width = `${bodyWidth}px`;
+        headerDomContainer.style.height = `${frozenRowsHeight}px`;
+        bodyDomContainer.style.top = `${table.tableY}px`;
+        bodyDomContainer.style.width = `${bodyWidth}px`;
+        bodyDomContainer.style.height = `${bodyHeight}px`;
+        bodyDomContainer.style.top = `${table.tableY + frozenRowsHeight}px`;
+        frozenBodyDomContainer.style.width = `${frozenColsWidth}px`;
+        frozenBodyDomContainer.style.height = `${bodyHeight}px`;
+        frozenBodyDomContainer.style.top = `${table.tableY + frozenRowsHeight}px`;
+        frozenHeaderDomContainer.style.width = `${frozenColsWidth}px`;
+        frozenHeaderDomContainer.style.height = `${frozenRowsHeight}px`;
+        frozenHeaderDomContainer.style.top = `${table.tableY}px`;
+        rightFrozenBodyDomContainer.style.width = `${rightFrozenColsWidth}px`;
+        rightFrozenBodyDomContainer.style.height = `${bodyHeight}px`;
+        rightFrozenBodyDomContainer.style.top = `${table.tableY + frozenRowsHeight}px`;
+        rightFrozenBodyDomContainer.style.left = `${table.tableX + table.tableNoFrameWidth - rightFrozenColsWidth}px`;
+        rightFrozenHeaderDomContainer.style.width = `${rightFrozenColsWidth}px`;
+        rightFrozenHeaderDomContainer.style.height = `${frozenRowsHeight}px`;
+        rightFrozenHeaderDomContainer.style.top = `${table.tableY}px`;
+        rightFrozenHeaderDomContainer.style.left = `${table.tableX + table.tableNoFrameWidth - rightFrozenColsWidth}px`;
+        bottomDomContainer.style.width = `${bodyWidth}px`;
+        bottomDomContainer.style.height = `${bottomFrozenRowsHeight}px`;
+        bottomDomContainer.style.top = `${table.tableY + table.tableNoFrameHeight - bottomFrozenRowsHeight}px`;
+        frozenBottomDomContainer.style.width = `${frozenColsWidth}px`;
+        frozenBottomDomContainer.style.height = `${bottomFrozenRowsHeight}px`;
+        frozenBottomDomContainer.style.top = `${table.tableY + table.tableNoFrameHeight - bottomFrozenRowsHeight}px`;
+        rightFrozenBottomDomContainer.style.width = `${rightFrozenColsWidth}px`;
+        rightFrozenBottomDomContainer.style.height = `${bottomFrozenRowsHeight}px`;
+        rightFrozenBottomDomContainer.style.top = `${table.tableY + table.tableNoFrameHeight - bottomFrozenRowsHeight}px`;
+        rightFrozenBottomDomContainer.style.left = `${table.tableX + table.tableNoFrameWidth - rightFrozenColsWidth}px`;
+    }
+    function updateReactComponentContainer(scene) {
+        if (!scene.table.reactCustomLayout) {
+            return;
+        }
+        const { table, stage } = scene;
+        const plugin = stage.pluginService.findPluginsByName('ReactAttributePlugin')[0];
+        const { htmlMap } = plugin;
+        for (const key in htmlMap) {
+            const item = htmlMap[key];
+            const { graphic, wrapContainer } = item;
+            let targetContainer;
+            if (scene.frozenColCount > table.frozenColCount) {
+                const { col, row } = getTargetCell(graphic);
+                if (row >= table.rowCount - table.bottomFrozenRowCount &&
+                    col < scene.frozenColCount &&
+                    col >= table.frozenColCount &&
+                    graphic.attribute.react.container === table.frozenBottomDomContainer) {
+                    targetContainer = table.bottomDomContainer;
+                }
+                else if (row >= table.frozenRowCount &&
+                    col < scene.frozenColCount &&
+                    col >= table.frozenColCount &&
+                    graphic.attribute.react.container === table.frozenBodyDomContainer) {
+                    targetContainer = table.bodyDomContainer;
+                }
+                else if (row < table.frozenRowCount &&
+                    col < scene.frozenColCount &&
+                    col >= table.frozenColCount &&
+                    graphic.attribute.react.container === table.frozenHeaderDomContainer) {
+                    targetContainer = table.headerDomContainer;
+                }
+            }
+            else if (scene.frozenColCount < table.frozenColCount) {
+                const { col, row } = getTargetCell(graphic);
+                if (row >= table.rowCount - table.bottomFrozenRowCount &&
+                    col < table.frozenColCount &&
+                    col >= scene.frozenColCount &&
+                    graphic.attribute.react.container === table.bottomDomContainer) {
+                    targetContainer = table.frozenBottomDomContainer;
+                }
+                else if (row >= table.frozenRowCount &&
+                    col < table.frozenColCount &&
+                    col >= scene.frozenColCount &&
+                    graphic.attribute.react.container === table.bodyDomContainer) {
+                    targetContainer = table.frozenBodyDomContainer;
+                }
+                else if (row < table.frozenRowCount &&
+                    col < table.frozenColCount &&
+                    col >= scene.frozenColCount &&
+                    graphic.attribute.react.container === table.headerDomContainer) {
+                    targetContainer = table.frozenHeaderDomContainer;
+                }
+            }
+            if (targetContainer) {
+                targetContainer.appendChild(wrapContainer);
+                item.nativeContainer = targetContainer;
+                item.container = targetContainer;
+                graphic.attribute.react.container = targetContainer;
+                plugin.updateStyleOfWrapContainer(graphic, stage, wrapContainer, targetContainer, graphic.attribute.react);
+            }
+        }
+    }
+
     function dealFrozen(scene) {
         if (scene.table.frozenColCount > scene.table.rowHeaderLevelCount) {
             scene.rowHeaderGroup.setAttribute('height', scene.bodyGroup.attribute.height);
@@ -42724,13 +43274,14 @@
                 moveColumnFromBottomToLeftBottomCorner(scene);
             }
         }
+        updateReactComponentContainer(scene);
         scene.deleteAllSelectBorder();
         scene.table.stateManager.select.ranges.forEach(range => {
             scene.updateCellSelectBorder(range);
         });
         scene.frozenColCount = scene.table.frozenColCount;
         scene.frozenRowCount = scene.colHeaderGroup.firstChild?.childrenCount ?? 0;
-        scene.proxy.colStart = scene.table.frozenColCount;
+        scene.proxy.colStart = scene.bodyGroup.firstChild?.col ?? scene.table.frozenColCount;
         scene.bodyGroup.setAttribute('x', scene.rowHeaderGroup.attribute.width);
         scene.colHeaderGroup.setAttribute('x', scene.cornerHeaderGroup.attribute.width);
         scene.updateContainer();
@@ -45397,22 +45948,7 @@
             return 0;
         }
         updateDomContainer() {
-            const { headerDomContainer, bodyDomContainer } = this.table.internalProps;
-            if (this.table.frozenColCount > 0 && (headerDomContainer || bodyDomContainer)) {
-                const frozenColsWidth = this.table.getFrozenColsWidth();
-                headerDomContainer && (headerDomContainer.style.left = `${frozenColsWidth}px`);
-                bodyDomContainer && (bodyDomContainer.style.left = `${frozenColsWidth}px`);
-            }
-            if (headerDomContainer) {
-                headerDomContainer.style.width = `${Math.min(this.table.getAllColsWidth(), this.table.tableNoFrameWidth)}px`;
-                headerDomContainer.style.height = `${this.table.getFrozenRowsHeight()}px`;
-            }
-            if (bodyDomContainer) {
-                const totalFrozenRowsHeight = this.table.getFrozenRowsHeight() + this.table.getBottomFrozenRowsHeight();
-                bodyDomContainer.style.width = `${Math.min(this.table.getAllColsWidth(), this.table.tableNoFrameWidth)}px`;
-                bodyDomContainer.style.height = `${(bodyDomContainer.parentElement?.offsetHeight ?? 1) - 1 - totalFrozenRowsHeight}px`;
-                bodyDomContainer.style.top = `${this.table.getFrozenRowsHeight()}px`;
-            }
+            updateReactContainer(this.table);
         }
     }
 
@@ -48819,6 +49355,9 @@
             }
         });
         table.scenegraph.tableGroup.addEventListener('pointertap', (e) => {
+            if (table.stateManager.columnResize.resizing) {
+                return;
+            }
             const eventArgsSet = getCellEventArgsSet(e);
             if (!eventManager.touchMove &&
                 e.button === 0 &&
@@ -51888,7 +52427,7 @@
                     if (order) {
                         order = order.toUpperCase();
                     }
-                    const sortIcon = order === 'ASC' ? this.downIcon : order === 'DESC' ? this.upIcon : this.normalIcon;
+                    const sortIcon = order === 'ASC' ? this.upIcon : order === 'DESC' ? this.downIcon : this.normalIcon;
                     if (sortIcon) {
                         icons.push(sortIcon);
                     }
@@ -52007,7 +52546,7 @@
             return frozen;
         }
         getSortIcon(order, _table, col, row) {
-            const icon = order === 'asc' ? this.downIcon : order === 'desc' ? this.upIcon : this.normalIcon;
+            const icon = order === 'asc' ? this.upIcon : order === 'desc' ? this.downIcon : this.normalIcon;
             const headerC = _table.getHeaderDefine(col, row);
             if (!headerC ||
                 headerC.showSort === false ||
@@ -52025,7 +52564,7 @@
                 (headerC.columns && headerC.columns.length > 0)) {
                 return null;
             }
-            const icon = order?.toUpperCase() === 'ASC' ? this.downIcon : order?.toUpperCase() === 'DESC' ? this.upIcon : this.normalIcon;
+            const icon = order?.toUpperCase() === 'ASC' ? this.upIcon : order?.toUpperCase() === 'DESC' ? this.downIcon : this.normalIcon;
             return icon;
         }
         getDropDownStateIcons(_table, col, row) {
@@ -53165,9 +53704,9 @@
             const column = columnObjects[i];
             if (column?.aggregation) {
                 if (Array.isArray(column?.aggregation)) {
-                    count = Math.max(count, column.aggregation.filter(item => item.showOnTop === true).length);
+                    count = Math.max(count, column.aggregation.filter(item => item.showOnTop).length);
                 }
-                else if (column.aggregation.showOnTop === true) {
+                else if (column.aggregation.showOnTop) {
                     count = Math.max(count, 1);
                 }
             }
@@ -53181,9 +53720,9 @@
             const column = columnObjects[i];
             if (column?.aggregation) {
                 if (Array.isArray(column?.aggregation)) {
-                    count = Math.max(count, column.aggregation.filter(item => item.showOnTop === false).length);
+                    count = Math.max(count, column.aggregation.filter(item => !item.showOnTop).length);
                 }
-                else if (column.aggregation.showOnTop === false) {
+                else if (!column.aggregation.showOnTop) {
                     count = Math.max(count, 1);
                 }
             }
@@ -54627,7 +55166,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.7.8-alpha.4";
+        version = "1.7.8";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -54698,12 +55237,7 @@
                 internalProps.element.appendChild(internalProps.canvas);
                 internalProps.context = internalProps.canvas.getContext('2d');
                 if (options.customConfig?.createReactContainer) {
-                    internalProps.bodyDomContainer = document.createElement('div');
-                    internalProps.bodyDomContainer.classList.add('table-component-container');
-                    internalProps.element.appendChild(internalProps.bodyDomContainer);
-                    internalProps.headerDomContainer = document.createElement('div');
-                    internalProps.headerDomContainer.classList.add('table-component-container');
-                    internalProps.element.appendChild(internalProps.headerDomContainer);
+                    createReactContainer(this);
                 }
             }
             internalProps.handler = new EventHandler();
@@ -55161,14 +55695,6 @@
                     canvas.style.width = `${widthP}px`;
                     canvas.style.height = `${heightP}px`;
                 }
-                if (this.internalProps.bodyDomContainer) {
-                    this.internalProps.bodyDomContainer.style.width = `${widthP}px`;
-                    this.internalProps.bodyDomContainer.style.height = `${heightP}px`;
-                }
-                if (this.internalProps.headerDomContainer) {
-                    this.internalProps.headerDomContainer.style.width = `${widthP}px`;
-                    this.internalProps.headerDomContainer.style.height = `${heightP}px`;
-                }
             }
             else if (Env.mode === 'node') {
                 widthP = this.canvasWidth - 1;
@@ -57242,6 +57768,27 @@
         get headerDomContainer() {
             return this.internalProps.headerDomContainer;
         }
+        get frozenBodyDomContainer() {
+            return this.internalProps.frozenBodyDomContainer;
+        }
+        get frozenHeaderDomContainer() {
+            return this.internalProps.frozenHeaderDomContainer;
+        }
+        get rightFrozenBodyDomContainer() {
+            return this.internalProps.rightFrozenBodyDomContainer;
+        }
+        get rightFrozenHeaderDomContainer() {
+            return this.internalProps.rightFrozenHeaderDomContainer;
+        }
+        get frozenBottomDomContainer() {
+            return this.internalProps.frozenBottomDomContainer;
+        }
+        get bottomDomContainer() {
+            return this.internalProps.bottomDomContainer;
+        }
+        get rightFrozenBottomDomContainer() {
+            return this.internalProps.rightFrozenBottomDomContainer;
+        }
         showMoverLine(col, row) {
             this.scenegraph.component.showMoveCol(col, row, 0);
             this.scenegraph.renderSceneGraph();
@@ -58734,25 +59281,25 @@
             return this._hasAggregationOnBottomCount;
         }
         getAggregatorsByCell(col, row) {
-            const column = this.getBody(col, row);
-            const aggregators = column.aggregator;
+            const column = this.getColumnDefine(col, row);
+            const aggregators = column.vtable_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]);
+                    const column = this.getColumnDefine(startCol, i);
+                    if (column.vtable_aggregator) {
+                        aggregators = aggregators.concat(Array.isArray(column.vtable_aggregator) ? column.vtable_aggregator : [column.vtable_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]);
+                    const column = this.getColumnDefine(i, startRow);
+                    if (column.vtable_aggregator) {
+                        aggregators = aggregators.concat(Array.isArray(column.vtable_aggregator) ? column.vtable_aggregator : [column.vtable_aggregator]);
                     }
                 }
                 return aggregators;
@@ -58760,8 +59307,8 @@
             return [];
         }
         getAggregatorOnTop(col, row) {
-            const column = this.getBody(col, row);
-            const aggregators = column.aggregator;
+            const column = this.getColumnDefine(col, row);
+            const aggregators = column.vtable_aggregator;
             const aggregation = column.aggregation;
             if (Array.isArray(aggregation)) {
                 const topAggregationIndexs = aggregation.reduce((indexs, agg, index) => {
@@ -58785,12 +59332,12 @@
             return null;
         }
         getAggregatorOnBottom(col, row) {
-            const column = this.getBody(col, row);
-            const aggregators = column.aggregator;
+            const column = this.getColumnDefine(col, row);
+            const aggregators = column.vtable_aggregator;
             const aggregation = column.aggregation;
             if (Array.isArray(aggregation)) {
                 const bottomAggregationIndexs = aggregation.reduce((indexs, agg, index) => {
-                    if (agg.showOnTop === false) {
+                    if (!agg.showOnTop) {
                         indexs.push(index);
                     }
                     return indexs;
@@ -58802,10 +59349,10 @@
                 return bottomAggregators[row - (this.rowCount - this.hasAggregationOnBottomCount)];
             }
             if (this.transpose && col - (this.colCount - this.hasAggregationOnBottomCount) === 0) {
-                return aggregation?.showOnTop === false ? aggregators : null;
+                return !aggregation?.showOnTop ? aggregators : null;
             }
             else if (!this.transpose && row - (this.rowCount - this.hasAggregationOnBottomCount) === 0) {
-                return aggregation?.showOnTop === false ? aggregators : null;
+                return !aggregation?.showOnTop ? aggregators : null;
             }
             return null;
         }
@@ -58815,8 +59362,8 @@
             const bottomCount = this.hasAggregationOnBottomCount;
             if (this.transpose) {
                 for (let row = startRow; row <= endRow; row++) {
-                    const column = this.getBody(startCol, row);
-                    if (column.aggregator) {
+                    const column = this.getColumnDefine(startCol, row);
+                    if (column.vtable_aggregator) {
                         for (let i = 0; i < topCount; i++) {
                             cellAddrs.push({ col: this.headerLevelCount + i, row });
                         }
@@ -58828,8 +59375,8 @@
             }
             else {
                 for (let col = startCol; col <= endCol; col++) {
-                    const column = this.getBody(col, startRow);
-                    if (column.aggregator) {
+                    const column = this.getColumnDefine(col, startRow);
+                    if (column.vtable_aggregator) {
                         for (let i = 0; i < topCount; i++) {
                             cellAddrs.push({ col, row: this.headerLevelCount + i });
                         }
@@ -59295,7 +59842,7 @@
                         define: hd,
                         columnWidthComputeMode: hd.columnWidthComputeMode,
                         disableColumnResize: hd?.disableColumnResize,
-                        aggregation: this._getAggregationForColumn(hd, col),
+                        aggregation: hd.aggregation,
                         isChildNode: row >= 1
                     };
                     this._columnsIncludeHided.push(colDef);
@@ -59309,35 +59856,6 @@
             });
             return results;
         }
-        _getAggregationForColumn(colDef, col) {
-            let aggregation;
-            if (colDef.aggregation) {
-                aggregation = colDef.aggregation;
-            }
-            else if (this._table.options.aggregation) {
-                if (typeof this._table.options.aggregation === 'function') {
-                    aggregation = this._table.options.aggregation({
-                        col: col,
-                        field: colDef.field
-                    });
-                }
-                else {
-                    aggregation = this._table.options.aggregation;
-                }
-            }
-            if (aggregation) {
-                if (Array.isArray(aggregation)) {
-                    return aggregation.map(item => {
-                        if (!isValid$1(item.showOnTop)) {
-                            item.showOnTop = false;
-                        }
-                        return item;
-                    });
-                }
-                return Object.assign({ showOnTop: false }, aggregation);
-            }
-            return null;
-        }
         _newRow(row, hideColumnsSubHeader = false) {
             if (this._headerCellIds[row]) {
                 const prev = this._headerCellIds[row - 1];
@@ -59417,8 +59935,8 @@
             else if (this.transpose &&
                 this.isSeriesNumberInBody(target.col, target.row) &&
                 this.isSeriesNumberInBody(source.col, source.row)) {
-                if (this._getColumnDefine(source.col + this.leftRowSeriesNumberColumnCount, source.row).isChildNode &&
-                    this._getColumnDefine(target.col + this.leftRowSeriesNumberColumnCount, target.row).isChildNode) {
+                if (this.getBody(source.col + this.leftRowSeriesNumberColumnCount, source.row).isChildNode &&
+                    this.getBody(target.col + this.leftRowSeriesNumberColumnCount, target.row).isChildNode) {
                     source.col = source.col + this.leftRowSeriesNumberColumnCount + this.rowHeaderLevelCount - 1;
                     target.col = target.col + this.leftRowSeriesNumberColumnCount + this.rowHeaderLevelCount - 1;
                 }
@@ -59623,15 +60141,15 @@
             }, []);
             return result;
         }
-        _getColumnDefine(col, row) {
+        getColumnDefine(col, row) {
             if (col >= 0) {
                 if (col < this.leftRowSeriesNumberColumnCount) {
-                    return this.leftRowSeriesNumberColumn[col];
+                    return this.leftRowSeriesNumberColumn[col].define;
                 }
                 if (this.transpose) {
-                    return this._columns[row];
+                    return this._columns[row].define;
                 }
-                return this._columns[col - this.leftRowSeriesNumberColumnCount];
+                return this._columns[col - this.leftRowSeriesNumberColumnCount].define;
             }
             return undefined;
         }
@@ -59669,6 +60187,9 @@
             });
         }
         startEditCell(col, row, value) {
+            if (this.editingEditor) {
+                return;
+            }
             const editor = this.table.getEditor(col, row);
             if (editor) {
                 if (this.table.internalProps.layoutMap?.isAggregation?.(col, row)) {
@@ -60098,6 +60619,14 @@
                         addRows.push({ col: 0, row });
                     }
                 }
+                const topAggregationCount = table.internalProps.layoutMap.hasAggregationOnTopCount;
+                const bottomAggregationCount = table.internalProps.layoutMap.hasAggregationOnBottomCount;
+                for (let row = headerCount; row < headerCount + topAggregationCount; row++) {
+                    if (table.transpose) ;
+                }
+                for (let row = (table.transpose ? table.colCount : table.rowCount) - bottomAggregationCount; row < (table.transpose ? table.colCount : table.rowCount); row++) {
+                    if (table.transpose) ;
+                }
                 table.transpose ? table.scenegraph.updateCol([], addRows, []) : table.scenegraph.updateRow([], addRows, []);
             }
         }
@@ -60184,7 +60713,28 @@
                         addRows.push({ col: 0, row });
                     }
                 }
-                table.transpose ? table.scenegraph.updateCol([], addRows, []) : table.scenegraph.updateRow([], addRows, []);
+                const topAggregationCount = table.internalProps.layoutMap.hasAggregationOnTopCount;
+                const bottomAggregationCount = table.internalProps.layoutMap.hasAggregationOnBottomCount;
+                const updateRows = [];
+                for (let row = headerCount; row < headerCount + topAggregationCount; row++) {
+                    if (table.transpose) {
+                        updateRows.push({ col: row, row: 0 });
+                    }
+                    else {
+                        updateRows.push({ col: 0, row });
+                    }
+                }
+                for (let row = (table.transpose ? table.colCount : table.rowCount) - bottomAggregationCount; row < (table.transpose ? table.colCount : table.rowCount); row++) {
+                    if (table.transpose) {
+                        updateRows.push({ col: row, row: 0 });
+                    }
+                    else {
+                        updateRows.push({ col: 0, row });
+                    }
+                }
+                table.transpose
+                    ? table.scenegraph.updateCol([], addRows, updateRows)
+                    : table.scenegraph.updateRow([], addRows, updateRows);
             }
         }
     }
@@ -60224,9 +60774,12 @@
                             table.scenegraph.createSceneGraph();
                         }
                         else {
+                            const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
+                            const topAggregationCount = table.internalProps.layoutMap.hasAggregationOnTopCount;
                             const minRowNum = minRecordIndex -
                                 (endIndex - perPageCount) +
-                                (table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount);
+                                (table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount) +
+                                topAggregationCount;
                             const updateRows = [];
                             const delRows = [];
                             for (let row = minRowNum; row < newRowCount; row++) {
@@ -60237,6 +60790,14 @@
                                     updateRows.push({ col: 0, row });
                                 }
                             }
+                            for (let row = headerCount; row < headerCount + topAggregationCount; row++) {
+                                if (table.transpose) {
+                                    updateRows.push({ col: row, row: 0 });
+                                }
+                                else {
+                                    updateRows.push({ col: 0, row });
+                                }
+                            }
                             if (newRowCount < oldRowCount) {
                                 for (let row = newRowCount; row < oldRowCount; row++) {
                                     if (table.transpose) {
@@ -60255,9 +60816,12 @@
                 }
                 else {
                     const delRows = [];
+                    const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
+                    const topAggregationCount = table.internalProps.layoutMap.hasAggregationOnTopCount;
+                    const bottomAggregationCount = table.internalProps.layoutMap.hasAggregationOnBottomCount;
                     for (let index = 0; index < recordIndexsMinToMax.length; index++) {
                         const recordIndex = recordIndexsMinToMax[index];
-                        const rowNum = recordIndex + (table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount);
+                        const rowNum = recordIndex + headerCount + topAggregationCount;
                         if (table.transpose) {
                             delRows.push({ col: rowNum, row: 0 });
                         }
@@ -60265,7 +60829,26 @@
                             delRows.push({ col: 0, row: rowNum });
                         }
                     }
-                    table.transpose ? table.scenegraph.updateCol(delRows, [], []) : table.scenegraph.updateRow(delRows, [], []);
+                    const updateRows = [];
+                    for (let row = headerCount; row < headerCount + topAggregationCount; row++) {
+                        if (table.transpose) {
+                            updateRows.push({ col: row, row: 0 });
+                        }
+                        else {
+                            updateRows.push({ col: 0, row });
+                        }
+                    }
+                    for (let row = (table.transpose ? table.colCount : table.rowCount) - bottomAggregationCount; row < (table.transpose ? table.colCount : table.rowCount); row++) {
+                        if (table.transpose) {
+                            updateRows.push({ col: row, row: 0 });
+                        }
+                        else {
+                            updateRows.push({ col: 0, row });
+                        }
+                    }
+                    table.transpose
+                        ? table.scenegraph.updateCol(delRows, [], updateRows)
+                        : table.scenegraph.updateRow(delRows, [], updateRows);
                 }
             }
         }
@@ -60294,6 +60877,8 @@
                 const recordIndexsMinToMax = updateRecordIndexs.sort((a, b) => a - b);
                 if (table.pagination) {
                     const { perPageCount, currentPage } = table.pagination;
+                    const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
+                    const topAggregationCount = table.internalProps.layoutMap.hasAggregationOnTopCount;
                     const startIndex = perPageCount * (currentPage || 0);
                     const endIndex = startIndex + perPageCount;
                     const updateRows = [];
@@ -60302,7 +60887,8 @@
                         if (recordIndex < endIndex && recordIndex >= endIndex - perPageCount) {
                             const rowNum = recordIndex -
                                 (endIndex - perPageCount) +
-                                (table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount);
+                                (table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount) +
+                                topAggregationCount;
                             updateRows.push(rowNum);
                         }
                     }
@@ -60317,6 +60903,14 @@
                                 updateRowCells.push({ col: 0, row: updateRow });
                             }
                         }
+                        for (let row = headerCount; row < headerCount + topAggregationCount; row++) {
+                            if (table.transpose) {
+                                updateRowCells.push({ col: row, row: 0 });
+                            }
+                            else {
+                                updateRowCells.push({ col: 0, row });
+                            }
+                        }
                         table.transpose
                             ? table.scenegraph.updateCol([], [], updateRowCells)
                             : table.scenegraph.updateRow([], [], updateRowCells);
@@ -60324,9 +60918,12 @@
                 }
                 else {
                     const updateRows = [];
+                    const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
+                    const topAggregationCount = table.internalProps.layoutMap.hasAggregationOnTopCount;
+                    const bottomAggregationCount = table.internalProps.layoutMap.hasAggregationOnBottomCount;
                     for (let index = 0; index < recordIndexsMinToMax.length; index++) {
                         const recordIndex = recordIndexsMinToMax[index];
-                        const rowNum = recordIndex + (table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount);
+                        const rowNum = recordIndex + headerCount + topAggregationCount;
                         if (table.transpose) {
                             updateRows.push({ col: rowNum, row: 0 });
                         }
@@ -60334,6 +60931,22 @@
                             updateRows.push({ col: 0, row: rowNum });
                         }
                     }
+                    for (let row = headerCount; row < headerCount + topAggregationCount; row++) {
+                        if (table.transpose) {
+                            updateRows.push({ col: row, row: 0 });
+                        }
+                        else {
+                            updateRows.push({ col: 0, row });
+                        }
+                    }
+                    for (let row = (table.transpose ? table.colCount : table.rowCount) - bottomAggregationCount; row < (table.transpose ? table.colCount : table.rowCount); row++) {
+                        if (table.transpose) {
+                            updateRows.push({ col: row, row: 0 });
+                        }
+                        else {
+                            updateRows.push({ col: 0, row });
+                        }
+                    }
                     table.transpose
                         ? table.scenegraph.updateCol([], [], updateRows)
                         : table.scenegraph.updateRow([], [], updateRows);
@@ -60371,6 +60984,7 @@
                 : options.header
                     ? cloneDeepSpec(options.header, ['children'])
                     : [];
+            generateAggregationForColumn(this);
             internalProps.enableTreeNodeMerge = options.enableTreeNodeMerge ?? isValid$1(options.groupBy) ?? false;
             this.internalProps.headerHelper.setTableColumnsEditor();
             this.showHeader = options.showHeader ?? true;
@@ -60433,6 +61047,7 @@
         updateColumns(columns) {
             const oldHoverState = { col: this.stateManager.hover.cellPos.col, row: this.stateManager.hover.cellPos.row };
             this.internalProps.columns = cloneDeepSpec(columns, ['children']);
+            generateAggregationForColumn(this);
             this.options.columns = columns;
             this.internalProps.headerHelper.setTableColumnsEditor();
             this._hasAutoImageColumn = undefined;
@@ -60455,6 +61070,7 @@
         }
         set header(header) {
             this.internalProps.columns = header;
+            generateAggregationForColumn(this);
             this.options.header = header;
             this.refreshHeader();
             this.internalProps.useOneRowHeightFillAll = false;
@@ -60638,6 +61254,7 @@
                 : options.header
                     ? cloneDeepSpec(options.header, ['children'])
                     : [];
+            generateAggregationForColumn(this);
             internalProps.enableTreeNodeMerge = options.enableTreeNodeMerge ?? isValid$1(options.groupBy) ?? false;
             this.internalProps.headerHelper.setTableColumnsEditor();
             this.transpose = options.transpose ?? false;
@@ -69179,13 +69796,17 @@
         indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
         customRowTree;
         customColTree;
+        customRowTreeDimensionPaths;
+        customColTreeDimensionPaths;
         colHeaderTree;
         rowHeaderTree;
         rowHierarchyType;
         indicators;
         indicatorsAsCol;
         totalRecordsTree = {};
-        constructor(dataConfig, rows, columns, indicatorKeys, indicators, indicatorsAsCol, records, rowHierarchyType, customColTree, customRowTree, needSplitPositiveAndNegative) {
+        hasExtensionRowTree;
+        parseCustomTreeToMatchRecords;
+        constructor(dataConfig, rows, columns, indicatorKeys, indicators, indicatorsAsCol, records, rowHierarchyType, customColTree, customRowTree, needSplitPositiveAndNegative, hasExtensionRowTree, parseCustomTreeToMatchRecords) {
             this.registerAggregators();
             this.dataConfig = dataConfig;
             this.filterRules = this.dataConfig?.filterRules;
@@ -69219,6 +69840,14 @@
             this.indicators = indicators;
             this.customColTree = customColTree;
             this.customRowTree = customRowTree;
+            this.hasExtensionRowTree = hasExtensionRowTree;
+            this.parseCustomTreeToMatchRecords = parseCustomTreeToMatchRecords;
+            if (this.parseCustomTreeToMatchRecords) {
+                this.customColTreeDimensionPaths = this.customTreeToDimensionPathArr(this.customColTree, 'col');
+                if (!this.hasExtensionRowTree) {
+                    this.customRowTreeDimensionPaths = this.customTreeToDimensionPathArr(this.customRowTree, 'row');
+                }
+            }
             this.colGrandTotalLabel = this.totals?.column?.grandTotalLabel ?? '总计';
             this.colSubTotalLabel = this.totals?.column?.subTotalLabel ?? '小计';
             this.rowGrandTotalLabel = this.totals?.row?.grandTotalLabel ?? '总计';
@@ -69503,217 +70132,291 @@
                     }
                 }
             }
-            const colKey = [];
-            const rowKey = [];
             let isToTalRecord = false;
-            for (let l = 0, len1 = this.rows.length; l < len1; l++) {
-                const rowAttr = this.rows[l];
-                if (rowAttr in record) {
-                    this.rowsHasValue[l] = true;
-                    rowKey.push(record[rowAttr]);
-                }
-                else if (rowAttr !== IndicatorDimensionKeyPlaceholder) {
-                    if (this.dataConfig?.totals?.row?.showGrandTotals &&
-                        l === 0 &&
-                        !this.rows.find((rk) => {
-                            return rk in record;
-                        })) {
-                        rowKey.push(this.rowGrandTotalLabel);
-                        isToTalRecord = true;
-                        break;
-                    }
-                    else if (this.dataConfig?.totals?.row?.subTotalsDimensions &&
-                        this.dataConfig?.totals?.row?.subTotalsDimensions.indexOf(this.rows[l - 1]) >= 0) {
-                        if (this.rowHierarchyType === 'grid') {
-                            rowKey.push(this.rowSubTotalLabel);
+            const colKeys = [];
+            const rowKeys = [];
+            if (this.parseCustomTreeToMatchRecords &&
+                !this.dataConfig?.isPivotChart &&
+                this.customRowTree?.length &&
+                !assignedIndicatorKey &&
+                !this.hasExtensionRowTree) {
+                const rowTreePath = this.getFieldMatchRowDimensionPaths(record);
+                if (rowTreePath.length > 0) {
+                    for (let i = 0, len = rowTreePath.length; i < len; i++) {
+                        const rowPath = rowTreePath[i];
+                        const rowKey = [];
+                        let indicatorKey;
+                        for (let j = 0, len1 = rowPath.length; j < len1; j++) {
+                            if (isValid$1(rowPath[j].indicatorKey)) {
+                                indicatorKey = rowPath[j].indicatorKey;
+                            }
+                            else {
+                                rowKey.push(rowPath[j].value);
+                            }
                         }
-                        isToTalRecord = true;
-                        break;
+                        rowKeys.push({ rowKey, indicatorKey });
                     }
                 }
             }
-            for (let n = 0, len2 = this.columns.length; n < len2; n++) {
-                const colAttr = this.columns[n];
-                if (colAttr in record) {
-                    this.columnsHasValue[n] = true;
-                    colKey.push(record[colAttr]);
-                }
-                else if (colAttr !== IndicatorDimensionKeyPlaceholder) {
-                    if (this.dataConfig?.totals?.column?.showGrandTotals &&
-                        n === 0 &&
-                        !this.columns.find((ck) => {
-                            return ck in record;
-                        })) {
-                        colKey.push(this.colGrandTotalLabel);
-                        isToTalRecord = true;
-                        break;
-                    }
-                    else if (this.dataConfig?.totals?.column?.subTotalsDimensions &&
-                        this.dataConfig?.totals?.column?.subTotalsDimensions.indexOf(this.columns[n - 1]) >= 0) {
-                        colKey.push(this.colSubTotalLabel);
-                        isToTalRecord = true;
-                        break;
+            else {
+                const rowKey = [];
+                rowKeys.push({ rowKey, indicatorKey: assignedIndicatorKey });
+                for (let l = 0, len1 = this.rows.length; l < len1; l++) {
+                    const rowAttr = this.rows[l];
+                    if (rowAttr in record) {
+                        this.rowsHasValue[l] = true;
+                        rowKey.push(record[rowAttr]);
+                    }
+                    else if (rowAttr !== IndicatorDimensionKeyPlaceholder) {
+                        if (this.dataConfig?.totals?.row?.showGrandTotals &&
+                            l === 0 &&
+                            !this.rows.find((rk) => {
+                                return rk in record;
+                            })) {
+                            rowKey.push(this.rowGrandTotalLabel);
+                            isToTalRecord = true;
+                            break;
+                        }
+                        else if (this.dataConfig?.totals?.row?.subTotalsDimensions &&
+                            this.dataConfig?.totals?.row?.subTotalsDimensions.indexOf(this.rows[l - 1]) >= 0) {
+                            if (this.rowHierarchyType === 'grid') {
+                                rowKey.push(this.rowSubTotalLabel);
+                            }
+                            isToTalRecord = true;
+                            break;
+                        }
                     }
                 }
             }
-            const flatRowKey = rowKey.join(this.stringJoinChar);
-            const flatColKey = colKey.join(this.stringJoinChar);
-            if (isToTalRecord) {
-                if (!this.totalRecordsTree[flatRowKey]) {
-                    this.totalRecordsTree[flatRowKey] = {};
-                }
-                if (!this.totalRecordsTree[flatRowKey][flatColKey]) {
-                    this.totalRecordsTree[flatRowKey][flatColKey] = [];
-                }
-                const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
-                for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
-                    if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
-                        const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
-                        if (!this.totalRecordsTree[flatRowKey]?.[flatColKey]?.[i]) {
-                            this.totalRecordsTree[flatRowKey][flatColKey][i] = new this.aggregators[AggregationType.RECALCULATE]({
-                                key: toComputeIndicatorKeys[i],
-                                dimension: toComputeIndicatorKeys[i],
-                                isRecord: true,
-                                formatFun: this.indicators?.find((indicator) => {
-                                    if (typeof indicator !== 'string') {
-                                        return indicator.indicatorKey === toComputeIndicatorKeys[i];
-                                    }
-                                    return false;
-                                })?.format,
-                                calculateFun: calculatedFieldRule?.calculateFun,
-                                dependAggregators: this.totalRecordsTree[flatRowKey][flatColKey],
-                                dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
-                            });
-                        }
-                        toComputeIndicatorKeys[i] in record && this.totalRecordsTree[flatRowKey]?.[flatColKey]?.[i].push(record);
-                    }
-                    else {
-                        const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
-                        if (!this.totalRecordsTree[flatRowKey]?.[flatColKey]?.[i]) {
-                            this.totalRecordsTree[flatRowKey][flatColKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
-                                key: toComputeIndicatorKeys[i],
-                                dimension: aggRule?.field ?? toComputeIndicatorKeys[i],
-                                formatFun: aggRule?.formatFun ??
-                                    this.indicators?.find((indicator) => {
-                                        if (typeof indicator !== 'string') {
-                                            return indicator.indicatorKey === toComputeIndicatorKeys[i];
-                                        }
-                                        return false;
-                                    })?.format
-                            });
+            if (this.parseCustomTreeToMatchRecords &&
+                !this.dataConfig?.isPivotChart &&
+                this.customColTree?.length &&
+                !assignedIndicatorKey &&
+                !this.hasExtensionRowTree) {
+                const colTreePath = this.getFieldMatchColDimensionPaths(record);
+                if (colTreePath.length > 0) {
+                    for (let i = 0, len = colTreePath.length; i < len; i++) {
+                        const colPath = colTreePath[i];
+                        const colKey = [];
+                        let indicatorKey;
+                        for (let j = 0, len1 = colPath.length; j < len1; j++) {
+                            if (isValid$1(colPath[j].indicatorKey)) {
+                                indicatorKey = colPath[j].indicatorKey;
+                            }
+                            else {
+                                colKey.push(colPath[j].value);
+                            }
                         }
-                        toComputeIndicatorKeys[i] in record && this.totalRecordsTree[flatRowKey]?.[flatColKey]?.[i].push(record);
+                        colKeys.push({ colKey: colKey, indicatorKey });
                     }
                 }
-                return;
             }
-            if (rowKey.length !== 0) {
-                if (!this.rowFlatKeys[flatRowKey]) {
-                    this.rowKeys.push(rowKey);
-                    this.rowFlatKeys[flatRowKey] = 1;
+            else {
+                const colKey = [];
+                colKeys.push({ colKey, indicatorKey: assignedIndicatorKey });
+                for (let n = 0, len2 = this.columns.length; n < len2; n++) {
+                    const colAttr = this.columns[n];
+                    if (colAttr in record) {
+                        this.columnsHasValue[n] = true;
+                        colKey.push(record[colAttr]);
+                    }
+                    else if (colAttr !== IndicatorDimensionKeyPlaceholder) {
+                        if (this.dataConfig?.totals?.column?.showGrandTotals &&
+                            n === 0 &&
+                            !this.columns.find((ck) => {
+                                return ck in record;
+                            })) {
+                            colKey.push(this.colGrandTotalLabel);
+                            isToTalRecord = true;
+                            break;
+                        }
+                        else if (this.dataConfig?.totals?.column?.subTotalsDimensions &&
+                            this.dataConfig?.totals?.column?.subTotalsDimensions.indexOf(this.columns[n - 1]) >= 0) {
+                            colKey.push(this.colSubTotalLabel);
+                            isToTalRecord = true;
+                            break;
+                        }
+                    }
                 }
             }
-            if (colKey.length !== 0) {
-                if (!this.colFlatKeys[flatColKey]) {
-                    this.colKeys.push(colKey);
-                    this.colFlatKeys[flatColKey] = 1;
+            for (let row_i = 0; row_i < rowKeys.length; row_i++) {
+                const rowKey = rowKeys[row_i].rowKey;
+                let assignedIndicatorKey_value;
+                if (!this.indicatorsAsCol) {
+                    assignedIndicatorKey_value = rowKeys[row_i].indicatorKey;
                 }
-            }
-            if (!this.tree[flatRowKey]) {
-                this.tree[flatRowKey] = {};
-            }
-            if (!this.tree[flatRowKey]?.[flatColKey]) {
-                this.tree[flatRowKey][flatColKey] = [];
-            }
-            const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
-            for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
-                if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
-                    const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
-                    if (!this.tree[flatRowKey]?.[flatColKey]?.[i]) {
-                        this.tree[flatRowKey][flatColKey][i] = new this.aggregators[AggregationType.RECALCULATE]({
-                            key: toComputeIndicatorKeys[i],
-                            dimension: toComputeIndicatorKeys[i],
-                            isRecord: true,
-                            formatFun: this.indicators?.find((indicator) => {
-                                if (typeof indicator !== 'string') {
-                                    return indicator.indicatorKey === toComputeIndicatorKeys[i];
+                for (let col_j = 0; col_j < colKeys.length; col_j++) {
+                    const colKey = colKeys[col_j].colKey;
+                    if (this.indicatorsAsCol) {
+                        assignedIndicatorKey_value = colKeys[col_j].indicatorKey;
+                    }
+                    const flatRowKey = rowKey.join(this.stringJoinChar);
+                    const flatColKey = colKey.join(this.stringJoinChar);
+                    if (isToTalRecord) {
+                        if (!this.totalRecordsTree[flatRowKey]) {
+                            this.totalRecordsTree[flatRowKey] = {};
+                        }
+                        if (!this.totalRecordsTree[flatRowKey][flatColKey]) {
+                            this.totalRecordsTree[flatRowKey][flatColKey] = [];
+                        }
+                        const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
+                        for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
+                            if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
+                                const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
+                                if (!this.totalRecordsTree[flatRowKey]?.[flatColKey]?.[i]) {
+                                    this.totalRecordsTree[flatRowKey][flatColKey][i] = new this.aggregators[AggregationType.RECALCULATE]({
+                                        key: toComputeIndicatorKeys[i],
+                                        dimension: toComputeIndicatorKeys[i],
+                                        isRecord: true,
+                                        formatFun: this.indicators?.find((indicator) => {
+                                            if (typeof indicator !== 'string') {
+                                                return indicator.indicatorKey === toComputeIndicatorKeys[i];
+                                            }
+                                            return false;
+                                        })?.format,
+                                        calculateFun: calculatedFieldRule?.calculateFun,
+                                        dependAggregators: this.totalRecordsTree[flatRowKey][flatColKey],
+                                        dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
+                                    });
                                 }
-                                return false;
-                            })?.format,
-                            calculateFun: calculatedFieldRule?.calculateFun,
-                            dependAggregators: this.tree[flatRowKey][flatColKey],
-                            dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
-                        });
+                                toComputeIndicatorKeys[i] in record && this.totalRecordsTree[flatRowKey]?.[flatColKey]?.[i].push(record);
+                            }
+                            else {
+                                const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
+                                if (!this.totalRecordsTree[flatRowKey]?.[flatColKey]?.[i]) {
+                                    this.totalRecordsTree[flatRowKey][flatColKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
+                                        key: toComputeIndicatorKeys[i],
+                                        dimension: aggRule?.field ?? toComputeIndicatorKeys[i],
+                                        formatFun: aggRule?.formatFun ??
+                                            this.indicators?.find((indicator) => {
+                                                if (typeof indicator !== 'string') {
+                                                    return indicator.indicatorKey === toComputeIndicatorKeys[i];
+                                                }
+                                                return false;
+                                            })?.format
+                                    });
+                                }
+                                toComputeIndicatorKeys[i] in record && this.totalRecordsTree[flatRowKey]?.[flatColKey]?.[i].push(record);
+                            }
+                        }
+                        return;
                     }
-                    this.tree[flatRowKey]?.[flatColKey]?.[i].push(record);
-                }
-                else {
-                    const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
-                    let needAddToAggregator = false;
-                    if (assignedIndicatorKey) {
-                        toComputeIndicatorKeys[i] === assignedIndicatorKey && (needAddToAggregator = true);
-                    }
-                    else if (aggRule?.field) {
-                        if (typeof aggRule?.field === 'string') {
-                            aggRule?.field in record && (needAddToAggregator = true);
+                    if (rowKey.length !== 0) {
+                        if (!this.rowFlatKeys[flatRowKey]) {
+                            this.rowKeys.push(rowKey);
+                            this.rowFlatKeys[flatRowKey] = 1;
                         }
-                        else {
-                            const isPush = aggRule?.field.find((field) => {
-                                return field in record;
-                            });
-                            isPush && (needAddToAggregator = true);
+                    }
+                    if (colKey.length !== 0) {
+                        if (!this.colFlatKeys[flatColKey]) {
+                            this.colKeys.push(colKey);
+                            this.colFlatKeys[flatColKey] = 1;
                         }
                     }
-                    else {
-                        toComputeIndicatorKeys[i] in record && (needAddToAggregator = true);
-                    }
-                    if (!this.tree[flatRowKey]?.[flatColKey]?.[i] && needAddToAggregator) {
-                        this.tree[flatRowKey][flatColKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
-                            key: toComputeIndicatorKeys[i],
-                            dimension: aggRule?.field ?? toComputeIndicatorKeys[i],
-                            formatFun: aggRule?.formatFun ??
-                                this.indicators?.find((indicator) => {
-                                    if (typeof indicator !== 'string') {
-                                        return indicator.indicatorKey === toComputeIndicatorKeys[i];
-                                    }
-                                    return false;
-                                })?.format
-                        });
+                    if (!this.tree[flatRowKey]) {
+                        this.tree[flatRowKey] = {};
                     }
-                    if (needAddToAggregator) {
-                        this.tree[flatRowKey]?.[flatColKey]?.[i].push(record);
-                    }
-                }
-            }
-            if (this.mappingRules) {
-                for (let i = 0; i < this.indicatorKeys.length; i++) {
-                    if (!this.indicatorStatistics[i]) {
-                        const aggRule = this.getAggregatorRule(this.indicatorKeys[i]);
-                        this.indicatorStatistics[i] = {
-                            max: new this.aggregators[AggregationType.MAX]({
-                                key: this.indicatorKeys[i],
-                                dimension: this.indicatorKeys[i]
-                            }),
-                            min: new this.aggregators[AggregationType.MIN]({
-                                key: this.indicatorKeys[i],
-                                dimension: this.indicatorKeys[i]
-                            }),
-                            total: new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
-                                key: this.indicatorKeys[i],
-                                dimension: aggRule?.field ?? this.indicatorKeys[i],
-                                formatFun: aggRule?.formatFun ??
-                                    this.indicators?.find((indicator) => {
+                    if (!this.tree[flatRowKey]?.[flatColKey]) {
+                        this.tree[flatRowKey][flatColKey] = [];
+                    }
+                    const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
+                    for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
+                        if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
+                            const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
+                            if (!this.tree[flatRowKey]?.[flatColKey]?.[i]) {
+                                this.tree[flatRowKey][flatColKey][i] = new this.aggregators[AggregationType.RECALCULATE]({
+                                    key: toComputeIndicatorKeys[i],
+                                    dimension: toComputeIndicatorKeys[i],
+                                    isRecord: true,
+                                    formatFun: this.indicators?.find((indicator) => {
                                         if (typeof indicator !== 'string') {
-                                            return indicator.indicatorKey === this.indicatorKeys[i];
+                                            return indicator.indicatorKey === toComputeIndicatorKeys[i];
                                         }
                                         return false;
-                                    })?.format
-                            })
-                        };
+                                    })?.format,
+                                    calculateFun: calculatedFieldRule?.calculateFun,
+                                    dependAggregators: this.tree[flatRowKey][flatColKey],
+                                    dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
+                                });
+                            }
+                            this.tree[flatRowKey]?.[flatColKey]?.[i].push(record);
+                        }
+                        else {
+                            const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
+                            let needAddToAggregator = false;
+                            if (assignedIndicatorKey_value) {
+                                if (assignedIndicatorKey === assignedIndicatorKey_value) {
+                                    toComputeIndicatorKeys[i] === assignedIndicatorKey_value && (needAddToAggregator = true);
+                                }
+                                else {
+                                    toComputeIndicatorKeys[i] === assignedIndicatorKey_value &&
+                                        toComputeIndicatorKeys[i] in record &&
+                                        (needAddToAggregator = true);
+                                }
+                            }
+                            else if (aggRule?.field) {
+                                if (typeof aggRule?.field === 'string') {
+                                    aggRule?.field in record && (needAddToAggregator = true);
+                                }
+                                else {
+                                    const isPush = aggRule?.field.find((field) => {
+                                        return field in record;
+                                    });
+                                    isPush && (needAddToAggregator = true);
+                                }
+                            }
+                            else {
+                                toComputeIndicatorKeys[i] in record && (needAddToAggregator = true);
+                            }
+                            if (!this.tree[flatRowKey]?.[flatColKey]?.[i] && needAddToAggregator) {
+                                this.tree[flatRowKey][flatColKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
+                                    key: toComputeIndicatorKeys[i],
+                                    dimension: aggRule?.field ?? toComputeIndicatorKeys[i],
+                                    formatFun: aggRule?.formatFun ??
+                                        this.indicators?.find((indicator) => {
+                                            if (typeof indicator !== 'string') {
+                                                return indicator.indicatorKey === toComputeIndicatorKeys[i];
+                                            }
+                                            return false;
+                                        })?.format
+                                });
+                            }
+                            if (needAddToAggregator) {
+                                this.tree[flatRowKey]?.[flatColKey]?.[i].push(record);
+                            }
+                        }
+                    }
+                    if (this.mappingRules) {
+                        for (let i = 0; i < this.indicatorKeys.length; i++) {
+                            if (!this.indicatorStatistics[i]) {
+                                const aggRule = this.getAggregatorRule(this.indicatorKeys[i]);
+                                this.indicatorStatistics[i] = {
+                                    max: new this.aggregators[AggregationType.MAX]({
+                                        key: this.indicatorKeys[i],
+                                        dimension: this.indicatorKeys[i]
+                                    }),
+                                    min: new this.aggregators[AggregationType.MIN]({
+                                        key: this.indicatorKeys[i],
+                                        dimension: this.indicatorKeys[i]
+                                    }),
+                                    total: new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
+                                        key: this.indicatorKeys[i],
+                                        dimension: aggRule?.field ?? this.indicatorKeys[i],
+                                        formatFun: aggRule?.formatFun ??
+                                            this.indicators?.find((indicator) => {
+                                                if (typeof indicator !== 'string') {
+                                                    return indicator.indicatorKey === this.indicatorKeys[i];
+                                                }
+                                                return false;
+                                            })?.format
+                                    })
+                                };
+                            }
+                            this.indicatorStatistics[i].max.push(this.tree[flatRowKey]?.[flatColKey]?.[i].value());
+                            this.indicatorStatistics[i].min.push(this.tree[flatRowKey]?.[flatColKey]?.[i].value());
+                            this.indicatorStatistics[i].total.push(record);
+                        }
                     }
-                    this.indicatorStatistics[i].max.push(this.tree[flatRowKey]?.[flatColKey]?.[i].value());
-                    this.indicatorStatistics[i].min.push(this.tree[flatRowKey]?.[flatColKey]?.[i].value());
-                    this.indicatorStatistics[i].total.push(record);
                 }
             }
         }
@@ -69751,7 +70454,7 @@
                 for (const treeRowKey in this.tree) {
                     for (const treeColKey in this.tree[treeRowKey]) {
                         for (let i = 0; i < this.tree[treeRowKey][treeColKey].length; i++) {
-                            this.tree[treeRowKey][treeColKey][i].reset();
+                            this.tree[treeRowKey][treeColKey][i]?.reset();
                         }
                     }
                 }
@@ -69962,136 +70665,139 @@
         }
         totalStatistics() {
             const that = this;
-            if ((that?.totals?.column?.subTotalsDimensions && that?.totals?.column?.subTotalsDimensions?.length >= 1) ||
-                (that?.totals?.row?.subTotalsDimensions && that?.totals?.row?.subTotalsDimensions?.length >= 1) ||
-                that?.totals?.column?.showGrandTotals ||
-                that?.totals?.row?.showGrandTotals) {
-                const rowTotalKeys = [];
-                const colCompute = (flatRowKey, flatColKey) => {
-                    if (this.totalRecordsTree?.[flatRowKey]?.[flatColKey]) {
-                        this.tree[flatRowKey][flatColKey] = this.totalRecordsTree?.[flatRowKey]?.[flatColKey];
-                        return;
+            const colCompute = (flatRowKey, flatColKey) => {
+                if (this.totalRecordsTree?.[flatRowKey]?.[flatColKey]) {
+                    if (!this.tree[flatRowKey]) {
+                        this.tree[flatRowKey] = {};
                     }
-                    const colKey = flatColKey.split(this.stringJoinChar);
-                    if (that.totals?.column?.subTotalsDimensions &&
-                        that.totals?.column?.subTotalsDimensions?.length > 0 &&
-                        that.totals.column.showSubTotals !== false) {
-                        for (let i = 0, len = that.totals?.column?.subTotalsDimensions?.length; i < len; i++) {
-                            const dimension = that.totals.column.subTotalsDimensions[i];
-                            const dimensionIndex = that.columns.indexOf(dimension);
-                            if (dimensionIndex >= 0) {
-                                const colTotalKey = colKey.slice(0, dimensionIndex + 1);
-                                colTotalKey.push(that.colSubTotalLabel);
-                                const flatColTotalKey = colTotalKey.join(this.stringJoinChar);
-                                if (this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey]) {
-                                    this.tree[flatRowKey][flatColTotalKey] = this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey];
-                                    return;
-                                }
-                                if (!this.tree[flatRowKey][flatColTotalKey]) {
-                                    this.tree[flatRowKey][flatColTotalKey] = [];
+                    this.tree[flatRowKey][flatColKey] = this.totalRecordsTree?.[flatRowKey]?.[flatColKey];
+                    return;
+                }
+                const colKey = flatColKey.split(this.stringJoinChar);
+                if (that.totals?.column?.subTotalsDimensions &&
+                    that.totals?.column?.subTotalsDimensions?.length > 0 &&
+                    that.totals.column.showSubTotals !== false) {
+                    for (let i = 0, len = that.totals?.column?.subTotalsDimensions?.length; i < len; i++) {
+                        const dimension = that.totals.column.subTotalsDimensions[i];
+                        const dimensionIndex = that.columns.indexOf(dimension);
+                        if (dimensionIndex >= 0) {
+                            const colTotalKey = colKey.slice(0, dimensionIndex + 1);
+                            colTotalKey.push(that.colSubTotalLabel);
+                            const flatColTotalKey = colTotalKey.join(this.stringJoinChar);
+                            if (this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey]) {
+                                this.tree[flatRowKey][flatColTotalKey] = this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey];
+                                return;
+                            }
+                            if (!this.tree[flatRowKey][flatColTotalKey]) {
+                                this.tree[flatRowKey][flatColTotalKey] = [];
+                            }
+                            const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
+                            for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
+                                if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
+                                    const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
+                                    if (!this.tree[flatRowKey]?.[flatColTotalKey]?.[i]) {
+                                        this.tree[flatRowKey][flatColTotalKey][i] = new this.aggregators[AggregationType.RECALCULATE]({
+                                            key: toComputeIndicatorKeys[i],
+                                            dimension: toComputeIndicatorKeys[i],
+                                            isRecord: true,
+                                            formatFun: this.indicators?.find((indicator) => {
+                                                if (typeof indicator !== 'string') {
+                                                    return indicator.indicatorKey === toComputeIndicatorKeys[i];
+                                                }
+                                                return false;
+                                            })?.format,
+                                            calculateFun: calculatedFieldRule?.calculateFun,
+                                            dependAggregators: this.tree[flatRowKey][flatColTotalKey],
+                                            dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
+                                        });
+                                    }
+                                    if (flatColTotalKey !== flatColKey) {
+                                        this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
+                                    }
                                 }
-                                const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
-                                for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
-                                    if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
-                                        const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
-                                        if (!this.tree[flatRowKey]?.[flatColTotalKey]?.[i]) {
-                                            this.tree[flatRowKey][flatColTotalKey][i] = new this.aggregators[AggregationType.RECALCULATE]({
-                                                key: toComputeIndicatorKeys[i],
-                                                dimension: toComputeIndicatorKeys[i],
-                                                isRecord: true,
-                                                formatFun: this.indicators?.find((indicator) => {
+                                else {
+                                    if (!this.tree[flatRowKey][flatColTotalKey][i]) {
+                                        const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
+                                        this.tree[flatRowKey][flatColTotalKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
+                                            key: toComputeIndicatorKeys[i],
+                                            dimension: aggRule?.field ?? toComputeIndicatorKeys[i],
+                                            formatFun: aggRule?.formatFun ??
+                                                this.indicators?.find((indicator) => {
                                                     if (typeof indicator !== 'string') {
                                                         return indicator.indicatorKey === toComputeIndicatorKeys[i];
                                                     }
                                                     return false;
-                                                })?.format,
-                                                calculateFun: calculatedFieldRule?.calculateFun,
-                                                dependAggregators: this.tree[flatRowKey][flatColTotalKey],
-                                                dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
-                                            });
-                                        }
-                                        if (flatColTotalKey !== flatColKey) {
-                                            this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
-                                        }
+                                                })?.format
+                                        });
                                     }
-                                    else {
-                                        if (!this.tree[flatRowKey][flatColTotalKey][i]) {
-                                            const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
-                                            this.tree[flatRowKey][flatColTotalKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
-                                                key: toComputeIndicatorKeys[i],
-                                                dimension: aggRule?.field ?? toComputeIndicatorKeys[i],
-                                                formatFun: aggRule?.formatFun ??
-                                                    this.indicators?.find((indicator) => {
-                                                        if (typeof indicator !== 'string') {
-                                                            return indicator.indicatorKey === toComputeIndicatorKeys[i];
-                                                        }
-                                                        return false;
-                                                    })?.format
-                                            });
-                                        }
-                                        if (flatColTotalKey !== flatColKey) {
-                                            this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
-                                        }
+                                    if (flatColTotalKey !== flatColKey) {
+                                        this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
                                     }
                                 }
                             }
                         }
                     }
-                    if (that.totals?.column?.showGrandTotals || this.rows.length === 0) {
-                        const flatColTotalKey = that.colGrandTotalLabel;
-                        if (this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey]) {
-                            this.tree[flatRowKey][flatColTotalKey] = this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey];
-                            return;
-                        }
-                        if (!this.tree[flatRowKey][flatColTotalKey]) {
-                            this.tree[flatRowKey][flatColTotalKey] = [];
+                }
+                if (that.totals?.column?.showGrandTotals || this.rows.length === 0) {
+                    const flatColTotalKey = that.colGrandTotalLabel;
+                    if (this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey]) {
+                        this.tree[flatRowKey][flatColTotalKey] = this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey];
+                        return;
+                    }
+                    if (!this.tree[flatRowKey][flatColTotalKey]) {
+                        this.tree[flatRowKey][flatColTotalKey] = [];
+                    }
+                    const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
+                    for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
+                        if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
+                            const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
+                            if (!this.tree[flatRowKey]?.[flatColTotalKey]?.[i]) {
+                                this.tree[flatRowKey][flatColTotalKey][i] = new this.aggregators[AggregationType.RECALCULATE]({
+                                    key: toComputeIndicatorKeys[i],
+                                    dimension: toComputeIndicatorKeys[i],
+                                    isRecord: true,
+                                    formatFun: this.indicators?.find((indicator) => {
+                                        if (typeof indicator !== 'string') {
+                                            return indicator.indicatorKey === toComputeIndicatorKeys[i];
+                                        }
+                                        return false;
+                                    })?.format,
+                                    calculateFun: calculatedFieldRule?.calculateFun,
+                                    dependAggregators: this.tree[flatRowKey][flatColTotalKey],
+                                    dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
+                                });
+                            }
+                            if (flatColTotalKey !== flatColKey) {
+                                this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
+                            }
                         }
-                        const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
-                        for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
-                            if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
-                                const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
-                                if (!this.tree[flatRowKey]?.[flatColTotalKey]?.[i]) {
-                                    this.tree[flatRowKey][flatColTotalKey][i] = new this.aggregators[AggregationType.RECALCULATE]({
-                                        key: toComputeIndicatorKeys[i],
-                                        dimension: toComputeIndicatorKeys[i],
-                                        isRecord: true,
-                                        formatFun: this.indicators?.find((indicator) => {
+                        else {
+                            if (!this.tree[flatRowKey][flatColTotalKey][i]) {
+                                const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
+                                this.tree[flatRowKey][flatColTotalKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
+                                    key: toComputeIndicatorKeys[i],
+                                    dimension: aggRule?.field ?? toComputeIndicatorKeys[i],
+                                    formatFun: aggRule?.formatFun ??
+                                        this.indicators?.find((indicator) => {
                                             if (typeof indicator !== 'string') {
                                                 return indicator.indicatorKey === toComputeIndicatorKeys[i];
                                             }
                                             return false;
-                                        })?.format,
-                                        calculateFun: calculatedFieldRule?.calculateFun,
-                                        dependAggregators: this.tree[flatRowKey][flatColTotalKey],
-                                        dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
-                                    });
-                                }
-                                if (flatColTotalKey !== flatColKey) {
-                                    this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
-                                }
+                                        })?.format
+                                });
                             }
-                            else {
-                                if (!this.tree[flatRowKey][flatColTotalKey][i]) {
-                                    const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
-                                    this.tree[flatRowKey][flatColTotalKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
-                                        key: toComputeIndicatorKeys[i],
-                                        dimension: aggRule?.field ?? toComputeIndicatorKeys[i],
-                                        formatFun: aggRule?.formatFun ??
-                                            this.indicators?.find((indicator) => {
-                                                if (typeof indicator !== 'string') {
-                                                    return indicator.indicatorKey === toComputeIndicatorKeys[i];
-                                                }
-                                                return false;
-                                            })?.format
-                                    });
-                                }
-                                if (flatColTotalKey !== flatColKey) {
-                                    this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
-                                }
+                            if (flatColTotalKey !== flatColKey) {
+                                this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
                             }
                         }
                     }
-                };
+                }
+            };
+            if ((that?.totals?.column?.subTotalsDimensions && that?.totals?.column?.subTotalsDimensions?.length >= 1) ||
+                (that?.totals?.row?.subTotalsDimensions && that?.totals?.row?.subTotalsDimensions?.length >= 1) ||
+                that?.totals?.column?.showGrandTotals ||
+                that?.totals?.row?.showGrandTotals) {
+                const rowTotalKeys = [];
                 Object.keys(that.tree).forEach(flatRowKey => {
                     const rowKey = flatRowKey.split(this.stringJoinChar);
                     Object.keys(that.tree[flatRowKey]).forEach(flatColKey => {
@@ -70214,6 +70920,11 @@
                     });
                 });
             }
+            for (const flatRowKey in that.totalRecordsTree) {
+                for (const flatColKey in that.totalRecordsTree[flatRowKey]) {
+                    colCompute(flatRowKey, flatColKey);
+                }
+            }
         }
         ArrToTree1(arr, rows, indicators, isGrandTotal, grandTotalLabel) {
             const result = [];
@@ -70370,20 +71081,6 @@
             }
             return result;
         }
-        TreeToArr(tree) {
-            const result = [];
-            function getPath(node, arr) {
-                arr.push(node.id);
-                if (node.children.length > 0) {
-                    node.children?.forEach((childItem) => getPath(childItem, [...arr]));
-                }
-                else {
-                    result.push(arr);
-                }
-            }
-            tree.forEach((treeNode) => getPath(treeNode, []));
-            return result;
-        }
         cacheDeminsionCollectedValues() {
             for (const key in this.collectValuesBy) {
                 if (this.collectValuesBy[key].type === 'xField' || this.collectValuesBy[key].type === 'yField') {
@@ -70461,6 +71158,11 @@
                 this.processRecords();
             }
         }
+        _rowTreeHasChanged() {
+            if (!this.hasExtensionRowTree) {
+                this.customRowTreeDimensionPaths = this.customTreeToDimensionPathArr(this.customRowTree, 'row');
+            }
+        }
         changeDataConfig(dataConfig) {
             this.rows = dataConfig.rows;
             this.columns = dataConfig.columns;
@@ -70474,6 +71176,91 @@
                 this.records.push(records);
             }
         }
+        customTreeToDimensionPathArr(tree, type) {
+            const result = [];
+            const that = this;
+            function getPath(node, arr) {
+                if (!node.virtual) {
+                    if (arr[arr.length - 1]?.childKeys &&
+                        node.dimensionKey &&
+                        arr[arr.length - 1].childKeys.indexOf(node.dimensionKey) === -1 &&
+                        node.dimensionKey !== arr[arr.length - 1].dimensionKey) {
+                        arr[arr.length - 1].childKeys.push(node.dimensionKey);
+                    }
+                    arr.push({
+                        dimensionKey: isValid$1(node.indicatorKey) ? undefined : node.dimensionKey,
+                        value: node.value,
+                        indicatorKey: node.indicatorKey,
+                        virtual: node.virtual
+                    });
+                }
+                if (node.children?.length > 0) {
+                    if (that.rowHierarchyType === 'tree' && type === 'row') {
+                        arr[arr.length - 1].childKeys = [];
+                        result.push([...arr]);
+                    }
+                    node.children?.forEach((childItem) => getPath(childItem, [...arr]));
+                }
+                else {
+                    result.push(arr);
+                }
+            }
+            tree?.forEach((treeNode) => getPath(treeNode, []));
+            return result;
+        }
+        getFieldMatchColDimensionPaths(record) {
+            const fieldMatchDimensionPaths = [];
+            for (let i = 0; i < this.customColTreeDimensionPaths?.length ?? 0; i++) {
+                const dimensionPath = this.customColTreeDimensionPaths[i];
+                let isMatch = true;
+                for (let j = 0; j < dimensionPath.length; j++) {
+                    const dimension = dimensionPath[j];
+                    if ((dimension.dimensionKey && record[dimension.dimensionKey] !== dimension.value) ||
+                        (dimension.indicatorKey && record[dimension.indicatorKey] === undefined)) {
+                        isMatch = false;
+                        break;
+                    }
+                }
+                if (isMatch) {
+                    fieldMatchDimensionPaths.push(dimensionPath);
+                }
+            }
+            return fieldMatchDimensionPaths;
+        }
+        getFieldMatchRowDimensionPaths(record) {
+            const fieldMatchDimensionPaths = [];
+            for (let i = 0; i < this.customRowTreeDimensionPaths?.length ?? 0; i++) {
+                const dimensionPath = this.customRowTreeDimensionPaths[i];
+                let isMatch = true;
+                for (let j = 0; j < dimensionPath.length; j++) {
+                    const dimension = dimensionPath[j];
+                    if ((dimension.dimensionKey && record[dimension.dimensionKey] !== dimension.value) ||
+                        (dimension.indicatorKey && record[dimension.indicatorKey] === undefined)) {
+                        isMatch = false;
+                        break;
+                    }
+                    if (dimension.childKeys && j === dimensionPath.length - 1) {
+                        if (dimension.childKeys.length > 0 && dimension.childKeys.find(key => isValid$1(record[key]))) {
+                            isMatch = false;
+                            break;
+                        }
+                    }
+                }
+                if (isMatch) {
+                    if (!this.indicatorsAsCol && this.rowHierarchyType === 'tree') {
+                        if (!dimensionPath.find(path => {
+                            return path.indicatorKey;
+                        })) {
+                            isMatch = false;
+                        }
+                    }
+                }
+                if (isMatch) {
+                    fieldMatchDimensionPaths.push(dimensionPath);
+                }
+            }
+            return fieldMatchDimensionPaths;
+        }
     }
     function arraySortByAnotherArray(array, sortArray) {
         return array.sort((a, b) => {
@@ -70553,7 +71340,7 @@
                     const keysResults = parseColKeyRowKeyForPivotTable(this, options);
                     const { rowKeys, columnKeys, indicatorKeys } = keysResults;
                     let { columnDimensionTree, rowDimensionTree } = keysResults;
-                    this.dataset = new Dataset(this.internalProps.dataConfig, rowKeys, columnKeys, indicatorKeys, this.internalProps.indicators, options.indicatorsAsCol ?? true, options.records, options.rowHierarchyType, this.internalProps.columnTree, this.internalProps.rowTree);
+                    this.dataset = new Dataset(this.internalProps.dataConfig, rowKeys, columnKeys, indicatorKeys, this.internalProps.indicators, options.indicatorsAsCol ?? true, options.records, options.rowHierarchyType, this.internalProps.columnTree, this.internalProps.rowTree, false, !!options.extensionRows, !!options.parseCustomTreeToMatchRecords);
                     if (!options.columnTree) {
                         if (options.indicatorsAsCol !== false) {
                             this.dataset.colHeaderTree = supplementIndicatorNodesForCustomTree(this.dataset.colHeaderTree, options.indicators);
@@ -70694,7 +71481,7 @@
                 const keysResults = parseColKeyRowKeyForPivotTable(this, options);
                 const { rowKeys, columnKeys, indicatorKeys } = keysResults;
                 let { columnDimensionTree, rowDimensionTree } = keysResults;
-                this.dataset = new Dataset(internalProps.dataConfig, rowKeys, columnKeys, indicatorKeys, this.internalProps.indicators, options.indicatorsAsCol ?? true, records, options.rowHierarchyType, this.internalProps.columnTree, this.internalProps.rowTree);
+                this.dataset = new Dataset(internalProps.dataConfig, rowKeys, columnKeys, indicatorKeys, this.internalProps.indicators, options.indicatorsAsCol ?? true, records, options.rowHierarchyType, this.internalProps.columnTree, this.internalProps.rowTree, false, !!options.extensionRows, !!options.parseCustomTreeToMatchRecords);
                 if (!options.columnTree) {
                     if (options.indicatorsAsCol !== false) {
                         this.dataset.colHeaderTree = supplementIndicatorNodesForCustomTree(this.dataset.colHeaderTree, options.indicators);
@@ -71900,6 +72687,7 @@
                 const headerTreeNode = this.internalProps.layoutMap.getHeadNode(col, row);
                 headerTreeNode.children = children;
                 this._refreshHierarchyState(col, row, () => {
+                    this.dataset._rowTreeHasChanged();
                     this.dataset.changeDataConfig({
                         rows: this.internalProps.layoutMap.fullRowDimensionKeys,
                         columns: this.internalProps.layoutMap.colDimensionKeys
@@ -73566,7 +74354,7 @@
     }
 
     registerForVrender();
-    const version = "1.7.8-alpha.4";
+    const version = "1.7.8";
     function getIcons() {
         return get$2();
     }