@hsu-react/ui 0.0.1

package/lib/components/Chart/_utils/autoScrollLegend.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.autoScrollLegend = autoScrollLegend;
+function autoScrollLegend(props) {
+  const {
+    chart,
+    total,
+    visibleCount = 8,
+    interval = 1500,
+    autoStart = true,
+    stopOnWheel = true
+  } = props;
+  let currentIndex = 0;
+  let scrollInterval = null;
+  let isManualScrolling = false;
+  function start() {
+    if (scrollInterval) {
+      stop();
+    }
+    scrollInterval = setInterval(() => {
+      currentIndex++;
+      if (currentIndex > total - visibleCount) {
+        currentIndex = 0;
+      }
+      chart.setOption({
+        legend: {
+          scrollDataIndex: currentIndex
+        }
+      });
+    }, interval);
+  }
+  function stop() {
+    if (scrollInterval) {
+      clearInterval(scrollInterval);
+      scrollInterval = null;
+    }
+  }
+  function handleMouseOver() {
+    stop();
+  }
+  function handleMouseOut() {
+    if (!isManualScrolling) {
+      start();
+    }
+  }
+  function handleWheel(event) {
+    const wheelEvent = event;
+    wheelEvent.preventDefault();
+    if (wheelEvent.deltaY > 0) {
+      currentIndex++;
+      if (currentIndex > total - visibleCount) {
+        currentIndex = total - visibleCount;
+      }
+    } else {
+      currentIndex--;
+      if (currentIndex < 0) {
+        currentIndex = 0;
+      }
+    }
+    chart.setOption({
+      legend: {
+        scrollDataIndex: currentIndex
+      }
+    });
+    if (stopOnWheel) {
+      isManualScrolling = true;
+      stop();
+    }
+  }
+  const chartDom = chart.getDom();
+  chartDom.addEventListener("mouseover", handleMouseOver);
+  chartDom.addEventListener("mouseout", handleMouseOut);
+  chartDom.addEventListener("wheel", handleWheel, {
+    passive: false
+  });
+  function dispose() {
+    stop();
+    chartDom.removeEventListener("mouseover", handleMouseOver);
+    chartDom.removeEventListener("mouseout", handleMouseOut);
+    chartDom.removeEventListener("wheel", handleWheel);
+  }
+  if (autoStart) {
+    start();
+  }
+  return {
+    start,
+    stop,
+    dispose
+  };
+}

package/lib/components/Chart/_utils/autoSmooth.d.ts

@@ -0,0 +1,15 @@
+import * as echarts from "echarts";
+export interface AutoScrollByItemProps {
+    chart: echarts.ECharts;
+    xAxisData?: Array<string>;
+    windowSize?: number;
+    interval?: number;
+    startIndex?: number;
+    autoPlay?: boolean;
+    enableWheelScroll?: boolean;
+}
+export declare function autoScrollByItem(props: AutoScrollByItemProps): {
+    pause: () => void;
+    resume: () => void;
+    dispose: () => void;
+};

package/lib/components/Chart/_utils/autoSmooth.js

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.autoScrollByItem = autoScrollByItem;
+function autoScrollByItem(props) {
+  const {
+    chart,
+    xAxisData,
+    windowSize = 10,
+    interval = 2000,
+    startIndex = 0,
+    autoPlay = true,
+    enableWheelScroll = true
+  } = props;
+  const total = xAxisData?.length ?? 0;
+  if (total <= 0) {
+    return {
+      pause: () => {},
+      resume: () => {},
+      dispose: () => {}
+    };
+  }
+  const initialStartIndex = Math.max(0, Math.min(startIndex, Math.max(total - 1, 0)));
+  const stepPercent = total > 0 ? 1 / total * 100 : 0;
+  const windowSizePercent = total > 0 ? windowSize / total * 100 : 100;
+  const initialStartPercent = total > 0 ? initialStartIndex / total * 100 : 0;
+  let start = initialStartPercent;
+  let end = Math.min(initialStartPercent + windowSizePercent, 100);
+  const syncDataZoomRange = () => {
+    const option = chart.getOption();
+    const currentDataZoom = option?.dataZoom;
+    if (!currentDataZoom?.length) return;
+    chart.setOption({
+      dataZoom: currentDataZoom.map(dz => ({
+        ...dz,
+        start,
+        end
+      }))
+    });
+  };
+  syncDataZoomRange();
+  let timer = null;
+  if (autoPlay) {
+    timer = setInterval(tick, interval);
+  }
+  function tick() {
+    start += stepPercent;
+    end += stepPercent;
+    if (end > 100) {
+      start = 0;
+      end = windowSizePercent;
+    }
+    syncDataZoomRange();
+  }
+  if (autoPlay) {
+    chart.getZr().on("mouseover", pause);
+    chart.getZr().on("mouseout", resume);
+  }
+  function pause() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  function resume() {
+    if (autoPlay && !timer) {
+      timer = setInterval(tick, interval);
+    }
+  }
+  const chartDom = chart.getDom();
+  const applyWheelDelta = delta => {
+    if (delta === 0) return;
+    const direction = delta > 0 ? 1 : -1;
+    start += direction * stepPercent;
+    end += direction * stepPercent;
+    if (start < 0) {
+      start = 0;
+      end = windowSizePercent;
+    }
+    if (end > 100) {
+      end = 100;
+      start = Math.max(0, 100 - windowSizePercent);
+    }
+    syncDataZoomRange();
+  };
+  function handleWheel(event) {
+    if (!enableWheelScroll) return;
+    const wheelEvent = event;
+    wheelEvent.preventDefault();
+    applyWheelDelta(wheelEvent.deltaY);
+  }
+  function handleZrMouseWheel(params) {
+    if (!enableWheelScroll) return;
+    const eventLike = params?.event;
+    const nativeEvent = eventLike?.event;
+    const deltaFromNative = nativeEvent?.deltaY;
+    const deltaFromEventLike = eventLike?.deltaY ?? eventLike?.zrDelta;
+    const wheelDelta = eventLike?.wheelDelta;
+    const resolvedDelta = deltaFromNative ?? deltaFromEventLike ?? (typeof wheelDelta === "number" ? -wheelDelta : undefined);
+    if (typeof resolvedDelta !== "number") return;
+    nativeEvent?.preventDefault();
+    applyWheelDelta(resolvedDelta);
+  }
+  if (enableWheelScroll) {
+    chartDom.addEventListener("wheel", handleWheel, {
+      passive: false
+    });
+    chart.getZr().on("mousewheel", handleZrMouseWheel);
+  }
+  const handleWindowResize = () => {
+    chart.resize();
+    syncDataZoomRange();
+  };
+  window.addEventListener("resize", handleWindowResize);
+  function dispose() {
+    pause();
+    if (autoPlay) {
+      chart.getZr().off("mouseover", pause);
+      chart.getZr().off("mouseout", resume);
+    }
+    if (enableWheelScroll) {
+      chartDom.removeEventListener("wheel", handleWheel);
+      chart.getZr().off("mousewheel", handleZrMouseWheel);
+    }
+    window.removeEventListener("resize", handleWindowResize);
+  }
+  return {
+    pause,
+    resume,
+    dispose
+  };
+}

package/lib/components/Chart/_utils/bubble.d.ts

@@ -0,0 +1,8 @@
+import * as echarts from "echarts";
+export declare const defaultBubbleColorList: echarts.Color[];
+export declare function calculateBubbleRadius(value: number, maxValue: number, baseSize: number): number;
+export declare function drawCircles(radiusList: number[], maxX: number, maxY: number): Array<{
+    x: number;
+    y: number;
+    radius: number;
+}>;

package/lib/components/Chart/_utils/bubble.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateBubbleRadius = calculateBubbleRadius;
+exports.defaultBubbleColorList = void 0;
+exports.drawCircles = drawCircles;
+const defaultBubbleColorList = exports.defaultBubbleColorList = ["#5470C6", "#91CC75", "#FAC858", "#EE6666", "#73C0DE", "#3BA272", "#FC8452", "#9A60B4", "#EA7CCC"];
+function calculateBubbleRadius(value, maxValue, baseSize) {
+  const number = Math.round(maxValue * 0.5);
+  const symbolSize = (value + number) / maxValue * baseSize;
+  return symbolSize / 2;
+}
+function isOverlapping(circle1, circle2, minGap) {
+  const distance = Math.hypot(circle1.x - circle2.x, circle1.y - circle2.y);
+  return distance < circle1.radius + circle2.radius + minGap;
+}
+function checkOverlapWithAll(circle, existingCircles, minGap) {
+  for (const existing of existingCircles) {
+    if (!existing) continue;
+    if (isOverlapping(circle, existing, minGap)) return true;
+  }
+  return false;
+}
+function getOverlapPenalty(circle, existingCircles, minGap) {
+  let penalty = 0;
+  for (const other of existingCircles) {
+    if (!other) continue;
+    const distance = Math.hypot(circle.x - other.x, circle.y - other.y);
+    const minDistance = circle.radius + other.radius + minGap;
+    if (distance < minDistance) {
+      penalty += minDistance - distance;
+    }
+  }
+  return penalty;
+}
+function drawCircles(radiusList, maxX, maxY) {
+  if (!radiusList.length) return [];
+  const circles = [];
+  const sortedIndices = radiusList.map((radius, index) => ({
+    radius,
+    index
+  })).sort((a, b) => b.radius - a.radius).map(item => item.index);
+  const centerX = maxX / 2;
+  const centerY = maxY / 2;
+  const minCanvas = Math.min(maxX, maxY);
+  const EDGE_PADDING = Math.max(8, Math.min(20, minCanvas * 0.06));
+  const avgRadius = radiusList.reduce((sum, radius) => sum + radius, 0) / radiusList.length;
+  const MIN_GAP = Math.max(1.5, avgRadius * 0.08);
+  const GOLDEN_ANGLE = Math.PI * (3 - Math.sqrt(5));
+
+  // 按容器长宽比例将同心圆扩展为同心椭圆（面积守恒：aspectX * aspectY = 1）：
+  // - 容器正方形时 aspectX = aspectY = 1（标准圆形环）
+  // - 容器越扁平，长边方向被适度拉伸、短边方向被对应压缩，
+  //   使层层外扩既贴合区域比例，又不会让边缘气泡飞离中心，保持"同心紧凑"观感。
+  const aspectRatio = maxY > 0 ? maxX / maxY : 1;
+  const aspectX = Math.sqrt(aspectRatio);
+  const aspectY = 1 / aspectX;
+  const ellipsePerimeter = (rx, ry) => {
+    if (rx <= 0 && ry <= 0) return 0;
+    const h = Math.pow(rx - ry, 2) / Math.max(1e-6, Math.pow(rx + ry, 2));
+    return Math.PI * (rx + ry) * (1 + 3 * h / (10 + Math.sqrt(Math.max(0, 4 - 3 * h))));
+  };
+  for (let orderIndex = 0; orderIndex < sortedIndices.length; orderIndex++) {
+    const originalIndex = sortedIndices[orderIndex];
+    const radius = radiusList[originalIndex];
+    const minX = radius + EDGE_PADDING;
+    const maxInnerX = maxX - radius - EDGE_PADDING;
+    const minY = radius + EDGE_PADDING;
+    const maxInnerY = maxY - radius - EDGE_PADDING;
+    if (minX >= maxInnerX || minY >= maxInnerY) {
+      circles[originalIndex] = {
+        x: centerX,
+        y: centerY,
+        radius
+      };
+      continue;
+    }
+
+    // 同心椭圆的"单位环半径"上限：需同时保证在 x、y 两个方向上不越界
+    const maxRingUnitX = aspectX > 0 ? Math.min(maxInnerX - centerX, centerX - minX) / aspectX : 0;
+    const maxRingUnitY = aspectY > 0 ? Math.min(maxInnerY - centerY, centerY - minY) / aspectY : 0;
+    const maxSearchRadius = Math.max(0, Math.min(maxRingUnitX, maxRingUnitY));
+    let placed = false;
+
+    // First bubble at center to ensure center-out expansion.
+    if (orderIndex === 0) {
+      const first = {
+        x: Math.max(minX, Math.min(maxInnerX, centerX)),
+        y: Math.max(minY, Math.min(maxInnerY, centerY)),
+        radius
+      };
+      circles[originalIndex] = first;
+      continue;
+    }
+
+    // 1) Deterministic concentric rings.
+    // 环间距要同时满足：
+    // - 与最大气泡（位于中心）不重叠：centerRadius + radius + gap
+    // - 标准六边形紧致堆叠：2 * avgRadius + gap
+    const centerRadius = radiusList[sortedIndices[0]] ?? avgRadius;
+    const ringSpacing = Math.max(centerRadius + radius + MIN_GAP, avgRadius * 2 + MIN_GAP, 8);
+    for (let ring = 1; ring * ringSpacing <= maxSearchRadius && !placed; ring++) {
+      const ringRadius = ring * ringSpacing;
+      const ringRadiusX = ringRadius * aspectX;
+      const ringRadiusY = ringRadius * aspectY;
+      const circumference = Math.max(1, ellipsePerimeter(ringRadiusX, ringRadiusY));
+      const slots = Math.max(8, Math.round(circumference / Math.max(radius * 2 + MIN_GAP, 10)));
+      const angleOffset = orderIndex * GOLDEN_ANGLE * 0.55 + ring * 0.25;
+      for (let slot = 0; slot < slots && !placed; slot++) {
+        const angle = angleOffset + slot / slots * Math.PI * 2;
+        const candidate = {
+          x: centerX + Math.cos(angle) * ringRadiusX,
+          y: centerY + Math.sin(angle) * ringRadiusY,
+          radius
+        };
+        if (candidate.x >= minX && candidate.x <= maxInnerX && candidate.y >= minY && candidate.y <= maxInnerY && !checkOverlapWithAll(candidate, circles, MIN_GAP)) {
+          circles[originalIndex] = candidate;
+          placed = true;
+        }
+      }
+    }
+
+    // 2) Center-out spiral fallback.
+    if (!placed) {
+      const spiralStep = Math.max(3, (avgRadius + radius + MIN_GAP) * 0.34);
+      const maxSteps = 1600;
+      for (let step = 1; step <= maxSteps && !placed; step++) {
+        const ringRadius = spiralStep * Math.sqrt(step);
+        if (ringRadius > maxSearchRadius) break;
+        const angle = step * GOLDEN_ANGLE + orderIndex * 0.31;
+        const candidate = {
+          x: centerX + Math.cos(angle) * ringRadius * aspectX,
+          y: centerY + Math.sin(angle) * ringRadius * aspectY,
+          radius
+        };
+        if (candidate.x >= minX && candidate.x <= maxInnerX && candidate.y >= minY && candidate.y <= maxInnerY && !checkOverlapWithAll(candidate, circles, MIN_GAP)) {
+          circles[originalIndex] = candidate;
+          placed = true;
+        }
+      }
+    }
+
+    // 3) Last resort: choose the least-overlap point on rings (keeps center-out trend).
+    if (!placed) {
+      let best = null;
+      let bestPenalty = Number.POSITIVE_INFINITY;
+      const levels = 40;
+      for (let level = 1; level <= levels; level++) {
+        const ringRadius = maxSearchRadius * level / levels;
+        const ringRadiusX = ringRadius * aspectX;
+        const ringRadiusY = ringRadius * aspectY;
+        const slots = Math.max(12, Math.round(ellipsePerimeter(ringRadiusX, ringRadiusY) / Math.max(radius + MIN_GAP, 8)));
+        const angleOffset = level * 0.21 + orderIndex * 0.17;
+        for (let slot = 0; slot < slots; slot++) {
+          const angle = angleOffset + slot / slots * Math.PI * 2;
+          const candidate = {
+            x: centerX + Math.cos(angle) * ringRadiusX,
+            y: centerY + Math.sin(angle) * ringRadiusY,
+            radius
+          };
+          if (candidate.x < minX || candidate.x > maxInnerX || candidate.y < minY || candidate.y > maxInnerY) {
+            continue;
+          }
+          const penalty = getOverlapPenalty(candidate, circles, MIN_GAP);
+          if (penalty < bestPenalty) {
+            bestPenalty = penalty;
+            best = candidate;
+            if (penalty === 0) break;
+          }
+        }
+        if (bestPenalty === 0) break;
+      }
+      circles[originalIndex] = best ?? {
+        x: Math.max(minX, Math.min(maxInnerX, centerX)),
+        y: Math.max(minY, Math.min(maxInnerY, centerY)),
+        radius
+      };
+    }
+  }
+  return circles.map((circle, index) => {
+    if (circle) return circle;
+    const radius = radiusList[index];
+    return {
+      x: centerX,
+      y: centerY,
+      radius
+    };
+  });
+}

package/lib/components/Chart/_utils/cartesian.d.ts

@@ -0,0 +1,25 @@
+import * as echarts from "echarts";
+import { ChartOptionType, SeriesDataType } from "..";
+export interface ChartScrollConfig {
+    enabled?: boolean;
+    autoScroll?: boolean;
+    windowSize?: number;
+    interval?: number;
+    startIndex?: number;
+    sliderVisible?: boolean;
+    wheelModeWhenSliderHidden?: "scroll" | "none";
+}
+export interface NormalizedScrollConfig {
+    zoomEnabled: boolean;
+    autoScroll: boolean;
+    windowSize: number;
+    interval: number;
+    startIndex: number;
+    sliderVisible?: boolean;
+    wheelModeWhenSliderHidden: "scroll" | "none";
+}
+export declare const createDefaultCategoryXAxis: (xAxisData?: Array<string>) => ChartOptionType;
+export declare const createDefaultValueYAxis: (mode?: "bar" | "line") => ChartOptionType;
+export declare const buildCartesianSeriesOptions: (mode: "bar" | "line", seriesData?: SeriesDataType, series?: echarts.SeriesOption | echarts.SeriesOption[]) => echarts.SeriesOption[];
+export declare const getSliderShow: (zoom?: echarts.DataZoomComponentOption | Record<string, unknown>) => boolean | undefined;
+export declare const resolveScrollConfig: (scrollConfig?: ChartScrollConfig) => NormalizedScrollConfig;

package/lib/components/Chart/_utils/cartesian.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveScrollConfig = exports.getSliderShow = exports.createDefaultValueYAxis = exports.createDefaultCategoryXAxis = exports.buildCartesianSeriesOptions = void 0;
+const createDefaultCategoryXAxis = xAxisData => ({
+  type: "category",
+  boundaryGap: true,
+  data: xAxisData,
+  axisLabel: {
+    interval: 0,
+    hideOverlap: true,
+    textStyle: {
+      fontSize: 14,
+      color: "#373D48"
+    }
+  },
+  axisTick: {
+    show: false
+  }
+});
+exports.createDefaultCategoryXAxis = createDefaultCategoryXAxis;
+const createDefaultValueYAxis = (mode = "bar") => ({
+  type: "value",
+  axisLabel: {
+    textStyle: {
+      fontSize: 14,
+      color: "#373D48"
+    }
+  },
+  splitLine: mode === "line" ? {
+    lineStyle: {
+      color: "#C9CED6",
+      type: "dashed"
+    }
+  } : {
+    show: false
+  }
+});
+exports.createDefaultValueYAxis = createDefaultValueYAxis;
+const buildCartesianSeriesOptions = (mode, seriesData, series) => {
+  const seriesStyle = mode === "bar" ? {
+    type: "bar",
+    barWidth: 20
+  } : {
+    type: "line",
+    symbol: "circle",
+    symbolSize: 8
+  };
+  if (!seriesData || seriesData.length === 0 || typeof seriesData[0] !== "object") {
+    if (Array.isArray(series)) {
+      return series.map(item => ({
+        data: seriesData,
+        ...seriesStyle,
+        ...item
+      }));
+    }
+    return [{
+      data: seriesData,
+      ...seriesStyle,
+      ...(series || {})
+    }];
+  }
+  const typedSeriesData = seriesData;
+  if (Array.isArray(series)) {
+    return series.flatMap(item => typedSeriesData.map(serie => ({
+      name: serie?.name,
+      data: serie?.value,
+      ...seriesStyle,
+      ...item,
+      ...serie?.series
+    })));
+  }
+  return typedSeriesData.map(serie => ({
+    name: serie?.name,
+    data: serie?.value,
+    ...seriesStyle,
+    ...(series || {}),
+    ...serie?.series
+  }));
+};
+exports.buildCartesianSeriesOptions = buildCartesianSeriesOptions;
+const getSliderShow = zoom => {
+  if (!zoom || typeof zoom !== "object") return undefined;
+  const maybeShow = zoom.show;
+  return typeof maybeShow === "boolean" ? maybeShow : undefined;
+};
+exports.getSliderShow = getSliderShow;
+const resolveScrollConfig = scrollConfig => ({
+  zoomEnabled: scrollConfig?.enabled ?? false,
+  autoScroll: scrollConfig?.autoScroll ?? false,
+  windowSize: scrollConfig?.windowSize ?? 10,
+  interval: scrollConfig?.interval ?? 2000,
+  startIndex: scrollConfig?.startIndex ?? 0,
+  sliderVisible: scrollConfig?.sliderVisible,
+  wheelModeWhenSliderHidden: scrollConfig?.wheelModeWhenSliderHidden ?? "scroll"
+});
+exports.resolveScrollConfig = resolveScrollConfig;

package/lib/components/Chart/_utils/heatmap.d.ts

@@ -0,0 +1,3 @@
+import { ChartOptionType } from "..";
+export declare const createDefaultHeatmapXAxis: (xAxisData?: string[]) => ChartOptionType;
+export declare const createDefaultHeatmapYAxis: (yAxisData?: string[]) => ChartOptionType;

package/lib/components/Chart/_utils/heatmap.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDefaultHeatmapYAxis = exports.createDefaultHeatmapXAxis = void 0;
+const createDefaultHeatmapXAxis = xAxisData => ({
+  type: "category",
+  data: xAxisData,
+  splitArea: {
+    show: true
+  },
+  axisLabel: {
+    interval: 0,
+    hideOverlap: true,
+    textStyle: {
+      fontSize: 14,
+      color: "#373D48"
+    }
+  },
+  axisTick: {
+    show: false
+  }
+});
+exports.createDefaultHeatmapXAxis = createDefaultHeatmapXAxis;
+const createDefaultHeatmapYAxis = yAxisData => ({
+  type: "category",
+  data: yAxisData,
+  splitArea: {
+    show: true
+  },
+  axisLabel: {
+    textStyle: {
+      fontSize: 14,
+      color: "#373D48"
+    }
+  },
+  axisTick: {
+    show: false
+  }
+});
+exports.createDefaultHeatmapYAxis = createDefaultHeatmapYAxis;

package/lib/components/Chart/_utils/tree.d.ts

@@ -0,0 +1,2 @@
+import { SeriesData } from "..";
+export declare const handleTreeData: (datas: SeriesData[], index: number, color?: string) => SeriesData<number | undefined>[];

package/lib/components/Chart/_utils/tree.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleTreeData = void 0;
+const handleTreeData = (datas, index, color = "#00f6ff") => {
+  return datas?.map(item => {
+    if (item.changedStatus === 1) {
+      color = "#FFB336";
+    } else if (item.changedStatus === 2) {
+      color = "#156FFF";
+    } else {
+      color = "#156FFF";
+    }
+    if (item.children) {
+      item.label = {
+        position: "insideBottom"
+      };
+    }
+    item.lineStyle = {
+      color
+    };
+    if (item.children) {
+      item.itemStyle = {
+        borderColor: color,
+        color
+      };
+      item.children = handleTreeData(item.children, index + 1, color);
+    } else {
+      item.itemStyle = {
+        color: "transparent",
+        borderColor: color
+      };
+    }
+    return item;
+  });
+};
+exports.handleTreeData = handleTreeData;

package/lib/components/Chart/chartUtils/calculateAxisConfig.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 计算合适的Y轴范围和间隔，确保0是刻度点，且总刻度数固定为6个
+ * @param min 最小值
+ * @param max 最大值
+ * @returns { min, max, interval } Y轴配置
+ */
+export declare function calculateAxisConfig(min: number, max: number): {
+    min: number;
+    max: number;
+    interval: number;
+};