@visactor/vtable 0.12.1-alpha.1 → 0.12.1

package/dist/vtable.js

@@ -39785,35 +39785,14 @@
                 row === layout.columnHeaderLevelCount - 1 &&
                 col >= layout.rowHeaderLevelCount &&
                 col < layout.colCount - layout.rightFrozenColCount) {
-                const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, layout.columnHeaderLevelCount - 1);
-                let defaultKey = indicatorKeys?.[1];
-                if (isArray$5(defaultKey)) {
-                    defaultKey = defaultKey[0];
-                }
-                if (!defaultKey) {
-                    return undefined;
+                const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col, row + 1, 'top', layout);
+                if (axisOption?.visible === false) {
+                    return;
                 }
-                const { axisOption, isPercent, isZeroAlign } = getAxisOption(col, row + 1, 'top', layout);
-                const data = layout.dataset.collectedValues[defaultKey + (isZeroAlign ? '_align' : '')]
-                    ? layout.dataset.collectedValues[defaultKey + (isZeroAlign ? '_align' : '')]
-                    : layout.dataset.collectedValues[defaultKey];
+                const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, layout.columnHeaderLevelCount - 1);
                 const colPath = layout.getColKeysPath(col, row);
-                const range = merge$1({}, data?.[colPath ?? ''] ?? { min: 0, max: 1 });
-                if (range.positiveMax && range.positiveMax > range.max) {
-                    range.max = range.positiveMax;
-                }
-                if (range.negativeMin && range.negativeMin < range.min) {
-                    range.min = range.negativeMin;
-                }
-                if (range.min === range.max) {
-                    if (range.min > 0) {
-                        range.min = 0;
-                    }
-                    else {
-                        range.max = 0;
-                    }
-                }
-                if (axisOption?.visible === false) {
+                const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, colPath, seriesIndice ?? 1);
+                if (!range) {
                     return;
                 }
                 if (isPercent) {
@@ -39843,30 +39822,15 @@
             else if (row === layout.rowCount - layout.bottomFrozenRowCount &&
                 col >= layout.rowHeaderLevelCount &&
                 col < layout.colCount - layout.rightFrozenColCount) {
+                const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col, row - 1, 'bottom', layout);
+                if (axisOption?.visible === false) {
+                    return;
+                }
                 const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
-                let defaultKey = indicatorKeys?.[0];
-                if (isArray$5(defaultKey)) {
-                    defaultKey = defaultKey[0];
-                }
-                const { axisOption, isPercent, isZeroAlign } = getAxisOption(col, row - 1, 'bottom', layout);
-                const data = layout.dataset.collectedValues[defaultKey + (isZeroAlign ? '_align' : '')]
-                    ? layout.dataset.collectedValues[defaultKey + (isZeroAlign ? '_align' : '')]
-                    : layout.dataset.collectedValues[defaultKey];
                 const colPath = layout.getColKeysPath(col, row);
-                const range = merge$1({}, data?.[colPath ?? ''] ?? { min: 0, max: 1 });
-                if (range.positiveMax && range.positiveMax > range.max) {
-                    range.max = range.positiveMax;
-                }
-                if (range.negativeMin && range.negativeMin < range.min) {
-                    range.min = range.negativeMin;
-                }
-                if (range.min === range.max) {
-                    if (range.min > 0) {
-                        range.min = 0;
-                    }
-                    else {
-                        range.max = 0;
-                    }
+                const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, colPath, seriesIndice ?? 0);
+                if (!range) {
+                    return;
                 }
                 let indicatorInfo = null;
                 indicatorKeys?.forEach(key => {
@@ -39875,9 +39839,6 @@
                         indicatorInfo = info;
                     }
                 });
-                if (axisOption?.visible === false) {
-                    return;
-                }
                 if (isPercent) {
                     range.min = range.min < 0 ? -1 : 0;
                     range.max = range.max > 0 ? 1 : 0;
@@ -39935,30 +39896,15 @@
             if (col === layout.rowHeaderLevelCount - 1 &&
                 row >= layout.columnHeaderLevelCount &&
                 row < layout.rowCount - layout.bottomFrozenRowCount) {
+                const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col + 1, row, 'left', layout);
+                if (axisOption?.visible === false) {
+                    return;
+                }
                 const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
-                let defaultKey = indicatorKeys?.[0];
-                if (isArray$5(defaultKey)) {
-                    defaultKey = defaultKey[0];
-                }
-                const { axisOption, isPercent, isZeroAlign } = getAxisOption(col + 1, row, 'left', layout);
-                const data = layout.dataset.collectedValues[defaultKey + (isZeroAlign ? '_align' : '')]
-                    ? layout.dataset.collectedValues[defaultKey + (isZeroAlign ? '_align' : '')]
-                    : layout.dataset.collectedValues[defaultKey];
                 const rowPath = layout.getRowKeysPath(col, row);
-                const range = merge$1({}, data?.[rowPath ?? ''] ?? { min: 0, max: 1 });
-                if (range.positiveMax && range.positiveMax > range.max) {
-                    range.max = range.positiveMax;
-                }
-                if (range.negativeMin && range.negativeMin < range.min) {
-                    range.min = range.negativeMin;
-                }
-                if (range.min === range.max) {
-                    if (range.min > 0) {
-                        range.min = 0;
-                    }
-                    else {
-                        range.max = 0;
-                    }
+                const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, rowPath, seriesIndice ?? 0);
+                if (!range) {
+                    return;
                 }
                 let indicatorInfo = null;
                 indicatorKeys?.forEach(key => {
@@ -39967,9 +39913,6 @@
                         indicatorInfo = info;
                     }
                 });
-                if (axisOption?.visible === false) {
-                    return;
-                }
                 if (isPercent) {
                     range.min = range.min < 0 ? -1 : 0;
                     range.max = range.max > 0 ? 1 : 0;
@@ -40002,35 +39945,14 @@
             else if (col === layout.colCount - layout.rightFrozenColCount &&
                 row >= layout.columnHeaderLevelCount &&
                 row < layout.rowCount - layout.bottomFrozenRowCount) {
-                const indicatorKeys = layout.getIndicatorKeyInChartSpec(layout.rowHeaderLevelCount - 1, row);
-                let defaultKey = indicatorKeys?.[1];
-                if (isArray$5(defaultKey)) {
-                    defaultKey = defaultKey[0];
-                }
-                if (!defaultKey) {
-                    return undefined;
+                const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col - 1, row, 'right', layout);
+                if (axisOption?.visible === false) {
+                    return;
                 }
-                const { axisOption, isPercent, isZeroAlign } = getAxisOption(col - 1, row, 'right', layout);
-                const data = layout.dataset.collectedValues[defaultKey + (isZeroAlign ? '_align' : '')]
-                    ? layout.dataset.collectedValues[defaultKey + (isZeroAlign ? '_align' : '')]
-                    : layout.dataset.collectedValues[defaultKey];
+                const indicatorKeys = layout.getIndicatorKeyInChartSpec(layout.rowHeaderLevelCount - 1, row);
                 const rowPath = layout.getRowKeysPath(col, row);
-                const range = merge$1({}, data?.[rowPath ?? ''] ?? { min: 0, max: 1 });
-                if (range.positiveMax && range.positiveMax > range.max) {
-                    range.max = range.positiveMax;
-                }
-                if (range.negativeMin && range.negativeMin < range.min) {
-                    range.min = range.negativeMin;
-                }
-                if (range.min === range.max) {
-                    if (range.min > 0) {
-                        range.min = 0;
-                    }
-                    else {
-                        range.max = 0;
-                    }
-                }
-                if (axisOption?.visible === false) {
+                const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, rowPath, seriesIndice ?? 1);
+                if (!range) {
                     return;
                 }
                 if (isPercent) {
@@ -40091,10 +40013,19 @@
                 return axis.orient === orient;
             });
             if (axisOption) {
+                const { seriesIndex, seriesId } = axisOption;
+                let seriesIndice;
+                if (isValid$5(seriesId) && isArray$5(spec.series)) {
+                    seriesIndice = (isArray$5(seriesId) ? seriesId : [seriesId]).map(id => spec.series.findIndex((s) => s.id === id));
+                }
+                else if (isValid$5(seriesIndex) && isArray$5(spec.series)) {
+                    seriesIndice = seriesIndex;
+                }
                 return {
                     axisOption,
                     isPercent: spec.percent,
-                    isZeroAlign: checkZeroAlign(spec, orient, layout)
+                    isZeroAlign: checkZeroAlign(spec, orient, layout),
+                    seriesIndice
                 };
             }
         }
@@ -40143,6 +40074,48 @@
         }
         return false;
     }
+    function getAxisRange(collectedValues, indicatorKeys, isZeroAlign, colPath, seriesId) {
+        if (isArray$5(seriesId)) {
+            const range = { min: Infinity, max: -Infinity };
+            for (let i = 0; i < seriesId.length; i++) {
+                const singleRange = getAxisRange(collectedValues, indicatorKeys, isZeroAlign, colPath, seriesId[i]);
+                if (singleRange) {
+                    range.min = Math.min(range.min, singleRange.min);
+                    range.max = Math.max(range.max, singleRange.max);
+                }
+            }
+            if (isFinite(range.min) && isFinite(range.max)) {
+                return range;
+            }
+            return null;
+        }
+        let defaultKey = indicatorKeys?.[seriesId];
+        if (isArray$5(defaultKey)) {
+            defaultKey = defaultKey[0];
+        }
+        if (!defaultKey) {
+            return null;
+        }
+        const data = collectedValues[defaultKey + (isZeroAlign ? '_align' : '')]
+            ? collectedValues[defaultKey + (isZeroAlign ? '_align' : '')]
+            : collectedValues[defaultKey];
+        const range = merge$1({}, data?.[colPath ?? ''] ?? { min: 0, max: 1 });
+        if (range.positiveMax && range.positiveMax > range.max) {
+            range.max = range.positiveMax;
+        }
+        if (range.negativeMin && range.negativeMin < range.min) {
+            range.min = range.negativeMin;
+        }
+        if (range.min === range.max) {
+            if (range.min > 0) {
+                range.min = 0;
+            }
+            else {
+                range.max = 0;
+            }
+        }
+        return range;
+    }
 
     function computeAxisComponentWidth(config, table) {
         const attribute = merge$1({}, commonAxis, config);
@@ -51620,16 +51593,27 @@
                         return;
                     }
                 }
-                if (table.internalProps.tooltip?.isShowOverflowTextTooltip) {
+                let tooltipOption;
+                const headerDescription = table.getHeaderDescription(col, row);
+                if (headerDescription) {
+                    const rect = table.getCellRangeRelativeRect({ col, row });
+                    tooltipOption = {
+                        content: headerDescription,
+                        referencePosition: {
+                            placement: Placement.bottom,
+                            rect
+                        },
+                        style: { arrowMark: false }
+                    };
+                }
+                else if (table.internalProps.tooltip?.isShowOverflowTextTooltip) {
                     const overflowText = table.getCellOverflowText(col, row);
-                    const headerDescription = table.getHeaderDescription(col, row);
                     const rect = table.getCellRangeRelativeRect({ col, row });
-                    let tooltipOption;
                     if (overflowText) {
                         tooltipOption = {
                             content: headerDescription
                                 ? `${headerDescription}
-  ${overflowText}`
+    ${overflowText}`
                                 : overflowText,
                             referencePosition: {
                                 placement: Placement.bottom,
@@ -51638,19 +51622,9 @@
                             style: { arrowMark: false }
                         };
                     }
-                    if (headerDescription) {
-                        tooltipOption = {
-                            content: headerDescription,
-                            referencePosition: {
-                                placement: Placement.bottom,
-                                rect
-                            },
-                            style: { arrowMark: false }
-                        };
-                    }
-                    if (tooltipOption) {
-                        this._bindToCell(e.col, e.row, tooltipOption);
-                    }
+                }
+                if (tooltipOption) {
+                    this._bindToCell(e.col, e.row, tooltipOption);
                 }
             });
             table.on(TABLE_EVENT_TYPE.MOUSEMOVE_CELL, e => {
@@ -52746,7 +52720,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "0.12.1-alpha.1";
+        version = "0.12.1";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -54968,23 +54942,10 @@
         const axes = [];
         if (layout.indicatorsAsCol) {
             const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
-            layout.getRecordIndexByCol(col);
+            const colPath = layout.getColKeysPath(col, row);
             indicatorKeys.forEach((key, index) => {
-                if (isArray$5(key)) {
-                    key = key[0];
-                }
-                const { axisOption, isPercent, isZeroAlign } = getAxisOption(col, row, index === 0 ? 'bottom' : 'top', layout);
-                const data = layout.dataset.collectedValues[key + (isZeroAlign ? '_align' : '')]
-                    ? layout.dataset.collectedValues[key + (isZeroAlign ? '_align' : '')]
-                    : layout.dataset.collectedValues[key];
-                const colPath = layout.getColKeysPath(col, row);
-                const range = merge$1({}, data?.[colPath ?? ''] ?? { min: 0, max: 1 });
-                if (range.positiveMax && range.positiveMax > range.max) {
-                    range.max = range.positiveMax;
-                }
-                if (range.negativeMin && range.negativeMin < range.min) {
-                    range.min = range.negativeMin;
-                }
+                const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col, row, index === 0 ? 'bottom' : 'top', layout);
+                const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, colPath, seriesIndice ?? index);
                 if (isPercent) {
                     range.min = range.min < 0 ? -1 : 0;
                     range.max = range.max > 0 ? 1 : 0;
@@ -55044,20 +55005,8 @@
             const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
             const rowPath = layout.getRowKeysPath(col, row);
             indicatorKeys.forEach((key, index) => {
-                if (isArray$5(key)) {
-                    key = key[0];
-                }
-                const { axisOption, isPercent, isZeroAlign } = getAxisOption(col, row, index === 0 ? 'left' : 'right', layout);
-                const data = layout.dataset.collectedValues[key + (isZeroAlign ? '_align' : '')]
-                    ? layout.dataset.collectedValues[key + (isZeroAlign ? '_align' : '')]
-                    : layout.dataset.collectedValues[key];
-                const range = merge$1({}, data?.[rowPath ?? ''] ?? { min: 0, max: 1 });
-                if (range.positiveMax && range.positiveMax > range.max) {
-                    range.max = range.positiveMax;
-                }
-                if (range.negativeMin && range.negativeMin < range.min) {
-                    range.min = range.negativeMin;
-                }
+                const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col, row, index === 0 ? 'left' : 'right', layout);
+                const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, rowPath, seriesIndice ?? index);
                 if (isPercent) {
                     range.min = range.min < 0 ? -1 : 0;
                     range.max = range.max > 0 ? 1 : 0;
@@ -56919,7 +56868,7 @@
                 });
                 const cell = {
                     id,
-                    title: hd.value ?? indicatorInfo.title,
+                    title: hd.value ?? indicatorInfo?.title,
                     field: hd.dimensionKey,
                     style: typeof (indicatorInfo ?? dimensionInfo)?.headerStyle === 'function'
                         ? (indicatorInfo ?? dimensionInfo)?.headerStyle
@@ -57631,7 +57580,7 @@
         }
         getCellRange(col, row) {
             const result = { start: { col, row }, end: { col, row } };
-            if (!this.isHeader(col, row) || col === -1 || row === -1 || this.isIndicatorHeader(col, row)) {
+            if (!this.isHeader(col, row) || col === -1 || row === -1) {
                 return result;
             }
             if (this.isRightFrozenColumn(col, row) || this.isBottomFrozenRow(col, row)) {
@@ -59380,6 +59329,7 @@
         rowHierarchyType;
         indicators;
         indicatorsAsCol;
+        totalRecordsTree = {};
         constructor(dataConfig, rows, columns, indicatorKeys, indicators, indicatorsAsCol, records, rowHierarchyType, customColTree, customRowTree, needSplitPositiveAndNegative) {
             this.registerAggregators();
             this.dataConfig = dataConfig;
@@ -59434,7 +59384,9 @@
                 }
                 else {
                     if (this.rowHierarchyType === 'tree') {
-                        this.rowHeaderTree = this.ArrToTree1(this.rowKeys, this.rows, indicatorsAsCol ? undefined : indicators);
+                        this.rowHeaderTree = this.ArrToTree1(this.rowKeys, this.rows, indicatorsAsCol ? undefined : indicators, this?.totals?.row?.showGrandTotals ||
+                            (!indicatorsAsCol && this.columns.length === 0) ||
+                            (indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel);
                     }
                     else {
                         this.rowHeaderTree = this.ArrToTree(this.rowKeys, this.rows, indicatorsAsCol ? undefined : indicators, this.rowsIsTotal, this?.totals?.row?.showGrandTotals ||
@@ -59560,16 +59512,6 @@
             this.derivedFieldRules?.forEach((derivedFieldRule, i) => {
                 record[derivedFieldRule.fieldName] = derivedFieldRule.derivedFunc(record);
             });
-            const colKey = [];
-            const rowKey = [];
-            for (let l = 0, len1 = this.rows.length; l < len1; l++) {
-                const rowAttr = this.rows[l];
-                rowKey.push(record[rowAttr]);
-            }
-            for (let n = 0, len2 = this.columns.length; n < len2; n++) {
-                const colAttr = this.columns[n];
-                colKey.push(record[colAttr]);
-            }
             for (const field in this.collectValuesBy) {
                 if (record[field]) {
                     if (!this.collectedValues[field]) {
@@ -59610,8 +59552,81 @@
                     }
                 }
             }
+            const colKey = [];
+            const rowKey = [];
+            let isToTalRecord = false;
+            for (let l = 0, len1 = this.rows.length; l < len1; l++) {
+                const rowAttr = this.rows[l];
+                if (rowAttr in record) {
+                    rowKey.push(record[rowAttr]);
+                }
+                else {
+                    if (this.dataConfig?.totals?.row?.showGrandTotals &&
+                        l === 0 &&
+                        !this.rows.find((rk) => {
+                            return rk in record;
+                        })) {
+                        rowKey.push(this.rowGrandTotalLabel);
+                        isToTalRecord = true;
+                        break;
+                    }
+                    else if (this.dataConfig?.totals?.row?.showSubTotals &&
+                        this.dataConfig?.totals?.row?.subTotalsDimensions.indexOf(this.rows[l - 1]) >= 0) {
+                        if (this.rowHierarchyType === 'grid') {
+                            rowKey.push(this.rowSubTotalLabel);
+                        }
+                        isToTalRecord = true;
+                        break;
+                    }
+                }
+            }
+            for (let n = 0, len2 = this.columns.length; n < len2; n++) {
+                const colAttr = this.columns[n];
+                if (colAttr in record) {
+                    colKey.push(record[colAttr]);
+                }
+                else {
+                    if (this.dataConfig?.totals?.column?.showGrandTotals &&
+                        n === 0 &&
+                        !this.columns.find((ck) => {
+                            return ck in record;
+                        })) {
+                        colKey.push(this.colGrandTotalLabel);
+                        isToTalRecord = true;
+                        break;
+                    }
+                    else if (this.dataConfig?.totals?.column?.showSubTotals &&
+                        this.dataConfig?.totals?.column?.subTotalsDimensions.indexOf(this.columns[n - 1]) >= 0) {
+                        colKey.push(this.colSubTotalLabel);
+                        isToTalRecord = true;
+                        break;
+                    }
+                }
+            }
             const flatRowKey = rowKey.join(this.stringJoinChar);
             const flatColKey = colKey.join(this.stringJoinChar);
+            if (isToTalRecord) {
+                if (!this.totalRecordsTree[flatRowKey]) {
+                    this.totalRecordsTree[flatRowKey] = {};
+                }
+                if (!this.totalRecordsTree[flatRowKey][flatColKey]) {
+                    this.totalRecordsTree[flatRowKey][flatColKey] = [];
+                }
+                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;
+            }
             if (rowKey.length !== 0) {
                 if (!this.rowFlatKeys[flatRowKey]) {
                     this.rowKeys.push(rowKey);
@@ -59884,16 +59899,22 @@
                 that?.totals?.row?.showGrandTotals) {
                 const rowTotalKeys = [];
                 const colCompute = (flatRowKey, flatColKey) => {
+                    if (this.totalRecordsTree?.[flatRowKey]?.[flatColKey]) {
+                        this.tree[flatRowKey][flatColKey] = this.totalRecordsTree?.[flatRowKey]?.[flatColKey];
+                        return;
+                    }
                     const colKey = flatColKey.split(this.stringJoinChar);
                     for (let i = 0, len = that.totals?.column?.subTotalsDimensions?.length; i < len; i++) {
                         const dimension = that.totals.column.subTotalsDimensions[i];
                         const dimensionIndex = that.columns.indexOf(dimension);
                         if (dimensionIndex >= 0) {
                             const colTotalKey = colKey.slice(0, dimensionIndex + 1);
-                            if (this.rowHierarchyType === 'grid') {
-                                colTotalKey.push(that.totals?.column?.subTotalLabel ?? '小计');
-                            }
+                            colTotalKey.push(that.totals?.column?.subTotalLabel ?? '小计');
                             const flatColTotalKey = colTotalKey.join(this.stringJoinChar);
+                            if (this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey]) {
+                                this.tree[flatRowKey][flatColTotalKey] = this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey];
+                                return;
+                            }
                             if (!this.tree[flatRowKey][flatColTotalKey]) {
                                 this.tree[flatRowKey][flatColTotalKey] = [];
                             }
@@ -59914,6 +59935,10 @@
                     }
                     if (that.totals?.column?.showGrandTotals || this.rows.length === 0) {
                         const flatColTotalKey = that.colGrandTotalLabel;
+                        if (this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey]) {
+                            this.tree[flatRowKey][flatColTotalKey] = this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey];
+                            return;
+                        }
                         if (!this.tree[flatRowKey][flatColTotalKey]) {
                             this.tree[flatRowKey][flatColTotalKey] = [];
                         }
@@ -59938,7 +59963,7 @@
                         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);
-                            if (dimensionIndex >= 0) {
+                            if (dimensionIndex >= 0 && dimensionIndex < that.rows.length - 1) {
                                 const rowTotalKey = rowKey.slice(0, dimensionIndex + 1);
                                 if (this.rowHierarchyType === 'grid') {
                                     rowTotalKey.push(that.totals?.row?.subTotalLabel ?? '小计');
@@ -59950,19 +59975,19 @@
                                 }
                                 if (!this.tree[flatRowTotalKey][flatColKey]) {
                                     this.tree[flatRowTotalKey][flatColKey] = [];
-                                    for (let i = 0; i < this.indicatorKeys.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);
-                                        }
-                                        this.tree[flatRowTotalKey][flatColKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
+                                }
+                                for (let i = 0; i < this.indicatorKeys.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);
                                     }
+                                    this.tree[flatRowTotalKey][flatColKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
                                 }
                             }
                         }
@@ -59999,7 +60024,7 @@
                 });
             }
         }
-        ArrToTree1(arr, rows, indicators) {
+        ArrToTree1(arr, rows, indicators, isGrandTotal, grandTotalLabel) {
             const result = [];
             const concatStr = this.stringJoinChar;
             const map = new Map();
@@ -60041,6 +60066,9 @@
                 });
             }
             arr.forEach(item => addList(item));
+            if (isGrandTotal) {
+                addList([grandTotalLabel]);
+            }
             return result;
         }
         ArrToTree(arr, rows, indicators, subTotalFlags, isGrandTotal, grandTotalLabel, subTotalLabel) {
@@ -62393,7 +62421,7 @@
         return new Tag(params ? params.attribute : {});
     }
 
-    const version = "0.12.1-alpha.1";
+    const version = "0.12.1";
     function getIcons() {
         return get$1();
     }