@expcat/tigercat-vue 1.0.7 → 1.2.0

package/dist/{chunk-VITTXNTD.js → chunk-FUI6WG2F.js}

@@ -1,14 +1,42 @@
-'use strict';
+"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 chunkFLAJKB2O_js = require('./chunk-FLAJKB2O.js');
-var chunkBKTQ6RWR_js = require('./chunk-BKTQ6RWR.js');
-var chunkHBFFINAI_js = require('./chunk-HBFFINAI.js');
-var chunkEPE6OOV7_js = require('./chunk-EPE6OOV7.js');
-var chunkFCV4ML6I_js = require('./chunk-FCV4ML6I.js');
-var vue = require('vue');
-var tigercatCore = require('@expcat/tigercat-core');
+var _chunk2VOZFFW6js = require('./chunk-2VOZFFW6.js');
 
-var RadarChart = vue.defineComponent({
+
+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: {
@@ -164,6 +192,18 @@ var RadarChart = vue.defineComponent({
       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
@@ -177,7 +217,7 @@ var RadarChart = vue.defineComponent({
     },
     pointBorderColor: {
       type: String,
-      default: "#fff"
+      default: "var(--tiger-surface,#ffffff)"
     },
     pointHoverSize: {
       type: Number,
@@ -199,17 +239,21 @@ var RadarChart = vue.defineComponent({
   },
   emits: ["update:hoveredIndex", "update:selectedIndex", "series-click", "series-hover"],
   setup(props, { emit }) {
-    const innerRect = vue.computed(() => tigercatCore.getChartInnerRect(props.width, props.height, props.padding));
-    const radius = vue.computed(
+    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(() => innerRect.value.width / 2);
-    const cy = vue.computed(() => innerRect.value.height / 2);
-    const resolvedSeries = vue.computed(
-      () => tigercatCore.resolveSeriesData(props.series, props.data, {
+    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,
@@ -223,14 +267,14 @@ var RadarChart = vue.defineComponent({
       handleLegendHover,
       handleLegendLeave,
       wrapperClasses
-    } = chunkFLAJKB2O_js.useChartInteraction({
-      hoverable: vue.computed(() => props.hoverable),
+    } = _chunk2VOZFFW6js.useChartInteraction.call(void 0, {
+      hoverable: _vue.computed.call(void 0, () => props.hoverable),
       hoveredIndexProp: () => props.hoveredIndex,
-      selectable: vue.computed(() => props.selectable),
+      selectable: _vue.computed.call(void 0, () => props.selectable),
       selectedIndexProp: () => props.selectedIndex,
-      activeOpacity: vue.computed(() => props.activeOpacity),
-      inactiveOpacity: vue.computed(() => props.inactiveOpacity),
-      legendPosition: vue.computed(() => props.legendPosition),
+      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: {
@@ -238,7 +282,7 @@ var RadarChart = vue.defineComponent({
         click: "series-click"
       }
     });
-    const hoveredPoint = vue.ref(null);
+    const hoveredPoint = _vue.ref.call(void 0, null);
     const handlePointEnter = (seriesIndex, pointIndex, event) => {
       if (!props.hoverable) return;
       hoveredPoint.value = { seriesIndex, pointIndex };
@@ -251,21 +295,22 @@ var RadarChart = vue.defineComponent({
       hoveredPoint.value = null;
       handleHoverLeave();
     };
-    const axisData = vue.computed(() => {
-      if (props.series && props.series.length > 0) return props.series[0]?.data ?? [];
-      return props.data ?? [];
+    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(() => {
+    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(() => tigercatCore.getRadarAngles(axisData.value.length, props.startAngle));
-    const seriesPoints = vue.computed(
-      () => resolvedSeries.value.map((item) => ({
+    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,
-        points: tigercatCore.getRadarPoints(item.data, {
+        seriesKey: seriesKeys.value[seriesIndex],
+        points: _tigercatcore.getRadarPoints.call(void 0, item.data, {
           cx: cx.value,
           cy: cy.value,
           radius: radius.value,
@@ -274,7 +319,7 @@ var RadarChart = vue.defineComponent({
         })
       }))
     );
-    const gridPaths = vue.computed(() => {
+    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) => {
@@ -283,21 +328,21 @@ var RadarChart = vue.defineComponent({
           return { type: "circle", cx: cx.value, cy: cy.value, r: levelRadius };
         }
         const ringPoints = angles.value.map(
-          (angle) => tigercatCore.polarToCartesian(cx.value, cy.value, levelRadius, angle)
+          (angle) => _tigercatcore.polarToCartesian.call(void 0, cx.value, cy.value, levelRadius, angle)
         );
         return {
           type: "polygon",
-          d: tigercatCore.createPolygonPath(ringPoints),
+          d: _tigercatcore.createPolygonPath.call(void 0, ringPoints),
           cx: cx.value,
           cy: cy.value,
           r: levelRadius
         };
       });
     });
-    const splitAreaPaths = vue.computed(() => {
+    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;
+      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);
@@ -314,16 +359,16 @@ var RadarChart = vue.defineComponent({
           };
         }
         const outerPoints = angles.value.map(
-          (angle) => tigercatCore.polarToCartesian(cx.value, cy.value, outerRadius, angle)
+          (angle) => _tigercatcore.polarToCartesian.call(void 0, cx.value, cy.value, outerRadius, angle)
         );
-        const innerPoints = outerIndex > 0 ? angles.value.map((angle) => tigercatCore.polarToCartesian(cx.value, cy.value, innerRadius, 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(() => {
+    const axisLines = _vue.computed.call(void 0, () => {
       if (!props.showAxis || angles.value.length === 0) return [];
       return angles.value.map((angle) => {
-        const end = tigercatCore.polarToCartesian(cx.value, cy.value, radius.value, angle);
+        const end = _tigercatcore.polarToCartesian.call(void 0, cx.value, cy.value, radius.value, angle);
         return {
           x1: cx.value,
           y1: cy.value,
@@ -332,18 +377,18 @@ var RadarChart = vue.defineComponent({
         };
       });
     });
-    const labels = vue.computed(() => {
+    const labels = _vue.computed.call(void 0, () => {
       if (!props.showLabels || angles.value.length === 0) return [];
-      const formatLabel = props.labelFormatter ?? ((datum) => datum.label ?? `${datum.value}`);
+      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(
+        const position = _tigercatcore.polarToCartesian.call(void 0, 
           cx.value,
           cy.value,
           radius.value + props.labelOffset,
           angle
         );
-        const align = props.labelAutoAlign ? tigercatCore.getRadarLabelAlign(angle) : { textAnchor: "middle", dominantBaseline: "middle" };
+        const align = props.labelAutoAlign ? _tigercatcore.getRadarLabelAlign.call(void 0, angle) : { textAnchor: "middle", dominantBaseline: "middle" };
         return {
           x: position.x,
           y: position.y,
@@ -353,14 +398,14 @@ var RadarChart = vue.defineComponent({
         };
       });
     });
-    const levelLabels = vue.computed(() => {
+    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 = props.levelLabelFormatter ?? ((value) => `${value}`);
+      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(
+        const position = _tigercatcore.polarToCartesian.call(void 0, 
           cx.value,
           cy.value,
           radius.value * ratio + props.levelLabelOffset,
@@ -373,43 +418,131 @@ var RadarChart = vue.defineComponent({
         };
       });
     });
-    const dasharray = vue.computed(() => tigercatCore.getChartGridLineDasharray(props.gridLineStyle));
-    const palette = vue.computed(() => tigercatCore.resolveChartPalette(props.colors));
-    const tooltipContent = vue.computed(
-      () => tigercatCore.resolveMultiSeriesTooltipContent(
+    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
+        _tigercatcore.defaultRadarTooltipFormatter
       )
     );
-    const legendItems = vue.computed(
-      () => tigercatCore.buildChartLegendItems({
+    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) : s.name ?? `Series ${i + 1}`,
-        getColor: (s, i) => s.color ?? palette.value[i % palette.value.length]
+        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(
-        chunkFCV4ML6I_js.ChartCanvas,
+      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(props.className)
+          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("g", { key: `split-${index}` }, [
-                  vue.h("circle", {
+                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,
@@ -418,7 +551,7 @@ var RadarChart = vue.defineComponent({
                     stroke: "none",
                     "data-radar-split-area": "true"
                   }),
-                  area.innerRadius > 0 ? vue.h("circle", {
+                  area.innerRadius > 0 ? _vue.h.call(void 0, "circle", {
                     cx: area.cx,
                     cy: area.cy,
                     r: area.innerRadius,
@@ -427,17 +560,17 @@ var RadarChart = vue.defineComponent({
                   }) : null
                 ]);
               }
-              const outerPath = tigercatCore.createPolygonPath(area.outerPoints);
-              return vue.h("g", { key: `split-${index}` }, [
-                outerPath ? vue.h("path", {
+              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("path", {
-                  d: tigercatCore.createPolygonPath(area.innerPoints),
+                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
@@ -445,57 +578,58 @@ var RadarChart = vue.defineComponent({
             }),
             // Grid lines
             ...gridPaths.value.map(
-              (grid, index) => grid.type === "circle" ? vue.h("circle", {
+              (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,
+                class: _tigercatcore.chartGridLineClasses,
                 fill: "none",
                 "stroke-width": props.gridStrokeWidth,
                 "stroke-dasharray": dasharray.value
-              }) : vue.h("path", {
+              }) : _vue.h.call(void 0, "path", {
                 key: `grid-${index}`,
                 d: grid.d,
-                class: tigercatCore.chartGridLineClasses,
+                class: _tigercatcore.chartGridLineClasses,
                 fill: "none",
                 "stroke-width": props.gridStrokeWidth,
                 "stroke-dasharray": dasharray.value
               })
             ),
             ...axisLines.value.map(
-              (line, index) => vue.h("line", {
+              (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,
+                class: _tigercatcore.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 = tigercatCore.createPolygonPath(
+              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(
-                chunkHBFFINAI_js.ChartSeries,
+              return _vue.h.call(void 0, 
+                _chunkHBFFINAIjs.ChartSeries,
                 {
-                  key: `series-${seriesIndex}`,
+                  key: item.seriesKey,
                   data: item.series.data,
                   name: item.series.name,
                   type: "radar",
-                  class: tigercatCore.classNames(
+                  "data-series-key": item.seriesKey,
+                  class: _tigercatcore.classNames.call(void 0, 
                     item.series.className,
                     props.hoverable || props.selectable ? "cursor-pointer" : null
                   ),
@@ -513,38 +647,40 @@ var RadarChart = vue.defineComponent({
                 },
                 {
                   default: () => [
-                    areaPath ? vue.h("path", {
+                    areaPath ? _vue.h.call(void 0, "path", {
                       d: areaPath,
-                      fill: resolvedFillColor,
-                      "fill-opacity": resolvedFillOpacity,
-                      stroke: resolvedStrokeColor,
+                      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-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 vue.h("circle", {
-                        key: `point-${seriesIndex}-${point.index}`,
+                      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: point.data.color ?? resolvedPointColor ?? resolvedStrokeColor,
+                        fill: props.pointGradient ? `url(#${gradientPrefix}-point-${item.seriesKey})` : _nullishCoalesce(_nullishCoalesce(point.data.color, () => ( resolvedPointColor)), () => ( resolvedStrokeColor)),
                         stroke: resolvedBorderColor,
                         "stroke-width": resolvedBorderWidth,
-                        class: tigercatCore.classNames(
+                        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,
@@ -556,13 +692,13 @@ var RadarChart = vue.defineComponent({
               );
             }),
             ...labels.value.map(
-              (label, index) => vue.h(
+              (label, index) => _vue.h.call(void 0, 
                 "text",
                 {
                   key: `label-${index}`,
                   x: label.x,
                   y: label.y,
-                  class: tigercatCore.chartAxisTickTextClasses,
+                  class: _tigercatcore.chartAxisTickTextClasses,
                   "text-anchor": label.textAnchor,
                   "dominant-baseline": label.dominantBaseline
                 },
@@ -570,13 +706,13 @@ var RadarChart = vue.defineComponent({
               )
             ),
             ...levelLabels.value.map(
-              (label, index) => vue.h(
+              (label, index) => _vue.h.call(void 0, 
                 "text",
                 {
                   key: `level-${index}`,
                   x: label.x,
                   y: label.y,
-                  class: tigercatCore.chartAxisTickTextClasses,
+                  class: _tigercatcore.chartAxisTickTextClasses,
                   "text-anchor": "middle",
                   "dominant-baseline": "middle",
                   "data-radar-level-label": "true"
@@ -587,18 +723,18 @@ var RadarChart = vue.defineComponent({
           ].filter(Boolean)
         }
       );
-      const tooltip = props.showTooltip && props.hoverable ? vue.h(chunkEPE6OOV7_js.ChartTooltip, {
+      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("div", { class: "inline-block relative" }, [chart, tooltip]);
+        return _vue.h.call(void 0, "div", { class: "inline-block relative" }, [chart, tooltip]);
       }
-      return vue.h("div", { class: wrapperClasses.value }, [
+      return _vue.h.call(void 0, "div", { class: wrapperClasses.value }, [
         chart,
-        vue.h(chunkBKTQ6RWR_js.ChartLegend, {
+        _vue.h.call(void 0, _chunkACYYQJ6Mjs.ChartLegend, {
           items: legendItems.value,
           position: props.legendPosition,
           markerSize: props.legendMarkerSize,
@@ -615,5 +751,7 @@ var RadarChart = vue.defineComponent({
 });
 var RadarChart_default = RadarChart;
 
-exports.RadarChart = RadarChart;
-exports.RadarChart_default = RadarChart_default;
+
+
+
+exports.RadarChart = RadarChart; exports.RadarChart_default = RadarChart_default;