@expcat/tigercat-vue 2.1.2 → 2.1.3

package/dist/chunk-N2XV37BL.mjs

@@ -1,783 +0,0 @@
-import {
-  useChartInteraction
-} from "./chunk-FHUGOSEY.mjs";
-import {
-  ChartSeries
-} from "./chunk-2ZUEXCVJ.mjs";
-import {
-  ChartTooltip
-} from "./chunk-SPFL55TF.mjs";
-import {
-  ChartCanvas
-} from "./chunk-SNNT64HK.mjs";
-import {
-  ChartLegend
-} from "./chunk-V443QIJM.mjs";
-
-// src/components/RadarChart.ts
-import { defineComponent, computed, h, ref, useId } from "vue";
-import {
-  chartAxisTickTextClasses,
-  chartGridLineClasses,
-  classNames,
-  createCircleRingPath,
-  createPolygonPath,
-  createPolygonRingPath,
-  getChartGridLineDasharray,
-  getChartInnerRect,
-  getRadarAngles,
-  getStableChartGradientPrefix,
-  getRadarLabelAlign,
-  getRadarPoints,
-  polarToCartesian,
-  RADAR_SPLIT_AREA_COLORS,
-  resolveChartPalette,
-  buildChartLegendItems,
-  buildChartSeriesKeys,
-  resolveMultiSeriesTooltipContent,
-  resolveSeriesData,
-  defaultRadarTooltipFormatter
-} from "@expcat/tigercat-core";
-var RadarChart = defineComponent({
-  name: "TigerRadarChart",
-  props: {
-    width: {
-      type: Number,
-      default: 320
-    },
-    height: {
-      type: Number,
-      default: 200
-    },
-    padding: {
-      type: [Number, Object],
-      default: 24
-    },
-    data: {
-      type: Array
-    },
-    series: {
-      type: Array
-    },
-    maxValue: {
-      type: Number
-    },
-    startAngle: {
-      type: Number,
-      default: -Math.PI / 2
-    },
-    levels: {
-      type: Number,
-      default: 5
-    },
-    showLevelLabels: {
-      type: Boolean,
-      default: false
-    },
-    showGrid: {
-      type: Boolean,
-      default: true
-    },
-    showAxis: {
-      type: Boolean,
-      default: true
-    },
-    showLabels: {
-      type: Boolean,
-      default: true
-    },
-    labelOffset: {
-      type: Number,
-      default: 12
-    },
-    labelFormatter: {
-      type: Function
-    },
-    levelLabelFormatter: {
-      type: Function
-    },
-    levelLabelOffset: {
-      type: Number,
-      default: 8
-    },
-    hoverable: {
-      type: Boolean,
-      default: false
-    },
-    hoveredIndex: {
-      type: Number,
-      default: void 0
-    },
-    activeOpacity: {
-      type: Number,
-      default: 1
-    },
-    inactiveOpacity: {
-      type: Number,
-      default: 0.25
-    },
-    selectable: {
-      type: Boolean,
-      default: false
-    },
-    selectedIndex: {
-      type: Number,
-      default: void 0
-    },
-    showLegend: {
-      type: Boolean,
-      default: false
-    },
-    legendPosition: {
-      type: String,
-      default: "bottom"
-    },
-    legendFormatter: {
-      type: Function
-    },
-    legendMarkerSize: {
-      type: Number,
-      default: 10
-    },
-    legendGap: {
-      type: Number,
-      default: 8
-    },
-    showTooltip: {
-      type: Boolean,
-      default: true
-    },
-    tooltipFormatter: {
-      type: Function
-    },
-    colors: {
-      type: Array
-    },
-    gridLineStyle: {
-      type: String,
-      default: "solid"
-    },
-    gridStrokeWidth: {
-      type: Number,
-      default: 1
-    },
-    strokeColor: {
-      type: String
-    },
-    strokeWidth: {
-      type: Number,
-      default: 2
-    },
-    fillColor: {
-      type: String
-    },
-    fillOpacity: {
-      type: Number,
-      default: 0.2
-    },
-    showPoints: {
-      type: Boolean,
-      default: true
-    },
-    pointSize: {
-      type: Number,
-      default: 3
-    },
-    pointColor: {
-      type: String
-    },
-    gridShape: {
-      type: String,
-      default: "polygon"
-    },
-    showSplitArea: {
-      type: Boolean,
-      default: false
-    },
-    gradient: {
-      type: Boolean,
-      default: false
-    },
-    strokeGradient: {
-      type: Boolean,
-      default: false
-    },
-    pointGradient: {
-      type: Boolean,
-      default: false
-    },
-    splitAreaOpacity: {
-      type: Number,
-      default: 0.06
-    },
-    splitAreaColors: {
-      type: Array
-    },
-    pointBorderWidth: {
-      type: Number,
-      default: 2
-    },
-    pointBorderColor: {
-      type: String,
-      default: "var(--tiger-surface,#ffffff)"
-    },
-    pointHoverSize: {
-      type: Number,
-      default: void 0
-    },
-    labelAutoAlign: {
-      type: Boolean,
-      default: true
-    },
-    title: {
-      type: String
-    },
-    desc: {
-      type: String
-    },
-    className: {
-      type: String
-    }
-  },
-  emits: ["update:hoveredIndex", "update:selectedIndex", "series-click", "series-hover"],
-  setup(props, { emit }) {
-    const gradientPrefix = getStableChartGradientPrefix("radar", useId());
-    const innerRect = computed(() => getChartInnerRect(props.width, props.height, props.padding));
-    const radius = computed(
-      () => Math.max(0, Math.min(innerRect.value.width, innerRect.value.height) / 2)
-    );
-    const cx = computed(() => innerRect.value.width / 2);
-    const cy = computed(() => innerRect.value.height / 2);
-    const resolvedSeries = computed(
-      () => resolveSeriesData(props.series, props.data, {
-        data: []
-      })
-    );
-    const seriesKeys = computed(
-      () => buildChartSeriesKeys(resolvedSeries.value, { prefix: "radar-" })
-    );
-    const {
-      resolvedHoveredIndex: _resolvedHoveredIndex,
-      resolvedSelectedIndex: _resolvedSelectedIndex,
-      activeIndex: resolvedActiveIndex,
-      tooltipPosition,
-      handleMouseEnter: handleHoverEnter,
-      handleMouseMove,
-      handleMouseLeave: handleHoverLeave,
-      handleClick: handleSelectIndex,
-      handleLegendClick,
-      handleLegendHover,
-      handleLegendLeave,
-      wrapperClasses
-    } = useChartInteraction({
-      hoverable: computed(() => props.hoverable),
-      showTooltip: computed(() => props.showTooltip),
-      hoveredIndexProp: () => props.hoveredIndex,
-      selectable: computed(() => props.selectable),
-      selectedIndexProp: () => props.selectedIndex,
-      activeOpacity: computed(() => props.activeOpacity),
-      inactiveOpacity: computed(() => props.inactiveOpacity),
-      legendPosition: computed(() => props.legendPosition),
-      emit,
-      getData: (index) => resolvedSeries.value[index],
-      eventNames: {
-        hover: "series-hover",
-        click: "series-click"
-      }
-    });
-    const hoveredPoint = ref(null);
-    const handlePointEnter = (seriesIndex, pointIndex, event) => {
-      if (!props.hoverable && !props.showTooltip) return;
-      hoveredPoint.value = { seriesIndex, pointIndex };
-      handleHoverEnter(seriesIndex, event);
-    };
-    const handlePointMove = (event) => {
-      handleMouseMove(event);
-    };
-    const handlePointLeave = () => {
-      hoveredPoint.value = null;
-      handleHoverLeave();
-    };
-    const showPointTooltipFromElement = (el, seriesIndex, pointIndex) => {
-      if (!props.hoverable) return;
-      const rect = el.getBoundingClientRect();
-      hoveredPoint.value = { seriesIndex, pointIndex };
-      handleHoverEnter(seriesIndex, {
-        clientX: rect.left + rect.width / 2,
-        clientY: rect.top + rect.height / 2
-      });
-    };
-    const axisData = computed(() => {
-      if (props.series && props.series.length > 0) return props.series[0]?.data ?? [];
-      return props.data ?? [];
-    });
-    const resolvedMaxValue = computed(() => {
-      if (typeof props.maxValue === "number") return Math.max(0, props.maxValue);
-      const values = resolvedSeries.value.flatMap((item) => item.data.map((datum) => datum.value));
-      const computedMax = values.length > 0 ? Math.max(...values) : 0;
-      return computedMax > 0 ? computedMax : 1;
-    });
-    const angles = computed(() => getRadarAngles(axisData.value.length, props.startAngle));
-    const seriesPoints = computed(
-      () => resolvedSeries.value.map((item, seriesIndex) => ({
-        series: item,
-        seriesKey: seriesKeys.value[seriesIndex],
-        points: getRadarPoints(item.data, {
-          cx: cx.value,
-          cy: cy.value,
-          radius: radius.value,
-          startAngle: props.startAngle,
-          maxValue: resolvedMaxValue.value
-        })
-      }))
-    );
-    const gridPaths = computed(() => {
-      if (!props.showGrid || angles.value.length === 0) return [];
-      const resolvedLevels = Math.max(1, Math.floor(props.levels));
-      return Array.from({ length: resolvedLevels }, (_, index) => {
-        const levelRadius = radius.value * ((index + 1) / resolvedLevels);
-        if (props.gridShape === "circle") {
-          return { type: "circle", cx: cx.value, cy: cy.value, r: levelRadius };
-        }
-        const ringPoints = angles.value.map(
-          (angle) => polarToCartesian(cx.value, cy.value, levelRadius, angle)
-        );
-        return {
-          type: "polygon",
-          d: createPolygonPath(ringPoints),
-          cx: cx.value,
-          cy: cy.value,
-          r: levelRadius
-        };
-      });
-    });
-    const splitAreaPaths = computed(() => {
-      if (!props.showSplitArea || angles.value.length === 0) return [];
-      const resolvedLevels = Math.max(1, Math.floor(props.levels));
-      const areaColors = props.splitAreaColors && props.splitAreaColors.length > 0 ? props.splitAreaColors : RADAR_SPLIT_AREA_COLORS;
-      return Array.from({ length: resolvedLevels }, (_, index) => {
-        const outerIndex = resolvedLevels - 1 - index;
-        const outerRadius = radius.value * ((outerIndex + 1) / resolvedLevels);
-        const innerRadius = radius.value * (outerIndex / resolvedLevels);
-        const color = areaColors[outerIndex % areaColors.length];
-        if (props.gridShape === "circle") {
-          return {
-            type: "circle-ring",
-            cx: cx.value,
-            cy: cy.value,
-            outerRadius,
-            innerRadius,
-            color
-          };
-        }
-        const outerPoints = angles.value.map(
-          (angle) => polarToCartesian(cx.value, cy.value, outerRadius, angle)
-        );
-        const innerPoints = outerIndex > 0 ? angles.value.map((angle) => polarToCartesian(cx.value, cy.value, innerRadius, angle)) : [];
-        return { type: "polygon-ring", outerPoints, innerPoints, color };
-      });
-    });
-    const axisLines = computed(() => {
-      if (!props.showAxis || angles.value.length === 0) return [];
-      return angles.value.map((angle) => {
-        const end = polarToCartesian(cx.value, cy.value, radius.value, angle);
-        return {
-          x1: cx.value,
-          y1: cy.value,
-          x2: end.x,
-          y2: end.y
-        };
-      });
-    });
-    const labels = computed(() => {
-      if (!props.showLabels || angles.value.length === 0) return [];
-      const formatLabel = props.labelFormatter ?? ((datum) => datum.label ?? `${datum.value}`);
-      return axisData.value.map((datum, index) => {
-        const angle = angles.value[index];
-        const position = polarToCartesian(
-          cx.value,
-          cy.value,
-          radius.value + props.labelOffset,
-          angle
-        );
-        const align = props.labelAutoAlign ? getRadarLabelAlign(angle) : { textAnchor: "middle", dominantBaseline: "middle" };
-        return {
-          x: position.x,
-          y: position.y,
-          text: formatLabel(datum, index),
-          textAnchor: align.textAnchor,
-          dominantBaseline: align.dominantBaseline
-        };
-      });
-    });
-    const levelLabels = computed(() => {
-      if (!props.showLevelLabels || !props.showGrid || angles.value.length === 0) return [];
-      const resolvedLevels = Math.max(1, Math.floor(props.levels));
-      const formatLevel = props.levelLabelFormatter ?? ((value) => `${value}`);
-      return Array.from({ length: resolvedLevels }, (_, index) => {
-        const ratio = (index + 1) / resolvedLevels;
-        const value = resolvedMaxValue.value * ratio;
-        const position = polarToCartesian(
-          cx.value,
-          cy.value,
-          radius.value * ratio + props.levelLabelOffset,
-          props.startAngle
-        );
-        return {
-          x: position.x,
-          y: position.y,
-          text: formatLevel(value, index)
-        };
-      });
-    });
-    const dasharray = computed(() => getChartGridLineDasharray(props.gridLineStyle));
-    const palette = computed(() => resolveChartPalette(props.colors));
-    const tooltipContent = computed(
-      () => resolveMultiSeriesTooltipContent(
-        hoveredPoint.value,
-        resolvedSeries.value,
-        props.tooltipFormatter,
-        defaultRadarTooltipFormatter
-      )
-    );
-    const legendItems = computed(
-      () => buildChartLegendItems({
-        data: resolvedSeries.value,
-        palette: palette.value,
-        activeIndex: resolvedActiveIndex.value,
-        getLabel: (s, i) => props.legendFormatter ? props.legendFormatter(s, i) : s.name ?? `Series ${i + 1}`,
-        getColor: (s, i) => s.color ?? palette.value[i % palette.value.length]
-      })
-    );
-    return () => {
-      const chart = h(
-        ChartCanvas,
-        {
-          width: props.width,
-          height: props.height,
-          padding: props.padding,
-          title: props.title,
-          desc: props.desc,
-          className: classNames(props.className)
-        },
-        {
-          default: () => [
-            // Gradient defs for area fills
-            props.gradient || props.strokeGradient || props.pointGradient ? h("defs", null, [
-              ...props.gradient ? seriesPoints.value.map((item, seriesIndex) => {
-                const seriesColor = item.series.color ?? palette.value[seriesIndex % palette.value.length];
-                const resolvedFillColor = item.series.fillColor ?? seriesColor ?? props.fillColor ?? palette.value[0];
-                const resolvedFillOpacity = item.series.fillOpacity ?? props.fillOpacity;
-                return h(
-                  "linearGradient",
-                  {
-                    key: `radar-grad-${item.seriesKey}`,
-                    id: `${gradientPrefix}-${item.seriesKey}`,
-                    x1: "0",
-                    y1: "0",
-                    x2: "0",
-                    y2: "1"
-                  },
-                  [
-                    h("stop", {
-                      offset: "0%",
-                      "stop-color": resolvedFillColor,
-                      "stop-opacity": resolvedFillOpacity
-                    }),
-                    h("stop", {
-                      offset: "100%",
-                      "stop-color": resolvedFillColor,
-                      "stop-opacity": 0.02
-                    })
-                  ]
-                );
-              }) : [],
-              ...props.strokeGradient ? seriesPoints.value.map((item, seriesIndex) => {
-                const seriesColor = item.series.color ?? palette.value[seriesIndex % palette.value.length];
-                const resolvedStrokeColor = item.series.strokeColor ?? seriesColor ?? props.strokeColor ?? palette.value[0];
-                return h(
-                  "linearGradient",
-                  {
-                    key: `radar-stroke-grad-${item.seriesKey}`,
-                    id: `${gradientPrefix}-stroke-${item.seriesKey}`,
-                    x1: "0",
-                    y1: "0",
-                    x2: "0",
-                    y2: "1"
-                  },
-                  [
-                    h("stop", {
-                      offset: "0%",
-                      "stop-color": `color-mix(in oklab, ${resolvedStrokeColor} 100%, white 12%)`
-                    }),
-                    h("stop", {
-                      offset: "50%",
-                      "stop-color": resolvedStrokeColor
-                    }),
-                    h("stop", {
-                      offset: "100%",
-                      "stop-color": `color-mix(in oklab, ${resolvedStrokeColor} 100%, black 8%)`
-                    })
-                  ]
-                );
-              }) : [],
-              ...props.pointGradient ? seriesPoints.value.map((item, seriesIndex) => {
-                const seriesColor = item.series.color ?? palette.value[seriesIndex % palette.value.length];
-                const resolvedPointColor = item.series.pointColor ?? seriesColor ?? props.pointColor ?? palette.value[0];
-                return h(
-                  "radialGradient",
-                  {
-                    key: `radar-point-grad-${item.seriesKey}`,
-                    id: `${gradientPrefix}-point-${item.seriesKey}`,
-                    cx: "0.5",
-                    cy: "0.5",
-                    r: "0.5"
-                  },
-                  [
-                    h("stop", {
-                      offset: "0%",
-                      "stop-color": `color-mix(in oklab, ${resolvedPointColor} 100%, white 30%)`
-                    }),
-                    h("stop", {
-                      offset: "70%",
-                      "stop-color": resolvedPointColor
-                    }),
-                    h("stop", {
-                      offset: "100%",
-                      "stop-color": `color-mix(in oklab, ${resolvedPointColor} 100%, black 12%)`
-                    })
-                  ]
-                );
-              }) : []
-            ]) : null,
-            // Split area (alternating fills – evenodd ring, transparent inner)
-            ...splitAreaPaths.value.map((area, index) => {
-              const shared = {
-                key: `split-${index}`,
-                fill: area.color,
-                "fill-opacity": props.splitAreaOpacity,
-                stroke: "none",
-                "data-radar-split-area": "true"
-              };
-              if (area.type === "circle-ring") {
-                if (area.innerRadius > 0) {
-                  return h("path", {
-                    ...shared,
-                    d: createCircleRingPath(area.cx, area.cy, area.outerRadius, area.innerRadius),
-                    "fill-rule": "evenodd"
-                  });
-                }
-                return h("circle", {
-                  ...shared,
-                  cx: area.cx,
-                  cy: area.cy,
-                  r: area.outerRadius
-                });
-              }
-              if (area.innerPoints.length > 0) {
-                const d2 = createPolygonRingPath(area.outerPoints, area.innerPoints);
-                return d2 ? h("path", { ...shared, d: d2, "fill-rule": "evenodd" }) : null;
-              }
-              const d = createPolygonPath(area.outerPoints);
-              return d ? h("path", { ...shared, d }) : null;
-            }),
-            // Grid lines
-            ...gridPaths.value.map(
-              (grid, index) => grid.type === "circle" ? h("circle", {
-                key: `grid-${index}`,
-                cx: grid.cx,
-                cy: grid.cy,
-                r: grid.r,
-                class: chartGridLineClasses,
-                fill: "none",
-                "stroke-width": props.gridStrokeWidth,
-                "stroke-dasharray": dasharray.value
-              }) : h("path", {
-                key: `grid-${index}`,
-                d: grid.d,
-                class: chartGridLineClasses,
-                fill: "none",
-                "stroke-width": props.gridStrokeWidth,
-                "stroke-dasharray": dasharray.value
-              })
-            ),
-            ...axisLines.value.map(
-              (line, index) => h("line", {
-                key: `axis-${index}`,
-                x1: line.x1,
-                y1: line.y1,
-                x2: line.x2,
-                y2: line.y2,
-                class: chartGridLineClasses,
-                "stroke-width": props.gridStrokeWidth,
-                "stroke-dasharray": dasharray.value
-              })
-            ),
-            ...seriesPoints.value.map((item, seriesIndex) => {
-              const seriesColor = item.series.color ?? palette.value[seriesIndex % palette.value.length];
-              const resolvedStrokeColor = item.series.strokeColor ?? seriesColor ?? props.strokeColor ?? palette.value[0];
-              const resolvedFillColor = item.series.fillColor ?? seriesColor ?? props.fillColor ?? palette.value[0];
-              const resolvedFillOpacity = item.series.fillOpacity ?? props.fillOpacity;
-              const resolvedStrokeWidth = item.series.strokeWidth ?? props.strokeWidth;
-              const resolvedShowPoints = item.series.showPoints ?? props.showPoints;
-              const resolvedPointSize = item.series.pointSize ?? props.pointSize;
-              const resolvedPointColor = item.series.pointColor ?? seriesColor ?? props.pointColor;
-              const areaPath = createPolygonPath(
-                item.points.map((point) => ({ x: point.x, y: point.y }))
-              );
-              const resolvedOpacity = resolvedActiveIndex.value === null ? void 0 : seriesIndex === resolvedActiveIndex.value ? props.activeOpacity : props.inactiveOpacity;
-              return h(
-                ChartSeries,
-                {
-                  key: item.seriesKey,
-                  data: item.series.data,
-                  name: item.series.name,
-                  type: "radar",
-                  "data-series-key": item.seriesKey,
-                  class: classNames(
-                    item.series.className,
-                    props.hoverable || props.selectable ? "cursor-pointer" : null
-                  ),
-                  opacity: resolvedOpacity,
-                  onMouseenter: props.hoverable ? (e) => handleHoverEnter(seriesIndex, e) : void 0,
-                  onMouseleave: props.hoverable ? handleHoverLeave : void 0,
-                  onClick: props.selectable ? () => handleSelectIndex(seriesIndex) : void 0,
-                  tabindex: props.selectable ? 0 : void 0,
-                  onKeydown: (event) => {
-                    if (!props.selectable) return;
-                    if (event.key !== "Enter" && event.key !== " ") return;
-                    event.preventDefault();
-                    handleSelectIndex(seriesIndex);
-                  }
-                },
-                {
-                  default: () => [
-                    areaPath ? h("path", {
-                      d: areaPath,
-                      fill: props.gradient ? `url(#${gradientPrefix}-${item.seriesKey})` : resolvedFillColor,
-                      "fill-opacity": props.gradient ? 1 : resolvedFillOpacity,
-                      stroke: props.strokeGradient ? `url(#${gradientPrefix}-stroke-${item.seriesKey})` : resolvedStrokeColor,
-                      "stroke-width": resolvedStrokeWidth,
-                      "stroke-linejoin": "round",
-                      class: "transition-[fill-opacity,filter] duration-200 ease-out",
-                      style: resolvedActiveIndex.value === 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 = hoveredPoint.value?.seriesIndex === seriesIndex && hoveredPoint.value?.pointIndex === point.index;
-                      const hoverSize = props.pointHoverSize ?? resolvedPointSize + 2;
-                      const currentSize = isHoveredPoint ? hoverSize : point.data.size ?? resolvedPointSize;
-                      const resolvedBorderWidth = item.series.pointBorderWidth ?? props.pointBorderWidth;
-                      const resolvedBorderColor = item.series.pointBorderColor ?? props.pointBorderColor;
-                      return h("circle", {
-                        key: `point-${item.seriesKey}-${point.index}`,
-                        cx: point.x,
-                        cy: point.y,
-                        r: currentSize,
-                        fill: props.pointGradient ? `url(#${gradientPrefix}-point-${item.seriesKey})` : point.data.color ?? resolvedPointColor ?? resolvedStrokeColor,
-                        stroke: resolvedBorderColor,
-                        "stroke-width": resolvedBorderWidth,
-                        class: classNames(
-                          props.showTooltip && props.hoverable ? "cursor-pointer" : null,
-                          "transition-[r] duration-150 ease-out"
-                        ),
-                        role: props.showTooltip && props.hoverable ? "button" : "img",
-                        "aria-label": point.data.label ?? String(point.data.value),
-                        tabindex: props.showTooltip && props.hoverable ? 0 : void 0,
-                        "data-radar-point": "true",
-                        "data-series-index": seriesIndex,
-                        "data-series-key": item.seriesKey,
-                        "data-point-index": point.index,
-                        onMouseenter: props.showTooltip || props.hoverable ? (e) => handlePointEnter(seriesIndex, point.index, e) : void 0,
-                        onMousemove: props.showTooltip || props.hoverable ? handlePointMove : void 0,
-                        onMouseleave: props.showTooltip || props.hoverable ? handlePointLeave : void 0,
-                        onFocus: props.showTooltip && props.hoverable ? (e) => showPointTooltipFromElement(
-                          e.currentTarget,
-                          seriesIndex,
-                          point.index
-                        ) : void 0,
-                        onBlur: props.showTooltip && props.hoverable ? handlePointLeave : void 0,
-                        onKeydown: props.showTooltip && props.hoverable ? (e) => {
-                          if (e.key === "Enter" || e.key === " ") {
-                            e.preventDefault();
-                            showPointTooltipFromElement(
-                              e.currentTarget,
-                              seriesIndex,
-                              point.index
-                            );
-                          } else if (e.key === "Escape") {
-                            handlePointLeave();
-                          }
-                        } : void 0
-                      });
-                    }) : null
-                  ]
-                }
-              );
-            }),
-            ...labels.value.map(
-              (label, index) => h(
-                "text",
-                {
-                  key: `label-${index}`,
-                  x: label.x,
-                  y: label.y,
-                  class: chartAxisTickTextClasses,
-                  "text-anchor": label.textAnchor,
-                  "dominant-baseline": label.dominantBaseline
-                },
-                label.text
-              )
-            ),
-            ...levelLabels.value.map(
-              (label, index) => h(
-                "text",
-                {
-                  key: `level-${index}`,
-                  x: label.x,
-                  y: label.y,
-                  class: chartAxisTickTextClasses,
-                  "text-anchor": "middle",
-                  "dominant-baseline": "middle",
-                  "data-radar-level-label": "true"
-                },
-                label.text
-              )
-            )
-          ].filter(Boolean)
-        }
-      );
-      const tooltip = props.showTooltip ? h(ChartTooltip, {
-        content: tooltipContent.value,
-        open: hoveredPoint.value !== null && tooltipContent.value !== "",
-        x: tooltipPosition.value.x,
-        y: tooltipPosition.value.y
-      }) : null;
-      if (!props.showLegend) {
-        return h("div", { class: "inline-block relative" }, [chart, tooltip]);
-      }
-      return h("div", { class: wrapperClasses.value }, [
-        chart,
-        h(ChartLegend, {
-          items: legendItems.value,
-          position: props.legendPosition,
-          markerSize: props.legendMarkerSize,
-          gap: props.legendGap,
-          interactive: props.hoverable || props.selectable,
-          onItemClick: handleLegendClick,
-          onItemHover: handleLegendHover,
-          onItemLeave: handleLegendLeave
-        }),
-        tooltip
-      ]);
-    };
-  }
-});
-var RadarChart_default = RadarChart;
-
-export {
-  RadarChart,
-  RadarChart_default
-};