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

package/dist/chunk-5VSKQLK3.js

@@ -1,693 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-var _chunk2VOZFFW6js = require('./chunk-2VOZFFW6.js');
-
-
-var _chunkACYYQJ6Mjs = require('./chunk-ACYYQJ6M.js');
-
-
-var _chunkHBFFINAIjs = require('./chunk-HBFFINAI.js');
-
-
-var _chunkZOUJFFG4js = require('./chunk-ZOUJFFG4.js');
-
-
-var _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: {
-      type: Number,
-      default: 320
-    },
-    height: {
-      type: Number,
-      default: 200
-    },
-    padding: {
-      type: [Number, Object],
-      default: 24
-    },
-    data: {
-      type: Array
-    },
-    series: {
-      type: Array
-    },
-    xScale: {
-      type: Object
-    },
-    yScale: {
-      type: Object
-    },
-    areaColor: {
-      type: String,
-      default: "var(--tiger-primary,#2563eb)"
-    },
-    strokeWidth: {
-      type: Number,
-      default: 2
-    },
-    fillOpacity: {
-      type: Number,
-      default: 0.2
-    },
-    curve: {
-      type: String,
-      default: "linear"
-    },
-    showPoints: {
-      type: Boolean,
-      default: false
-    },
-    pointSize: {
-      type: Number,
-      default: 4
-    },
-    pointColor: {
-      type: String
-    },
-    stacked: {
-      type: Boolean,
-      default: false
-    },
-    showGrid: {
-      type: Boolean,
-      default: true
-    },
-    showAxis: {
-      type: Boolean,
-      default: true
-    },
-    showXAxis: {
-      type: Boolean,
-      default: true
-    },
-    showYAxis: {
-      type: Boolean,
-      default: true
-    },
-    includeZero: {
-      type: Boolean,
-      default: true
-    },
-    xAxisLabel: {
-      type: String
-    },
-    yAxisLabel: {
-      type: String
-    },
-    xTicks: {
-      type: Number,
-      default: 5
-    },
-    yTicks: {
-      type: Number,
-      default: 5
-    },
-    xTickValues: {
-      type: Array
-    },
-    yTickValues: {
-      type: Array
-    },
-    xTickFormat: {
-      type: Function
-    },
-    yTickFormat: {
-      type: Function
-    },
-    gridLineStyle: {
-      type: String,
-      default: "solid"
-    },
-    gridStrokeWidth: {
-      type: Number,
-      default: 1
-    },
-    colors: {
-      type: Array
-    },
-    // Interaction props
-    hoverable: {
-      type: Boolean,
-      default: false
-    },
-    hoveredIndex: {
-      type: Number,
-      default: void 0
-    },
-    activeOpacity: {
-      type: Number,
-      default: 1
-    },
-    inactiveOpacity: {
-      type: Number,
-      default: 0.25
-    },
-    selectable: {
-      type: Boolean,
-      default: false
-    },
-    selectedIndex: {
-      type: Number,
-      default: void 0
-    },
-    // Legend props
-    showLegend: {
-      type: Boolean,
-      default: false
-    },
-    legendPosition: {
-      type: String,
-      default: "bottom"
-    },
-    legendMarkerSize: {
-      type: Number,
-      default: 10
-    },
-    legendGap: {
-      type: Number,
-      default: 8
-    },
-    // Tooltip props
-    showTooltip: {
-      type: Boolean,
-      default: true
-    },
-    gradient: {
-      type: Boolean,
-      default: true
-    },
-    animated: {
-      type: Boolean,
-      default: false
-    },
-    pointHollow: {
-      type: Boolean,
-      default: false
-    },
-    strokeGradient: {
-      type: Boolean,
-      default: false
-    },
-    pointGradient: {
-      type: Boolean,
-      default: false
-    },
-    tooltipFormatter: {
-      type: Function
-    },
-    legendFormatter: {
-      type: Function
-    },
-    // Accessibility
-    title: {
-      type: String
-    },
-    desc: {
-      type: String
-    },
-    className: {
-      type: String
-    }
-  },
-  emits: [
-    "update:hoveredIndex",
-    "update:selectedIndex",
-    "series-click",
-    "series-hover",
-    "point-click",
-    "point-hover"
-  ],
-  setup(props, { emit }) {
-    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,
-      resolvedSelectedIndex: _resolvedSelectedIndex,
-      activeIndex,
-      handleMouseEnter: handleSeriesHoverEnter,
-      handleMouseLeave: handleSeriesHoverLeave,
-      handleClick: handleSeriesSelect,
-      handleLegendClick: _handleLegendClick,
-      handleLegendHover: _handleLegendHover,
-      handleLegendLeave: _handleLegendLeave,
-      wrapperClasses
-    } = _chunk2VOZFFW6js.useChartInteraction.call(void 0, {
-      hoverable: _vue.computed.call(void 0, () => props.hoverable),
-      hoveredIndexProp: () => props.hoveredIndex,
-      selectable: _vue.computed.call(void 0, () => props.selectable),
-      selectedIndexProp: () => props.selectedIndex,
-      activeOpacity: _vue.computed.call(void 0, () => props.activeOpacity),
-      inactiveOpacity: _vue.computed.call(void 0, () => props.inactiveOpacity),
-      legendPosition: _vue.computed.call(void 0, () => props.legendPosition),
-      emit,
-      getData: (index) => resolvedSeries.value[index],
-      eventNames: {
-        hover: "series-hover",
-        click: "series-click"
-      }
-    });
-    const 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.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.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.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.call(void 0, categories, [0, innerRect.value.width], { padding: 0 });
-      }
-    });
-    const resolvedYScale = _vue.computed.call(void 0, () => {
-      if (props.yScale) return props.yScale;
-      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.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.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 = _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;
-        if (props.stacked && stackedData) {
-          const stackedSeries = stackedData[seriesIndex];
-          points = stackedSeries.map((sd, pointIndex) => ({
-            x: resolvedXScale.value.map(sd.original.x),
-            y: resolvedYScale.value.map(sd.y1),
-            datum: sd.original,
-            pointIndex
-          }));
-          const topPoints = points.map((p) => ({ x: p.x, y: p.y }));
-          const bottomPoints = stackedSeries.map((sd) => ({
-            x: resolvedXScale.value.map(sd.original.x),
-            y: resolvedYScale.value.map(sd.y0)
-          })).reverse();
-          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 {
-          points = series.data.map((datum, pointIndex) => ({
-            x: resolvedXScale.value.map(datum.x),
-            y: resolvedYScale.value.map(datum.y),
-            datum,
-            pointIndex
-          }));
-          areaPath = _tigercatcore.createAreaPath.call(void 0, points, baseline.value, props.curve);
-          linePath = _tigercatcore.createLinePath.call(void 0, points, props.curve);
-        }
-        const opacity = _tigercatcore.getChartElementOpacity.call(void 0, seriesIndex, activeIndex.value, {
-          activeOpacity: props.activeOpacity,
-          inactiveOpacity: props.inactiveOpacity
-        });
-        return {
-          series,
-          seriesIndex,
-          seriesKey,
-          color,
-          fillColor,
-          fillOpacity: seriesFillOpacity,
-          areaPath,
-          linePath,
-          points,
-          opacity,
-          strokeWidth: _nullishCoalesce(series.strokeWidth, () => ( props.strokeWidth)),
-          strokeDasharray: series.strokeDasharray,
-          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.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) : _nullishCoalesce(s.name, () => ( `Series ${i + 1}`)),
-        getColor: (s, i) => _nullishCoalesce(s.color, () => ( palette.value[i % palette.value.length]))
-      })
-    );
-    const tooltipContent = _vue.computed.call(void 0, 
-      () => _tigercatcore.resolveMultiSeriesTooltipContent.call(void 0, 
-        hoveredPointInfo.value,
-        resolvedSeries.value,
-        props.tooltipFormatter,
-        _tigercatcore.defaultSeriesXYTooltipFormatter
-      )
-    );
-    const handlePointMouseEnter = (seriesIndex, pointIndex, event) => {
-      hoveredPointInfo.value = { seriesIndex, pointIndex };
-      tooltipPosition.value = { x: event.clientX, y: event.clientY };
-      emit(
-        "point-hover",
-        seriesIndex,
-        pointIndex,
-        _optionalChain([resolvedSeries, 'access', _ => _.value, 'access', _2 => _2[seriesIndex], 'optionalAccess', _3 => _3.data, 'access', _4 => _4[pointIndex]])
-      );
-    };
-    const handlePointMouseMove = (event) => {
-      tooltipPosition.value = { x: event.clientX, y: event.clientY };
-    };
-    const handlePointMouseLeave = () => {
-      hoveredPointInfo.value = null;
-      emit("point-hover", null, null, null);
-    };
-    const handlePointClick = (seriesIndex, pointIndex) => {
-      emit(
-        "point-click",
-        seriesIndex,
-        pointIndex,
-        _optionalChain([resolvedSeries, 'access', _5 => _5.value, 'access', _6 => _6[seriesIndex], 'optionalAccess', _7 => _7.data, 'access', _8 => _8[pointIndex]])
-      );
-      handleSeriesSelect(seriesIndex);
-    };
-    const handleKeyDown = (event, seriesIndex) => {
-      if (!props.selectable) return;
-      if (event.key !== "Enter" && event.key !== " ") return;
-      event.preventDefault();
-      handleSeriesSelect(seriesIndex);
-    };
-    return () => {
-      const reversedSeriesData = [...seriesData.value].reverse();
-      const chart = _vue.h.call(void 0, 
-        _chunkUHVUKLHFjs.ChartCanvas,
-        {
-          width: props.width,
-          height: props.height,
-          padding: props.padding,
-          title: props.title,
-          desc: props.desc,
-          className: _tigercatcore.classNames.call(void 0, props.className)
-        },
-        {
-          default: () => [
-            // Gradient defs and animation styles
-            props.gradient || props.animated || props.strokeGradient || props.pointGradient ? _vue.h.call(void 0, "defs", null, [
-              // Animation keyframes
-              props.animated ? _vue.h.call(void 0, 
-                "style",
-                null,
-                `
-                          .tiger-area-animated {
-                            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.call(void 0, 
-                  "linearGradient",
-                  {
-                    key: `area-grad-${sd.seriesKey}`,
-                    id: `${gradientPrefix}-${sd.seriesKey}`,
-                    x1: "0",
-                    y1: "0",
-                    x2: "0",
-                    y2: "1"
-                  },
-                  [
-                    _vue.h.call(void 0, "stop", {
-                      offset: "0%",
-                      "stop-color": sd.fillColor,
-                      "stop-opacity": sd.fillOpacity
-                    }),
-                    _vue.h.call(void 0, "stop", {
-                      offset: "100%",
-                      "stop-color": sd.fillColor,
-                      "stop-opacity": 0.02
-                    })
-                  ]
-                )
-              ) : [],
-              // Point fill radial gradients (bright center → series color edge)
-              ...props.pointGradient ? reversedSeriesData.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 brightness ramp)
-              ...props.strokeGradient ? reversedSeriesData.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,
-            props.showGrid ? _vue.h.call(void 0, _chunk57MJTNDLjs.ChartGrid, {
-              xScale: resolvedXScale.value,
-              yScale: resolvedYScale.value,
-              show: "both",
-              xTicks: props.xTicks,
-              yTicks: props.yTicks,
-              xTickValues: props.xTickValues,
-              yTickValues: props.yTickValues,
-              lineStyle: props.gridLineStyle,
-              strokeWidth: props.gridStrokeWidth
-            }) : null,
-            shouldShowXAxis.value ? _vue.h.call(void 0, _chunk5PXTMXXSjs.ChartAxis, {
-              scale: resolvedXScale.value,
-              orientation: "bottom",
-              y: innerRect.value.height,
-              ticks: props.xTicks,
-              tickValues: props.xTickValues,
-              tickFormat: props.xTickFormat,
-              label: props.xAxisLabel
-            }) : null,
-            shouldShowYAxis.value ? _vue.h.call(void 0, _chunk5PXTMXXSjs.ChartAxis, {
-              scale: resolvedYScale.value,
-              orientation: "left",
-              ticks: props.yTicks,
-              tickValues: props.yTickValues,
-              tickFormat: props.yTickFormat,
-              label: props.yAxisLabel
-            }) : null,
-            // Layer 1: area fills + line strokes (reverse order for proper stacking visual)
-            ...reversedSeriesData.map(
-              (sd) => _vue.h.call(void 0, 
-                _chunkHBFFINAIjs.ChartSeries,
-                {
-                  key: sd.seriesKey,
-                  data: sd.series.data,
-                  name: sd.series.name,
-                  type: "area",
-                  opacity: sd.opacity,
-                  "data-series-key": sd.seriesKey,
-                  class: _tigercatcore.classNames.call(void 0, 
-                    sd.series.className,
-                    (props.hoverable || props.selectable) && "cursor-pointer",
-                    "outline-none"
-                  ),
-                  onMouseenter: (e) => handleSeriesHoverEnter(sd.seriesIndex, e),
-                  onMouseleave: handleSeriesHoverLeave,
-                  onClick: () => handleSeriesSelect(sd.seriesIndex),
-                  tabindex: props.selectable ? 0 : void 0,
-                  onKeydown: (e) => handleKeyDown(e, sd.seriesIndex)
-                },
-                {
-                  default: () => [
-                    // Area fill
-                    _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,
-                      stroke: "none",
-                      class: "transition-opacity duration-300",
-                      "data-area-series": sd.seriesIndex,
-                      "data-series-key": sd.seriesKey
-                    }),
-                    // Line stroke
-                    _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 ? _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.call(void 0, 
-                        "transition-opacity [transition-duration:var(--tiger-motion-duration-base,200ms)]",
-                        props.animated && "tiger-area-animated"
-                      )
-                    })
-                  ]
-                }
-              )
-            ),
-            // Layer 2: data points on top of all areas (prevents coverage)
-            ...seriesData.value.filter((sd) => sd.showPoints).map(
-              (sd) => _vue.h.call(void 0, 
-                "g",
-                {
-                  key: `points-${sd.seriesKey}`,
-                  opacity: sd.opacity,
-                  "data-series-key": sd.seriesKey
-                },
-                sd.points.map((point) => {
-                  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.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" : props.pointGradient ? `url(#${gradientPrefix}-point-${sd.seriesKey})` : sd.pointColor,
-                    stroke: sd.pointHollow ? sd.pointColor : "none",
-                    "stroke-width": sd.pointHollow ? 2 : 0,
-                    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,
-                    onClick: (e) => {
-                      e.stopPropagation();
-                      handlePointClick(sd.seriesIndex, point.pointIndex);
-                    }
-                  });
-                })
-              )
-            )
-          ].filter(Boolean)
-        }
-      );
-      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.call(void 0, "div", { class: "inline-block relative" }, [chart, tooltip]);
-      }
-      return _vue.h.call(void 0, "div", { class: wrapperClasses.value }, [
-        chart,
-        _vue.h.call(void 0, _chunkACYYQJ6Mjs.ChartLegend, {
-          items: legendItems.value,
-          position: props.legendPosition,
-          markerSize: props.legendMarkerSize,
-          gap: props.legendGap,
-          interactive: props.hoverable || props.selectable,
-          onItemClick: handleSeriesSelect,
-          onItemHover: handleSeriesHoverEnter,
-          onItemLeave: handleSeriesHoverLeave
-        }),
-        tooltip
-      ]);
-    };
-  }
-});
-var AreaChart_default = AreaChart;
-
-
-
-
-exports.AreaChart = AreaChart; exports.AreaChart_default = AreaChart_default;