@visactor/vtable 1.3.3-alpha.3 → 1.3.3

package/dist/vtable.js

@@ -21976,7 +21976,6 @@
         AggregationType["AVG"] = "AVG";
         AggregationType["COUNT"] = "COUNT";
         AggregationType["CUSTOM"] = "CUSTOM";
-        AggregationType["RECALCULATE"] = "RECALCULATE";
     })(AggregationType || (AggregationType = {}));
     var SortType;
     (function (SortType) {
@@ -32872,15 +32871,13 @@
         isRecord = true;
         records = [];
         type;
-        key;
         field;
         formatFun;
         _formatedValue;
-        constructor(config) {
-            this.key = config.key;
-            this.field = config.dimension;
-            this.formatFun = config.formatFun;
-            this.isRecord = config.isRecord ?? this.isRecord;
+        constructor(dimension, formatFun, isRecord) {
+            this.field = dimension;
+            this.formatFun = formatFun;
+            this.isRecord = isRecord ?? this.isRecord;
         }
         clearCacheValue() {
             this._formatedValue = undefined;
@@ -32904,7 +32901,7 @@
         type = AggregationType.RECORD;
         isRecord = true;
         push(record) {
-            if (record && this.isRecord && this.records) {
+            if (this.isRecord && this.records) {
                 if (record.className === 'Aggregator') {
                     this.records.push(...record.records);
                 }
@@ -32927,13 +32924,11 @@
         isRecord = true;
         fieldValue;
         push(record) {
-            if (record) {
-                if (this.isRecord) {
-                    this.records = [record];
-                }
-                if (this.field) {
-                    this.fieldValue = record[this.field];
-                }
+            if (this.isRecord) {
+                this.records = [record];
+            }
+            if (this.field) {
+                this.fieldValue = record[this.field];
             }
         }
         value() {
@@ -32952,53 +32947,12 @@
         aggregationFun;
         values = [];
         fieldValue;
-        constructor(config) {
-            super(config);
-            this.aggregationFun = config.aggregationFun;
-        }
-        push(record) {
-            if (record) {
-                if (this.isRecord && this.records) {
-                    if (record.className === 'Aggregator') {
-                        this.records.push(...record.records);
-                    }
-                    else {
-                        this.records.push(record);
-                    }
-                }
-                if (this.field) {
-                    this.values.push(record[this.field]);
-                }
-            }
-        }
-        value() {
-            if (!this.fieldValue) {
-                this.fieldValue = this.aggregationFun?.(this.values, this.records, this.field);
-            }
-            return this.fieldValue;
-        }
-        reset() {
-            this.records = [];
-            this.fieldValue = undefined;
-        }
-        recalculate() {
-        }
-    }
-    class RecalculateAggregator extends Aggregator {
-        type = AggregationType.RECALCULATE;
-        isRecord = true;
-        calculateFun;
-        fieldValue;
-        dependAggregators;
-        dependIndicatorKeys;
-        constructor(config) {
-            super(config);
-            this.calculateFun = config.calculateFun;
-            this.dependAggregators = config.dependAggregators;
-            this.dependIndicatorKeys = config.dependIndicatorKeys;
+        constructor(dimension, formatFun, isRecord, aggregationFun) {
+            super(dimension, formatFun, isRecord);
+            this.aggregationFun = aggregationFun;
         }
         push(record) {
-            if (record && this.isRecord && this.records) {
+            if (this.isRecord && this.records) {
                 if (record.className === 'Aggregator') {
                     this.records.push(...record.records);
                 }
@@ -33006,11 +32960,13 @@
                     this.records.push(record);
                 }
             }
+            if (this.field) {
+                this.values.push(record[this.field]);
+            }
         }
         value() {
             if (!this.fieldValue) {
-                const aggregatorValue = _getDependAggregatorValues(this.dependAggregators, this.dependIndicatorKeys);
-                this.fieldValue = this.calculateFun?.(aggregatorValue, this.records, this.field);
+                this.fieldValue = this.aggregationFun?.(this.values, this.records, this.field);
             }
             return this.fieldValue;
         }
@@ -33027,42 +32983,40 @@
         positiveSum = 0;
         nagetiveSum = 0;
         needSplitPositiveAndNegativeForSum = false;
-        constructor(config) {
-            super(config);
-            this.needSplitPositiveAndNegativeForSum = config.needSplitPositiveAndNegative ?? false;
+        constructor(dimension, formatFun, isRecord, needSplitPositiveAndNegative) {
+            super(dimension, formatFun, isRecord);
+            this.needSplitPositiveAndNegativeForSum = needSplitPositiveAndNegative ?? false;
         }
         push(record) {
-            if (record) {
-                if (this.isRecord && this.records) {
-                    if (record.className === 'Aggregator') {
-                        this.records.push(...record.records);
+            if (this.isRecord && this.records) {
+                if (record.className === 'Aggregator') {
+                    this.records.push(...record.records);
+                }
+                else {
+                    this.records.push(record);
+                }
+            }
+            if (record.className === 'Aggregator') {
+                const value = record.value();
+                this.sum += value;
+                if (this.needSplitPositiveAndNegativeForSum) {
+                    if (value > 0) {
+                        this.positiveSum += value;
                     }
-                    else {
-                        this.records.push(record);
+                    else if (value < 0) {
+                        this.nagetiveSum += value;
                     }
                 }
-                if (record.className === 'Aggregator') {
-                    const value = record.value();
-                    this.sum += value;
-                    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 (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;
-                        }
+                    else if (value < 0) {
+                        this.nagetiveSum += value;
                     }
                 }
             }
@@ -33118,22 +33072,20 @@
         type = AggregationType.COUNT;
         count = 0;
         push(record) {
-            if (record) {
-                if (this.isRecord && this.records) {
-                    if (record.className === 'Aggregator') {
-                        this.records.push(...record.records);
-                    }
-                    else {
-                        this.records.push(record);
-                    }
-                }
+            if (this.isRecord && this.records) {
                 if (record.className === 'Aggregator') {
-                    this.count += record.value();
+                    this.records.push(...record.records);
                 }
                 else {
-                    this.count++;
+                    this.records.push(record);
                 }
             }
+            if (record.className === 'Aggregator') {
+                this.count += record.value();
+            }
+            else {
+                this.count++;
+            }
         }
         value() {
             return this.count;
@@ -33163,24 +33115,22 @@
         sum = 0;
         count = 0;
         push(record) {
-            if (record) {
-                if (this.isRecord && this.records) {
-                    if (record.className === 'Aggregator') {
-                        this.records.push(...record.records);
-                    }
-                    else {
-                        this.records.push(record);
-                    }
-                }
-                if (record.className === 'Aggregator' && record.type === AggregationType.AVG) {
-                    this.sum += record.sum;
-                    this.count += record.count;
+            if (this.isRecord && this.records) {
+                if (record.className === 'Aggregator') {
+                    this.records.push(...record.records);
                 }
-                else if (this.field && !isNaN(parseFloat(record[this.field]))) {
-                    this.sum += parseFloat(record[this.field]);
-                    this.count++;
+                else {
+                    this.records.push(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++;
+            }
         }
         value() {
             return this.sum / this.count;
@@ -33213,28 +33163,26 @@
         type = AggregationType.MAX;
         max = Number.MIN_SAFE_INTEGER;
         push(record) {
-            if (record) {
-                if (this.isRecord && this.records) {
-                    if (record.className === 'Aggregator') {
-                        this.records.push(...record.records);
-                    }
-                    else {
-                        this.records.push(record);
-                    }
-                }
+            if (this.isRecord && this.records) {
                 if (record.className === 'Aggregator') {
-                    this.max = record.max > this.max ? record.max : this.max;
-                }
-                else if (typeof record === 'number') {
-                    this.max = record > this.max ? record : this.max;
-                }
-                else if (this.field && typeof record[this.field] === 'number') {
-                    this.max = record[this.field] > this.max ? record[this.field] : this.max;
+                    this.records.push(...record.records);
                 }
-                else if (this.field && !isNaN(record[this.field])) {
-                    this.max = parseFloat(record[this.field]) > this.max ? parseFloat(record[this.field]) : this.max;
+                else {
+                    this.records.push(record);
                 }
             }
+            if (record.className === 'Aggregator') {
+                this.max = record.max > this.max ? record.max : this.max;
+            }
+            else if (typeof record === 'number') {
+                this.max = record > this.max ? record : this.max;
+            }
+            else if (this.field && typeof record[this.field] === 'number') {
+                this.max = record[this.field] > this.max ? record[this.field] : this.max;
+            }
+            else if (this.field && !isNaN(record[this.field])) {
+                this.max = parseFloat(record[this.field]) > this.max ? parseFloat(record[this.field]) : this.max;
+            }
         }
         value() {
             return this.max;
@@ -33269,25 +33217,23 @@
         type = AggregationType.MIN;
         min = Number.MAX_SAFE_INTEGER;
         push(record) {
-            if (record) {
-                if (this.isRecord && this.records) {
-                    if (record.className === 'Aggregator') {
-                        this.records.push(...record.records);
-                    }
-                    else {
-                        this.records.push(record);
-                    }
-                }
+            if (this.isRecord && this.records) {
                 if (record.className === 'Aggregator') {
-                    this.min = record.min < this.min ? record.min : this.min;
-                }
-                else if (typeof record === 'number') {
-                    this.min = record < this.min ? record : this.min;
+                    this.records.push(...record.records);
                 }
-                else if (this.field && typeof record[this.field] === 'number') {
-                    this.min = record[this.field] < this.min ? record[this.field] : this.min;
+                else {
+                    this.records.push(record);
                 }
             }
+            if (record.className === 'Aggregator') {
+                this.min = record.min < this.min ? record.min : this.min;
+            }
+            else if (typeof record === 'number') {
+                this.min = record < this.min ? record : this.min;
+            }
+            else if (this.field && typeof record[this.field] === 'number') {
+                this.min = record[this.field] < this.min ? record[this.field] : this.min;
+            }
         }
         value() {
             return this.min;
@@ -33433,16 +33379,6 @@
             return naturalSort(a, b);
         };
     }
-    function _getDependAggregatorValues(aggregators, dependIndicatorKeys) {
-        const dependAggregatorValues = {};
-        for (let m = 0; m < dependIndicatorKeys?.length; m++) {
-            const aggrator = aggregators.find(aggrator => aggrator.key === dependIndicatorKeys[m]);
-            if (aggrator) {
-                dependAggregatorValues[aggrator.key] = aggrator?.value();
-            }
-        }
-        return dependAggregatorValues;
-    }
 
     function isFieldAssessor(field) {
         if (obj.isObject(field)) {
@@ -33608,12 +33544,7 @@
                 if (Array.isArray(aggragation)) {
                     for (let j = 0; j < aggragation.length; j++) {
                         const item = aggragation[j];
-                        const aggregator = new this.registedAggregators[item.aggregationType]({
-                            dimension: field,
-                            formatFun: item.formatFun,
-                            isRecord: true,
-                            aggregationFun: item.aggregationFun
-                        });
+                        const aggregator = new this.registedAggregators[item.aggregationType](field, item.formatFun, true, item.aggregationFun);
                         this.fieldAggregators.push(aggregator);
                         if (!columnObjs[i].aggregator) {
                             columnObjs[i].aggregator = [];
@@ -33622,12 +33553,7 @@
                     }
                 }
                 else {
-                    const aggregator = new this.registedAggregators[aggragation.aggregationType]({
-                        dimension: field,
-                        formatFun: aggragation.formatFun,
-                        isRecord: true,
-                        aggregationFun: aggragation.aggregationFun
-                    });
+                    const aggregator = new this.registedAggregators[aggragation.aggregationType](field, aggragation.formatFun, true, aggragation.aggregationFun);
                     this.fieldAggregators.push(aggregator);
                     columnObjs[i].aggregator = aggregator;
                 }
@@ -45555,14 +45481,12 @@
         }
     }
 
-    async function dynamicSetX(x, isEnd, proxy) {
-        const screenLeft = proxy.table.getTargetColAt(x + proxy.table.scenegraph.rowHeaderGroup.attribute.width);
+    async function dynamicSetX(x, screenLeft, isEnd, proxy) {
         if (!screenLeft) {
             return;
         }
         const screenLeftCol = screenLeft.col;
         const screenLeftX = screenLeft.left;
-        proxy.screenLeftCol = screenLeftCol;
         let deltaCol;
         if (isEnd) {
             deltaCol = proxy.bodyRightCol - proxy.colEnd;
@@ -45770,7 +45694,7 @@
             for (let col = colStart; col <= colEnd; col++) {
                 for (let row = rowStart; row <= rowEnd; row++) {
                     const cellGroup = table.scenegraph.highPerformanceGetCell(col, row, true);
-                    if (!cellGroup.row) {
+                    if (cellGroup.role !== 'cell' || !cellGroup.row) {
                         continue;
                     }
                     let y;
@@ -45781,7 +45705,7 @@
                         const baseCellGroup = table.scenegraph.highPerformanceGetCell(col, rowEnd + 1, true);
                         y = baseCellGroup.attribute.y;
                         if (isValid$1(y)) {
-                            for (let r = rowStart; r <= rowEnd; r++) {
+                            for (let r = row; r <= rowEnd; r++) {
                                 y -= table.getRowHeight(r);
                             }
                         }
@@ -45799,7 +45723,7 @@
             for (let col = colStart; col <= colEnd; col++) {
                 for (let row = rowEnd; row >= rowStart; row--) {
                     const cellGroup = table.scenegraph.highPerformanceGetCell(col, row, true);
-                    if (!cellGroup.row) {
+                    if (cellGroup.role !== 'cell' || !cellGroup.row) {
                         continue;
                     }
                     let y;
@@ -45809,14 +45733,17 @@
                     else if (part) {
                         const baseCellGroup = table.scenegraph.highPerformanceGetCell(col, rowStart - 1, true);
                         y = baseCellGroup.attribute.y;
-                        for (let r = rowStart - 1; r < rowEnd; r++) {
-                            y += table.getRowHeight(r);
+                        for (let r = rowStart - 1; r < row; r++) {
+                            const height = table.getRowHeight(r);
+                            y += height;
                         }
                     }
                     else {
                         y = table.getRowsHeight(table.columnHeaderLevelCount, cellGroup.row - 1);
                     }
-                    cellGroup.setAttribute('y', y);
+                    if (isValid$1(y)) {
+                        cellGroup.setAttribute('y', y);
+                    }
                 }
             }
         }
@@ -45827,14 +45754,12 @@
         table.scenegraph.proxy.yLimitBottom = totalHeight - totalBodyHeight / 2;
     }
 
-    async function dynamicSetY(y, isEnd, proxy) {
-        const screenTop = proxy.table.getTargetRowAt(y + proxy.table.scenegraph.colHeaderGroup.attribute.height);
+    async function dynamicSetY(y, screenTop, isEnd, proxy) {
         if (!screenTop) {
             return;
         }
         const screenTopRow = screenTop.row;
         const screenTopY = screenTop.top;
-        proxy.screenTopRow = screenTopRow;
         let deltaRow;
         if (isEnd) {
             deltaRow = proxy.bodyBottomRow - proxy.rowEnd;
@@ -45906,7 +45831,7 @@
             updatePartRowPosition(startRow, endRow, direction, proxy);
             proxy.rowStart = direction === 'up' ? proxy.rowStart + count : proxy.rowStart - count;
             proxy.rowEnd = direction === 'up' ? proxy.rowEnd + count : proxy.rowEnd - count;
-            updateRowContent(syncTopRow, syncBottomRow, proxy, true);
+            const sync = updateRowContent(syncTopRow, syncBottomRow, proxy, true);
             if (proxy.table.heightMode === 'autoHeight') {
                 updateAutoRow(proxy.bodyLeftCol, proxy.bodyRightCol, syncTopRow, syncBottomRow, proxy.table, distEndRow > proxy.bodyBottomRow - (proxy.rowEnd - proxy.rowStart + 1) ? 'down' : 'up', true);
                 updateAutoRow(0, proxy.table.frozenColCount - 1, syncTopRow, syncBottomRow, proxy.table, distEndRow > proxy.bodyBottomRow - (proxy.rowEnd - proxy.rowStart + 1) ? 'down' : 'up', true);
@@ -45915,7 +45840,7 @@
             proxy.currentRow = direction === 'up' ? proxy.currentRow + count : proxy.currentRow - count;
             proxy.totalRow = Math.max(0, Math.min(proxy.bodyBottomRow, direction === 'up' ? proxy.totalRow + count : proxy.totalRow - count));
             proxy.referenceRow = proxy.rowStart + Math.floor((proxy.rowEnd - proxy.rowStart) / 2);
-            if (proxy.table.heightMode === 'autoHeight') {
+            if (proxy.table.heightMode === 'autoHeight' && sync) {
                 proxy.rowUpdatePos = Math.min(proxy.rowUpdatePos, proxy.rowEnd + 1);
             }
             else {
@@ -45923,9 +45848,7 @@
             }
             proxy.rowUpdateDirection = direction;
             proxy.table.scenegraph.updateNextFrame();
-            if (proxy.table.heightMode !== 'autoHeight') {
-                await proxy.progress();
-            }
+            await proxy.progress();
         }
         else {
             const distStartRow = direction === 'up' ? proxy.rowStart + count : proxy.rowStart - count;
@@ -45945,7 +45868,7 @@
             updateAllRowPosition(distStartRowY, count, direction, proxy);
             proxy.rowStart = distStartRow;
             proxy.rowEnd = distEndRow;
-            updateRowContent(syncTopRow, syncBottomRow, proxy, true);
+            const sync = updateRowContent(syncTopRow, syncBottomRow, proxy, true);
             if (proxy.table.heightMode === 'autoHeight') {
                 updateAutoRow(proxy.bodyLeftCol, proxy.bodyRightCol, syncTopRow, syncBottomRow, proxy.table, distEndRow > proxy.bodyBottomRow - (proxy.rowEnd - proxy.rowStart + 1) ? 'down' : 'up');
                 updateAutoRow(0, proxy.table.frozenColCount - 1, syncTopRow, syncBottomRow, proxy.table, distEndRow > proxy.bodyBottomRow - (proxy.rowEnd - proxy.rowStart + 1) ? 'down' : 'up');
@@ -45954,7 +45877,7 @@
             proxy.currentRow = direction === 'up' ? proxy.currentRow + count : proxy.currentRow - count;
             proxy.totalRow = Math.max(0, Math.min(proxy.bodyBottomRow, direction === 'up' ? proxy.totalRow + count : proxy.totalRow - count));
             proxy.referenceRow = proxy.rowStart + Math.floor((proxy.rowEnd - proxy.rowStart) / 2);
-            if (proxy.table.heightMode === 'autoHeight') {
+            if (proxy.table.heightMode === 'autoHeight' && sync) {
                 proxy.rowUpdatePos = proxy.rowEnd + 1;
             }
             else {
@@ -45962,9 +45885,7 @@
             }
             proxy.rowUpdateDirection = distEndRow > proxy.bodyBottomRow - (proxy.rowEnd - proxy.rowStart + 1) ? 'down' : 'up';
             proxy.table.scenegraph.updateNextFrame();
-            if (proxy.table.heightMode !== 'autoHeight') {
-                await proxy.progress();
-            }
+            await proxy.progress();
         }
     }
     function updatePartRowPosition(startRow, endRow, direction, proxy) {
@@ -46050,10 +45971,14 @@
         }
         let leftCol = proxy.bodyLeftCol;
         let rightCol = proxy.bodyRightCol;
+        let sync = true;
         if (async) {
             const screenLeftCol = proxy.screenLeftCol;
             leftCol = Math.max(proxy.bodyLeftCol, screenLeftCol - proxy.screenColCount * 1);
             rightCol = Math.min(proxy.bodyRightCol, screenLeftCol + proxy.screenColCount * 2);
+            if (leftCol !== proxy.bodyLeftCol || rightCol !== proxy.bodyRightCol) {
+                sync = false;
+            }
         }
         for (let col = leftCol; col <= rightCol; col++) {
             for (let row = syncTopRow; row <= syncBottomRow; row++) {
@@ -46062,6 +45987,7 @@
             }
         }
         proxy.table.scenegraph.updateNextFrame();
+        return sync;
     }
 
     async function sortVertical(proxy) {
@@ -46682,6 +46608,10 @@
         async setY(y, isEnd = false) {
             const yLimitTop = this.table.getRowsHeight(this.bodyTopRow, this.bodyTopRow + (this.rowEnd - this.rowStart + 1)) / 2;
             const yLimitBottom = this.table.getAllRowsHeight() - yLimitTop;
+            const screenTop = this.table.getTargetRowAt(y + this.table.scenegraph.colHeaderGroup.attribute.height);
+            if (screenTop) {
+                this.screenTopRow = screenTop.row;
+            }
             if (y < yLimitTop && this.rowStart === this.bodyTopRow) {
                 this.updateDeltaY(y);
                 this.updateBody(y - this.deltaY);
@@ -46697,12 +46627,16 @@
                 this.updateBody(y - this.deltaY);
             }
             else {
-                this.dynamicSetY(y, isEnd);
+                this.dynamicSetY(y, screenTop, isEnd);
             }
         }
         async setX(x, isEnd = false) {
             const xLimitLeft = this.table.getColsWidth(this.bodyLeftCol, this.bodyLeftCol + (this.colEnd - this.colStart + 1)) / 2;
             const xLimitRight = this.table.getAllColsWidth() - xLimitLeft;
+            const screenLeft = this.table.getTargetColAt(x + this.table.scenegraph.rowHeaderGroup.attribute.width);
+            if (screenLeft) {
+                this.screenLeftCol = screenLeft.col;
+            }
             if (x < xLimitLeft && this.colStart === this.bodyLeftCol) {
                 this.updateDeltaX(x);
                 this.table.scenegraph.setBodyAndColHeaderX(-x + this.deltaX);
@@ -46717,14 +46651,14 @@
                 this.table.scenegraph.setBodyAndColHeaderX(-x + this.deltaX);
             }
             else {
-                this.dynamicSetX(x, isEnd);
+                this.dynamicSetX(x, screenLeft, isEnd);
             }
         }
-        async dynamicSetY(y, isEnd = false) {
-            dynamicSetY(y, isEnd, this);
+        async dynamicSetY(y, screenTop, isEnd = false) {
+            dynamicSetY(y, screenTop, isEnd, this);
         }
-        async dynamicSetX(x, isEnd = false) {
-            dynamicSetX(x, isEnd, this);
+        async dynamicSetX(x, screenLeft, isEnd = false) {
+            dynamicSetX(x, screenLeft, isEnd, this);
         }
         updateBody(y) {
             this.table.scenegraph.setBodyAndRowHeaderY(-y);
@@ -59340,7 +59274,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.3.3-alpha.3";
+        version = "1.3.3";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -68578,9 +68512,6 @@
         aggregationRules;
         derivedFieldRules;
         mappingRules;
-        calculatedFieldRules;
-        calculatedFiledKeys;
-        calculatedFieldDependIndicatorKeys;
         totals;
         indicatorStatistics = [];
         aggregators = {};
@@ -68600,7 +68531,6 @@
         columns;
         columnsHasValue;
         indicatorKeys;
-        indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
         customRowTree;
         customColTree;
         colHeaderTree;
@@ -68617,27 +68547,10 @@
             this.aggregationRules = this.dataConfig?.aggregationRules;
             this.derivedFieldRules = this.dataConfig?.derivedFieldRules;
             this.mappingRules = this.dataConfig?.mappingRules;
-            this.calculatedFieldRules = this.dataConfig?.calculatedFieldRules;
-            this.calculatedFiledKeys = this.calculatedFieldRules?.map(rule => rule.key) ?? [];
-            this.calculatedFieldDependIndicatorKeys =
-                this.calculatedFieldRules?.reduce((arr, rule) => {
-                    for (let i = 0; i < rule.dependIndicatorKeys.length; i++) {
-                        if (arr.indexOf(rule.dependIndicatorKeys[i]) === -1) {
-                            arr.push(rule.dependIndicatorKeys[i]);
-                        }
-                    }
-                    return arr;
-                }, []) ?? [];
             this.totals = this.dataConfig?.totals;
             this.rows = rows;
             this.columns = columns;
             this.indicatorKeys = indicatorKeys;
-            this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys = [...indicatorKeys];
-            for (let m = 0; m < this.calculatedFieldDependIndicatorKeys.length; m++) {
-                if (this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys.indexOf(this.calculatedFieldDependIndicatorKeys[m]) === -1) {
-                    this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys.push(this.calculatedFieldDependIndicatorKeys[m]);
-                }
-            }
             this.indicatorsAsCol = indicatorsAsCol;
             this.indicators = indicators;
             this.customColTree = customColTree;
@@ -68735,7 +68648,6 @@
             this.registerAggregator(AggregationType.MIN, MinAggregator);
             this.registerAggregator(AggregationType.AVG, AvgAggregator);
             this.registerAggregator(AggregationType.NONE, NoneAggregator);
-            this.registerAggregator(AggregationType.RECALCULATE, RecalculateAggregator);
         }
         processCollectedValuesWithSumBy() {
             for (const field in this.collectedValues) {
@@ -68887,12 +68799,7 @@
                             .sumBy.map(byField => record[byField])
                             .join(this.stringJoinChar);
                         if (!this.collectedValues[field][collectKeys][sumByKeys]) {
-                            this.collectedValues[field][collectKeys][sumByKeys] = new this.aggregators[AggregationType.SUM]({
-                                key: field,
-                                dimension: field,
-                                isRecord: undefined,
-                                needSplitPositiveAndNegative: this.needSplitPositiveAndNegative
-                            });
+                            this.collectedValues[field][collectKeys][sumByKeys] = new this.aggregators[AggregationType.SUM](field, undefined, undefined, this.needSplitPositiveAndNegative);
                         }
                         this.collectedValues[field][collectKeys][sumByKeys].push(record);
                     }
@@ -68975,45 +68882,18 @@
                 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
-                            });
-                        }
-                        toComputeIndicatorKeys[i] in record && this.totalRecordsTree[flatRowKey]?.[flatColKey]?.[i].push(record);
+                for (let i = 0; i < this.indicatorKeys.length; i++) {
+                    const aggRule = this.getAggregatorRule(this.indicatorKeys[i]);
+                    if (!this.totalRecordsTree[flatRowKey]?.[flatColKey]?.[i]) {
+                        this.totalRecordsTree[flatRowKey][flatColKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM](aggRule?.field ?? this.indicatorKeys[i], aggRule?.formatFun ??
+                            this.indicators?.find((indicator) => {
+                                if (typeof indicator !== 'string') {
+                                    return indicator.indicatorKey === this.indicatorKeys[i];
+                                }
+                                return false;
+                            })?.format);
                     }
+                    this.indicatorKeys[i] in record && this.totalRecordsTree[flatRowKey]?.[flatColKey]?.[i].push(record);
                 }
                 return;
             }
@@ -69029,39 +68909,18 @@
                     this.colFlatKeys[flatColKey] = 1;
                 }
             }
-            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];
-                                }
-                                return false;
-                            })?.format,
-                            calculateFun: calculatedFieldRule?.calculateFun,
-                            dependAggregators: this.tree[flatRowKey][flatColKey],
-                            dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
-                        });
-                    }
-                    this.tree[flatRowKey]?.[flatColKey]?.[i].push(record);
+            {
+                if (!this.tree[flatRowKey]) {
+                    this.tree[flatRowKey] = {};
                 }
-                else {
-                    const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
+                if (!this.tree[flatRowKey]?.[flatColKey]) {
+                    this.tree[flatRowKey][flatColKey] = [];
+                }
+                for (let i = 0; i < this.indicatorKeys.length; i++) {
+                    const aggRule = this.getAggregatorRule(this.indicatorKeys[i]);
                     let needAddToAggregator = false;
                     if (assignedIndicatorKey) {
-                        toComputeIndicatorKeys[i] === assignedIndicatorKey && (needAddToAggregator = true);
+                        this.indicatorKeys[i] === assignedIndicatorKey && (needAddToAggregator = true);
                     }
                     else if (aggRule?.field) {
                         if (typeof aggRule?.field === 'string') {
@@ -69075,20 +68934,16 @@
                         }
                     }
                     else {
-                        toComputeIndicatorKeys[i] in record && (needAddToAggregator = true);
+                        this.indicatorKeys[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
-                        });
+                        this.tree[flatRowKey][flatColKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM](aggRule?.field ?? this.indicatorKeys[i], aggRule?.formatFun ??
+                            this.indicators?.find((indicator) => {
+                                if (typeof indicator !== 'string') {
+                                    return indicator.indicatorKey === this.indicatorKeys[i];
+                                }
+                                return false;
+                            })?.format);
                     }
                     if (needAddToAggregator) {
                         this.tree[flatRowKey]?.[flatColKey]?.[i].push(record);
@@ -69100,25 +68955,15 @@
                     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
-                            })
+                            max: new this.aggregators[AggregationType.MAX](this.indicatorKeys[i]),
+                            min: new this.aggregators[AggregationType.MIN](this.indicatorKeys[i]),
+                            total: new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM](aggRule?.field ?? this.indicatorKeys[i], 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());
@@ -69398,9 +69243,7 @@
                         return;
                     }
                     const colKey = flatColKey.split(this.stringJoinChar);
-                    if (that.totals?.column?.subTotalsDimensions &&
-                        that.totals?.column?.subTotalsDimensions?.length > 0 &&
-                        that.totals.column.showSubTotals !== false) {
+                    if (that.totals?.column?.subTotalsDimensions) {
                         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);
@@ -69415,45 +69258,18 @@
                                 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
-                                            });
-                                        }
-                                        this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
-                                    }
-                                    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
-                                            });
-                                        }
-                                        this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
+                                for (let i = 0; i < this.indicatorKeys.length; i++) {
+                                    if (!this.tree[flatRowKey][flatColTotalKey][i]) {
+                                        const aggRule = this.getAggregatorRule(this.indicatorKeys[i]);
+                                        this.tree[flatRowKey][flatColTotalKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM](aggRule?.field ?? this.indicatorKeys[i], aggRule?.formatFun ??
+                                            this.indicators?.find((indicator) => {
+                                                if (typeof indicator !== 'string') {
+                                                    return indicator.indicatorKey === this.indicatorKeys[i];
+                                                }
+                                                return false;
+                                            })?.format);
                                     }
+                                    this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
                                 }
                             }
                         }
@@ -69467,54 +69283,25 @@
                         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
-                                    });
-                                }
-                                this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
-                            }
-                            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
-                                    });
-                                }
-                                this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
+                        for (let i = 0; i < this.indicatorKeys.length; i++) {
+                            if (!this.tree[flatRowKey][flatColTotalKey][i]) {
+                                const aggRule = this.getAggregatorRule(this.indicatorKeys[i]);
+                                this.tree[flatRowKey][flatColTotalKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM](aggRule?.field ?? this.indicatorKeys[i], aggRule?.formatFun ??
+                                    this.indicators?.find((indicator) => {
+                                        if (typeof indicator !== 'string') {
+                                            return indicator.indicatorKey === this.indicatorKeys[i];
+                                        }
+                                        return false;
+                                    })?.format);
                             }
+                            this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
                         }
                     }
                 };
                 Object.keys(that.tree).forEach(flatRowKey => {
                     const rowKey = flatRowKey.split(this.stringJoinChar);
                     Object.keys(that.tree[flatRowKey]).forEach(flatColKey => {
-                        if (that.totals?.row?.subTotalsDimensions &&
-                            that.totals?.row?.subTotalsDimensions?.length > 0 &&
-                            that.totals.row.showSubTotals !== false) {
+                        if (that.totals?.row?.subTotalsDimensions) {
                             for (let i = 0, len = that.totals?.row?.subTotalsDimensions?.length; i < len; i++) {
                                 const dimension = that.totals.row.subTotalsDimensions[i];
                                 const dimensionIndex = that.rows.indexOf(dimension);
@@ -69531,40 +69318,16 @@
                                     if (!this.tree[flatRowTotalKey][flatColKey]) {
                                         this.tree[flatRowTotalKey][flatColKey] = [];
                                     }
-                                    const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
-                                    for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
+                                    for (let i = 0; i < this.indicatorKeys.length; i++) {
                                         if (!this.tree[flatRowTotalKey][flatColKey][i]) {
-                                            if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
-                                                const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
-                                                this.tree[flatRowTotalKey][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.tree[flatRowTotalKey][flatColKey],
-                                                    dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
-                                                });
-                                            }
-                                            else {
-                                                const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
-                                                this.tree[flatRowTotalKey][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
-                                                });
-                                            }
+                                            const aggRule = this.getAggregatorRule(this.indicatorKeys[i]);
+                                            this.tree[flatRowTotalKey][flatColKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM](aggRule?.field ?? this.indicatorKeys[i], aggRule?.formatFun ??
+                                                this.indicators?.find((indicator) => {
+                                                    if (typeof indicator !== 'string') {
+                                                        return indicator.indicatorKey === this.indicatorKeys[i];
+                                                    }
+                                                    return false;
+                                                })?.format);
                                         }
                                         this.tree[flatRowTotalKey][flatColKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
                                     }
@@ -69580,40 +69343,16 @@
                             if (!this.tree[flatRowTotalKey][flatColKey]) {
                                 this.tree[flatRowTotalKey][flatColKey] = [];
                             }
-                            const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
-                            for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
+                            for (let i = 0; i < this.indicatorKeys.length; i++) {
                                 if (!this.tree[flatRowTotalKey][flatColKey][i]) {
-                                    if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
-                                        const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
-                                        this.tree[flatRowTotalKey][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.tree[flatRowTotalKey][flatColKey],
-                                            dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
-                                        });
-                                    }
-                                    else {
-                                        const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
-                                        this.tree[flatRowTotalKey][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
-                                        });
-                                    }
+                                    const aggRule = this.getAggregatorRule(this.indicatorKeys[i]);
+                                    this.tree[flatRowTotalKey][flatColKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM](aggRule?.field ?? this.indicatorKeys[i], aggRule?.formatFun ??
+                                        this.indicators?.find((indicator) => {
+                                            if (typeof indicator !== 'string') {
+                                                return indicator.indicatorKey === this.indicatorKeys[i];
+                                            }
+                                            return false;
+                                        })?.format);
                                 }
                                 this.tree[flatRowTotalKey][flatColKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
                             }
@@ -72823,7 +72562,7 @@
     }
 
     registerForVrender();
-    const version = "1.3.3-alpha.3";
+    const version = "1.3.3";
     function getIcons() {
         return get$2();
     }