@visactor/vtable 1.22.5-alpha.1 → 1.22.5

package/dist/vtable.js

@@ -586,7 +586,7 @@
 
     const EnvContribution = Symbol.for("EnvContribution");
     const VGlobal = Symbol.for("VGlobal");
-    const DEFAULT_TEXT_FONT_FAMILY$2 = "PingFang SC,Helvetica Neue,Microsoft Yahei,system-ui,-apple-system,segoe ui,Roboto,Helvetica,Arial,sans-serif,apple color emoji,segoe ui emoji,segoe ui symbol";
+    const DEFAULT_TEXT_FONT_FAMILY$2 = "PingFang SC,Helvetica Neue,Microsoft Yahei,system-ui,'-apple-system',segoe ui,Roboto,Helvetica,Arial,sans-serif,apple color emoji,segoe ui emoji,segoe ui symbol";
 
     const container = new Container$2();
 
@@ -4468,7 +4468,7 @@
       textAlign: "left",
       textBaseline: "alphabetic",
       fontSize: 16,
-      fontFamily: "PingFang SC,Microsoft Yahei,system-ui,-apple-system,segoe ui,\n    Roboto,Helvetica,Arial,sans-serif, apple color emoji,segoe ui emoji,segoe ui symbol",
+      fontFamily: "PingFang SC,Microsoft Yahei,system-ui,'-apple-system',segoe ui,\n    Roboto,Helvetica,Arial,sans-serif, apple color emoji,segoe ui emoji,segoe ui symbol",
       fontWeight: "",
       ellipsis: "…",
       fontVariant: "",
@@ -11365,9 +11365,10 @@
       }
       updateSymbolAABBBoundsAccurate(attribute, symbolTheme, aabbBounds) {
         const {
-          size = symbolTheme.size
-        } = attribute;
-        return this.getParsedPath().bounds(size, aabbBounds), aabbBounds;
+            size = symbolTheme.size
+          } = attribute,
+          symbolClass = this.getParsedPath();
+        return symbolClass ? (symbolClass.bounds(size, aabbBounds), aabbBounds) : aabbBounds;
       }
       needUpdateTags(keys) {
         return super.needUpdateTags(keys, SYMBOL_UPDATE_TAG_KEY);
@@ -11376,8 +11377,9 @@
         return super.needUpdateTag(key, SYMBOL_UPDATE_TAG_KEY);
       }
       toCustomPath() {
-        const symbolInstance = this.getParsedPath(),
-          size = this.attribute.size,
+        const symbolInstance = this.getParsedPath();
+        if (!symbolInstance) return null;
+        const size = this.attribute.size,
           formattedSize = isArray$9(size) ? size : [size, size];
         return symbolInstance.path ? new CustomPath2D().fromCustomPath2D(symbolInstance.path, 0, 0, formattedSize[0], formattedSize[1]) : new CustomPath2D().fromString(symbolInstance.pathStr, 0, 0, formattedSize[0], formattedSize[1]);
       }
@@ -16952,7 +16954,7 @@
         }));
       }
       enableAutoRefresh() {
-        this.autoRefresh || (this.autoRefresh = !0, this.pluginService.register(new AutoRefreshPlugin()));
+        this.autoRefresh || "node" === this.global.env || (this.autoRefresh = !0, this.pluginService.register(new AutoRefreshPlugin()));
       }
       disableAutoRefresh() {
         this.autoRefresh && (this.autoRefresh = !1, this.pluginService.findPluginsByName("AutoRefreshPlugin").forEach(plugin => {
@@ -30398,7 +30400,7 @@
           labelStyle: labelStyle
         } = op,
         radius = null == getRadius ? void 0 : getRadius();
-      if (!radius) return convertDomainToTickData(scale.domain());
+      if (!radius || radius <= 0) return convertDomainToTickData(scale.domain());
       let scaleTicks;
       if (isValid$5(tickStep)) scaleTicks = scale.stepTicks(tickStep);else if (isValid$5(forceTickCount)) scaleTicks = scale.forceTicks(forceTickCount);else if (isValid$5(tickCount)) {
         const range = scale.range(),
@@ -49030,6 +49032,10 @@
                         else {
                             if (hideTooltip) {
                                 chartInstanceListColumnByColumnDirection[col][i].hideTooltip();
+                                chartInstanceListColumnByColumnDirection[col][i].setDimensionIndex(dimensionValueOrXValue, {
+                                    tooltip: false,
+                                    showTooltipOption: { x: canvasXY.x, y: absolutePosition.top + 3, activeType: 'dimension' }
+                                });
                             }
                             else {
                                 chartInstanceListColumnByColumnDirection[col][i].setDimensionIndex(dimensionValueOrXValue, {
@@ -49122,6 +49128,10 @@
                         else {
                             if (hideTooltip) {
                                 chartInstanceListRowByRowDirection[row][i].hideTooltip();
+                                chartInstanceListRowByRowDirection[row][i].setDimensionIndex(dimensionValueOrXValue, {
+                                    tooltip: false,
+                                    showTooltipOption: { x: absolutePosition.left + 3, y: canvasXY.y, activeType: 'dimension' }
+                                });
                             }
                             else {
                                 chartInstanceListRowByRowDirection[row][i].setDimensionIndex(dimensionValueOrXValue, {
@@ -49388,6 +49398,11 @@
                 row === layout.columnHeaderLevelCount - 1 &&
                 col >= layout.rowHeaderLevelCount &&
                 col < layout.colCount - layout.rightFrozenColCount) {
+                const indicatorKey = layout.getIndicatorKey(col, row);
+                const indicatorInfo = layout.getIndicatorInfo(indicatorKey);
+                if (!indicatorInfo?.hasTwoIndicatorAxes) {
+                    return;
+                }
                 const axisRange = getRange('top', col, row + 1, col, layout.columnHeaderLevelCount - 1, col, row, 1, layout);
                 if (!axisRange) {
                     return;
@@ -49590,14 +49605,19 @@
             else if (col === layout.colCount - layout.rightFrozenColCount &&
                 row >= layout.columnHeaderLevelCount &&
                 row < layout.rowCount - layout.bottomFrozenRowCount) {
+                const indicatorKey = layout.getIndicatorKey(col, row);
+                const indicatorInfo = layout.getIndicatorInfo(indicatorKey);
+                if (!indicatorInfo?.hasTwoIndicatorAxes) {
+                    return;
+                }
+                const { axisOption, chartType } = getAxisOption(col - 1, row, 'right', layout);
                 const axisRange = getRange('right', col - 1, row, layout.rowHeaderLevelCount - 1, row, col, row, 1, layout);
-                const { chartType } = getAxisOption(col - 1, row, 'right', layout);
                 if (!axisRange) {
                     return;
                 }
                 const chartCellStyle = layout._table._getCellStyle(col - 1, row);
                 const bodyChartCellPadding = getQuadProps(getProp('padding', chartCellStyle, col - 1, row, layout._table));
-                const { range, ticks, axisOption, index, targetTicks, targetRange, theme } = axisRange;
+                const { range, ticks, index, targetTicks, targetRange, theme } = axisRange;
                 if (isNumber$4(axisOption?.min)) {
                     range.min = axisOption.min;
                     if (range.min > 0) {
@@ -49715,7 +49735,7 @@
         const axisOption = layout._table.pivotChartAxes.find(axisOption => {
             return axisOption.orient === orient;
         }) ?? {};
-        if (!axisOption.labelHoverOnAxis) {
+        if (axisOption && !axisOption.labelHoverOnAxis) {
             axisOption.labelHoverOnAxis = layout._table.options.chartDimensionLinkage?.labelHoverOnAxis?.[orient];
         }
         const { isZeroAlign, isTickAlign } = checkZeroAlign(spec, orient, layout);
@@ -49784,7 +49804,7 @@
             }
             return null;
         }
-        let defaultKey = indicatorKeys?.[seriesId];
+        let defaultKey = indicatorKeys?.[seriesId] ?? indicatorKeys?.[0];
         if (isArray$7(defaultKey)) {
             defaultKey = defaultKey[0];
         }
@@ -50091,6 +50111,9 @@
         chartInstance;
         activeChartInstance;
         activeChartInstanceHoverOnMark = null;
+        justShowMarkTooltip = undefined;
+        justShowMarkTooltipTimer = Date.now();
+        delayRunDimensionHoverTimer = undefined;
         cacheCanvas;
         isShareChartSpec;
         constructor(isShareChartSpec, params) {
@@ -50233,41 +50256,116 @@
                             }
                         }
                         else {
-                            let hideTooltip = false;
+                            let justShowMarkTooltip = true;
                             const preMark = this.activeChartInstanceHoverOnMark;
+                            const prev_justShowMarkTooltip = this.justShowMarkTooltip;
                             if (params.mark && params.datum && !Array.isArray(params.datum)) {
                                 this.activeChartInstanceHoverOnMark = params.mark;
-                                hideTooltip = true;
+                                justShowMarkTooltip = true;
                             }
                             else {
                                 this.activeChartInstanceHoverOnMark = null;
+                                justShowMarkTooltip = false;
                             }
-                            if (params.action === 'enter' || preMark !== this.activeChartInstanceHoverOnMark) {
+                            this.justShowMarkTooltip = justShowMarkTooltip;
+                            let delayRunDimensionHover = false;
+                            if (prev_justShowMarkTooltip === true && justShowMarkTooltip === false) {
+                                this.justShowMarkTooltipTimer = Date.now();
+                                delayRunDimensionHover = true;
+                            }
+                            else if (prev_justShowMarkTooltip === false && justShowMarkTooltip === false) {
+                                if (Date.now() - this.justShowMarkTooltipTimer < 100) {
+                                    delayRunDimensionHover = true;
+                                }
+                                else {
+                                    delayRunDimensionHover = false;
+                                }
+                            }
+                            else if (prev_justShowMarkTooltip === false && justShowMarkTooltip === true) {
+                                delayRunDimensionHover = false;
+                                clearTimeout(this.delayRunDimensionHoverTimer);
+                                this.delayRunDimensionHoverTimer = undefined;
+                            }
+                            else if (prev_justShowMarkTooltip === true && justShowMarkTooltip === true) {
+                                delayRunDimensionHover = false;
+                                clearTimeout(this.delayRunDimensionHoverTimer);
+                                this.delayRunDimensionHoverTimer = undefined;
+                            }
+                            if (params.action === 'enter' ||
+                                params.action === 'move' ||
+                                preMark !== this.activeChartInstanceHoverOnMark) {
                                 const dimensionValue = dimensionInfo.value;
                                 const indicatorsAsCol = table.options.indicatorsAsCol;
+                                if (!delayRunDimensionHover) {
+                                    if (indicatorsAsCol) {
+                                        generateChartInstanceListByRowDirection(row, dimensionValue, null, canvasXY, table, justShowMarkTooltip, false);
+                                    }
+                                    else {
+                                        generateChartInstanceListByColumnDirection(col, dimensionValue, null, canvasXY, table, justShowMarkTooltip, false);
+                                    }
+                                }
+                                else {
+                                    clearTimeout(this.delayRunDimensionHoverTimer);
+                                    this.delayRunDimensionHoverTimer = setTimeout(() => {
+                                        if (indicatorsAsCol) {
+                                            generateChartInstanceListByRowDirection(row, dimensionValue, null, canvasXY, table, justShowMarkTooltip, false);
+                                        }
+                                        else {
+                                            generateChartInstanceListByColumnDirection(col, dimensionValue, null, canvasXY, table, justShowMarkTooltip, false);
+                                        }
+                                    }, 100);
+                                }
                                 if (indicatorsAsCol) {
                                     const series = dimensionInfo.data[0].series;
-                                    const width = series.getYAxisHelper().getBandwidth(0);
-                                    const y = series.valueToPositionY(dimensionValue);
+                                    const width = this.attribute.spec.type === 'histogram' ||
+                                        this.attribute.spec.type === 'boxPlot' ||
+                                        series.type === 'line' ||
+                                        series.type === 'area'
+                                        ? 0
+                                        : series.getYAxisHelper().getBandwidth(0);
+                                    let y = series.valueToPositionY(dimensionValue);
                                     const axisConfig = getAxisConfigInPivotChart(table.rowHeaderLevelCount - 1, row, table.internalProps.layoutMap);
+                                    let hoverOnLabelValue = yValue;
+                                    if (this.attribute.spec.type === 'histogram') {
+                                        const { series, datum } = dimensionInfo.data[0];
+                                        if (datum.length > 0) {
+                                            const rangeStartValue = datum[0][series.fieldY[0]];
+                                            const rangeEndValue = datum[0][series.fieldY2];
+                                            hoverOnLabelValue = rangeStartValue + ' ~ ' + rangeEndValue;
+                                            y = (series.valueToPositionY(rangeStartValue) + series.valueToPositionY(rangeEndValue)) / 2;
+                                        }
+                                    }
                                     if (axisConfig.labelHoverOnAxis) {
                                         table.scenegraph
                                             .getCell(table.rowHeaderLevelCount - 1, row)
-                                            .firstChild.showLabelHoverOnAxis(y + (series.type === 'line' || series.type === 'area' ? 0 : width / 2), yValue);
+                                            .firstChild.showLabelHoverOnAxis(y + (series.type === 'line' || series.type === 'area' ? 0 : width / 2), hoverOnLabelValue);
                                     }
-                                    generateChartInstanceListByRowDirection(row, dimensionValue, null, canvasXY, table, hideTooltip, false);
                                 }
                                 else {
                                     const series = dimensionInfo.data[0].series;
-                                    const width = series.getXAxisHelper().getBandwidth(0);
-                                    const x = series.valueToPositionX(dimensionValue);
+                                    const width = this.attribute.spec.type === 'histogram' ||
+                                        this.attribute.spec.type === 'boxPlot' ||
+                                        series.type === 'line' ||
+                                        series.type === 'area'
+                                        ? 0
+                                        : series.getXAxisHelper().getBandwidth(0);
+                                    let x = series.valueToPositionX(dimensionValue);
                                     const axisConfig = getAxisConfigInPivotChart(col, table.rowCount - table.bottomFrozenRowCount, table.internalProps.layoutMap);
+                                    let hoverOnLabelValue = dimensionValue;
+                                    if (this.attribute.spec.type === 'histogram') {
+                                        const { series, datum } = dimensionInfo.data[0];
+                                        if (datum.length > 0) {
+                                            const rangeStartValue = datum[0][series.fieldX[0]];
+                                            const rangeEndValue = datum[0][series.fieldX2];
+                                            hoverOnLabelValue = rangeStartValue + ' ~ ' + rangeEndValue;
+                                            x = (series.valueToPositionX(rangeStartValue) + series.valueToPositionX(rangeEndValue)) / 2;
+                                        }
+                                    }
                                     if (axisConfig.labelHoverOnAxis) {
                                         table.scenegraph
                                             .getCell(col, table.rowCount - table.bottomFrozenRowCount)
-                                            .firstChild.showLabelHoverOnAxis(x + (series.type === 'line' || series.type === 'area' ? 0 : width / 2), dimensionValue);
+                                            .firstChild.showLabelHoverOnAxis(x + width / 2, hoverOnLabelValue);
                                     }
-                                    generateChartInstanceListByColumnDirection(col, dimensionValue, null, canvasXY, table, hideTooltip, false);
                                 }
                             }
                         }
@@ -50279,6 +50377,10 @@
         static temp = 1;
         deactivate(table, { releaseChartInstance = true, releaseColumnChartInstance = true, releaseRowChartInstance = true } = {}) {
             this.activeChartInstanceHoverOnMark = null;
+            this.justShowMarkTooltip = undefined;
+            this.justShowMarkTooltipTimer = Date.now();
+            clearTimeout(this.delayRunDimensionHoverTimer);
+            this.delayRunDimensionHoverTimer = undefined;
             if (releaseChartInstance) {
                 this.activeChartInstance?.updateViewBox({
                     x1: -1000,
@@ -56732,7 +56834,8 @@
         const table = scenegraph.table;
         if (table.isPivotChart()) {
             const preSelectItemsCount = table._selectedDataItemsInChart.length;
-            if ((datum === null || datum?.length === 0 || Object.keys(datum).length === 0) && preSelectItemsCount === 0) {
+            if ((datum === null || datum === undefined || datum?.length === 0 || Object.keys(datum).length === 0) &&
+                preSelectItemsCount === 0) {
                 return;
             }
             const newSelectedDataItemsInChart = [];
@@ -69858,7 +69961,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.22.5-alpha.1";
+        version = "1.22.5";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -74342,7 +74445,7 @@
         domainLine: {
             visible: true,
             style: {
-                lineWidth: 1,
+                lineWidth: 0,
                 stroke: '#D9DDE4',
                 strokeOpacity: 1
             }
@@ -74433,6 +74536,10 @@
     }
     function getAxisAttributes(option) {
         const spec = merge$1({}, option);
+        if (option.labelHoverOnAxis && spec.domainLine.visible === false) {
+            spec.domainLine.style.lineWidth = 0;
+            spec.domainLine.visible = true;
+        }
         let titleAngle = spec.title?.angle ?? 0;
         let titleTextStyle;
         if (spec.orient === 'left' || spec.orient === 'right') {
@@ -74743,6 +74850,15 @@
             const rowPath = layout.getRowKeysPath(col, row);
             const domain = data[rowPath ?? ''];
             const { axisOption, isPercent, chartType } = getAxisOption(col, row, 'left', layout);
+            if (axisOption?.zero &&
+                domain &&
+                !Array.isArray(domain) &&
+                isValid$3(domain.min) &&
+                isValid$3(domain.max) &&
+                (axisOption?.zero || domain.min === domain.max)) {
+                domain.min = Math.min(domain.min, 0);
+                domain.max = Math.max(domain.max, 0);
+            }
             axes.push(merge$1({
                 domain: axisOption?.type === 'linear' && !Array.isArray(domain) ? undefined : Array.from(domain ?? []),
                 range: axisOption?.type === 'linear' && !Array.isArray(domain) ? domain : undefined,
@@ -74813,6 +74929,15 @@
             const colPath = layout.getColKeysPath(col, row);
             const domain = data?.[colPath ?? ''] ?? [];
             const { axisOption, isPercent, chartType } = getAxisOption(col, row, 'bottom', layout);
+            if (axisOption?.zero &&
+                domain &&
+                !Array.isArray(domain) &&
+                isValid$3(domain.min) &&
+                isValid$3(domain.max) &&
+                (axisOption?.zero || domain.min === domain.max)) {
+                domain.min = Math.min(domain.min, 0);
+                domain.max = Math.max(domain.max, 0);
+            }
             axes.push(merge$1({
                 domain: axisOption?.type === 'linear' && !Array.isArray(domain) ? undefined : Array.from(domain ?? []),
                 range: axisOption?.type === 'linear' && !Array.isArray(domain) ? domain : undefined,
@@ -85720,7 +85845,8 @@
             this.fullRowDimensionKeys = this.fullRowDimensionKeys.concat(this.rowDimensionKeys);
             this.resetRowHeaderLevelCount();
             if (this._table.isPivotChart()) {
-                this.hasTwoIndicatorAxes = this.indicatorsDefine.some((indicatorObject) => {
+                this.hasTwoIndicatorAxes = false;
+                this.indicatorsDefine.forEach((indicatorObject) => {
                     if (indicatorObject.chartSpec &&
                         indicatorObject.chartSpec.series &&
                         indicatorObject.chartSpec.series.length > 1) {
@@ -85732,9 +85858,58 @@
                                 }
                                 return true;
                             })) {
+                            indicatorObject.hasTwoIndicatorAxes = true;
+                            this.hasTwoIndicatorAxes = true;
                             return true;
                         }
                     }
+                    indicatorObject.hasTwoIndicatorAxes = false;
+                    return false;
+                });
+                this.indicatorsDefine.forEach((indicatorObject) => {
+                    if (indicatorObject.hasTwoIndicatorAxes) {
+                        return false;
+                    }
+                    if (indicatorObject.chartSpec) {
+                        const axes = indicatorObject.chartSpec.axes ?? this._table.pivotChartAxes ?? [];
+                        if (this.indicatorsAsCol) {
+                            const topAxis = axes.find((axis) => {
+                                if (axis.orient === 'top' && axis.visible !== false) {
+                                    return true;
+                                }
+                                return false;
+                            });
+                            const bottomAxis = axes.find((axis) => {
+                                if (axis.orient === 'bottom' && axis.visible !== false) {
+                                    return true;
+                                }
+                                return false;
+                            });
+                            if (topAxis && bottomAxis) {
+                                indicatorObject.hasTwoIndicatorAxes = true;
+                                return true;
+                            }
+                        }
+                        else {
+                            const leftAxis = axes.find((axis) => {
+                                if (axis.orient === 'left' && axis.visible !== false) {
+                                    return true;
+                                }
+                                return false;
+                            });
+                            const rightAxis = axes.find((axis) => {
+                                if (axis.orient === 'right' && axis.visible !== false) {
+                                    return true;
+                                }
+                                return false;
+                            });
+                            if (leftAxis && rightAxis) {
+                                indicatorObject.hasTwoIndicatorAxes = true;
+                                return true;
+                            }
+                        }
+                    }
+                    indicatorObject.hasTwoIndicatorAxes = false;
                     return false;
                 });
             }
@@ -87977,7 +88152,9 @@
                             const findLeafNode = (nodes) => {
                                 for (const node of nodes) {
                                     const nodeChildren = node.children;
-                                    const nodeHasAxis = checkAxisNode && nodeChildren.some((row) => row.dimensionKey === 'axis');
+                                    const nodeHasAxis = checkAxisNode &&
+                                        nodeChildren &&
+                                        nodeChildren.some((row) => row.dimensionKey === 'axis');
                                     if (!nodeChildren?.length || nodeHasAxis) {
                                         return node;
                                     }
@@ -88446,7 +88623,9 @@
                             ? chartSpec.type === 'histogram'
                                 ? chartSpec.x2Field
                                 : chartSpec.xField ?? chartSpec?.series?.[0]?.xField
-                            : chartSpec.yField ?? chartSpec?.series?.[0]?.yField;
+                            : chartSpec.type === 'histogram'
+                                ? chartSpec.y2Field
+                                : chartSpec.yField ?? chartSpec?.series?.[0]?.yField;
                     if (dimensionKey) {
                         return dimensionKey;
                     }
@@ -93444,7 +93623,9 @@
                             collectValuesBy[indicatorDefine.indicatorKey] = {
                                 by: columnKeys,
                                 range: true,
-                                sumBy: indicatorSpec?.stack && rowKeys.concat(indicatorSpec?.yField)
+                                sumBy: indicatorSpec.type === 'histogram'
+                                    ? rowKeys.concat(indicatorSpec?.yField, indicatorSpec?.y2Field)
+                                    : indicatorSpec?.stack && rowKeys.concat(indicatorSpec?.yField)
                             };
                         }
                         if (indicatorSpec.series) {
@@ -93474,7 +93655,11 @@
                             });
                         }
                         else {
-                            const yField = typeof indicatorSpec.yField === 'string' ? indicatorSpec.yField : indicatorSpec.yField[0];
+                            const yField = indicatorSpec.type === 'histogram'
+                                ? indicatorSpec.y2Field
+                                : typeof indicatorSpec.yField === 'string'
+                                    ? indicatorSpec.yField
+                                    : indicatorSpec.yField[0];
                             collectValuesBy[yField] = {
                                 by: rowKeys,
                                 type: indicatorSpec.direction === 'horizontal' ? 'yField' : undefined,
@@ -93484,14 +93669,14 @@
                             indicatorSpec?.stack !== false &&
                                 (indicatorSpec?.type === 'bar' || indicatorSpec?.type === 'area') &&
                                 (indicatorSpec.stack = true);
-                            const xField = indicatorSpec.type === 'histogram'
-                                ? indicatorSpec.x2Field
-                                : indicatorSpec.xField ?? indicatorSpec.maxField;
+                            const xField = 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),
+                                sumBy: indicatorSpec.type === 'histogram'
+                                    ? rowKeys.concat(indicatorSpec?.yField, indicatorSpec?.y2Field)
+                                    : indicatorSpec.stack && rowKeys.concat(indicatorSpec?.yField),
                                 sortBy: indicatorSpec.direction !== 'horizontal' ? indicatorSpec?.data?.fields?.[xField]?.domain : undefined,
                                 extendRange: parseMarkLineGetExtendRange(indicatorSpec.markLine),
                                 considerFields: indicatorSpec?.type === 'boxPlot'
@@ -94503,7 +94688,7 @@
     }
 
     registerForVrender();
-    const version = "1.22.5-alpha.1";
+    const version = "1.22.5";
     function getIcons() {
         return get$2();
     }