@visactor/vtable 0.12.1-alpha.0 → 0.12.1

package/dist/vtable.js

@@ -3365,7 +3365,7 @@
             if (id == null) {
                 return;
             }
-            const obj = this.listeners[id];
+            const obj = this.listeners?.[id];
             if (!obj) {
                 return;
             }
@@ -3415,7 +3415,7 @@
                 return;
             }
             this.clear();
-            this.listeners = null;
+            this.listeners = {};
         }
     }
 
@@ -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);
@@ -45766,7 +45739,7 @@
     function updateChartSize(scenegraph, col) {
         for (let c = col; c <= scenegraph.proxy.colEnd; c++) {
             const columnGroup = scenegraph.getColGroup(c);
-            columnGroup.getChildren().forEach((cellNode) => {
+            columnGroup.getChildren()?.forEach((cellNode) => {
                 const width = scenegraph.table.getColWidth(cellNode.col);
                 const height = scenegraph.table.getRowHeight(cellNode.row);
                 cellNode.children.forEach((node) => {
@@ -45782,7 +45755,7 @@
     function clearChartCacheImage(scenegraph) {
         for (let c = scenegraph.proxy.colStart; c <= scenegraph.proxy.colEnd; c++) {
             const columnGroup = scenegraph.getColGroup(c);
-            columnGroup.getChildren().forEach((cellNode) => {
+            columnGroup.getChildren()?.forEach((cellNode) => {
                 cellNode.children.forEach((node) => {
                     if (node.type === 'chart') {
                         node.cacheCanvas = null;
@@ -45796,7 +45769,7 @@
         const table = scenegraph.table;
         for (let c = scenegraph.proxy.colStart; c <= scenegraph.proxy.colEnd; c++) {
             const columnGroup = scenegraph.getColGroup(c);
-            columnGroup.getChildren().forEach((cellNode) => {
+            columnGroup.getChildren()?.forEach((cellNode) => {
                 const col = cellNode.col;
                 const row = cellNode.row;
                 cellNode.children.forEach((node) => {
@@ -50677,23 +50650,13 @@
             const rect = table.getCellRangeRelativeRect({ col, row });
             const element = table.getElement();
             const { top, bottom, left, right } = rect;
-            const { frozenRowCount, frozenColCount } = table;
-            if (row >= frozenRowCount && frozenRowCount > 0) {
-                const frozenRect = table.getCellRangeRelativeRect({ col, row: frozenRowCount - 1 });
-                if (bottom < frozenRect.bottom) {
-                    return false;
-                }
-            }
-            else if (bottom < 0) {
-                return false;
-            }
-            if (col >= frozenColCount && frozenColCount > 0) {
-                const frozenRect = table.getCellRangeRelativeRect({ col: frozenColCount - 1, row });
-                if (right < frozenRect.right) {
-                    return false;
-                }
+            if (table.isFrozenCell(col, row)) {
+                return true;
             }
-            else if (right < 0) {
+            else if (bottom < table.getFrozenRowsHeight() ||
+                right < table.getFrozenColsWidth() ||
+                left > table.tableNoFrameWidth - table.getRightFrozenColsWidth() ||
+                top > table.tableNoFrameHeight - table.getBottomFrozenRowsHeight()) {
                 return false;
             }
             const { offsetHeight, offsetWidth } = element;
@@ -51353,31 +51316,21 @@
         _canBindToCell(table, col, row) {
             const rect = table.getCellRangeRelativeRect({ col, row });
             const element = table.getElement();
-            const { bottom, left, right } = rect;
-            const { frozenRowCount, frozenColCount } = table;
-            if (row >= frozenRowCount && frozenRowCount > 0) {
-                const frozenRect = table.getCellRangeRelativeRect({ col, row: frozenRowCount - 1 });
-                if (bottom < frozenRect.bottom) {
-                    return false;
-                }
-            }
-            else if (bottom < 0) {
-                return false;
-            }
-            if (col >= frozenColCount && frozenColCount > 0) {
-                const frozenRect = table.getCellRangeRelativeRect({ col: frozenColCount - 1, row });
-                if (right < frozenRect.right) {
-                    return false;
-                }
+            const { bottom, left, right, top } = rect;
+            if (table.isFrozenCell(col, row)) {
+                return true;
             }
-            else if (left < 0) {
+            else if (bottom < table.getFrozenRowsHeight() ||
+                right < table.getFrozenColsWidth() ||
+                left > table.tableNoFrameWidth - table.getRightFrozenColsWidth() ||
+                top > table.tableNoFrameHeight - table.getBottomFrozenRowsHeight()) {
                 return false;
             }
             const { offsetHeight, offsetWidth } = element;
-            if (offsetHeight < bottom) {
+            if (top > offsetHeight) {
                 return false;
             }
-            if (offsetWidth < left) {
+            if (left > offsetWidth) {
                 return false;
             }
             return true;
@@ -51640,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,
@@ -51658,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 => {
@@ -51870,23 +51824,13 @@
             const rect = table.getCellRangeRelativeRect({ col, row });
             const element = table.getElement();
             const { top, bottom, left, right } = rect;
-            const { frozenRowCount, frozenColCount } = table;
-            if (row >= frozenRowCount && frozenRowCount > 0) {
-                const frozenRect = table.getCellRangeRelativeRect({ col, row: frozenRowCount - 1 });
-                if (bottom < frozenRect.bottom) {
-                    return false;
-                }
-            }
-            else if (bottom < 0) {
-                return false;
-            }
-            if (col >= frozenColCount && frozenColCount > 0) {
-                const frozenRect = table.getCellRangeRelativeRect({ col: frozenColCount - 1, row });
-                if (right < frozenRect.right) {
-                    return false;
-                }
+            if (table.isFrozenCell(col, row)) {
+                return true;
             }
-            else if (right < 0) {
+            else if (bottom < table.getFrozenRowsHeight() ||
+                right < table.getFrozenColsWidth() ||
+                left > table.tableNoFrameWidth - table.getRightFrozenColsWidth() ||
+                top > table.tableNoFrameHeight - table.getBottomFrozenRowsHeight()) {
                 return false;
             }
             const { offsetHeight, offsetWidth } = element;
@@ -52776,7 +52720,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "0.12.1-alpha.0";
+        version = "0.12.1";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -53503,9 +53447,8 @@
             return this.getCellsRectWidth(cellRange.start.col, cellRange.start.row, cellRange.end.col, cellRange.end.row);
         }
         isFrozenCell(col, row) {
-            const { frozenRowCount, frozenColCount } = this.internalProps;
-            const isFrozenRow = (frozenRowCount > 0 && row < frozenRowCount) || this.isBottomFrozenRow(col, row);
-            const isFrozenCol = (frozenColCount > 0 && col < frozenColCount) || this.isRightFrozenColumn(col, row);
+            const isFrozenRow = this.isFrozenRow(row) || this.isBottomFrozenRow(row);
+            const isFrozenCol = this.isFrozenRow(col) || this.isRightFrozenColumn(col);
             if (isFrozenRow || isFrozenCol) {
                 return {
                     row: isFrozenRow,
@@ -54257,9 +54200,21 @@
         isCornerHeader(col, row) {
             return this.internalProps.layoutMap?.isCornerHeader(col, row);
         }
+        isFrozenColumn(col, row) {
+            return this.internalProps.layoutMap?.isFrozenColumn(col, row);
+        }
+        isLeftFrozenColumn(col, row) {
+            return this.internalProps.layoutMap?.isFrozenColumn(col, row);
+        }
         isRightFrozenColumn(col, row) {
             return this.internalProps.layoutMap?.isRightFrozenColumn(col, row);
         }
+        isFrozenRow(col, row) {
+            return this.internalProps.layoutMap?.isFrozenRow(col, row);
+        }
+        isTopFrozenRow(col, row) {
+            return this.internalProps.layoutMap?.isFrozenRow(col, row);
+        }
         isBottomFrozenRow(col, row) {
             return this.internalProps.layoutMap?.isBottomFrozenRow(col, row);
         }
@@ -54987,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;
@@ -55063,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;
@@ -55216,25 +55146,73 @@
             }
             return 'body';
         }
+        isRowHeader(col, row) {
+            if (this.transpose && col < this.headerLevelCount) {
+                return true;
+            }
+            return false;
+        }
         isColumnHeader(col, row) {
             if (!this.transpose && row < this.headerLevelCount) {
                 return true;
             }
             return false;
         }
+        isFrozenColumn(col, row) {
+            if (isValid$6(row)) {
+                if (col < this.frozenColCount && row >= this.frozenRowCount && row < this.rowCount - this.bottomFrozenRowCount) {
+                    return true;
+                }
+            }
+            else {
+                if (this.frozenColCount > 0 && col < this.frozenColCount) {
+                    return true;
+                }
+            }
+            return false;
+        }
         isRightFrozenColumn(col, row) {
-            if (col >= this.colCount - this.rightFrozenColCount &&
-                row >= this.columnHeaderLevelCount &&
-                row < this.rowCount - this.bottomFrozenRowCount) {
-                return true;
+            if (isValid$6(row)) {
+                if (col >= this.colCount - this.rightFrozenColCount &&
+                    row >= this.frozenRowCount &&
+                    row < this.rowCount - this.bottomFrozenRowCount) {
+                    return true;
+                }
+            }
+            else {
+                if (this.rightFrozenColCount > 0 && col >= this.colCount - this.rightFrozenColCount) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        isFrozenRow(col, row) {
+            if (isValid$6(row)) {
+                if (row < this.frozenRowCount && col >= this.frozenColCount && col < this.colCount - this.rightFrozenColCount) {
+                    return true;
+                }
+            }
+            else {
+                row = col;
+                if (this.frozenRowCount > 0 && row < this.frozenRowCount) {
+                    return true;
+                }
             }
             return false;
         }
         isBottomFrozenRow(col, row) {
-            if (col >= this.rowHeaderLevelCount &&
-                row >= this.rowCount - this.bottomFrozenRowCount &&
-                col < this.colCount - this.rightFrozenColCount) {
-                return true;
+            if (isValid$6(row)) {
+                if (row >= this.rowCount - this.bottomFrozenRowCount &&
+                    col >= this.frozenColCount &&
+                    col < this.colCount - this.rightFrozenColCount) {
+                    return true;
+                }
+            }
+            else {
+                row = col;
+                if (this.frozenRowCount > 0 && row >= this.rowCount - this.bottomFrozenRowCount) {
+                    return true;
+                }
             }
             return false;
         }
@@ -55259,12 +55237,6 @@
         isCornerHeader(col, row) {
             return false;
         }
-        isRowHeader(col, row) {
-            if (this.transpose && col < this.headerLevelCount) {
-                return true;
-            }
-            return false;
-        }
         getColumnHeaderRange() {
             if (this.transpose) {
                 return {
@@ -55313,11 +55285,17 @@
         get rowHeaderLevelCount() {
             return this.transpose ? this.headerLevelCount : 0;
         }
+        get frozenColCount() {
+            return this._table.internalProps.frozenColCount ?? 0;
+        }
+        get frozenRowCount() {
+            return this._table.internalProps.frozenRowCount ?? 0;
+        }
         get bottomFrozenRowCount() {
-            return 0;
+            return this._table.internalProps.bottomFrozenRowCount ?? 0;
         }
         get rightFrozenColCount() {
-            return 0;
+            return this._table.internalProps.rightFrozenColCount ?? 0;
         }
         get colCount() {
             return this.transpose ? this.headerLevelCount + this.recordsCount : this._columns.length;
@@ -56890,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
@@ -57310,19 +57288,61 @@
             }
             return false;
         }
+        isFrozenColumn(col, row) {
+            if (isValid$6(row)) {
+                if (col < this.frozenColCount && row >= this.frozenRowCount && row < this.rowCount - this.bottomFrozenRowCount) {
+                    return true;
+                }
+            }
+            else {
+                if (this.frozenColCount > 0 && col < this.frozenColCount) {
+                    return true;
+                }
+            }
+            return false;
+        }
         isRightFrozenColumn(col, row) {
-            if (col >= this.colCount - this.rightFrozenColCount &&
-                row >= this.columnHeaderLevelCount &&
-                row < this.rowCount - this.bottomFrozenRowCount) {
-                return true;
+            if (isValid$6(row)) {
+                if (col >= this.colCount - this.rightFrozenColCount &&
+                    row >= this.frozenRowCount &&
+                    row < this.rowCount - this.bottomFrozenRowCount) {
+                    return true;
+                }
+            }
+            else {
+                if (this.rightFrozenColCount > 0 && col >= this.colCount - this.rightFrozenColCount) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        isFrozenRow(col, row) {
+            if (isValid$6(row)) {
+                if (row < this.frozenRowCount && col >= this.frozenColCount && col < this.colCount - this.rightFrozenColCount) {
+                    return true;
+                }
+            }
+            else {
+                row = col;
+                if (this.frozenRowCount > 0 && row < this.frozenRowCount) {
+                    return true;
+                }
             }
             return false;
         }
         isBottomFrozenRow(col, row) {
-            if (col >= this.rowHeaderLevelCount &&
-                row >= this.rowCount - this.bottomFrozenRowCount &&
-                col < this.colCount - this.rightFrozenColCount) {
-                return true;
+            if (isValid$6(row)) {
+                if (row >= this.rowCount - this.bottomFrozenRowCount &&
+                    col >= this.frozenColCount &&
+                    col < this.colCount - this.rightFrozenColCount) {
+                    return true;
+                }
+            }
+            else {
+                row = col;
+                if (this.frozenRowCount > 0 && row >= this.rowCount - this.bottomFrozenRowCount) {
+                    return true;
+                }
             }
             return false;
         }
@@ -57370,6 +57390,12 @@
         }
         resetCellIds() {
         }
+        get frozenColCount() {
+            return this._table.internalProps.frozenColCount ?? 0;
+        }
+        get frozenRowCount() {
+            return this._table.internalProps.frozenRowCount ?? 0;
+        }
         get headerLevelCount() {
             return this.columnHeaderLevelCount;
         }
@@ -57426,7 +57452,7 @@
             return this.columnDimensionTree.tree.size + this.rowHeaderLevelCount + this.rightFrozenColCount;
         }
         get rowCount() {
-            return Math.max(this._rowHeaderCellIds.length, 1) + this.columnHeaderLevelCount + this.bottomFrozenRowCount;
+            return (this._rowHeaderCellIds?.length ?? 0) + this.columnHeaderLevelCount + this.bottomFrozenRowCount;
         }
         get bodyRowCount() {
             return this.rowDimensionTree.tree.size;
@@ -57554,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)) {
@@ -59303,6 +59329,7 @@
         rowHierarchyType;
         indicators;
         indicatorsAsCol;
+        totalRecordsTree = {};
         constructor(dataConfig, rows, columns, indicatorKeys, indicators, indicatorsAsCol, records, rowHierarchyType, customColTree, customRowTree, needSplitPositiveAndNegative) {
             this.registerAggregators();
             this.dataConfig = dataConfig;
@@ -59357,10 +59384,14 @@
                 }
                 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 || this.columns.length === 0, this.rowGrandTotalLabel, this.rowSubTotalLabel);
+                        this.rowHeaderTree = this.ArrToTree(this.rowKeys, this.rows, indicatorsAsCol ? undefined : indicators, this.rowsIsTotal, this?.totals?.row?.showGrandTotals ||
+                            (!indicatorsAsCol && this.columns.length === 0) ||
+                            (indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel, this.rowSubTotalLabel);
                     }
                 }
                 if (customColTree) {
@@ -59481,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]) {
@@ -59531,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);
@@ -59805,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] = [];
                             }
@@ -59835,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] = [];
                         }
@@ -59859,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 ?? '小计');
@@ -59871,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]);
                                 }
                             }
                         }
@@ -59920,7 +60024,7 @@
                 });
             }
         }
-        ArrToTree1(arr, rows, indicators) {
+        ArrToTree1(arr, rows, indicators, isGrandTotal, grandTotalLabel) {
             const result = [];
             const concatStr = this.stringJoinChar;
             const map = new Map();
@@ -59962,6 +60066,9 @@
                 });
             }
             arr.forEach(item => addList(item));
+            if (isGrandTotal) {
+                addList([grandTotalLabel]);
+            }
             return result;
         }
         ArrToTree(arr, rows, indicators, subTotalFlags, isGrandTotal, grandTotalLabel, subTotalLabel) {
@@ -62314,7 +62421,7 @@
         return new Tag(params ? params.attribute : {});
     }
 
-    const version = "0.12.1-alpha.0";
+    const version = "0.12.1";
     function getIcons() {
         return get$1();
     }