@expcat/tigercat-react 1.0.7 → 1.2.0

package/dist/chunk-EOU6WZTS.js

@@ -0,0 +1,647 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkXTV5JLLCjs = require('./chunk-XTV5JLLC.js');
+
+
+var _chunkWV5XHYW6js = require('./chunk-WV5XHYW6.js');
+
+
+var _chunkAX5XRD2Qjs = require('./chunk-AX5XRD2Q.js');
+
+
+var _chunkUVMQJOTXjs = require('./chunk-UVMQJOTX.js');
+
+
+var _chunkUKLVOR4Ejs = require('./chunk-UKLVOR4E.js');
+
+// src/components/RadarChart.tsx
+var _react = require('react');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
+var RadarChart = ({
+  width = 320,
+  height = 200,
+  padding = 24,
+  data,
+  series,
+  maxValue,
+  startAngle = -Math.PI / 2,
+  levels = 5,
+  showLevelLabels = false,
+  showGrid = true,
+  showAxis = true,
+  showLabels = true,
+  labelOffset = 12,
+  labelFormatter,
+  levelLabelFormatter,
+  levelLabelOffset = 8,
+  colors,
+  gridLineStyle = "solid",
+  gridStrokeWidth = 1,
+  hoverable = false,
+  hoveredIndex: hoveredIndexProp,
+  activeOpacity = 1,
+  inactiveOpacity = 0.25,
+  showTooltip = true,
+  tooltipFormatter,
+  selectable = false,
+  selectedIndex: selectedIndexProp,
+  onHoveredIndexChange,
+  onSelectedIndexChange,
+  onSeriesClick,
+  onSeriesHover,
+  showLegend = false,
+  legendPosition = "bottom",
+  legendFormatter,
+  legendMarkerSize = 10,
+  legendGap = 8,
+  strokeColor,
+  strokeWidth = 2,
+  fillColor,
+  fillOpacity = 0.2,
+  showPoints = true,
+  pointSize = 3,
+  pointColor,
+  gridShape = "polygon",
+  showSplitArea = false,
+  splitAreaOpacity = 0.06,
+  splitAreaColors,
+  gradient = false,
+  strokeGradient = false,
+  pointGradient = false,
+  pointBorderWidth = 2,
+  pointBorderColor = "var(--tiger-surface,#ffffff)",
+  pointHoverSize,
+  labelAutoAlign = true,
+  title,
+  desc,
+  className
+}) => {
+  const resolvedSeries = _react.useMemo.call(void 0, 
+    () => _tigercatcore.resolveSeriesData.call(void 0, series, data, {
+      data: []
+    }),
+    [series, data]
+  );
+  const seriesKeys = _react.useMemo.call(void 0, 
+    () => _tigercatcore.buildChartSeriesKeys.call(void 0, resolvedSeries, { prefix: "radar-" }),
+    [resolvedSeries]
+  );
+  const {
+    resolvedHoveredIndex: _resolvedHoveredIndex,
+    resolvedSelectedIndex: _resolvedSelectedIndex,
+    activeIndex: resolvedActiveIndex,
+    tooltipPosition,
+    handleMouseEnter: handleHoverEnter,
+    handleMouseMove,
+    handleMouseLeave: handleHoverLeave,
+    handleClick: handleSelectIndex,
+    handleLegendClick,
+    handleLegendHover,
+    handleLegendLeave,
+    wrapperClasses
+  } = _chunkXTV5JLLCjs.useChartInteraction.call(void 0, {
+    hoverable,
+    hoveredIndexProp,
+    selectable,
+    selectedIndexProp,
+    activeOpacity,
+    inactiveOpacity,
+    legendPosition,
+    getData: (index) => resolvedSeries[index],
+    onHoveredIndexChange: (index) => {
+      _optionalChain([onHoveredIndexChange, 'optionalCall', _2 => _2(index)]);
+      _optionalChain([onSeriesHover, 'optionalCall', _3 => _3(index, index !== null ? resolvedSeries[index] : null)]);
+    },
+    onSelectedIndexChange: (index) => {
+      _optionalChain([onSelectedIndexChange, 'optionalCall', _4 => _4(index)]);
+      if (index !== null) {
+        _optionalChain([onSeriesClick, 'optionalCall', _5 => _5(index, resolvedSeries[index])]);
+      }
+    }
+  });
+  const [hoveredPoint, setHoveredPoint] = _react.useState.call(void 0, null);
+  const handlePointEnter = _react.useCallback.call(void 0, 
+    (seriesIndex, pointIndex, event) => {
+      if (!hoverable) return;
+      setHoveredPoint({ seriesIndex, pointIndex });
+      handleHoverEnter(seriesIndex, event);
+    },
+    [hoverable, handleHoverEnter]
+  );
+  const handlePointMove = _react.useCallback.call(void 0, 
+    (event) => {
+      handleMouseMove(event);
+    },
+    [handleMouseMove]
+  );
+  const handlePointLeave = _react.useCallback.call(void 0, () => {
+    setHoveredPoint(null);
+    handleHoverLeave();
+  }, [handleHoverLeave]);
+  const innerRect = _react.useMemo.call(void 0, 
+    () => _tigercatcore.getChartInnerRect.call(void 0, width, height, padding),
+    [width, height, padding]
+  );
+  const radius = _react.useMemo.call(void 0, 
+    () => Math.max(0, Math.min(innerRect.width, innerRect.height) / 2),
+    [innerRect.width, innerRect.height]
+  );
+  const cx = innerRect.width / 2;
+  const cy = innerRect.height / 2;
+  const axisData = _react.useMemo.call(void 0, () => {
+    if (series && series.length > 0) return _nullishCoalesce(_optionalChain([series, 'access', _6 => _6[0], 'optionalAccess', _7 => _7.data]), () => ( []));
+    return _nullishCoalesce(data, () => ( []));
+  }, [series, data]);
+  const resolvedMaxValue = _react.useMemo.call(void 0, () => {
+    if (typeof maxValue === "number") return Math.max(0, maxValue);
+    const values = resolvedSeries.flatMap((item) => item.data.map((datum) => datum.value));
+    const computedMax = values.length > 0 ? Math.max(...values) : 0;
+    return computedMax > 0 ? computedMax : 1;
+  }, [resolvedSeries, maxValue]);
+  const angles = _react.useMemo.call(void 0, 
+    () => _tigercatcore.getRadarAngles.call(void 0, axisData.length, startAngle),
+    [axisData.length, startAngle]
+  );
+  const seriesPoints = _react.useMemo.call(void 0, 
+    () => resolvedSeries.map((item, seriesIndex) => ({
+      series: item,
+      seriesKey: seriesKeys[seriesIndex],
+      points: _tigercatcore.getRadarPoints.call(void 0, item.data, {
+        cx,
+        cy,
+        radius,
+        startAngle,
+        maxValue: resolvedMaxValue
+      })
+    })),
+    [resolvedSeries, seriesKeys, cx, cy, radius, startAngle, resolvedMaxValue]
+  );
+  const gridPaths = _react.useMemo.call(void 0, () => {
+    if (!showGrid || angles.length === 0) return [];
+    const resolvedLevels = Math.max(1, Math.floor(levels));
+    return Array.from({ length: resolvedLevels }, (_, index) => {
+      const levelRadius = radius * ((index + 1) / resolvedLevels);
+      if (gridShape === "circle") {
+        return { type: "circle", cx, cy, r: levelRadius };
+      }
+      const ringPoints = angles.map((angle) => _tigercatcore.polarToCartesian.call(void 0, cx, cy, levelRadius, angle));
+      return { type: "polygon", d: _tigercatcore.createPolygonPath.call(void 0, ringPoints), cx, cy, r: levelRadius };
+    });
+  }, [showGrid, levels, angles, radius, cx, cy, gridShape]);
+  const splitAreaPaths = _react.useMemo.call(void 0, () => {
+    if (!showSplitArea || angles.length === 0) return [];
+    const resolvedLevels = Math.max(1, Math.floor(levels));
+    const areaColors = splitAreaColors && splitAreaColors.length > 0 ? splitAreaColors : _tigercatcore.RADAR_SPLIT_AREA_COLORS;
+    return Array.from({ length: resolvedLevels }, (_, index) => {
+      const outerIndex = resolvedLevels - 1 - index;
+      const outerRadius = radius * ((outerIndex + 1) / resolvedLevels);
+      const innerRadius = radius * (outerIndex / resolvedLevels);
+      const color = areaColors[outerIndex % areaColors.length];
+      if (gridShape === "circle") {
+        return { type: "circle-ring", cx, cy, outerRadius, innerRadius, color };
+      }
+      const outerPoints = angles.map((angle) => _tigercatcore.polarToCartesian.call(void 0, cx, cy, outerRadius, angle));
+      const innerPoints = outerIndex > 0 ? angles.map((angle) => _tigercatcore.polarToCartesian.call(void 0, cx, cy, innerRadius, angle)) : [];
+      return { type: "polygon-ring", outerPoints, innerPoints, color };
+    });
+  }, [showSplitArea, levels, angles, radius, cx, cy, gridShape, splitAreaColors]);
+  const axisLines = _react.useMemo.call(void 0, () => {
+    if (!showAxis || angles.length === 0) return [];
+    return angles.map((angle) => {
+      const end = _tigercatcore.polarToCartesian.call(void 0, cx, cy, radius, angle);
+      return {
+        x1: cx,
+        y1: cy,
+        x2: end.x,
+        y2: end.y
+      };
+    });
+  }, [showAxis, angles, cx, cy, radius]);
+  const labels = _react.useMemo.call(void 0, () => {
+    if (!showLabels || angles.length === 0) return [];
+    const formatLabel = _nullishCoalesce(labelFormatter, () => ( ((datum) => _nullishCoalesce(datum.label, () => ( `${datum.value}`)))));
+    return axisData.map((datum, index) => {
+      const angle = angles[index];
+      const position = _tigercatcore.polarToCartesian.call(void 0, cx, cy, radius + labelOffset, angle);
+      const align = labelAutoAlign ? _tigercatcore.getRadarLabelAlign.call(void 0, angle) : { textAnchor: "middle", dominantBaseline: "middle" };
+      return {
+        x: position.x,
+        y: position.y,
+        text: formatLabel(datum, index),
+        textAnchor: align.textAnchor,
+        dominantBaseline: align.dominantBaseline
+      };
+    });
+  }, [showLabels, axisData, angles, cx, cy, radius, labelOffset, labelFormatter, labelAutoAlign]);
+  const levelLabels = _react.useMemo.call(void 0, () => {
+    if (!showLevelLabels || !showGrid || angles.length === 0) return [];
+    const resolvedLevels = Math.max(1, Math.floor(levels));
+    const formatLevel = _nullishCoalesce(levelLabelFormatter, () => ( ((value) => `${value}`)));
+    return Array.from({ length: resolvedLevels }, (_, index) => {
+      const ratio = (index + 1) / resolvedLevels;
+      const value = resolvedMaxValue * ratio;
+      const position = _tigercatcore.polarToCartesian.call(void 0, cx, cy, radius * ratio + levelLabelOffset, startAngle);
+      return {
+        x: position.x,
+        y: position.y,
+        text: formatLevel(value, index)
+      };
+    });
+  }, [
+    showLevelLabels,
+    showGrid,
+    angles.length,
+    levels,
+    resolvedMaxValue,
+    cx,
+    cy,
+    radius,
+    levelLabelOffset,
+    startAngle,
+    levelLabelFormatter
+  ]);
+  const dasharray = _tigercatcore.getChartGridLineDasharray.call(void 0, gridLineStyle);
+  const palette = _react.useMemo.call(void 0, () => _tigercatcore.resolveChartPalette.call(void 0, colors), [colors]);
+  const gradientId = _react.useId.call(void 0, );
+  const gradientPrefix = _react.useMemo.call(void 0, 
+    () => _tigercatcore.getStableChartGradientPrefix.call(void 0, "radar", gradientId),
+    [gradientId]
+  );
+  const tooltipContent = _react.useMemo.call(void 0, 
+    () => _tigercatcore.resolveMultiSeriesTooltipContent.call(void 0, 
+      hoveredPoint,
+      resolvedSeries,
+      tooltipFormatter,
+      _tigercatcore.defaultRadarTooltipFormatter
+    ),
+    [hoveredPoint, resolvedSeries, tooltipFormatter]
+  );
+  const legendItems = _react.useMemo.call(void 0, 
+    () => _tigercatcore.buildChartLegendItems.call(void 0, {
+      data: resolvedSeries,
+      palette,
+      activeIndex: resolvedActiveIndex,
+      getLabel: (s, i) => legendFormatter ? legendFormatter(s, i) : _nullishCoalesce(s.name, () => ( `Series ${i + 1}`)),
+      getColor: (s, i) => _nullishCoalesce(s.color, () => ( palette[i % palette.length]))
+    }),
+    [resolvedSeries, palette, resolvedActiveIndex, legendFormatter]
+  );
+  const chart = /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    _chunkUKLVOR4Ejs.ChartCanvas,
+    {
+      width,
+      height,
+      padding,
+      title,
+      desc,
+      className: _tigercatcore.classNames.call(void 0, className),
+      children: [
+        (gradient || strokeGradient || pointGradient) && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "defs", { children: [
+          gradient && seriesPoints.map((item, seriesIndex) => {
+            const seriesColor = _nullishCoalesce(item.series.color, () => ( palette[seriesIndex % palette.length]));
+            const resolvedFillColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(item.series.fillColor, () => ( seriesColor)), () => ( fillColor)), () => ( palette[0]));
+            const resolvedFillOpacity = _nullishCoalesce(item.series.fillOpacity, () => ( fillOpacity));
+            return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+              "linearGradient",
+              {
+                id: `${gradientPrefix}-${item.seriesKey}`,
+                x1: "0",
+                y1: "0",
+                x2: "0",
+                y2: "1",
+                children: [
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                    "stop",
+                    {
+                      offset: "0%",
+                      stopColor: resolvedFillColor,
+                      stopOpacity: resolvedFillOpacity
+                    }
+                  ),
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "100%", stopColor: resolvedFillColor, stopOpacity: 0.02 })
+                ]
+              },
+              `radar-grad-${item.seriesKey}`
+            );
+          }),
+          strokeGradient && seriesPoints.map((item, seriesIndex) => {
+            const seriesColor = _nullishCoalesce(item.series.color, () => ( palette[seriesIndex % palette.length]));
+            const resolvedStrokeColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(item.series.strokeColor, () => ( seriesColor)), () => ( strokeColor)), () => ( palette[0]));
+            return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+              "linearGradient",
+              {
+                id: `${gradientPrefix}-stroke-${item.seriesKey}`,
+                x1: "0",
+                y1: "0",
+                x2: "0",
+                y2: "1",
+                children: [
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                    "stop",
+                    {
+                      offset: "0%",
+                      stopColor: `color-mix(in oklab, ${resolvedStrokeColor} 100%, white 12%)`
+                    }
+                  ),
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "50%", stopColor: resolvedStrokeColor }),
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                    "stop",
+                    {
+                      offset: "100%",
+                      stopColor: `color-mix(in oklab, ${resolvedStrokeColor} 100%, black 8%)`
+                    }
+                  )
+                ]
+              },
+              `radar-stroke-grad-${item.seriesKey}`
+            );
+          }),
+          pointGradient && seriesPoints.map((item, seriesIndex) => {
+            const seriesColor = _nullishCoalesce(item.series.color, () => ( palette[seriesIndex % palette.length]));
+            const resolvedPointColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(item.series.pointColor, () => ( seriesColor)), () => ( pointColor)), () => ( palette[0]));
+            return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+              "radialGradient",
+              {
+                id: `${gradientPrefix}-point-${item.seriesKey}`,
+                cx: "0.5",
+                cy: "0.5",
+                r: "0.5",
+                children: [
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                    "stop",
+                    {
+                      offset: "0%",
+                      stopColor: `color-mix(in oklab, ${resolvedPointColor} 100%, white 30%)`
+                    }
+                  ),
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "70%", stopColor: resolvedPointColor }),
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                    "stop",
+                    {
+                      offset: "100%",
+                      stopColor: `color-mix(in oklab, ${resolvedPointColor} 100%, black 12%)`
+                    }
+                  )
+                ]
+              },
+              `radar-point-grad-${item.seriesKey}`
+            );
+          })
+        ] }),
+        splitAreaPaths.map((area, index) => {
+          if (area.type === "circle-ring") {
+            return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                "circle",
+                {
+                  cx: area.cx,
+                  cy: area.cy,
+                  r: area.outerRadius,
+                  fill: area.color,
+                  fillOpacity: splitAreaOpacity,
+                  stroke: "none",
+                  "data-radar-split-area": "true"
+                }
+              ),
+              area.innerRadius > 0 ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                "circle",
+                {
+                  cx: area.cx,
+                  cy: area.cy,
+                  r: area.innerRadius,
+                  fill: "var(--tiger-bg,#fff)",
+                  stroke: "none"
+                }
+              ) : null
+            ] }, `split-${index}`);
+          }
+          const outerPath = _tigercatcore.createPolygonPath.call(void 0, area.outerPoints);
+          return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
+            outerPath ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              "path",
+              {
+                d: outerPath,
+                fill: area.color,
+                fillOpacity: splitAreaOpacity,
+                stroke: "none",
+                "data-radar-split-area": "true"
+              }
+            ) : null,
+            area.innerPoints.length > 0 ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              "path",
+              {
+                d: _tigercatcore.createPolygonPath.call(void 0, area.innerPoints),
+                fill: "var(--tiger-bg,#fff)",
+                stroke: "none"
+              }
+            ) : null
+          ] }, `split-${index}`);
+        }),
+        gridPaths.map(
+          (grid, index) => grid.type === "circle" ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "circle",
+            {
+              cx: grid.cx,
+              cy: grid.cy,
+              r: grid.r,
+              className: _tigercatcore.chartGridLineClasses,
+              fill: "none",
+              strokeWidth: gridStrokeWidth,
+              strokeDasharray: dasharray
+            },
+            `grid-${index}`
+          ) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "path",
+            {
+              d: grid.d,
+              className: _tigercatcore.chartGridLineClasses,
+              fill: "none",
+              strokeWidth: gridStrokeWidth,
+              strokeDasharray: dasharray
+            },
+            `grid-${index}`
+          )
+        ),
+        axisLines.map((line, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          "line",
+          {
+            x1: line.x1,
+            y1: line.y1,
+            x2: line.x2,
+            y2: line.y2,
+            className: _tigercatcore.chartGridLineClasses,
+            strokeWidth: gridStrokeWidth,
+            strokeDasharray: dasharray
+          },
+          `axis-${index}`
+        )),
+        seriesPoints.map((item, seriesIndex) => {
+          const seriesColor = _nullishCoalesce(item.series.color, () => ( palette[seriesIndex % palette.length]));
+          const resolvedStrokeColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(item.series.strokeColor, () => ( seriesColor)), () => ( strokeColor)), () => ( palette[0]));
+          const resolvedFillColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(item.series.fillColor, () => ( seriesColor)), () => ( fillColor)), () => ( palette[0]));
+          const resolvedFillOpacity = _nullishCoalesce(item.series.fillOpacity, () => ( fillOpacity));
+          const resolvedStrokeWidth = _nullishCoalesce(item.series.strokeWidth, () => ( strokeWidth));
+          const resolvedShowPoints = _nullishCoalesce(item.series.showPoints, () => ( showPoints));
+          const resolvedPointSize = _nullishCoalesce(item.series.pointSize, () => ( pointSize));
+          const resolvedPointColor = _nullishCoalesce(_nullishCoalesce(item.series.pointColor, () => ( seriesColor)), () => ( pointColor));
+          const areaPath = _tigercatcore.createPolygonPath.call(void 0, item.points.map((point) => ({ x: point.x, y: point.y })));
+          const resolvedOpacity = resolvedActiveIndex === null ? void 0 : seriesIndex === resolvedActiveIndex ? activeOpacity : inactiveOpacity;
+          return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+            _chunkAX5XRD2Qjs.ChartSeries,
+            {
+              "data-series-key": item.seriesKey,
+              data: item.series.data,
+              name: item.series.name,
+              type: "radar",
+              className: item.series.className,
+              opacity: resolvedOpacity,
+              style: hoverable || selectable ? { cursor: "pointer" } : void 0,
+              onMouseEnter: hoverable ? (e) => handleHoverEnter(seriesIndex, e) : void 0,
+              onMouseLeave: hoverable ? handleHoverLeave : void 0,
+              onClick: selectable ? () => handleSelectIndex(seriesIndex) : void 0,
+              tabIndex: selectable ? 0 : void 0,
+              onKeyDown: (event) => {
+                if (!selectable) return;
+                if (event.key !== "Enter" && event.key !== " ") return;
+                event.preventDefault();
+                handleSelectIndex(seriesIndex);
+              },
+              children: [
+                areaPath ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  "path",
+                  {
+                    d: areaPath,
+                    fill: gradient ? `url(#${gradientPrefix}-${item.seriesKey})` : resolvedFillColor,
+                    fillOpacity: gradient ? 1 : resolvedFillOpacity,
+                    stroke: strokeGradient ? `url(#${gradientPrefix}-stroke-${item.seriesKey})` : resolvedStrokeColor,
+                    strokeWidth: resolvedStrokeWidth,
+                    strokeLinejoin: "round",
+                    className: "transition-[fill-opacity,filter] duration-200 ease-out",
+                    style: resolvedActiveIndex === seriesIndex ? { filter: "drop-shadow(0 2px 6px rgba(0,0,0,0.15))" } : void 0,
+                    "data-radar-area": "true",
+                    "data-series-index": seriesIndex,
+                    "data-series-key": item.seriesKey
+                  }
+                ) : null,
+                resolvedShowPoints ? item.points.map((point) => {
+                  const isHoveredPoint = _optionalChain([hoveredPoint, 'optionalAccess', _8 => _8.seriesIndex]) === seriesIndex && _optionalChain([hoveredPoint, 'optionalAccess', _9 => _9.pointIndex]) === point.index;
+                  const hoverSize = _nullishCoalesce(pointHoverSize, () => ( resolvedPointSize + 2));
+                  const currentSize = isHoveredPoint ? hoverSize : _nullishCoalesce(point.data.size, () => ( resolvedPointSize));
+                  const resolvedBorderWidth = _nullishCoalesce(item.series.pointBorderWidth, () => ( pointBorderWidth));
+                  const resolvedBorderColor = _nullishCoalesce(item.series.pointBorderColor, () => ( pointBorderColor));
+                  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                    "circle",
+                    {
+                      cx: point.x,
+                      cy: point.y,
+                      r: currentSize,
+                      fill: pointGradient ? `url(#${gradientPrefix}-point-${item.seriesKey})` : _nullishCoalesce(_nullishCoalesce(point.data.color, () => ( resolvedPointColor)), () => ( resolvedStrokeColor)),
+                      stroke: resolvedBorderColor,
+                      strokeWidth: resolvedBorderWidth,
+                      className: _tigercatcore.classNames.call(void 0, 
+                        showTooltip && hoverable ? "cursor-pointer" : void 0,
+                        "transition-[r] duration-150 ease-out"
+                      ),
+                      "data-radar-point": "true",
+                      "data-series-index": seriesIndex,
+                      "data-series-key": item.seriesKey,
+                      "data-point-index": point.index,
+                      onMouseEnter: showTooltip && hoverable ? (e) => handlePointEnter(seriesIndex, point.index, e) : void 0,
+                      onMouseMove: showTooltip && hoverable ? handlePointMove : void 0,
+                      onMouseLeave: showTooltip && hoverable ? handlePointLeave : void 0
+                    },
+                    `point-${item.seriesKey}-${point.index}`
+                  );
+                }) : null
+              ]
+            },
+            item.seriesKey
+          );
+        }),
+        labels.map((label, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          "text",
+          {
+            x: label.x,
+            y: label.y,
+            className: _tigercatcore.chartAxisTickTextClasses,
+            textAnchor: label.textAnchor,
+            dominantBaseline: label.dominantBaseline,
+            children: label.text
+          },
+          `label-${index}`
+        )),
+        levelLabels.map((label, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          "text",
+          {
+            x: label.x,
+            y: label.y,
+            className: _tigercatcore.chartAxisTickTextClasses,
+            textAnchor: "middle",
+            dominantBaseline: "middle",
+            "data-radar-level-label": "true",
+            children: label.text
+          },
+          `level-${index}`
+        ))
+      ]
+    }
+  );
+  const tooltip = showTooltip && hoverable ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _chunkUVMQJOTXjs.ChartTooltip,
+    {
+      content: tooltipContent,
+      visible: hoveredPoint !== null && tooltipContent !== "",
+      x: tooltipPosition.x,
+      y: tooltipPosition.y
+    }
+  ) : null;
+  if (!showLegend) {
+    return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "inline-block relative", children: [
+      chart,
+      tooltip
+    ] });
+  }
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: wrapperClasses, children: [
+    chart,
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _chunkWV5XHYW6js.ChartLegend,
+      {
+        items: legendItems,
+        position: legendPosition,
+        markerSize: legendMarkerSize,
+        gap: legendGap,
+        interactive: hoverable || selectable,
+        onItemClick: handleLegendClick,
+        onItemHover: handleLegendHover,
+        onItemLeave: handleLegendLeave
+      }
+    ),
+    tooltip
+  ] });
+};
+var RadarChart_default = RadarChart;
+
+
+
+
+exports.RadarChart = RadarChart; exports.RadarChart_default = RadarChart_default;

package/dist/chunk-EPN7QWP6.mjs

@@ -1,8 +1,21 @@
-import { useMemo, useSyncExternalStore } from 'react';
-import { resolveResponsiveValue, classNames, descriptionsWrapperClasses, getDescriptionsClasses, descriptionsHeaderClasses, descriptionsTitleClasses, descriptionsExtraClasses, groupItemsIntoRows, getDescriptionsTableClasses, descriptionsVerticalWrapperClasses, getDescriptionsLabelClasses, getDescriptionsContentClasses, getDescriptionsVerticalItemClasses } from '@expcat/tigercat-core';
-import { jsxs, jsx } from 'react/jsx-runtime';
-
 // src/components/Descriptions.tsx
+import { useMemo, useSyncExternalStore } from "react";
+import {
+  classNames,
+  getDescriptionsClasses,
+  getDescriptionsTableClasses,
+  getDescriptionsLabelClasses,
+  getDescriptionsContentClasses,
+  getDescriptionsVerticalItemClasses,
+  groupItemsIntoRows,
+  descriptionsWrapperClasses,
+  descriptionsHeaderClasses,
+  descriptionsTitleClasses,
+  descriptionsExtraClasses,
+  descriptionsVerticalWrapperClasses,
+  resolveResponsiveValue
+} from "@expcat/tigercat-core";
+import { jsx, jsxs } from "react/jsx-runtime";
 var Descriptions = ({
   title,
   extra,
@@ -128,4 +141,7 @@ var Descriptions = ({
 };
 var Descriptions_default = Descriptions;
 
-export { Descriptions, Descriptions_default };
+export {
+  Descriptions,
+  Descriptions_default
+};