@expcat/tigercat-vue 1.4.0 → 2.0.0-preview.1

package/dist/chunk-FUI6WG2F.js

@@ -1,757 +0,0 @@
-"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 _chunk2VOZFFW6js = require('./chunk-2VOZFFW6.js');
-
-
-var _chunkACYYQJ6Mjs = require('./chunk-ACYYQJ6M.js');
-
-
-var _chunkHBFFINAIjs = require('./chunk-HBFFINAI.js');
-
-
-var _chunkZOUJFFG4js = require('./chunk-ZOUJFFG4.js');
-
-
-var _chunkUHVUKLHFjs = require('./chunk-UHVUKLHF.js');
-
-// src/components/RadarChart.ts
-var _vue = require('vue');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _tigercatcore = require('@expcat/tigercat-core');
-var RadarChart = _vue.defineComponent.call(void 0, {
-  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 = _tigercatcore.getStableChartGradientPrefix.call(void 0, "radar", _vue.useId.call(void 0, ));
-    const innerRect = _vue.computed.call(void 0, () => _tigercatcore.getChartInnerRect.call(void 0, props.width, props.height, props.padding));
-    const radius = _vue.computed.call(void 0, 
-      () => Math.max(0, Math.min(innerRect.value.width, innerRect.value.height) / 2)
-    );
-    const cx = _vue.computed.call(void 0, () => innerRect.value.width / 2);
-    const cy = _vue.computed.call(void 0, () => innerRect.value.height / 2);
-    const resolvedSeries = _vue.computed.call(void 0, 
-      () => _tigercatcore.resolveSeriesData.call(void 0, props.series, props.data, {
-        data: []
-      })
-    );
-    const seriesKeys = _vue.computed.call(void 0, 
-      () => _tigercatcore.buildChartSeriesKeys.call(void 0, resolvedSeries.value, { prefix: "radar-" })
-    );
-    const {
-      resolvedHoveredIndex: _resolvedHoveredIndex,
-      resolvedSelectedIndex: _resolvedSelectedIndex,
-      activeIndex: resolvedActiveIndex,
-      tooltipPosition,
-      handleMouseEnter: handleHoverEnter,
-      handleMouseMove,
-      handleMouseLeave: handleHoverLeave,
-      handleClick: handleSelectIndex,
-      handleLegendClick,
-      handleLegendHover,
-      handleLegendLeave,
-      wrapperClasses
-    } = _chunk2VOZFFW6js.useChartInteraction.call(void 0, {
-      hoverable: _vue.computed.call(void 0, () => props.hoverable),
-      hoveredIndexProp: () => props.hoveredIndex,
-      selectable: _vue.computed.call(void 0, () => props.selectable),
-      selectedIndexProp: () => props.selectedIndex,
-      activeOpacity: _vue.computed.call(void 0, () => props.activeOpacity),
-      inactiveOpacity: _vue.computed.call(void 0, () => props.inactiveOpacity),
-      legendPosition: _vue.computed.call(void 0, () => props.legendPosition),
-      emit,
-      getData: (index) => resolvedSeries.value[index],
-      eventNames: {
-        hover: "series-hover",
-        click: "series-click"
-      }
-    });
-    const hoveredPoint = _vue.ref.call(void 0, null);
-    const handlePointEnter = (seriesIndex, pointIndex, event) => {
-      if (!props.hoverable) return;
-      hoveredPoint.value = { seriesIndex, pointIndex };
-      handleHoverEnter(seriesIndex, event);
-    };
-    const handlePointMove = (event) => {
-      handleMouseMove(event);
-    };
-    const handlePointLeave = () => {
-      hoveredPoint.value = null;
-      handleHoverLeave();
-    };
-    const axisData = _vue.computed.call(void 0, () => {
-      if (props.series && props.series.length > 0) return _nullishCoalesce(_optionalChain([props, 'access', _2 => _2.series, 'access', _3 => _3[0], 'optionalAccess', _4 => _4.data]), () => ( []));
-      return _nullishCoalesce(props.data, () => ( []));
-    });
-    const resolvedMaxValue = _vue.computed.call(void 0, () => {
-      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 = _vue.computed.call(void 0, () => _tigercatcore.getRadarAngles.call(void 0, axisData.value.length, props.startAngle));
-    const seriesPoints = _vue.computed.call(void 0, 
-      () => resolvedSeries.value.map((item, seriesIndex) => ({
-        series: item,
-        seriesKey: seriesKeys.value[seriesIndex],
-        points: _tigercatcore.getRadarPoints.call(void 0, item.data, {
-          cx: cx.value,
-          cy: cy.value,
-          radius: radius.value,
-          startAngle: props.startAngle,
-          maxValue: resolvedMaxValue.value
-        })
-      }))
-    );
-    const gridPaths = _vue.computed.call(void 0, () => {
-      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) => _tigercatcore.polarToCartesian.call(void 0, cx.value, cy.value, levelRadius, angle)
-        );
-        return {
-          type: "polygon",
-          d: _tigercatcore.createPolygonPath.call(void 0, ringPoints),
-          cx: cx.value,
-          cy: cy.value,
-          r: levelRadius
-        };
-      });
-    });
-    const splitAreaPaths = _vue.computed.call(void 0, () => {
-      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 : _tigercatcore.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) => _tigercatcore.polarToCartesian.call(void 0, cx.value, cy.value, outerRadius, angle)
-        );
-        const innerPoints = outerIndex > 0 ? angles.value.map((angle) => _tigercatcore.polarToCartesian.call(void 0, cx.value, cy.value, innerRadius, angle)) : [];
-        return { type: "polygon-ring", outerPoints, innerPoints, color };
-      });
-    });
-    const axisLines = _vue.computed.call(void 0, () => {
-      if (!props.showAxis || angles.value.length === 0) return [];
-      return angles.value.map((angle) => {
-        const end = _tigercatcore.polarToCartesian.call(void 0, cx.value, cy.value, radius.value, angle);
-        return {
-          x1: cx.value,
-          y1: cy.value,
-          x2: end.x,
-          y2: end.y
-        };
-      });
-    });
-    const labels = _vue.computed.call(void 0, () => {
-      if (!props.showLabels || angles.value.length === 0) return [];
-      const formatLabel = _nullishCoalesce(props.labelFormatter, () => ( ((datum) => _nullishCoalesce(datum.label, () => ( `${datum.value}`)))));
-      return axisData.value.map((datum, index) => {
-        const angle = angles.value[index];
-        const position = _tigercatcore.polarToCartesian.call(void 0, 
-          cx.value,
-          cy.value,
-          radius.value + props.labelOffset,
-          angle
-        );
-        const align = props.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
-        };
-      });
-    });
-    const levelLabels = _vue.computed.call(void 0, () => {
-      if (!props.showLevelLabels || !props.showGrid || angles.value.length === 0) return [];
-      const resolvedLevels = Math.max(1, Math.floor(props.levels));
-      const formatLevel = _nullishCoalesce(props.levelLabelFormatter, () => ( ((value) => `${value}`)));
-      return Array.from({ length: resolvedLevels }, (_, index) => {
-        const ratio = (index + 1) / resolvedLevels;
-        const value = resolvedMaxValue.value * ratio;
-        const position = _tigercatcore.polarToCartesian.call(void 0, 
-          cx.value,
-          cy.value,
-          radius.value * ratio + props.levelLabelOffset,
-          props.startAngle
-        );
-        return {
-          x: position.x,
-          y: position.y,
-          text: formatLevel(value, index)
-        };
-      });
-    });
-    const dasharray = _vue.computed.call(void 0, () => _tigercatcore.getChartGridLineDasharray.call(void 0, props.gridLineStyle));
-    const palette = _vue.computed.call(void 0, () => _tigercatcore.resolveChartPalette.call(void 0, props.colors));
-    const tooltipContent = _vue.computed.call(void 0, 
-      () => _tigercatcore.resolveMultiSeriesTooltipContent.call(void 0, 
-        hoveredPoint.value,
-        resolvedSeries.value,
-        props.tooltipFormatter,
-        _tigercatcore.defaultRadarTooltipFormatter
-      )
-    );
-    const legendItems = _vue.computed.call(void 0, 
-      () => _tigercatcore.buildChartLegendItems.call(void 0, {
-        data: resolvedSeries.value,
-        palette: palette.value,
-        activeIndex: resolvedActiveIndex.value,
-        getLabel: (s, i) => props.legendFormatter ? props.legendFormatter(s, i) : _nullishCoalesce(s.name, () => ( `Series ${i + 1}`)),
-        getColor: (s, i) => _nullishCoalesce(s.color, () => ( palette.value[i % palette.value.length]))
-      })
-    );
-    return () => {
-      const chart = _vue.h.call(void 0, 
-        _chunkUHVUKLHFjs.ChartCanvas,
-        {
-          width: props.width,
-          height: props.height,
-          padding: props.padding,
-          title: props.title,
-          desc: props.desc,
-          className: _tigercatcore.classNames.call(void 0, props.className)
-        },
-        {
-          default: () => [
-            // Gradient defs for area fills
-            props.gradient || props.strokeGradient || props.pointGradient ? _vue.h.call(void 0, "defs", null, [
-              ...props.gradient ? seriesPoints.value.map((item, seriesIndex) => {
-                const seriesColor = _nullishCoalesce(item.series.color, () => ( palette.value[seriesIndex % palette.value.length]));
-                const resolvedFillColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(item.series.fillColor, () => ( seriesColor)), () => ( props.fillColor)), () => ( palette.value[0]));
-                const resolvedFillOpacity = _nullishCoalesce(item.series.fillOpacity, () => ( props.fillOpacity));
-                return _vue.h.call(void 0, 
-                  "linearGradient",
-                  {
-                    key: `radar-grad-${item.seriesKey}`,
-                    id: `${gradientPrefix}-${item.seriesKey}`,
-                    x1: "0",
-                    y1: "0",
-                    x2: "0",
-                    y2: "1"
-                  },
-                  [
-                    _vue.h.call(void 0, "stop", {
-                      offset: "0%",
-                      "stop-color": resolvedFillColor,
-                      "stop-opacity": resolvedFillOpacity
-                    }),
-                    _vue.h.call(void 0, "stop", {
-                      offset: "100%",
-                      "stop-color": resolvedFillColor,
-                      "stop-opacity": 0.02
-                    })
-                  ]
-                );
-              }) : [],
-              ...props.strokeGradient ? seriesPoints.value.map((item, seriesIndex) => {
-                const seriesColor = _nullishCoalesce(item.series.color, () => ( palette.value[seriesIndex % palette.value.length]));
-                const resolvedStrokeColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(item.series.strokeColor, () => ( seriesColor)), () => ( props.strokeColor)), () => ( palette.value[0]));
-                return _vue.h.call(void 0, 
-                  "linearGradient",
-                  {
-                    key: `radar-stroke-grad-${item.seriesKey}`,
-                    id: `${gradientPrefix}-stroke-${item.seriesKey}`,
-                    x1: "0",
-                    y1: "0",
-                    x2: "0",
-                    y2: "1"
-                  },
-                  [
-                    _vue.h.call(void 0, "stop", {
-                      offset: "0%",
-                      "stop-color": `color-mix(in oklab, ${resolvedStrokeColor} 100%, white 12%)`
-                    }),
-                    _vue.h.call(void 0, "stop", {
-                      offset: "50%",
-                      "stop-color": resolvedStrokeColor
-                    }),
-                    _vue.h.call(void 0, "stop", {
-                      offset: "100%",
-                      "stop-color": `color-mix(in oklab, ${resolvedStrokeColor} 100%, black 8%)`
-                    })
-                  ]
-                );
-              }) : [],
-              ...props.pointGradient ? seriesPoints.value.map((item, seriesIndex) => {
-                const seriesColor = _nullishCoalesce(item.series.color, () => ( palette.value[seriesIndex % palette.value.length]));
-                const resolvedPointColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(item.series.pointColor, () => ( seriesColor)), () => ( props.pointColor)), () => ( palette.value[0]));
-                return _vue.h.call(void 0, 
-                  "radialGradient",
-                  {
-                    key: `radar-point-grad-${item.seriesKey}`,
-                    id: `${gradientPrefix}-point-${item.seriesKey}`,
-                    cx: "0.5",
-                    cy: "0.5",
-                    r: "0.5"
-                  },
-                  [
-                    _vue.h.call(void 0, "stop", {
-                      offset: "0%",
-                      "stop-color": `color-mix(in oklab, ${resolvedPointColor} 100%, white 30%)`
-                    }),
-                    _vue.h.call(void 0, "stop", {
-                      offset: "70%",
-                      "stop-color": resolvedPointColor
-                    }),
-                    _vue.h.call(void 0, "stop", {
-                      offset: "100%",
-                      "stop-color": `color-mix(in oklab, ${resolvedPointColor} 100%, black 12%)`
-                    })
-                  ]
-                );
-              }) : []
-            ]) : null,
-            // Split area (alternating fills – ECharts splitArea style)
-            ...splitAreaPaths.value.map((area, index) => {
-              if (area.type === "circle-ring") {
-                return _vue.h.call(void 0, "g", { key: `split-${index}` }, [
-                  _vue.h.call(void 0, "circle", {
-                    cx: area.cx,
-                    cy: area.cy,
-                    r: area.outerRadius,
-                    fill: area.color,
-                    "fill-opacity": props.splitAreaOpacity,
-                    stroke: "none",
-                    "data-radar-split-area": "true"
-                  }),
-                  area.innerRadius > 0 ? _vue.h.call(void 0, "circle", {
-                    cx: area.cx,
-                    cy: area.cy,
-                    r: area.innerRadius,
-                    fill: "var(--tiger-bg,#fff)",
-                    stroke: "none"
-                  }) : null
-                ]);
-              }
-              const outerPath = _tigercatcore.createPolygonPath.call(void 0, area.outerPoints);
-              return _vue.h.call(void 0, "g", { key: `split-${index}` }, [
-                outerPath ? _vue.h.call(void 0, "path", {
-                  d: outerPath,
-                  fill: area.color,
-                  "fill-opacity": props.splitAreaOpacity,
-                  stroke: "none",
-                  "data-radar-split-area": "true"
-                }) : null,
-                area.innerPoints.length > 0 ? _vue.h.call(void 0, "path", {
-                  d: _tigercatcore.createPolygonPath.call(void 0, area.innerPoints),
-                  fill: "var(--tiger-bg,#fff)",
-                  stroke: "none"
-                }) : null
-              ]);
-            }),
-            // Grid lines
-            ...gridPaths.value.map(
-              (grid, index) => grid.type === "circle" ? _vue.h.call(void 0, "circle", {
-                key: `grid-${index}`,
-                cx: grid.cx,
-                cy: grid.cy,
-                r: grid.r,
-                class: _tigercatcore.chartGridLineClasses,
-                fill: "none",
-                "stroke-width": props.gridStrokeWidth,
-                "stroke-dasharray": dasharray.value
-              }) : _vue.h.call(void 0, "path", {
-                key: `grid-${index}`,
-                d: grid.d,
-                class: _tigercatcore.chartGridLineClasses,
-                fill: "none",
-                "stroke-width": props.gridStrokeWidth,
-                "stroke-dasharray": dasharray.value
-              })
-            ),
-            ...axisLines.value.map(
-              (line, index) => _vue.h.call(void 0, "line", {
-                key: `axis-${index}`,
-                x1: line.x1,
-                y1: line.y1,
-                x2: line.x2,
-                y2: line.y2,
-                class: _tigercatcore.chartGridLineClasses,
-                "stroke-width": props.gridStrokeWidth,
-                "stroke-dasharray": dasharray.value
-              })
-            ),
-            ...seriesPoints.value.map((item, seriesIndex) => {
-              const seriesColor = _nullishCoalesce(item.series.color, () => ( palette.value[seriesIndex % palette.value.length]));
-              const resolvedStrokeColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(item.series.strokeColor, () => ( seriesColor)), () => ( props.strokeColor)), () => ( palette.value[0]));
-              const resolvedFillColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(item.series.fillColor, () => ( seriesColor)), () => ( props.fillColor)), () => ( palette.value[0]));
-              const resolvedFillOpacity = _nullishCoalesce(item.series.fillOpacity, () => ( props.fillOpacity));
-              const resolvedStrokeWidth = _nullishCoalesce(item.series.strokeWidth, () => ( props.strokeWidth));
-              const resolvedShowPoints = _nullishCoalesce(item.series.showPoints, () => ( props.showPoints));
-              const resolvedPointSize = _nullishCoalesce(item.series.pointSize, () => ( props.pointSize));
-              const resolvedPointColor = _nullishCoalesce(_nullishCoalesce(item.series.pointColor, () => ( seriesColor)), () => ( props.pointColor));
-              const areaPath = _tigercatcore.createPolygonPath.call(void 0, 
-                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 _vue.h.call(void 0, 
-                _chunkHBFFINAIjs.ChartSeries,
-                {
-                  key: item.seriesKey,
-                  data: item.series.data,
-                  name: item.series.name,
-                  type: "radar",
-                  "data-series-key": item.seriesKey,
-                  class: _tigercatcore.classNames.call(void 0, 
-                    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 ? _vue.h.call(void 0, "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 = _optionalChain([hoveredPoint, 'access', _5 => _5.value, 'optionalAccess', _6 => _6.seriesIndex]) === seriesIndex && _optionalChain([hoveredPoint, 'access', _7 => _7.value, 'optionalAccess', _8 => _8.pointIndex]) === point.index;
-                      const hoverSize = _nullishCoalesce(props.pointHoverSize, () => ( resolvedPointSize + 2));
-                      const currentSize = isHoveredPoint ? hoverSize : _nullishCoalesce(point.data.size, () => ( resolvedPointSize));
-                      const resolvedBorderWidth = _nullishCoalesce(item.series.pointBorderWidth, () => ( props.pointBorderWidth));
-                      const resolvedBorderColor = _nullishCoalesce(item.series.pointBorderColor, () => ( props.pointBorderColor));
-                      return _vue.h.call(void 0, "circle", {
-                        key: `point-${item.seriesKey}-${point.index}`,
-                        cx: point.x,
-                        cy: point.y,
-                        r: currentSize,
-                        fill: props.pointGradient ? `url(#${gradientPrefix}-point-${item.seriesKey})` : _nullishCoalesce(_nullishCoalesce(point.data.color, () => ( resolvedPointColor)), () => ( resolvedStrokeColor)),
-                        stroke: resolvedBorderColor,
-                        "stroke-width": resolvedBorderWidth,
-                        class: _tigercatcore.classNames.call(void 0, 
-                          props.showTooltip && props.hoverable ? "cursor-pointer" : null,
-                          "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: 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
-                      });
-                    }) : null
-                  ]
-                }
-              );
-            }),
-            ...labels.value.map(
-              (label, index) => _vue.h.call(void 0, 
-                "text",
-                {
-                  key: `label-${index}`,
-                  x: label.x,
-                  y: label.y,
-                  class: _tigercatcore.chartAxisTickTextClasses,
-                  "text-anchor": label.textAnchor,
-                  "dominant-baseline": label.dominantBaseline
-                },
-                label.text
-              )
-            ),
-            ...levelLabels.value.map(
-              (label, index) => _vue.h.call(void 0, 
-                "text",
-                {
-                  key: `level-${index}`,
-                  x: label.x,
-                  y: label.y,
-                  class: _tigercatcore.chartAxisTickTextClasses,
-                  "text-anchor": "middle",
-                  "dominant-baseline": "middle",
-                  "data-radar-level-label": "true"
-                },
-                label.text
-              )
-            )
-          ].filter(Boolean)
-        }
-      );
-      const tooltip = props.showTooltip && props.hoverable ? _vue.h.call(void 0, _chunkZOUJFFG4js.ChartTooltip, {
-        content: tooltipContent.value,
-        visible: hoveredPoint.value !== null && tooltipContent.value !== "",
-        x: tooltipPosition.value.x,
-        y: tooltipPosition.value.y
-      }) : null;
-      if (!props.showLegend) {
-        return _vue.h.call(void 0, "div", { class: "inline-block relative" }, [chart, tooltip]);
-      }
-      return _vue.h.call(void 0, "div", { class: wrapperClasses.value }, [
-        chart,
-        _vue.h.call(void 0, _chunkACYYQJ6Mjs.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;
-
-
-
-
-exports.RadarChart = RadarChart; exports.RadarChart_default = RadarChart_default;