@expcat/tigercat-vue 1.0.7 → 1.2.0

package/dist/{chunk-2J54DRDA.js → chunk-KA7DILCI.js}

@@ -1,16 +1,46 @@
-'use strict';
-
-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 chunk5PXTMXXS_js = require('./chunk-5PXTMXXS.js');
-var chunkFCV4ML6I_js = require('./chunk-FCV4ML6I.js');
-var chunk57MJTNDL_js = require('./chunk-57MJTNDL.js');
-var vue = require('vue');
-var tigercatCore = require('@expcat/tigercat-core');
-
-var LineChart = vue.defineComponent({
+"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 _chunk5PXTMXXSjs = require('./chunk-5PXTMXXS.js');
+
+
+var _chunkUHVUKLHFjs = require('./chunk-UHVUKLHF.js');
+
+
+var _chunk57MJTNDLjs = require('./chunk-57MJTNDL.js');
+
+// src/components/LineChart.ts
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var LineChart = _vue.defineComponent.call(void 0, {
   name: "TigerLineChart",
   props: {
     width: {
@@ -178,6 +208,16 @@ var LineChart = vue.defineComponent({
       type: Boolean,
       default: false
     },
+    // Stroke gradient (modern look — opt-in)
+    strokeGradient: {
+      type: Boolean,
+      default: false
+    },
+    // Point fill radial gradient (modern look — opt-in)
+    pointGradient: {
+      type: Boolean,
+      default: false
+    },
     // Tooltip props
     showTooltip: {
       type: Boolean,
@@ -209,12 +249,12 @@ var LineChart = vue.defineComponent({
     "point-hover"
   ],
   setup(props, { emit }) {
-    const hoveredPointInfo = vue.ref(null);
-    const tooltipPosition = vue.ref({ x: 0, y: 0 });
-    const gradientPrefix = tigercatCore.getLineGradientPrefix();
-    const innerRect = vue.computed(() => tigercatCore.getChartInnerRect(props.width, props.height, props.padding));
-    const resolvedSeries = vue.computed(
-      () => tigercatCore.resolveSeriesData(props.series, props.data)
+    const hoveredPointInfo = _vue.ref.call(void 0, null);
+    const tooltipPosition = _vue.ref.call(void 0, { x: 0, y: 0 });
+    const gradientPrefix = _tigercatcore.getStableChartGradientPrefix.call(void 0, "line", _vue.useId.call(void 0, ));
+    const innerRect = _vue.computed.call(void 0, () => _tigercatcore.getChartInnerRect.call(void 0, props.width, props.height, props.padding));
+    const resolvedSeries = _vue.computed.call(void 0, 
+      () => _tigercatcore.resolveSeriesData.call(void 0, props.series, props.data)
     );
     const {
       activeIndex,
@@ -225,14 +265,14 @@ var LineChart = 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: {
@@ -240,78 +280,83 @@ var LineChart = vue.defineComponent({
         click: "series-click"
       }
     });
-    const allData = vue.computed(() => resolvedSeries.value.flatMap((s) => s.data));
-    const xValues = vue.computed(() => allData.value.map((d) => d.x));
-    const yValues = vue.computed(() => allData.value.map((d) => d.y));
-    const isXNumeric = vue.computed(() => xValues.value.every((v) => typeof v === "number"));
-    const resolvedXScale = vue.computed(() => {
+    const allData = _vue.computed.call(void 0, () => resolvedSeries.value.flatMap((s) => s.data));
+    const xValues = _vue.computed.call(void 0, () => allData.value.map((d) => d.x));
+    const yValues = _vue.computed.call(void 0, () => allData.value.map((d) => d.y));
+    const isXNumeric = _vue.computed.call(void 0, () => xValues.value.every((v) => typeof v === "number"));
+    const resolvedXScale = _vue.computed.call(void 0, () => {
       if (props.xScale) return props.xScale;
       if (isXNumeric.value) {
-        const extent = tigercatCore.getNumberExtent(xValues.value, { includeZero: false });
-        return tigercatCore.createLinearScale(extent, [0, innerRect.value.width]);
+        const extent = _tigercatcore.getNumberExtent.call(void 0, xValues.value, { includeZero: false });
+        return _tigercatcore.createLinearScale.call(void 0, extent, [0, innerRect.value.width]);
       } else {
         const categories = [...new Set(xValues.value.map(String))];
-        return tigercatCore.createPointScale(categories, [0, innerRect.value.width], { padding: 0 });
+        return _tigercatcore.createPointScale.call(void 0, categories, [0, innerRect.value.width], { padding: 0 });
       }
     });
-    const resolvedYScale = vue.computed(() => {
+    const resolvedYScale = _vue.computed.call(void 0, () => {
       if (props.yScale) return props.yScale;
-      const extent = tigercatCore.getNumberExtent(yValues.value, { includeZero: props.includeZero });
-      return tigercatCore.createLinearScale(extent, [innerRect.value.height, 0]);
+      const extent = _tigercatcore.getNumberExtent.call(void 0, yValues.value, { includeZero: props.includeZero });
+      return _tigercatcore.createLinearScale.call(void 0, extent, [innerRect.value.height, 0]);
     });
-    const shouldShowXAxis = vue.computed(() => props.showAxis && props.showXAxis);
-    const shouldShowYAxis = vue.computed(() => props.showAxis && props.showYAxis);
-    const palette = vue.computed(() => tigercatCore.resolveChartPalette(props.colors));
-    const seriesData = vue.computed(
+    const shouldShowXAxis = _vue.computed.call(void 0, () => props.showAxis && props.showXAxis);
+    const shouldShowYAxis = _vue.computed.call(void 0, () => props.showAxis && props.showYAxis);
+    const palette = _vue.computed.call(void 0, () => _tigercatcore.resolveChartPalette.call(void 0, props.colors));
+    const seriesKeys = _vue.computed.call(void 0, 
+      () => _tigercatcore.buildChartSeriesKeys.call(void 0, resolvedSeries.value, { prefix: "line-" })
+    );
+    const seriesData = _vue.computed.call(void 0, 
       () => resolvedSeries.value.map((series, seriesIndex) => {
-        const color = series.color ?? palette.value[seriesIndex % palette.value.length];
+        const seriesKey = seriesKeys.value[seriesIndex];
+        const color = _nullishCoalesce(series.color, () => ( palette.value[seriesIndex % palette.value.length]));
         const points = series.data.map((datum, pointIndex) => ({
           x: resolvedXScale.value.map(datum.x),
           y: resolvedYScale.value.map(datum.y),
           datum,
           pointIndex
         }));
-        const linePath = tigercatCore.createLinePath(points, props.curve);
-        const seriesShowArea = series.showArea ?? props.showArea;
-        const areaPath = seriesShowArea ? tigercatCore.createAreaPath(points, innerRect.value.height, props.curve) : "";
-        const opacity = tigercatCore.getChartElementOpacity(seriesIndex, activeIndex.value, {
+        const linePath = _tigercatcore.createLinePath.call(void 0, points, props.curve);
+        const seriesShowArea = _nullishCoalesce(series.showArea, () => ( props.showArea));
+        const areaPath = seriesShowArea ? _tigercatcore.createAreaPath.call(void 0, points, innerRect.value.height, props.curve) : "";
+        const opacity = _tigercatcore.getChartElementOpacity.call(void 0, seriesIndex, activeIndex.value, {
           activeOpacity: props.activeOpacity,
           inactiveOpacity: props.inactiveOpacity
         });
         return {
           series,
           seriesIndex,
+          seriesKey,
           color,
           linePath,
           areaPath,
           showArea: seriesShowArea,
-          areaOpacity: series.areaOpacity ?? props.areaOpacity,
+          areaOpacity: _nullishCoalesce(series.areaOpacity, () => ( props.areaOpacity)),
           points,
           opacity,
-          strokeWidth: series.strokeWidth ?? props.strokeWidth,
+          strokeWidth: _nullishCoalesce(series.strokeWidth, () => ( props.strokeWidth)),
           strokeDasharray: series.strokeDasharray,
-          showPoints: series.showPoints ?? props.showPoints,
-          pointSize: series.pointSize ?? props.pointSize,
-          pointColor: series.pointColor ?? color,
-          pointHollow: series.pointHollow ?? props.pointHollow
+          showPoints: _nullishCoalesce(series.showPoints, () => ( props.showPoints)),
+          pointSize: _nullishCoalesce(series.pointSize, () => ( props.pointSize)),
+          pointColor: _nullishCoalesce(series.pointColor, () => ( color)),
+          pointHollow: _nullishCoalesce(series.pointHollow, () => ( props.pointHollow))
         };
       })
     );
-    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: activeIndex.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]))
       })
     );
-    const tooltipContent = vue.computed(
-      () => tigercatCore.resolveMultiSeriesTooltipContent(
+    const tooltipContent = _vue.computed.call(void 0, 
+      () => _tigercatcore.resolveMultiSeriesTooltipContent.call(void 0, 
         hoveredPointInfo.value,
         resolvedSeries.value,
         props.tooltipFormatter,
-        tigercatCore.defaultSeriesXYTooltipFormatter
+        _tigercatcore.defaultSeriesXYTooltipFormatter
       )
     );
     const handlePointMouseEnter = (seriesIndex, pointIndex, event) => {
@@ -321,7 +366,7 @@ var LineChart = vue.defineComponent({
         "point-hover",
         seriesIndex,
         pointIndex,
-        resolvedSeries.value[seriesIndex]?.data[pointIndex]
+        _optionalChain([resolvedSeries, 'access', _ => _.value, 'access', _2 => _2[seriesIndex], 'optionalAccess', _3 => _3.data, 'access', _4 => _4[pointIndex]])
       );
     };
     const handlePointMouseMove = (event) => {
@@ -336,7 +381,7 @@ var LineChart = vue.defineComponent({
         "point-click",
         seriesIndex,
         pointIndex,
-        resolvedSeries.value[seriesIndex]?.data[pointIndex]
+        _optionalChain([resolvedSeries, 'access', _5 => _5.value, 'access', _6 => _6[seriesIndex], 'optionalAccess', _7 => _7.data, 'access', _8 => _8[pointIndex]])
       );
       handleSeriesSelect(seriesIndex);
     };
@@ -347,19 +392,19 @@ var LineChart = vue.defineComponent({
       handleSeriesSelect(seriesIndex);
     };
     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: () => [
-            props.showGrid ? vue.h(chunk57MJTNDL_js.ChartGrid, {
+            props.showGrid ? _vue.h.call(void 0, _chunk57MJTNDLjs.ChartGrid, {
               xScale: resolvedXScale.value,
               yScale: resolvedYScale.value,
               show: "both",
@@ -370,7 +415,7 @@ var LineChart = vue.defineComponent({
               lineStyle: props.gridLineStyle,
               strokeWidth: props.gridStrokeWidth
             }) : null,
-            shouldShowXAxis.value ? vue.h(chunk5PXTMXXS_js.ChartAxis, {
+            shouldShowXAxis.value ? _vue.h.call(void 0, _chunk5PXTMXXSjs.ChartAxis, {
               scale: resolvedXScale.value,
               orientation: "bottom",
               y: innerRect.value.height,
@@ -379,7 +424,7 @@ var LineChart = vue.defineComponent({
               tickFormat: props.xTickFormat,
               label: props.xAxisLabel
             }) : null,
-            shouldShowYAxis.value ? vue.h(chunk5PXTMXXS_js.ChartAxis, {
+            shouldShowYAxis.value ? _vue.h.call(void 0, _chunk5PXTMXXSjs.ChartAxis, {
               scale: resolvedYScale.value,
               orientation: "left",
               ticks: props.yTicks,
@@ -388,59 +433,118 @@ var LineChart = vue.defineComponent({
               label: props.yAxisLabel
             }) : null,
             // Gradient defs and animation styles
-            seriesData.value.some((sd) => sd.showArea) || props.animated ? vue.h("defs", null, [
+            seriesData.value.some((sd) => sd.showArea) || props.animated || props.strokeGradient || props.pointGradient ? _vue.h.call(void 0, "defs", null, [
               // Animation keyframes
-              props.animated ? vue.h(
+              props.animated ? _vue.h.call(void 0, 
                 "style",
                 null,
                 `
                           .tiger-line-animated {
-                            animation: tiger-line-draw 1.2s cubic-bezier(.4,0,.2,1) forwards;
+                            animation: tiger-line-draw var(--tiger-motion-duration-slow,1.2s) var(--tiger-motion-ease-emphasized,cubic-bezier(.4,0,.2,1)) forwards;
                           }
                           @keyframes tiger-line-draw {
                             from { stroke-dashoffset: 1; }
                             to { stroke-dashoffset: 0; }
                           }
+                          @media (prefers-reduced-motion: reduce) {
+                            .tiger-line-animated { animation-duration: 0ms; }
+                          }
                         `
               ) : null,
               // Area fill gradients
               ...seriesData.value.filter((sd) => sd.showArea).map(
-                (sd) => vue.h(
+                (sd) => _vue.h.call(void 0, 
                   "linearGradient",
                   {
-                    key: `area-grad-${sd.seriesIndex}`,
-                    id: `${gradientPrefix}-${sd.seriesIndex}`,
+                    key: `area-grad-${sd.seriesKey}`,
+                    id: `${gradientPrefix}-${sd.seriesKey}`,
                     x1: "0",
                     y1: "0",
                     x2: "0",
                     y2: "1"
                   },
                   [
-                    vue.h("stop", {
+                    _vue.h.call(void 0, "stop", {
                       offset: "0%",
                       "stop-color": sd.color,
                       "stop-opacity": sd.areaOpacity
                     }),
-                    vue.h("stop", {
+                    _vue.h.call(void 0, "stop", {
                       offset: "100%",
                       "stop-color": sd.color,
                       "stop-opacity": 0.02
                     })
                   ]
                 )
-              )
+              ),
+              // Point fill radial gradients (bright center → series color edge)
+              ...props.pointGradient ? seriesData.value.map(
+                (sd) => _vue.h.call(void 0, 
+                  "radialGradient",
+                  {
+                    key: `point-grad-${sd.seriesKey}`,
+                    id: `${gradientPrefix}-point-${sd.seriesKey}`,
+                    cx: "0.5",
+                    cy: "0.5",
+                    r: "0.5"
+                  },
+                  [
+                    _vue.h.call(void 0, "stop", {
+                      offset: "0%",
+                      "stop-color": `color-mix(in oklab, ${sd.color} 100%, white 30%)`
+                    }),
+                    _vue.h.call(void 0, "stop", {
+                      offset: "70%",
+                      "stop-color": sd.color
+                    }),
+                    _vue.h.call(void 0, "stop", {
+                      offset: "100%",
+                      "stop-color": `color-mix(in oklab, ${sd.color} 100%, black 12%)`
+                    })
+                  ]
+                )
+              ) : [],
+              // Stroke gradients (3-stop horizontal lighter→base→darker)
+              ...props.strokeGradient ? seriesData.value.map(
+                (sd) => _vue.h.call(void 0, 
+                  "linearGradient",
+                  {
+                    key: `stroke-grad-${sd.seriesKey}`,
+                    id: `${gradientPrefix}-stroke-${sd.seriesKey}`,
+                    x1: "0",
+                    y1: "0",
+                    x2: "1",
+                    y2: "0"
+                  },
+                  [
+                    _vue.h.call(void 0, "stop", {
+                      offset: "0%",
+                      "stop-color": `color-mix(in oklab, ${sd.color} 100%, white 12%)`
+                    }),
+                    _vue.h.call(void 0, "stop", {
+                      offset: "50%",
+                      "stop-color": sd.color
+                    }),
+                    _vue.h.call(void 0, "stop", {
+                      offset: "100%",
+                      "stop-color": `color-mix(in oklab, ${sd.color} 100%, black 8%)`
+                    })
+                  ]
+                )
+              ) : []
             ]) : null,
             // Render each series
             ...seriesData.value.map(
-              (sd) => vue.h(
-                chunkHBFFINAI_js.ChartSeries,
+              (sd) => _vue.h.call(void 0, 
+                _chunkHBFFINAIjs.ChartSeries,
                 {
-                  key: `series-${sd.seriesIndex}`,
+                  key: sd.seriesKey,
                   data: sd.series.data,
                   name: sd.series.name,
                   type: "line",
                   opacity: sd.opacity,
-                  class: tigercatCore.classNames(
+                  "data-series-key": sd.seriesKey,
+                  class: _tigercatcore.classNames.call(void 0, 
                     sd.series.className,
                     (props.hoverable || props.selectable) && "cursor-pointer"
                   ),
@@ -453,45 +557,48 @@ var LineChart = vue.defineComponent({
                 {
                   default: () => [
                     // Area fill path
-                    sd.showArea && sd.areaPath ? vue.h("path", {
+                    sd.showArea && sd.areaPath ? _vue.h.call(void 0, "path", {
                       d: sd.areaPath,
-                      fill: `url(#${gradientPrefix}-${sd.seriesIndex})`,
+                      fill: `url(#${gradientPrefix}-${sd.seriesKey})`,
                       stroke: "none",
                       class: "transition-opacity duration-300",
-                      "data-area-series": sd.seriesIndex
+                      "data-area-series": sd.seriesIndex,
+                      "data-series-key": sd.seriesKey
                     }) : null,
                     // Line path
-                    vue.h("path", {
+                    _vue.h.call(void 0, "path", {
                       d: sd.linePath,
                       fill: "none",
-                      stroke: sd.color,
+                      stroke: props.strokeGradient ? `url(#${gradientPrefix}-stroke-${sd.seriesKey})` : sd.color,
                       "stroke-width": sd.strokeWidth,
-                      "stroke-dasharray": props.animated ? sd.strokeDasharray ?? "1" : sd.strokeDasharray,
+                      "stroke-dasharray": props.animated ? _nullishCoalesce(sd.strokeDasharray, () => ( "1")) : sd.strokeDasharray,
                       "stroke-dashoffset": props.animated ? "1" : void 0,
                       "stroke-linecap": "round",
                       "stroke-linejoin": "round",
                       pathLength: props.animated ? 1 : void 0,
-                      class: tigercatCore.classNames(
-                        "transition-opacity duration-200",
+                      class: _tigercatcore.classNames.call(void 0, 
+                        "transition-opacity [transition-duration:var(--tiger-motion-duration-base,200ms)]",
                         props.animated && "tiger-line-animated"
                       ),
-                      "data-line-series": sd.seriesIndex
+                      "data-line-series": sd.seriesIndex,
+                      "data-series-key": sd.seriesKey
                     }),
                     // Data points
                     sd.showPoints ? sd.points.map((point) => {
-                      const isHovered = hoveredPointInfo.value?.seriesIndex === sd.seriesIndex && hoveredPointInfo.value?.pointIndex === point.pointIndex;
+                      const isHovered = _optionalChain([hoveredPointInfo, 'access', _9 => _9.value, 'optionalAccess', _10 => _10.seriesIndex]) === sd.seriesIndex && _optionalChain([hoveredPointInfo, 'access', _11 => _11.value, 'optionalAccess', _12 => _12.pointIndex]) === point.pointIndex;
                       const hoverSize = sd.pointSize + 2;
-                      return vue.h("circle", {
-                        key: `point-${sd.seriesIndex}-${point.pointIndex}`,
+                      return _vue.h.call(void 0, "circle", {
+                        key: `point-${sd.seriesKey}-${point.pointIndex}`,
                         cx: point.x,
                         cy: point.y,
                         r: isHovered ? hoverSize : sd.pointSize,
-                        fill: sd.pointHollow ? "white" : sd.pointColor,
+                        fill: sd.pointHollow ? "white" : props.pointGradient ? `url(#${gradientPrefix}-point-${sd.seriesKey})` : sd.pointColor,
                         stroke: sd.pointHollow ? sd.pointColor : "none",
                         "stroke-width": sd.pointHollow ? 2 : 0,
-                        class: "transition-all duration-200 ease-out",
+                        class: _tigercatcore.linePointTransitionClasses,
                         style: isHovered ? `filter: drop-shadow(0 0 4px ${sd.color})` : void 0,
                         "data-point-index": point.pointIndex,
+                        "data-series-key": sd.seriesKey,
                         onMouseenter: (e) => handlePointMouseEnter(sd.seriesIndex, point.pointIndex, e),
                         onMousemove: handlePointMouseMove,
                         onMouseleave: handlePointMouseLeave,
@@ -508,18 +615,18 @@ var LineChart = vue.defineComponent({
           ].filter(Boolean)
         }
       );
-      const tooltip = props.showTooltip ? vue.h(chunkEPE6OOV7_js.ChartTooltip, {
+      const tooltip = props.showTooltip ? _vue.h.call(void 0, _chunkZOUJFFG4js.ChartTooltip, {
         content: tooltipContent.value,
         visible: hoveredPointInfo.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,
@@ -536,5 +643,7 @@ var LineChart = vue.defineComponent({
 });
 var LineChart_default = LineChart;
 
-exports.LineChart = LineChart;
-exports.LineChart_default = LineChart_default;
+
+
+
+exports.LineChart = LineChart; exports.LineChart_default = LineChart_default;

package/dist/chunk-KDA4XDXT.js

@@ -0,0 +1,67 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkX6FG4RPFjs = require('./chunk-X6FG4RPF.js');
+
+// src/components/ImageGroup.ts
+var _vue = require('vue');
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var IMAGE_GROUP_INJECTION_KEY = "tiger-image-group";
+var ImageGroup = _vue.defineComponent.call(void 0, {
+  name: "TigerImageGroup",
+  props: {
+    preview: { type: Boolean, default: true }
+  },
+  emits: ["preview-visible-change"],
+  setup(props, { slots, emit }) {
+    const images = _vue.ref.call(void 0, []);
+    const previewVisible = _vue.ref.call(void 0, false);
+    const previewIndex = _vue.ref.call(void 0, 0);
+    const context = {
+      register(src) {
+        const result = _tigercatcore.registerImageGroupItem.call(void 0, images.value, src);
+        images.value = result.items;
+        return result.index;
+      },
+      unregister(src) {
+        images.value = _tigercatcore.unregisterImageGroupItem.call(void 0, images.value, src);
+      },
+      openPreview(index) {
+        if (!props.preview) return;
+        previewIndex.value = index;
+        previewVisible.value = true;
+        emit("preview-visible-change", true);
+      }
+    };
+    _vue.provide.call(void 0, IMAGE_GROUP_INJECTION_KEY, context);
+    _vue.onBeforeUnmount.call(void 0, () => {
+      images.value = [];
+    });
+    return () => {
+      const children = _optionalChain([slots, 'access', _ => _.default, 'optionalCall', _2 => _2()]);
+      const preview = props.preview ? _vue.h.call(void 0, _chunkX6FG4RPFjs.ImagePreview, {
+        open: previewVisible.value,
+        images: images.value,
+        currentIndex: previewIndex.value,
+        "onUpdate:open": (val) => {
+          previewVisible.value = val;
+          if (!val) emit("preview-visible-change", false);
+        },
+        "onUpdate:currentIndex": (val) => {
+          previewIndex.value = val;
+        }
+      }) : null;
+      return _vue.h.call(void 0, "div", { class: _tigercatcore.getImageGroupClasses.call(void 0, ), role: "group" }, [children, preview]);
+    };
+  }
+});
+var ImageGroup_default = ImageGroup;
+
+
+
+
+
+exports.IMAGE_GROUP_INJECTION_KEY = IMAGE_GROUP_INJECTION_KEY; exports.ImageGroup = ImageGroup; exports.ImageGroup_default = ImageGroup_default;

package/dist/chunk-KOTSKHPQ.mjs

@@ -1,7 +1,19 @@
-import { defineComponent, computed, h } from 'vue';
-import { classNames, getCardClasses, cardDirectionClasses, cardSizeClasses, mergeStyleValues, coerceClassValue, cardCoverWrapperClasses, cardCoverClasses, cardActionsClasses, cardFooterClasses, cardHorizontalBodyClasses, cardHeaderClasses } from '@expcat/tigercat-core';
-
 // src/components/Card.ts
+import { defineComponent, computed, h } from "vue";
+import {
+  classNames,
+  coerceClassValue,
+  mergeStyleValues,
+  getCardClasses,
+  cardSizeClasses,
+  cardHeaderClasses,
+  cardFooterClasses,
+  cardCoverWrapperClasses,
+  cardCoverClasses,
+  cardActionsClasses,
+  cardDirectionClasses,
+  cardHorizontalBodyClasses
+} from "@expcat/tigercat-core";
 var Card = defineComponent({
   name: "TigerCard",
   inheritAttrs: false,
@@ -122,4 +134,7 @@ var Card = defineComponent({
 });
 var Card_default = Card;
 
-export { Card, Card_default };
+export {
+  Card,
+  Card_default
+};