@expcat/tigercat-vue 0.4.3 → 1.0.4

package/dist/chunk-33C5E3AQ.mjs

@@ -0,0 +1,328 @@
+import { useTigerConfig } from './chunk-XP5M2GK7.mjs';
+import { defineComponent, ref, computed, watch, h } from 'vue';
+import { filterColumns, mergeTigerLocale, getTaskBoardLabels, classNames, getKanbanContainerClasses, coerceClassValue, mergeStyleValues, isWipExceeded, getColumnCardCount, resolveLocaleText, kanbanCardCountClasses, taskBoardWipExceededClasses, taskBoardColumnHeaderClasses, taskBoardCardClasses, taskBoardCardDraggingClasses, taskBoardDropIndicatorClasses, taskBoardColumnBodyClasses, taskBoardEmptyClasses, kanbanAddCardClasses, taskBoardColumnClasses, taskBoardColumnDropTargetClasses, taskBoardColumnDraggingClasses, kanbanAddColumnClasses, setDragData, createCardDragData, parseDragData, moveCard, reorderColumns, getDropIndex, createColumnDragData, getColumnDropIndex } from '@expcat/tigercat-core';
+
+var Kanban = defineComponent({
+  name: "TigerKanban",
+  inheritAttrs: false,
+  props: {
+    columns: {
+      type: Array,
+      default: void 0
+    },
+    defaultColumns: {
+      type: Array,
+      default: () => []
+    },
+    draggable: { type: Boolean, default: true },
+    columnDraggable: { type: Boolean, default: true },
+    enforceWipLimit: { type: Boolean, default: false },
+    beforeCardMove: {
+      type: Function,
+      default: void 0
+    },
+    beforeColumnMove: {
+      type: Function,
+      default: void 0
+    },
+    onCardAdd: {
+      type: Function,
+      default: void 0
+    },
+    filterText: { type: String, default: "" },
+    hiddenColumns: {
+      type: Array,
+      default: () => []
+    },
+    showCardCount: { type: Boolean, default: true },
+    allowAddCard: { type: Boolean, default: true },
+    allowAddColumn: { type: Boolean, default: false },
+    locale: {
+      type: Object,
+      default: void 0
+    },
+    className: { type: String, default: void 0 },
+    style: {
+      type: Object,
+      default: void 0
+    }
+  },
+  emits: ["card-move", "column-move", "update:columns", "card-add", "column-add"],
+  setup(props, { emit, attrs, slots }) {
+    const config = useTigerConfig();
+    const boardRef = ref(null);
+    const internalColumns = ref(props.defaultColumns ?? []);
+    const isControlled = computed(() => props.columns !== void 0);
+    const rawColumns = computed(() => isControlled.value ? props.columns : internalColumns.value);
+    const visibleColumns = computed(
+      () => filterColumns(rawColumns.value, props.filterText || "", props.hiddenColumns)
+    );
+    watch(
+      () => props.columns,
+      (v) => {
+        if (v) internalColumns.value = v;
+      }
+    );
+    function updateColumns(cols) {
+      if (!isControlled.value) internalColumns.value = cols;
+      emit("update:columns", cols);
+    }
+    const merged = computed(() => mergeTigerLocale(config.value.locale, props.locale));
+    const labels = computed(() => getTaskBoardLabels(merged.value));
+    const dragState = ref(null);
+    const dropTargetCol = ref(null);
+    const dropTargetIdx = ref(-1);
+    const dragType = computed(() => dragState.value?.type ?? null);
+    function onCardDragStart(e, card, colId, idx) {
+      if (!props.draggable || !e.dataTransfer) return;
+      setDragData(e.dataTransfer, createCardDragData(card.id, colId, idx));
+      dragState.value = { type: "card", id: card.id, fromColumnId: colId, fromIndex: idx };
+    }
+    function onColumnDragStart(e, colId, idx) {
+      if (!props.columnDraggable || !e.dataTransfer) return;
+      setDragData(e.dataTransfer, createColumnDragData(colId, idx));
+      dragState.value = { type: "column", id: colId, fromIndex: idx };
+    }
+    function onDragOver(e, colId) {
+      e.preventDefault();
+      if (!dragState.value) return;
+      dropTargetCol.value = colId;
+      if (dragState.value.type === "card") {
+        const colEl = e.currentTarget.querySelector("[data-kanban-body]");
+        if (colEl) {
+          const cards = Array.from(colEl.querySelectorAll("[data-kanban-card]"));
+          const rects = cards.map((c) => c.getBoundingClientRect());
+          dropTargetIdx.value = getDropIndex(e.clientY, rects);
+        }
+      }
+    }
+    function onColumnDragOver(e) {
+      e.preventDefault();
+      if (!dragState.value || dragState.value.type !== "column") return;
+      const boardEl = boardRef.value;
+      if (!boardEl) return;
+      const cols = Array.from(boardEl.querySelectorAll("[data-kanban-column]"));
+      const rects = cols.map((c) => c.getBoundingClientRect());
+      dropTargetIdx.value = getColumnDropIndex(e.clientX, rects);
+    }
+    async function onDrop(e) {
+      e.preventDefault();
+      if (!dragState.value || !e.dataTransfer) return;
+      const data = parseDragData(e.dataTransfer);
+      if (!data) return;
+      const cols = rawColumns.value;
+      if (data.type === "card" && dropTargetCol.value != null) {
+        if (props.beforeCardMove) {
+          const evt = {
+            cardId: data.cardId,
+            fromColumnId: data.columnId,
+            toColumnId: dropTargetCol.value,
+            fromIndex: data.index,
+            toIndex: dropTargetIdx.value
+          };
+          const ok = await props.beforeCardMove(evt);
+          if (!ok) {
+            resetDrag();
+            return;
+          }
+        }
+        const result = moveCard(
+          cols,
+          data.cardId,
+          data.columnId,
+          dropTargetCol.value,
+          dropTargetIdx.value,
+          { enforceWipLimit: props.enforceWipLimit }
+        );
+        if (result) {
+          updateColumns(result.columns);
+          emit("card-move", result.event);
+        }
+      } else if (data.type === "column") {
+        if (props.beforeColumnMove) {
+          const evt = {
+            columnId: data.columnId,
+            fromIndex: data.index,
+            toIndex: dropTargetIdx.value
+          };
+          const ok = await props.beforeColumnMove(evt);
+          if (!ok) {
+            resetDrag();
+            return;
+          }
+        }
+        const result = reorderColumns(cols, data.index, dropTargetIdx.value);
+        if (result) {
+          updateColumns(result.columns);
+          emit("column-move", result.event);
+        }
+      }
+      resetDrag();
+    }
+    function onDragEnd() {
+      resetDrag();
+    }
+    function resetDrag() {
+      dragState.value = null;
+      dropTargetCol.value = null;
+      dropTargetIdx.value = -1;
+    }
+    const containerClasses = computed(
+      () => classNames(getKanbanContainerClasses(props.className), coerceClassValue(attrs.class))
+    );
+    const containerStyle = computed(() => mergeStyleValues(attrs.style, props.style));
+    return () => {
+      const children = visibleColumns.value.map((col, colIdx) => {
+        const wipExceeded = isWipExceeded(col);
+        const cardCount = getColumnCardCount(col);
+        const isDragOverCol = dropTargetCol.value === col.id;
+        const isColDragging = dragState.value?.type === "column" && dragState.value.id === col.id;
+        const headerContent = [
+          slots["column-header"] ? slots["column-header"]({ column: col }) : h("span", {}, resolveLocaleText(col.title)),
+          props.showCardCount ? h(
+            "span",
+            {
+              class: classNames(
+                kanbanCardCountClasses,
+                wipExceeded && taskBoardWipExceededClasses
+              )
+            },
+            cardCount.limit ? `${cardCount.count}/${cardCount.limit}` : `${cardCount.count}`
+          ) : null
+        ];
+        const header = h(
+          "div",
+          {
+            class: classNames(
+              taskBoardColumnHeaderClasses,
+              wipExceeded && taskBoardWipExceededClasses
+            )
+          },
+          headerContent
+        );
+        const cardEls = col.cards.map((card, cardIdx) => {
+          const isCardDragging = dragState.value?.type === "card" && dragState.value.id === card.id;
+          return h(
+            "div",
+            {
+              key: card.id,
+              class: classNames(
+                taskBoardCardClasses,
+                isCardDragging && taskBoardCardDraggingClasses
+              ),
+              draggable: props.draggable,
+              "data-kanban-card": "",
+              onDragstart: (e) => onCardDragStart(e, card, col.id, cardIdx)
+            },
+            slots.card ? slots.card({ card, columnId: col.id }) : [
+              h("div", { class: "font-medium text-sm" }, resolveLocaleText(card.title)),
+              card.description ? h(
+                "div",
+                { class: "text-xs text-[var(--tiger-text-muted,#6b7280)] mt-1" },
+                card.description
+              ) : null
+            ]
+          );
+        });
+        if (isDragOverCol && dragType.value === "card" && dropTargetIdx.value >= 0) {
+          cardEls.splice(
+            dropTargetIdx.value,
+            0,
+            h("div", {
+              key: "__drop-indicator",
+              class: taskBoardDropIndicatorClasses
+            })
+          );
+        }
+        const body = h(
+          "div",
+          {
+            class: taskBoardColumnBodyClasses,
+            "data-kanban-body": ""
+          },
+          cardEls.length > 0 ? cardEls : [
+            h(
+              "div",
+              { class: taskBoardEmptyClasses },
+              resolveLocaleText(labels.value.emptyColumnText)
+            )
+          ]
+        );
+        const addBtn = props.allowAddCard ? h(
+          "div",
+          {
+            class: kanbanAddCardClasses,
+            role: "button",
+            tabindex: 0,
+            onClick: () => {
+              props.onCardAdd?.(col.id);
+              emit("card-add", col.id);
+            },
+            onKeydown: (e) => {
+              if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                props.onCardAdd?.(col.id);
+                emit("card-add", col.id);
+              }
+            }
+          },
+          "+ " + resolveLocaleText(labels.value.addCardText)
+        ) : null;
+        return h(
+          "div",
+          {
+            key: col.id,
+            class: classNames(
+              taskBoardColumnClasses,
+              isDragOverCol && dragType.value === "card" && taskBoardColumnDropTargetClasses,
+              isColDragging && taskBoardColumnDraggingClasses
+            ),
+            "data-kanban-column": "",
+            draggable: props.columnDraggable,
+            onDragstart: (e) => onColumnDragStart(e, col.id, colIdx),
+            onDragover: (e) => onDragOver(e, col.id),
+            onDrop,
+            onDragend: onDragEnd
+          },
+          [header, body, addBtn]
+        );
+      });
+      if (props.allowAddColumn) {
+        children.push(
+          h(
+            "div",
+            {
+              key: "__add-column",
+              class: kanbanAddColumnClasses,
+              role: "button",
+              tabindex: 0,
+              onClick: () => emit("column-add"),
+              onKeydown: (e) => {
+                if (e.key === "Enter" || e.key === " ") {
+                  e.preventDefault();
+                  emit("column-add");
+                }
+              }
+            },
+            "+ " + resolveLocaleText(labels.value.addCardText)
+          )
+        );
+      }
+      return h(
+        "div",
+        {
+          ref: boardRef,
+          class: containerClasses.value,
+          style: containerStyle.value,
+          role: "region",
+          "aria-label": "Kanban board",
+          onDragover: onColumnDragOver
+        },
+        children
+      );
+    };
+  }
+});
+var Kanban_default = Kanban;
+
+export { Kanban, Kanban_default };

package/dist/chunk-34ZZLKQ4.js

@@ -0,0 +1,184 @@
+'use strict';
+
+var chunkFCV4ML6I_js = require('./chunk-FCV4ML6I.js');
+var vue = require('vue');
+var tigercatCore = require('@expcat/tigercat-core');
+
+var GaugeChart = vue.defineComponent({
+  name: "TigerGaugeChart",
+  props: {
+    width: { type: Number, default: 280 },
+    height: { type: Number, default: 200 },
+    padding: { type: [Number, Object], default: 24 },
+    value: { type: Number, required: true },
+    min: { type: Number, default: 0 },
+    max: { type: Number, default: 100 },
+    startAngle: { type: Number, default: 135 },
+    endAngle: { type: Number, default: 405 },
+    arcWidth: { type: Number, default: 20 },
+    showTicks: { type: Boolean, default: true },
+    tickCount: { type: Number, default: 5 },
+    valueFormatter: { type: Function },
+    label: { type: String },
+    segments: {
+      type: Array
+    },
+    trackColor: { type: String, default: "var(--tiger-border,#e5e7eb)" },
+    color: { type: String, default: "var(--tiger-primary,#2563eb)" },
+    // a11y
+    title: { type: String },
+    desc: { type: String },
+    className: { type: String }
+  },
+  setup(props) {
+    const innerRect = vue.computed(() => tigercatCore.getChartInnerRect(props.width, props.height, props.padding));
+    const radius = vue.computed(() => Math.min(innerRect.value.width, innerRect.value.height) / 2 - 4);
+    const cx = vue.computed(() => innerRect.value.width / 2);
+    const cy = vue.computed(() => innerRect.value.height / 2);
+    const needleAngle = vue.computed(
+      () => tigercatCore.valueToGaugeAngle(props.value, props.min, props.max, props.startAngle, props.endAngle)
+    );
+    const ticks = vue.computed(
+      () => props.showTicks ? tigercatCore.computeGaugeTicks(
+        cx.value,
+        cy.value,
+        radius.value,
+        props.min,
+        props.max,
+        props.startAngle,
+        props.endAngle,
+        props.tickCount
+      ) : []
+    );
+    return () => {
+      const r = radius.value;
+      const c = cx.value;
+      const cY = cy.value;
+      const aw = props.arcWidth;
+      const trackPath = tigercatCore.createGaugeArcPath(c, cY, r, props.startAngle, props.endAngle, aw);
+      const valuePath = needleAngle.value > props.startAngle ? tigercatCore.createGaugeArcPath(c, cY, r, props.startAngle, needleAngle.value, aw) : null;
+      const segmentArcs = props.segments?.map((seg, i) => {
+        const sStart = tigercatCore.valueToGaugeAngle(
+          seg.range[0],
+          props.min,
+          props.max,
+          props.startAngle,
+          props.endAngle
+        );
+        const sEnd = tigercatCore.valueToGaugeAngle(
+          seg.range[1],
+          props.min,
+          props.max,
+          props.startAngle,
+          props.endAngle
+        );
+        return vue.h("path", {
+          key: `seg-${i}`,
+          d: tigercatCore.createGaugeArcPath(c, cY, r, sStart, sEnd, aw),
+          fill: seg.color,
+          "stroke-width": 0
+        });
+      }) ?? [];
+      const needlePath = tigercatCore.createGaugeNeedlePath(c, cY, r - aw - 6, needleAngle.value);
+      const formattedValue = props.valueFormatter ? props.valueFormatter(props.value) : `${props.value}`;
+      return vue.h(
+        chunkFCV4ML6I_js.ChartCanvas,
+        {
+          width: props.width,
+          height: props.height,
+          padding: props.padding,
+          title: props.title,
+          desc: props.desc,
+          className: tigercatCore.classNames(props.className)
+        },
+        {
+          default: () => [
+            // Track
+            vue.h("path", {
+              d: trackPath,
+              fill: props.trackColor,
+              "stroke-width": 0
+            }),
+            // Segments or value arc
+            ...props.segments ? segmentArcs : valuePath ? [
+              vue.h("path", {
+                d: valuePath,
+                fill: props.color,
+                "stroke-width": 0,
+                style: { transition: "all 0.3s ease-out" }
+              })
+            ] : [],
+            // Ticks
+            ...ticks.value.map((tick, i) => [
+              vue.h("line", {
+                key: `tick-${i}`,
+                x1: tick.x1,
+                y1: tick.y1,
+                x2: tick.x2,
+                y2: tick.y2,
+                stroke: "var(--tiger-text-secondary,#6b7280)",
+                "stroke-width": 1
+              }),
+              vue.h(
+                "text",
+                {
+                  key: `tick-label-${i}`,
+                  x: tick.x2 + (tick.x2 - tick.x1) * 1.5,
+                  y: tick.y2 + (tick.y2 - tick.y1) * 1.5,
+                  class: tigercatCore.chartAxisTickTextClasses,
+                  "text-anchor": "middle",
+                  "dominant-baseline": "middle",
+                  style: { fontSize: "10px" }
+                },
+                tick.label
+              )
+            ]).flat(),
+            // Needle
+            vue.h("path", {
+              d: needlePath,
+              fill: "var(--tiger-text,#374151)",
+              style: { transition: "all 0.3s ease-out" }
+            }),
+            // Center dot
+            vue.h("circle", {
+              cx: c,
+              cy: cY,
+              r: 5,
+              fill: "var(--tiger-text,#374151)"
+            }),
+            // Value text
+            vue.h(
+              "text",
+              {
+                x: c,
+                y: cY + r * 0.35,
+                class: "fill-[color:var(--tiger-text,#374151)] text-lg font-semibold",
+                "text-anchor": "middle",
+                "dominant-baseline": "middle"
+              },
+              formattedValue
+            ),
+            // Label
+            ...props.label ? [
+              vue.h(
+                "text",
+                {
+                  x: c,
+                  y: cY + r * 0.35 + 20,
+                  class: tigercatCore.chartAxisTickTextClasses,
+                  "text-anchor": "middle",
+                  "dominant-baseline": "middle"
+                },
+                props.label
+              )
+            ] : []
+          ]
+        }
+      );
+    };
+  }
+});
+var GaugeChart_default = GaugeChart;
+
+exports.GaugeChart = GaugeChart;
+exports.GaugeChart_default = GaugeChart_default;

package/dist/chunk-3FVWZYBQ.js

@@ -0,0 +1,196 @@
+'use strict';
+
+var chunkFLAJKB2O_js = require('./chunk-FLAJKB2O.js');
+var chunkBKTQ6RWR_js = require('./chunk-BKTQ6RWR.js');
+var chunkHBFFINAI_js = require('./chunk-HBFFINAI.js');
+var chunkEPE6OOV7_js = require('./chunk-EPE6OOV7.js');
+var chunkFCV4ML6I_js = require('./chunk-FCV4ML6I.js');
+var vue = require('vue');
+var tigercatCore = require('@expcat/tigercat-core');
+
+var TreeMapChart = vue.defineComponent({
+  name: "TigerTreeMapChart",
+  props: {
+    width: { type: Number, default: 400 },
+    height: { type: Number, default: 300 },
+    padding: { type: [Number, Object], default: 8 },
+    data: { type: Array, required: true },
+    gap: { type: Number, default: 2 },
+    showLabels: { type: Boolean, default: true },
+    minLabelSize: { type: Number, default: 10 },
+    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", "node-click", "node-hover"],
+  setup(props, { emit }) {
+    const {
+      tooltipPosition,
+      resolvedHoveredIndex,
+      activeIndex,
+      handleMouseEnter,
+      handleMouseMove,
+      handleMouseLeave,
+      handleClick,
+      handleLegendClick,
+      handleLegendHover,
+      handleLegendLeave,
+      wrapperClasses
+    } = chunkFLAJKB2O_js.useChartInteraction({
+      hoverable: vue.computed(() => props.hoverable),
+      hoveredIndexProp: () => props.hoveredIndex,
+      selectable: vue.computed(() => props.selectable),
+      selectedIndexProp: () => props.selectedIndex,
+      activeOpacity: vue.computed(() => props.activeOpacity),
+      inactiveOpacity: vue.computed(() => props.inactiveOpacity),
+      legendPosition: vue.computed(() => props.legendPosition),
+      emit,
+      getData: (index) => {
+        const node = nodes.value[index];
+        return node ? { label: node.label, value: node.value } : {};
+      },
+      eventNames: { hover: "node-hover", click: "node-click" }
+    });
+    const innerRect = vue.computed(() => tigercatCore.getChartInnerRect(props.width, props.height, props.padding));
+    const palette = vue.computed(() => tigercatCore.resolveChartPalette(props.colors));
+    const nodes = vue.computed(
+      () => tigercatCore.computeTreeMapNodes(props.data, {
+        width: innerRect.value.width,
+        height: innerRect.value.height,
+        gap: props.gap,
+        colors: palette.value
+      })
+    );
+    const total = vue.computed(() => nodes.value.reduce((s, n) => s + n.value, 0));
+    const legendItems = vue.computed(
+      () => tigercatCore.buildChartLegendItems({
+        data: nodes.value,
+        palette: palette.value,
+        activeIndex: activeIndex.value,
+        getLabel: (d) => d.label,
+        getColor: (d) => d.color
+      })
+    );
+    const tooltipContent = vue.computed(
+      () => tigercatCore.resolveChartTooltipContent(resolvedHoveredIndex.value, nodes.value, void 0, (node) => {
+        const pct = total.value > 0 ? (node.value / total.value * 100).toFixed(1) : "0";
+        return `${node.label}: ${node.value} (${pct}%)`;
+      })
+    );
+    return () => {
+      const interactive = props.hoverable || props.selectable;
+      const chart = vue.h(
+        chunkFCV4ML6I_js.ChartCanvas,
+        {
+          width: props.width,
+          height: props.height,
+          padding: props.padding,
+          title: props.title,
+          desc: props.desc,
+          className: tigercatCore.classNames(props.className)
+        },
+        {
+          default: () => {
+            return vue.h(
+              chunkHBFFINAI_js.ChartSeries,
+              { data: nodes.value, type: "treemap" },
+              {
+                default: () => nodes.value.map((node) => {
+                  const opacity = tigercatCore.getChartElementOpacity(node.index, activeIndex.value, {
+                    activeOpacity: props.activeOpacity,
+                    inactiveOpacity: props.inactiveOpacity
+                  });
+                  const elems = [
+                    vue.h("rect", {
+                      key: `node-${node.index}`,
+                      x: node.x,
+                      y: node.y,
+                      width: node.w,
+                      height: node.h,
+                      rx: 2,
+                      fill: node.color,
+                      opacity,
+                      class: tigercatCore.classNames(interactive && "cursor-pointer"),
+                      style: { transition: "opacity 0.2s ease-out" },
+                      onMouseenter: (e) => handleMouseEnter(node.index, e),
+                      onMousemove: handleMouseMove,
+                      onMouseleave: handleMouseLeave,
+                      onClick: () => handleClick(node.index)
+                    })
+                  ];
+                  if (props.showLabels && node.w > 30 && node.h > props.minLabelSize + 4) {
+                    elems.push(
+                      vue.h(
+                        "text",
+                        {
+                          key: `label-${node.index}`,
+                          x: node.x + node.w / 2,
+                          y: node.y + node.h / 2,
+                          class: "fill-white text-xs",
+                          "text-anchor": "middle",
+                          "dominant-baseline": "middle",
+                          style: {
+                            pointerEvents: "none",
+                            fontSize: `${Math.min(12, node.h * 0.3)}px`
+                          }
+                        },
+                        node.label
+                      )
+                    );
+                  }
+                  return elems;
+                }).flat()
+              }
+            );
+          }
+        }
+      );
+      const tooltip = props.showTooltip && props.hoverable ? vue.h(chunkEPE6OOV7_js.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("div", { class: "inline-block relative" }, [chart, tooltip]);
+      }
+      return vue.h("div", { class: wrapperClasses.value }, [
+        chart,
+        vue.h(chunkBKTQ6RWR_js.ChartLegend, {
+          items: legendItems.value,
+          position: props.legendPosition,
+          markerSize: props.legendMarkerSize,
+          gap: props.legendGap,
+          interactive,
+          onItemClick: handleLegendClick,
+          onItemHover: handleLegendHover,
+          onItemLeave: handleLegendLeave
+        }),
+        tooltip
+      ]);
+    };
+  }
+});
+var TreeMapChart_default = TreeMapChart;
+
+exports.TreeMapChart = TreeMapChart;
+exports.TreeMapChart_default = TreeMapChart_default;