@expcat/tigercat-vue 1.0.7 → 1.2.0

package/dist/{chunk-HFCVHAQ6.mjs → chunk-UAD2XROX.mjs}

@@ -1,13 +1,44 @@
-import { useChartInteraction } from './chunk-DU2NXX75.mjs';
-import { ChartLegend } from './chunk-F5HOHSFH.mjs';
-import { ChartSeries } from './chunk-2ZUEXCVJ.mjs';
-import { ChartTooltip } from './chunk-FXGIIFGN.mjs';
-import { ChartAxis } from './chunk-ZWVA7HT3.mjs';
-import { ChartCanvas } from './chunk-5WHLXWWT.mjs';
-import { ChartGrid } from './chunk-MI6TL3CQ.mjs';
-import { defineComponent, ref, onMounted, computed, h } from 'vue';
-import { getScatterGradientPrefix, getChartInnerRect, getNumberExtent, createLinearScale, resolveChartPalette, getChartElementOpacity, getScatterHoverSize, buildChartLegendItems, resolveChartTooltipContent, SCATTER_ENTRANCE_KEYFRAMES, classNames, getScatterHoverShadow, scatterPointTransitionClasses, SCATTER_ENTRANCE_CLASS, getScatterPointPath } from '@expcat/tigercat-core';
+import {
+  useChartInteraction
+} from "./chunk-R2HO74FE.mjs";
+import {
+  ChartLegend
+} from "./chunk-VVS2CQS4.mjs";
+import {
+  ChartSeries
+} from "./chunk-2ZUEXCVJ.mjs";
+import {
+  ChartTooltip
+} from "./chunk-OK4PVFQG.mjs";
+import {
+  ChartAxis
+} from "./chunk-ZWVA7HT3.mjs";
+import {
+  ChartCanvas
+} from "./chunk-W5RZPTFD.mjs";
+import {
+  ChartGrid
+} from "./chunk-MI6TL3CQ.mjs";
 
+// src/components/ScatterChart.ts
+import { defineComponent, computed, h, onMounted, ref, useId } from "vue";
+import {
+  classNames,
+  createLinearScale,
+  getChartElementOpacity,
+  getChartInnerRect,
+  getNumberExtent,
+  getStableChartGradientPrefix,
+  getScatterHoverShadow,
+  getScatterHoverSize,
+  getScatterPointPath,
+  scatterPointTransitionClasses,
+  SCATTER_ENTRANCE_KEYFRAMES,
+  SCATTER_ENTRANCE_CLASS,
+  resolveChartPalette,
+  buildChartLegendItems,
+  resolveChartTooltipContent
+} from "@expcat/tigercat-core";
 var ScatterChart = defineComponent({
   name: "TigerScatterChart",
   props: {
@@ -96,7 +127,7 @@ var ScatterChart = defineComponent({
   },
   emits: ["update:hoveredIndex", "update:selectedIndex", "point-click", "point-hover"],
   setup(props, { emit }) {
-    const gradientPrefix = getScatterGradientPrefix();
+    const gradientPrefix = getStableChartGradientPrefix("scatter", useId());
     const mounted = ref(false);
     onMounted(() => {
       if (props.animated) mounted.value = true;
@@ -255,7 +286,7 @@ var ScatterChart = defineComponent({
                   const animDelay = props.animated && mounted.value ? `${index * 60}ms` : void 0;
                   const styleStr = [
                     filterStyle ? `filter:${filterStyle}` : "",
-                    animDelay ? `animation:${SCATTER_ENTRANCE_CLASS} 500ms cubic-bezier(.34,1.56,.64,1) ${animDelay} both` : ""
+                    animDelay ? `animation:${SCATTER_ENTRANCE_CLASS} var(--tiger-motion-duration-slow,500ms) var(--tiger-motion-ease-spring,cubic-bezier(.34,1.56,.64,1)) ${animDelay} both` : ""
                   ].filter(Boolean).join(";");
                   const shared = {
                     fill,
@@ -264,6 +295,7 @@ var ScatterChart = defineComponent({
                     "stroke-width": props.pointBorderWidth,
                     class: classNames(
                       scatterPointTransitionClasses,
+                      animDelay && SCATTER_ENTRANCE_CLASS,
                       interactive && "cursor-pointer"
                     ),
                     style: styleStr || void 0,
@@ -326,4 +358,7 @@ var ScatterChart = defineComponent({
 });
 var ScatterChart_default = ScatterChart;
 
-export { ScatterChart, ScatterChart_default };
+export {
+  ScatterChart,
+  ScatterChart_default
+};

package/dist/{chunk-URYEEQD7.mjs → chunk-UANF7XE5.mjs}

@@ -1,7 +1,25 @@
-import { h, defineComponent, ref, shallowRef, onMounted, onBeforeUnmount, computed } from 'vue';
-import { backTopIconPath, classNames, backTopButtonClasses, backTopContainerClasses, backTopVisibleClasses, backTopHiddenClasses, coerceClassValue, mergeStyleValues, getScrollTop, scrollToTop } from '@expcat/tigercat-core';
-
 // src/components/BackTop.ts
+import {
+  defineComponent,
+  h,
+  ref,
+  shallowRef,
+  computed,
+  onMounted,
+  onBeforeUnmount
+} from "vue";
+import {
+  classNames,
+  coerceClassValue,
+  createBackTopVisibilityController,
+  mergeStyleValues,
+  scrollToTop,
+  backTopButtonClasses,
+  backTopContainerClasses,
+  backTopHiddenClasses,
+  backTopVisibleClasses,
+  backTopIconPath
+} from "@expcat/tigercat-core";
 var DefaultIcon = h(
   "svg",
   {
@@ -36,7 +54,7 @@ var BackTop = defineComponent({
       default: () => window
     },
     /**
-     * Duration of scroll animation in milliseconds
+     * Use immediate scroll when set to 0; positive values use native smooth scrolling
      * @default 450
      */
     duration: {
@@ -56,11 +74,7 @@ var BackTop = defineComponent({
   setup(props, { slots, emit, attrs }) {
     const visible = ref(false);
     const targetElement = shallowRef(null);
-    const handleScroll = () => {
-      if (!targetElement.value) return;
-      const scrollTop = getScrollTop(targetElement.value);
-      visible.value = scrollTop >= props.visibilityHeight;
-    };
+    let visibilityController;
     const handleClick = (event) => {
       if (!targetElement.value) return;
       scrollToTop(targetElement.value, props.duration);
@@ -68,13 +82,23 @@ var BackTop = defineComponent({
     };
     onMounted(() => {
       targetElement.value = props.target() ?? window;
-      targetElement.value.addEventListener("scroll", handleScroll, { passive: true });
-      handleScroll();
+      visibilityController = createBackTopVisibilityController({
+        target: targetElement.value,
+        getVisibilityHeight: () => props.visibilityHeight,
+        onChange: (nextVisible) => {
+          visible.value = nextVisible;
+        }
+      });
+      targetElement.value.addEventListener("scroll", visibilityController.schedule, {
+        passive: true
+      });
+      visibilityController.update();
     });
     onBeforeUnmount(() => {
-      if (targetElement.value) {
-        targetElement.value.removeEventListener("scroll", handleScroll);
+      if (targetElement.value && visibilityController) {
+        targetElement.value.removeEventListener("scroll", visibilityController.schedule);
       }
+      visibilityController?.cancel();
     });
     const buttonClasses = computed(() => {
       const target = targetElement.value ?? props.target();
@@ -107,4 +131,7 @@ var BackTop = defineComponent({
 });
 var BackTop_default = BackTop;
 
-export { BackTop, BackTop_default };
+export {
+  BackTop,
+  BackTop_default
+};

package/dist/chunk-UHVUKLHF.js

@@ -0,0 +1,112 @@
+"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; }// src/components/ChartCanvas.ts
+var _vue = require('vue');
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var ChartCanvas = _vue.defineComponent.call(void 0, {
+  name: "TigerChartCanvas",
+  inheritAttrs: false,
+  props: {
+    width: {
+      type: Number,
+      default: 320
+    },
+    height: {
+      type: Number,
+      default: 200
+    },
+    responsive: {
+      type: Boolean,
+      default: false
+    },
+    padding: {
+      type: [Number, Object],
+      default: 24
+    },
+    className: {
+      type: String
+    },
+    title: {
+      type: String
+    },
+    desc: {
+      type: String
+    }
+  },
+  setup(props, { slots, attrs }) {
+    const svgRef = _vue.ref.call(void 0, null);
+    const observedSize = _vue.ref.call(void 0, null);
+    const resizeController = _tigercatcore.createChartResizeObserverController.call(void 0, {
+      onSizeChange: (size) => {
+        observedSize.value = size;
+      }
+    });
+    const resolvedSize = _vue.computed.call(void 0, 
+      () => _tigercatcore.resolveResponsiveChartSize.call(void 0, 
+        { width: props.width, height: props.height },
+        props.responsive ? observedSize.value : null
+      )
+    );
+    const innerRect = _vue.computed.call(void 0, 
+      () => _tigercatcore.getChartInnerRect.call(void 0, resolvedSize.value.width, resolvedSize.value.height, props.padding)
+    );
+    const svgClasses = _vue.computed.call(void 0, 
+      () => _tigercatcore.classNames.call(void 0, _tigercatcore.chartCanvasBaseClasses, _tigercatcore.coerceClassValue.call(void 0, attrs.class), props.className)
+    );
+    const svgStyle = _vue.computed.call(void 0, () => ({
+      ...attrs.style
+    }));
+    const syncResponsiveObserver = () => {
+      if (!props.responsive) {
+        resizeController.disconnect();
+        observedSize.value = null;
+        return;
+      }
+      const target = _optionalChain([svgRef, 'access', _ => _.value, 'optionalAccess', _2 => _2.parentElement]);
+      if (target) {
+        resizeController.observe(target);
+      }
+    };
+    _vue.onMounted.call(void 0, syncResponsiveObserver);
+    _vue.watch.call(void 0, () => props.responsive, syncResponsiveObserver);
+    _vue.onBeforeUnmount.call(void 0, () => resizeController.disconnect());
+    return () => {
+      const rect = innerRect.value;
+      const size = resolvedSize.value;
+      return _vue.h.call(void 0, 
+        "svg",
+        {
+          ...attrs,
+          ref: svgRef,
+          width: size.width,
+          height: size.height,
+          viewBox: `0 0 ${size.width} ${size.height}`,
+          class: svgClasses.value,
+          style: svgStyle.value
+        },
+        [
+          props.title ? _vue.h.call(void 0, "title", props.title) : null,
+          props.desc ? _vue.h.call(void 0, "desc", props.desc) : null,
+          _vue.h.call(void 0, 
+            "g",
+            {
+              transform: `translate(${rect.x}, ${rect.y})`
+            },
+            _optionalChain([slots, 'access', _3 => _3.default, 'optionalCall', _4 => _4({ innerRect: rect })])
+          )
+        ].filter(Boolean)
+      );
+    };
+  }
+});
+var ChartCanvas_default = ChartCanvas;
+
+
+
+
+exports.ChartCanvas = ChartCanvas; exports.ChartCanvas_default = ChartCanvas_default;

package/dist/chunk-UI7N2ZDU.js

@@ -0,0 +1,142 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/components/Countdown.ts
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var Countdown = _vue.defineComponent.call(void 0, {
+  name: "TigerCountdown",
+  inheritAttrs: false,
+  props: {
+    value: {
+      type: [String, Number, Date],
+      default: void 0
+    },
+    now: {
+      type: [String, Number, Date],
+      default: void 0
+    },
+    format: {
+      type: String,
+      default: _tigercatcore.COUNTDOWN_DEFAULT_FORMAT
+    },
+    interval: {
+      type: Number,
+      default: _tigercatcore.COUNTDOWN_DEFAULT_INTERVAL_MS
+    },
+    title: {
+      type: String,
+      default: void 0
+    },
+    prefix: {
+      type: String,
+      default: void 0
+    },
+    suffix: {
+      type: String,
+      default: void 0
+    },
+    size: {
+      type: String,
+      default: "md"
+    },
+    ariaLabel: {
+      type: String,
+      default: void 0
+    },
+    className: {
+      type: String,
+      default: void 0
+    }
+  },
+  emits: ["change", "finish"],
+  setup(props, { attrs, emit }) {
+    const remaining = _vue.ref.call(void 0, _tigercatcore.getCountdownRemaining.call(void 0, props.value, props.now));
+    const formatted = _vue.computed.call(void 0, () => _tigercatcore.formatCountdown.call(void 0, remaining.value, props.format));
+    let finished = remaining.value <= 0;
+    let mounted = false;
+    let timerId = null;
+    const stopTimer = () => {
+      if (timerId !== null) clearInterval(timerId);
+      timerId = null;
+    };
+    const tick = () => {
+      const nextRemaining = _tigercatcore.getCountdownRemaining.call(void 0, props.value);
+      const payload = _tigercatcore.createCountdownPayload.call(void 0, nextRemaining, props.format);
+      remaining.value = nextRemaining;
+      emit("change", payload);
+      if (nextRemaining <= 0 && !finished) {
+        finished = true;
+        emit("finish", payload);
+        stopTimer();
+      }
+    };
+    const setupTimer = () => {
+      stopTimer();
+      if (!mounted || props.interval <= 0 || props.value === void 0) return;
+      timerId = setInterval(tick, props.interval);
+    };
+    _vue.watch.call(void 0, 
+      () => [props.value, props.now],
+      () => {
+        remaining.value = _tigercatcore.getCountdownRemaining.call(void 0, props.value, props.now);
+        finished = remaining.value <= 0;
+        setupTimer();
+      },
+      { immediate: true }
+    );
+    _vue.watch.call(void 0, 
+      () => [props.interval, props.format],
+      () => setupTimer()
+    );
+    _vue.onMounted.call(void 0, () => {
+      mounted = true;
+      setupTimer();
+    });
+    _vue.onBeforeUnmount.call(void 0, () => {
+      mounted = false;
+      stopTimer();
+    });
+    return () => _vue.h.call(void 0, 
+      "div",
+      {
+        ...attrs,
+        class: _tigercatcore.classNames.call(void 0, _tigercatcore.countdownBaseClasses, props.className, _tigercatcore.coerceClassValue.call(void 0, attrs.class))
+      },
+      [
+        props.title ? _vue.h.call(void 0, "div", { class: _tigercatcore.getCountdownTitleClasses.call(void 0, props.size) }, props.title) : null,
+        _vue.h.call(void 0, "div", { class: _tigercatcore.countdownValueWrapperClasses }, [
+          props.prefix ? _vue.h.call(void 0, "span", { class: _tigercatcore.countdownPrefixClasses }, props.prefix) : null,
+          _vue.h.call(void 0, 
+            "span",
+            {
+              class: _tigercatcore.getCountdownValueClasses.call(void 0, props.size),
+              role: "timer",
+              "aria-live": "polite",
+              "aria-label": props.ariaLabel
+            },
+            formatted.value
+          ),
+          props.suffix ? _vue.h.call(void 0, "span", { class: _tigercatcore.countdownSuffixClasses }, props.suffix) : null
+        ])
+      ]
+    );
+  }
+});
+var Countdown_default = Countdown;
+
+
+
+
+exports.Countdown = Countdown; exports.Countdown_default = Countdown_default;

package/dist/chunk-ULUH6UNV.js

@@ -0,0 +1,238 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk2VOZFFW6js = require('./chunk-2VOZFFW6.js');
+
+
+var _chunkACYYQJ6Mjs = require('./chunk-ACYYQJ6M.js');
+
+
+var _chunkHBFFINAIjs = require('./chunk-HBFFINAI.js');
+
+
+var _chunkZOUJFFG4js = require('./chunk-ZOUJFFG4.js');
+
+
+var _chunkUHVUKLHFjs = require('./chunk-UHVUKLHF.js');
+
+// src/components/SunburstChart.ts
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var SunburstChart = _vue.defineComponent.call(void 0, {
+  name: "TigerSunburstChart",
+  props: {
+    width: { type: Number, default: 320 },
+    height: { type: Number, default: 320 },
+    padding: { type: [Number, Object], default: 24 },
+    data: { type: Array, required: true },
+    innerRadiusRatio: { type: Number, default: 0 },
+    showLabels: { type: Boolean, default: true },
+    colors: { type: Array },
+    gradient: { type: Boolean, default: false },
+    // Interaction
+    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
+    showLegend: { type: Boolean, default: false },
+    legendPosition: { type: String, default: "bottom" },
+    legendMarkerSize: { type: Number, default: 10 },
+    legendGap: { type: Number, default: 8 },
+    // Tooltip
+    showTooltip: { type: Boolean, default: true },
+    tooltipFormatter: {
+      type: Function
+    },
+    // a11y
+    title: { type: String },
+    desc: { type: String },
+    className: { type: String }
+  },
+  emits: ["update:hoveredIndex", "update:selectedIndex", "arc-click", "arc-hover"],
+  setup(props, { emit }) {
+    const {
+      tooltipPosition,
+      resolvedHoveredIndex,
+      activeIndex,
+      handleMouseEnter,
+      handleMouseMove,
+      handleMouseLeave,
+      handleClick,
+      handleLegendClick,
+      handleLegendHover,
+      handleLegendLeave,
+      wrapperClasses
+    } = _chunk2VOZFFW6js.useChartInteraction.call(void 0, {
+      hoverable: _vue.computed.call(void 0, () => props.hoverable),
+      hoveredIndexProp: () => props.hoveredIndex,
+      selectable: _vue.computed.call(void 0, () => props.selectable),
+      selectedIndexProp: () => props.selectedIndex,
+      activeOpacity: _vue.computed.call(void 0, () => props.activeOpacity),
+      inactiveOpacity: _vue.computed.call(void 0, () => props.inactiveOpacity),
+      legendPosition: _vue.computed.call(void 0, () => props.legendPosition),
+      emit,
+      getData: (index) => {
+        const arc = arcs.value[index];
+        return arc ? { label: arc.label, value: arc.value } : {};
+      },
+      eventNames: { hover: "arc-hover", click: "arc-click" }
+    });
+    const innerRect = _vue.computed.call(void 0, () => _tigercatcore.getChartInnerRect.call(void 0, props.width, props.height, props.padding));
+    const palette = _vue.computed.call(void 0, () => _tigercatcore.resolveChartPalette.call(void 0, props.colors));
+    const gradientPrefix = _tigercatcore.getStableChartGradientPrefix.call(void 0, "sunburst", _vue.useId.call(void 0, ));
+    const outerRadius = _vue.computed.call(void 0, () => Math.min(innerRect.value.width, innerRect.value.height) / 2);
+    const innerRadius = _vue.computed.call(void 0, 
+      () => outerRadius.value * Math.max(0, Math.min(1, props.innerRadiusRatio))
+    );
+    const cx = _vue.computed.call(void 0, () => innerRect.value.width / 2);
+    const cy = _vue.computed.call(void 0, () => innerRect.value.height / 2);
+    const arcs = _vue.computed.call(void 0, 
+      () => _tigercatcore.computeSunburstArcs.call(void 0, props.data, {
+        cx: cx.value,
+        cy: cy.value,
+        innerRadius: innerRadius.value,
+        outerRadius: outerRadius.value,
+        colors: palette.value
+      })
+    );
+    const rootArcs = _vue.computed.call(void 0, () => arcs.value.filter((a) => a.depth === 0));
+    const legendItems = _vue.computed.call(void 0, 
+      () => _tigercatcore.buildChartLegendItems.call(void 0, {
+        data: rootArcs.value,
+        palette: palette.value,
+        activeIndex: activeIndex.value,
+        getLabel: (d) => d.label,
+        getColor: (d) => d.color
+      })
+    );
+    const tooltipContent = _vue.computed.call(void 0, 
+      () => _tigercatcore.resolveChartTooltipContent.call(void 0, 
+        resolvedHoveredIndex.value,
+        arcs.value,
+        void 0,
+        (arc) => `${arc.label}: ${arc.value}`
+      )
+    );
+    return () => {
+      const interactive = props.hoverable || props.selectable;
+      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: () => {
+            const gradientDefs = props.gradient ? _vue.h.call(void 0, 
+              "defs",
+              null,
+              arcs.value.map(
+                (arc) => _vue.h.call(void 0, 
+                  "linearGradient",
+                  {
+                    id: `${gradientPrefix}-${arc.index}`,
+                    x1: "0",
+                    y1: "0",
+                    x2: "0",
+                    y2: "1"
+                  },
+                  [
+                    _vue.h.call(void 0, "stop", {
+                      offset: "0%",
+                      "stop-color": arc.color,
+                      "stop-opacity": "1"
+                    }),
+                    _vue.h.call(void 0, "stop", {
+                      offset: "100%",
+                      "stop-color": arc.color,
+                      "stop-opacity": "0.7"
+                    })
+                  ]
+                )
+              )
+            ) : null;
+            return _vue.h.call(void 0, 
+              _chunkHBFFINAIjs.ChartSeries,
+              { data: arcs.value, type: "sunburst" },
+              {
+                default: () => [
+                  gradientDefs,
+                  ...arcs.value.map((arc) => {
+                    const opacity = _tigercatcore.getChartElementOpacity.call(void 0, arc.index, activeIndex.value, {
+                      activeOpacity: props.activeOpacity,
+                      inactiveOpacity: props.inactiveOpacity
+                    });
+                    return _vue.h.call(void 0, "path", {
+                      key: `arc-${arc.index}`,
+                      d: arc.path,
+                      fill: props.gradient ? `url(#${gradientPrefix}-${arc.index})` : arc.color,
+                      opacity,
+                      stroke: "var(--tiger-surface,#ffffff)",
+                      "stroke-width": 1,
+                      class: _tigercatcore.classNames.call(void 0, interactive && "cursor-pointer"),
+                      style: {
+                        transition: "opacity var(--tiger-motion-duration-base,0.2s) var(--tiger-motion-ease-decelerate,ease-out), filter var(--tiger-motion-duration-base,0.2s) var(--tiger-motion-ease-decelerate,ease-out)",
+                        filter: activeIndex.value === arc.index ? "var(--tiger-chart-block-active-filter, none)" : "none"
+                      },
+                      tabindex: props.selectable ? 0 : void 0,
+                      role: props.selectable ? "button" : "img",
+                      "aria-label": arc.label,
+                      onMouseenter: (e) => handleMouseEnter(arc.index, e),
+                      onMousemove: handleMouseMove,
+                      onMouseleave: handleMouseLeave,
+                      onClick: () => handleClick(arc.index)
+                    });
+                  })
+                ]
+              }
+            );
+          }
+        }
+      );
+      const tooltip = props.showTooltip && props.hoverable ? _vue.h.call(void 0, _chunkZOUJFFG4js.ChartTooltip, {
+        content: tooltipContent.value,
+        visible: resolvedHoveredIndex.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,
+          onItemClick: handleLegendClick,
+          onItemHover: handleLegendHover,
+          onItemLeave: handleLegendLeave
+        }),
+        tooltip
+      ]);
+    };
+  }
+});
+var SunburstChart_default = SunburstChart;
+
+
+
+
+exports.SunburstChart = SunburstChart; exports.SunburstChart_default = SunburstChart_default;