@visactor/vtable 0.9.3-alpha.3 → 0.9.3-alpha.4

package/dist/vtable.js

@@ -36525,7 +36525,7 @@
             this.table = table;
             this.width = width;
             this.height = height;
-            this.option = merge$2({}, option, commonAxis);
+            this.option = merge$2({}, commonAxis, option);
             this.orient = option.orient ?? 'left';
             this.visible = option.visible ?? true;
             this.type = option.type ?? 'band';
@@ -41643,7 +41643,7 @@
                     renderCanvas: params.canvas,
                     mode: 'desktop-browser',
                     canvasControled: false,
-                    viewBox: params.viewBox,
+                    viewBox: { x1: 0, x2: 0, y1: 0, y2: 0 },
                     interactive: false,
                     animation: false
                 });
@@ -41655,7 +41655,7 @@
         }
         activate(table) {
             this.active = true;
-            const { x1, y1, x2, y2 } = this.attribute.viewBox;
+            const { x1, y1, x2, y2 } = this.getViewBox();
             const tableBound = table.scenegraph.tableGroup.globalAABBBounds;
             const bodyBound = new Bounds();
             bodyBound.x1 = tableBound.x1 + table.getFrozenColsWidth();
@@ -41723,6 +41723,17 @@
         updateData(data) {
             this.attribute.data = data;
         }
+        getViewBox() {
+            const cellGroup = this.parent;
+            const padding = this.attribute.cellPadding;
+            const table = this.stage.table;
+            return {
+                x1: Math.ceil(cellGroup.globalAABBBounds.x1 + padding[3] + table.scrollLeft),
+                x2: Math.ceil(cellGroup.globalAABBBounds.x1 + cellGroup.attribute.width - padding[1] + table.scrollLeft),
+                y1: Math.ceil(cellGroup.globalAABBBounds.y1 + padding[0] + table.scrollTop),
+                y2: Math.ceil(cellGroup.globalAABBBounds.y1 + cellGroup.attribute.height - padding[2] + table.scrollTop)
+            };
+        }
     }
 
     const ChartRender = Symbol.for('ChartRender');
@@ -41731,7 +41742,8 @@
         numberType = CHART_NUMBER_TYPE;
         drawShape(chart, context, x, y, drawContext, params, fillCb, strokeCb) {
             const groupAttribute = getTheme(chart, params?.theme).group;
-            const { dataId, data, viewBox } = chart.attribute;
+            const { dataId, data } = chart.attribute;
+            const viewBox = chart.getViewBox();
             const { width = groupAttribute.width, height = groupAttribute.height } = chart.attribute;
             const { chartInstance, active, cacheCanvas, activeChartInstance } = chart;
             if (!active && cacheCanvas) {
@@ -42697,7 +42709,7 @@
     });
     function computeRowsHeight(table, rowStart, rowEnd) {
         const time = typeof window !== 'undefined' ? window.performance.now() : 0;
-        if (table.heightMode === 'autoHeight') {
+        if (table.heightMode === 'autoHeight' || table.heightMode === 'adaptive') {
             rowStart = rowStart ?? 0;
             rowEnd = rowEnd ?? table.rowCount - 1;
             if (rowStart === 0 && rowEnd === table.rowCount - 1) {
@@ -42738,7 +42750,7 @@
                 }
             }
         }
-        else if (table.heightMode === 'adaptive') {
+        if (table.heightMode === 'adaptive') {
             table._clearRowRangeHeightsMap();
             const totalDrawHeight = table.tableNoFrameHeight - table.getFrozenRowsHeight() - table.getBottomFrozenRowsHeight();
             let actualHeight = 0;
@@ -42762,6 +42774,17 @@
     }
     function computeRowHeight(row, startCol, endCol, table) {
         let maxHeight = 0;
+        if (table.isPivotChart() && row >= table.columnHeaderLevelCount) {
+            if (table.internalProps.layoutMap.indicatorsAsCol) {
+                const optimunHeight = table.internalProps.layoutMap.getOptimunHeightForChart(row);
+                if (optimunHeight > 0) {
+                    return optimunHeight;
+                }
+            }
+            else {
+                return table.getRowHeight(row);
+            }
+        }
         for (let col = startCol; col <= endCol; col++) {
             const customHeight = computeCustomRenderHeight(col, row, table);
             if (typeof customHeight === 'number') {
@@ -42972,12 +42995,6 @@
             dataId,
             data: table.getCellValue(col, row),
             cellPadding: padding,
-            viewBox: {
-                x1: Math.ceil(cellGroup.globalAABBBounds.x1 + padding[3] + table.scrollLeft),
-                x2: Math.ceil(cellGroup.globalAABBBounds.x1 + width - padding[1] + table.scrollLeft),
-                y1: Math.ceil(cellGroup.globalAABBBounds.y1 + padding[0] + table.scrollTop),
-                y2: Math.ceil(cellGroup.globalAABBBounds.y1 + height - padding[2] + table.scrollTop)
-            },
             axes: table.internalProps.layoutMap.getChartAxes(col, row)
         });
         cellGroup.appendChild(chartGroup);
@@ -44005,6 +44022,10 @@
         cellCache = new Map();
         constructor(table) {
             this.table = table;
+            if (this.table.isPivotChart()) {
+                this.rowLimit = 100;
+                this.colLimit = 100;
+            }
             if (this.table.internalProps.transpose) {
                 this.mode = 'row';
             }
@@ -44931,12 +44952,6 @@
                         node.cacheCanvas = null;
                         node.setAttribute('width', Math.ceil(width - node.attribute.cellPadding[3] - node.attribute.cellPadding[1]));
                         node.setAttribute('height', Math.ceil(height - node.attribute.cellPadding[0] - node.attribute.cellPadding[2]));
-                        node.setAttribute('viewBox', {
-                            x1: Math.ceil(cellNode.globalAABBBounds.x1 + node.attribute.cellPadding[3] + scenegraph.table.scrollLeft),
-                            x2: Math.ceil(cellNode.globalAABBBounds.x1 + width - node.attribute.cellPadding[1] + scenegraph.table.scrollLeft),
-                            y1: Math.ceil(cellNode.globalAABBBounds.y1 + node.attribute.cellPadding[0] + scenegraph.table.scrollTop),
-                            y2: Math.ceil(cellNode.globalAABBBounds.y1 + height - node.attribute.cellPadding[2] + scenegraph.table.scrollTop)
-                        });
                     }
                 });
             });
@@ -51166,11 +51181,11 @@
             });
             if (this.orient === 'left') {
                 this.table.tableNoFrameWidth = this.table.tableNoFrameWidth - Math.ceil(width);
-                this.table.tableX = Math.ceil(width);
+                this.table.tableX += Math.ceil(width);
             }
             else if (this.orient === 'top') {
                 this.table.tableNoFrameHeight = this.table.tableNoFrameHeight - Math.ceil(height);
-                this.table.tableY = Math.ceil(height);
+                this.table.tableY += Math.ceil(height);
             }
             else if (this.orient === 'right') {
                 this.table.tableNoFrameWidth = this.table.tableNoFrameWidth - Math.ceil(width);
@@ -51221,6 +51236,7 @@
             };
         }
         dispose() {
+            this.table.scenegraph.stage.defaultLayer.removeChild(this.legendComponent);
             this.legendComponent = null;
         }
     }
@@ -51267,11 +51283,11 @@
             }
             if (this._titleOption.orient === 'left') {
                 this.table.tableNoFrameWidth = this.table.tableNoFrameWidth - Math.ceil(width);
-                this.table.tableX = Math.ceil(width);
+                this.table.tableX += Math.ceil(width);
             }
             else if (this._titleOption.orient === 'top') {
                 this.table.tableNoFrameHeight = this.table.tableNoFrameHeight - Math.ceil(height);
-                this.table.tableY = Math.ceil(height);
+                this.table.tableY += Math.ceil(height);
             }
             else if (this._titleOption.orient === 'right') {
                 this.table.tableNoFrameWidth = this.table.tableNoFrameWidth - Math.ceil(width);
@@ -51293,6 +51309,7 @@
             return this._titleComponent;
         }
         dispose() {
+            this.table.scenegraph.stage.defaultLayer.removeChild(this._titleComponent);
             this._titleComponent = null;
         }
         _getTitleAttrs() {
@@ -51360,7 +51377,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "0.9.3-alpha.3";
+        version = "0.9.3-alpha.4";
         pagerConf;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -52422,6 +52439,9 @@
             this.dataSet = new DataSet();
             this.scenegraph.clearCells();
             this.stateManeger.initState();
+            this._updateSize();
+            this.internalProps.legends?.dispose();
+            this.internalProps.title?.dispose();
             if (options.legends) {
                 internalProps.legends = new TableLegend(options.legends, this);
                 this.scenegraph.tableGroup.setAttributes({
@@ -52675,7 +52695,7 @@
             return this.internalProps.layoutMap.columnHeaderLevelCount;
         }
         get records() {
-            return this.internalProps.records || null;
+            return this.internalProps.records;
         }
         get dataSource() {
             return this.internalProps.dataSource;
@@ -53502,6 +53522,219 @@
         numberFormat: numberFormat
     });
 
+    function getAxisConfigInPivotChart(col, row, layout) {
+        if (!layout._table.isPivotChart()) {
+            return undefined;
+        }
+        if (layout.indicatorsAsCol) {
+            if (layout.hasTwoIndicatorAxes &&
+                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$3(defaultKey)) {
+                    defaultKey = defaultKey[0];
+                }
+                if (!defaultKey) {
+                    return undefined;
+                }
+                const data = layout.dataset.collectedValues[defaultKey + '_align']
+                    ? layout.dataset.collectedValues[defaultKey + '_align']
+                    : layout.dataset.collectedValues[defaultKey];
+                const index = layout.getRecordIndexByCol(col);
+                const range = data[layout.getColKeysPath()[index][Math.max(0, layout.columnHeaderLevelCount - 1 - layout.topAxesCount)]];
+                const axisOption = getAxisOption(col, row, 'top', layout);
+                if (axisOption?.visible === false) {
+                    return;
+                }
+                return merge$2({}, axisOption, {
+                    orient: 'top',
+                    type: 'linear',
+                    range: range,
+                    label: {
+                        flush: true
+                    },
+                    title: {
+                        visible: false
+                    }
+                });
+            }
+            else if (row === layout.rowCount - layout.bottomFrozenRowCount &&
+                col >= layout.rowHeaderLevelCount &&
+                col < layout.colCount - layout.rightFrozenColCount) {
+                const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
+                let defaultKey = indicatorKeys[0];
+                if (isArray$3(defaultKey)) {
+                    defaultKey = defaultKey[0];
+                }
+                const data = layout.dataset.collectedValues[defaultKey + '_align']
+                    ? layout.dataset.collectedValues[defaultKey + '_align']
+                    : layout.dataset.collectedValues[defaultKey];
+                const index = layout.getRecordIndexByCol(col);
+                const range = data[layout.getColKeysPath()[index][Math.max(0, layout.columnHeaderLevelCount - 1 - layout.topAxesCount)]];
+                let indicatorInfo = null;
+                indicatorKeys.forEach(key => {
+                    const info = layout.getIndicatorInfo(key);
+                    if (info) {
+                        indicatorInfo = info;
+                    }
+                });
+                const axisOption = getAxisOption(col, row, 'bottom', layout);
+                if (axisOption?.visible === false) {
+                    return;
+                }
+                return merge$2({}, axisOption, {
+                    orient: 'bottom',
+                    type: 'linear',
+                    range: range,
+                    label: {
+                        flush: true
+                    },
+                    title: {
+                        text: indicatorInfo?.caption,
+                        autoRotate: true
+                    }
+                });
+            }
+            else if (col === layout.rowHeaderLevelCount - 1 &&
+                row >= layout.columnHeaderLevelCount &&
+                row < layout.rowCount - layout.bottomFrozenRowCount) {
+                let rowDimensionKey = layout.getDimensionKeyInChartSpec(layout.rowHeaderLevelCount, row)[0];
+                if (isArray$3(rowDimensionKey)) {
+                    rowDimensionKey = rowDimensionKey[0];
+                }
+                const data = layout.dataset.collectedValues[rowDimensionKey];
+                const recordRow = layout.getRecordIndexByRow(row);
+                const rowPath = layout.getRowKeysPath()[recordRow];
+                const domain = data[rowPath[rowPath.length - 1]];
+                const axisOption = getAxisOption(col, row, 'left', layout);
+                if (axisOption?.visible === false) {
+                    return;
+                }
+                return merge$2({}, axisOption, {
+                    orient: 'left',
+                    type: 'band',
+                    data: Array.from(domain).reverse(),
+                    title: {
+                        visible: false
+                    }
+                });
+            }
+        }
+        else {
+            if (col === layout.rowHeaderLevelCount - 1 &&
+                row >= layout.columnHeaderLevelCount &&
+                row < layout.rowCount - layout.bottomFrozenRowCount) {
+                const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
+                let defaultKey = indicatorKeys[0];
+                if (isArray$3(defaultKey)) {
+                    defaultKey = defaultKey[0];
+                }
+                const data = layout.dataset.collectedValues[defaultKey + '_align']
+                    ? layout.dataset.collectedValues[defaultKey + '_align']
+                    : layout.dataset.collectedValues[defaultKey];
+                const index = layout.getRecordIndexByRow(row);
+                const range = data[layout.getRowKeysPath()[index][Math.max(0, layout.rowHeaderLevelCount - 1 - layout.leftAxesCount)]];
+                let indicatorInfo = null;
+                indicatorKeys.forEach(key => {
+                    const info = layout.getIndicatorInfo(key);
+                    if (info) {
+                        indicatorInfo = info;
+                    }
+                });
+                const axisOption = getAxisOption(col, row, 'left', layout);
+                if (axisOption?.visible === false) {
+                    return;
+                }
+                return merge$2({}, axisOption, {
+                    orient: 'left',
+                    type: 'linear',
+                    range: range,
+                    label: {
+                        flush: true
+                    },
+                    title: {
+                        text: indicatorInfo?.caption,
+                        autoRotate: true
+                    }
+                });
+            }
+            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$3(defaultKey)) {
+                    defaultKey = defaultKey[0];
+                }
+                if (!defaultKey) {
+                    return undefined;
+                }
+                const data = layout.dataset.collectedValues[defaultKey + '_align']
+                    ? layout.dataset.collectedValues[defaultKey + '_align']
+                    : layout.dataset.collectedValues[defaultKey];
+                const index = layout.getRecordIndexByRow(row);
+                const range = data[layout.getRowKeysPath()[index][Math.max(0, layout.rowHeaderLevelCount - 1 - layout.leftAxesCount)]];
+                const axisOption = getAxisOption(col, row, 'right', layout);
+                if (axisOption?.visible === false) {
+                    return;
+                }
+                return merge$2({}, axisOption, {
+                    orient: 'right',
+                    type: 'linear',
+                    range: range,
+                    label: {
+                        flush: true
+                    },
+                    title: {
+                        visible: false
+                    }
+                });
+            }
+            else if (row === layout.rowCount - layout.bottomFrozenRowCount &&
+                col >= layout.rowHeaderLevelCount &&
+                col < layout.colCount - layout.rightFrozenColCount) {
+                let columnDimensionKey = layout.getDimensionKeyInChartSpec(col, layout.columnHeaderLevelCount)[0];
+                if (isArray$3(columnDimensionKey)) {
+                    columnDimensionKey = columnDimensionKey[0];
+                }
+                const data = layout.dataset.collectedValues[columnDimensionKey];
+                const recordCol = layout.getRecordIndexByCol(col);
+                const colPath = layout.getColKeysPath()[recordCol];
+                const domain = data[colPath[colPath.length - 1]];
+                const axisOption = getAxisOption(col, row, 'bottom', layout);
+                if (axisOption?.visible === false) {
+                    return;
+                }
+                return merge$2({}, axisOption, {
+                    orient: 'bottom',
+                    type: 'band',
+                    data: Array.from(domain),
+                    title: {
+                        visible: false
+                    }
+                });
+            }
+        }
+        return undefined;
+    }
+    function getAxisOption(col, row, orient, layout) {
+        const spec = layout.getRawChartSpec(col, row);
+        if (spec && isArray$3(spec.axes)) {
+            const axisOption = spec.axes.find((axis) => {
+                return axis.orient === orient;
+            });
+            if (axisOption) {
+                return axisOption;
+            }
+        }
+        const axisOption = layout._table.pivotChartAxes.find(axisOption => {
+            return axisOption.orient === orient;
+        });
+        return axisOption;
+    }
+
     function getRawChartSpec(col, row, layout) {
         const paths = layout.getCellHeaderPaths(col, row);
         let indicatorObj;
@@ -53539,16 +53772,15 @@
                     ? layout.dataset.collectedValues[key + '_align']
                     : layout.dataset.collectedValues[key];
                 const range = data[layout.getColKeysPath()[colIndex][Math.max(0, layout.columnHeaderLevelCount - 1 - layout.topAxesCount)]];
-                const axisOption = layout._table.pivotChartAxes.find(axisOption => {
-                    return axisOption.orient === (index === 0 ? 'bottom' : 'top');
-                });
+                const axisOption = getAxisOption(col, row, index === 0 ? 'bottom' : 'top', layout);
                 axes.push(merge$2({}, axisOption, {
                     type: 'linear',
                     orient: index === 0 ? 'bottom' : 'top',
                     label: { visible: false },
                     title: { visible: false },
                     range,
-                    seriesIndex: index
+                    seriesIndex: index,
+                    height: -1
                 }));
             });
             let rowDimensionKey = layout.getDimensionKeyInChartSpec(layout.rowHeaderLevelCount, col)[0];
@@ -53559,9 +53791,7 @@
             const recordRow = layout.getRecordIndexByRow(row);
             const rowPath = layout.getRowKeysPath()[recordRow];
             const domain = data[rowPath[rowPath.length - 1]];
-            const axisOption = layout._table.pivotChartAxes.find(axisOption => {
-                return axisOption.orient === 'left';
-            });
+            const axisOption = getAxisOption(col, row, 'left', layout);
             axes.push(merge$2({}, axisOption, {
                 type: 'band',
                 orient: 'left',
@@ -53585,16 +53815,15 @@
                     ? layout.dataset.collectedValues[key + '_align']
                     : layout.dataset.collectedValues[key];
                 const range = data[layout.getRowKeysPath()[rowIndex][Math.max(0, layout.rowHeaderLevelCount - 1 - layout.leftAxesCount)]];
-                const axisOption = layout._table.pivotChartAxes.find(axisOption => {
-                    return axisOption.orient === (index === 0 ? 'left' : 'right');
-                });
+                const axisOption = getAxisOption(col, row, index === 0 ? 'left' : 'right', layout);
                 axes.push(merge$2({}, axisOption, {
                     type: 'linear',
                     orient: index === 0 ? 'left' : 'right',
                     label: { visible: false },
                     title: { visible: false },
                     range,
-                    seriesIndex: index
+                    seriesIndex: index,
+                    width: -1
                 }));
             });
             let columnDimensionKey = layout.getDimensionKeyInChartSpec(col, layout.columnHeaderLevelCount)[0];
@@ -53605,9 +53834,7 @@
             const recordCol = layout.getRecordIndexByCol(col);
             const colPath = layout.getColKeysPath()[recordCol];
             const domain = data[colPath[colPath.length - 1]];
-            const axisOption = layout._table.pivotChartAxes.find(axisOption => {
-                return axisOption.orient === 'bottom';
-            });
+            const axisOption = getAxisOption(col, row, 'bottom', layout);
             axes.push(merge$2({}, axisOption, {
                 type: 'band',
                 orient: 'bottom',
@@ -54415,7 +54642,6 @@
                 internalProps.disposables.forEach(disposable => disposable?.dispose?.());
                 internalProps.disposables = null;
             }
-            this._updateSize();
             if (options.dataSource) {
                 _setDataSource(this, options.dataSource);
             }
@@ -54526,8 +54752,8 @@
         }
         getCellAddress(findTargetRecord, field) {
             let targetRecordIndex;
-            for (let i = 0; i < this.records.length; i++) {
-                const record = this.records[i];
+            for (let i = 0; i < this.internalProps.records.length; i++) {
+                const record = this.internalProps.records[i];
                 if (typeof findTargetRecord === 'function') {
                     if (findTargetRecord(record)) {
                         targetRecordIndex = i;
@@ -56196,216 +56422,6 @@
         }
     }
 
-    function getAxisConfigInPivotChart(col, row, layout) {
-        if (!layout._table.isPivotChart()) {
-            return undefined;
-        }
-        if (layout.indicatorsAsCol) {
-            if (layout.hasTwoIndicatorAxes &&
-                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$3(defaultKey)) {
-                    defaultKey = defaultKey[0];
-                }
-                if (!defaultKey) {
-                    return undefined;
-                }
-                const data = layout.dataset.collectedValues[defaultKey + '_align']
-                    ? layout.dataset.collectedValues[defaultKey + '_align']
-                    : layout.dataset.collectedValues[defaultKey];
-                const index = layout.getRecordIndexByCol(col);
-                const range = data[layout.getColKeysPath()[index][Math.max(0, layout.columnHeaderLevelCount - 1 - layout.topAxesCount)]];
-                const axisOption = layout._table.pivotChartAxes.find(axisOption => {
-                    return axisOption.orient === 'top';
-                });
-                if (axisOption?.visible === false) {
-                    return;
-                }
-                return merge$2({}, axisOption, {
-                    orient: 'top',
-                    type: 'linear',
-                    range: range,
-                    label: {
-                        flush: true
-                    },
-                    title: {
-                        visible: false
-                    }
-                });
-            }
-            else if (row === layout.rowCount - layout.bottomFrozenRowCount &&
-                col >= layout.rowHeaderLevelCount &&
-                col < layout.colCount - layout.rightFrozenColCount) {
-                const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
-                let defaultKey = indicatorKeys[0];
-                if (isArray$3(defaultKey)) {
-                    defaultKey = defaultKey[0];
-                }
-                const data = layout.dataset.collectedValues[defaultKey + '_align']
-                    ? layout.dataset.collectedValues[defaultKey + '_align']
-                    : layout.dataset.collectedValues[defaultKey];
-                const index = layout.getRecordIndexByCol(col);
-                const range = data[layout.getColKeysPath()[index][Math.max(0, layout.columnHeaderLevelCount - 1 - layout.topAxesCount)]];
-                let indicatorInfo = null;
-                indicatorKeys.forEach(key => {
-                    const info = layout.getIndicatorInfo(key);
-                    if (info) {
-                        indicatorInfo = info;
-                    }
-                });
-                const axisOption = layout._table.pivotChartAxes.find(axisOption => {
-                    return axisOption.orient === 'bottom';
-                });
-                if (axisOption?.visible === false) {
-                    return;
-                }
-                return merge$2({}, axisOption, {
-                    orient: 'bottom',
-                    type: 'linear',
-                    range: range,
-                    label: {
-                        flush: true
-                    },
-                    title: {
-                        text: indicatorInfo?.caption,
-                        autoRotate: true
-                    }
-                });
-            }
-            else if (col === layout.rowHeaderLevelCount - 1 &&
-                row >= layout.rowHeaderLevelCount &&
-                row < layout.rowCount - layout.bottomFrozenRowCount) {
-                let rowDimensionKey = layout.getDimensionKeyInChartSpec(layout.rowHeaderLevelCount, row)[0];
-                if (isArray$3(rowDimensionKey)) {
-                    rowDimensionKey = rowDimensionKey[0];
-                }
-                const data = layout.dataset.collectedValues[rowDimensionKey];
-                const recordRow = layout.getRecordIndexByRow(row);
-                const rowPath = layout.getRowKeysPath()[recordRow];
-                const domain = data[rowPath[rowPath.length - 1]];
-                const axisOption = layout._table.pivotChartAxes.find(axisOption => {
-                    return axisOption.orient === 'left';
-                });
-                if (axisOption?.visible === false) {
-                    return;
-                }
-                return merge$2({}, axisOption, {
-                    orient: 'left',
-                    type: 'band',
-                    data: Array.from(domain).reverse(),
-                    title: {
-                        visible: false
-                    }
-                });
-            }
-        }
-        else {
-            if (col === layout.rowHeaderLevelCount - 1 &&
-                row >= layout.columnHeaderLevelCount &&
-                row < layout.rowCount - layout.bottomFrozenRowCount) {
-                const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
-                let defaultKey = indicatorKeys[0];
-                if (isArray$3(defaultKey)) {
-                    defaultKey = defaultKey[0];
-                }
-                const data = layout.dataset.collectedValues[defaultKey + '_align']
-                    ? layout.dataset.collectedValues[defaultKey + '_align']
-                    : layout.dataset.collectedValues[defaultKey];
-                const index = layout.getRecordIndexByRow(row);
-                const range = data[layout.getRowKeysPath()[index][Math.max(0, layout.rowHeaderLevelCount - 1 - layout.leftAxesCount)]];
-                let indicatorInfo = null;
-                indicatorKeys.forEach(key => {
-                    const info = layout.getIndicatorInfo(key);
-                    if (info) {
-                        indicatorInfo = info;
-                    }
-                });
-                const axisOption = layout._table.pivotChartAxes.find(axisOption => {
-                    return axisOption.orient === 'left';
-                });
-                if (axisOption?.visible === false) {
-                    return;
-                }
-                return merge$2({}, axisOption, {
-                    orient: 'left',
-                    type: 'linear',
-                    range: range,
-                    label: {
-                        flush: true
-                    },
-                    title: {
-                        text: indicatorInfo?.caption,
-                        autoRotate: true
-                    }
-                });
-            }
-            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$3(defaultKey)) {
-                    defaultKey = defaultKey[0];
-                }
-                if (!defaultKey) {
-                    return undefined;
-                }
-                const data = layout.dataset.collectedValues[defaultKey + '_align']
-                    ? layout.dataset.collectedValues[defaultKey + '_align']
-                    : layout.dataset.collectedValues[defaultKey];
-                const index = layout.getRecordIndexByRow(row);
-                const range = data[layout.getRowKeysPath()[index][Math.max(0, layout.rowHeaderLevelCount - 1 - layout.leftAxesCount)]];
-                const axisOption = layout._table.pivotChartAxes.find(axisOption => {
-                    return axisOption.orient === 'right';
-                });
-                if (axisOption?.visible === false) {
-                    return;
-                }
-                return merge$2({}, axisOption, {
-                    orient: 'right',
-                    type: 'linear',
-                    range: range,
-                    label: {
-                        flush: true
-                    },
-                    title: {
-                        visible: false
-                    }
-                });
-            }
-            else if (row === layout.rowCount - layout.bottomFrozenRowCount &&
-                col >= layout.rowHeaderLevelCount &&
-                col < layout.colCount - layout.rightFrozenColCount) {
-                let columnDimensionKey = layout.getDimensionKeyInChartSpec(col, layout.columnHeaderLevelCount)[0];
-                if (isArray$3(columnDimensionKey)) {
-                    columnDimensionKey = columnDimensionKey[0];
-                }
-                const data = layout.dataset.collectedValues[columnDimensionKey];
-                const recordCol = layout.getRecordIndexByCol(col);
-                const colPath = layout.getColKeysPath()[recordCol];
-                const domain = data[colPath[colPath.length - 1]];
-                const axisOption = layout._table.pivotChartAxes.find(axisOption => {
-                    return axisOption.orient === 'bottom';
-                });
-                if (axisOption?.visible === false) {
-                    return;
-                }
-                return merge$2({}, axisOption, {
-                    orient: 'bottom',
-                    type: 'band',
-                    data: Array.from(domain),
-                    title: {
-                        visible: false
-                    }
-                });
-            }
-        }
-        return undefined;
-    }
-
     const EMPTY_HEADER = {
         isEmpty: true,
         id: undefined,
@@ -57530,6 +57546,23 @@
             const barWidth = this._chartItemSpanSize || 25;
             return (collectedValues?.length ?? 0) * (barWidth + barWidth / 3);
         }
+        getOptimunHeightForChart(row) {
+            const path = this.getCellHeaderPaths(this.rowHeaderLevelCount, row).rowHeaderPaths;
+            let collectedValues;
+            for (const key in this.dataset.collectValuesBy) {
+                if (this.dataset.collectValuesBy[key].type === 'yField' && !this.dataset.collectValuesBy[key].range) {
+                    collectedValues =
+                        this.dataset.collectedValues[key][path
+                            .map(pathObj => {
+                            return pathObj.value;
+                        })
+                            .join(this.dataset.stringJoinChar)];
+                    break;
+                }
+            }
+            const barWidth = this._chartItemSpanSize || 25;
+            return (collectedValues?.length ?? 0) * (barWidth + barWidth / 3);
+        }
         getIndicatorKeyInChartSpec(_col, _row) {
             const chartSpec = this.getRawChartSpec(_col, _row);
             const indicatorKeys = [];
@@ -58310,7 +58343,7 @@
             if (records) {
                 this.records = records;
                 const t0 = typeof window !== 'undefined' ? window.performance.now() : 0;
-                this.setRecords(records);
+                this.setRecords();
                 this.processCollectedValuesWithSumBy();
                 this.processCollectedValuesWithSortBy();
                 const t1 = typeof window !== 'undefined' ? window.performance.now() : 0;
@@ -58355,7 +58388,7 @@
             this.registerAggregator(AggregationType.MIN, MinAggregator);
             this.registerAggregator(AggregationType.AVG, AvgAggregator);
         }
-        setRecords(records) {
+        setRecords() {
             this.processRecords();
         }
         processCollectedValuesWithSumBy() {
@@ -58389,10 +58422,22 @@
             if (this.dataConfig?.filterRules?.length >= 1) {
                 isNeedFilter = true;
             }
-            for (let i = 0, len = this.records.length; i < len; i++) {
-                const record = this.records[i];
-                if (!isNeedFilter || this.filterRecord(record)) {
-                    this.processRecord(record);
+            if (Array.isArray(this.records)) {
+                for (let i = 0, len = this.records.length; i < len; i++) {
+                    const record = this.records[i];
+                    if (!isNeedFilter || this.filterRecord(record)) {
+                        this.processRecord(record);
+                    }
+                }
+            }
+            else {
+                for (const key in this.records) {
+                    for (let i = 0, len = this.records[key].length; i < len; i++) {
+                        const record = this.records[key][i];
+                        if (!isNeedFilter || this.filterRecord(record)) {
+                            this.processRecord(record, key);
+                        }
+                    }
                 }
             }
             this.rowFlatKeys = {};
@@ -58416,7 +58461,7 @@
             }
             return isReserved;
         }
-        processRecord(record) {
+        processRecord(record, assignedIndicatorKey) {
             this.derivedFieldRules?.forEach((derivedFieldRule, i) => {
                 record[derivedFieldRule.fieldName] = derivedFieldRule.derivedFunc(record);
             });
@@ -58496,7 +58541,10 @@
                     if (!this.tree[flatRowKey]?.[flatColKey]?.[i]) {
                         this.tree[flatRowKey][flatColKey][i] = new this.aggregators[aggRule?.aggregationType ?? AggregationType.SUM](aggRule?.field ?? this.indicatorKeys[i], aggRule?.formatFun);
                     }
-                    if (aggRule?.field) {
+                    if (assignedIndicatorKey) {
+                        this.indicatorKeys[i] === assignedIndicatorKey && this.tree[flatRowKey]?.[flatColKey]?.[i].push(record);
+                    }
+                    else if (aggRule?.field) {
                         if (typeof aggRule?.field === 'string') {
                             isValid$1(record[aggRule?.field]) && this.tree[flatRowKey]?.[flatColKey]?.[i].push(record);
                         }
@@ -59099,7 +59147,6 @@
                 internalProps.disposables.forEach(disposable => disposable?.dispose?.());
                 internalProps.disposables = null;
             }
-            this._updateSize();
             if (options.dataSource) {
                 _setDataSource(this, options.dataSource);
             }
@@ -59321,10 +59368,10 @@
             if (moveContext) {
                 if (moveContext.moveType === 'column') {
                     if (this.options.records?.[0]?.constructor === Array) {
-                        for (let row = 0; row < this.records.length; row++) {
-                            const sourceColumns = this.records[row].splice(moveContext.sourceIndex - this.rowHeaderLevelCount, moveContext.moveSize);
+                        for (let row = 0; row < this.internalProps.records.length; row++) {
+                            const sourceColumns = this.internalProps.records[row].splice(moveContext.sourceIndex - this.rowHeaderLevelCount, moveContext.moveSize);
                             sourceColumns.unshift(moveContext.targetIndex - this.rowHeaderLevelCount, 0);
-                            Array.prototype.splice.apply(this.records[row], sourceColumns);
+                            Array.prototype.splice.apply(this.internalProps.records[row], sourceColumns);
                         }
                     }
                     this.colWidthsMap.adjustOrder(moveContext.sourceIndex, moveContext.targetIndex, moveContext.moveSize);
@@ -59340,9 +59387,9 @@
                 }
                 else if (moveContext.moveType === 'row') {
                     if (this.options.records?.[0]?.constructor === Array) {
-                        const sourceRows = this.records.splice(moveContext.sourceIndex - this.columnHeaderLevelCount, moveContext.moveSize);
+                        const sourceRows = this.internalProps.records.splice(moveContext.sourceIndex - this.columnHeaderLevelCount, moveContext.moveSize);
                         sourceRows.unshift(moveContext.targetIndex - this.columnHeaderLevelCount, 0);
-                        Array.prototype.splice.apply(this.records, sourceRows);
+                        Array.prototype.splice.apply(this.internalProps.records, sourceRows);
                     }
                     this.rowHeightsMap.adjustOrder(moveContext.sourceIndex, moveContext.targetIndex, moveContext.moveSize);
                 }
@@ -59424,9 +59471,8 @@
             }
             this.setCustomStateNameToSpec();
             this.internalProps.dataConfig = { isPivotChart: true };
-            this.internalProps.enableDataAnalysis = true;
             this._axes = isArray$3(options.axes) ? options.axes : [];
-            if (this.internalProps.enableDataAnalysis && (options.rows || options.columns)) {
+            if (options.rows || options.columns) {
                 const rowKeys = options.rows.reduce((keys, rowObj) => {
                     if (typeof rowObj === 'string') {
                         keys.push(rowObj);
@@ -59502,8 +59548,7 @@
             super.updateOption(options);
             this.setCustomStateNameToSpec();
             internalProps.dataConfig = {};
-            this.internalProps.enableDataAnalysis = true;
-            if (this.internalProps.enableDataAnalysis && (options.rows || options.columns)) {
+            if (options.rows || options.columns) {
                 const rowKeys = options.rows.reduce((keys, rowObj) => {
                     if (typeof rowObj === 'string') {
                         keys.push(rowObj);
@@ -59540,7 +59585,6 @@
                 internalProps.disposables.forEach(disposable => disposable?.dispose?.());
                 internalProps.disposables = null;
             }
-            this._updateSize();
             if (options.dataSource) {
                 _setDataSource(this, options.dataSource);
             }
@@ -59561,9 +59605,7 @@
             if (internalProps.headerEvents) {
                 internalProps.headerEvents.forEach((id) => this.unlisten(id));
             }
-            if (this.internalProps.enableDataAnalysis) {
-                internalProps.layoutMap = new PivotLayoutMap(this, this.dataset);
-            }
+            internalProps.layoutMap = new PivotLayoutMap(this, this.dataset);
             for (let col = 0; col < internalProps.layoutMap.columnWidths.length; col++) {
                 const { width, minWidth, maxWidth } = internalProps.layoutMap.columnWidths?.[col] ?? {};
                 if (width && ((typeof width === 'string' && width !== 'auto') || (typeof width === 'number' && width > 0))) {
@@ -59708,10 +59750,10 @@
             if (moveContext) {
                 if (moveContext.moveType === 'column') {
                     if (this.options.records?.[0]?.constructor === Array) {
-                        for (let row = 0; row < this.records.length; row++) {
-                            const sourceColumns = this.records[row].splice(moveContext.sourceIndex - this.rowHeaderLevelCount, moveContext.moveSize);
+                        for (let row = 0; row < this.internalProps.records.length; row++) {
+                            const sourceColumns = this.internalProps.records[row].splice(moveContext.sourceIndex - this.rowHeaderLevelCount, moveContext.moveSize);
                             sourceColumns.unshift(moveContext.targetIndex - this.rowHeaderLevelCount, 0);
-                            Array.prototype.splice.apply(this.records[row], sourceColumns);
+                            Array.prototype.splice.apply(this.internalProps.records[row], sourceColumns);
                         }
                     }
                     this.colWidthsMap.adjustOrder(moveContext.sourceIndex, moveContext.targetIndex, moveContext.moveSize);
@@ -59727,9 +59769,9 @@
                 }
                 else if (moveContext.moveType === 'row') {
                     if (this.options.records?.[0]?.constructor === Array) {
-                        const sourceRows = this.records.splice(moveContext.sourceIndex - this.columnHeaderLevelCount, moveContext.moveSize);
+                        const sourceRows = this.internalProps.records.splice(moveContext.sourceIndex - this.columnHeaderLevelCount, moveContext.moveSize);
                         sourceRows.unshift(moveContext.targetIndex - this.columnHeaderLevelCount, 0);
-                        Array.prototype.splice.apply(this.records, sourceRows);
+                        Array.prototype.splice.apply(this.internalProps.records, sourceRows);
                     }
                     this.rowHeightsMap.adjustOrder(moveContext.sourceIndex, moveContext.targetIndex, moveContext.moveSize);
                 }
@@ -59940,9 +59982,12 @@
                         });
                     }
                     else {
+                        const field = this.options.indicatorsAsCol === false
+                            ? indicator.chartSpec.yField
+                            : indicator.chartSpec.xField;
                         aggregationRules.push({
                             indicatorKey: indicator.indicatorKey,
-                            field: indicator.indicatorKey,
+                            field: field ?? indicator.indicatorKey,
                             aggregationType: AggregationType.RECORD
                         });
                     }
@@ -60029,7 +60074,8 @@
             const chartNode = cellGroup?.getChildren()?.[0];
             if (chartNode.attribute.chartInstance) {
                 const chartInstance = chartNode.attribute.chartInstance;
-                const { dataId, data, viewBox, axes } = chartNode.attribute;
+                const { dataId, data, axes } = chartNode.attribute;
+                const viewBox = chartNode.getViewBox();
                 axes.forEach((axis, index) => {
                     if (axis.type === 'linear') {
                         const chartAxis = chartInstance._chart._components[index];
@@ -60686,7 +60732,7 @@
         percentCalc: percentCalc
     });
 
-    const version = "0.9.3-alpha.3";
+    const version = "0.9.3-alpha.4";
     function getIcons() {
         return get$1();
     }