@zendir/ui 0.1.0

package/dist/react/charts/unified/presets.js

@@ -0,0 +1,999 @@
+import { jsx } from "react/jsx-runtime";
+import { memo, forwardRef } from "react";
+import { AstroChart } from "./AstroChart.js";
+import { ASTRO_DATA_VIZ_COLORS } from "./theme.js";
+import { useTheme } from "../../theme/ThemeProvider.js";
+const SOFT_STATUS_COLORS = {
+  normal: "#6ed86e",
+  caution: "#ffd54f",
+  critical: "#e57373"
+};
+const LineChart = memo(forwardRef(
+  function LineChart2({ smooth = true, showPoints = false, showArea = false, series = [], ...props }, ref) {
+    const transformedSeries = series.map((s) => ({
+      ...s,
+      type: showArea ? "area" : "line",
+      smooth,
+      symbol: showPoints ? { type: "circle", size: 6 } : { type: "none" }
+    }));
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: showArea ? "area" : "line",
+        series: transformedSeries,
+        tooltip: { trigger: "axis", crosshair: "x" },
+        ...props
+      }
+    );
+  }
+));
+const AreaChart = memo(forwardRef(
+  function AreaChart2({ stacked = false, smooth = true, series = [], ...props }, ref) {
+    const transformedSeries = series.map((s, _i) => ({
+      ...s,
+      type: "area",
+      smooth,
+      stack: stacked ? "total" : void 0,
+      areaStyle: { opacity: stacked ? 0.8 : 0.3 }
+    }));
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "area",
+        series: transformedSeries,
+        tooltip: { trigger: "axis", crosshair: "x" },
+        ...props
+      }
+    );
+  }
+));
+const BarChart = memo(forwardRef(
+  function BarChart2({ stacked = false, horizontal = false, series = [], xAxis, yAxis, ...props }, ref) {
+    const transformedSeries = series.map((s) => ({
+      ...s,
+      type: "bar",
+      stack: stacked ? "total" : void 0
+    }));
+    const finalXAxis = horizontal ? { type: "value", ...yAxis } : { type: "category", ...xAxis };
+    const finalYAxis = horizontal ? { type: "category", ...xAxis } : { type: "value", ...yAxis };
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "bar",
+        series: transformedSeries,
+        xAxis: finalXAxis,
+        yAxis: finalYAxis,
+        tooltip: { trigger: "axis" },
+        ...props
+      }
+    );
+  }
+));
+const ScatterChart = memo(forwardRef(
+  function ScatterChart2({ symbolSize = 10, series = [], ...props }, ref) {
+    const transformedSeries = series.map((s) => ({
+      ...s,
+      type: "scatter",
+      symbol: {
+        type: "circle",
+        size: typeof symbolSize === "number" ? symbolSize : 10
+      }
+    }));
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "scatter",
+        series: transformedSeries,
+        tooltip: { trigger: "item" },
+        xAxis: { type: "value" },
+        yAxis: { type: "value" },
+        ...props
+      }
+    );
+  }
+));
+const PieChart = memo(forwardRef(
+  function PieChart2({
+    donut = false,
+    innerRadius = "40%",
+    outerRadius = "70%",
+    showLabels = true,
+    series = [],
+    ...props
+  }, ref) {
+    const transformedSeries = series.map((s) => ({
+      ...s,
+      type: donut ? "donut" : "pie"
+    }));
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: donut ? "donut" : "pie",
+        series: transformedSeries,
+        tooltip: { trigger: "item" },
+        echartsOptions: {
+          series: [{
+            radius: donut ? [innerRadius, outerRadius] : outerRadius,
+            label: {
+              show: showLabels,
+              formatter: "{b}: {d}%"
+            }
+          }]
+        },
+        ...props
+      }
+    );
+  }
+));
+const DonutChart = memo(forwardRef(
+  function DonutChart2(props, ref) {
+    return /* @__PURE__ */ jsx(PieChart, { ref, donut: true, ...props });
+  }
+));
+const GaugeChart = memo(forwardRef(
+  function GaugeChart2({
+    value,
+    min = 0,
+    max = 100,
+    unit = "%",
+    label,
+    thresholds,
+    progress = true,
+    showPointer = true,
+    width = 220,
+    height = 220,
+    ...props
+  }, ref) {
+    var _a;
+    const { tokens } = useTheme();
+    const range = max - min;
+    const safeRange = range === 0 ? 1 : range;
+    const clampedValue = Math.max(min, Math.min(max, value));
+    const widthPx = typeof width === "number" ? width : typeof height === "number" ? height : 220;
+    const heightPx = typeof height === "number" ? height : 220;
+    const gaugeSize = Math.max(120, Math.min(widthPx, heightPx));
+    const compactGauge = gaugeSize < 170;
+    const arcWidth = Math.max(8, Math.round(gaugeSize * 0.07));
+    const valueFontSize = Math.max(16, Math.round(gaugeSize * 0.15));
+    const labelFontSize = Math.max(10, Math.round(gaugeSize * 0.07));
+    const unitSuffix = (unit == null ? void 0 : unit.trim()) ?? "";
+    const longUnit = unitSuffix.length > 4;
+    const series = [{
+      id: "gauge",
+      name: label || "Value",
+      type: "gauge",
+      data: [{ x: 0, y: clampedValue }]
+    }];
+    const normalizedThresholds = [...thresholds ?? []].filter((t) => Number.isFinite(t.value)).sort((a, b) => a.value - b.value);
+    const colorStops = normalizedThresholds.map((t) => [
+      Math.max(0, Math.min(1, (t.value - min) / safeRange)),
+      t.color
+    ]);
+    if (colorStops.length === 0) {
+      colorStops.push(
+        [0.3, SOFT_STATUS_COLORS.normal],
+        [0.7, SOFT_STATUS_COLORS.caution],
+        [1, SOFT_STATUS_COLORS.critical]
+      );
+    } else if (colorStops[colorStops.length - 1][0] < 1) {
+      colorStops.push([1, colorStops[colorStops.length - 1][1]]);
+    }
+    const activeColor = ((_a = [...colorStops].reverse().find(([stop]) => stop <= (clampedValue - min) / safeRange)) == null ? void 0 : _a[1]) ?? SOFT_STATUS_COLORS.normal;
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "gauge",
+        series,
+        width,
+        height,
+        echartsOptions: {
+          series: [{
+            type: "gauge",
+            min,
+            max,
+            progress: {
+              show: progress,
+              width: arcWidth,
+              roundCap: true
+            },
+            axisLine: {
+              lineStyle: {
+                width: arcWidth,
+                color: colorStops
+              }
+            },
+            axisTick: { show: false },
+            splitLine: { show: false },
+            axisLabel: { show: false },
+            pointer: {
+              show: showPointer,
+              length: compactGauge ? "56%" : "60%",
+              width: Math.max(3, Math.round(arcWidth * 0.38))
+            },
+            title: {
+              show: !!label,
+              offsetCenter: [0, compactGauge ? "73%" : "78%"],
+              fontSize: labelFontSize,
+              color: tokens.colors.text.secondary
+            },
+            detail: {
+              valueAnimation: true,
+              formatter: (currentValue) => {
+                const rounded = Math.round(currentValue);
+                if (!unitSuffix) return `${rounded}`;
+                if (longUnit) return `${rounded}
+{unit|${unitSuffix}}`;
+                return `${rounded}${unitSuffix}`;
+              },
+              rich: {
+                unit: {
+                  color: tokens.colors.text.secondary,
+                  fontSize: Math.max(10, Math.round(valueFontSize * 0.48)),
+                  fontWeight: 500,
+                  lineHeight: Math.round(valueFontSize * 0.78)
+                }
+              },
+              lineHeight: Math.round(valueFontSize * 1.05),
+              fontSize: valueFontSize,
+              fontWeight: 700,
+              offsetCenter: [0, compactGauge ? "10%" : "14%"],
+              color: activeColor
+            },
+            data: [{ value: clampedValue, name: label }]
+          }]
+        },
+        ...props
+      }
+    );
+  }
+));
+const RadarChart = memo(forwardRef(
+  function RadarChart2({ indicators, areaStyle = true, series = [], ...props }, ref) {
+    const extractValues = (data) => {
+      if (!data || data.length === 0) return [];
+      const first = data[0];
+      if (typeof first === "number") return data;
+      if (typeof first === "object" && first !== null && "y" in first) {
+        return data.map((d) => d.y);
+      }
+      return [];
+    };
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "radar",
+        series: [],
+        tooltip: { trigger: "item" },
+        echartsOptions: {
+          radar: {
+            indicator: indicators,
+            shape: "polygon"
+          },
+          series: series.map((s) => ({
+            type: "radar",
+            name: s.name,
+            data: [{
+              value: extractValues(s.data),
+              name: s.name
+            }],
+            areaStyle: areaStyle ? { opacity: 0.3 } : void 0
+          }))
+        },
+        ...props
+      }
+    );
+  }
+));
+const HeatmapChart = memo(forwardRef(
+  function HeatmapChart2({
+    xCategories,
+    yCategories,
+    valueRange = [0, 100],
+    showLabels = true,
+    series = [],
+    ...props
+  }, ref) {
+    var _a;
+    const heatmapData = (_a = series[0]) == null ? void 0 : _a.data;
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "heatmap",
+        series,
+        xAxis: { type: "category" },
+        yAxis: { type: "category" },
+        tooltip: { trigger: "item" },
+        echartsOptions: {
+          xAxis: { data: xCategories },
+          yAxis: { data: yCategories },
+          visualMap: {
+            min: valueRange[0],
+            max: valueRange[1],
+            calculable: true,
+            orient: "horizontal",
+            left: "center",
+            bottom: "5%"
+          },
+          series: [{
+            type: "heatmap",
+            data: heatmapData,
+            label: {
+              show: showLabels
+            },
+            emphasis: {
+              itemStyle: {
+                shadowBlur: 10,
+                shadowColor: "rgba(0, 0, 0, 0.5)"
+              }
+            }
+          }]
+        },
+        ...props
+      }
+    );
+  }
+));
+const TimeSeriesChart = memo(forwardRef(
+  function TimeSeriesChart2({
+    timeWindow,
+    maxPoints = 1e3,
+    autoScroll = true,
+    showCurrentValues: _showCurrentValues = true,
+    series = [],
+    ...props
+  }, ref) {
+    const xAxis = {
+      type: "time",
+      ...timeWindow ? {
+        min: "dataMin",
+        max: "dataMax"
+      } : {}
+    };
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "line",
+        series: series.map((s) => ({
+          ...s,
+          smooth: true,
+          symbol: { type: "none" }
+        })),
+        xAxis,
+        tooltip: {
+          trigger: "axis",
+          crosshair: "x"
+        },
+        zoom: autoScroll ? void 0 : {
+          enabled: true,
+          type: "both",
+          axis: "x"
+        },
+        realTime: {
+          enabled: true,
+          maxPoints,
+          timeWindow,
+          shift: autoScroll
+        },
+        ...props
+      }
+    );
+  }
+));
+const DualAxisChart = memo(forwardRef(
+  function DualAxisChart2({ leftAxis, rightAxis, series = [], ...props }, ref) {
+    const transformedSeries = series.map((s, i) => ({
+      ...s,
+      yAxisIndex: s.yAxisIndex ?? i % 2
+      // Alternate by default
+    }));
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "line",
+        series: transformedSeries,
+        yAxis: [
+          { position: "left", ...leftAxis },
+          { position: "right", ...rightAxis }
+        ],
+        tooltip: { trigger: "axis", crosshair: "x" },
+        ...props
+      }
+    );
+  }
+));
+const StackedAreaChart = memo(forwardRef(
+  function StackedAreaChart2(props, ref) {
+    return /* @__PURE__ */ jsx(AreaChart, { ref, stacked: true, ...props });
+  }
+));
+const StackedBarChart = memo(forwardRef(
+  function StackedBarChart2(props, ref) {
+    return /* @__PURE__ */ jsx(BarChart, { ref, stacked: true, ...props });
+  }
+));
+const BubbleChart = memo(forwardRef(
+  function BubbleChart2({
+    minSize = 10,
+    maxSize = 60,
+    showSizeLegend = true,
+    series = [],
+    ...props
+  }, ref) {
+    const transformedSeries = series.map((s) => ({
+      ...s,
+      type: "scatter"
+    }));
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "scatter",
+        series: transformedSeries,
+        tooltip: { trigger: "item" },
+        echartsOptions: {
+          series: series.map((s, _idx) => {
+            const data = s.data;
+            return {
+              type: "scatter",
+              name: s.name,
+              data: data.map((d) => {
+                if (Array.isArray(d)) return d;
+                return [d.x, d.y, d.size ?? 10];
+              }),
+              symbolSize: (val) => {
+                const size = val[2] ?? minSize;
+                return Math.max(minSize, Math.min(maxSize, size));
+              }
+            };
+          }),
+          visualMap: showSizeLegend ? {
+            show: true,
+            dimension: 2,
+            min: 0,
+            max: 100,
+            inRange: { symbolSize: [minSize, maxSize] },
+            right: 10,
+            top: "center"
+          } : void 0
+        },
+        ...props
+      }
+    );
+  }
+));
+const HistogramChart = memo(forwardRef(
+  function HistogramChart2({
+    bins: _bins = 20,
+    showCurve: _showCurve = false,
+    series = [],
+    xAxis,
+    ...props
+  }, ref) {
+    const transformedSeries = series.map((s) => ({
+      ...s,
+      type: "bar"
+    }));
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "bar",
+        series: transformedSeries,
+        xAxis: { type: "category", ...xAxis },
+        yAxis: { type: "value", name: "Frequency" },
+        tooltip: { trigger: "axis" },
+        echartsOptions: {
+          series: series.map((s) => ({
+            type: "bar",
+            name: s.name,
+            data: s.data,
+            barWidth: "90%",
+            itemStyle: { borderRadius: [2, 2, 0, 0] }
+          }))
+        },
+        ...props
+      }
+    );
+  }
+));
+const SankeyChart = memo(forwardRef(
+  function SankeyChart2({
+    nodes = [],
+    links = [],
+    orient = "horizontal",
+    ...props
+  }, ref) {
+    const { tokens } = useTheme();
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "sankey",
+        series: [],
+        echartsOptions: {
+          tooltip: {
+            trigger: "item",
+            triggerOn: "mousemove"
+          },
+          series: [{
+            type: "sankey",
+            orient,
+            layoutIterations: 32,
+            emphasis: { focus: "adjacency" },
+            nodeAlign: "justify",
+            lineStyle: { color: "gradient", curveness: 0.5 },
+            data: nodes,
+            links,
+            label: {
+              color: tokens.colors.text.primary,
+              fontSize: 12
+            }
+          }]
+        },
+        ...props
+      }
+    );
+  }
+));
+const TreemapChart = memo(forwardRef(
+  function TreemapChart2({
+    data = [],
+    showBreadcrumb = true,
+    leafDepth = 2,
+    ...props
+  }, ref) {
+    const { tokens } = useTheme();
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "treemap",
+        series: [],
+        echartsOptions: {
+          tooltip: {
+            formatter: (info) => {
+              const value = info.value;
+              const name = info.name;
+              return `${name}: ${typeof value === "number" ? value.toLocaleString() : value}`;
+            }
+          },
+          series: [{
+            type: "treemap",
+            data,
+            leafDepth,
+            roam: false,
+            // AstroUXDS compliant breadcrumb navigation
+            breadcrumb: {
+              show: showBreadcrumb,
+              bottom: 10,
+              itemStyle: { color: "rgba(100, 116, 139, 0.6)" }
+              // Subtle grey
+            },
+            label: {
+              show: true,
+              formatter: "{b}",
+              color: tokens.colors.text.primary,
+              fontSize: 12
+            },
+            upperLabel: {
+              show: true,
+              height: 30,
+              color: tokens.colors.text.secondary
+            },
+            // AstroUXDS compliant borders - subtle grey
+            itemStyle: {
+              borderColor: "rgba(100, 116, 139, 0.2)",
+              borderWidth: 2,
+              gapWidth: 2
+            },
+            levels: [
+              {
+                itemStyle: { borderColor: "rgba(100, 116, 139, 0.3)", borderWidth: 4, gapWidth: 4 },
+                upperLabel: { show: false }
+              },
+              {
+                itemStyle: { borderColor: "rgba(100, 116, 139, 0.25)", borderWidth: 2, gapWidth: 2 },
+                emphasis: { itemStyle: { borderColor: ASTRO_DATA_VIZ_COLORS.mixed[0] } }
+                // Zendir Electric on hover
+              },
+              {
+                colorSaturation: [0.35, 0.5],
+                itemStyle: { borderColor: "rgba(62, 60, 255, 0.3)", borderWidth: 1 }
+                // Zendir Electric subtle
+              }
+            ]
+          }]
+        },
+        ...props
+      }
+    );
+  }
+));
+const SunburstChart = memo(forwardRef(
+  function SunburstChart2({
+    data = [],
+    innerRadius = "15%",
+    outerRadius = "80%",
+    ...props
+  }, ref) {
+    const { tokens } = useTheme();
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "sunburst",
+        series: [],
+        echartsOptions: {
+          tooltip: {
+            trigger: "item"
+          },
+          // Zendir-branded sunburst visualization
+          series: [{
+            type: "sunburst",
+            data,
+            radius: [innerRadius, outerRadius],
+            emphasis: { focus: "ancestor" },
+            label: {
+              rotate: "radial",
+              color: tokens.colors.text.secondary,
+              fontSize: 11
+            },
+            itemStyle: {
+              borderRadius: 4,
+              borderWidth: 2,
+              borderColor: "rgba(62, 60, 255, 0.25)"
+              // Zendir Electric subtle border
+            },
+            levels: [
+              {},
+              { r0: "15%", r: "40%", label: { rotate: "tangential" } },
+              { r0: "40%", r: "65%" },
+              { r0: "65%", r: "80%", label: { position: "outside", fontSize: 10 } }
+            ]
+          }]
+        },
+        ...props
+      }
+    );
+  }
+));
+const ParallelChart = memo(forwardRef(
+  function ParallelChart2({
+    axes = [],
+    data = [],
+    lineStyle = { opacity: 0.5, width: 1.5 },
+    ...props
+  }, ref) {
+    const { tokens } = useTheme();
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "line",
+        series: [],
+        echartsOptions: {
+          parallelAxis: axes.map((axis) => ({
+            dim: axis.dim,
+            name: axis.name,
+            min: axis.min,
+            max: axis.max,
+            type: axis.type || "value",
+            data: axis.data,
+            nameTextStyle: { color: tokens.colors.text.secondary },
+            axisLine: { lineStyle: { color: "rgba(100, 116, 139, 0.3)" } },
+            axisTick: { lineStyle: { color: "rgba(100, 116, 139, 0.3)" } },
+            axisLabel: { color: tokens.colors.text.tertiary }
+          })),
+          parallel: {
+            left: 60,
+            right: 60,
+            bottom: 60,
+            top: 60,
+            parallelAxisDefault: {
+              type: "value",
+              nameLocation: "end",
+              nameGap: 20,
+              axisLine: { lineStyle: { color: "rgba(100, 116, 139, 0.3)" } },
+              axisTick: { lineStyle: { color: "rgba(100, 116, 139, 0.3)" } },
+              splitLine: { show: false },
+              axisLabel: { color: tokens.colors.text.tertiary }
+            }
+          },
+          series: [{
+            type: "parallel",
+            lineStyle: {
+              ...lineStyle,
+              color: ASTRO_DATA_VIZ_COLORS.mixed[0]
+              // Zendir Electric
+            },
+            data: data.map((row) => ({ value: row })),
+            emphasis: {
+              lineStyle: { width: 3, opacity: 1 }
+            }
+          }]
+        },
+        ...props
+      }
+    );
+  }
+));
+const CandlestickChart = memo(forwardRef(
+  function CandlestickChart2({
+    data = [],
+    showVolume: _showVolume = false,
+    ...props
+  }, ref) {
+    const { tokens } = useTheme();
+    const categoryData = data.map((d) => d.time);
+    const ohlcData = data.map((d) => [d.open, d.close, d.low, d.high]);
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "candlestick",
+        series: [],
+        echartsOptions: {
+          tooltip: {
+            trigger: "axis",
+            axisPointer: { type: "cross" }
+          },
+          xAxis: {
+            type: "category",
+            data: categoryData,
+            axisLine: { lineStyle: { color: "rgba(100, 116, 139, 0.3)" } },
+            axisLabel: { color: tokens.colors.text.secondary }
+          },
+          yAxis: {
+            type: "value",
+            scale: true,
+            splitLine: { lineStyle: { color: "rgba(100, 116, 139, 0.15)" } },
+            axisLine: { lineStyle: { color: "rgba(100, 116, 139, 0.3)" } },
+            axisLabel: { color: tokens.colors.text.secondary }
+          },
+          series: [{
+            type: "candlestick",
+            data: ohlcData,
+            itemStyle: {
+              color: SOFT_STATUS_COLORS.normal,
+              // AstroUXDS green (up/bullish)
+              color0: SOFT_STATUS_COLORS.critical,
+              // AstroUXDS red (down/bearish)
+              borderColor: SOFT_STATUS_COLORS.normal,
+              borderColor0: SOFT_STATUS_COLORS.critical
+            }
+          }],
+          dataZoom: [
+            { type: "inside", start: 0, end: 100 },
+            { show: true, type: "slider", bottom: 10 }
+          ]
+        },
+        ...props
+      }
+    );
+  }
+));
+const GraphChart = memo(forwardRef(
+  function GraphChart2({
+    nodes = [],
+    links = [],
+    categories = [],
+    layout = "force",
+    ...props
+  }, ref) {
+    const { tokens } = useTheme();
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "scatter",
+        series: [],
+        echartsOptions: {
+          tooltip: {},
+          legend: categories.length > 0 ? {
+            data: categories.map((c) => c.name),
+            textStyle: { color: tokens.colors.text.primary }
+          } : void 0,
+          series: [{
+            type: "graph",
+            layout,
+            data: nodes.map((n) => ({
+              ...n,
+              symbolSize: n.symbolSize || 30
+            })),
+            links,
+            categories,
+            roam: true,
+            label: {
+              show: true,
+              position: "right",
+              formatter: "{b}",
+              color: tokens.colors.text.primary,
+              fontSize: 11
+            },
+            lineStyle: {
+              color: "source",
+              curveness: 0.3,
+              opacity: 0.6
+            },
+            emphasis: {
+              focus: "adjacency",
+              lineStyle: { width: 3 }
+            },
+            force: layout === "force" ? {
+              repulsion: 200,
+              edgeLength: [50, 150],
+              gravity: 0.1
+            } : void 0
+          }]
+        },
+        ...props
+      }
+    );
+  }
+));
+function calculateBoxplotStats(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const n = sorted.length;
+  const min = sorted[0];
+  const max = sorted[n - 1];
+  const median = n % 2 === 0 ? (sorted[n / 2 - 1] + sorted[n / 2]) / 2 : sorted[Math.floor(n / 2)];
+  const q1Index = Math.floor(n * 0.25);
+  const q3Index = Math.floor(n * 0.75);
+  const q1 = sorted[q1Index];
+  const q3 = sorted[q3Index];
+  const iqr = q3 - q1;
+  const lowerWhisker = Math.max(min, q1 - 1.5 * iqr);
+  const upperWhisker = Math.min(max, q3 + 1.5 * iqr);
+  return [lowerWhisker, q1, median, q3, upperWhisker];
+}
+memo(forwardRef(
+  function BoxPlotChart2({
+    data = [],
+    showOutliers = true,
+    colors,
+    horizontal = false,
+    ...props
+  }, ref) {
+    const { tokens } = useTheme();
+    const categories = data.map((d) => d.name);
+    const boxplotData = data.map((d, index) => {
+      const stats = calculateBoxplotStats(d.values);
+      return {
+        value: stats,
+        itemStyle: (colors == null ? void 0 : colors[index]) ? {
+          color: colors[index],
+          borderColor: colors[index]
+        } : void 0
+      };
+    });
+    const outliers = [];
+    if (showOutliers) {
+      data.forEach((d, catIndex) => {
+        const sorted = [...d.values].sort((a, b) => a - b);
+        const n = sorted.length;
+        const q1Index = Math.floor(n * 0.25);
+        const q3Index = Math.floor(n * 0.75);
+        const q1 = sorted[q1Index];
+        const q3 = sorted[q3Index];
+        const iqr = q3 - q1;
+        const lowerBound = q1 - 1.5 * iqr;
+        const upperBound = q3 + 1.5 * iqr;
+        d.values.forEach((v) => {
+          if (v < lowerBound || v > upperBound) {
+            outliers.push([catIndex, v]);
+          }
+        });
+      });
+    }
+    const categoryAxis = {
+      type: "category",
+      data: categories,
+      boundaryGap: true,
+      axisLine: { lineStyle: { color: "rgba(100, 116, 139, 0.3)" } },
+      axisLabel: { color: tokens.colors.text.secondary, fontSize: 12 },
+      splitArea: { show: false }
+    };
+    const valueAxis = {
+      type: "value",
+      splitLine: { lineStyle: { color: "rgba(100, 116, 139, 0.15)" } },
+      axisLine: { lineStyle: { color: "rgba(100, 116, 139, 0.3)" } },
+      axisLabel: { color: tokens.colors.text.secondary }
+    };
+    return /* @__PURE__ */ jsx(
+      AstroChart,
+      {
+        ref,
+        type: "boxplot",
+        series: [],
+        echartsOptions: {
+          tooltip: {
+            trigger: "item",
+            axisPointer: { type: "shadow" },
+            formatter: (params) => {
+              var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+              if (params.seriesType === "boxplot") {
+                const value = params.value;
+                return `
+                  <div style="font-weight: 600; margin-bottom: 4px;">${params.name}</div>
+                  <div>Upper: ${((_a = value[5]) == null ? void 0 : _a.toFixed(1)) ?? ((_b = value[4]) == null ? void 0 : _b.toFixed(1))}</div>
+                  <div>Q3: ${((_c = value[4]) == null ? void 0 : _c.toFixed(1)) ?? ((_d = value[3]) == null ? void 0 : _d.toFixed(1))}</div>
+                  <div>Median: ${((_e = value[3]) == null ? void 0 : _e.toFixed(1)) ?? ((_f = value[2]) == null ? void 0 : _f.toFixed(1))}</div>
+                  <div>Q1: ${((_g = value[2]) == null ? void 0 : _g.toFixed(1)) ?? ((_h = value[1]) == null ? void 0 : _h.toFixed(1))}</div>
+                  <div>Lower: ${((_i = value[1]) == null ? void 0 : _i.toFixed(1)) ?? ((_j = value[0]) == null ? void 0 : _j.toFixed(1))}</div>
+                `;
+              }
+              return `Outlier: ${params.value[1]}`;
+            }
+          },
+          grid: {
+            left: "10%",
+            right: "10%",
+            bottom: "15%",
+            top: "15%"
+          },
+          xAxis: horizontal ? valueAxis : categoryAxis,
+          yAxis: horizontal ? categoryAxis : valueAxis,
+          series: [
+            {
+              name: "boxplot",
+              type: "boxplot",
+              data: boxplotData,
+              itemStyle: {
+                borderWidth: 2
+              },
+              emphasis: {
+                itemStyle: {
+                  borderWidth: 3
+                }
+              }
+            },
+            ...showOutliers && outliers.length > 0 ? [{
+              name: "outlier",
+              type: "scatter",
+              data: outliers,
+              symbolSize: 8,
+              itemStyle: {
+                color: SOFT_STATUS_COLORS.caution
+              }
+            }] : []
+          ]
+        },
+        ...props
+      }
+    );
+  }
+));
+export {
+  AreaChart,
+  BarChart,
+  BubbleChart,
+  CandlestickChart,
+  DonutChart,
+  DualAxisChart,
+  GaugeChart,
+  GraphChart,
+  HeatmapChart,
+  HistogramChart,
+  LineChart,
+  ParallelChart,
+  PieChart,
+  RadarChart,
+  SankeyChart,
+  ScatterChart,
+  StackedAreaChart,
+  StackedBarChart,
+  SunburstChart,
+  TimeSeriesChart,
+  TreemapChart
+};
+//# sourceMappingURL=presets.js.map