@expcat/tigercat-react 1.0.7 → 1.2.0

package/dist/chunk-TVJZB7ZC.js

@@ -1,509 +0,0 @@
-'use strict';
-
-var chunkKQZ4F7FZ_js = require('./chunk-KQZ4F7FZ.js');
-var chunk6PBNFLM7_js = require('./chunk-6PBNFLM7.js');
-var chunkAX5XRD2Q_js = require('./chunk-AX5XRD2Q.js');
-var chunkM375I56K_js = require('./chunk-M375I56K.js');
-var chunkDUWAV47E_js = require('./chunk-DUWAV47E.js');
-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,
-  pointBorderWidth = 2,
-  pointBorderColor = "#fff",
-  pointHoverSize,
-  labelAutoAlign = true,
-  title,
-  desc,
-  className
-}) => {
-  const resolvedSeries = react.useMemo(
-    () => tigercatCore.resolveSeriesData(series, data, {
-      data: []
-    }),
-    [series, data]
-  );
-  const {
-    resolvedHoveredIndex: _resolvedHoveredIndex,
-    resolvedSelectedIndex: _resolvedSelectedIndex,
-    activeIndex: resolvedActiveIndex,
-    tooltipPosition,
-    handleMouseEnter: handleHoverEnter,
-    handleMouseMove,
-    handleMouseLeave: handleHoverLeave,
-    handleClick: handleSelectIndex,
-    handleLegendClick,
-    handleLegendHover,
-    handleLegendLeave,
-    wrapperClasses
-  } = chunkKQZ4F7FZ_js.useChartInteraction({
-    hoverable,
-    hoveredIndexProp,
-    selectable,
-    selectedIndexProp,
-    activeOpacity,
-    inactiveOpacity,
-    legendPosition,
-    getData: (index) => resolvedSeries[index],
-    onHoveredIndexChange: (index) => {
-      onHoveredIndexChange?.(index);
-      onSeriesHover?.(index, index !== null ? resolvedSeries[index] : null);
-    },
-    onSelectedIndexChange: (index) => {
-      onSelectedIndexChange?.(index);
-      if (index !== null) {
-        onSeriesClick?.(index, resolvedSeries[index]);
-      }
-    }
-  });
-  const [hoveredPoint, setHoveredPoint] = react.useState(null);
-  const handlePointEnter = react.useCallback(
-    (seriesIndex, pointIndex, event) => {
-      if (!hoverable) return;
-      setHoveredPoint({ seriesIndex, pointIndex });
-      handleHoverEnter(seriesIndex, event);
-    },
-    [hoverable, handleHoverEnter]
-  );
-  const handlePointMove = react.useCallback(
-    (event) => {
-      handleMouseMove(event);
-    },
-    [handleMouseMove]
-  );
-  const handlePointLeave = react.useCallback(() => {
-    setHoveredPoint(null);
-    handleHoverLeave();
-  }, [handleHoverLeave]);
-  const innerRect = react.useMemo(
-    () => tigercatCore.getChartInnerRect(width, height, padding),
-    [width, height, padding]
-  );
-  const radius = react.useMemo(
-    () => 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(() => {
-    if (series && series.length > 0) return series[0]?.data ?? [];
-    return data ?? [];
-  }, [series, data]);
-  const resolvedMaxValue = react.useMemo(() => {
-    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(
-    () => tigercatCore.getRadarAngles(axisData.length, startAngle),
-    [axisData.length, startAngle]
-  );
-  const seriesPoints = react.useMemo(
-    () => resolvedSeries.map((item) => ({
-      series: item,
-      points: tigercatCore.getRadarPoints(item.data, {
-        cx,
-        cy,
-        radius,
-        startAngle,
-        maxValue: resolvedMaxValue
-      })
-    })),
-    [resolvedSeries, cx, cy, radius, startAngle, resolvedMaxValue]
-  );
-  const gridPaths = react.useMemo(() => {
-    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(cx, cy, levelRadius, angle));
-      return { type: "polygon", d: tigercatCore.createPolygonPath(ringPoints), cx, cy, r: levelRadius };
-    });
-  }, [showGrid, levels, angles, radius, cx, cy, gridShape]);
-  const splitAreaPaths = react.useMemo(() => {
-    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(cx, cy, outerRadius, angle));
-      const innerPoints = outerIndex > 0 ? angles.map((angle) => tigercatCore.polarToCartesian(cx, cy, innerRadius, angle)) : [];
-      return { type: "polygon-ring", outerPoints, innerPoints, color };
-    });
-  }, [showSplitArea, levels, angles, radius, cx, cy, gridShape, splitAreaColors, splitAreaOpacity]);
-  const axisLines = react.useMemo(() => {
-    if (!showAxis || angles.length === 0) return [];
-    return angles.map((angle) => {
-      const end = tigercatCore.polarToCartesian(cx, cy, radius, angle);
-      return {
-        x1: cx,
-        y1: cy,
-        x2: end.x,
-        y2: end.y
-      };
-    });
-  }, [showAxis, angles, cx, cy, radius]);
-  const labels = react.useMemo(() => {
-    if (!showLabels || angles.length === 0) return [];
-    const formatLabel = labelFormatter ?? ((datum) => datum.label ?? `${datum.value}`);
-    return axisData.map((datum, index) => {
-      const angle = angles[index];
-      const position = tigercatCore.polarToCartesian(cx, cy, radius + labelOffset, angle);
-      const align = labelAutoAlign ? tigercatCore.getRadarLabelAlign(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(() => {
-    if (!showLevelLabels || !showGrid || angles.length === 0) return [];
-    const resolvedLevels = Math.max(1, Math.floor(levels));
-    const formatLevel = levelLabelFormatter ?? ((value) => `${value}`);
-    return Array.from({ length: resolvedLevels }, (_, index) => {
-      const ratio = (index + 1) / resolvedLevels;
-      const value = resolvedMaxValue * ratio;
-      const position = tigercatCore.polarToCartesian(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(gridLineStyle);
-  const palette = react.useMemo(() => tigercatCore.resolveChartPalette(colors), [colors]);
-  const tooltipContent = react.useMemo(
-    () => tigercatCore.resolveMultiSeriesTooltipContent(
-      hoveredPoint,
-      resolvedSeries,
-      tooltipFormatter,
-      tigercatCore.defaultRadarTooltipFormatter
-    ),
-    [hoveredPoint, resolvedSeries, tooltipFormatter]
-  );
-  const legendItems = react.useMemo(
-    () => tigercatCore.buildChartLegendItems({
-      data: resolvedSeries,
-      palette,
-      activeIndex: resolvedActiveIndex,
-      getLabel: (s, i) => legendFormatter ? legendFormatter(s, i) : s.name ?? `Series ${i + 1}`,
-      getColor: (s, i) => s.color ?? palette[i % palette.length]
-    }),
-    [resolvedSeries, palette, resolvedActiveIndex, legendFormatter]
-  );
-  const chart = /* @__PURE__ */ jsxRuntime.jsxs(
-    chunkDUWAV47E_js.ChartCanvas,
-    {
-      width,
-      height,
-      padding,
-      title,
-      desc,
-      className: tigercatCore.classNames(className),
-      children: [
-        splitAreaPaths.map((area, index) => {
-          if (area.type === "circle-ring") {
-            return /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
-              /* @__PURE__ */ jsxRuntime.jsx(
-                "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(
-                "circle",
-                {
-                  cx: area.cx,
-                  cy: area.cy,
-                  r: area.innerRadius,
-                  fill: "var(--tiger-bg,#fff)",
-                  stroke: "none"
-                }
-              ) : null
-            ] }, `split-${index}`);
-          }
-          const outerPath = tigercatCore.createPolygonPath(area.outerPoints);
-          return /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
-            outerPath ? /* @__PURE__ */ jsxRuntime.jsx(
-              "path",
-              {
-                d: outerPath,
-                fill: area.color,
-                fillOpacity: splitAreaOpacity,
-                stroke: "none",
-                "data-radar-split-area": "true"
-              }
-            ) : null,
-            area.innerPoints.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(
-              "path",
-              {
-                d: tigercatCore.createPolygonPath(area.innerPoints),
-                fill: "var(--tiger-bg,#fff)",
-                stroke: "none"
-              }
-            ) : null
-          ] }, `split-${index}`);
-        }),
-        gridPaths.map(
-          (grid, index) => grid.type === "circle" ? /* @__PURE__ */ jsxRuntime.jsx(
-            "circle",
-            {
-              cx: grid.cx,
-              cy: grid.cy,
-              r: grid.r,
-              className: tigercatCore.chartGridLineClasses,
-              fill: "none",
-              strokeWidth: gridStrokeWidth,
-              strokeDasharray: dasharray
-            },
-            `grid-${index}`
-          ) : /* @__PURE__ */ jsxRuntime.jsx(
-            "path",
-            {
-              d: grid.d,
-              className: tigercatCore.chartGridLineClasses,
-              fill: "none",
-              strokeWidth: gridStrokeWidth,
-              strokeDasharray: dasharray
-            },
-            `grid-${index}`
-          )
-        ),
-        axisLines.map((line, index) => /* @__PURE__ */ jsxRuntime.jsx(
-          "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 = item.series.color ?? palette[seriesIndex % palette.length];
-          const resolvedStrokeColor = item.series.strokeColor ?? seriesColor ?? strokeColor ?? palette[0];
-          const resolvedFillColor = item.series.fillColor ?? seriesColor ?? fillColor ?? palette[0];
-          const resolvedFillOpacity = item.series.fillOpacity ?? fillOpacity;
-          const resolvedStrokeWidth = item.series.strokeWidth ?? strokeWidth;
-          const resolvedShowPoints = item.series.showPoints ?? showPoints;
-          const resolvedPointSize = item.series.pointSize ?? pointSize;
-          const resolvedPointColor = item.series.pointColor ?? seriesColor ?? pointColor;
-          const areaPath = tigercatCore.createPolygonPath(item.points.map((point) => ({ x: point.x, y: point.y })));
-          const resolvedOpacity = resolvedActiveIndex === null ? void 0 : seriesIndex === resolvedActiveIndex ? activeOpacity : inactiveOpacity;
-          return /* @__PURE__ */ jsxRuntime.jsxs(
-            chunkAX5XRD2Q_js.ChartSeries,
-            {
-              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(
-                  "path",
-                  {
-                    d: areaPath,
-                    fill: resolvedFillColor,
-                    fillOpacity: resolvedFillOpacity,
-                    stroke: 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
-                  }
-                ) : null,
-                resolvedShowPoints ? item.points.map((point) => {
-                  const isHoveredPoint = hoveredPoint?.seriesIndex === seriesIndex && hoveredPoint?.pointIndex === point.index;
-                  const hoverSize = pointHoverSize ?? resolvedPointSize + 2;
-                  const currentSize = isHoveredPoint ? hoverSize : point.data.size ?? resolvedPointSize;
-                  const resolvedBorderWidth = item.series.pointBorderWidth ?? pointBorderWidth;
-                  const resolvedBorderColor = item.series.pointBorderColor ?? pointBorderColor;
-                  return /* @__PURE__ */ jsxRuntime.jsx(
-                    "circle",
-                    {
-                      cx: point.x,
-                      cy: point.y,
-                      r: currentSize,
-                      fill: point.data.color ?? resolvedPointColor ?? resolvedStrokeColor,
-                      stroke: resolvedBorderColor,
-                      strokeWidth: resolvedBorderWidth,
-                      className: tigercatCore.classNames(
-                        showTooltip && hoverable ? "cursor-pointer" : void 0,
-                        "transition-[r] duration-150 ease-out"
-                      ),
-                      "data-radar-point": "true",
-                      "data-series-index": seriesIndex,
-                      "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-${seriesIndex}-${point.index}`
-                  );
-                }) : null
-              ]
-            },
-            `series-${seriesIndex}`
-          );
-        }),
-        labels.map((label, index) => /* @__PURE__ */ jsxRuntime.jsx(
-          "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(
-          "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(
-    chunkM375I56K_js.ChartTooltip,
-    {
-      content: tooltipContent,
-      visible: hoveredPoint !== null && tooltipContent !== "",
-      x: tooltipPosition.x,
-      y: tooltipPosition.y
-    }
-  ) : null;
-  if (!showLegend) {
-    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "inline-block relative", children: [
-      chart,
-      tooltip
-    ] });
-  }
-  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: wrapperClasses, children: [
-    chart,
-    /* @__PURE__ */ jsxRuntime.jsx(
-      chunk6PBNFLM7_js.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-TZNTHABR.js

@@ -1,58 +0,0 @@
-'use strict';
-
-var react = require('react');
-var tigercatCore = require('@expcat/tigercat-core');
-var jsxRuntime = require('react/jsx-runtime');
-
-// src/components/InfiniteScroll.tsx
-var InfiniteScroll = ({
-  hasMore = true,
-  loading = false,
-  threshold = 100,
-  loadingText = "Loading...",
-  endText = "No more data",
-  direction = "vertical",
-  inverse = false,
-  disabled = false,
-  className,
-  children,
-  loader,
-  end,
-  onLoadMore,
-  ...rest
-}) => {
-  const containerRef = react.useRef(null);
-  const containerClasses = react.useMemo(
-    () => tigercatCore.getInfiniteScrollContainerClasses(direction, className),
-    [direction, className]
-  );
-  const checkScroll = react.useCallback(() => {
-    if (disabled || loading || !hasMore) return;
-    const el = containerRef.current;
-    if (!el) return;
-    if (tigercatCore.shouldLoadMore(el, threshold, direction, inverse)) {
-      onLoadMore?.();
-    }
-  }, [disabled, loading, hasMore, threshold, direction, inverse, onLoadMore]);
-  react.useEffect(() => {
-    const el = containerRef.current;
-    if (!el) return;
-    el.addEventListener("scroll", checkScroll, { passive: true });
-    return () => el.removeEventListener("scroll", checkScroll);
-  }, [checkScroll]);
-  const loaderEl = loading ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.infiniteScrollLoaderClasses, role: "status", "aria-live": "polite", children: loader ?? loadingText }) : null;
-  const endEl = !hasMore && !loading ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.infiniteScrollEndClasses, children: end ?? endText }) : null;
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, className: tigercatCore.classNames(containerClasses), ...rest, children: inverse ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-    loaderEl,
-    children,
-    endEl
-  ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-    children,
-    loaderEl,
-    endEl
-  ] }) });
-};
-var InfiniteScroll_default = InfiniteScroll;
-
-exports.InfiniteScroll = InfiniteScroll;
-exports.InfiniteScroll_default = InfiniteScroll_default;

package/dist/chunk-UEJHVPE2.js

@@ -1,97 +0,0 @@
-'use strict';
-
-var chunkRVCUNEBU_js = require('./chunk-RVCUNEBU.js');
-var react = require('react');
-var tigercatCore = require('@expcat/tigercat-core');
-var jsxRuntime = require('react/jsx-runtime');
-
-var Radio = ({
-  value,
-  size,
-  disabled,
-  name,
-  checked,
-  defaultChecked = false,
-  onChange,
-  children,
-  className,
-  style,
-  ...props
-}) => {
-  const groupContext = react.useContext(chunkRVCUNEBU_js.RadioGroupContext);
-  const [internalChecked, setInternalChecked] = react.useState(defaultChecked);
-  const isCheckedControlled = checked !== void 0;
-  const isInGroup = !!groupContext;
-  const actualSize = size || groupContext?.size || "md";
-  const actualDisabled = disabled !== void 0 ? disabled : groupContext?.disabled || false;
-  const actualName = name || groupContext?.name || "";
-  const isChecked = checked !== void 0 ? checked : groupContext?.value !== void 0 ? groupContext.value === value : internalChecked;
-  const radioClasses = react.useMemo(
-    () => tigercatCore.getRadioVisualClasses({
-      size: actualSize,
-      checked: isChecked,
-      disabled: actualDisabled,
-      colors: tigercatCore.defaultRadioColors
-    }),
-    [actualSize, isChecked, actualDisabled]
-  );
-  const dotClasses = react.useMemo(
-    () => tigercatCore.getRadioDotClasses({
-      size: actualSize,
-      checked: isChecked,
-      colors: tigercatCore.defaultRadioColors
-    }),
-    [actualSize, isChecked]
-  );
-  const labelClasses = react.useMemo(
-    () => tigercatCore.getRadioLabelClasses({
-      size: actualSize,
-      disabled: actualDisabled,
-      colors: tigercatCore.defaultRadioColors
-    }),
-    [actualSize, actualDisabled]
-  );
-  const handleChange = (event) => {
-    if (actualDisabled) {
-      event.preventDefault();
-      return;
-    }
-    const newChecked = event.target.checked;
-    if (!newChecked) return;
-    if (!isCheckedControlled && !isInGroup) {
-      setInternalChecked(true);
-    }
-    onChange?.(value);
-    groupContext?.onChange?.(value);
-  };
-  const handleKeyDown = (event) => {
-    props.onKeyDown?.(event);
-    if (event.defaultPrevented) return;
-    if (actualDisabled) return;
-    if (event.key === "Enter") {
-      event.preventDefault();
-      const input = event.currentTarget;
-      if (!input.checked) input.click();
-    }
-  };
-  return /* @__PURE__ */ jsxRuntime.jsxs("label", { className: tigercatCore.classNames(tigercatCore.radioRootBaseClasses, className), style, children: [
-    /* @__PURE__ */ jsxRuntime.jsx(
-      "input",
-      {
-        type: "radio",
-        className: "sr-only peer",
-        ...props,
-        name: actualName,
-        value,
-        checked: isChecked,
-        disabled: actualDisabled,
-        onChange: handleChange,
-        onKeyDown: handleKeyDown
-      }
-    ),
-    /* @__PURE__ */ jsxRuntime.jsx("span", { className: radioClasses, "aria-hidden": "true", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: dotClasses }) }),
-    children && /* @__PURE__ */ jsxRuntime.jsx("span", { className: labelClasses, children })
-  ] });
-};
-
-exports.Radio = Radio;