@expcat/tigercat-vue 1.1.0 → 1.2.0

package/dist/{chunk-OMVVPNU7.js → chunk-5VSKQLK3.js}

@@ -1,16 +1,47 @@
-'use strict';
-
-var chunkGZK6R2E3_js = require('./chunk-GZK6R2E3.js');
-var chunkACYYQJ6M_js = require('./chunk-ACYYQJ6M.js');
-var chunkHBFFINAI_js = require('./chunk-HBFFINAI.js');
-var chunkZOUJFFG4_js = require('./chunk-ZOUJFFG4.js');
-var chunk5PXTMXXS_js = require('./chunk-5PXTMXXS.js');
-var chunkUHVUKLHF_js = require('./chunk-UHVUKLHF.js');
-var chunk57MJTNDL_js = require('./chunk-57MJTNDL.js');
-var vue = require('vue');
-var tigercatCore = require('@expcat/tigercat-core');
-
-var AreaChart = 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/AreaChart.ts
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var AreaChart = _vue.defineComponent.call(void 0, {
   name: "TigerAreaChart",
   props: {
     width: {
@@ -218,12 +249,12 @@ var AreaChart = vue.defineComponent({
     "point-hover"
   ],
   setup(props, { emit }) {
-    const hoveredPointInfo = vue.ref(null);
-    const tooltipPosition = vue.ref({ x: 0, y: 0 });
-    const gradientPrefix = tigercatCore.getAreaGradientPrefix();
-    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, "area", _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 {
       resolvedHoveredIndex: _resolvedHoveredIndex,
@@ -236,14 +267,14 @@ var AreaChart = vue.defineComponent({
       handleLegendHover: _handleLegendHover,
       handleLegendLeave: _handleLegendLeave,
       wrapperClasses
-    } = chunkGZK6R2E3_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: {
@@ -251,45 +282,45 @@ var AreaChart = 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(() => {
+    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, () => {
       if (props.stacked) {
-        const stackedData = tigercatCore.stackSeriesData(resolvedSeries.value.map((s) => s.data));
+        const stackedData = _tigercatcore.stackSeriesData.call(void 0, resolvedSeries.value.map((s) => s.data));
         return stackedData.flatMap((series) => series.map((d) => d.y1));
       }
       return allData.value.map((d) => d.y);
     });
-    const isXNumeric = vue.computed(() => xValues.value.every((v) => typeof v === "number"));
-    const resolvedXScale = vue.computed(() => {
+    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 baseline = vue.computed(() => resolvedYScale.value.map(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 seriesKeys = vue.computed(
-      () => tigercatCore.buildChartSeriesKeys(resolvedSeries.value, { prefix: "area-" })
+    const baseline = _vue.computed.call(void 0, () => resolvedYScale.value.map(0));
+    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: "area-" })
     );
-    const seriesData = vue.computed(() => {
-      const stackedData = props.stacked ? tigercatCore.stackSeriesData(resolvedSeries.value.map((s) => s.data)) : null;
+    const seriesData = _vue.computed.call(void 0, () => {
+      const stackedData = props.stacked ? _tigercatcore.stackSeriesData.call(void 0, resolvedSeries.value.map((s) => s.data)) : null;
       return resolvedSeries.value.map((series, seriesIndex) => {
         const seriesKey = seriesKeys.value[seriesIndex];
-        const color = series.color ?? palette.value[seriesIndex % palette.value.length];
-        const fillColor = series.fillColor ?? color;
-        const seriesFillOpacity = series.fillOpacity ?? props.fillOpacity;
+        const color = _nullishCoalesce(series.color, () => ( palette.value[seriesIndex % palette.value.length]));
+        const fillColor = _nullishCoalesce(series.fillColor, () => ( color));
+        const seriesFillOpacity = _nullishCoalesce(series.fillOpacity, () => ( props.fillOpacity));
         let points;
         let areaPath;
         let linePath;
@@ -306,8 +337,8 @@ var AreaChart = vue.defineComponent({
             x: resolvedXScale.value.map(sd.original.x),
             y: resolvedYScale.value.map(sd.y0)
           })).reverse();
-          const topPath = tigercatCore.createLinePath(topPoints, props.curve);
-          const bottomPath = tigercatCore.createLinePath(bottomPoints, props.curve).replace("M", "L");
+          const topPath = _tigercatcore.createLinePath.call(void 0, topPoints, props.curve);
+          const bottomPath = _tigercatcore.createLinePath.call(void 0, bottomPoints, props.curve).replace("M", "L");
           areaPath = `${topPath} ${bottomPath} Z`;
           linePath = topPath;
         } else {
@@ -317,10 +348,10 @@ var AreaChart = vue.defineComponent({
             datum,
             pointIndex
           }));
-          areaPath = tigercatCore.createAreaPath(points, baseline.value, props.curve);
-          linePath = tigercatCore.createLinePath(points, props.curve);
+          areaPath = _tigercatcore.createAreaPath.call(void 0, points, baseline.value, props.curve);
+          linePath = _tigercatcore.createLinePath.call(void 0, points, props.curve);
         }
-        const opacity = tigercatCore.getChartElementOpacity(seriesIndex, activeIndex.value, {
+        const opacity = _tigercatcore.getChartElementOpacity.call(void 0, seriesIndex, activeIndex.value, {
           activeOpacity: props.activeOpacity,
           inactiveOpacity: props.inactiveOpacity
         });
@@ -335,30 +366,30 @@ var AreaChart = vue.defineComponent({
           linePath,
           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) => {
@@ -368,7 +399,7 @@ var AreaChart = 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) => {
@@ -383,7 +414,7 @@ var AreaChart = 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);
     };
@@ -395,37 +426,40 @@ var AreaChart = vue.defineComponent({
     };
     return () => {
       const reversedSeriesData = [...seriesData.value].reverse();
-      const chart = vue.h(
-        chunkUHVUKLHF_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 and animation styles
-            props.gradient || props.animated || props.strokeGradient || props.pointGradient ? vue.h("defs", null, [
+            props.gradient || 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-area-animated {
-                            animation: tiger-area-draw 1.2s cubic-bezier(.4,0,.2,1) forwards;
+                            animation: tiger-area-draw var(--tiger-motion-duration-slow,1.2s) var(--tiger-motion-ease-emphasized,cubic-bezier(.4,0,.2,1)) forwards;
                           }
                           @keyframes tiger-area-draw {
                             from { stroke-dashoffset: 1; }
                             to { stroke-dashoffset: 0; }
                           }
+                          @media (prefers-reduced-motion: reduce) {
+                            .tiger-area-animated { animation-duration: 0ms; }
+                          }
                         `
               ) : null,
               // Area fill gradients
               ...props.gradient ? reversedSeriesData.map(
-                (sd) => vue.h(
+                (sd) => _vue.h.call(void 0, 
                   "linearGradient",
                   {
                     key: `area-grad-${sd.seriesKey}`,
@@ -436,12 +470,12 @@ var AreaChart = vue.defineComponent({
                     y2: "1"
                   },
                   [
-                    vue.h("stop", {
+                    _vue.h.call(void 0, "stop", {
                       offset: "0%",
                       "stop-color": sd.fillColor,
                       "stop-opacity": sd.fillOpacity
                     }),
-                    vue.h("stop", {
+                    _vue.h.call(void 0, "stop", {
                       offset: "100%",
                       "stop-color": sd.fillColor,
                       "stop-opacity": 0.02
@@ -451,7 +485,7 @@ var AreaChart = vue.defineComponent({
               ) : [],
               // Point fill radial gradients (bright center → series color edge)
               ...props.pointGradient ? reversedSeriesData.map(
-                (sd) => vue.h(
+                (sd) => _vue.h.call(void 0, 
                   "radialGradient",
                   {
                     key: `point-grad-${sd.seriesKey}`,
@@ -461,15 +495,15 @@ var AreaChart = vue.defineComponent({
                     r: "0.5"
                   },
                   [
-                    vue.h("stop", {
+                    _vue.h.call(void 0, "stop", {
                       offset: "0%",
                       "stop-color": `color-mix(in oklab, ${sd.color} 100%, white 30%)`
                     }),
-                    vue.h("stop", {
+                    _vue.h.call(void 0, "stop", {
                       offset: "70%",
                       "stop-color": sd.color
                     }),
-                    vue.h("stop", {
+                    _vue.h.call(void 0, "stop", {
                       offset: "100%",
                       "stop-color": `color-mix(in oklab, ${sd.color} 100%, black 12%)`
                     })
@@ -478,7 +512,7 @@ var AreaChart = vue.defineComponent({
               ) : [],
               // Stroke gradients (3-stop horizontal brightness ramp)
               ...props.strokeGradient ? reversedSeriesData.map(
-                (sd) => vue.h(
+                (sd) => _vue.h.call(void 0, 
                   "linearGradient",
                   {
                     key: `stroke-grad-${sd.seriesKey}`,
@@ -489,15 +523,15 @@ var AreaChart = vue.defineComponent({
                     y2: "0"
                   },
                   [
-                    vue.h("stop", {
+                    _vue.h.call(void 0, "stop", {
                       offset: "0%",
                       "stop-color": `color-mix(in oklab, ${sd.color} 100%, white 12%)`
                     }),
-                    vue.h("stop", {
+                    _vue.h.call(void 0, "stop", {
                       offset: "50%",
                       "stop-color": sd.color
                     }),
-                    vue.h("stop", {
+                    _vue.h.call(void 0, "stop", {
                       offset: "100%",
                       "stop-color": `color-mix(in oklab, ${sd.color} 100%, black 8%)`
                     })
@@ -505,7 +539,7 @@ var AreaChart = vue.defineComponent({
                 )
               ) : []
             ]) : null,
-            props.showGrid ? vue.h(chunk57MJTNDL_js.ChartGrid, {
+            props.showGrid ? _vue.h.call(void 0, _chunk57MJTNDLjs.ChartGrid, {
               xScale: resolvedXScale.value,
               yScale: resolvedYScale.value,
               show: "both",
@@ -516,7 +550,7 @@ var AreaChart = 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,
@@ -525,7 +559,7 @@ var AreaChart = 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,
@@ -535,8 +569,8 @@ var AreaChart = vue.defineComponent({
             }) : null,
             // Layer 1: area fills + line strokes (reverse order for proper stacking visual)
             ...reversedSeriesData.map(
-              (sd) => vue.h(
-                chunkHBFFINAI_js.ChartSeries,
+              (sd) => _vue.h.call(void 0, 
+                _chunkHBFFINAIjs.ChartSeries,
                 {
                   key: sd.seriesKey,
                   data: sd.series.data,
@@ -544,7 +578,7 @@ var AreaChart = vue.defineComponent({
                   type: "area",
                   opacity: sd.opacity,
                   "data-series-key": sd.seriesKey,
-                  class: tigercatCore.classNames(
+                  class: _tigercatcore.classNames.call(void 0, 
                     sd.series.className,
                     (props.hoverable || props.selectable) && "cursor-pointer",
                     "outline-none"
@@ -558,7 +592,7 @@ var AreaChart = vue.defineComponent({
                 {
                   default: () => [
                     // Area fill
-                    vue.h("path", {
+                    _vue.h.call(void 0, "path", {
                       d: sd.areaPath,
                       fill: props.gradient ? `url(#${gradientPrefix}-${sd.seriesKey})` : sd.fillColor,
                       "fill-opacity": props.gradient ? 1 : sd.fillOpacity,
@@ -568,18 +602,18 @@ var AreaChart = vue.defineComponent({
                       "data-series-key": sd.seriesKey
                     }),
                     // Line stroke
-                    vue.h("path", {
+                    _vue.h.call(void 0, "path", {
                       d: sd.linePath,
                       fill: "none",
                       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-area-animated"
                       )
                     })
@@ -589,7 +623,7 @@ var AreaChart = vue.defineComponent({
             ),
             // Layer 2: data points on top of all areas (prevents coverage)
             ...seriesData.value.filter((sd) => sd.showPoints).map(
-              (sd) => vue.h(
+              (sd) => _vue.h.call(void 0, 
                 "g",
                 {
                   key: `points-${sd.seriesKey}`,
@@ -597,9 +631,9 @@ var AreaChart = vue.defineComponent({
                   "data-series-key": sd.seriesKey
                 },
                 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", {
+                  return _vue.h.call(void 0, "circle", {
                     key: `point-${sd.seriesKey}-${point.pointIndex}`,
                     cx: point.x,
                     cy: point.y,
@@ -607,7 +641,7 @@ var AreaChart = vue.defineComponent({
                     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: tigercatCore.linePointTransitionClasses,
+                    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,
@@ -625,18 +659,18 @@ var AreaChart = vue.defineComponent({
           ].filter(Boolean)
         }
       );
-      const tooltip = props.showTooltip ? vue.h(chunkZOUJFFG4_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(chunkACYYQJ6M_js.ChartLegend, {
+        _vue.h.call(void 0, _chunkACYYQJ6Mjs.ChartLegend, {
           items: legendItems.value,
           position: props.legendPosition,
           markerSize: props.legendMarkerSize,
@@ -653,5 +687,7 @@ var AreaChart = vue.defineComponent({
 });
 var AreaChart_default = AreaChart;
 
-exports.AreaChart = AreaChart;
-exports.AreaChart_default = AreaChart_default;
+
+
+
+exports.AreaChart = AreaChart; exports.AreaChart_default = AreaChart_default;

package/dist/chunk-5WG4OFXH.mjs

@@ -0,0 +1,133 @@
+// src/components/NumberKeyboard.ts
+import { computed, defineComponent, h, ref } from "vue";
+import {
+  applyNumberKeyboardInput,
+  classNames,
+  coerceClassValue,
+  deleteNumberKeyboardValue,
+  getNumberKeyboardAction,
+  getNumberKeyboardKeyClasses,
+  getNumberKeyboardKeys,
+  mergeStyleValues,
+  normalizeNumberKeyboardValue,
+  numberKeyboardGridClasses,
+  numberKeyboardRootClasses
+} from "@expcat/tigercat-core";
+var NumberKeyboard = defineComponent({
+  name: "TigerNumberKeyboard",
+  inheritAttrs: false,
+  props: {
+    modelValue: { type: String, default: void 0 },
+    defaultValue: { type: String, default: "" },
+    mode: { type: String, default: "number" },
+    maxLength: { type: Number, default: void 0 },
+    precision: { type: Number, default: void 0 },
+    decimalSeparator: { type: String, default: "." },
+    disabled: { type: Boolean, default: false },
+    readonly: { type: Boolean, default: false },
+    confirmText: { type: String, default: "Done" },
+    deleteText: { type: String, default: "Delete" },
+    ariaLabel: { type: String, default: "Number keyboard" },
+    showConfirm: { type: Boolean, default: true },
+    className: { type: String, default: void 0 },
+    style: {
+      type: Object,
+      default: void 0
+    }
+  },
+  emits: ["update:modelValue", "change", "key-press", "delete", "confirm"],
+  setup(props, { attrs, emit }) {
+    const innerValue = ref(normalizeNumberKeyboardValue(props.defaultValue));
+    const isControlled = computed(() => props.modelValue !== void 0);
+    const currentValue = computed(
+      () => isControlled.value ? normalizeNumberKeyboardValue(props.modelValue) : innerValue.value
+    );
+    const isDisabled = computed(() => props.disabled || props.readonly);
+    const keys = computed(
+      () => getNumberKeyboardKeys({
+        mode: props.mode,
+        decimalSeparator: props.decimalSeparator,
+        deleteText: props.deleteText,
+        confirmText: props.confirmText,
+        showConfirm: props.showConfirm
+      })
+    );
+    function emitChange(nextValue, payload) {
+      if (!isControlled.value) innerValue.value = nextValue;
+      emit("update:modelValue", nextValue);
+      emit("change", nextValue, payload);
+    }
+    function handleKeyClick(key) {
+      if (isDisabled.value || key.type === "empty") return;
+      const action = getNumberKeyboardAction(key);
+      const nextValue = action === "delete" ? deleteNumberKeyboardValue(currentValue.value) : action === "input" ? applyNumberKeyboardInput(currentValue.value, key.value, {
+        mode: props.mode,
+        maxLength: props.maxLength,
+        precision: props.precision,
+        decimalSeparator: props.decimalSeparator
+      }) : currentValue.value;
+      const payload = {
+        value: nextValue,
+        key: key.value,
+        action,
+        mode: props.mode
+      };
+      emit("key-press", key, payload);
+      if (action === "confirm") {
+        emit("confirm", currentValue.value, { ...payload, value: currentValue.value });
+        return;
+      }
+      if (action === "delete") emit("delete", nextValue, payload);
+      if (nextValue !== currentValue.value) emitChange(nextValue, payload);
+    }
+    const rootClasses = computed(
+      () => classNames(numberKeyboardRootClasses, props.className, coerceClassValue(attrs.class))
+    );
+    const rootStyle = computed(
+      () => mergeStyleValues(props.style, attrs.style)
+    );
+    return () => {
+      const forwardedAttrs = Object.fromEntries(
+        Object.entries(attrs).filter(([key]) => key !== "class" && key !== "style")
+      );
+      return h(
+        "div",
+        {
+          ...forwardedAttrs,
+          class: rootClasses.value,
+          style: rootStyle.value,
+          role: "group",
+          "aria-label": props.ariaLabel,
+          "aria-disabled": isDisabled.value || void 0
+        },
+        [
+          h(
+            "div",
+            { class: numberKeyboardGridClasses },
+            keys.value.map(
+              (key, index) => h(
+                "button",
+                {
+                  key: `${key.type}-${key.value}-${index}`,
+                  type: "button",
+                  class: getNumberKeyboardKeyClasses(key, isDisabled.value),
+                  disabled: isDisabled.value || key.disabled,
+                  "aria-label": key.ariaLabel,
+                  "data-key": key.value,
+                  onClick: () => handleKeyClick(key)
+                },
+                key.label
+              )
+            )
+          )
+        ]
+      );
+    };
+  }
+});
+var NumberKeyboard_default = NumberKeyboard;
+
+export {
+  NumberKeyboard,
+  NumberKeyboard_default
+};