bj-web-components 0.2.26 → 0.2.28

package/dist/web/InputNumber/BInputNumber.js

@@ -0,0 +1,311 @@
+"use strict";
+const jsxRuntime = require("react/jsx-runtime");
+const react = require("react");
+;/* empty css                   */
+const useCursor = require("./hooks/useCursor.js");
+const useFrame = require("./hooks/useFrame.js");
+const StepHandler = require("./StepHandler.js");
+const decimal = require("./utils/decimal.js");
+function getDecimalIfValid(value) {
+  if (value === void 0 || value === null) return null;
+  const decimal$1 = decimal.getDecimal(value);
+  return decimal$1.isInvalidate() ? null : decimal$1;
+}
+const BInputNumber = react.forwardRef(function BInputNumber2({
+  value,
+  defaultValue,
+  onChange,
+  min,
+  max,
+  step = 1,
+  precision,
+  disabled = false,
+  readOnly = false,
+  placeholder,
+  autoFocus,
+  size = "middle",
+  status,
+  bordered = true,
+  controls = true,
+  keyboard = true,
+  changeOnWheel = false,
+  changeOnBlur = true,
+  addonBefore,
+  addonAfter,
+  prefix,
+  suffix,
+  formatter,
+  parser,
+  decimalSeparator,
+  onStep,
+  onPressEnter,
+  onFocus,
+  onBlur,
+  id,
+  name,
+  className,
+  style
+}, ref) {
+  const inputRef = react.useRef(null);
+  const [focused, setFocused] = react.useState(false);
+  const userTypingRef = react.useRef(false);
+  const compositionRef = react.useRef(false);
+  const shiftKeyRef = react.useRef(false);
+  const inputValueRef = react.useRef("");
+  const [decimalValue, setDecimalValue] = react.useState(() => decimal.getDecimal(value ?? defaultValue));
+  const setUncontrolledDecimalValue = (next) => {
+    if (value === void 0) setDecimalValue(next);
+  };
+  const getPrecision = react.useCallback(
+    (numStr, userTyping) => {
+      if (userTyping) return void 0;
+      if (precision !== void 0 && precision >= 0) return precision;
+      return Math.max(decimal.getNumberPrecision(numStr), decimal.getNumberPrecision(step));
+    },
+    [precision, step]
+  );
+  const mergedParser = react.useCallback(
+    (num) => {
+      if (parser) return parser(num);
+      let parsedStr = num;
+      if (decimalSeparator) parsedStr = parsedStr.replace(decimalSeparator, ".");
+      return parsedStr.replace(/[^\w.-]+/g, "");
+    },
+    [parser, decimalSeparator]
+  );
+  const mergedFormatter = react.useCallback(
+    (number, userTyping) => {
+      if (formatter) return formatter(number, { userTyping: !!userTyping, input: inputValueRef.current });
+      let str = number;
+      if (!userTyping) {
+        const mergedPrecision = getPrecision(str, userTyping);
+        if (decimal.validateNumber(str) && (decimalSeparator || (mergedPrecision ?? -1) >= 0)) {
+          str = decimal.toFixed(str, decimalSeparator || ".", mergedPrecision);
+        }
+      }
+      return str;
+    },
+    [formatter, getPrecision, decimalSeparator]
+  );
+  const [inputValue, setInternalInputValue] = react.useState(() => {
+    const initValue = defaultValue ?? value;
+    if (decimalValue.isInvalidate() && ["string", "number"].includes(typeof initValue)) {
+      return initValue === void 0 || initValue === null || Number.isNaN(initValue) ? "" : String(initValue);
+    }
+    return mergedFormatter(decimalValue.toString(), false);
+  });
+  inputValueRef.current = inputValue;
+  const setInputValue = (newValue, userTyping) => {
+    setInternalInputValue(
+      mergedFormatter(newValue.isInvalidate() ? newValue.toString(false) : newValue.toString(!userTyping), userTyping)
+    );
+  };
+  const maxDecimal = react.useMemo(() => getDecimalIfValid(max), [max]);
+  const minDecimal = react.useMemo(() => getDecimalIfValid(min), [min]);
+  const upDisabled = react.useMemo(() => {
+    if (!maxDecimal || decimalValue.isInvalidate()) return false;
+    return maxDecimal.lessEquals(decimalValue);
+  }, [maxDecimal, decimalValue]);
+  const downDisabled = react.useMemo(() => {
+    if (!minDecimal || decimalValue.isInvalidate()) return false;
+    return decimalValue.lessEquals(minDecimal);
+  }, [minDecimal, decimalValue]);
+  const [recordCursor] = useCursor(inputRef.current, focused);
+  const getRangeValue = (target) => {
+    if (maxDecimal && !target.lessEquals(maxDecimal)) return maxDecimal;
+    if (minDecimal && !minDecimal.lessEquals(target)) return minDecimal;
+    return null;
+  };
+  const isInRange = (target) => !getRangeValue(target);
+  const triggerValueUpdate = (newValue, userTyping) => {
+    let updateValue = newValue;
+    let isRangeValidate = isInRange(updateValue) || updateValue.isEmpty();
+    if (!updateValue.isEmpty() && !userTyping) {
+      updateValue = getRangeValue(updateValue) || updateValue;
+      isRangeValidate = true;
+    }
+    if (!readOnly && !disabled && isRangeValidate) {
+      const numStr = updateValue.toString();
+      const mergedPrecision = getPrecision(numStr, userTyping);
+      if (mergedPrecision !== void 0 && mergedPrecision >= 0) {
+        updateValue = decimal.getDecimal(decimal.toFixed(numStr, ".", mergedPrecision));
+        if (!isInRange(updateValue)) {
+          updateValue = decimal.getDecimal(decimal.toFixed(numStr, ".", mergedPrecision, true));
+        }
+      }
+      if (!updateValue.equals(decimalValue)) {
+        setUncontrolledDecimalValue(updateValue);
+        onChange == null ? void 0 : onChange(updateValue.isEmpty() ? null : updateValue.toNumber());
+        if (value === void 0) setInputValue(updateValue, userTyping);
+      }
+      return updateValue;
+    }
+    return decimalValue;
+  };
+  const onNextFrame = useFrame();
+  const collectInputValue = (inputStr) => {
+    recordCursor();
+    inputValueRef.current = inputStr;
+    setInternalInputValue(inputStr);
+    if (!compositionRef.current) {
+      const finalValue = mergedParser(inputStr);
+      const finalDecimal = decimal.getDecimal(finalValue);
+      if (!finalDecimal.isNaN()) triggerValueUpdate(finalDecimal, true);
+    }
+    onNextFrame(() => {
+      const nextInputStr = parser ? inputStr : inputStr.replace(/。/g, ".");
+      if (nextInputStr !== inputStr) collectInputValue(nextInputStr);
+    });
+  };
+  const onCompositionStart = () => {
+    compositionRef.current = true;
+  };
+  const onCompositionEnd = (e) => {
+    compositionRef.current = false;
+    collectInputValue(e.target.value);
+  };
+  const onInternalInput = (e) => collectInputValue(e.target.value);
+  const onInternalStep = (up) => {
+    var _a;
+    if (up && upDisabled || !up && downDisabled) return;
+    userTypingRef.current = false;
+    let stepDecimal = decimal.getDecimal(shiftKeyRef.current ? decimal.getDecupleSteps(step) : step);
+    if (!up) stepDecimal = stepDecimal.negate();
+    const target = (decimalValue.isInvalidate() ? decimal.getDecimal(0) : decimalValue).add(stepDecimal.toString());
+    const updatedValue = triggerValueUpdate(target, false);
+    onStep == null ? void 0 : onStep(updatedValue.toNumber(), { offset: shiftKeyRef.current ? decimal.getDecupleSteps(step) : step, type: up ? "up" : "down" });
+    (_a = inputRef.current) == null ? void 0 : _a.focus();
+  };
+  const flushInputValue = (userTyping) => {
+    const parsedValue = decimal.getDecimal(mergedParser(inputValue));
+    let formatValue;
+    if (!parsedValue.isNaN()) {
+      formatValue = triggerValueUpdate(parsedValue, userTyping);
+    } else {
+      formatValue = triggerValueUpdate(decimalValue, userTyping);
+    }
+    if (value !== void 0) {
+      setInputValue(decimalValue, false);
+    } else if (!formatValue.isNaN()) {
+      setInputValue(formatValue, false);
+    }
+  };
+  const onKeyDown = (event) => {
+    const { key, shiftKey } = event;
+    userTypingRef.current = true;
+    shiftKeyRef.current = shiftKey;
+    if (key === "Enter") {
+      if (!compositionRef.current) userTypingRef.current = false;
+      flushInputValue(false);
+      onPressEnter == null ? void 0 : onPressEnter(event);
+    }
+    if (!keyboard) return;
+    if (!compositionRef.current && (key === "ArrowUp" || key === "ArrowDown")) {
+      onInternalStep(key === "ArrowUp");
+      event.preventDefault();
+    }
+  };
+  const onKeyUp = () => {
+    userTypingRef.current = false;
+    shiftKeyRef.current = false;
+  };
+  const onInternalFocus = (e) => {
+    setFocused(true);
+    onFocus == null ? void 0 : onFocus(e);
+  };
+  const onInternalBlur = (e) => {
+    if (changeOnBlur) flushInputValue(false);
+    setFocused(false);
+    userTypingRef.current = false;
+    onBlur == null ? void 0 : onBlur(e);
+  };
+  const prevValueRef = react.useRef(value);
+  if (prevValueRef.current !== value) {
+    prevValueRef.current = value;
+    const newValue = decimal.getDecimal(value);
+    if (!newValue.equals(decimalValue)) {
+      setDecimalValue(newValue);
+      const currentParsedValue = decimal.getDecimal(mergedParser(inputValue));
+      if (!newValue.equals(currentParsedValue) || !userTypingRef.current || formatter) {
+        setInputValue(newValue, userTypingRef.current);
+      }
+    }
+  }
+  const setRefs = (node) => {
+    inputRef.current = node;
+    if (typeof ref === "function") ref(node);
+    else if (ref) ref.current = node;
+  };
+  const controlsEnabled = !!controls;
+  const controlsIcon = typeof controls === "object" ? controls.icon : void 0;
+  const outOfRange = !decimalValue.isInvalidate() && !isInRange(decimalValue);
+  const rootCls = [
+    "bj-input-number",
+    `bj-input-number--${size}`,
+    focused && "bj-input-number--focused",
+    disabled && "bj-input-number--disabled",
+    readOnly && "bj-input-number--readonly",
+    !bordered && "bj-input-number--borderless",
+    status && `bj-input-number--${status}`,
+    outOfRange && "bj-input-number--out-of-range",
+    controlsEnabled && "bj-input-number--with-controls",
+    addonBefore && "bj-input-number--group-left",
+    addonAfter && "bj-input-number--group-right"
+  ].filter(Boolean).join(" ");
+  const numberBox = /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: [rootCls, !(addonBefore || addonAfter || prefix || suffix) && className].filter(Boolean).join(" "),
+      style: !(addonBefore || addonAfter || prefix || suffix) ? style : void 0,
+      onKeyDown,
+      onKeyUp,
+      children: [
+        prefix && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "bj-input-number__prefix", children: prefix }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bj-input-number__input-wrap", children: /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            ref: setRefs,
+            id,
+            name,
+            className: "bj-input-number__input",
+            autoComplete: "off",
+            role: "spinbutton",
+            "aria-valuemin": min,
+            "aria-valuemax": max,
+            "aria-valuenow": decimalValue.isInvalidate() ? void 0 : decimalValue.toNumber(),
+            value: inputValue,
+            placeholder,
+            disabled,
+            readOnly,
+            autoFocus,
+            onChange: onInternalInput,
+            onFocus: onInternalFocus,
+            onBlur: onInternalBlur,
+            onCompositionStart,
+            onCompositionEnd,
+            onWheel: changeOnWheel ? (e) => {
+              if (!focused) return;
+              onInternalStep(e.deltaY < 0);
+            } : void 0
+          }
+        ) }),
+        suffix && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "bj-input-number__suffix", children: suffix }),
+        controlsEnabled && /* @__PURE__ */ jsxRuntime.jsx(StepHandler, { icon: controlsIcon, upDisabled, downDisabled, onStep: onInternalStep })
+      ]
+    }
+  );
+  if (!addonBefore && !addonAfter) return numberBox;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: ["bj-input-number-group", `bj-input-number-group--${size}`, className].filter(Boolean).join(" "),
+      style,
+      children: [
+        addonBefore && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bj-input-number-group__addon", children: addonBefore }),
+        numberBox,
+        addonAfter && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bj-input-number-group__addon", children: addonAfter })
+      ]
+    }
+  );
+});
+module.exports = BInputNumber;

package/dist/web/InputNumber/BInputNumber.mjs

@@ -0,0 +1,312 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { forwardRef, useRef, useState, useCallback, useMemo } from "react";
+/* empty css                   */
+import useCursor from "./hooks/useCursor.mjs";
+import useFrame from "./hooks/useFrame.mjs";
+import StepHandler from "./StepHandler.mjs";
+import { getDecimal, getNumberPrecision, validateNumber, toFixed, getDecupleSteps } from "./utils/decimal.mjs";
+function getDecimalIfValid(value) {
+  if (value === void 0 || value === null) return null;
+  const decimal = getDecimal(value);
+  return decimal.isInvalidate() ? null : decimal;
+}
+const BInputNumber = forwardRef(function BInputNumber2({
+  value,
+  defaultValue,
+  onChange,
+  min,
+  max,
+  step = 1,
+  precision,
+  disabled = false,
+  readOnly = false,
+  placeholder,
+  autoFocus,
+  size = "middle",
+  status,
+  bordered = true,
+  controls = true,
+  keyboard = true,
+  changeOnWheel = false,
+  changeOnBlur = true,
+  addonBefore,
+  addonAfter,
+  prefix,
+  suffix,
+  formatter,
+  parser,
+  decimalSeparator,
+  onStep,
+  onPressEnter,
+  onFocus,
+  onBlur,
+  id,
+  name,
+  className,
+  style
+}, ref) {
+  const inputRef = useRef(null);
+  const [focused, setFocused] = useState(false);
+  const userTypingRef = useRef(false);
+  const compositionRef = useRef(false);
+  const shiftKeyRef = useRef(false);
+  const inputValueRef = useRef("");
+  const [decimalValue, setDecimalValue] = useState(() => getDecimal(value ?? defaultValue));
+  const setUncontrolledDecimalValue = (next) => {
+    if (value === void 0) setDecimalValue(next);
+  };
+  const getPrecision = useCallback(
+    (numStr, userTyping) => {
+      if (userTyping) return void 0;
+      if (precision !== void 0 && precision >= 0) return precision;
+      return Math.max(getNumberPrecision(numStr), getNumberPrecision(step));
+    },
+    [precision, step]
+  );
+  const mergedParser = useCallback(
+    (num) => {
+      if (parser) return parser(num);
+      let parsedStr = num;
+      if (decimalSeparator) parsedStr = parsedStr.replace(decimalSeparator, ".");
+      return parsedStr.replace(/[^\w.-]+/g, "");
+    },
+    [parser, decimalSeparator]
+  );
+  const mergedFormatter = useCallback(
+    (number, userTyping) => {
+      if (formatter) return formatter(number, { userTyping: !!userTyping, input: inputValueRef.current });
+      let str = number;
+      if (!userTyping) {
+        const mergedPrecision = getPrecision(str, userTyping);
+        if (validateNumber(str) && (decimalSeparator || (mergedPrecision ?? -1) >= 0)) {
+          str = toFixed(str, decimalSeparator || ".", mergedPrecision);
+        }
+      }
+      return str;
+    },
+    [formatter, getPrecision, decimalSeparator]
+  );
+  const [inputValue, setInternalInputValue] = useState(() => {
+    const initValue = defaultValue ?? value;
+    if (decimalValue.isInvalidate() && ["string", "number"].includes(typeof initValue)) {
+      return initValue === void 0 || initValue === null || Number.isNaN(initValue) ? "" : String(initValue);
+    }
+    return mergedFormatter(decimalValue.toString(), false);
+  });
+  inputValueRef.current = inputValue;
+  const setInputValue = (newValue, userTyping) => {
+    setInternalInputValue(
+      mergedFormatter(newValue.isInvalidate() ? newValue.toString(false) : newValue.toString(!userTyping), userTyping)
+    );
+  };
+  const maxDecimal = useMemo(() => getDecimalIfValid(max), [max]);
+  const minDecimal = useMemo(() => getDecimalIfValid(min), [min]);
+  const upDisabled = useMemo(() => {
+    if (!maxDecimal || decimalValue.isInvalidate()) return false;
+    return maxDecimal.lessEquals(decimalValue);
+  }, [maxDecimal, decimalValue]);
+  const downDisabled = useMemo(() => {
+    if (!minDecimal || decimalValue.isInvalidate()) return false;
+    return decimalValue.lessEquals(minDecimal);
+  }, [minDecimal, decimalValue]);
+  const [recordCursor] = useCursor(inputRef.current, focused);
+  const getRangeValue = (target) => {
+    if (maxDecimal && !target.lessEquals(maxDecimal)) return maxDecimal;
+    if (minDecimal && !minDecimal.lessEquals(target)) return minDecimal;
+    return null;
+  };
+  const isInRange = (target) => !getRangeValue(target);
+  const triggerValueUpdate = (newValue, userTyping) => {
+    let updateValue = newValue;
+    let isRangeValidate = isInRange(updateValue) || updateValue.isEmpty();
+    if (!updateValue.isEmpty() && !userTyping) {
+      updateValue = getRangeValue(updateValue) || updateValue;
+      isRangeValidate = true;
+    }
+    if (!readOnly && !disabled && isRangeValidate) {
+      const numStr = updateValue.toString();
+      const mergedPrecision = getPrecision(numStr, userTyping);
+      if (mergedPrecision !== void 0 && mergedPrecision >= 0) {
+        updateValue = getDecimal(toFixed(numStr, ".", mergedPrecision));
+        if (!isInRange(updateValue)) {
+          updateValue = getDecimal(toFixed(numStr, ".", mergedPrecision, true));
+        }
+      }
+      if (!updateValue.equals(decimalValue)) {
+        setUncontrolledDecimalValue(updateValue);
+        onChange == null ? void 0 : onChange(updateValue.isEmpty() ? null : updateValue.toNumber());
+        if (value === void 0) setInputValue(updateValue, userTyping);
+      }
+      return updateValue;
+    }
+    return decimalValue;
+  };
+  const onNextFrame = useFrame();
+  const collectInputValue = (inputStr) => {
+    recordCursor();
+    inputValueRef.current = inputStr;
+    setInternalInputValue(inputStr);
+    if (!compositionRef.current) {
+      const finalValue = mergedParser(inputStr);
+      const finalDecimal = getDecimal(finalValue);
+      if (!finalDecimal.isNaN()) triggerValueUpdate(finalDecimal, true);
+    }
+    onNextFrame(() => {
+      const nextInputStr = parser ? inputStr : inputStr.replace(/。/g, ".");
+      if (nextInputStr !== inputStr) collectInputValue(nextInputStr);
+    });
+  };
+  const onCompositionStart = () => {
+    compositionRef.current = true;
+  };
+  const onCompositionEnd = (e) => {
+    compositionRef.current = false;
+    collectInputValue(e.target.value);
+  };
+  const onInternalInput = (e) => collectInputValue(e.target.value);
+  const onInternalStep = (up) => {
+    var _a;
+    if (up && upDisabled || !up && downDisabled) return;
+    userTypingRef.current = false;
+    let stepDecimal = getDecimal(shiftKeyRef.current ? getDecupleSteps(step) : step);
+    if (!up) stepDecimal = stepDecimal.negate();
+    const target = (decimalValue.isInvalidate() ? getDecimal(0) : decimalValue).add(stepDecimal.toString());
+    const updatedValue = triggerValueUpdate(target, false);
+    onStep == null ? void 0 : onStep(updatedValue.toNumber(), { offset: shiftKeyRef.current ? getDecupleSteps(step) : step, type: up ? "up" : "down" });
+    (_a = inputRef.current) == null ? void 0 : _a.focus();
+  };
+  const flushInputValue = (userTyping) => {
+    const parsedValue = getDecimal(mergedParser(inputValue));
+    let formatValue;
+    if (!parsedValue.isNaN()) {
+      formatValue = triggerValueUpdate(parsedValue, userTyping);
+    } else {
+      formatValue = triggerValueUpdate(decimalValue, userTyping);
+    }
+    if (value !== void 0) {
+      setInputValue(decimalValue, false);
+    } else if (!formatValue.isNaN()) {
+      setInputValue(formatValue, false);
+    }
+  };
+  const onKeyDown = (event) => {
+    const { key, shiftKey } = event;
+    userTypingRef.current = true;
+    shiftKeyRef.current = shiftKey;
+    if (key === "Enter") {
+      if (!compositionRef.current) userTypingRef.current = false;
+      flushInputValue(false);
+      onPressEnter == null ? void 0 : onPressEnter(event);
+    }
+    if (!keyboard) return;
+    if (!compositionRef.current && (key === "ArrowUp" || key === "ArrowDown")) {
+      onInternalStep(key === "ArrowUp");
+      event.preventDefault();
+    }
+  };
+  const onKeyUp = () => {
+    userTypingRef.current = false;
+    shiftKeyRef.current = false;
+  };
+  const onInternalFocus = (e) => {
+    setFocused(true);
+    onFocus == null ? void 0 : onFocus(e);
+  };
+  const onInternalBlur = (e) => {
+    if (changeOnBlur) flushInputValue(false);
+    setFocused(false);
+    userTypingRef.current = false;
+    onBlur == null ? void 0 : onBlur(e);
+  };
+  const prevValueRef = useRef(value);
+  if (prevValueRef.current !== value) {
+    prevValueRef.current = value;
+    const newValue = getDecimal(value);
+    if (!newValue.equals(decimalValue)) {
+      setDecimalValue(newValue);
+      const currentParsedValue = getDecimal(mergedParser(inputValue));
+      if (!newValue.equals(currentParsedValue) || !userTypingRef.current || formatter) {
+        setInputValue(newValue, userTypingRef.current);
+      }
+    }
+  }
+  const setRefs = (node) => {
+    inputRef.current = node;
+    if (typeof ref === "function") ref(node);
+    else if (ref) ref.current = node;
+  };
+  const controlsEnabled = !!controls;
+  const controlsIcon = typeof controls === "object" ? controls.icon : void 0;
+  const outOfRange = !decimalValue.isInvalidate() && !isInRange(decimalValue);
+  const rootCls = [
+    "bj-input-number",
+    `bj-input-number--${size}`,
+    focused && "bj-input-number--focused",
+    disabled && "bj-input-number--disabled",
+    readOnly && "bj-input-number--readonly",
+    !bordered && "bj-input-number--borderless",
+    status && `bj-input-number--${status}`,
+    outOfRange && "bj-input-number--out-of-range",
+    controlsEnabled && "bj-input-number--with-controls",
+    addonBefore && "bj-input-number--group-left",
+    addonAfter && "bj-input-number--group-right"
+  ].filter(Boolean).join(" ");
+  const numberBox = /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: [rootCls, !(addonBefore || addonAfter || prefix || suffix) && className].filter(Boolean).join(" "),
+      style: !(addonBefore || addonAfter || prefix || suffix) ? style : void 0,
+      onKeyDown,
+      onKeyUp,
+      children: [
+        prefix && /* @__PURE__ */ jsx("span", { className: "bj-input-number__prefix", children: prefix }),
+        /* @__PURE__ */ jsx("div", { className: "bj-input-number__input-wrap", children: /* @__PURE__ */ jsx(
+          "input",
+          {
+            ref: setRefs,
+            id,
+            name,
+            className: "bj-input-number__input",
+            autoComplete: "off",
+            role: "spinbutton",
+            "aria-valuemin": min,
+            "aria-valuemax": max,
+            "aria-valuenow": decimalValue.isInvalidate() ? void 0 : decimalValue.toNumber(),
+            value: inputValue,
+            placeholder,
+            disabled,
+            readOnly,
+            autoFocus,
+            onChange: onInternalInput,
+            onFocus: onInternalFocus,
+            onBlur: onInternalBlur,
+            onCompositionStart,
+            onCompositionEnd,
+            onWheel: changeOnWheel ? (e) => {
+              if (!focused) return;
+              onInternalStep(e.deltaY < 0);
+            } : void 0
+          }
+        ) }),
+        suffix && /* @__PURE__ */ jsx("span", { className: "bj-input-number__suffix", children: suffix }),
+        controlsEnabled && /* @__PURE__ */ jsx(StepHandler, { icon: controlsIcon, upDisabled, downDisabled, onStep: onInternalStep })
+      ]
+    }
+  );
+  if (!addonBefore && !addonAfter) return numberBox;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: ["bj-input-number-group", `bj-input-number-group--${size}`, className].filter(Boolean).join(" "),
+      style,
+      children: [
+        addonBefore && /* @__PURE__ */ jsx("div", { className: "bj-input-number-group__addon", children: addonBefore }),
+        numberBox,
+        addonAfter && /* @__PURE__ */ jsx("div", { className: "bj-input-number-group__addon", children: addonAfter })
+      ]
+    }
+  );
+});
+export {
+  BInputNumber as default
+};

package/dist/web/InputNumber/StepHandler.js

@@ -0,0 +1,69 @@
+"use strict";
+const jsxRuntime = require("react/jsx-runtime");
+const react = require("react");
+const STEP_DELAY = 600;
+const STEP_INTERVAL = 200;
+function SpinnerIcon({ className }) {
+  return /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", className, children: /* @__PURE__ */ jsxRuntime.jsx(
+    "path",
+    {
+      d: "M15.4573 13.6501C15.9047 13.6504 16.129 14.192 15.8128 14.5085L12.3352 17.9851C12.139 18.1811 11.8214 18.1811 11.6253 17.9851L8.14772 14.5085C7.83144 14.192 8.0558 13.6504 8.50319 13.6501H15.4573ZM11.6643 5.98311C11.8606 5.78688 12.179 5.78688 12.3753 5.98311L15.8518 9.45967C16.1683 9.77623 15.944 10.3171 15.4964 10.3171H8.54323C8.09567 10.3171 7.87154 9.77625 8.18776 9.45967L11.6643 5.98311Z",
+      fill: "currentColor"
+    }
+  ) });
+}
+function StepHandler({ icon, upDisabled, downDisabled, onStep }) {
+  const stepTimeoutRef = react.useRef(void 0);
+  const onStepRef = react.useRef(onStep);
+  onStepRef.current = onStep;
+  const onStopStep = () => clearTimeout(stepTimeoutRef.current);
+  const onStepMouseDown = (e, up) => {
+    e.preventDefault();
+    onStopStep();
+    onStepRef.current(up);
+    function loopStep() {
+      onStepRef.current(up);
+      stepTimeoutRef.current = setTimeout(loopStep, STEP_INTERVAL);
+    }
+    stepTimeoutRef.current = setTimeout(loopStep, STEP_DELAY);
+  };
+  react.useEffect(() => onStopStep, []);
+  const sharedProps = {
+    unselectable: "on",
+    role: "button",
+    onMouseUp: onStopStep,
+    onMouseLeave: onStopStep
+  };
+  return (
+    // Click zones come before the icon(s) in DOM order so the icon halves
+    // can be dimmed via a `:hover ~`/`:active ~` sibling selector in CSS —
+    // the icon itself stays `pointer-events: none` and purely visual.
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bj-input-number__handler-wrap", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "span",
+        {
+          ...sharedProps,
+          "aria-label": "Increase Value",
+          "aria-disabled": upDisabled,
+          className: upDisabled ? "bj-input-number__handler bj-input-number__handler--up bj-input-number__handler--disabled" : "bj-input-number__handler bj-input-number__handler--up",
+          onMouseDown: (e) => onStepMouseDown(e, true)
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "span",
+        {
+          ...sharedProps,
+          "aria-label": "Decrease Value",
+          "aria-disabled": downDisabled,
+          className: downDisabled ? "bj-input-number__handler bj-input-number__handler--down bj-input-number__handler--disabled" : "bj-input-number__handler bj-input-number__handler--down",
+          onMouseDown: (e) => onStepMouseDown(e, false)
+        }
+      ),
+      icon || /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(SpinnerIcon, { className: "bj-input-number__handler-icon bj-input-number__handler-icon--up" }),
+        /* @__PURE__ */ jsxRuntime.jsx(SpinnerIcon, { className: "bj-input-number__handler-icon bj-input-number__handler-icon--down" })
+      ] })
+    ] })
+  );
+}
+module.exports = StepHandler;