@expcat/tigercat-vue 1.0.7 → 1.2.0

package/dist/{chunk-KFE7T7CN.js → chunk-V32X2OEO.js}

@@ -1,20 +1,48 @@
-'use strict';
+"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; }
 
-var chunkJCMGBKS6_js = require('./chunk-JCMGBKS6.js');
-var vue = require('vue');
-var tigercatCore = require('@expcat/tigercat-core');
 
+var _chunkJCMGBKS6js = require('./chunk-JCMGBKS6.js');
+
+// src/components/Message.ts
+
+
+
+
+
+
+
+
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
 var MESSAGE_CONTAINER_ID = "tiger-message-container";
 var MESSAGE_CLOSE_ARIA_LABEL = "Close message";
 var MESSAGE_CONTAINER_ROOT_ID = `${MESSAGE_CONTAINER_ID}-root`;
-var messageInstances = vue.ref([]);
+var messageInstances = _vue.ref.call(void 0, []);
 var instanceIdCounter = 0;
-var IS_TEST_ENV = typeof process !== "undefined" && process.env?.NODE_ENV === "test";
+var IS_TEST_ENV = (() => {
+  const proc = globalThis.process;
+  return typeof proc !== "undefined" && _optionalChain([proc, 'access', _ => _.env, 'optionalAccess', _2 => _2.NODE_ENV]) === "test";
+})();
 var containerApp = null;
 function getNextInstanceId() {
   return ++instanceIdCounter;
 }
-var MessageContainer = vue.defineComponent({
+var MessageContainer = _vue.defineComponent.call(void 0, {
   name: "TigerMessageContainer",
   props: {
     position: {
@@ -23,46 +51,46 @@ var MessageContainer = vue.defineComponent({
     }
   },
   setup(props) {
-    const containerClasses = vue.computed(() => {
-      return tigercatCore.classNames(tigercatCore.messageContainerBaseClasses, tigercatCore.messagePositionClasses[props.position]);
+    const containerClasses = _vue.computed.call(void 0, () => {
+      return _tigercatcore.classNames.call(void 0, _tigercatcore.messageContainerBaseClasses, _tigercatcore.messagePositionClasses[props.position]);
     });
     const renderMessageItem = (message) => {
-      const colorScheme = tigercatCore.getMessageTypeClasses(message.type, tigercatCore.defaultMessageThemeColors);
-      const messageClasses = tigercatCore.classNames(
-        tigercatCore.messageBaseClasses,
+      const colorScheme = _tigercatcore.getMessageTypeClasses.call(void 0, message.type, _tigercatcore.defaultMessageThemeColors);
+      const messageClasses = _tigercatcore.classNames.call(void 0, 
+        _tigercatcore.messageBaseClasses,
         colorScheme.bg,
         colorScheme.border,
         colorScheme.text,
         message.className
       );
-      const iconPath = message.icon || tigercatCore.getMessageIconPath(message.type);
-      const iconClass = tigercatCore.classNames(tigercatCore.messageIconClasses, colorScheme.icon);
+      const iconPath = message.icon || _tigercatcore.getMessageIconPath.call(void 0, message.type);
+      const iconClass = _tigercatcore.classNames.call(void 0, _tigercatcore.messageIconClasses, colorScheme.icon);
       const a11yRole = message.type === "error" ? "alert" : "status";
       const ariaLive = message.type === "error" ? "assertive" : "polite";
       const children = [
-        chunkJCMGBKS6_js.createStatusIconWithLoading(
+        _chunkJCMGBKS6js.createStatusIconWithLoading.call(void 0, 
           iconPath,
           iconClass,
           message.type === "loading",
-          tigercatCore.messageLoadingSpinnerClasses
+          _tigercatcore.messageLoadingSpinnerClasses
         ),
-        vue.h("div", { class: tigercatCore.messageContentClasses }, message.content)
+        _vue.h.call(void 0, "div", { class: _tigercatcore.messageContentClasses }, message.content)
       ];
       if (message.closable) {
         children.push(
-          vue.h(
+          _vue.h.call(void 0, 
             "button",
             {
-              class: tigercatCore.messageCloseButtonClasses,
+              class: _tigercatcore.messageCloseButtonClasses,
               onClick: () => removeMessage(message.id),
               "aria-label": MESSAGE_CLOSE_ARIA_LABEL,
               type: "button"
             },
-            chunkJCMGBKS6_js.createStatusIcon(tigercatCore.messageCloseIconPath, "w-4 h-4")
+            _chunkJCMGBKS6js.createStatusIcon.call(void 0, _tigercatcore.messageCloseIconPath, "w-4 h-4")
           )
         );
       }
-      return vue.h(
+      return _vue.h.call(void 0, 
         "div",
         {
           key: message.id,
@@ -78,10 +106,10 @@ var MessageContainer = vue.defineComponent({
         children
       );
     };
-    return () => vue.h(
-      vue.Teleport,
+    return () => _vue.h.call(void 0, 
+      _vue.Teleport,
       { to: "body" },
-      vue.h(
+      _vue.h.call(void 0, 
         "div",
         {
           class: containerClasses.value,
@@ -90,8 +118,8 @@ var MessageContainer = vue.defineComponent({
           "aria-relevant": "additions",
           "data-tiger-message-container": ""
         },
-        IS_TEST_ENV ? messageInstances.value.map(renderMessageItem) : vue.h(
-          vue.TransitionGroup,
+        IS_TEST_ENV ? messageInstances.value.map(renderMessageItem) : _vue.h.call(void 0, 
+          _vue.TransitionGroup,
           { name: "message", tag: "div" },
           () => messageInstances.value.map(renderMessageItem)
         )
@@ -100,7 +128,7 @@ var MessageContainer = vue.defineComponent({
   }
 });
 function ensureContainer() {
-  if (!tigercatCore.isBrowser()) {
+  if (!_tigercatcore.isBrowser.call(void 0, )) {
     return;
   }
   const existingRootEl = document.getElementById(MESSAGE_CONTAINER_ROOT_ID);
@@ -116,7 +144,7 @@ function ensureContainer() {
     rootEl.id = MESSAGE_CONTAINER_ROOT_ID;
     document.body.appendChild(rootEl);
   }
-  containerApp = vue.createApp(MessageContainer);
+  containerApp = _vue.createApp.call(void 0, MessageContainer);
   containerApp.mount(rootEl);
 }
 function addMessage(config) {
@@ -161,15 +189,15 @@ function clearAll() {
     containerApp.unmount();
     containerApp = null;
   }
-  if (tigercatCore.isBrowser()) {
+  if (_tigercatcore.isBrowser.call(void 0, )) {
     const rootEl = document.getElementById(MESSAGE_CONTAINER_ROOT_ID);
-    if (rootEl?.parentNode) {
+    if (_optionalChain([rootEl, 'optionalAccess', _3 => _3.parentNode])) {
       rootEl.parentNode.removeChild(rootEl);
     }
   }
 }
 function normalizeOptions(options) {
-  return tigercatCore.normalizeStringOption(options, "content");
+  return _tigercatcore.normalizeStringOption.call(void 0, options, "content");
 }
 var Message = {
   info(options) {
@@ -198,6 +226,8 @@ var Message = {
 };
 var Message_default = Message;
 
-exports.Message = Message;
-exports.MessageContainer = MessageContainer;
-exports.Message_default = Message_default;
+
+
+
+
+exports.MessageContainer = MessageContainer; exports.Message = Message; exports.Message_default = Message_default;

package/dist/chunk-VAXO5NEM.js

@@ -0,0 +1,320 @@
+"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 _chunkZOUJFFG4js = require('./chunk-ZOUJFFG4.js');
+
+
+var _chunkUHVUKLHFjs = require('./chunk-UHVUKLHF.js');
+
+// src/components/HeatmapChart.ts
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var HeatmapChart = _vue.defineComponent.call(void 0, {
+  name: "TigerHeatmapChart",
+  props: {
+    width: { type: Number, default: 400 },
+    height: { type: Number, default: 300 },
+    padding: { type: [Number, Object], default: 40 },
+    data: { type: Array, required: true },
+    xLabels: { type: Array, required: true },
+    yLabels: { type: Array, required: true },
+    minColor: { type: String, default: "#f0f9ff" },
+    maxColor: { type: String, default: "#2563eb" },
+    colorSpace: { type: String, default: "rgb" },
+    cellRadius: { type: Number, default: 2 },
+    cellGap: { type: Number, default: 1 },
+    showValues: { type: Boolean, default: false },
+    renderMode: { type: String, default: "auto" },
+    canvasThreshold: { type: Number },
+    valueFormatter: { type: Function },
+    // 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 },
+    // Tooltip
+    showTooltip: { type: Boolean, default: true },
+    tooltipFormatter: {
+      type: Function
+    },
+    // a11y
+    title: { type: String },
+    desc: { type: String },
+    className: { type: String }
+  },
+  emits: ["update:hoveredIndex", "update:selectedIndex", "cell-click", "cell-hover"],
+  setup(props, { emit }) {
+    const canvasRef = _vue.ref.call(void 0, null);
+    const {
+      tooltipPosition,
+      resolvedHoveredIndex,
+      activeIndex,
+      handleMouseEnter,
+      handleMouseMove,
+      handleMouseLeave,
+      handleClick,
+      wrapperClasses: _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),
+      emit,
+      getData: (index) => props.data[index],
+      eventNames: { hover: "cell-hover", click: "cell-click" }
+    });
+    const innerRect = _vue.computed.call(void 0, () => _tigercatcore.getChartInnerRect.call(void 0, props.width, props.height, props.padding));
+    const cells = _vue.computed.call(void 0, 
+      () => _tigercatcore.computeHeatmapCells.call(void 0, props.data, {
+        xLabels: props.xLabels,
+        yLabels: props.yLabels,
+        width: innerRect.value.width,
+        height: innerRect.value.height,
+        cellGap: props.cellGap,
+        minColor: props.minColor,
+        maxColor: props.maxColor,
+        colorSpace: props.colorSpace
+      })
+    );
+    const tooltipContent = _vue.computed.call(void 0, 
+      () => _tigercatcore.resolveChartTooltipContent.call(void 0, resolvedHoveredIndex.value, cells.value, void 0, (cell) => {
+        const val = props.valueFormatter ? props.valueFormatter(cell.value) : `${cell.value}`;
+        return `${cell.xLabel} \xD7 ${cell.yLabel}: ${val}`;
+      })
+    );
+    const resolvedRenderMode = _vue.computed.call(void 0, 
+      () => _tigercatcore.resolveHeatmapRenderMode.call(void 0, cells.value.length, {
+        renderMode: props.renderMode,
+        canvasThreshold: props.canvasThreshold
+      })
+    );
+    const shouldRenderCanvas = _vue.computed.call(void 0, () => resolvedRenderMode.value === "canvas");
+    _vue.watchEffect.call(void 0, () => {
+      if (!shouldRenderCanvas.value) return;
+      const rect = innerRect.value;
+      const cellList = cells.value;
+      const currentActiveIndex = activeIndex.value;
+      const currentActiveOpacity = props.activeOpacity;
+      const currentInactiveOpacity = props.inactiveOpacity;
+      const currentCellRadius = props.cellRadius;
+      const currentShowValues = props.showValues;
+      const formatter = props.valueFormatter;
+      _vue.nextTick.call(void 0, () => {
+        const canvas = canvasRef.value;
+        const context = _optionalChain([canvas, 'optionalAccess', _ => _.getContext, 'call', _2 => _2("2d")]);
+        if (!canvas || !context) return;
+        context.clearRect(0, 0, rect.width, rect.height);
+        context.textAlign = "center";
+        context.textBaseline = "middle";
+        context.font = "10px sans-serif";
+        cellList.forEach((cell, idx) => {
+          context.globalAlpha = _nullishCoalesce(_tigercatcore.getChartElementOpacity.call(void 0, idx, currentActiveIndex, {
+            activeOpacity: currentActiveOpacity,
+            inactiveOpacity: currentInactiveOpacity
+          }), () => ( 1));
+          context.fillStyle = cell.fill;
+          const radius = Math.max(0, Math.min(currentCellRadius, cell.w / 2, cell.h / 2));
+          if (radius > 0) {
+            context.beginPath();
+            context.moveTo(cell.x + radius, cell.y);
+            context.lineTo(cell.x + cell.w - radius, cell.y);
+            context.quadraticCurveTo(cell.x + cell.w, cell.y, cell.x + cell.w, cell.y + radius);
+            context.lineTo(cell.x + cell.w, cell.y + cell.h - radius);
+            context.quadraticCurveTo(
+              cell.x + cell.w,
+              cell.y + cell.h,
+              cell.x + cell.w - radius,
+              cell.y + cell.h
+            );
+            context.lineTo(cell.x + radius, cell.y + cell.h);
+            context.quadraticCurveTo(cell.x, cell.y + cell.h, cell.x, cell.y + cell.h - radius);
+            context.lineTo(cell.x, cell.y + radius);
+            context.quadraticCurveTo(cell.x, cell.y, cell.x + radius, cell.y);
+            context.closePath();
+            context.fill();
+          } else {
+            context.fillRect(cell.x, cell.y, cell.w, cell.h);
+          }
+          if (currentShowValues) {
+            context.globalAlpha = 1;
+            context.fillStyle = "var(--tiger-text,#374151)";
+            context.fillText(
+              formatter ? formatter(cell.value) : `${cell.value}`,
+              cell.x + cell.w / 2,
+              cell.y + cell.h / 2
+            );
+          }
+        });
+        context.globalAlpha = 1;
+      });
+    });
+    const getCanvasPoint = (event) => {
+      const canvas = event.currentTarget;
+      const bounds = canvas.getBoundingClientRect();
+      const scaleX = bounds.width > 0 ? canvas.width / bounds.width : 1;
+      const scaleY = bounds.height > 0 ? canvas.height / bounds.height : 1;
+      return {
+        x: event.offsetX * scaleX,
+        y: event.offsetY * scaleY
+      };
+    };
+    const handleCanvasMouseMove = (event) => {
+      const point = getCanvasPoint(event);
+      const index = _tigercatcore.getHeatmapCellIndexAtPoint.call(void 0, cells.value, point.x, point.y);
+      if (index === null) {
+        handleMouseLeave();
+        return;
+      }
+      handleMouseEnter(index, event);
+      handleMouseMove(event);
+    };
+    const handleCanvasClick = (event) => {
+      const point = getCanvasPoint(event);
+      const index = _tigercatcore.getHeatmapCellIndexAtPoint.call(void 0, cells.value, point.x, point.y);
+      if (index !== null) {
+        handleClick(index);
+      }
+    };
+    return () => {
+      const interactive = props.hoverable || props.selectable;
+      const rect = innerRect.value;
+      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 xAxisLabels = props.xLabels.map((label, i) => {
+              const cellW = (rect.width - props.cellGap * (props.xLabels.length - 1)) / props.xLabels.length;
+              return _vue.h.call(void 0, 
+                "text",
+                {
+                  key: `x-${i}`,
+                  x: i * (cellW + props.cellGap) + cellW / 2,
+                  y: rect.height + 16,
+                  class: _tigercatcore.chartAxisTickTextClasses,
+                  "text-anchor": "middle"
+                },
+                label
+              );
+            });
+            const yAxisLabels = props.yLabels.map((label, i) => {
+              const cellH = (rect.height - props.cellGap * (props.yLabels.length - 1)) / props.yLabels.length;
+              return _vue.h.call(void 0, 
+                "text",
+                {
+                  key: `y-${i}`,
+                  x: -8,
+                  y: i * (cellH + props.cellGap) + cellH / 2,
+                  class: _tigercatcore.chartAxisTickTextClasses,
+                  "text-anchor": "end",
+                  "dominant-baseline": "middle"
+                },
+                label
+              );
+            });
+            const cellElems = shouldRenderCanvas.value ? [] : cells.value.map((cell, idx) => {
+              const opacity = _tigercatcore.getChartElementOpacity.call(void 0, idx, activeIndex.value, {
+                activeOpacity: props.activeOpacity,
+                inactiveOpacity: props.inactiveOpacity
+              });
+              const elems = [
+                _vue.h.call(void 0, "rect", {
+                  key: `cell-${idx}`,
+                  x: cell.x,
+                  y: cell.y,
+                  width: cell.w,
+                  height: cell.h,
+                  rx: props.cellRadius,
+                  fill: cell.fill,
+                  opacity,
+                  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)",
+                    rx: `var(--tiger-chart-block-radius, ${props.cellRadius}px)`
+                  },
+                  onMouseenter: (e) => handleMouseEnter(idx, e),
+                  onMousemove: handleMouseMove,
+                  onMouseleave: handleMouseLeave,
+                  onClick: () => handleClick(idx)
+                })
+              ];
+              if (props.showValues) {
+                const val = props.valueFormatter ? props.valueFormatter(cell.value) : `${cell.value}`;
+                elems.push(
+                  _vue.h.call(void 0, 
+                    "text",
+                    {
+                      key: `val-${idx}`,
+                      x: cell.x + cell.w / 2,
+                      y: cell.y + cell.h / 2,
+                      class: "fill-[color:var(--tiger-text,#374151)] text-[10px]",
+                      "text-anchor": "middle",
+                      "dominant-baseline": "middle"
+                    },
+                    val
+                  )
+                );
+              }
+              return elems;
+            }).flat();
+            return [...xAxisLabels, ...yAxisLabels, ...cellElems];
+          }
+        }
+      );
+      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;
+      const canvas = shouldRenderCanvas.value ? _vue.h.call(void 0, "canvas", {
+        ref: canvasRef,
+        width: rect.width,
+        height: rect.height,
+        class: _tigercatcore.classNames.call(void 0, interactive && "cursor-pointer"),
+        style: {
+          position: "absolute",
+          left: `${rect.x}px`,
+          top: `${rect.y}px`,
+          width: `${rect.width}px`,
+          height: `${rect.height}px`,
+          pointerEvents: interactive ? "auto" : "none"
+        },
+        "data-heatmap-canvas": "true",
+        "data-heatmap-render-mode": resolvedRenderMode.value,
+        onMousemove: interactive ? handleCanvasMouseMove : void 0,
+        onMouseleave: interactive ? handleMouseLeave : void 0,
+        onClick: interactive ? handleCanvasClick : void 0
+      }) : null;
+      return _vue.h.call(void 0, "div", { class: "inline-block relative" }, [chart, canvas, tooltip]);
+    };
+  }
+});
+var HeatmapChart_default = HeatmapChart;
+
+
+
+
+exports.HeatmapChart = HeatmapChart; exports.HeatmapChart_default = HeatmapChart_default;

package/dist/chunk-VG6E4NX6.mjs

@@ -0,0 +1,139 @@
+// src/components/ConfigProvider.ts
+import {
+  defineComponent,
+  computed,
+  inject,
+  onBeforeUnmount,
+  provide,
+  ref,
+  watch
+} from "vue";
+import {
+  mergeTigerLocale,
+  isLazyTigerLocale,
+  getImmediateTigerLocale,
+  resolveTigerLocale,
+  getLocaleDirection,
+  ThemeManager
+} from "@expcat/tigercat-core";
+var TigerConfigKey = /* @__PURE__ */ Symbol("TigerConfig");
+function useTigerConfig() {
+  return inject(
+    TigerConfigKey,
+    computed(() => ({}))
+  );
+}
+var configProviderProps = {
+  locale: {
+    type: [Object, Function, Promise],
+    default: void 0
+  },
+  direction: {
+    type: String,
+    default: void 0
+  },
+  theme: {
+    type: String,
+    default: void 0
+  },
+  colorScheme: {
+    type: String,
+    default: void 0
+  }
+};
+var ConfigProvider = defineComponent({
+  name: "TigerConfigProvider",
+  props: configProviderProps,
+  setup(props, { slots }) {
+    const parent = useTigerConfig();
+    const resolvedLocale = ref(
+      isLazyTigerLocale(props.locale) ? void 0 : getImmediateTigerLocale(props.locale)
+    );
+    const localeLoading = ref(isLazyTigerLocale(props.locale));
+    let loadId = 0;
+    watch(
+      () => props.locale,
+      (locale) => {
+        if (!isLazyTigerLocale(locale)) {
+          resolvedLocale.value = getImmediateTigerLocale(locale);
+          localeLoading.value = false;
+          return;
+        }
+        const thisId = ++loadId;
+        localeLoading.value = true;
+        resolveTigerLocale(locale).then(
+          (result) => {
+            if (thisId === loadId) {
+              resolvedLocale.value = result;
+              localeLoading.value = false;
+            }
+          },
+          () => {
+            if (thisId === loadId) {
+              localeLoading.value = false;
+            }
+          }
+        );
+      },
+      { immediate: true }
+    );
+    const merged = computed(() => {
+      return {
+        locale: mergeTigerLocale(parent.value.locale, resolvedLocale.value),
+        localeLoading: localeLoading.value || parent.value.localeLoading,
+        direction: props.direction ?? resolvedLocale.value?.direction ?? parent.value.direction ?? (resolvedLocale.value?.locale ? getLocaleDirection(resolvedLocale.value) : void 0),
+        theme: props.theme ?? parent.value.theme,
+        colorScheme: props.colorScheme ?? parent.value.colorScheme
+      };
+    });
+    watch(
+      () => merged.value.theme,
+      (name) => {
+        if (name) ThemeManager.setTheme(name);
+      },
+      { immediate: true }
+    );
+    watch(
+      () => merged.value.colorScheme,
+      (scheme) => {
+        if (scheme) ThemeManager.setColorScheme(scheme);
+      },
+      { immediate: true }
+    );
+    let previousDir = null;
+    let previousDataDir = null;
+    watch(
+      () => merged.value.direction,
+      (direction) => {
+        if (!direction || typeof document === "undefined") return;
+        const root = document.documentElement;
+        if (previousDir === null && previousDataDir === null) {
+          previousDir = root.getAttribute("dir");
+          previousDataDir = root.getAttribute("data-tiger-dir");
+        }
+        root.setAttribute("dir", direction);
+        root.setAttribute("data-tiger-dir", direction);
+      },
+      { immediate: true }
+    );
+    onBeforeUnmount(() => {
+      if (typeof document === "undefined") return;
+      const root = document.documentElement;
+      if (previousDir === null) root.removeAttribute("dir");
+      else root.setAttribute("dir", previousDir);
+      if (previousDataDir === null) root.removeAttribute("data-tiger-dir");
+      else root.setAttribute("data-tiger-dir", previousDataDir);
+    });
+    provide(TigerConfigKey, merged);
+    return () => slots.default?.();
+  }
+});
+var ConfigProvider_default = ConfigProvider;
+
+export {
+  TigerConfigKey,
+  useTigerConfig,
+  configProviderProps,
+  ConfigProvider,
+  ConfigProvider_default
+};

package/dist/chunk-VIIGYWUY.mjs

@@ -1,7 +1,11 @@
-import { defineComponent, provide, computed, h, inject } from 'vue';
-import { classNames, getInputGroupClasses, coerceClassValue, getInputGroupAddonClasses } from '@expcat/tigercat-core';
-
 // src/components/InputGroup.ts
+import { defineComponent, h, provide, inject, computed } from "vue";
+import {
+  classNames,
+  coerceClassValue,
+  getInputGroupClasses,
+  getInputGroupAddonClasses
+} from "@expcat/tigercat-core";
 var INPUT_GROUP_INJECTION_KEY = /* @__PURE__ */ Symbol("TigerInputGroup");
 var InputGroup = defineComponent({
   name: "TigerInputGroup",
@@ -80,4 +84,9 @@ var InputGroupAddon = defineComponent({
 });
 var InputGroup_default = InputGroup;
 
-export { INPUT_GROUP_INJECTION_KEY, InputGroup, InputGroupAddon, InputGroup_default };
+export {
+  INPUT_GROUP_INJECTION_KEY,
+  InputGroup,
+  InputGroupAddon,
+  InputGroup_default
+};