@visactor/vtable 1.22.2 → 1.22.3

package/dist/vtable.js

@@ -39102,7 +39102,7 @@
                 }, 0);
             });
             this.currentIndexedData = sortedIndexArray;
-            if (this.hierarchyExpandLevel) {
+            if (this.hierarchyExpandLevel && this.rowHierarchyType === 'tree') {
                 let nodeLength = sortedIndexArray.length;
                 for (let i = 0; i < nodeLength; i++) {
                     const record = this.getOriginalRecord(sortedIndexArray[i]);
@@ -45337,7 +45337,7 @@
         }
         if (!addNew && oldCellGroup.parent) {
             if (table.reactCustomLayout) {
-                const reactGroup = oldCellGroup.getChildByName('custom-container');
+                const reactGroup = oldCellGroup.getChildByName(CUSTOM_CONTAINER_NAME);
                 if (reactGroup) {
                     const { col, row } = reactGroup;
                     if (isNumber$4(col) && isNumber$4(row)) {
@@ -45853,7 +45853,6 @@
         textConfig: []
     });
     function computeRowsHeight(table, rowStart, rowEnd, isClearRowRangeHeightsMap = true, update) {
-        typeof window !== 'undefined' ? window.performance.now() : 0;
         const oldRowHeights = [];
         const newHeights = [];
         if (update) {
@@ -45913,6 +45912,7 @@
                 if (!(table.internalProps.transpose ||
                     (table.isPivotTable() && !table.internalProps.layoutMap.indicatorsAsCol)) &&
                     !table.options.customComputeRowHeight &&
+                    !table.options.rowHeightConfig &&
                     checkFixedStyleAndNoWrap(table, rowStart)) {
                     const height = computeRowHeight(table.columnHeaderLevelCount, 0, table.colCount - 1, table);
                     fillRowsHeight(height, table.columnHeaderLevelCount, table.rowCount - 1 - table.bottomFrozenRowCount, table, update ? newHeights : undefined);
@@ -46106,6 +46106,16 @@
                 return table.getDefaultRowHeight(row);
             }
         }
+        if (table.internalProps.rowHeightConfig) {
+            const rowHeightConfig = table.internalProps.rowHeightConfig.find((item) => item.key === row);
+            if (rowHeightConfig) {
+                if (!table.internalProps._heightResizedRowMap.has(row)) {
+                    table._setRowHeight(row, rowHeightConfig.height);
+                    table.internalProps._heightResizedRowMap.add(row);
+                }
+                return rowHeightConfig.height;
+            }
+        }
         if (table.isPivotChart() &&
             row >= table.columnHeaderLevelCount &&
             row < table.rowCount - table.bottomFrozenRowCount) {
@@ -50238,7 +50248,7 @@
         order = 0;
         drawShape(rect, context, x, y, doFill, doStroke, fVisible, sVisible, rectAttribute, drawContext, fillCb, strokeCb) {
             const { width = rectAttribute.width, height = rectAttribute.height, stroke = rectAttribute.stroke, strokeArrayColor = rectAttribute.strokeArrayColor, strokeArrayWidth = rectAttribute.strokeArrayWidth, lineWidth = rectAttribute.lineWidth, strokeColor = rectAttribute.stroke, cornerRadius = rectAttribute.cornerRadius } = rect.attribute;
-            if (!stroke || (!Array.isArray(strokeArrayWidth) && lineWidth === 0)) {
+            if (!stroke || (!Array.isArray(strokeArrayWidth) && lineWidth === 0) || width <= 0 || height <= 0) {
                 return;
             }
             if (Array.isArray(stroke) || Array.isArray(strokeArrayColor) || Array.isArray(strokeArrayWidth)) {
@@ -58688,10 +58698,11 @@
 
     function adjustMoveHeaderTarget(source, target, table) {
         const sourceCellRange = table.getCellRange(source.col, source.row);
-        if (table.isColumnHeader(source.col, source.row)) {
+        if (table.isColumnHeader(source.col, source.row) ||
+            (table.stateManager.columnMove.movingColumnOrRow === 'column' && source.row === 0)) {
             const targetCellRange = table.getCellRange(target.col, sourceCellRange.start.row);
             if (target.row >= table.columnHeaderLevelCount) {
-                target.row = table.columnHeaderLevelCount - 1;
+                target.row = Math.max(table.columnHeaderLevelCount - 1, 0);
             }
             if (target.col >= source.col) {
                 target.col = targetCellRange.end.col;
@@ -58732,6 +58743,109 @@
         }
         return target;
     }
+    function adjustWidthResizedColMap(moveContext, table) {
+        if (table.internalProps._widthResizedColMap.size > 0) {
+            const resizedColIndexs = Array.from(table.internalProps._widthResizedColMap.keys());
+            table.internalProps._widthResizedColMap.clear();
+            for (let i = 0; i < resizedColIndexs.length; i++) {
+                const colIndex = resizedColIndexs[i];
+                let newColIndex;
+                const { sourceIndex, targetIndex, sourceSize } = moveContext;
+                if (colIndex >= sourceIndex && colIndex < sourceIndex + sourceSize) {
+                    newColIndex = targetIndex + (colIndex - sourceIndex);
+                }
+                else if (sourceIndex < targetIndex) {
+                    if (colIndex >= sourceIndex + sourceSize && colIndex < targetIndex) {
+                        newColIndex = colIndex - sourceSize;
+                    }
+                    else if (colIndex >= targetIndex) {
+                        newColIndex = colIndex - sourceSize;
+                    }
+                    else {
+                        newColIndex = colIndex;
+                    }
+                }
+                else {
+                    if (colIndex >= targetIndex && colIndex < sourceIndex) {
+                        newColIndex = colIndex + sourceSize;
+                    }
+                    else if (colIndex >= sourceIndex + sourceSize) {
+                        newColIndex = colIndex;
+                    }
+                    else {
+                        newColIndex = colIndex;
+                    }
+                }
+                table.internalProps._widthResizedColMap.add(newColIndex);
+            }
+        }
+    }
+    function adjustHeightResizedRowMap(moveContext, table) {
+        if (table.internalProps._heightResizedRowMap.size > 0) {
+            const resizedRowIndexs = Array.from(table.internalProps._heightResizedRowMap.keys());
+            table.internalProps._heightResizedRowMap.clear();
+            for (let i = 0; i < resizedRowIndexs.length; i++) {
+                const rowIndex = resizedRowIndexs[i];
+                let newRowIndex;
+                const { sourceIndex, targetIndex, sourceSize } = moveContext;
+                if (rowIndex >= sourceIndex && rowIndex < sourceIndex + sourceSize) {
+                    newRowIndex = targetIndex + (rowIndex - sourceIndex);
+                }
+                else if (sourceIndex < targetIndex) {
+                    if (rowIndex >= sourceIndex + sourceSize && rowIndex < targetIndex) {
+                        newRowIndex = rowIndex - sourceSize;
+                    }
+                    else if (rowIndex >= targetIndex) {
+                        newRowIndex = rowIndex - sourceSize;
+                    }
+                    else {
+                        newRowIndex = rowIndex;
+                    }
+                }
+                else {
+                    if (rowIndex >= targetIndex && rowIndex < sourceIndex) {
+                        newRowIndex = rowIndex + sourceSize;
+                    }
+                    else if (rowIndex >= sourceIndex + sourceSize) {
+                        newRowIndex = rowIndex;
+                    }
+                    else {
+                        newRowIndex = rowIndex;
+                    }
+                }
+                table.internalProps._heightResizedRowMap.add(newRowIndex);
+            }
+        }
+    }
+    function adjustHeightResizedRowMapWithAddRecordIndex(table, recordIndex, records) {
+        const resizedRowIndexs = Array.from(table.internalProps._heightResizedRowMap.keys());
+        const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
+        const rowIndex = recordIndex + headerCount;
+        for (let i = 0; i < resizedRowIndexs.length; i++) {
+            if (resizedRowIndexs[i] >= rowIndex) {
+                table.internalProps._heightResizedRowMap.delete(resizedRowIndexs[i]);
+                table.internalProps._heightResizedRowMap.add(resizedRowIndexs[i] + records.length);
+            }
+        }
+    }
+    function adjustHeightResizedRowMapWithDeleteRecordIndex(table, recordIndexs) {
+        const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
+        recordIndexs.sort((a, b) => b - a);
+        for (let i = 0; i < recordIndexs.length; i++) {
+            const rowIndex = recordIndexs[i] + headerCount;
+            const resizedRowIndexs = Array.from(table.internalProps._heightResizedRowMap.keys());
+            for (let j = 0; j < resizedRowIndexs.length; j++) {
+                if (resizedRowIndexs[j] === rowIndex) {
+                    table.internalProps._heightResizedRowMap.delete(resizedRowIndexs[j]);
+                }
+                else if (resizedRowIndexs[j] > rowIndex) {
+                    table.internalProps._heightResizedRowMap.delete(resizedRowIndexs[j]);
+                    table.internalProps._heightResizedRowMap.add(resizedRowIndexs[j] - 1);
+                }
+                else ;
+            }
+        }
+    }
 
     function startMoveCol(col, row, x, y, state, event, dragColumnOrRow) {
         if (!('canMoveHeaderPosition' in state.table.internalProps.layoutMap)) {
@@ -58812,7 +58926,8 @@
             let lineY;
             let backY;
             const cellLocation = state.table.getCellLocation(state.columnMove.colSource, state.columnMove.rowSource);
-            if (cellLocation === 'columnHeader') {
+            if (cellLocation === 'columnHeader' ||
+                (state.columnMove.movingColumnOrRow === 'column' && state.columnMove.rowSource === 0)) {
                 backX = state.columnMove.x;
                 if (state.table.isLeftFrozenColumn(col)) {
                     lineX =
@@ -61491,7 +61606,8 @@
         }
         isWheelEvent && state.resetInteractionState(state.interactionStateBeforeScroll);
         if (event.nativeEvent?.cancelable &&
-            (state.table.internalProps.overscrollBehavior === 'none' ||
+            ((state.table.internalProps.overscrollBehavior === 'none' &&
+                ((deltaY && isVerticalExistScrollBar(state)) || (deltaX && isHorizontalExistScrollBar(state)))) ||
                 (Math.abs(deltaY) >= Math.abs(deltaX) && deltaY !== 0 && isVerticalScrollable(deltaY, state)) ||
                 (Math.abs(deltaY) <= Math.abs(deltaX) && deltaX !== 0 && isHorizontalScrollable(deltaX, state)))) {
             event.nativeEvent.preventDefault();
@@ -61518,6 +61634,20 @@
         }
         return !isScrollToLeft(deltaX, state) && !isScrollToRight(deltaX, state);
     }
+    function isVerticalExistScrollBar(state) {
+        const totalHeight = state.table.getAllRowsHeight() - state.table.scenegraph.height;
+        if (totalHeight <= 0) {
+            return false;
+        }
+        return true;
+    }
+    function isHorizontalExistScrollBar(state) {
+        const totalWidth = state.table.getAllColsWidth() - state.table.scenegraph.width;
+        if (totalWidth <= 0) {
+            return false;
+        }
+        return true;
+    }
     function isScrollToTop(deltaY, state) {
         const totalHeight = state.table.getAllRowsHeight() - state.table.scenegraph.height;
         return totalHeight !== 0 && deltaY <= 0 && state.scroll.verticalBarPos < 1;
@@ -63183,7 +63313,9 @@
                         eventManager.touchMovePoints[eventManager.touchMovePoints.length - 2].y;
                     handleWhell({ deltaX, deltaY }, stateManager);
                     if (e.cancelable &&
-                        (table.internalProps.overscrollBehavior === 'none' ||
+                        ((table.internalProps.overscrollBehavior === 'none' &&
+                            ((deltaY && isVerticalExistScrollBar(stateManager)) ||
+                                (deltaX && isHorizontalExistScrollBar(stateManager)))) ||
                             (Math.abs(deltaY) >= Math.abs(deltaX) && deltaY !== 0 && isVerticalScrollable(deltaY, stateManager)) ||
                             (Math.abs(deltaY) <= Math.abs(deltaX) && deltaX !== 0 && isHorizontalScrollable(deltaX, stateManager)))) {
                         e.preventDefault();
@@ -68105,17 +68237,23 @@
                 const chartCellStyle = layout._table._getCellStyle(col, row - 1);
                 const padding = getQuadProps(getProp('padding', chartCellStyle, col, row - 1, layout._table));
                 const { range, ticks, axisOption, index, targetTicks, targetRange, theme } = axisRange;
+                if (isNumber$4(axisOption?.max)) {
+                    range.max = axisOption.max;
+                    if (range.max < 0) {
+                        axisOption.zero = false;
+                    }
+                }
+                else if (chartType === 'boxPlot') {
+                    range.max += (range.max - range.min) / 20;
+                }
                 if (isNumber$4(axisOption?.min)) {
                     range.min = axisOption.min;
                     if (range.min > 0) {
                         axisOption.zero = false;
                     }
                 }
-                if (isNumber$4(axisOption?.max)) {
-                    range.max = axisOption.max;
-                    if (range.max < 0) {
-                        axisOption.zero = false;
-                    }
+                else if (chartType === 'boxPlot') {
+                    range.min -= (range.max - range.min) / 20;
                 }
                 let domain = [];
                 if (chartType === 'heatmap') {
@@ -68197,17 +68335,23 @@
                 const chartCellStyle = layout._table._getCellStyle(col + 1, row);
                 const padding = getQuadProps(getProp('padding', chartCellStyle, col + 1, row, layout._table));
                 const { range, ticks, axisOption, index, targetTicks, targetRange, theme } = axisRange;
+                if (isNumber$4(axisOption?.max)) {
+                    range.max = axisOption.max;
+                    if (range.max < 0) {
+                        axisOption.zero = false;
+                    }
+                }
+                else if (chartType === 'boxPlot') {
+                    range.max += (range.max - range.min) / 20;
+                }
                 if (isNumber$4(axisOption?.min)) {
                     range.min = axisOption.min;
                     if (range.min > 0) {
                         axisOption.zero = false;
                     }
                 }
-                if (isNumber$4(axisOption?.max)) {
-                    range.max = axisOption.max;
-                    if (range.max < 0) {
-                        axisOption.zero = false;
-                    }
+                else if (chartType === 'boxPlot') {
+                    range.min -= (range.max - range.min) / 20;
                 }
                 let domain = [];
                 if (chartType === 'heatmap') {
@@ -68672,7 +68816,7 @@
         };
     }
     function getAxisRangeAndTicks(col, row, index, position, subAxisPosition, indicatorKeys, path, layout) {
-        const { range, isZeroAlign, isTickAlign, axisOption } = getChartAxisRange(col, row, index, position, indicatorKeys, path, layout);
+        const { range, isZeroAlign, isTickAlign, axisOption, chartType } = getChartAxisRange(col, row, index, position, indicatorKeys, path, layout);
         const { targetRange, targetTicks } = getTargetRangeAndTicks(col, row, index, isZeroAlign, isTickAlign, range, indicatorKeys, subAxisPosition, path, layout);
         if (index !== 0 && targetTicks) {
             const getAxisDomainRangeAndLabels = Factory.getFunction('getAxisDomainRangeAndLabels');
@@ -68689,7 +68833,8 @@
             axisOption,
             range,
             targetTicks,
-            targetRange
+            targetRange,
+            chartType
         };
     }
     function getTargetRangeAndTicks(col, row, index, isZeroAlign, isTickAlign, range, indicatorKeys, subAxisPosition, path, layout) {
@@ -69259,7 +69404,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.22.2";
+        version = "1.22.3";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -70304,6 +70449,9 @@
             else if (this.options.customComputeRowHeight) {
                 return true;
             }
+            else if (this.internalProps.rowHeightConfig) {
+                return true;
+            }
             else if (row >= 0 && row < this.columnHeaderLevelCount) {
                 return this.getDefaultRowHeight(row) === 'auto';
             }
@@ -74098,12 +74246,18 @@
             const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
             const colPath = layout.getColKeysPath(col, row);
             indicatorKeys.forEach((key, index) => {
-                const { range, targetTicks, targetRange, axisOption } = getAxisRangeAndTicks(col, row, index, index === 0 ? 'bottom' : 'top', index === 0 ? 'top' : 'bottom', indicatorKeys, colPath, layout);
+                const { range, targetTicks, targetRange, axisOption, chartType } = getAxisRangeAndTicks(col, row, index, index === 0 ? 'bottom' : 'top', index === 0 ? 'top' : 'bottom', indicatorKeys, colPath, layout);
+                if (isNumber$4(axisOption?.max)) {
+                    range.max = axisOption.max;
+                }
+                else if (chartType === 'boxPlot') {
+                    range.max += (range.max - range.min) / 20;
+                }
                 if (isNumber$4(axisOption?.min)) {
                     range.min = axisOption.min;
                 }
-                if (isNumber$4(axisOption?.max)) {
-                    range.max = axisOption.max;
+                else if (chartType === 'boxPlot') {
+                    range.min -= (range.max - range.min) / 20;
                 }
                 if (hasSameAxis(axisOption, axes)) {
                     return;
@@ -74153,16 +74307,22 @@
             const rowPath = layout.getRowKeysPath(col, row);
             indicatorKeys.forEach((key, index) => {
                 const { range, targetTicks, targetRange, axisOption } = getAxisRangeAndTicks(col, row, index, index === 0 ? 'left' : 'right', index === 0 ? 'right' : 'left', indicatorKeys, rowPath, layout);
+                const { chartType } = getAxisOption(col, row, index === 0 ? 'left' : 'right', layout);
+                if (isNumber$4(axisOption?.max)) {
+                    range.max = axisOption.max;
+                }
+                else if (chartType === 'boxPlot') {
+                    range.max += (range.max - range.min) / 20;
+                }
                 if (isNumber$4(axisOption?.min)) {
                     range.min = axisOption.min;
                 }
-                if (isNumber$4(axisOption?.max)) {
-                    range.max = axisOption.max;
+                else if (chartType === 'boxPlot') {
+                    range.min -= (range.max - range.min) / 20;
                 }
                 if (hasSameAxis(axisOption, axes)) {
                     return;
                 }
-                const { chartType } = getAxisOption(col, row, index === 0 ? 'left' : 'right', layout);
                 let domain = [];
                 if (chartType === 'heatmap') {
                     const rowDimensionKey = layout.getDimensionKeyInChartSpec(layout.rowHeaderLevelCount, row, 'yField');
@@ -75497,7 +75657,8 @@
                 }
             }
             const sourceCellRange = this.getCellRange(source.col, source.row);
-            if (this.isColumnHeader(source.col, source.row)) {
+            if (this.isColumnHeader(source.col, source.row) ||
+                (this._table.stateManager.columnMove.movingColumnOrRow === 'column' && source.row === 0)) {
                 const sourceTopId = this.getParentCellId(source.col, sourceCellRange.start.row);
                 const targetTopId = this.getParentCellId(target.col, sourceCellRange.start.row);
                 return sourceTopId === targetTopId;
@@ -75514,7 +75675,8 @@
                 this._table.options.dragOrder?.validateDragOrderOnEnd(source, target)) &&
                 this.canMoveHeaderPosition(source, target)) {
                 let sourceCellRange = this.getCellRange(source.col, source.row);
-                if (this.isColumnHeader(source.col, source.row)) {
+                if (this.isColumnHeader(source.col, source.row) ||
+                    (this._table.stateManager.columnMove.movingColumnOrRow === 'column' && source.row === 0)) {
                     const sourceSize = sourceCellRange.end.col - sourceCellRange.start.col + 1;
                     let targetIndex;
                     const targetCellRange = this.getCellRange(target.col, sourceCellRange.start.row);
@@ -75536,8 +75698,8 @@
                         for (let j = 0; j < this._table.dataSource.dataSourceObj?.records.length; j++) {
                             const rowRecords = this._table.dataSource.dataSourceObj?.records[j];
                             if (Array.isArray(rowRecords)) {
-                                if (rowRecords.length - 1 < targetIndex) {
-                                    rowRecords.push(...Array(targetIndex - rowRecords.length + 1).fill(undefined));
+                                if (rowRecords.length - 1 < Math.max(targetIndex, source.col)) {
+                                    rowRecords.push(...Array(Math.max(targetIndex, source.col) - rowRecords.length + 1).fill(undefined));
                                 }
                                 const sourceData = rowRecords.splice(sourceCellRange.start.col - this.leftRowSeriesNumberColumnCount, sourceSize);
                                 sourceData.unshift((targetIndex - this.leftRowSeriesNumberColumnCount), 0);
@@ -77000,6 +77162,7 @@
             this.internalProps.headerHelper.setTableColumnsEditor();
             this.showHeader = options.showHeader ?? true;
             this.internalProps.columnWidthConfig = options.columnWidthConfig;
+            this.internalProps.rowHeightConfig = options.rowHeightConfig;
             this.transpose = options.transpose ?? false;
             if (Env.mode !== 'node') {
                 this.editorManager = new EditManager(this);
@@ -77402,6 +77565,7 @@
             this.refreshHeader();
             this.internalProps.useOneRowHeightFillAll = false;
             this.internalProps.columnWidthConfig = options.columnWidthConfig;
+            this.internalProps.rowHeightConfig = options.rowHeightConfig;
             if (internalProps.releaseList) {
                 for (let i = internalProps.releaseList.length - 1; i >= 0; i--) {
                     const releaseObj = internalProps.releaseList[i];
@@ -77550,6 +77714,7 @@
             if (moveContext) {
                 if (moveContext.moveType === 'column') {
                     this.colWidthsMap.exchangeOrder(sourceCellRange.start.col, sourceCellRange.end.col - sourceCellRange.start.col + 1, targetCellRange.start.col, targetCellRange.end.col - targetCellRange.start.col + 1, moveContext.targetIndex);
+                    adjustWidthResizedColMap(moveContext, this);
                     if (!this.transpose) {
                         this.colWidthsLimit = {};
                         this.setMinMaxLimitWidth();
@@ -77562,6 +77727,7 @@
                     else {
                         this.rowHeightsMap.exchangeOrder(moveContext.sourceIndex, moveContext.sourceSize, moveContext.targetIndex, moveContext.targetSize, moveContext.targetIndex);
                     }
+                    adjustHeightResizedRowMap(moveContext, this);
                 }
                 return moveContext;
             }
@@ -77829,7 +77995,7 @@
                 this.stateManager.updateSortState(sortState);
             }
         }
-        updateFilterRules(filterRules) {
+        updateFilterRules(filterRules, options = { clearRowHeightCache: true }) {
             this.scenegraph.clearCells();
             if (this.sortState) {
                 this.dataSource.updateFilterRulesForSorted(filterRules);
@@ -77840,7 +78006,7 @@
             }
             this.refreshRowColCount();
             this.stateManager.initCheckedState(this.records);
-            this.scenegraph.createSceneGraph();
+            this.scenegraph.createSceneGraph(!!!options?.clearRowHeightCache);
             this.resize();
         }
         getFilteredRecords() {
@@ -78049,6 +78215,7 @@
         }
         addRecord(record, recordIndex) {
             const success = listTableAddRecord(record, recordIndex, this);
+            adjustHeightResizedRowMapWithAddRecordIndex(this, recordIndex, [record]);
             this.internalProps.emptyTip?.resetVisible();
             if (success) {
                 this.fireListeners(TABLE_EVENT_TYPE.ADD_RECORD, {
@@ -78060,6 +78227,9 @@
         }
         addRecords(records, recordIndex) {
             const success = listTableAddRecords(records, recordIndex, this);
+            if (typeof recordIndex === 'number') {
+                adjustHeightResizedRowMapWithAddRecordIndex(this, recordIndex, records);
+            }
             this.internalProps.emptyTip?.resetVisible();
             if (success) {
                 this.fireListeners(TABLE_EVENT_TYPE.ADD_RECORD, {
@@ -78071,6 +78241,7 @@
         }
         deleteRecords(recordIndexs) {
             listTableDeleteRecords(recordIndexs, this);
+            adjustHeightResizedRowMapWithDeleteRecordIndex(this, recordIndexs);
             this.internalProps.emptyTip?.resetVisible();
             const rowIndexs = [];
             for (let i = 0; i < recordIndexs.length; i++) {
@@ -86645,6 +86816,37 @@
             });
             return headerPaths;
         }
+        getCellRowHeaderFullPaths(col) {
+            const headerPaths = [];
+            if (this.rowHierarchyType === 'grid') {
+                for (let i = 0; i <= Math.min(this.rowsDefine.length - 1, col); i++) {
+                    const rowDefine = this.rowsDefine[i];
+                    if (typeof rowDefine === 'string') {
+                        headerPaths.push({
+                            dimensionKey: rowDefine
+                        });
+                    }
+                    else {
+                        headerPaths.push({
+                            dimensionKey: rowDefine.dimensionKey
+                        });
+                    }
+                }
+                if (col >= this.rowsDefine.length && this.indicatorsAsCol === false && this.indicatorsDefine.length > 0) {
+                    if (typeof this.indicatorsDefine[0] === 'string') {
+                        headerPaths.push({
+                            indicatorKey: this.indicatorsDefine[0]
+                        });
+                    }
+                    else {
+                        headerPaths.push({
+                            indicatorKey: this.indicatorsDefine[0].indicatorKey
+                        });
+                    }
+                }
+            }
+            return headerPaths;
+        }
         getIndicatorInfoByIndicatorKey(indicatorKey) {
             const indicatorInfo = this.indicatorsDefine?.find(indicator => {
                 if (typeof indicator === 'string') {
@@ -87425,7 +87627,17 @@
                 const { startInTotal, afterSpanLevel } = rowDimensionFinded ?? defaultDimension;
                 row += startInTotal ?? 0;
                 if (this.rowHierarchyType === 'grid') {
-                    defaultCol = (this.rowHeaderTitle ? afterSpanLevel + 1 : afterSpanLevel) + this.leftRowSeriesNumberColumnCount;
+                    const isMatch = rowHeaderPaths.every((path, index) => {
+                        return this.rowDimensionKeys[index] === path.dimensionKey;
+                    });
+                    if (isMatch) {
+                        const col = rowHeaderPaths.length - 1;
+                        defaultCol = (this.rowHeaderTitle ? col + 1 : col) + this.leftRowSeriesNumberColumnCount;
+                    }
+                    else {
+                        defaultCol =
+                            (this.rowHeaderTitle ? afterSpanLevel + 1 : afterSpanLevel) + this.leftRowSeriesNumberColumnCount;
+                    }
                 }
                 else {
                     defaultCol = 0;
@@ -87440,6 +87652,15 @@
             if (isValid$3(col) || isValid$3(row)) {
                 return { col: col ?? defaultCol, row: row ?? defaultRow };
             }
+            if (rowHeaderPaths.length > 0) {
+                const isMatch = rowHeaderPaths.every((path, index) => {
+                    return this.rowDimensionKeys[index] === path.dimensionKey;
+                });
+                if (isMatch) {
+                    const col = rowHeaderPaths.length - 1;
+                    return { col: (this.rowHeaderTitle ? col + 1 : col) + this.leftRowSeriesNumberColumnCount, row: undefined };
+                }
+            }
             return undefined;
         }
         setChartInstance(_col, _row, chartInstance) {
@@ -87811,6 +88032,9 @@
             const chartSpec = this.getRawChartSpec(_col, _row);
             const indicatorKeys = [];
             if (chartSpec) {
+                if (chartSpec.type === 'boxPlot') {
+                    return [chartSpec.maxField];
+                }
                 if (chartSpec.series || chartSpec.xField || chartSpec.yField) {
                     if (this.indicatorsAsCol === false) {
                         if (chartSpec.series) {
@@ -88971,8 +89195,22 @@
                     }
                     else if (this.collectValuesBy[field].range) {
                         const fieldRange = this.collectedValues[field][collectKeys];
-                        const max = Math.max(record[field], fieldRange.max);
-                        const min = Math.min(record[field], fieldRange.min);
+                        let max = Math.max(record[field], fieldRange.max);
+                        let min = Math.min(record[field], fieldRange.min);
+                        if (this.collectValuesBy[field].considerFields) {
+                            for (const considerField of this.collectValuesBy[field].considerFields) {
+                                if (record[considerField]) {
+                                    if (typeof record[considerField] === 'number') {
+                                        max = Math.max(record[considerField], max);
+                                        min = Math.min(record[considerField], min);
+                                    }
+                                    else if (Array.isArray(record[considerField])) {
+                                        max = Math.max(...record[considerField], max);
+                                        min = Math.min(...record[considerField], min);
+                                    }
+                                }
+                            }
+                        }
                         if (!isNaN(max)) {
                             fieldRange.max = max;
                             fieldRange.min = min;
@@ -89307,12 +89545,10 @@
             if (isResetTree) {
                 return this.setRecords(this.records);
             }
-            else {
-                for (const treeRowKey in this.tree) {
-                    for (const treeColKey in this.tree[treeRowKey]) {
-                        for (let i = 0; i < this.tree[treeRowKey][treeColKey].length; i++) {
-                            this.tree[treeRowKey][treeColKey][i]?.reset();
-                        }
+            for (const treeRowKey in this.tree) {
+                for (const treeColKey in this.tree[treeRowKey]) {
+                    for (let i = 0; i < this.tree[treeRowKey][treeColKey].length; i++) {
+                        this.tree[treeRowKey][treeColKey][i]?.reset();
                     }
                 }
             }
@@ -91887,6 +92123,9 @@
                 cellLocation
             };
         }
+        getCellRowHeaderFullPaths(col) {
+            return this.internalProps.layoutMap.getCellRowHeaderFullPaths(col);
+        }
         setLoadingHierarchyState(col, row) {
             this.scenegraph.setLoadingHierarchyState(col, row);
         }
@@ -92662,7 +92901,7 @@
                             indicatorSpec?.stack !== false &&
                                 (indicatorSpec?.type === 'bar' || indicatorSpec?.type === 'area') &&
                                 (indicatorSpec.stack = true);
-                            const yField = indicatorSpec.yField;
+                            const yField = indicatorSpec.yField ?? indicatorSpec.maxField;
                             collectValuesBy[yField] = {
                                 by: rowKeys,
                                 type: indicatorSpec.direction !== 'horizontal' ? 'yField' : undefined,
@@ -92671,7 +92910,10 @@
                                     ? columnKeys.concat(indicatorSpec?.xField, indicatorSpec?.x2Field)
                                     : indicatorSpec.stack && columnKeys.concat(indicatorSpec?.xField),
                                 sortBy: indicatorSpec.direction === 'horizontal' ? indicatorSpec?.data?.fields?.[yField]?.domain : undefined,
-                                extendRange: parseMarkLineGetExtendRange(indicatorSpec.markLine)
+                                extendRange: parseMarkLineGetExtendRange(indicatorSpec.markLine),
+                                considerFields: indicatorSpec?.type === 'boxPlot'
+                                    ? [indicatorSpec.maxField, indicatorSpec.minField, indicatorSpec.outliersField]
+                                    : undefined
                             };
                         }
                     }
@@ -92724,14 +92966,19 @@
                             indicatorSpec?.stack !== false &&
                                 (indicatorSpec?.type === 'bar' || indicatorSpec?.type === 'area') &&
                                 (indicatorSpec.stack = true);
-                            const xField = indicatorSpec.type === 'histogram' ? indicatorSpec.x2Field : indicatorSpec.xField;
+                            const xField = indicatorSpec.type === 'histogram'
+                                ? indicatorSpec.x2Field
+                                : indicatorSpec.xField ?? indicatorSpec.maxField;
                             collectValuesBy[xField] = {
                                 by: columnKeys,
                                 type: indicatorSpec.direction === 'horizontal' ? 'xField' : undefined,
                                 range: hasLinearAxis(indicatorSpec, this._axes, indicatorSpec.direction === 'horizontal', true),
                                 sumBy: indicatorSpec.stack && rowKeys.concat(indicatorSpec?.yField),
                                 sortBy: indicatorSpec.direction !== 'horizontal' ? indicatorSpec?.data?.fields?.[xField]?.domain : undefined,
-                                extendRange: parseMarkLineGetExtendRange(indicatorSpec.markLine)
+                                extendRange: parseMarkLineGetExtendRange(indicatorSpec.markLine),
+                                considerFields: indicatorSpec?.type === 'boxPlot'
+                                    ? [indicatorSpec.maxField, indicatorSpec.minField, indicatorSpec.outliersField]
+                                    : undefined
                             };
                         }
                     }
@@ -93738,7 +93985,7 @@
     }
 
     registerForVrender();
-    const version = "1.22.2";
+    const version = "1.22.3";
     function getIcons() {
         return get$2();
     }
@@ -93746,6 +93993,8 @@
         clearAll();
     }
 
+    exports.CUSTOM_CONTAINER_NAME = CUSTOM_CONTAINER_NAME;
+    exports.CUSTOM_MERGE_PRE_NAME = CUSTOM_MERGE_PRE_NAME;
     exports.CustomLayout = index;
     exports.DataStatistics = DataStatistics;
     exports.EventTarget = EventTarget$1;