@zendir/ui 0.1.8 → 0.1.9

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

@@ -1,999 +0,0 @@
-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