@techie_doubts/tui.chart.2026 4.6.1

package/dist/esm/store/axes.js

@@ -0,0 +1,282 @@
+import { getAxisFormatter, getAxisName, getAxisTheme, getInitAxisIntervalData, getLabelsAppliedFormatter, getLabelXMargin, getMaxLabelSize, getRotatableOption, getSizeKey, getViewAxisLabels, getYAxisOption, hasAxesLayoutChanged, hasBoxTypeSeries, isDateType, isLabelAxisOnYAxis, isPointOnColumn, makeRotationData, makeTitleOption, } from "../helpers/axes";
+import { getAxisLabelAnchorPoint, makeLabelsFromLimit } from "../helpers/calculator";
+import { deepMergedCopy, hasNegativeOnly, isNumber, pickProperty } from "../helpers/utils";
+import { isCoordinateSeries } from "../helpers/coordinate";
+import { AxisType } from "../component/axis";
+import { getTitleFontString } from "../helpers/style";
+export function isCenterYAxis(options) {
+    var _a, _b;
+    const diverging = !!pickProperty(options, ['series', 'diverging']);
+    const alignCenter = ((_b = (_a = options) === null || _a === void 0 ? void 0 : _a.yAxis) === null || _b === void 0 ? void 0 : _b.align) === 'center';
+    return diverging && alignCenter;
+}
+function isDivergingBoxSeries(series, options) {
+    var _a;
+    return hasBoxTypeSeries(series) && !!((_a = options.series) === null || _a === void 0 ? void 0 : _a.diverging);
+}
+function getZeroPosition(limit, axisSize, labelAxisOnYAxis, isDivergingSeries) {
+    const { min, max } = limit;
+    const hasZeroValue = min <= 0 && max >= 0;
+    if (!hasZeroValue || isDivergingSeries) {
+        return null;
+    }
+    const position = ((0 - min) / (max - min)) * axisSize;
+    return labelAxisOnYAxis ? position : axisSize - position;
+}
+export function getLabelAxisData(stateProp) {
+    const { axisSize, categories, series, options, theme, scale, initialAxisData, isCoordinateTypeChart, axisName, } = stateProp;
+    const hasLineSeries = !!series.line;
+    const pointOnColumn = isPointOnColumn(series, options);
+    const dateType = isDateType(options, axisName);
+    const labelsBeforeFormatting = isCoordinateTypeChart
+        ? makeLabelsFromLimit(scale.limit, scale.stepSize, dateType)
+        : categories;
+    const labels = getLabelsAppliedFormatter(labelsBeforeFormatting, options, dateType, axisName);
+    let labelRange;
+    if (scale && hasLineSeries) {
+        const baseLabels = pointOnColumn ? labelsBeforeFormatting : categories;
+        const values = baseLabels.map((value) => (dateType ? Number(new Date(value)) : Number(value)));
+        labelRange = { min: Math.min(...values), max: Math.max(...values) };
+    }
+    const rectResponderCount = categories.length;
+    const tickIntervalCount = rectResponderCount - (pointOnColumn ? 0 : 1);
+    const tickDistance = tickIntervalCount ? axisSize / tickIntervalCount : axisSize;
+    const labelDistance = axisSize / (labels.length - (pointOnColumn ? 0 : 1));
+    let tickCount = labels.length;
+    if (pointOnColumn && !isCoordinateTypeChart) {
+        tickCount += 1;
+    }
+    const viewLabels = getViewAxisLabels(Object.assign({ labels,
+        pointOnColumn,
+        tickDistance,
+        tickCount,
+        scale }, initialAxisData), axisSize);
+    const axisLabelMargin = getLabelXMargin(axisName, options);
+    return Object.assign(Object.assign({ labels,
+        viewLabels,
+        pointOnColumn,
+        labelDistance,
+        tickDistance,
+        tickCount,
+        labelRange,
+        rectResponderCount, isLabelAxis: true }, initialAxisData), getMaxLabelSize(labels, axisLabelMargin, getTitleFontString(theme.label)));
+}
+function getValueAxisData(stateProp) {
+    var _a;
+    const { scale, axisSize, series, options, centerYAxis, initialAxisData, theme, labelOnYAxis, axisName, } = stateProp;
+    const { limit, stepSize } = scale;
+    const size = centerYAxis ? (_a = centerYAxis) === null || _a === void 0 ? void 0 : _a.xAxisHalfSize : axisSize;
+    const divergingBoxSeries = isDivergingBoxSeries(series, options);
+    const formatter = getAxisFormatter(options, axisName);
+    const zeroPosition = getZeroPosition(limit, axisSize, isLabelAxisOnYAxis({ series, options }), divergingBoxSeries);
+    let valueLabels = makeLabelsFromLimit(limit, stepSize);
+    if (!centerYAxis && divergingBoxSeries) {
+        valueLabels = getDivergingValues(valueLabels);
+    }
+    const labels = valueLabels.map((label, index) => formatter(label, { index, labels: valueLabels, axisName }));
+    const tickDistance = size / Math.max(valueLabels.length, 1);
+    const tickCount = valueLabels.length;
+    const pointOnColumn = false;
+    const viewLabels = getViewAxisLabels(Object.assign({ labels: labelOnYAxis ? labels : [...labels].reverse(), pointOnColumn,
+        tickDistance,
+        tickCount }, initialAxisData), size);
+    const axisLabelMargin = getLabelXMargin(axisName, options);
+    const axisData = Object.assign(Object.assign({ labels,
+        viewLabels,
+        pointOnColumn, isLabelAxis: false, tickCount,
+        tickDistance }, initialAxisData), getMaxLabelSize(labels, axisLabelMargin, getTitleFontString(theme.label)));
+    if (isNumber(zeroPosition)) {
+        axisData.zeroPosition = zeroPosition;
+    }
+    return axisData;
+}
+function getDivergingValues(valueLabels) {
+    return hasNegativeOnly(valueLabels)
+        ? valueLabels.reverse().slice(1).concat(valueLabels)
+        : valueLabels.slice(1).reverse().concat(valueLabels);
+}
+function makeDefaultAxisData(isLabelAxis, params) {
+    var _a, _b;
+    const axisData = getInitAxisIntervalData(isLabelAxis, params);
+    const title = makeTitleOption((_b = (_a = params) === null || _a === void 0 ? void 0 : _a.axis) === null || _b === void 0 ? void 0 : _b.title);
+    if (title) {
+        axisData.title = title;
+    }
+    return axisData;
+}
+function getInitialAxisData(options, labelOnYAxis, categories, layout, isCoordinateTypeChart) {
+    var _a, _b, _c;
+    const { yAxis, secondaryYAxis } = getYAxisOption(options);
+    const shift = (_b = (_a = options) === null || _a === void 0 ? void 0 : _a.series) === null || _b === void 0 ? void 0 : _b.shift;
+    return {
+        xAxis: makeDefaultAxisData(!labelOnYAxis, {
+            categories,
+            axis: (_c = options) === null || _c === void 0 ? void 0 : _c.xAxis,
+            layout,
+            shift,
+            isCoordinateTypeChart,
+        }),
+        yAxis: makeDefaultAxisData(labelOnYAxis, { axis: yAxis }),
+        secondaryYAxis: secondaryYAxis
+            ? makeDefaultAxisData(labelOnYAxis, { axis: secondaryYAxis })
+            : null,
+    };
+}
+function getSecondaryYAxisData({ state, labelOnYAxis, valueAxisSize, labelAxisSize, initialAxisData, isCoordinateTypeChart, }) {
+    var _a, _b;
+    const { scale, options, series, theme } = state;
+    const categories = state.categories;
+    return labelOnYAxis
+        ? getLabelAxisData({
+            scale: scale.secondaryYAxis,
+            axisSize: labelAxisSize,
+            categories: (_b = (_a = getYAxisOption(options).secondaryYAxis) === null || _a === void 0 ? void 0 : _a.categories, (_b !== null && _b !== void 0 ? _b : categories)),
+            options,
+            series,
+            theme: getAxisTheme(theme, AxisType.SECONDARY_Y),
+            initialAxisData,
+            isCoordinateTypeChart,
+            axisName: AxisType.SECONDARY_Y,
+        })
+        : getValueAxisData({
+            scale: scale.secondaryYAxis,
+            axisSize: valueAxisSize,
+            options,
+            series,
+            theme: getAxisTheme(theme, AxisType.SECONDARY_Y),
+            centerYAxis: null,
+            initialAxisData,
+            axisName: AxisType.SECONDARY_Y,
+        });
+}
+function makeXAxisData({ axisData, axisSize, axisLayout, centerYAxis, rotatable, labelMargin = 0, }) {
+    const { viewLabels, pointOnColumn, maxLabelWidth, maxLabelHeight } = axisData;
+    const offsetY = getAxisLabelAnchorPoint(maxLabelHeight) + labelMargin;
+    const size = centerYAxis ? centerYAxis.xAxisHalfSize : axisSize;
+    const distance = size / (viewLabels.length - (pointOnColumn ? 0 : 1));
+    const rotationData = makeRotationData(maxLabelWidth, maxLabelHeight, distance, rotatable, axisLayout);
+    const { needRotateLabel, rotationHeight } = rotationData;
+    const maxHeight = (needRotateLabel ? rotationHeight : maxLabelHeight) + offsetY;
+    return Object.assign(Object.assign(Object.assign({}, axisData), rotationData), { maxHeight,
+        offsetY });
+}
+function getAxisInfo(labelOnYAxis, plot, series) {
+    const { valueAxisName, labelAxisName } = getAxisName(labelOnYAxis, series);
+    const { valueSizeKey, labelSizeKey } = getSizeKey(labelOnYAxis);
+    const valueAxisSize = plot[valueSizeKey];
+    const labelAxisSize = plot[labelSizeKey];
+    return { valueAxisName, valueAxisSize, labelAxisName, labelAxisSize };
+}
+function getCategoriesWithTypes(categories, rawCategories) {
+    var _a, _b;
+    return {
+        categories: (_a = categories, (_a !== null && _a !== void 0 ? _a : [])),
+        rawCategories: (_b = rawCategories, (_b !== null && _b !== void 0 ? _b : [])),
+    };
+}
+const axes = {
+    name: 'axes',
+    state: ({ series, options }) => {
+        const { secondaryYAxis } = getYAxisOption(options);
+        const axesState = {
+            xAxis: {},
+            yAxis: {},
+        };
+        if (!!series.bar && isCenterYAxis(options)) {
+            axesState.centerYAxis = {};
+        }
+        if (secondaryYAxis) {
+            axesState.secondaryYAxis = {};
+        }
+        return {
+            axes: axesState,
+        };
+    },
+    action: {
+        setAxesData({ state, initStoreState }) {
+            var _a, _b;
+            const { scale, options, series, layout, theme } = state;
+            const { xAxis, yAxis, plot } = layout;
+            const isCoordinateTypeChart = isCoordinateSeries(initStoreState.series);
+            const labelOnYAxis = isLabelAxisOnYAxis({ series, options });
+            const { categories } = getCategoriesWithTypes(state.categories, state.rawCategories);
+            const { valueAxisName, valueAxisSize, labelAxisName, labelAxisSize } = getAxisInfo(labelOnYAxis, plot, series);
+            const hasCenterYAxis = state.axes.centerYAxis;
+            const initialAxisData = getInitialAxisData(options, labelOnYAxis, categories, layout, isCoordinateTypeChart);
+            const valueAxisData = getValueAxisData({
+                scale: scale[valueAxisName],
+                axisSize: valueAxisSize,
+                options,
+                series,
+                theme: getAxisTheme(theme, valueAxisName),
+                centerYAxis: hasCenterYAxis
+                    ? {
+                        xAxisHalfSize: (xAxis.width - yAxis.width) / 2,
+                    }
+                    : null,
+                initialAxisData: initialAxisData[valueAxisName],
+                labelOnYAxis,
+                axisName: valueAxisName,
+            });
+            const labelAxisData = getLabelAxisData({
+                scale: scale[labelAxisName],
+                axisSize: labelAxisSize,
+                categories,
+                options,
+                series,
+                theme: getAxisTheme(theme, labelAxisName),
+                initialAxisData: initialAxisData[labelAxisName],
+                isCoordinateTypeChart,
+                labelOnYAxis,
+                axisName: labelAxisName,
+            });
+            let secondaryYAxis, centerYAxis;
+            if (state.axes.secondaryYAxis) {
+                secondaryYAxis = getSecondaryYAxisData({
+                    state,
+                    labelOnYAxis,
+                    valueAxisSize,
+                    labelAxisSize,
+                    labelAxisName,
+                    valueAxisName,
+                    initialAxisData: initialAxisData.secondaryYAxis,
+                    isCoordinateTypeChart,
+                });
+            }
+            if (hasCenterYAxis) {
+                const xAxisHalfSize = (xAxis.width - yAxis.width) / 2;
+                centerYAxis = deepMergedCopy(valueAxisData, {
+                    x: xAxis.x + xAxisHalfSize,
+                    xAxisHalfSize,
+                    secondStartX: (xAxis.width + yAxis.width) / 2,
+                    yAxisLabelAnchorPoint: yAxis.width / 2,
+                    yAxisHeight: yAxis.height,
+                });
+            }
+            const axesState = {
+                xAxis: makeXAxisData({
+                    axisData: labelOnYAxis ? valueAxisData : labelAxisData,
+                    axisSize: labelOnYAxis ? valueAxisSize : labelAxisSize,
+                    axisLayout: layout.xAxis,
+                    centerYAxis,
+                    rotatable: getRotatableOption(options),
+                    labelMargin: (_b = (_a = options.xAxis) === null || _a === void 0 ? void 0 : _a.label) === null || _b === void 0 ? void 0 : _b.margin,
+                }),
+                yAxis: labelOnYAxis ? labelAxisData : valueAxisData,
+                secondaryYAxis,
+                centerYAxis,
+            };
+            if (hasAxesLayoutChanged(state.axes, axesState)) {
+                this.notify(state, 'layout');
+            }
+            state.axes = axesState;
+        },
+    },
+    computed: {},
+    observe: {
+        updateAxes() {
+            this.dispatch('setAxesData');
+        },
+    },
+};
+export default axes;

package/dist/esm/store/category.d.ts

@@ -0,0 +1,4 @@
+import { StoreModule, RawSeries, Series, Categories } from "../../types/store/store";
+export declare function makeRawCategories(series: RawSeries | Series, categories?: Categories): string[] | import("../../types/options").HeatmapCategoriesType;
+declare const category: StoreModule;
+export default category;

package/dist/esm/store/category.js

@@ -0,0 +1,73 @@
+import { isNull, isNumber, isUndefined, sortCategories } from "../helpers/utils";
+import { getCoordinateXValue } from "../helpers/coordinate";
+import { getDataInRange } from "../helpers/range";
+export function makeRawCategories(series, categories) {
+    if (categories) {
+        return categories;
+    }
+    const firstValues = new Set();
+    Object.keys(series).forEach((key) => {
+        var _a;
+        if (key === 'pie' || key === 'gauge') {
+            return;
+        }
+        (_a = series[key].data, (_a !== null && _a !== void 0 ? _a : series[key])).forEach(({ data, name, visible }) => {
+            if (Array.isArray(data)) {
+                data.forEach((datum) => {
+                    if (!isNull(datum)) {
+                        const rawXValue = getCoordinateXValue(datum);
+                        firstValues.add(isNumber(rawXValue) ? rawXValue : rawXValue.toString());
+                    }
+                });
+            }
+            else if ((key === 'bullet' && isUndefined(visible)) || visible) {
+                firstValues.add(name);
+            }
+        });
+    });
+    return Array.from(firstValues)
+        .sort(sortCategories)
+        .map((category) => String(category));
+}
+const category = {
+    name: 'category',
+    state: ({ categories, series }) => ({
+        categories: makeRawCategories(series, categories),
+    }),
+    action: {
+        setCategory({ state, computed }) {
+            const { viewRange } = computed;
+            let categories = state.rawCategories;
+            if (viewRange) {
+                if (Array.isArray(categories)) {
+                    categories = getDataInRange(categories, viewRange);
+                }
+                else {
+                    categories = Object.assign(Object.assign({}, categories), { x: getDataInRange(categories.x, viewRange) });
+                }
+            }
+            state.categories = categories;
+            this.notify(state, 'categories');
+        },
+        initCategory({ initStoreState, state }) {
+            const { zoomRange } = state;
+            let categories = makeRawCategories(initStoreState.series);
+            if (zoomRange && Array.isArray(categories)) {
+                categories = getDataInRange(categories, zoomRange);
+            }
+            state.categories = categories;
+            this.notify(state, 'categories');
+        },
+        removeCategoryByName({ state }, name) {
+            const index = state.categories.findIndex((seriesName) => seriesName === name);
+            state.categories.splice(index, 1);
+            this.notify(state, 'axes');
+        },
+    },
+    observe: {
+        updateCategory() {
+            this.dispatch('setCategory');
+        },
+    },
+};
+export default category;

package/dist/esm/store/colorValueScale.d.ts

@@ -0,0 +1,3 @@
+import { StoreModule } from "../../types/store/store";
+declare const colorValueScale: StoreModule;
+export default colorValueScale;

package/dist/esm/store/colorValueScale.js

@@ -0,0 +1,56 @@
+import { extend } from "./store";
+import { calculateCoordinateScale } from "../scale/coordinateScaleCalculator";
+import { getLimitSafely } from "./dataRange";
+import { isVerticalAlign } from "./layout";
+import { TREEMAP_ROOT_ID } from "./treemapSeriesData";
+const colorValueScale = {
+    name: 'colorValueScale',
+    state: () => ({
+        treemapZoomId: {
+            prev: TREEMAP_ROOT_ID,
+            cur: TREEMAP_ROOT_ID,
+        },
+        colorValueScale: {},
+    }),
+    action: {
+        setColorValueScale({ state }) {
+            const { layout, treemapSeries, legend, heatmapSeries } = state;
+            if (!legend.useSpectrumLegend) {
+                return;
+            }
+            const series = (treemapSeries !== null && treemapSeries !== void 0 ? treemapSeries : heatmapSeries.flatMap((value) => value));
+            const values = series.reduce((acc, { colorValue }) => (colorValue ? [...acc, colorValue] : acc), []);
+            const dataRange = getLimitSafely([...new Set(values)]);
+            const offsetSize = isVerticalAlign(legend.align) ? layout.plot.width / 2 : layout.plot.height;
+            extend(state.colorValueScale, calculateCoordinateScale({
+                dataRange,
+                offsetSize,
+                useSpectrumLegend: true,
+                scaleOption: {},
+            }));
+        },
+        setTreemapZoomId({ state }, id) {
+            state.treemapZoomId.prev = state.treemapZoomId.cur;
+            state.treemapZoomId.cur = id;
+        },
+        zoomBack({ state }) {
+            var _a, _b;
+            const { treemapSeries, treemapZoomId } = state;
+            const { prev } = treemapZoomId;
+            const prevSeries = treemapSeries.find(({ id }) => id === prev);
+            state.treemapZoomId.prev = (_b = (_a = prevSeries) === null || _a === void 0 ? void 0 : _a.parentId, (_b !== null && _b !== void 0 ? _b : TREEMAP_ROOT_ID));
+            state.treemapZoomId.cur = prev;
+        },
+    },
+    observe: {
+        updateColorValueScale() {
+            this.dispatch('setColorValueScale');
+        },
+    },
+    computed: {
+        isTreemapSeriesZooming: ({ treemapZoomId }) => {
+            return treemapZoomId && treemapZoomId.cur !== treemapZoomId.prev;
+        },
+    },
+};
+export default colorValueScale;

package/dist/esm/store/dataRange.d.ts

@@ -0,0 +1,4 @@
+import { ValueEdge, StoreModule } from "../../types/store/store";
+export declare function getLimitSafely(baseValues: number[], isXAxis?: boolean): ValueEdge;
+declare const dataRange: StoreModule;
+export default dataRange;

package/dist/esm/store/dataRange.js

@@ -0,0 +1,170 @@
+import { getFirstValidValue, isNull, includes } from "../helpers/utils";
+import { extend } from "./store";
+import { getAxisName, isLabelAxisOnYAxis, getValueAxisNames, getYAxisOption, hasSecondaryYAxis, } from "../helpers/axes";
+import { getCoordinateYValue, isCoordinateSeries } from "../helpers/coordinate";
+import { isRangeValue } from "../helpers/range";
+import { AxisType } from "../component/axis";
+export function getLimitSafely(baseValues, isXAxis = false) {
+    const limit = {
+        min: Math.min(...baseValues),
+        max: Math.max(...baseValues),
+    };
+    if (baseValues.length === 1) {
+        const [firstValue] = baseValues;
+        if (isXAxis) {
+            limit.min = firstValue;
+            limit.max = firstValue;
+        }
+        else if (firstValue > 0) {
+            limit.min = 0;
+        }
+        else if (firstValue === 0) {
+            limit.max = 10;
+        }
+        else {
+            limit.max = 0;
+        }
+    }
+    else if (limit.min === 0 && limit.max === 0) {
+        limit.max = 10;
+    }
+    else if (limit.min === limit.max) {
+        limit.min -= limit.min / 10;
+        limit.max += limit.max / 10;
+    }
+    return limit;
+}
+function initDataRange(accDataRangeValue, curDataRangeValue, axisName) {
+    var _a, _b, _c, _d;
+    const defaultDataRange = {
+        min: Number.MAX_SAFE_INTEGER,
+        max: Number.MIN_SAFE_INTEGER,
+    };
+    return {
+        min: Math.min(curDataRangeValue[axisName].min, (_b = (_a = accDataRangeValue[axisName]) === null || _a === void 0 ? void 0 : _a.min, (_b !== null && _b !== void 0 ? _b : defaultDataRange.min))),
+        max: Math.max(curDataRangeValue[axisName].max, (_d = (_c = accDataRangeValue[axisName]) === null || _c === void 0 ? void 0 : _c.max, (_d !== null && _d !== void 0 ? _d : defaultDataRange.max))),
+    };
+}
+function getTotalDataRange(seriesDataRange) {
+    return Object.values(seriesDataRange).reduce((acc, cur) => {
+        if (cur.xAxis) {
+            acc.xAxis = initDataRange(acc, cur, 'xAxis');
+        }
+        if (cur.yAxis) {
+            acc.yAxis = initDataRange(acc, cur, 'yAxis');
+        }
+        if (cur.secondaryYAxis) {
+            acc.secondaryYAxis = initDataRange(acc, cur, 'secondaryYAxis');
+        }
+        if (cur.circularAxis) {
+            acc.circularAxis = initDataRange(acc, cur, 'circularAxis');
+        }
+        if (cur.verticalAxis) {
+            acc.verticalAxis = initDataRange(acc, cur, 'verticalAxis');
+        }
+        return acc;
+    }, {});
+}
+function setSeriesDataRange({ options, seriesName, values, valueAxisName, seriesDataRange, }) {
+    var _a;
+    let axisNames;
+    if (includes([AxisType.X, AxisType.CIRCULAR, AxisType.VERTICAL], valueAxisName)) {
+        axisNames = [valueAxisName];
+    }
+    else {
+        const optionsUsingYAxis = options;
+        const { secondaryYAxis } = getYAxisOption(optionsUsingYAxis);
+        axisNames =
+            hasSecondaryYAxis(optionsUsingYAxis) && ((_a = secondaryYAxis) === null || _a === void 0 ? void 0 : _a.chartType)
+                ? [secondaryYAxis.chartType === seriesName ? 'secondaryYAxis' : 'yAxis']
+                : getValueAxisNames(optionsUsingYAxis, valueAxisName);
+    }
+    axisNames.forEach((axisName) => {
+        seriesDataRange[seriesName][axisName] = getLimitSafely([...new Set(values)]);
+    });
+    return seriesDataRange;
+}
+function getBoxPlotValues(series, seriesName) {
+    return series[seriesName].data.flatMap(({ data, outliers = [] }) => [
+        ...((data !== null && data !== void 0 ? data : [])).flatMap((datum) => datum),
+        ...((outliers !== null && outliers !== void 0 ? outliers : [])).flatMap((datum) => datum),
+    ]);
+}
+function getBulletValues(series, seriesName) {
+    return series[seriesName].data.flatMap(({ data, markers, ranges }) => [
+        data,
+        ...((markers !== null && markers !== void 0 ? markers : [])).flatMap((datum) => datum),
+        ...((ranges !== null && ranges !== void 0 ? ranges : [])).flatMap((range) => range),
+    ]);
+}
+function getCoordinateDataValues(values, categories, hasDateValue) {
+    const yAxisValues = values
+        .filter((value) => !isNull(value))
+        .map((value) => getCoordinateYValue(value));
+    const xAxisValues = categories.map((value) => hasDateValue ? Number(new Date(value)) : Number(value));
+    return { xAxisValues, yAxisValues };
+}
+const dataRange = {
+    name: 'dataRange',
+    state: () => ({
+        dataRange: {},
+    }),
+    action: {
+        setDataRange({ state, initStoreState }) {
+            const { series, disabledSeries, stackSeries, categories, options } = state;
+            const seriesDataRange = {};
+            const labelAxisOnYAxis = isLabelAxisOnYAxis({ series, options, categories });
+            const { labelAxisName, valueAxisName } = getAxisName(labelAxisOnYAxis, series);
+            Object.keys(series).forEach((seriesName) => {
+                var _a, _b;
+                seriesDataRange[seriesName] = {};
+                let values = series[seriesName].data.flatMap(({ data, name }) => disabledSeries.includes(name) ? [] : data);
+                const firstExistValue = getFirstValidValue(values);
+                if (isCoordinateSeries(initStoreState.series)) {
+                    const hasDateValue = !!((_a = options.xAxis) === null || _a === void 0 ? void 0 : _a.date);
+                    const { yAxisValues, xAxisValues } = getCoordinateDataValues(values, categories, hasDateValue);
+                    values = yAxisValues;
+                    seriesDataRange[seriesName][labelAxisName] = getLimitSafely([...xAxisValues], true);
+                }
+                else if (!series[seriesName].data.length) {
+                    values = [];
+                }
+                else if (isRangeValue(firstExistValue)) {
+                    values = values.reduce((arr, value) => {
+                        if (isNull(value)) {
+                            return arr;
+                        }
+                        return Array.isArray(value) ? [...arr, ...value] : [...value];
+                    }, []);
+                }
+                else if (stackSeries && ((_b = stackSeries[seriesName]) === null || _b === void 0 ? void 0 : _b.stack)) {
+                    values = stackSeries[seriesName].dataRangeValues;
+                }
+                else if (seriesName === 'boxPlot') {
+                    values = getBoxPlotValues(series, seriesName);
+                }
+                else if (seriesName === 'bullet') {
+                    values = getBulletValues(series, seriesName);
+                }
+                if (includes(['bar', 'column', 'radar', 'bullet'], seriesName)) {
+                    values.push(0);
+                }
+                setSeriesDataRange({
+                    options,
+                    seriesName,
+                    values,
+                    valueAxisName,
+                    seriesDataRange,
+                });
+            });
+            const newDataRange = getTotalDataRange(seriesDataRange);
+            extend(state.dataRange, newDataRange);
+        },
+    },
+    observe: {
+        updateDataRange() {
+            this.dispatch('setDataRange');
+        },
+    },
+};
+export default dataRange;

package/dist/esm/store/gaugeAxes.d.ts

@@ -0,0 +1,4 @@
+import { StoreModule } from "../../types/store/store";
+export declare const DATA_LABEL_MARGIN = 30;
+declare const axes: StoreModule;
+export default axes;