@expcat/tigercat-vue 1.0.7 → 1.2.0

package/dist/chunk-4YHOD7LT.mjs

@@ -1,7 +1,13 @@
-import { defineComponent, computed, h } from 'vue';
-import { classNames, linkBaseClasses, getLinkVariantClasses, linkSizeClasses, linkDisabledClasses, getSecureRel } from '@expcat/tigercat-core';
-
 // src/components/Link.ts
+import { defineComponent, computed, h } from "vue";
+import {
+  classNames,
+  getLinkVariantClasses,
+  getSecureRel,
+  linkBaseClasses,
+  linkDisabledClasses,
+  linkSizeClasses
+} from "@expcat/tigercat-core";
 var Link = defineComponent({
   name: "TigerLink",
   props: {
@@ -79,4 +85,7 @@ var Link = defineComponent({
 });
 var Link_default = Link;
 
-export { Link, Link_default };
+export {
+  Link,
+  Link_default
+};

package/dist/chunk-5436FG3B.js

@@ -0,0 +1,136 @@
+"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; }// src/components/Button.ts
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var createLoadingSpinner = () => {
+  const spinnerSvg = _tigercatcore.getSpinnerSVG.call(void 0, "spinner");
+  return _vue.h.call(void 0, 
+    "svg",
+    {
+      class: "animate-spin h-4 w-4",
+      xmlns: "http://www.w3.org/2000/svg",
+      fill: "none",
+      viewBox: spinnerSvg.viewBox,
+      "aria-hidden": "true",
+      focusable: "false"
+    },
+    spinnerSvg.elements.map((el) => _vue.h.call(void 0, el.type, _tigercatcore.normalizeSvgAttrs.call(void 0, el.attrs)))
+  );
+};
+var Button = _vue.defineComponent.call(void 0, {
+  name: "TigerButton",
+  inheritAttrs: false,
+  props: {
+    /**
+     * Button variant style
+     * @default 'primary'
+     */
+    variant: {
+      type: String,
+      default: "primary"
+    },
+    /**
+     * Button size
+     * @default 'md'
+     */
+    size: {
+      type: String,
+      default: "md"
+    },
+    /**
+     * Whether the button is disabled
+     */
+    disabled: Boolean,
+    /**
+     * Whether the button is in loading state
+     */
+    loading: Boolean,
+    /**
+     * Whether the button should take full width of its parent
+     */
+    block: Boolean,
+    /**
+     * Icon position relative to button text
+     * @default 'left'
+     */
+    iconPosition: {
+      type: String,
+      default: "left"
+    },
+    /**
+     * HTML button type
+     * @default 'button'
+     */
+    htmlType: {
+      type: String,
+      default: "button"
+    },
+    /**
+     * Whether to apply danger/destructive styling
+     */
+    danger: Boolean,
+    className: {
+      type: String,
+      default: void 0
+    },
+    style: {
+      type: Object,
+      default: void 0
+    }
+  },
+  emits: ["click"],
+  setup(props, { slots, emit, attrs }) {
+    const buttonClasses = _vue.computed.call(void 0, () => {
+      const variantClasses = props.danger ? _nullishCoalesce(_tigercatcore.buttonDangerClasses[props.variant], () => ( _tigercatcore.buttonDangerClasses.primary)) : _tigercatcore.getButtonVariantClasses.call(void 0, props.variant);
+      return _tigercatcore.composeComponentClasses.call(void 0, 
+        _tigercatcore.buttonBaseClasses,
+        variantClasses,
+        _tigercatcore.buttonSizeClasses[props.size],
+        (props.disabled || props.loading) && _tigercatcore.buttonDisabledClasses,
+        props.block && "w-full",
+        props.className,
+        attrs.class
+      );
+    });
+    const mergedStyle = _vue.computed.call(void 0, () => _tigercatcore.mergeStyleValues.call(void 0, attrs.style, props.style));
+    return () => {
+      const isDisabled = props.disabled || props.loading;
+      const iconIsRight = props.iconPosition === "right";
+      const loadingNode = props.loading ? _vue.h.call(void 0, 
+        "span",
+        { class: iconIsRight ? "ml-2 order-1" : "mr-2" },
+        slots["loading-icon"] ? slots["loading-icon"]() : createLoadingSpinner()
+      ) : null;
+      const iconNode = !props.loading && slots.icon ? _vue.h.call(void 0, "span", { class: iconIsRight ? "ml-2 order-1" : "mr-2" }, slots.icon()) : null;
+      return _vue.h.call(void 0, 
+        "button",
+        {
+          ...attrs,
+          class: buttonClasses.value,
+          style: mergedStyle.value,
+          "aria-busy": _nullishCoalesce(attrs["aria-busy"], () => ( (props.loading ? "true" : void 0))),
+          "aria-disabled": _nullishCoalesce(attrs["aria-disabled"], () => ( (isDisabled ? "true" : void 0))),
+          disabled: isDisabled,
+          type: props.htmlType,
+          onClick: isDisabled ? void 0 : (event) => emit("click", event)
+        },
+        [loadingNode, iconNode, _optionalChain([slots, 'access', _ => _.default, 'optionalCall', _2 => _2()])]
+      );
+    };
+  }
+});
+var Button_default = Button;
+
+
+
+
+exports.Button = Button; exports.Button_default = Button_default;

package/dist/chunk-54VVFMYI.js

@@ -1,10 +1,7 @@
-'use strict';
-
-var vue = require('vue');
-var tigercatCore = require('@expcat/tigercat-core');
-
-// src/components/Container.ts
-var Container = vue.defineComponent({
+"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/Container.ts
+var _vue = require('vue');
+var _tigercatcore = require('@expcat/tigercat-core');
+var Container = _vue.defineComponent.call(void 0, {
   name: "TigerContainer",
   inheritAttrs: false,
   props: {
@@ -42,8 +39,8 @@ var Container = vue.defineComponent({
     }
   },
   setup(props, { slots, attrs }) {
-    const containerClasses = vue.computed(
-      () => tigercatCore.getContainerClasses({
+    const containerClasses = _vue.computed.call(void 0, 
+      () => _tigercatcore.getContainerClasses.call(void 0, {
         maxWidth: props.maxWidth,
         center: props.center,
         padding: props.padding
@@ -51,20 +48,22 @@ var Container = vue.defineComponent({
     );
     return () => {
       const { class: attrsClass, style: attrsStyle, ...restAttrs } = attrs;
-      const tag = vue.resolveDynamicComponent(props.as);
-      return vue.h(
+      const tag = _vue.resolveDynamicComponent.call(void 0, props.as);
+      return _vue.h.call(void 0, 
         tag,
         {
           ...restAttrs,
           class: [containerClasses.value, attrsClass],
           style: attrsStyle
         },
-        slots.default?.()
+        _optionalChain([slots, 'access', _ => _.default, 'optionalCall', _2 => _2()])
       );
     };
   }
 });
 var Container_default = Container;
 
-exports.Container = Container;
-exports.Container_default = Container_default;
+
+
+
+exports.Container = Container; exports.Container_default = Container_default;

package/dist/chunk-57MJTNDL.js

@@ -1,10 +1,13 @@
-'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; }// src/components/ChartGrid.ts
+var _vue = require('vue');
 
-var vue = require('vue');
-var tigercatCore = require('@expcat/tigercat-core');
 
-// src/components/ChartGrid.ts
-var ChartGrid = vue.defineComponent({
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var ChartGrid = _vue.defineComponent.call(void 0, {
   name: "TigerChartGrid",
   inheritAttrs: false,
   props: {
@@ -53,37 +56,37 @@ var ChartGrid = vue.defineComponent({
     }
   },
   setup(props, { attrs }) {
-    const dasharray = vue.computed(() => tigercatCore.getChartGridLineDasharray(props.lineStyle));
-    const xTicks = vue.computed(() => {
+    const dasharray = _vue.computed.call(void 0, () => _tigercatcore.getChartGridLineDasharray.call(void 0, props.lineStyle));
+    const xTicks = _vue.computed.call(void 0, () => {
       if (!props.xScale) return [];
-      return tigercatCore.getChartAxisTicks(props.xScale, {
+      return _tigercatcore.getChartAxisTicks.call(void 0, props.xScale, {
         tickCount: props.xTicks,
         tickValues: props.xTickValues
       });
     });
-    const yTicks = vue.computed(() => {
+    const yTicks = _vue.computed.call(void 0, () => {
       if (!props.yScale) return [];
-      return tigercatCore.getChartAxisTicks(props.yScale, {
+      return _tigercatcore.getChartAxisTicks.call(void 0, props.yScale, {
         tickCount: props.yTicks,
         tickValues: props.yTickValues
       });
     });
-    const gridClasses = vue.computed(() => tigercatCore.classNames(tigercatCore.coerceClassValue(attrs.class), props.className));
+    const gridClasses = _vue.computed.call(void 0, () => _tigercatcore.classNames.call(void 0, _tigercatcore.coerceClassValue.call(void 0, attrs.class), props.className));
     return () => {
       const shouldRenderX = props.show === "both" || props.show === "x";
       const shouldRenderY = props.show === "both" || props.show === "y";
-      const xRange = props.xScale?.range;
-      const yRange = props.yScale?.range;
+      const xRange = _optionalChain([props, 'access', _ => _.xScale, 'optionalAccess', _2 => _2.range]);
+      const yRange = _optionalChain([props, 'access', _3 => _3.yScale, 'optionalAccess', _4 => _4.range]);
       const lines = [];
       if (shouldRenderX && props.xScale && yRange) {
         xTicks.value.forEach((tick) => {
           lines.push(
-            vue.h("line", {
+            _vue.h.call(void 0, "line", {
               x1: tick.position,
               y1: yRange[0],
               x2: tick.position,
               y2: yRange[1],
-              class: tigercatCore.chartGridLineClasses,
+              class: _tigercatcore.chartGridLineClasses,
               "stroke-width": props.strokeWidth,
               "stroke-dasharray": dasharray.value
             })
@@ -93,19 +96,19 @@ var ChartGrid = vue.defineComponent({
       if (shouldRenderY && props.yScale && xRange) {
         yTicks.value.forEach((tick) => {
           lines.push(
-            vue.h("line", {
+            _vue.h.call(void 0, "line", {
               x1: xRange[0],
               y1: tick.position,
               x2: xRange[1],
               y2: tick.position,
-              class: tigercatCore.chartGridLineClasses,
+              class: _tigercatcore.chartGridLineClasses,
               "stroke-width": props.strokeWidth,
               "stroke-dasharray": dasharray.value
             })
           );
         });
       }
-      return vue.h(
+      return _vue.h.call(void 0, 
         "g",
         {
           ...attrs,
@@ -119,5 +122,7 @@ var ChartGrid = vue.defineComponent({
 });
 var ChartGrid_default = ChartGrid;
 
-exports.ChartGrid = ChartGrid;
-exports.ChartGrid_default = ChartGrid_default;
+
+
+
+exports.ChartGrid = ChartGrid; exports.ChartGrid_default = ChartGrid_default;

package/dist/{chunk-JGUXQMYL.mjs → chunk-5D2UAWWP.mjs}

@@ -1,10 +1,42 @@
-import { createStatusIcon } from './chunk-2TNZ4JNT.mjs';
-import { defineComponent, ref, computed, h, Teleport, TransitionGroup, createApp } from 'vue';
-import { classNames, notificationContainerBaseClasses, notificationPositionClasses, coerceClassValue, getNotificationTypeClasses, notificationBaseClasses, getNotificationIconPath, notificationIconClasses, notificationTitleClasses, notificationDescriptionClasses, notificationContentClasses, notificationCloseButtonClasses, notificationCloseIconPath, notificationCloseIconClasses, isBrowser, normalizeStringOption } from '@expcat/tigercat-core';
+import {
+  createStatusIcon
+} from "./chunk-2TNZ4JNT.mjs";
 
+// src/components/Notification.ts
+import {
+  createApp,
+  computed,
+  defineComponent,
+  h,
+  ref,
+  Teleport,
+  TransitionGroup
+} from "vue";
+import {
+  classNames,
+  coerceClassValue,
+  getNotificationIconPath,
+  getNotificationTypeClasses,
+  notificationBaseClasses,
+  notificationCloseButtonClasses,
+  notificationCloseIconClasses,
+  notificationCloseIconPath,
+  notificationContainerBaseClasses,
+  notificationContentClasses,
+  notificationDescriptionClasses,
+  notificationIconClasses,
+  notificationPositionClasses,
+  notificationTitleClasses,
+  createNotificationStackUpdateScheduler,
+  normalizeStringOption,
+  isBrowser
+} from "@expcat/tigercat-core";
 var NOTIFICATION_CONTAINER_ID_PREFIX = "tiger-notification-container";
 var NOTIFICATION_CLOSE_ARIA_LABEL = "Close notification";
-var IS_TEST_ENV = typeof process !== "undefined" && process.env?.NODE_ENV === "test";
+var IS_TEST_ENV = (() => {
+  const proc = globalThis.process;
+  return typeof proc !== "undefined" && proc.env?.NODE_ENV === "test";
+})();
 var notificationInstancesByPosition = {
   "top-left": [],
   "top-right": [],
@@ -24,6 +56,12 @@ var updateCallbacks = {
   "bottom-left": null,
   "bottom-right": null
 };
+var stackUpdateScheduler = createNotificationStackUpdateScheduler();
+function scheduleNotificationStackUpdate(position) {
+  const callback = updateCallbacks[position];
+  if (!callback) return;
+  stackUpdateScheduler.schedule(position, callback);
+}
 function getNextInstanceId() {
   return ++instanceIdCounter;
 }
@@ -102,7 +140,10 @@ var NotificationContainer = defineComponent({
               "aria-label": NOTIFICATION_CLOSE_ARIA_LABEL,
               type: "button"
             },
-            createStatusIcon(notificationCloseIconPath, notificationCloseIconClasses, { "aria-hidden": "true", focusable: "false" })
+            createStatusIcon(notificationCloseIconPath, notificationCloseIconClasses, {
+              "aria-hidden": "true",
+              focusable: "false"
+            })
           )
         );
       }
@@ -168,6 +209,7 @@ function ensureContainer(position) {
   if (containerApps[position] && !existingRootEl) {
     containerApps[position] = null;
     updateCallbacks[position] = null;
+    stackUpdateScheduler.cancel(position);
   }
   if (containerApps[position]) {
     return;
@@ -188,6 +230,7 @@ function destroyContainer(position) {
     containerApps[position] = null;
   }
   updateCallbacks[position] = null;
+  stackUpdateScheduler.cancel(position);
   if (isBrowser()) {
     document.getElementById(rootId)?.remove();
   }
@@ -210,7 +253,7 @@ function addNotification(config) {
     position
   };
   notificationInstancesByPosition[position].push(instance);
-  updateCallbacks[position]?.();
+  scheduleNotificationStackUpdate(position);
   if (instance.duration > 0) {
     setTimeout(() => {
       removeNotification(id, position);
@@ -225,8 +268,10 @@ function removeNotification(id, position) {
     const instance = instances[index];
     instances.splice(index, 1);
     instance.onClose?.();
+    if (notificationInstancesByPosition[position].length > 0) {
+      scheduleNotificationStackUpdate(position);
+    }
   }
-  updateCallbacks[position]?.();
   if (notificationInstancesByPosition[position].length === 0) {
     destroyContainer(position);
   }
@@ -275,4 +320,8 @@ var notification = {
 };
 var Notification_default = notification;
 
-export { NotificationContainer, Notification_default, notification };
+export {
+  NotificationContainer,
+  notification,
+  Notification_default
+};

package/dist/chunk-5F6P5Y4K.js

@@ -0,0 +1,115 @@
+"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/VirtualList.ts
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var VirtualList = _vue.defineComponent.call(void 0, {
+  name: "TigerVirtualList",
+  props: {
+    itemCount: { type: Number, default: 0 },
+    itemHeight: { type: Number, default: 40 },
+    estimatedItemHeight: { type: Number, default: void 0 },
+    getItemHeight: {
+      type: Function,
+      default: void 0
+    },
+    sizeStrategy: {
+      type: Object,
+      default: void 0
+    },
+    height: { type: Number, default: 400 },
+    overscan: { type: Number, default: 5 }
+  },
+  emits: ["scroll"],
+  setup(props, { emit, attrs, slots }) {
+    const scrollTop = _vue.ref.call(void 0, 0);
+    const containerRef = _vue.ref.call(void 0, null);
+    const strategy = _vue.computed.call(void 0, () => {
+      if (props.sizeStrategy) return props.sizeStrategy;
+      if (props.getItemHeight) {
+        return _tigercatcore.variableSizeStrategy.call(void 0, props.getItemHeight, props.itemCount);
+      }
+      if (props.estimatedItemHeight !== void 0) {
+        return _tigercatcore.dynamicSizeStrategy.call(void 0, props.estimatedItemHeight, props.itemCount);
+      }
+      return _tigercatcore.fixedSizeStrategy.call(void 0, props.itemHeight);
+    });
+    const range = _vue.computed.call(void 0, 
+      () => strategy.value.getRange(scrollTop.value, props.height, props.itemCount, props.overscan)
+    );
+    function handleScroll() {
+      if (containerRef.value) {
+        scrollTop.value = containerRef.value.scrollTop;
+        emit("scroll", scrollTop.value);
+      }
+    }
+    return () => {
+      const { startIndex, endIndex, totalHeight } = range.value;
+      const currentStrategy = strategy.value;
+      const items = [];
+      for (let i = startIndex; i <= endIndex; i++) {
+        const itemH = currentStrategy.getItemHeight(i);
+        const slotContent = _optionalChain([slots, 'access', _ => _.default, 'optionalCall', _2 => _2({ index: i })]);
+        items.push(
+          _vue.h.call(void 0, 
+            "div",
+            {
+              key: i,
+              style: {
+                height: `${itemH}px`,
+                width: "100%"
+              }
+            },
+            slotContent
+          )
+        );
+      }
+      const offsetTop = startIndex >= 0 ? currentStrategy.getItemOffset(startIndex) : 0;
+      return _vue.h.call(void 0, 
+        "div",
+        {
+          ref: containerRef,
+          class: _tigercatcore.classNames.call(void 0, _tigercatcore.virtualListContainerClasses, _tigercatcore.coerceClassValue.call(void 0, attrs.class)),
+          style: { height: `${props.height}px` },
+          onScroll: handleScroll
+        },
+        [
+          _vue.h.call(void 0, 
+            "div",
+            {
+              class: _tigercatcore.virtualListInnerClasses,
+              style: { height: `${totalHeight}px` }
+            },
+            [
+              _vue.h.call(void 0, 
+                "div",
+                {
+                  style: {
+                    transform: `translateY(${offsetTop}px)`,
+                    position: "absolute",
+                    top: 0,
+                    left: 0,
+                    width: "100%"
+                  }
+                },
+                items
+              )
+            ]
+          )
+        ]
+      );
+    };
+  }
+});
+var VirtualList_default = VirtualList;
+
+
+
+
+exports.VirtualList = VirtualList; exports.VirtualList_default = VirtualList_default;

package/dist/chunk-5JKQPOG2.js

@@ -0,0 +1,133 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/components/NumberKeyboard.ts
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var NumberKeyboard = _vue.defineComponent.call(void 0, {
+  name: "TigerNumberKeyboard",
+  inheritAttrs: false,
+  props: {
+    modelValue: { type: String, default: void 0 },
+    defaultValue: { type: String, default: "" },
+    mode: { type: String, default: "number" },
+    maxLength: { type: Number, default: void 0 },
+    precision: { type: Number, default: void 0 },
+    decimalSeparator: { type: String, default: "." },
+    disabled: { type: Boolean, default: false },
+    readonly: { type: Boolean, default: false },
+    confirmText: { type: String, default: "Done" },
+    deleteText: { type: String, default: "Delete" },
+    ariaLabel: { type: String, default: "Number keyboard" },
+    showConfirm: { type: Boolean, default: true },
+    className: { type: String, default: void 0 },
+    style: {
+      type: Object,
+      default: void 0
+    }
+  },
+  emits: ["update:modelValue", "change", "key-press", "delete", "confirm"],
+  setup(props, { attrs, emit }) {
+    const innerValue = _vue.ref.call(void 0, _tigercatcore.normalizeNumberKeyboardValue.call(void 0, props.defaultValue));
+    const isControlled = _vue.computed.call(void 0, () => props.modelValue !== void 0);
+    const currentValue = _vue.computed.call(void 0, 
+      () => isControlled.value ? _tigercatcore.normalizeNumberKeyboardValue.call(void 0, props.modelValue) : innerValue.value
+    );
+    const isDisabled = _vue.computed.call(void 0, () => props.disabled || props.readonly);
+    const keys = _vue.computed.call(void 0, 
+      () => _tigercatcore.getNumberKeyboardKeys.call(void 0, {
+        mode: props.mode,
+        decimalSeparator: props.decimalSeparator,
+        deleteText: props.deleteText,
+        confirmText: props.confirmText,
+        showConfirm: props.showConfirm
+      })
+    );
+    function emitChange(nextValue, payload) {
+      if (!isControlled.value) innerValue.value = nextValue;
+      emit("update:modelValue", nextValue);
+      emit("change", nextValue, payload);
+    }
+    function handleKeyClick(key) {
+      if (isDisabled.value || key.type === "empty") return;
+      const action = _tigercatcore.getNumberKeyboardAction.call(void 0, key);
+      const nextValue = action === "delete" ? _tigercatcore.deleteNumberKeyboardValue.call(void 0, currentValue.value) : action === "input" ? _tigercatcore.applyNumberKeyboardInput.call(void 0, currentValue.value, key.value, {
+        mode: props.mode,
+        maxLength: props.maxLength,
+        precision: props.precision,
+        decimalSeparator: props.decimalSeparator
+      }) : currentValue.value;
+      const payload = {
+        value: nextValue,
+        key: key.value,
+        action,
+        mode: props.mode
+      };
+      emit("key-press", key, payload);
+      if (action === "confirm") {
+        emit("confirm", currentValue.value, { ...payload, value: currentValue.value });
+        return;
+      }
+      if (action === "delete") emit("delete", nextValue, payload);
+      if (nextValue !== currentValue.value) emitChange(nextValue, payload);
+    }
+    const rootClasses = _vue.computed.call(void 0, 
+      () => _tigercatcore.classNames.call(void 0, _tigercatcore.numberKeyboardRootClasses, props.className, _tigercatcore.coerceClassValue.call(void 0, attrs.class))
+    );
+    const rootStyle = _vue.computed.call(void 0, 
+      () => _tigercatcore.mergeStyleValues.call(void 0, props.style, attrs.style)
+    );
+    return () => {
+      const forwardedAttrs = Object.fromEntries(
+        Object.entries(attrs).filter(([key]) => key !== "class" && key !== "style")
+      );
+      return _vue.h.call(void 0, 
+        "div",
+        {
+          ...forwardedAttrs,
+          class: rootClasses.value,
+          style: rootStyle.value,
+          role: "group",
+          "aria-label": props.ariaLabel,
+          "aria-disabled": isDisabled.value || void 0
+        },
+        [
+          _vue.h.call(void 0, 
+            "div",
+            { class: _tigercatcore.numberKeyboardGridClasses },
+            keys.value.map(
+              (key, index) => _vue.h.call(void 0, 
+                "button",
+                {
+                  key: `${key.type}-${key.value}-${index}`,
+                  type: "button",
+                  class: _tigercatcore.getNumberKeyboardKeyClasses.call(void 0, key, isDisabled.value),
+                  disabled: isDisabled.value || key.disabled,
+                  "aria-label": key.ariaLabel,
+                  "data-key": key.value,
+                  onClick: () => handleKeyClick(key)
+                },
+                key.label
+              )
+            )
+          )
+        ]
+      );
+    };
+  }
+});
+var NumberKeyboard_default = NumberKeyboard;
+
+
+
+
+exports.NumberKeyboard = NumberKeyboard; exports.NumberKeyboard_default = NumberKeyboard_default;