@visactor/vtable 1.3.3-alpha.1 → 1.3.3-alpha.2

package/dist/vtable.js

@@ -7143,12 +7143,6 @@
       return Array.isArray(color) && isNumber$2(color[0]) ? alphaChannel ? `rgb(${Math.round(color[0])},${Math.round(color[1])},${Math.round(color[2])},${color[3].toFixed(2)})` : `rgb(${Math.round(color[0])},${Math.round(color[1])},${Math.round(color[2])})` : color;
     }
     function interpolateColor(from, to, ratio, alphaChannel, cb) {
-      if (Array.isArray(from) && !isNumber$2(from[0]) || Array.isArray(to) && !isNumber$2(to[0])) {
-        return new Array(4).fill(0).map((_, index) => _interpolateColor(isArray$1(from) ? from[index] : from, isArray$1(to) ? to[index] : to, ratio, alphaChannel));
-      }
-      return _interpolateColor(from, to, ratio, alphaChannel, cb);
-    }
-    function _interpolateColor(from, to, ratio, alphaChannel, cb) {
       if (!from || !to) return from && colorArrayToString(from) || to && colorArrayToString(to) || !1;
       let fromArray,
         toArray,
@@ -7659,7 +7653,7 @@
           animate.stateNames = stateNames, animate.to(animateAttrs, null !== (_b = null === (_a = this.stateAnimateConfig) || void 0 === _a ? void 0 : _a.duration) && void 0 !== _b ? _b : DefaultStateAnimateConfig.duration, null !== (_d = null === (_c = this.stateAnimateConfig) || void 0 === _c ? void 0 : _c.easing) && void 0 !== _d ? _d : DefaultStateAnimateConfig.easing), noAnimateAttrs && this.setAttributes(noAnimateAttrs, !1, {
             type: AttributeUpdateType.STATE
           });
-        } else this.stopStateAnimates(), this.setAttributes(attrs, !1, {
+        } else this.setAttributes(attrs, !1, {
           type: AttributeUpdateType.STATE
         });
       }
@@ -7689,7 +7683,7 @@
         }), value;
       }
       clearStates(hasAnimation) {
-        this.hasState() && this.normalAttrs ? (this.currentStates = [], this.applyStateAttrs(this.normalAttrs, this.currentStates, hasAnimation, !0)) : this.currentStates = [], this.normalAttrs = null;
+        this.stopStateAnimates(), this.hasState() && this.normalAttrs ? (this.currentStates = [], this.applyStateAttrs(this.normalAttrs, this.currentStates, hasAnimation, !0)) : this.currentStates = [], this.normalAttrs = null;
       }
       removeState(stateName, hasAnimation) {
         if ((this.currentStates ? this.currentStates.indexOf(stateName) : -1) >= 0) {
@@ -7715,6 +7709,7 @@
         var _a;
         if (!states.length) return void this.clearStates(hasAnimation);
         if (!((null === (_a = this.currentStates) || void 0 === _a ? void 0 : _a.length) !== states.length || states.some((stateName, index) => this.currentStates[index] !== stateName))) return;
+        this.stopStateAnimates();
         const stateAttrs = {};
         states.forEach(stateName => {
           var _a;
@@ -15285,8 +15280,7 @@
         if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
       };
     const DrawItemInterceptor = Symbol.for("DrawItemInterceptor");
-    const tempDirtyBounds = new AABBBounds(),
-      tempBackupDirtyBounds = new AABBBounds();
+    const tempDirtyBounds = new AABBBounds();
     class ShadowRootDrawItemInterceptorContribution {
       constructor() {
         this.order = 1;
@@ -15303,11 +15297,11 @@
           context: context
         } = drawContext;
         if (context.highPerformanceSave(), context.transformFromMatrix(graphic.transMatrix, !0), drawContribution.dirtyBounds && drawContribution.backupDirtyBounds) {
-          tempDirtyBounds.copy(drawContribution.dirtyBounds), tempBackupDirtyBounds.copy(drawContribution.backupDirtyBounds);
+          tempDirtyBounds.copy(drawContribution.dirtyBounds);
           const m = graphic.globalTransMatrix.getInverse();
-          drawContribution.dirtyBounds.copy(drawContribution.backupDirtyBounds).transformWithMatrix(m), drawContribution.backupDirtyBounds.copy(drawContribution.dirtyBounds);
+          drawContribution.dirtyBounds.copy(drawContribution.backupDirtyBounds).transformWithMatrix(m);
         }
-        return drawContribution.renderGroup(graphic.shadowRoot, drawContext, graphic.parent.globalTransMatrix), context.highPerformanceRestore(), drawContribution.dirtyBounds && drawContribution.backupDirtyBounds && (drawContribution.dirtyBounds.copy(tempDirtyBounds), drawContribution.backupDirtyBounds.copy(tempBackupDirtyBounds)), !0;
+        return drawContribution.renderGroup(graphic.shadowRoot, drawContext, graphic.parent.globalTransMatrix), context.highPerformanceRestore(), drawContribution.dirtyBounds && drawContribution.backupDirtyBounds && drawContribution.dirtyBounds.copy(tempDirtyBounds), !0;
       }
     }
     class DebugDrawItemInterceptorContribution {
@@ -21982,6 +21976,7 @@
         AggregationType["AVG"] = "AVG";
         AggregationType["COUNT"] = "COUNT";
         AggregationType["CUSTOM"] = "CUSTOM";
+        AggregationType["RECALCULATE"] = "RECALCULATE";
     })(AggregationType || (AggregationType = {}));
     var SortType;
     (function (SortType) {
@@ -32877,13 +32872,15 @@
         isRecord = true;
         records = [];
         type;
+        key;
         field;
         formatFun;
         _formatedValue;
-        constructor(dimension, formatFun, isRecord) {
-            this.field = dimension;
-            this.formatFun = formatFun;
-            this.isRecord = isRecord ?? this.isRecord;
+        constructor(config) {
+            this.key = config.key;
+            this.field = config.dimension;
+            this.formatFun = config.formatFun;
+            this.isRecord = config.isRecord ?? this.isRecord;
         }
         clearCacheValue() {
             this._formatedValue = undefined;
@@ -32907,7 +32904,7 @@
         type = AggregationType.RECORD;
         isRecord = true;
         push(record) {
-            if (this.isRecord && this.records) {
+            if (record && this.isRecord && this.records) {
                 if (record.className === 'Aggregator') {
                     this.records.push(...record.records);
                 }
@@ -32930,11 +32927,13 @@
         isRecord = true;
         fieldValue;
         push(record) {
-            if (this.isRecord) {
-                this.records = [record];
-            }
-            if (this.field) {
-                this.fieldValue = record[this.field];
+            if (record) {
+                if (this.isRecord) {
+                    this.records = [record];
+                }
+                if (this.field) {
+                    this.fieldValue = record[this.field];
+                }
             }
         }
         value() {
@@ -32953,12 +32952,53 @@
         aggregationFun;
         values = [];
         fieldValue;
-        constructor(dimension, formatFun, isRecord, aggregationFun) {
-            super(dimension, formatFun, isRecord);
-            this.aggregationFun = aggregationFun;
+        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;
         }
         push(record) {
-            if (this.isRecord && this.records) {
+            if (record && this.isRecord && this.records) {
                 if (record.className === 'Aggregator') {
                     this.records.push(...record.records);
                 }
@@ -32966,13 +33006,11 @@
                     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);
+                const aggregatorValue = _getDependAggregatorValues(this.dependAggregators, this.dependIndicatorKeys);
+                this.fieldValue = this.calculateFun?.(aggregatorValue, this.records, this.field);
             }
             return this.fieldValue;
         }
@@ -32989,40 +33027,42 @@
         positiveSum = 0;
         nagetiveSum = 0;
         needSplitPositiveAndNegativeForSum = false;
-        constructor(dimension, formatFun, isRecord, needSplitPositiveAndNegative) {
-            super(dimension, formatFun, isRecord);
-            this.needSplitPositiveAndNegativeForSum = needSplitPositiveAndNegative ?? false;
+        constructor(config) {
+            super(config);
+            this.needSplitPositiveAndNegativeForSum = config.needSplitPositiveAndNegative ?? false;
         }
         push(record) {
-            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;
+            if (record) {
+                if (this.isRecord && this.records) {
+                    if (record.className === 'Aggregator') {
+                        this.records.push(...record.records);
                     }
-                    else if (value < 0) {
-                        this.nagetiveSum += value;
+                    else {
+                        this.records.push(record);
                     }
                 }
-            }
-            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;
+                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 (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;
+                        }
                     }
                 }
             }
@@ -33078,20 +33118,22 @@
         type = AggregationType.COUNT;
         count = 0;
         push(record) {
-            if (this.isRecord && this.records) {
+            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') {
-                    this.records.push(...record.records);
+                    this.count += record.value();
                 }
                 else {
-                    this.records.push(record);
+                    this.count++;
                 }
             }
-            if (record.className === 'Aggregator') {
-                this.count += record.value();
-            }
-            else {
-                this.count++;
-            }
         }
         value() {
             return this.count;
@@ -33121,21 +33163,23 @@
         sum = 0;
         count = 0;
         push(record) {
-            if (this.isRecord && this.records) {
-                if (record.className === 'Aggregator') {
-                    this.records.push(...record.records);
+            if (record) {
+                if (this.isRecord && this.records) {
+                    if (record.className === 'Aggregator') {
+                        this.records.push(...record.records);
+                    }
+                    else {
+                        this.records.push(record);
+                    }
                 }
-                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++;
                 }
-            }
-            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() {
@@ -33169,25 +33213,27 @@
         type = AggregationType.MAX;
         max = Number.MIN_SAFE_INTEGER;
         push(record) {
-            if (this.isRecord && this.records) {
+            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') {
-                    this.records.push(...record.records);
+                    this.max = record.max > this.max ? record.max : this.max;
                 }
-                else {
-                    this.records.push(record);
+                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;
                 }
-            }
-            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() {
@@ -33223,22 +33269,24 @@
         type = AggregationType.MIN;
         min = Number.MAX_SAFE_INTEGER;
         push(record) {
-            if (this.isRecord && this.records) {
+            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') {
-                    this.records.push(...record.records);
+                    this.min = record.min < this.min ? record.min : this.min;
                 }
-                else {
-                    this.records.push(record);
+                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;
                 }
-            }
-            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() {
@@ -33385,6 +33433,16 @@
             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)) {
@@ -33550,7 +33608,12 @@
                 if (Array.isArray(aggragation)) {
                     for (let j = 0; j < aggragation.length; j++) {
                         const item = aggragation[j];
-                        const aggregator = new this.registedAggregators[item.aggregationType](field, item.formatFun, true, item.aggregationFun);
+                        const aggregator = new this.registedAggregators[item.aggregationType]({
+                            dimension: field,
+                            formatFun: item.formatFun,
+                            isRecord: true,
+                            aggregationFun: item.aggregationFun
+                        });
                         this.fieldAggregators.push(aggregator);
                         if (!columnObjs[i].aggregator) {
                             columnObjs[i].aggregator = [];
@@ -33559,7 +33622,12 @@
                     }
                 }
                 else {
-                    const aggregator = new this.registedAggregators[aggragation.aggregationType](field, aggragation.formatFun, true, aggragation.aggregationFun);
+                    const aggregator = new this.registedAggregators[aggragation.aggregationType]({
+                        dimension: field,
+                        formatFun: aggragation.formatFun,
+                        isRecord: true,
+                        aggregationFun: aggragation.aggregationFun
+                    });
                     this.fieldAggregators.push(aggregator);
                     columnObjs[i].aggregator = aggregator;
                 }
@@ -59272,7 +59340,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.3.3-alpha.1";
+        version = "1.3.3-alpha.2";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -68510,6 +68578,9 @@
         aggregationRules;
         derivedFieldRules;
         mappingRules;
+        calculatedFieldRules;
+        calculatedFiledKeys;
+        calculatedFieldDependIndicatorKeys;
         totals;
         indicatorStatistics = [];
         aggregators = {};
@@ -68529,6 +68600,7 @@
         columns;
         columnsHasValue;
         indicatorKeys;
+        indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
         customRowTree;
         customColTree;
         colHeaderTree;
@@ -68545,10 +68617,27 @@
             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;
@@ -68646,6 +68735,7 @@
             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) {
@@ -68797,7 +68887,12 @@
                             .sumBy.map(byField => record[byField])
                             .join(this.stringJoinChar);
                         if (!this.collectedValues[field][collectKeys][sumByKeys]) {
-                            this.collectedValues[field][collectKeys][sumByKeys] = new this.aggregators[AggregationType.SUM](field, undefined, undefined, this.needSplitPositiveAndNegative);
+                            this.collectedValues[field][collectKeys][sumByKeys] = new this.aggregators[AggregationType.SUM]({
+                                key: field,
+                                dimension: field,
+                                isRecord: undefined,
+                                needSplitPositiveAndNegative: this.needSplitPositiveAndNegative
+                            });
                         }
                         this.collectedValues[field][collectKeys][sumByKeys].push(record);
                     }
@@ -68883,13 +68978,17 @@
                 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.totalRecordsTree[flatRowKey][flatColKey][i] = 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.indicatorKeys[i] in record && this.totalRecordsTree[flatRowKey]?.[flatColKey]?.[i].push(record);
                 }
@@ -68907,18 +69006,39 @@
                     this.colFlatKeys[flatColKey] = 1;
                 }
             }
-            {
-                if (!this.tree[flatRowKey]) {
-                    this.tree[flatRowKey] = {};
-                }
-                if (!this.tree[flatRowKey]?.[flatColKey]) {
-                    this.tree[flatRowKey][flatColKey] = [];
+            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);
                 }
-                for (let i = 0; i < this.indicatorKeys.length; i++) {
-                    const aggRule = this.getAggregatorRule(this.indicatorKeys[i]);
+                else {
+                    const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
                     let needAddToAggregator = false;
                     if (assignedIndicatorKey) {
-                        this.indicatorKeys[i] === assignedIndicatorKey && (needAddToAggregator = true);
+                        toComputeIndicatorKeys[i] === assignedIndicatorKey && (needAddToAggregator = true);
                     }
                     else if (aggRule?.field) {
                         if (typeof aggRule?.field === 'string') {
@@ -68932,16 +69052,20 @@
                         }
                     }
                     else {
-                        this.indicatorKeys[i] in record && (needAddToAggregator = true);
+                        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](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][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);
@@ -68953,15 +69077,25 @@
                     if (!this.indicatorStatistics[i]) {
                         const aggRule = this.getAggregatorRule(this.indicatorKeys[i]);
                         this.indicatorStatistics[i] = {
-                            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)
+                            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());
@@ -69256,18 +69390,45 @@
                                 if (!this.tree[flatRowKey][flatColTotalKey]) {
                                     this.tree[flatRowKey][flatColTotalKey] = [];
                                 }
-                                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);
+                                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]);
                                     }
-                                    this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
                                 }
                             }
                         }
@@ -69281,18 +69442,45 @@
                         if (!this.tree[flatRowKey][flatColTotalKey]) {
                             this.tree[flatRowKey][flatColTotalKey] = [];
                         }
-                        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);
+                        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]);
                             }
-                            this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
                         }
                     }
                 };
@@ -69316,16 +69504,40 @@
                                     if (!this.tree[flatRowTotalKey][flatColKey]) {
                                         this.tree[flatRowTotalKey][flatColKey] = [];
                                     }
-                                    for (let i = 0; i < this.indicatorKeys.length; i++) {
+                                    const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
+                                    for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
                                         if (!this.tree[flatRowTotalKey][flatColKey][i]) {
-                                            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);
+                                            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
+                                                });
+                                            }
                                         }
                                         this.tree[flatRowTotalKey][flatColKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
                                     }
@@ -69341,16 +69553,40 @@
                             if (!this.tree[flatRowTotalKey][flatColKey]) {
                                 this.tree[flatRowTotalKey][flatColKey] = [];
                             }
-                            for (let i = 0; i < this.indicatorKeys.length; i++) {
+                            const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
+                            for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
                                 if (!this.tree[flatRowTotalKey][flatColKey][i]) {
-                                    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);
+                                    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
+                                        });
+                                    }
                                 }
                                 this.tree[flatRowTotalKey][flatColKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
                             }
@@ -72560,7 +72796,7 @@
     }
 
     registerForVrender();
-    const version = "1.3.3-alpha.1";
+    const version = "1.3.3-alpha.2";
     function getIcons() {
         return get$2();
     }