@fangxinyan/lumina 0.6.17 → 0.7.0

package/dist/chunk-Y2MT6PI6.js

@@ -0,0 +1,207 @@
+import { Spin } from './chunk-PQOBBASY.js';
+import { Button } from './chunk-JHM7MN3G.js';
+import { InternalComponentThemePart, withComponentTheme } from './chunk-DRDDQCDD.js';
+import './tokens-CEJVVA3G.css';
+import './shared-NJHRNLRH.css';
+import './Card-VPMTWAWZ.css';
+import * as React from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var CARD_INTERACTIVE_SELECTOR = [
+  "a[href]",
+  "button",
+  "input",
+  "select",
+  "textarea",
+  "[role='button']",
+  "[role='link']",
+  "[contenteditable='true']"
+].join(",");
+function isNestedCardControl(target, currentTarget) {
+  if (!(target instanceof Element)) return false;
+  const control = target.closest(CARD_INTERACTIVE_SELECTOR);
+  return !!control && !control.classList.contains("card-interactive-control") && control !== currentTarget && currentTarget.contains(control);
+}
+function getCardText(node) {
+  return React.Children.toArray(node).map((child) => {
+    if (typeof child === "string" || typeof child === "number") return String(child);
+    if (React.isValidElement(child)) {
+      return getCardText(child.props.children);
+    }
+    return "";
+  }).filter(Boolean).join(" ").trim();
+}
+function hasCardControlNode(node) {
+  return React.Children.toArray(node).some((child) => {
+    if (!React.isValidElement(child)) return false;
+    const type = child.type;
+    const displayName = typeof type !== "string" && type != null ? type.displayName : void 0;
+    const interactiveType = typeof type === "string" && ["a", "button", "input", "select", "textarea"].includes(type);
+    if (interactiveType || displayName === "Button" || displayName === "IconButton") return true;
+    if (child.props.role === "button" || child.props.role === "link") return true;
+    return hasCardControlNode(child.props.children);
+  });
+}
+function handleCardControlKeyDown(event) {
+  if (event.key !== "Enter" && event.key !== " ") return;
+  event.preventDefault();
+  event.currentTarget.click();
+}
+var CardBase = React.forwardRef(
+  ({
+    variant = "raised",
+    padding = "md",
+    hoverable,
+    interactive,
+    disabled = false,
+    title,
+    description,
+    actions,
+    background,
+    fill = false,
+    bodyLayout,
+    bodyClassName = "",
+    bodyStyle,
+    bodyProps,
+    loading = false,
+    loadingOverlay,
+    className = "",
+    style,
+    children,
+    onClick,
+    onKeyDown,
+    onClickCapture,
+    onKeyDownCapture,
+    role,
+    tabIndex,
+    "aria-label": ariaLabel,
+    "aria-labelledby": ariaLabelledBy,
+    ...rest
+  }, ref) => {
+    const contentRef = React.useRef(null);
+    const headRef = React.useRef(null);
+    const actionsRef = React.useRef(null);
+    const isInteractive = interactive ?? !!onClick;
+    React.useEffect(() => {
+      const isolated = disabled || loading;
+      if (contentRef.current) contentRef.current.inert = isolated;
+      if (headRef.current) headRef.current.inert = isolated;
+      if (actionsRef.current) actionsRef.current.inert = isolated;
+    }, [disabled, loading]);
+    const resolvedBodyLayout = bodyLayout ?? (fill ? "fill" : "block");
+    const cls = [
+      "card",
+      variant,
+      padding !== "md" && `pad-${padding}`,
+      fill && "fill",
+      hoverable && !disabled && !loading && "hoverable",
+      isInteractive && "interactive",
+      disabled && "disabled",
+      loading && "loading",
+      className
+    ].filter(Boolean).join(" ");
+    const bodyCls = [
+      "card-body",
+      resolvedBodyLayout !== "block" && `body-${resolvedBodyLayout}`,
+      loading && "loading",
+      bodyClassName
+    ].filter(Boolean).join(" ");
+    const cardStyle = background ? {
+      "--card-bg": background,
+      ...style
+    } : style;
+    const bodyLabel = hasCardControlNode(children) ? "" : getCardText(children);
+    const interactiveLabel = ariaLabel ?? (getCardText(title ?? description) || bodyLabel || "\u53EF\u64CD\u4F5C\u5361\u7247");
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref: (node) => {
+          if (typeof ref === "function") ref(node);
+          else if (ref) ref.current = node;
+        },
+        className: cls,
+        style: cardStyle,
+        role,
+        tabIndex: isInteractive ? void 0 : tabIndex,
+        "aria-label": role ? ariaLabel : void 0,
+        "aria-labelledby": role ? ariaLabelledBy : void 0,
+        "aria-disabled": isInteractive && (disabled || loading) ? true : void 0,
+        "aria-busy": loading || void 0,
+        onClickCapture: (event) => {
+          if (disabled || loading) {
+            event.preventDefault();
+            event.stopPropagation();
+            return;
+          }
+          onClickCapture?.(event);
+        },
+        onKeyDownCapture: (event) => {
+          if (disabled || loading) {
+            event.preventDefault();
+            event.stopPropagation();
+            return;
+          }
+          onKeyDownCapture?.(event);
+        },
+        onClick: (event) => {
+          if (disabled || loading) {
+            event.preventDefault();
+            return;
+          }
+          if (isNestedCardControl(event.target, event.currentTarget)) return;
+          onClick?.(event);
+        },
+        onKeyDown: (event) => {
+          onKeyDown?.(event);
+          if (isInteractive && !disabled && !loading && !event.defaultPrevented && event.target === event.currentTarget && (event.key === "Enter" || event.key === " ")) {
+            event.preventDefault();
+            event.currentTarget.click();
+          }
+        },
+        ...rest,
+        children: [
+          isInteractive && /* @__PURE__ */ jsx(InternalComponentThemePart, { components: "Button", children: /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "button",
+              variant: "ghost",
+              className: "card-interactive-control",
+              "aria-label": interactiveLabel,
+              "aria-labelledby": ariaLabelledBy,
+              tabIndex: disabled || loading ? -1 : tabIndex ?? 0,
+              disabled: disabled || loading,
+              onKeyDown: handleCardControlKeyDown
+            }
+          ) }),
+          (title || description || actions) && /* @__PURE__ */ jsxs("div", { ref: headRef, className: "card-head", children: [
+            /* @__PURE__ */ jsxs("div", { className: "card-titles", children: [
+              title && /* @__PURE__ */ jsx("div", { className: "card-title", children: title }),
+              description && /* @__PURE__ */ jsx("div", { className: "card-desc", children: description })
+            ] }),
+            actions && /* @__PURE__ */ jsx("div", { ref: actionsRef, className: "card-actions", children: actions })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { ...bodyProps, className: bodyCls, style: bodyStyle, children: [
+            /* @__PURE__ */ jsx(
+              "div",
+              {
+                ref: contentRef,
+                className: "card-body-content",
+                "aria-hidden": loading || void 0,
+                children
+              }
+            ),
+            loading && /* @__PURE__ */ jsx("div", { className: "card-loading-overlay", "aria-live": "polite", children: loadingOverlay ?? /* @__PURE__ */ jsx(InternalComponentThemePart, { components: "Spin", children: /* @__PURE__ */ jsx(Spin, { tip: "\u52A0\u8F7D\u4E2D..." }) }) })
+          ] })
+        ]
+      }
+    );
+  }
+);
+CardBase.displayName = "Card";
+var Card = withComponentTheme(
+  CardBase,
+  "Card",
+  ["card", "button", "spin"]
+);
+
+export { Card };

package/dist/chunk-YAYSXZZZ.cjs

@@ -0,0 +1,82 @@
+'use strict';
+
+var chunkNRJXZPZR_cjs = require('./chunk-NRJXZPZR.cjs');
+require('./tokens-CEJVVA3G.css');
+require('./shared-NJHRNLRH.css');
+require('./Progress-33WE2NI7.css');
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var ProgressBase = React__namespace.forwardRef(({
+  value,
+  max = 100,
+  label,
+  showValue,
+  tone = "accent",
+  color,
+  size = "md",
+  indeterminate = false,
+  className = "",
+  style,
+  ...rest
+}, ref) => {
+  const safeMax = Number.isFinite(max) && max > 0 ? max : 100;
+  const safeValue = Number.isFinite(value) ? value : 0;
+  const normalizedValue = Math.max(0, Math.min(safeMax, safeValue));
+  const pct = normalizedValue / safeMax * 100;
+  const rootStyle = {
+    ...color ? {
+      ["--progress-fill"]: color,
+      ["--progress-fill-glow"]: `color-mix(in oklch, ${color} 35%, transparent)`
+    } : null,
+    ...style
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ref,
+      className: `progress ${size} ${tone} ${indeterminate ? "indeterminate" : ""} ${className}`,
+      style: rootStyle,
+      role: "progressbar",
+      "aria-valuemin": 0,
+      "aria-valuemax": safeMax,
+      "aria-valuenow": indeterminate ? void 0 : normalizedValue,
+      "aria-valuetext": indeterminate ? "\u52A0\u8F7D\u4E2D" : void 0,
+      ...rest,
+      children: [
+        (label || showValue) && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "progress-label", children: [
+          label ? /* @__PURE__ */ jsxRuntime.jsx("span", { children: label }) : /* @__PURE__ */ jsxRuntime.jsx("span", {}),
+          showValue && !indeterminate && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "v", children: [
+            Math.round(pct),
+            "%"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "progress-track", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "progress-bar", style: { width: indeterminate ? "35%" : `${pct}%` } }) })
+      ]
+    }
+  );
+});
+ProgressBase.displayName = "Progress";
+var Progress = chunkNRJXZPZR_cjs.withComponentTheme(ProgressBase, "Progress", "progress");
+
+exports.Progress = Progress;

package/dist/{chunk-6LN4VVX7.js → chunk-YBGMTQ2V.js}

@@ -1,11 +1,12 @@
-import { Icon } from './chunk-FDZG27IG.js';
-import './tokens-RYJ3DFTU.css';
+import { Icon } from './chunk-LQMOYVQF.js';
+import { withComponentTheme } from './chunk-DRDDQCDD.js';
+import './tokens-CEJVVA3G.css';
 import './shared-NJHRNLRH.css';
-import './Collapse-UNBHEPYP.css';
+import './Collapse-BTSBHBSY.css';
 import * as React from 'react';
 import { jsx, jsxs } from 'react/jsx-runtime';
 
-var CollapsePanel = ({ open, children }) => {
+var CollapsePanel = ({ open, id, labelledBy, children }) => {
   const innerRef = React.useRef(null);
   const [h, setH] = React.useState(0);
   const [animated, setAnimated] = React.useState(false);
@@ -18,21 +19,28 @@ var CollapsePanel = ({ open, children }) => {
     return () => ro.disconnect();
   }, []);
   React.useEffect(() => {
-    const id = requestAnimationFrame(() => setAnimated(true));
-    return () => cancelAnimationFrame(id);
+    const id2 = requestAnimationFrame(() => setAnimated(true));
+    return () => cancelAnimationFrame(id2);
   }, []);
   return /* @__PURE__ */ jsx(
     "div",
     {
+      id,
       className: "collapse-body",
       style: { maxHeight: open ? h : 0, transition: animated ? void 0 : "none" },
       "aria-hidden": !open,
+      "aria-labelledby": labelledBy,
+      role: "region",
+      ...!open ? { inert: "" } : {},
       children: /* @__PURE__ */ jsx("div", { ref: innerRef, className: "collapse-body-inner", children })
     }
   );
 };
-var normalizeKeys = (value) => value == null ? [] : Array.isArray(value) ? value : [value];
-var Collapse = React.forwardRef(({
+var normalizeKeys = (value, singleOpen = false) => {
+  const keys = value == null ? [] : Array.isArray(value) ? value : [value];
+  return singleOpen ? keys.slice(0, 1) : keys;
+};
+var CollapseBase = React.forwardRef(({
   items,
   accordion = false,
   multiple = true,
@@ -45,10 +53,14 @@ var Collapse = React.forwardRef(({
   className = "",
   ...rest
 }, ref) => {
-  const [inner, setInner] = React.useState(() => normalizeKeys(defaultActiveKey));
-  const isControlled = activeKey !== void 0;
-  const keys = isControlled ? normalizeKeys(activeKey) : inner;
+  const baseId = React.useId();
   const singleOpen = accordion || !multiple;
+  const [inner, setInner] = React.useState(() => normalizeKeys(defaultActiveKey, singleOpen));
+  const isControlled = activeKey !== void 0;
+  const keys = normalizeKeys(isControlled ? activeKey : inner, singleOpen);
+  React.useEffect(() => {
+    if (!isControlled && singleOpen && inner.length > 1) setInner(inner.slice(0, 1));
+  }, [inner, isControlled, singleOpen]);
   const toggle = (k, itemDisabled) => {
     if (collapsible === "disabled" || itemDisabled) return;
     const next = keys.includes(k) ? keys.filter((x) => x !== k) : singleOpen ? [k] : [...keys, k];
@@ -61,42 +73,49 @@ var Collapse = React.forwardRef(({
       ref,
       className: `collapse ${ghost ? "ghost" : ""} ${size} ${className}`,
       ...rest,
-      children: items.map((it) => {
+      children: items.map((it, index) => {
         const open = keys.includes(it.key);
         const isDisabled = it.disabled || collapsible === "disabled";
         const headerClickable = collapsible === "header" && !isDisabled;
+        const headerId = `${baseId}-header-${index}`;
+        const panelId = `${baseId}-panel-${index}`;
         return /* @__PURE__ */ jsxs(
           "div",
           {
             className: `collapse-item ${open ? "open" : ""} ${isDisabled ? "disabled" : ""} ${collapsible === "icon" ? "icon-only" : ""}`,
             children: [
-              /* @__PURE__ */ jsxs(
+              collapsible === "icon" ? /* @__PURE__ */ jsxs("div", { id: headerId, className: "collapse-head", children: [
+                /* @__PURE__ */ jsx("span", { children: it.label }),
+                /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    className: "collapse-chev clickable",
+                    disabled: isDisabled,
+                    onClick: () => toggle(it.key, it.disabled),
+                    "aria-expanded": open,
+                    "aria-controls": panelId,
+                    "aria-label": open ? "\u6536\u8D77\u9762\u677F" : "\u5C55\u5F00\u9762\u677F",
+                    children: /* @__PURE__ */ jsx(Icon, { name: "chevDown", size: 16, "aria-hidden": true })
+                  }
+                )
+              ] }) : /* @__PURE__ */ jsxs(
                 "button",
                 {
+                  id: headerId,
                   type: "button",
                   className: "collapse-head",
                   disabled: isDisabled,
                   onClick: () => headerClickable && toggle(it.key, it.disabled),
                   "aria-expanded": open,
+                  "aria-controls": panelId,
                   children: [
                     /* @__PURE__ */ jsx("span", { children: it.label }),
-                    /* @__PURE__ */ jsx(
-                      "span",
-                      {
-                        className: `collapse-chev${collapsible === "icon" ? " clickable" : ""}`,
-                        onClick: (e) => {
-                          if (collapsible === "icon" && !isDisabled) {
-                            e.stopPropagation();
-                            toggle(it.key, it.disabled);
-                          }
-                        },
-                        children: /* @__PURE__ */ jsx(Icon, { name: "chevDown", size: 16 })
-                      }
-                    )
+                    /* @__PURE__ */ jsx("span", { className: "collapse-chev", "aria-hidden": true, children: /* @__PURE__ */ jsx(Icon, { name: "chevDown", size: 16 }) })
                   ]
                 }
               ),
-              /* @__PURE__ */ jsx(CollapsePanel, { open, children: it.children })
+              /* @__PURE__ */ jsx(CollapsePanel, { open, id: panelId, labelledBy: headerId, children: it.children })
             ]
           },
           it.key
@@ -105,6 +124,7 @@ var Collapse = React.forwardRef(({
     }
   );
 });
-Collapse.displayName = "Collapse";
+CollapseBase.displayName = "Collapse";
+var Collapse = withComponentTheme(CollapseBase, "Collapse", "collapse");
 
 export { Collapse };

package/dist/{chunk-TYLDISRK.js → chunk-YKHIIC7M.js}

@@ -1,11 +1,11 @@
-import './tokens-RYJ3DFTU.css';
+import { withComponentTheme } from './chunk-DRDDQCDD.js';
+import './tokens-CEJVVA3G.css';
 import './shared-NJHRNLRH.css';
-import './StatusBar-FJKEEPXU.css';
+import './StatusBar-TCGR3LXP.css';
 import * as React from 'react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
-// src/components/StatusBar/StatusBar.tsx
-var StatusBarItem = React.forwardRef(({
+var StatusBarItemBase = React.forwardRef(({
   icon,
   tone = "default",
   onClick,
@@ -26,13 +26,19 @@ var StatusBarItem = React.forwardRef(({
         type: "button",
         className: cls,
         onClick,
+        ...rest,
         children: content
       }
     );
   }
   return /* @__PURE__ */ jsx("div", { ref, className: cls, ...rest, children: content });
 });
-StatusBarItem.displayName = "StatusBarItem";
+StatusBarItemBase.displayName = "StatusBarItem";
+var StatusBarItem = withComponentTheme(
+  StatusBarItemBase,
+  "StatusBarItem",
+  "status-bar"
+);
 var StatusBarBase = React.forwardRef(({
   left,
   center,
@@ -47,7 +53,8 @@ var StatusBarBase = React.forwardRef(({
   right != null && /* @__PURE__ */ jsx("div", { className: "statusbar-section right", children: right })
 ] }));
 StatusBarBase.displayName = "StatusBar";
-var StatusBar = StatusBarBase;
+var ThemedStatusBar = withComponentTheme(StatusBarBase, "StatusBar", "status-bar");
+var StatusBar = ThemedStatusBar;
 StatusBar.Item = StatusBarItem;
 
 export { StatusBar, StatusBarItem };

package/dist/{chunk-3VXGZ3SJ.js → chunk-YPMQC5HX.js}

@@ -1,11 +1,16 @@
-import { Input } from './chunk-IOAOG5L7.js';
-import { Icon } from './chunk-FDZG27IG.js';
-import './tokens-RYJ3DFTU.css';
+import { InputThemeIdentityProvider, Input } from './chunk-UE4HFGJ6.js';
+import { Icon } from './chunk-LQMOYVQF.js';
+import './tokens-CEJVVA3G.css';
 import './shared-NJHRNLRH.css';
-import './InputNumber-VXQIWLQC.css';
+import './InputNumber-6NHBMRT4.css';
 import * as React from 'react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
+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.forwardRef(
   ({
     value,
@@ -13,6 +18,8 @@ var InputNumber = React.forwardRef(
     onChange,
     onBlur,
     onFocus,
+    onWheel,
+    onKeyDown,
     onPressEnter,
     min = -Infinity,
     max = Infinity,
@@ -29,22 +36,31 @@ var InputNumber = React.forwardRef(
     suffix,
     autoFocus,
     id,
-    name
+    name,
+    theme,
+    ...rest
   }, ref) => {
-    const [inner, setInner] = React.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.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.useState(current == null ? "" : String(current));
     React.useEffect(() => {
-      if (isControlled) setText(value == null ? "" : String(value));
-    }, [value, isControlled]);
+      if (isControlled) setText(current == null ? "" : String(current));
+    }, [current, isControlled]);
     const clamp = React.useCallback(
-      (n) => Math.max(min, Math.min(max, n)),
-      [min, max]
+      (n) => Math.max(normalizedMin, Math.min(normalizedMax, n)),
+      [normalizedMax, normalizedMin]
     );
     const round = React.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);
@@ -57,7 +73,7 @@ var InputNumber = React.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("");
@@ -73,19 +89,27 @@ var InputNumber = React.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__ */ 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__ */ jsxs("span", { className: "ipn-steppers", children: [
       /* @__PURE__ */ jsx(
         "button",
         {
@@ -94,7 +118,8 @@ var InputNumber = React.forwardRef(
           tabIndex: -1,
           disabled: upDisabled,
           onMouseDown: (e) => e.preventDefault(),
-          onClick: () => increment(step),
+          onClick: () => increment(normalizedStep),
+          "aria-label": "\u589E\u52A0\u6570\u503C",
           children: /* @__PURE__ */ jsx(Icon, { name: "chevUp", size: 10, stroke: 2.5 })
         }
       ),
@@ -106,7 +131,8 @@ var InputNumber = React.forwardRef(
           tabIndex: -1,
           disabled: downDisabled,
           onMouseDown: (e) => e.preventDefault(),
-          onClick: () => increment(-step),
+          onClick: () => increment(-normalizedStep),
+          "aria-label": "\u51CF\u5C11\u6570\u503C",
           children: /* @__PURE__ */ jsx(Icon, { name: "chevDown", size: 10, stroke: 2.5 })
         }
       )
@@ -115,10 +141,11 @@ var InputNumber = React.forwardRef(
       suffix,
       stepperSuffix
     ] }) : stepperSuffix ?? suffix;
-    return /* @__PURE__ */ jsx(
+    return /* @__PURE__ */ jsx(InputThemeIdentityProvider, { value: { component: "InputNumber", cssPrefix: "input" }, children: /* @__PURE__ */ jsx(
       Input,
       {
         ref,
+        ...rest,
         id,
         name,
         size,
@@ -132,12 +159,18 @@ var InputNumber = React.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";