@fangxinyan/lumina 0.6.18 → 0.7.0

package/dist/chunk-3F424R5P.js

@@ -0,0 +1,143 @@
+import { Icon } from './chunk-LQMOYVQF.js';
+import { useComponentThemeRootRef, ComponentThemeBoundary, mergeComponentRootStyleWithInstanceStyle } from './chunk-DRDDQCDD.js';
+import './tokens-CEJVVA3G.css';
+import './shared-NJHRNLRH.css';
+import './Textarea-ZGHBZNLX.css';
+import * as React from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/utils/inputEvents.ts
+function createValueOverrideTarget(element, value) {
+  if (!element) return { value };
+  return new Proxy(element, {
+    get(target, property) {
+      if (property === "value") return value;
+      const result = Reflect.get(target, property, target);
+      return typeof result === "function" ? result.bind(target) : result;
+    }
+  });
+}
+var TextareaBase = React.forwardRef(
+  ({
+    value,
+    defaultValue,
+    onChange,
+    onValueChange,
+    invalid,
+    allowClear,
+    maxLength,
+    showCount,
+    className = "",
+    theme,
+    style,
+    ...rest
+  }, ref) => {
+    const [inner, setInner] = React.useState(defaultValue ?? "");
+    const [themeRootElement, themeRootRef] = useComponentThemeRootRef(
+      void 0,
+      { component: "Textarea", theme }
+    );
+    const textareaRef = React.useRef(null);
+    const isControlled = value !== void 0;
+    const currentValue = isControlled ? value : inner;
+    const disabled = rest.disabled;
+    const handleChange = (e) => {
+      if (!isControlled) setInner(e.target.value);
+      onChange?.(e);
+      onValueChange?.(e.target.value, e);
+    };
+    const setTextareaRef = React.useCallback((node) => {
+      textareaRef.current = node;
+      if (typeof ref === "function") ref(node);
+      else if (ref) ref.current = node;
+    }, [ref]);
+    const handleClear = (e) => {
+      e.stopPropagation();
+      if (disabled) return;
+      if (!isControlled) setInner("");
+      if (!isControlled && textareaRef.current) textareaRef.current.value = "";
+      const clearedTarget = createValueOverrideTarget(textareaRef.current, "");
+      const synthetic = {
+        ...e,
+        type: "change",
+        target: clearedTarget,
+        currentTarget: clearedTarget
+      };
+      onChange?.(synthetic);
+      onValueChange?.("", synthetic);
+    };
+    const cls = ["textarea", invalid && "invalid", className].filter(Boolean).join(" ");
+    const showClear = !!allowClear && !!currentValue && !disabled;
+    const count = currentValue ? currentValue.length : 0;
+    return /* @__PURE__ */ jsx(
+      ComponentThemeBoundary,
+      {
+        component: "Textarea",
+        cssPrefix: "textarea",
+        theme,
+        rootElement: themeRootElement,
+        children: (themeState) => {
+          const mergedRootStyle = mergeComponentRootStyleWithInstanceStyle(
+            themeState.rootStyle,
+            style
+          );
+          const field = /* @__PURE__ */ jsxs(
+            "div",
+            {
+              ref: showCount ? void 0 : themeRootRef,
+              className: "textarea-wrap",
+              ...!showCount ? themeState.rootDataAttributes : null,
+              style: showCount ? themeState.styles.control : mergedRootStyle,
+              children: [
+                /* @__PURE__ */ jsx(
+                  "textarea",
+                  {
+                    ref: setTextareaRef,
+                    className: cls,
+                    value: isControlled ? value : void 0,
+                    defaultValue: isControlled ? void 0 : defaultValue,
+                    onChange: handleChange,
+                    maxLength,
+                    ...rest,
+                    style: { ...themeState.styles.input, ...style }
+                  }
+                ),
+                showClear && /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    className: "textarea-clear",
+                    role: "button",
+                    "aria-label": "Clear",
+                    onMouseDown: (e) => e.preventDefault(),
+                    onClick: handleClear,
+                    children: /* @__PURE__ */ jsx(Icon, { name: "x", size: 12 })
+                  }
+                )
+              ]
+            }
+          );
+          if (!showCount) return field;
+          return /* @__PURE__ */ jsxs(
+            "div",
+            {
+              ref: themeRootRef,
+              className: "textarea-shell",
+              ...themeState.rootDataAttributes,
+              style: mergedRootStyle,
+              children: [
+                field,
+                /* @__PURE__ */ jsx("div", { className: "textarea-count", style: themeState.styles.count, children: maxLength != null ? `${count} / ${maxLength}` : `${count}` })
+              ]
+            }
+          );
+        }
+      }
+    );
+  }
+);
+TextareaBase.displayName = "Textarea";
+var Textarea = TextareaBase;
+var TextArea = Textarea;
+
+export { TextArea, Textarea, createValueOverrideTarget };

package/dist/chunk-3IZZBM56.js

@@ -0,0 +1,269 @@
+import { useOverlayZIndex, useOverlayLayer } from './chunk-2A4GYSN4.js';
+import { useComponentPortalTheme, withComponentTheme } from './chunk-DRDDQCDD.js';
+import { usePortalContainer } from './chunk-ULTDRMGN.js';
+import './tokens-CEJVVA3G.css';
+import './shared-NJHRNLRH.css';
+import './ContextMenu-NG524Y2P.css';
+import * as React from 'react';
+import ReactDOM from 'react-dom';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+var ESTIMATED_ITEM_H = 32;
+var MARGIN = 8;
+var KEYBOARD_TRIGGER_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "[tabindex]:not([tabindex='-1'])",
+  "[contenteditable='true']"
+].join(",");
+var ContextMenuBase = React.forwardRef((props, ref) => {
+  const hasExplicitMinWidth = props.minWidth !== void 0;
+  const {
+    items,
+    children,
+    disabled,
+    minWidth = 180,
+    className = "",
+    style,
+    onContextMenu,
+    onKeyDown,
+    tabIndex,
+    ...rest
+  } = props;
+  const portalContainer = usePortalContainer();
+  const portalTheme = useComponentPortalTheme("ContextMenu");
+  const [open, setOpen] = React.useState(false);
+  const [pos, setPos] = React.useState({ top: 0, left: 0 });
+  const [active, setActive] = React.useState(-1);
+  const [useWrapperKeyboardFallback, setUseWrapperKeyboardFallback] = React.useState(false);
+  const menuRef = React.useRef(null);
+  const triggerRef = React.useRef(null);
+  const returnFocusRef = React.useRef(null);
+  const overlayZIndex = useOverlayZIndex(open);
+  const isSelectable = React.useCallback(
+    (i) => i.type !== "divider" && !i.disabled,
+    []
+  );
+  const close = React.useCallback(() => setOpen(false), []);
+  const closeAndRestoreFocus = React.useCallback(() => {
+    close();
+    window.requestAnimationFrame(() => {
+      if (returnFocusRef.current?.isConnected) returnFocusRef.current.focus();
+    });
+  }, [close]);
+  React.useEffect(() => {
+    if (disabled && open) closeAndRestoreFocus();
+  }, [closeAndRestoreFocus, disabled, open]);
+  useOverlayLayer({
+    open: open && portalContainer != null,
+    containerRef: menuRef,
+    ownerRef: triggerRef,
+    zIndex: overlayZIndex,
+    onEscape: closeAndRestoreFocus
+  });
+  React.useLayoutEffect(() => {
+    const wrapper = triggerRef.current;
+    if (!wrapper || disabled) {
+      setUseWrapperKeyboardFallback(false);
+      return;
+    }
+    if (wrapper.querySelector(KEYBOARD_TRIGGER_SELECTOR)) {
+      setUseWrapperKeyboardFallback(false);
+      return;
+    }
+    const HTMLElementConstructor = wrapper.ownerDocument.defaultView?.HTMLElement;
+    const candidate = Array.from(wrapper.children).find(
+      (child) => !!HTMLElementConstructor && child instanceof HTMLElementConstructor && !child.hasAttribute("tabindex") && !child.matches("button:disabled,input:disabled,select:disabled,textarea:disabled")
+    );
+    if (!candidate) {
+      setUseWrapperKeyboardFallback(true);
+      return;
+    }
+    setUseWrapperKeyboardFallback(false);
+    candidate.setAttribute("tabindex", "0");
+    return () => {
+      if (candidate.getAttribute("tabindex") === "0") candidate.removeAttribute("tabindex");
+    };
+  }, [children, disabled]);
+  const openAt = (clientX, clientY) => {
+    returnFocusRef.current = document.activeElement;
+    const vw = window.innerWidth;
+    const vh = window.innerHeight;
+    const estH = Math.min(items.length * ESTIMATED_ITEM_H + 16, vh - MARGIN * 2);
+    const estW = minWidth;
+    const left = Math.min(clientX, vw - estW - MARGIN);
+    const top = Math.min(clientY, vh - estH - MARGIN);
+    setPos({ top: Math.max(MARGIN, top), left: Math.max(MARGIN, left) });
+    const firstIdx = items.findIndex(isSelectable);
+    setActive(firstIdx);
+    setOpen(true);
+  };
+  React.useEffect(() => {
+    if (!open) return;
+    const onOutside = (e) => {
+      if (!menuRef.current?.contains(e.target)) close();
+    };
+    const onBlur = () => close();
+    window.addEventListener("mousedown", onOutside);
+    window.addEventListener("scroll", close, true);
+    window.addEventListener("resize", close);
+    window.addEventListener("blur", onBlur);
+    return () => {
+      window.removeEventListener("mousedown", onOutside);
+      window.removeEventListener("scroll", close, true);
+      window.removeEventListener("resize", close);
+      window.removeEventListener("blur", onBlur);
+    };
+  }, [open, close]);
+  React.useEffect(() => {
+    if (!open || active < 0) return;
+    const frame = window.requestAnimationFrame(() => {
+      menuRef.current?.querySelector(`[data-context-index="${active}"]`)?.focus();
+    });
+    return () => window.cancelAnimationFrame(frame);
+  }, [open, active]);
+  React.useLayoutEffect(() => {
+    if (!open || !menuRef.current) return;
+    const rect = menuRef.current.getBoundingClientRect();
+    const vw = window.innerWidth;
+    const vh = window.innerHeight;
+    setPos((p) => ({
+      top: Math.min(p.top, Math.max(MARGIN, vh - rect.height - MARGIN)),
+      left: Math.min(p.left, Math.max(MARGIN, vw - rect.width - MARGIN))
+    }));
+  }, [open]);
+  const handleTriggerContextMenu = (e) => {
+    if (disabled || e.defaultPrevented) return;
+    e.preventDefault();
+    openAt(e.clientX, e.clientY);
+  };
+  const handleMenuKeyDown = (e) => {
+    if (e.key === "Tab") {
+      close();
+      return;
+    }
+    if (e.key === "ArrowDown" || e.key === "ArrowUp") {
+      e.preventDefault();
+      setActive((current) => {
+        const direction = e.key === "ArrowDown" ? 1 : -1;
+        let index = current;
+        for (let count = 0; count < items.length; count += 1) {
+          index = (index + direction + items.length) % items.length;
+          if (isSelectable(items[index])) return index;
+        }
+        return current;
+      });
+      return;
+    }
+    if (e.key === "Home" || e.key === "End") {
+      e.preventDefault();
+      const indexes = items.map((item, index) => ({ item, index })).filter(({ item }) => isSelectable(item));
+      const target = e.key === "Home" ? indexes[0] : indexes[indexes.length - 1];
+      if (target) setActive(target.index);
+      return;
+    }
+    if (e.key === "Enter") {
+      const item = items[active];
+      if (!disabled && item && isSelectable(item)) {
+        e.preventDefault();
+        item.onSelect?.();
+        closeAndRestoreFocus();
+      }
+    }
+  };
+  const trigger = /* @__PURE__ */ jsx(
+    "span",
+    {
+      ref: (node) => {
+        triggerRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      className,
+      tabIndex: tabIndex ?? (useWrapperKeyboardFallback && !disabled ? 0 : void 0),
+      style: { display: useWrapperKeyboardFallback || tabIndex != null ? "inline-block" : "contents", ...style },
+      onContextMenu: (e) => {
+        onContextMenu?.(e);
+        handleTriggerContextMenu(e);
+      },
+      onKeyDown: (e) => {
+        onKeyDown?.(e);
+        if (e.defaultPrevented) return;
+        if (e.key === "ContextMenu" || e.shiftKey && e.key === "F10") {
+          e.preventDefault();
+          const target = e.target;
+          const rect = target.getBoundingClientRect();
+          openAt(rect.left + Math.min(12, rect.width / 2), rect.bottom);
+        }
+      },
+      ...rest,
+      children
+    }
+  );
+  const panel = open && portalContainer ? ReactDOM.createPortal(
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: menuRef,
+        className: "context-menu",
+        role: "menu",
+        "aria-label": "\u4E0A\u4E0B\u6587\u83DC\u5355",
+        tabIndex: -1,
+        onKeyDown: handleMenuKeyDown,
+        ...portalTheme.dataAttributes,
+        style: {
+          position: "fixed",
+          top: pos.top,
+          left: pos.left,
+          ...portalTheme.style,
+          minWidth,
+          ...portalTheme.styles.popup,
+          ...hasExplicitMinWidth ? { minWidth } : null,
+          zIndex: overlayZIndex
+        },
+        onContextMenu: (e) => e.preventDefault(),
+        children: items.map(
+          (it, i) => it.type === "divider" ? /* @__PURE__ */ jsx("div", { className: "context-menu-divider", role: "separator" }, it.key) : /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              role: "menuitem",
+              "data-context-index": i,
+              tabIndex: active === i ? 0 : -1,
+              disabled: it.disabled,
+              className: `context-menu-item ${active === i ? "active" : ""} ${it.danger ? "danger" : ""}`,
+              onMouseEnter: () => isSelectable(it) && setActive(i),
+              onClick: () => {
+                if (disabled || !isSelectable(it)) return;
+                it.onSelect?.();
+                closeAndRestoreFocus();
+              },
+              children: [
+                /* @__PURE__ */ jsx("span", { className: "context-menu-icon", children: it.icon }),
+                /* @__PURE__ */ jsx("span", { className: "context-menu-label", children: it.label }),
+                it.shortcut && /* @__PURE__ */ jsx("span", { className: "context-menu-shortcut", children: it.shortcut })
+              ]
+            },
+            it.key
+          )
+        )
+      }
+    ),
+    portalContainer
+  ) : null;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    trigger,
+    panel
+  ] });
+});
+ContextMenuBase.displayName = "ContextMenu";
+var ContextMenu = withComponentTheme(
+  ContextMenuBase,
+  "ContextMenu",
+  "context-menu"
+);
+
+export { ContextMenu };

package/dist/{chunk-DUFRASGO.js → chunk-3QXP2ZNP.js}

@@ -1,6 +1,7 @@
+import { useOverlayZIndex } from './chunk-2A4GYSN4.js';
 import * as React from 'react';
 
-// src/utils/useFloating.ts
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? React.useLayoutEffect : React.useEffect;
 function useFloating(opts) {
   const triggerRef = React.useRef(null);
   const floatingRef = React.useRef(null);
@@ -13,8 +14,9 @@ function useFloating(opts) {
   const matchW = !!opts.matchTriggerWidth;
   const align = opts.alignCross ?? "start";
   const open = opts.open;
+  const zIndex = useOverlayZIndex(open);
   const [state, setState] = React.useState({ top: 0, left: 0, placement: preferred });
-  React.useLayoutEffect(() => {
+  useIsomorphicLayoutEffect(() => {
     if (!open) return;
     const update = () => {
       const el = triggerRef.current;
@@ -64,18 +66,16 @@ function useFloating(opts) {
           coords = altCoords;
         }
       }
-      if (align !== "start") {
-        if (resolved === "top" || resolved === "bottom") {
-          coords.left = align === "center" ? rect.left + rect.width / 2 : rect.right;
-        } else {
-          coords.top = align === "center" ? rect.top + rect.height / 2 : rect.bottom;
-        }
-      } else if (doShift) {
-        if (resolved === "bottom" || resolved === "top") {
-          coords.left = Math.max(MARGIN, Math.min(coords.left, vw - w - MARGIN));
-        } else {
-          coords.top = Math.max(MARGIN, Math.min(coords.top, vh - h - MARGIN));
-        }
+      if (resolved === "top" || resolved === "bottom") {
+        if (align === "center") coords.left = rect.left + (rect.width - w) / 2;
+        if (align === "end") coords.left = rect.right - w;
+      } else {
+        if (align === "center") coords.top = rect.top + (rect.height - h) / 2;
+        if (align === "end") coords.top = rect.bottom - h;
+      }
+      if (doShift) {
+        coords.left = Math.max(MARGIN, Math.min(coords.left, Math.max(MARGIN, vw - w - MARGIN)));
+        coords.top = Math.max(MARGIN, Math.min(coords.top, Math.max(MARGIN, vh - h - MARGIN)));
       }
       setState({
         top: coords.top,
@@ -98,24 +98,19 @@ function useFloating(opts) {
       ro?.disconnect();
     };
   }, [open, preferred, gap, panelW, panelH, doShift, doFlip, matchW, align]);
-  let transform;
-  if (align !== "start") {
-    const cross = state.placement === "top" || state.placement === "bottom" ? "X" : "Y";
-    const percent = align === "center" ? "-50%" : "-100%";
-    transform = `translate${cross}(${percent})`;
-  }
   const floatingStyle = {
     position: "fixed",
     top: state.top,
     left: state.left,
-    ...state.width != null ? { width: state.width } : {},
-    ...transform ? { transform } : {}
+    zIndex,
+    ...state.width != null ? { width: state.width } : {}
   };
   return {
     triggerRef,
     floatingRef,
     floatingStyle,
-    placement: state.placement
+    placement: state.placement,
+    zIndex
   };
 }
 

package/dist/{chunk-5QEI7GGA.cjs → chunk-434Y2JVW.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunkVS3I5OKA_cjs = require('./chunk-VS3I5OKA.cjs');
-var chunkQMX67CVT_cjs = require('./chunk-QMX67CVT.cjs');
-require('./tokens-RYJ3DFTU.css');
+var chunkSTQDKMS5_cjs = require('./chunk-STQDKMS5.cjs');
+var chunk2AUXUZ3Z_cjs = require('./chunk-2AUXUZ3Z.cjs');
+require('./tokens-CEJVVA3G.css');
 require('./shared-NJHRNLRH.css');
-require('./InputNumber-VXQIWLQC.css');
+require('./InputNumber-6NHBMRT4.css');
 var React = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 
@@ -28,6 +28,11 @@ function _interopNamespace(e) {
 
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
+var normalizeNumber = (value, min, max, precision) => {
+  const clamped = Math.max(min, Math.min(max, value));
+  return precision != null ? Number(clamped.toFixed(precision)) : clamped;
+};
+var normalizePrecision = (precision) => precision != null && Number.isFinite(precision) ? Math.max(0, Math.min(100, Math.trunc(precision))) : void 0;
 var InputNumber = React__namespace.forwardRef(
   ({
     value,
@@ -35,6 +40,8 @@ var InputNumber = React__namespace.forwardRef(
     onChange,
     onBlur,
     onFocus,
+    onWheel,
+    onKeyDown,
     onPressEnter,
     min = -Infinity,
     max = Infinity,
@@ -51,22 +58,31 @@ var InputNumber = React__namespace.forwardRef(
     suffix,
     autoFocus,
     id,
-    name
+    name,
+    theme,
+    ...rest
   }, ref) => {
-    const [inner, setInner] = React__namespace.useState(defaultValue ?? null);
+    const normalizedMin = Number.isFinite(min) ? min : -Infinity;
+    const normalizedMaxCandidate = Number.isFinite(max) ? max : Infinity;
+    const normalizedMax = Math.max(normalizedMin, normalizedMaxCandidate);
+    const normalizedStep = Number.isFinite(step) && step > 0 ? step : 1;
+    const normalizedPrecision = normalizePrecision(precision);
+    const [inner, setInner] = React__namespace.useState(
+      () => defaultValue == null || !Number.isFinite(defaultValue) ? null : normalizeNumber(defaultValue, normalizedMin, normalizedMax, normalizedPrecision)
+    );
     const isControlled = value !== void 0;
-    const current = isControlled ? value : inner;
+    const current = isControlled ? typeof value === "number" && Number.isFinite(value) ? normalizeNumber(value, normalizedMin, normalizedMax, normalizedPrecision) : null : inner;
     const [text, setText] = React__namespace.useState(current == null ? "" : String(current));
     React__namespace.useEffect(() => {
-      if (isControlled) setText(value == null ? "" : String(value));
-    }, [value, isControlled]);
+      if (isControlled) setText(current == null ? "" : String(current));
+    }, [current, isControlled]);
     const clamp = React__namespace.useCallback(
-      (n) => Math.max(min, Math.min(max, n)),
-      [min, max]
+      (n) => Math.max(normalizedMin, Math.min(normalizedMax, n)),
+      [normalizedMax, normalizedMin]
     );
     const round = React__namespace.useCallback(
-      (n) => precision != null ? Number(n.toFixed(precision)) : n,
-      [precision]
+      (n) => normalizedPrecision != null ? Number(n.toFixed(normalizedPrecision)) : n,
+      [normalizedPrecision]
     );
     const commit = (next) => {
       if (!isControlled) setInner(next);
@@ -79,7 +95,7 @@ var InputNumber = React__namespace.forwardRef(
         return;
       }
       const parsed = Number(v);
-      if (!Number.isNaN(parsed)) commit(clamp(round(parsed)));
+      if (Number.isFinite(parsed)) commit(clamp(round(parsed)));
     };
     const handleBlur = (e) => {
       if (current == null) setText("");
@@ -95,19 +111,27 @@ var InputNumber = React__namespace.forwardRef(
       onChange?.(next);
     };
     const handleKeyDown = (e) => {
+      onKeyDown?.(e);
+      if (e.defaultPrevented) return;
       if (e.key === "ArrowUp") {
         e.preventDefault();
-        increment(step);
+        increment(normalizedStep);
       }
       if (e.key === "ArrowDown") {
         e.preventDefault();
-        increment(-step);
+        increment(-normalizedStep);
       }
       if (e.key === "Enter") onPressEnter?.(e);
     };
-    const upDisabled = disabled || readOnly || current != null && current >= max;
-    const downDisabled = disabled || readOnly || current != null && current <= min;
-    const stepperSuffix = controls ? /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ipn-steppers", "aria-hidden": true, children: [
+    const handleWheel = (event) => {
+      onWheel?.(event);
+      if (event.defaultPrevented || document.activeElement !== event.currentTarget || disabled || readOnly) return;
+      event.preventDefault();
+      increment(event.deltaY < 0 ? normalizedStep : -normalizedStep);
+    };
+    const upDisabled = disabled || readOnly || current != null && current >= normalizedMax;
+    const downDisabled = disabled || readOnly || current != null && current <= normalizedMin;
+    const stepperSuffix = controls ? /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ipn-steppers", children: [
       /* @__PURE__ */ jsxRuntime.jsx(
         "button",
         {
@@ -116,8 +140,9 @@ var InputNumber = React__namespace.forwardRef(
           tabIndex: -1,
           disabled: upDisabled,
           onMouseDown: (e) => e.preventDefault(),
-          onClick: () => increment(step),
-          children: /* @__PURE__ */ jsxRuntime.jsx(chunkQMX67CVT_cjs.Icon, { name: "chevUp", size: 10, stroke: 2.5 })
+          onClick: () => increment(normalizedStep),
+          "aria-label": "\u589E\u52A0\u6570\u503C",
+          children: /* @__PURE__ */ jsxRuntime.jsx(chunk2AUXUZ3Z_cjs.Icon, { name: "chevUp", size: 10, stroke: 2.5 })
         }
       ),
       /* @__PURE__ */ jsxRuntime.jsx(
@@ -128,8 +153,9 @@ var InputNumber = React__namespace.forwardRef(
           tabIndex: -1,
           disabled: downDisabled,
           onMouseDown: (e) => e.preventDefault(),
-          onClick: () => increment(-step),
-          children: /* @__PURE__ */ jsxRuntime.jsx(chunkQMX67CVT_cjs.Icon, { name: "chevDown", size: 10, stroke: 2.5 })
+          onClick: () => increment(-normalizedStep),
+          "aria-label": "\u51CF\u5C11\u6570\u503C",
+          children: /* @__PURE__ */ jsxRuntime.jsx(chunk2AUXUZ3Z_cjs.Icon, { name: "chevDown", size: 10, stroke: 2.5 })
         }
       )
     ] }) : null;
@@ -137,10 +163,11 @@ var InputNumber = React__namespace.forwardRef(
       suffix,
       stepperSuffix
     ] }) : stepperSuffix ?? suffix;
-    return /* @__PURE__ */ jsxRuntime.jsx(
-      chunkVS3I5OKA_cjs.Input,
+    return /* @__PURE__ */ jsxRuntime.jsx(chunkSTQDKMS5_cjs.InputThemeIdentityProvider, { value: { component: "InputNumber", cssPrefix: "input" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+      chunkSTQDKMS5_cjs.Input,
       {
         ref,
+        ...rest,
         id,
         name,
         size,
@@ -154,12 +181,18 @@ var InputNumber = React__namespace.forwardRef(
         suffix: finalSuffix,
         className: `input-number ${className}`,
         inputMode: "decimal",
+        role: "spinbutton",
+        "aria-valuemin": Number.isFinite(normalizedMin) ? normalizedMin : void 0,
+        "aria-valuemax": Number.isFinite(normalizedMax) ? normalizedMax : void 0,
+        "aria-valuenow": current ?? void 0,
         onValueChange: handleInput,
         onKeyDown: handleKeyDown,
+        onWheel: handleWheel,
         onBlur: handleBlur,
-        onFocus
+        onFocus,
+        theme
       }
-    );
+    ) });
   }
 );
 InputNumber.displayName = "InputNumber";