@expcat/tigercat-vue 0.4.2 → 1.0.0

package/dist/chunk-UQK22ZMC.mjs

@@ -0,0 +1,151 @@
+import { defineComponent, ref, computed, watch, onBeforeUnmount, h } from 'vue';
+import { hexToRgb, rgbToHsv, classNames, colorPickerBaseClasses, coerceClassValue, getColorPickerTriggerClasses, colorPickerPanelClasses, colorPickerInputClasses, colorPickerPresetClasses, hsvToRgb, rgbToHex, isValidHex } from '@expcat/tigercat-core';
+
+// src/components/ColorPicker.ts
+var ColorPicker = defineComponent({
+  name: "TigerColorPicker",
+  props: {
+    modelValue: { type: String, default: "#2563eb" },
+    disabled: { type: Boolean, default: false },
+    size: { type: String, default: "md" },
+    showAlpha: { type: Boolean, default: false },
+    format: { type: String, default: "hex" },
+    presets: { type: Array, default: void 0 }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(props, { emit, attrs }) {
+    const isOpen = ref(false);
+    const containerRef = ref(null);
+    const inputValue = ref(props.modelValue);
+    const hsv = computed(() => {
+      const rgb = hexToRgb(props.modelValue);
+      return rgbToHsv(rgb.r, rgb.g, rgb.b);
+    });
+    watch(
+      () => props.modelValue,
+      (v) => {
+        inputValue.value = v;
+      }
+    );
+    function togglePanel() {
+      if (props.disabled) return;
+      isOpen.value = !isOpen.value;
+    }
+    function closePanel() {
+      isOpen.value = false;
+    }
+    function handleHueChange(e) {
+      const hue = Number(e.target.value);
+      const { r, g, b } = hsvToRgb(hue, hsv.value.s, hsv.value.v);
+      const hex = rgbToHex(r, g, b);
+      emit("update:modelValue", hex);
+      emit("change", hex);
+    }
+    function handleInputChange(e) {
+      const val = e.target.value;
+      inputValue.value = val;
+      if (isValidHex(val)) {
+        const hex = val.startsWith("#") ? val : `#${val}`;
+        emit("update:modelValue", hex);
+        emit("change", hex);
+      }
+    }
+    function handlePresetClick(color) {
+      emit("update:modelValue", color);
+      emit("change", color);
+    }
+    function handleClickOutside(e) {
+      if (containerRef.value && !containerRef.value.contains(e.target)) {
+        closePanel();
+      }
+    }
+    watch(isOpen, (val) => {
+      if (val) document.addEventListener("click", handleClickOutside);
+      else document.removeEventListener("click", handleClickOutside);
+    });
+    onBeforeUnmount(() => {
+      document.removeEventListener("click", handleClickOutside);
+    });
+    return () => h(
+      "div",
+      {
+        ref: containerRef,
+        class: classNames(colorPickerBaseClasses, coerceClassValue(attrs.class))
+      },
+      [
+        // Color trigger swatch
+        h("div", {
+          class: getColorPickerTriggerClasses(props.size, props.disabled),
+          style: { backgroundColor: props.modelValue },
+          role: "button",
+          "aria-label": "Pick color",
+          tabindex: 0,
+          onClick: togglePanel
+        }),
+        // Panel
+        isOpen.value ? h("div", { class: colorPickerPanelClasses }, [
+          // Hue slider
+          h("div", { class: "mb-2" }, [
+            h(
+              "label",
+              { class: "block text-xs text-[var(--tiger-text-muted,#6b7280)] mb-1" },
+              "Hue"
+            ),
+            h("input", {
+              type: "range",
+              min: 0,
+              max: 360,
+              value: hsv.value.h,
+              class: "w-full h-2 rounded-full cursor-pointer accent-[var(--tiger-primary,#2563eb)]",
+              "aria-label": "Hue",
+              onInput: handleHueChange
+            })
+          ]),
+          // Hex input
+          h("div", { class: "mb-2" }, [
+            h(
+              "label",
+              { class: "block text-xs text-[var(--tiger-text-muted,#6b7280)] mb-1" },
+              "Hex"
+            ),
+            h("input", {
+              type: "text",
+              class: colorPickerInputClasses,
+              value: inputValue.value,
+              "aria-label": "Color value",
+              onInput: handleInputChange
+            })
+          ]),
+          // Preview
+          h("div", { class: "flex items-center gap-2 mb-2" }, [
+            h("div", {
+              class: "w-8 h-8 rounded border border-[var(--tiger-border,#d1d5db)]",
+              style: { backgroundColor: props.modelValue },
+              "aria-label": "Color preview"
+            }),
+            h(
+              "span",
+              { class: "text-xs font-mono text-[var(--tiger-text,#111827)]" },
+              props.modelValue
+            )
+          ]),
+          // Presets
+          props.presets && props.presets.length > 0 ? h("div", { class: "flex flex-wrap gap-1" }, [
+            ...props.presets.map(
+              (color) => h("div", {
+                key: color,
+                class: colorPickerPresetClasses,
+                style: { backgroundColor: color },
+                "aria-label": `Select ${color}`,
+                onClick: () => handlePresetClick(color)
+              })
+            )
+          ]) : null
+        ]) : null
+      ]
+    );
+  }
+});
+var ColorPicker_default = ColorPicker;
+
+export { ColorPicker, ColorPicker_default };

package/dist/{chunk-NV6GZPJP.mjs → chunk-UWL2XUAH.mjs}

@@ -1,27 +1,9 @@
+import { createFilledIcon } from './chunk-2TNZ4JNT.mjs';
 import { defineComponent, ref, computed, watch, nextTick, onMounted, onBeforeUnmount, h } from 'vue';
-import { parseTime, getTimePickerLabels, getTimePeriodLabels, classNames, timePickerBaseClasses, coerceClassValue, mergeStyleValues, formatTimeDisplayWithLocale, generateHours, generateMinutes, generateSeconds, getTimePickerInputClasses, getTimePickerIconButtonClasses, timePickerInputWrapperClasses, timePickerClearButtonClasses, timePickerPanelClasses, timePickerRangeHeaderClasses, getTimePickerRangeTabButtonClasses, timePickerPanelContentClasses, timePickerColumnClasses, timePickerColumnHeaderClasses, timePickerColumnListClasses, to24HourFormat, getTimePickerOptionAriaLabel, getTimePickerItemClasses, getTimePickerPeriodButtonClasses, timePickerFooterClasses, timePickerFooterButtonClasses, icon20ViewBox, to12HourFormat, TimePickerCloseIconPath, ClockIconPath, isTimeInRange, getCurrentTime, formatTime } from '@expcat/tigercat-core';
+import { ClockIconPath, TimePickerCloseIconPath, parseTime, getTimePickerLabels, getTimePeriodLabels, classNames, timePickerBaseClasses, coerceClassValue, mergeStyleValues, formatTimeDisplayWithLocale, generateHours, generateMinutes, generateSeconds, getTimePickerInputClasses, getTimePickerIconButtonClasses, timePickerInputWrapperClasses, timePickerClearButtonClasses, timePickerPanelClasses, timePickerRangeHeaderClasses, getTimePickerRangeTabButtonClasses, timePickerPanelContentClasses, timePickerColumnClasses, timePickerColumnHeaderClasses, timePickerColumnListClasses, to24HourFormat, getTimePickerOptionAriaLabel, getTimePickerItemClasses, getTimePickerPeriodButtonClasses, timePickerFooterClasses, timePickerFooterButtonClasses, to12HourFormat, isTimeInRange, getCurrentTime, formatTime } from '@expcat/tigercat-core';
 
-// src/components/TimePicker.ts
-var createIcon = (path, className) => {
-  return h(
-    "svg",
-    {
-      class: className,
-      xmlns: "http://www.w3.org/2000/svg",
-      viewBox: icon20ViewBox,
-      fill: "currentColor"
-    },
-    [
-      h("path", {
-        "fill-rule": "evenodd",
-        d: path,
-        "clip-rule": "evenodd"
-      })
-    ]
-  );
-};
-var ClockIcon = createIcon(ClockIconPath, "w-5 h-5");
-var CloseIcon = createIcon(TimePickerCloseIconPath, "w-4 h-4");
+var ClockIcon = createFilledIcon(ClockIconPath, "w-5 h-5");
+var CloseIcon = createFilledIcon(TimePickerCloseIconPath, "w-4 h-4");
 var TimePicker = defineComponent({
   name: "TigerTimePicker",
   inheritAttrs: false,

package/dist/{chunk-LUN3PRLX.js → chunk-V4PBWEAU.js}

@@ -17,15 +17,39 @@ var ConfigProvider = vue.defineComponent({
     locale: {
       type: Object,
       default: void 0
+    },
+    theme: {
+      type: String,
+      default: void 0
+    },
+    colorScheme: {
+      type: String,
+      default: void 0
     }
   },
   setup(props, { slots }) {
     const parent = useTigerConfig();
     const merged = vue.computed(() => {
       return {
-        locale: tigercatCore.mergeTigerLocale(parent.value.locale, props.locale)
+        locale: tigercatCore.mergeTigerLocale(parent.value.locale, props.locale),
+        theme: props.theme ?? parent.value.theme,
+        colorScheme: props.colorScheme ?? parent.value.colorScheme
       };
     });
+    vue.watch(
+      () => merged.value.theme,
+      (name) => {
+        if (name) tigercatCore.ThemeManager.setTheme(name);
+      },
+      { immediate: true }
+    );
+    vue.watch(
+      () => merged.value.colorScheme,
+      (scheme) => {
+        if (scheme) tigercatCore.ThemeManager.setColorScheme(scheme);
+      },
+      { immediate: true }
+    );
     vue.provide(TigerConfigKey, merged);
     return () => slots.default?.();
   }

package/dist/chunk-VDNAGLQJ.js

@@ -0,0 +1,176 @@
+'use strict';
+
+var vue = require('vue');
+var tigercatCore = require('@expcat/tigercat-core');
+
+// src/components/FileManager.ts
+var FileManager = vue.defineComponent({
+  name: "TigerFileManager",
+  inheritAttrs: false,
+  props: {
+    files: { type: Array, default: () => [] },
+    viewMode: {
+      type: String,
+      default: "list"
+    },
+    selectedKeys: {
+      type: Array,
+      default: () => []
+    },
+    multiple: { type: Boolean, default: false },
+    sortField: {
+      type: String,
+      default: "name"
+    },
+    sortOrder: {
+      type: String,
+      default: "asc"
+    },
+    currentPath: {
+      type: Array,
+      default: () => []
+    },
+    showHidden: { type: Boolean, default: false },
+    draggable: { type: Boolean, default: false },
+    loading: { type: Boolean, default: false },
+    emptyText: { type: String, default: "Empty folder" },
+    searchable: { type: Boolean, default: false },
+    searchText: { type: String, default: "" },
+    className: { type: String, default: void 0 }
+  },
+  emits: [
+    "select",
+    "open",
+    "navigate",
+    "update:currentPath",
+    "update:searchText",
+    "update:selectedKeys"
+  ],
+  setup(props, { emit, attrs }) {
+    const localSearch = vue.ref(props.searchText);
+    const currentItems = vue.computed(() => tigercatCore.navigateToFolder(props.files, props.currentPath));
+    const processedItems = vue.computed(() => {
+      let items = tigercatCore.filterHiddenFiles(currentItems.value, props.showHidden);
+      if (localSearch.value || props.searchText) {
+        items = tigercatCore.filterFileItems(items, localSearch.value || props.searchText);
+      }
+      return tigercatCore.sortFileItems(items, props.sortField, props.sortOrder);
+    });
+    const selectedSet = vue.computed(() => new Set(props.selectedKeys));
+    const containerClasses = vue.computed(
+      () => tigercatCore.classNames(tigercatCore.getFileManagerContainerClasses(props.className), tigercatCore.coerceClassValue(attrs.class))
+    );
+    function handleSelect(item) {
+      if (item.disabled) return;
+      emit("select", item);
+      const keys = [...props.selectedKeys];
+      const idx = keys.indexOf(item.key);
+      if (idx >= 0) {
+        keys.splice(idx, 1);
+      } else {
+        if (!props.multiple) keys.length = 0;
+        keys.push(item.key);
+      }
+      emit("update:selectedKeys", keys);
+    }
+    function handleOpen(item) {
+      if (item.disabled) return;
+      if (item.type === "folder") {
+        const newPath = [...props.currentPath, item.name];
+        emit("update:currentPath", newPath);
+        emit("navigate", newPath);
+      } else {
+        emit("open", item);
+      }
+    }
+    function navigateToBreadcrumb(index) {
+      const newPath = props.currentPath.slice(0, index);
+      emit("update:currentPath", newPath);
+      emit("navigate", newPath);
+    }
+    return () => {
+      const breadcrumbItems = [
+        vue.h(
+          "span",
+          {
+            class: tigercatCore.fileManagerBreadcrumbItemClasses,
+            onClick: () => navigateToBreadcrumb(0)
+          },
+          "Root"
+        ),
+        ...props.currentPath.flatMap((seg, i) => [
+          vue.h("span", { class: tigercatCore.fileManagerBreadcrumbSeparatorClasses }, "/"),
+          vue.h(
+            "span",
+            {
+              class: tigercatCore.fileManagerBreadcrumbItemClasses,
+              onClick: () => navigateToBreadcrumb(i + 1)
+            },
+            seg
+          )
+        ])
+      ];
+      const breadcrumb = vue.h(
+        "nav",
+        { class: tigercatCore.fileManagerBreadcrumbClasses, "aria-label": "File path" },
+        breadcrumbItems
+      );
+      const searchInput = props.searchable ? vue.h("input", {
+        type: "text",
+        class: tigercatCore.fileManagerSearchClasses,
+        placeholder: "Search...",
+        value: localSearch.value,
+        onInput: (e) => {
+          const val = e.target.value;
+          localSearch.value = val;
+          emit("update:searchText", val);
+        }
+      }) : null;
+      const toolbar = vue.h("div", { class: tigercatCore.fileManagerToolbarClasses }, [
+        breadcrumb,
+        vue.h("div", { class: "flex-1" }),
+        searchInput
+      ]);
+      const fileIcon = (item) => vue.h(
+        "span",
+        { class: tigercatCore.fileManagerItemIconClasses, "aria-hidden": "true" },
+        item.type === "folder" ? "\u{1F4C1}" : "\u{1F4C4}"
+      );
+      const renderItem = (item) => {
+        const isSelected = selectedSet.value.has(item.key);
+        const itemClass = tigercatCore.getFileItemClasses(props.viewMode, isSelected);
+        const nameEl = vue.h("span", { class: tigercatCore.fileManagerItemNameClasses }, item.name);
+        const metaEls = props.viewMode === "list" ? [
+          item.size !== void 0 ? vue.h("span", { class: tigercatCore.fileManagerItemMetaClasses }, tigercatCore.formatFileSizeLabel(item.size)) : null,
+          item.modified ? vue.h("span", { class: tigercatCore.fileManagerItemMetaClasses }, item.modified) : null
+        ] : [];
+        return vue.h(
+          "div",
+          {
+            key: item.key,
+            class: itemClass,
+            role: "option",
+            "aria-selected": isSelected,
+            "data-disabled": item.disabled || void 0,
+            onClick: () => handleSelect(item),
+            onDblclick: () => handleOpen(item),
+            draggable: props.draggable && !item.disabled
+          },
+          [fileIcon(item), nameEl, ...metaEls]
+        );
+      };
+      const contentClass = props.viewMode === "grid" ? `${tigercatCore.fileManagerContentClasses} grid grid-cols-4 gap-2` : tigercatCore.fileManagerContentClasses;
+      const content = processedItems.value.length > 0 ? vue.h(
+        "div",
+        { class: contentClass, role: "listbox", "aria-multiselectable": props.multiple },
+        processedItems.value.map(renderItem)
+      ) : vue.h("div", { class: tigercatCore.fileManagerEmptyClasses }, props.emptyText);
+      const loadingEl = props.loading ? vue.h("div", { class: tigercatCore.fileManagerLoadingClasses }, "Loading...") : null;
+      return vue.h("div", { class: containerClasses.value }, [toolbar, content, loadingEl]);
+    };
+  }
+});
+var FileManager_default = FileManager;
+
+exports.FileManager = FileManager;
+exports.FileManager_default = FileManager_default;

package/dist/chunk-VIIGYWUY.mjs

@@ -0,0 +1,83 @@
+import { defineComponent, provide, computed, h, inject } from 'vue';
+import { classNames, getInputGroupClasses, coerceClassValue, getInputGroupAddonClasses } from '@expcat/tigercat-core';
+
+// src/components/InputGroup.ts
+var INPUT_GROUP_INJECTION_KEY = /* @__PURE__ */ Symbol("TigerInputGroup");
+var InputGroup = defineComponent({
+  name: "TigerInputGroup",
+  inheritAttrs: false,
+  props: {
+    size: {
+      type: String,
+      default: "md"
+    },
+    compact: {
+      type: Boolean,
+      default: false
+    },
+    className: {
+      type: String,
+      default: void 0
+    }
+  },
+  setup(props, { slots, attrs }) {
+    provide(INPUT_GROUP_INJECTION_KEY, {
+      get size() {
+        return props.size;
+      },
+      get compact() {
+        return props.compact;
+      }
+    });
+    const classes = computed(
+      () => classNames(
+        getInputGroupClasses(props.compact, props.className),
+        coerceClassValue(attrs.class)
+      )
+    );
+    return () => h(
+      "div",
+      {
+        ...attrs,
+        class: classes.value,
+        role: "group"
+      },
+      slots.default?.()
+    );
+  }
+});
+var InputGroupAddon = defineComponent({
+  name: "TigerInputGroupAddon",
+  inheritAttrs: false,
+  props: {
+    type: {
+      type: String,
+      default: "text"
+    },
+    className: {
+      type: String,
+      default: void 0
+    }
+  },
+  setup(props, { slots, attrs }) {
+    const ctx = inject(INPUT_GROUP_INJECTION_KEY, null);
+    return () => {
+      const size = ctx?.size ?? "md";
+      const compact = ctx?.compact ?? true;
+      return h(
+        "span",
+        {
+          ...attrs,
+          class: classNames(
+            getInputGroupAddonClasses(size, compact, props.className),
+            coerceClassValue(attrs.class)
+          )
+        },
+        slots.default?.()
+      );
+    };
+  }
+});
+var InputGroup_default = InputGroup;
+
+export { INPUT_GROUP_INJECTION_KEY, InputGroup, InputGroupAddon, InputGroup_default };

package/dist/chunk-W2WGLETE.mjs

@@ -0,0 +1,177 @@
+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 { ChartCanvas } from './chunk-5WHLXWWT.mjs';
+import { defineComponent, computed, h } from 'vue';
+import { getChartInnerRect, resolveChartPalette, computeSunburstArcs, buildChartLegendItems, resolveChartTooltipContent, classNames, getChartElementOpacity } from '@expcat/tigercat-core';
+
+var SunburstChart = defineComponent({
+  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 },
+    // 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
+    } = useChartInteraction({
+      hoverable: computed(() => props.hoverable),
+      hoveredIndexProp: () => props.hoveredIndex,
+      selectable: computed(() => props.selectable),
+      selectedIndexProp: () => props.selectedIndex,
+      activeOpacity: computed(() => props.activeOpacity),
+      inactiveOpacity: computed(() => props.inactiveOpacity),
+      legendPosition: computed(() => 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 = computed(() => getChartInnerRect(props.width, props.height, props.padding));
+    const palette = computed(() => resolveChartPalette(props.colors));
+    const outerRadius = computed(() => Math.min(innerRect.value.width, innerRect.value.height) / 2);
+    const innerRadius = computed(
+      () => outerRadius.value * Math.max(0, Math.min(1, props.innerRadiusRatio))
+    );
+    const cx = computed(() => innerRect.value.width / 2);
+    const cy = computed(() => innerRect.value.height / 2);
+    const arcs = computed(
+      () => computeSunburstArcs(props.data, {
+        cx: cx.value,
+        cy: cy.value,
+        innerRadius: innerRadius.value,
+        outerRadius: outerRadius.value,
+        colors: palette.value
+      })
+    );
+    const rootArcs = computed(() => arcs.value.filter((a) => a.depth === 0));
+    const legendItems = computed(
+      () => buildChartLegendItems({
+        data: rootArcs.value,
+        palette: palette.value,
+        activeIndex: activeIndex.value,
+        getLabel: (d) => d.label,
+        getColor: (d) => d.color
+      })
+    );
+    const tooltipContent = computed(
+      () => resolveChartTooltipContent(
+        resolvedHoveredIndex.value,
+        arcs.value,
+        void 0,
+        (arc) => `${arc.label}: ${arc.value}`
+      )
+    );
+    return () => {
+      const interactive = props.hoverable || props.selectable;
+      const chart = h(
+        ChartCanvas,
+        {
+          width: props.width,
+          height: props.height,
+          padding: props.padding,
+          title: props.title,
+          desc: props.desc,
+          className: classNames(props.className)
+        },
+        {
+          default: () => h(
+            ChartSeries,
+            { data: arcs.value, type: "sunburst" },
+            {
+              default: () => arcs.value.map((arc) => {
+                const opacity = getChartElementOpacity(arc.index, activeIndex.value, {
+                  activeOpacity: props.activeOpacity,
+                  inactiveOpacity: props.inactiveOpacity
+                });
+                return h("path", {
+                  key: `arc-${arc.index}`,
+                  d: arc.path,
+                  fill: arc.color,
+                  opacity,
+                  stroke: "#ffffff",
+                  "stroke-width": 1,
+                  class: classNames(interactive && "cursor-pointer"),
+                  style: { transition: "opacity 0.2s ease-out" },
+                  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 ? h(ChartTooltip, {
+        content: tooltipContent.value,
+        visible: resolvedHoveredIndex.value !== null && tooltipContent.value !== "",
+        x: tooltipPosition.value.x,
+        y: tooltipPosition.value.y
+      }) : null;
+      if (!props.showLegend) {
+        return h("div", { class: "inline-block relative" }, [chart, tooltip]);
+      }
+      return h("div", { class: wrapperClasses.value }, [
+        chart,
+        h(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;
+
+export { SunburstChart, SunburstChart_default };