@nickeylin/antd-mobile-pro 2.0.0

package/dist/es/components/input-captcha/input-captcha.d.ts

@@ -0,0 +1,40 @@
+import { ButtonProps, InputProps } from 'antd-mobile';
+import { NativeProps } from 'antd-mobile/es/utils/native-props';
+import { ReactNode } from 'react';
+export type InputCaptchaProps = NativeProps & Omit<InputProps, 'className' | 'style'> & {
+    inputClassName?: string;
+    inputStyle?: InputProps['style'];
+    /** 获取验证码按钮的 props */
+    captchaProps?: ButtonProps;
+    /** 倒计时秒数，默认值：60s */
+    countDown?: number;
+    /** 渲染计时的文案 */
+    renderCaptchaText?: (timing: boolean, count: number) => ReactNode;
+    /** 获取验证码的自定义请求，resolve后开始倒计时 */
+    request?(): Promise<void>;
+    /** 计时监听 */
+    onTiming?(count: number): void;
+};
+export interface InputCaptchaAction {
+    startTiming(): void;
+    stopTiming(): void;
+}
+declare const InputCaptcha: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    style?: (import("react").CSSProperties & Partial<Record<never, string>>) | undefined;
+    tabIndex?: number | undefined;
+} & import("react").AriaAttributes & Omit<InputProps, "style" | "className"> & {
+    inputClassName?: string | undefined;
+    inputStyle?: InputProps['style'];
+    /** 获取验证码按钮的 props */
+    captchaProps?: ButtonProps | undefined;
+    /** 倒计时秒数，默认值：60s */
+    countDown?: number | undefined;
+    /** 渲染计时的文案 */
+    renderCaptchaText?: ((timing: boolean, count: number) => ReactNode) | undefined;
+    /** 获取验证码的自定义请求，resolve后开始倒计时 */
+    request?(): Promise<void>;
+    /** 计时监听 */
+    onTiming?(count: number): void;
+} & import("react").RefAttributes<InputCaptchaAction>>;
+export default InputCaptcha;

package/dist/es/components/input-captcha/input-captcha.js

@@ -0,0 +1,123 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["className", "style", "placeholder", "inputClassName", "inputStyle", "captchaProps", "countDown", "renderCaptchaText", "request", "onTiming", "readOnly"];
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { Button, Input } from 'antd-mobile';
+import classNames from 'classnames';
+import { forwardRef, useEffect, useImperativeHandle, useRef, useState } from 'react';
+import { cn } from "../../utils/bem";
+import { useConfig } from "../config-provider";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var bem = cn('input-captcha');
+var InputCaptcha = /*#__PURE__*/forwardRef(function (props, ref) {
+  var _useConfig = useConfig(),
+    locale = _useConfig.locale;
+  var className = props.className,
+    style = props.style,
+    _props$placeholder = props.placeholder,
+    placeholder = _props$placeholder === void 0 ? locale.common.inputPlaceholder : _props$placeholder,
+    inputClassName = props.inputClassName,
+    inputStyle = props.inputStyle,
+    captchaProps = props.captchaProps,
+    _props$countDown = props.countDown,
+    countDown = _props$countDown === void 0 ? 60 : _props$countDown,
+    _props$renderCaptchaT = props.renderCaptchaText,
+    renderCaptchaText = _props$renderCaptchaT === void 0 ? function (timing, count) {
+      return timing ? "".concat(count, "s") : locale.InputCaptcha.getCaptcha;
+    } : _props$renderCaptchaT,
+    request = props.request,
+    onTiming = props.onTiming,
+    readOnly = props.readOnly,
+    inputProps = _objectWithoutProperties(props, _excluded);
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    timing = _useState2[0],
+    setTiming = _useState2[1];
+  var _useState3 = useState(countDown),
+    _useState4 = _slicedToArray(_useState3, 2),
+    count = _useState4[0],
+    setCount = _useState4[1];
+  var countDownRef = useRef(countDown);
+  countDownRef.current = countDown;
+  var onTimingRef = useRef(onTiming);
+  onTimingRef.current = onTiming;
+  useEffect(function () {
+    if (timing) {
+      var timerId = window.setInterval(function () {
+        setCount(function (prevCount) {
+          if (prevCount < 1) {
+            setTiming(false);
+            window.clearInterval(timerId);
+            return countDownRef.current;
+          }
+          return prevCount - 1;
+        });
+      }, 1000);
+      return function () {
+        return window.clearInterval(timerId);
+      };
+    } else {
+      setCount(countDownRef.current);
+    }
+  }, [timing]);
+  useEffect(function () {
+    var _onTimingRef$current;
+    (_onTimingRef$current = onTimingRef.current) === null || _onTimingRef$current === void 0 || _onTimingRef$current.call(onTimingRef, count);
+  }, [count]);
+  useImperativeHandle(ref, function () {
+    return {
+      startTiming: function startTiming() {
+        setTiming(true);
+      },
+      stopTiming: function stopTiming() {
+        setTiming(false);
+      }
+    };
+  });
+  return /*#__PURE__*/_jsxs("div", {
+    className: classNames(bem(), className),
+    style: style,
+    children: [/*#__PURE__*/_jsx(Input, _objectSpread({
+      className: bem('input', inputClassName),
+      style: inputStyle,
+      placeholder: placeholder,
+      readOnly: readOnly
+    }, inputProps)), !readOnly && /*#__PURE__*/_jsx(Button, _objectSpread(_objectSpread({
+      fill: "none",
+      size: "small",
+      color: "primary",
+      loading: "auto"
+    }, captchaProps), {}, {
+      className: classNames(bem('send-btn'), captchaProps === null || captchaProps === void 0 ? void 0 : captchaProps.className),
+      disabled: timing,
+      onClick: /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              _context.next = 3;
+              return request === null || request === void 0 ? void 0 : request();
+            case 3:
+              setTiming(true);
+              _context.next = 9;
+              break;
+            case 6:
+              _context.prev = 6;
+              _context.t0 = _context["catch"](0);
+              console.error(_context.t0);
+            case 9:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[0, 6]]);
+      })),
+      children: renderCaptchaText(timing, count)
+    }))]
+  });
+});
+export default InputCaptcha;

package/dist/es/components/input-captcha/style.less

@@ -0,0 +1,12 @@
+@class-prefix-input-captcha: ~'suid-input-captcha';
+
+.@{class-prefix-input-captcha} {
+  display: flex;
+  align-items: center;
+  &__input {
+    flex: 1;
+  }
+  &__send-btn {
+    padding: 8px;
+  }
+}

package/dist/es/components/input-number/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import './input-number.less';
+declare const InputNumber: import("react").ForwardRefExoticComponent<import("./input-number").InputNumberProps & import("react").RefAttributes<import("./input-number").InputNumberRef>> & {
+    Money: import("react").ForwardRefExoticComponent<import("./input-money").InputMoneyProps & import("react").RefAttributes<import("./input-number").InputNumberRef>>;
+};
+export default InputNumber;
+export { type InputMoneyProps } from './input-money';
+export { type InputNumberProps, type InputNumberRef } from './input-number';

package/dist/es/components/input-number/index.js

@@ -0,0 +1,7 @@
+import InputMoney from "./input-money";
+import _InputNumber from "./input-number";
+import "./input-number.less";
+var InputNumber = Object.assign(_InputNumber, {
+  Money: InputMoney
+});
+export default InputNumber;

package/dist/es/components/input-number/input-money.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { InputNumberProps, InputNumberRef } from './input-number';
+export type InputMoneyProps = InputNumberProps & {
+    thousands?: boolean;
+};
+declare const InputMoney: import("react").ForwardRefExoticComponent<InputMoneyProps & import("react").RefAttributes<InputNumberRef>>;
+export default InputMoney;

package/dist/es/components/input-number/input-money.js

@@ -0,0 +1,52 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["thousands", "allowEmpty", "digits", "min", "formatter", "parser"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { toThousandsAmount } from '@nickeylin/rc-utils';
+import { forwardRef, useCallback, useMemo } from 'react';
+import { useConfig } from "../config-provider";
+import InputNumber from "./input-number";
+import { jsx as _jsx } from "react/jsx-runtime";
+var InnerInputMoney = function InnerInputMoney(_ref, ref) {
+  var thousandsProp = _ref.thousands,
+    _ref$allowEmpty = _ref.allowEmpty,
+    allowEmpty = _ref$allowEmpty === void 0 ? true : _ref$allowEmpty,
+    _ref$digits = _ref.digits,
+    digits = _ref$digits === void 0 ? 2 : _ref$digits,
+    _ref$min = _ref.min,
+    min = _ref$min === void 0 ? 0 : _ref$min,
+    formatter = _ref.formatter,
+    parser = _ref.parser,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var _useConfig = useConfig(),
+    inputMoney = _useConfig.inputMoney;
+  var thousands = useMemo(function () {
+    var _ref2;
+    return (_ref2 = thousandsProp !== null && thousandsProp !== void 0 ? thousandsProp : inputMoney === null || inputMoney === void 0 ? void 0 : inputMoney.thousands) !== null && _ref2 !== void 0 ? _ref2 : true;
+  }, [inputMoney === null || inputMoney === void 0 ? void 0 : inputMoney.thousands, thousandsProp]);
+  var defaultFormatter = useCallback(function (value) {
+    if (value === 0) return 0;
+    if (thousands) {
+      var _toThousandsAmount;
+      return (_toThousandsAmount = toThousandsAmount(value)) !== null && _toThousandsAmount !== void 0 ? _toThousandsAmount : '';
+    }
+    if (typeof value == 'undefined') return '';
+    return "".concat(value);
+  }, [thousands]);
+  var defaultParser = useCallback(function (text) {
+    if (!text) return '';
+    return text.replace(/,*/g, '');
+  }, []);
+  return /*#__PURE__*/_jsx(InputNumber, _objectSpread(_objectSpread({
+    min: min
+  }, props), {}, {
+    ref: ref,
+    allowEmpty: allowEmpty,
+    digits: digits,
+    formatter: formatter !== null && formatter !== void 0 ? formatter : defaultFormatter,
+    parser: parser !== null && parser !== void 0 ? parser : defaultParser
+  }));
+};
+var InputMoney = /*#__PURE__*/forwardRef(InnerInputMoney);
+export default InputMoney;

package/dist/es/components/input-number/input-number.d.ts

@@ -0,0 +1,38 @@
+import { InputProps, InputRef } from 'antd-mobile';
+import { NativeProps } from 'antd-mobile/es/utils/native-props';
+import React, { ReactNode } from 'react';
+type ValueProps<ValueType> = {
+    allowEmpty: true;
+    value?: ValueType | null;
+    defaultValue?: ValueType | null;
+    onChange?: (value: ValueType | null) => void;
+};
+type ValuePropsWithNull<ValueType> = {
+    allowEmpty?: false;
+    value?: ValueType;
+    defaultValue?: ValueType;
+    onChange?: (value: ValueType) => void;
+};
+export type BaseInputNumberProps<ValueType> = Pick<InputProps, 'onFocus' | 'onBlur' | 'placeholder' | 'readOnly'> & (ValuePropsWithNull<ValueType> | ValueProps<ValueType>) & {
+    min?: ValueType;
+    max?: ValueType;
+    step?: ValueType;
+    digits?: number;
+    disabled?: boolean;
+    showStepper?: boolean;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    parser?: (text: string) => ValueType;
+    formatter?: (value?: ValueType) => string;
+} & NativeProps<'--input-font-size' | '--input-color' | '--input-placeholder-color' | '--input-text-align' | '--stepper-height' | '--stepper-background-color' | '--input-prefix-color' | '--input-suffix-color'>;
+export type InputNumberNumberProps = BaseInputNumberProps<number> & {
+    stringMode?: false;
+};
+export type InputNumberStringProps = BaseInputNumberProps<string> & {
+    stringMode: true;
+};
+export type InputNumberProps = InputNumberNumberProps | InputNumberStringProps;
+export type InputNumberRef = Pick<InputRef, 'blur' | 'focus' | 'nativeElement'>;
+export declare function InnerInputNumber<ValueType extends number | string>(p: InputNumberProps, ref: React.ForwardedRef<InputNumberRef>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+declare const InputNumber: React.ForwardRefExoticComponent<InputNumberProps & React.RefAttributes<InputNumberRef>>;
+export default InputNumber;

package/dist/es/components/input-number/input-number.js

@@ -0,0 +1,261 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import getMiniDecimal, { toFixed } from '@rc-component/mini-decimal';
+import { Button, Input } from 'antd-mobile';
+import { AddOutline, MinusOutline } from 'antd-mobile-icons';
+import { withNativeProps } from 'antd-mobile/es/utils/native-props';
+import { mergeProps } from 'antd-mobile/es/utils/with-default-props';
+import { useMergedState } from 'rc-util';
+import React, { forwardRef, useEffect, useImperativeHandle, useState } from 'react';
+import { cn } from "../../utils/bem";
+import { useConfig } from "../config-provider";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var bem = cn('input-money');
+var defaultProps = {
+  step: 1,
+  disabled: false,
+  allowEmpty: true
+};
+export function InnerInputNumber(p, ref) {
+  var props = mergeProps(defaultProps, p);
+  var _ref = props,
+    _ref$defaultValue = _ref.defaultValue,
+    defaultValue = _ref$defaultValue === void 0 ? props.allowEmpty ? null : 0 : _ref$defaultValue,
+    value = _ref.value,
+    _onChange = _ref.onChange,
+    disabled = _ref.disabled,
+    placeholder = _ref.placeholder,
+    readOnly = _ref.readOnly,
+    _ref$step = _ref.step,
+    step = _ref$step === void 0 ? 1 : _ref$step,
+    max = _ref.max,
+    min = _ref.min,
+    digits = _ref.digits,
+    stringMode = _ref.stringMode,
+    showStepper = _ref.showStepper,
+    prefix = _ref.prefix,
+    suffix = _ref.suffix,
+    formatter = _ref.formatter,
+    parser = _ref.parser;
+  var _useConfig = useConfig(),
+    locale = _useConfig.locale;
+  var inputRef = React.useRef(null);
+
+  // ========================== Ref ==========================
+  useImperativeHandle(ref, function () {
+    return {
+      focus: function focus() {
+        var _inputRef$current;
+        (_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 || _inputRef$current.focus();
+      },
+      blur: function blur() {
+        var _inputRef$current2;
+        (_inputRef$current2 = inputRef.current) === null || _inputRef$current2 === void 0 || _inputRef$current2.blur();
+      },
+      get nativeElement() {
+        var _inputRef$current$nat, _inputRef$current3;
+        return (_inputRef$current$nat = (_inputRef$current3 = inputRef.current) === null || _inputRef$current3 === void 0 ? void 0 : _inputRef$current3.nativeElement) !== null && _inputRef$current$nat !== void 0 ? _inputRef$current$nat : null;
+      }
+    };
+  });
+
+  // ========================== Parse / Format ==========================
+  var fixedValue = function fixedValue(value) {
+    var fixedValue = digits !== undefined ? toFixed(value.toString(), '.', digits) : value;
+    return fixedValue.toString();
+  };
+  var getValueAsType = function getValueAsType(value) {
+    return stringMode ? value.toString() : value.toNumber();
+  };
+  var parseValue = function parseValue(text) {
+    if (text === '') return null;
+    if (parser) {
+      return String(parser(text));
+    }
+    var decimal = getMiniDecimal(text);
+    return decimal.isInvalidate() ? null : decimal.toString();
+  };
+  var formatValue = function formatValue(value) {
+    if (value === null) return '';
+    return formatter ? formatter(value) : fixedValue(value);
+  };
+
+  // ======================== Value & InputValue ========================
+  var _useMergedState = useMergedState(defaultValue, {
+      value: value,
+      onChange: function onChange(nextValue) {
+        _onChange === null || _onChange === void 0 || _onChange(nextValue);
+      }
+    }),
+    _useMergedState2 = _slicedToArray(_useMergedState, 2),
+    mergedValue = _useMergedState2[0],
+    setMergedValue = _useMergedState2[1];
+  var _useState = useState(function () {
+      return formatValue(mergedValue);
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    inputValue = _useState2[0],
+    setInputValue = _useState2[1];
+
+  // >>>>> Value
+  function setValueWithCheck(nextValue) {
+    if (nextValue.isNaN()) return;
+    var target = nextValue;
+
+    // Put into range
+    if (min !== undefined) {
+      var minDecimal = getMiniDecimal(min);
+      if (target.lessEquals(minDecimal)) {
+        target = minDecimal;
+      }
+    }
+    if (max !== undefined) {
+      var maxDecimal = getMiniDecimal(max);
+      if (maxDecimal.lessEquals(target)) {
+        target = maxDecimal;
+      }
+    }
+
+    // Fix digits
+    if (digits !== undefined) {
+      target = getMiniDecimal(fixedValue(getValueAsType(target)));
+    }
+    setMergedValue(getValueAsType(target));
+  }
+
+  // >>>>> Input
+  var handleInputChange = function handleInputChange(v) {
+    setInputValue(v);
+    var valueStr = parseValue(v);
+    if (valueStr === null) {
+      if (props.allowEmpty) {
+        setMergedValue(null);
+      } else {
+        setMergedValue(defaultValue);
+      }
+    } else {
+      setValueWithCheck(getMiniDecimal(valueStr));
+    }
+  };
+
+  // ============================== Focus ===============================
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    focused = _useState4[0],
+    setFocused = _useState4[1];
+  function triggerFocus(nextFocus) {
+    setFocused(nextFocus);
+
+    // We will convert value to original text when focus
+    if (nextFocus) {
+      setInputValue(mergedValue !== null && mergedValue !== undefined && mergedValue != 0 ? String(mergedValue) : '');
+    }
+  }
+
+  // Focus change to format value
+  useEffect(function () {
+    if (!focused) {
+      setInputValue(formatValue(mergedValue));
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [focused, mergedValue, digits]);
+
+  // ============================ Operations ============================
+  var handleOffset = function handleOffset(positive) {
+    var stepValue = getMiniDecimal(step);
+    if (!positive) {
+      stepValue = stepValue.negate();
+    }
+    setValueWithCheck(getMiniDecimal(mergedValue !== null && mergedValue !== void 0 ? mergedValue : 0).add(stepValue.toString()));
+  };
+  var handleMinus = function handleMinus() {
+    handleOffset(false);
+  };
+  var handlePlus = function handlePlus() {
+    handleOffset(true);
+  };
+  var minusDisabled = function minusDisabled() {
+    if (disabled) return true;
+    if (mergedValue === null) return false;
+    if (min !== undefined) {
+      return mergedValue <= min;
+    }
+    return false;
+  };
+  var plusDisabled = function plusDisabled() {
+    if (disabled) return true;
+    if (mergedValue === null) return false;
+    if (max !== undefined) {
+      return mergedValue >= max;
+    }
+    return false;
+  };
+  var buttonProps = {
+    fill: 'none',
+    shape: 'rectangular',
+    color: 'primary',
+    size: 'small'
+  };
+  // ============================== Render ==============================
+  return withNativeProps(props, /*#__PURE__*/_jsxs("div", {
+    className: bem({
+      active: focused,
+      stepper: showStepper
+    }),
+    children: [showStepper && !readOnly && /*#__PURE__*/_jsx(Button, _objectSpread(_objectSpread({
+      className: bem('minus'),
+      onClick: handleMinus,
+      disabled: minusDisabled(),
+      "aria-label": locale.Stepper.decrease
+    }, buttonProps), {}, {
+      children: /*#__PURE__*/_jsx(MinusOutline, {})
+    })), /*#__PURE__*/_jsxs("div", {
+      className: bem('input-wrap'),
+      children: [prefix && /*#__PURE__*/_jsx("div", {
+        className: bem('prefix'),
+        children: prefix
+      }), /*#__PURE__*/_jsx(Input, {
+        ref: inputRef,
+        className: bem('input'),
+        onFocus: function onFocus(e) {
+          var _props$onFocus;
+          triggerFocus(true);
+          (_props$onFocus = props.onFocus) === null || _props$onFocus === void 0 || _props$onFocus.call(props, e);
+        },
+        value: inputValue,
+        onChange: function onChange(val) {
+          disabled || handleInputChange(val);
+        },
+        disabled: disabled,
+        onBlur: function onBlur(e) {
+          var _props$onBlur;
+          triggerFocus(false);
+          (_props$onBlur = props.onBlur) === null || _props$onBlur === void 0 || _props$onBlur.call(props, e);
+        },
+        readOnly: readOnly,
+        placeholder: placeholder,
+        role: "spinbutton",
+        "aria-valuenow": Number(inputValue),
+        "aria-valuemax": Number(max),
+        "aria-valuemin": Number(min),
+        inputMode: "decimal",
+        clearable: props.allowEmpty
+      }), suffix && /*#__PURE__*/_jsx("div", {
+        className: bem('suffix'),
+        children: suffix
+      })]
+    }), showStepper && !readOnly && /*#__PURE__*/_jsx(Button, _objectSpread(_objectSpread({
+      className: bem('plus'),
+      onClick: handlePlus,
+      disabled: plusDisabled(),
+      "aria-label": locale.Stepper.increase
+    }, buttonProps), {}, {
+      children: /*#__PURE__*/_jsx(AddOutline, {})
+    }))]
+  }));
+}
+var InputNumber = /*#__PURE__*/forwardRef(InnerInputNumber);
+export default InputNumber;

package/dist/es/components/input-number/input-number.less

@@ -0,0 +1,62 @@
+@class-prefix-input-money: ~'suid-input-money';
+
+.@{class-prefix-input-money} {
+  display: flex;
+  align-items: center;
+  &__input-wrap {
+    flex: 1;
+    display: flex;
+    align-items: center;
+  }
+
+  & &__input {
+    --font-size: var(--input-font-size);
+    --color: var(--input-color);
+    --placeholder-color: var(--input-placeholder-color, var(--adm-color-light));
+    --text-align: var(--input-text-align);
+  }
+  &__prefix {
+    margin-right: 5px;
+    color: var(--input-prefix-color);
+  }
+  &__suffix {
+    margin-left: 5px;
+    color: var(--input-suffix-color);
+  }
+
+  &--stepper &__minus,
+  &--stepper &__plus {
+    height: var(--stepper-height);
+    flex: 0 0 var(--stepper-height);
+    padding: 0;
+    background-color: var(--stepper-background-color);
+  }
+
+  &--stepper &__input-wrap {
+    height: var(--stepper-height);
+    background-color: var(--stepper-background-color);
+    margin: 0 5px;
+    padding-left: 5px;
+    padding-right: 5px;
+  }
+}
+
+.@{class-prefix-input-money} {
+  --input-prefix-color: var(
+    --suid-input-number-prefix-color,
+    var(--adm-color-weak)
+  );
+  --input-suffix-color: var(
+    --suid-input-number-suffix-color,
+    var(--adm-color-weak)
+  );
+  --input-font-size: var(--suid-input-number-font-size);
+  --input-color: var(--suid-input-number-color);
+  --input-placeholder-color: var(--suid-input-number-placeholder-color);
+  --input-text-align: var(--suid-input-number-text-align);
+  --stepper-height: var(--suid-input-number-stepper-height, 28px);
+  --stepper-background-color: var(
+    --suid-input-number-stepper-background-color,
+    var(--adm-color-fill-content)
+  );
+}

package/dist/es/components/input-password/index.d.ts

@@ -0,0 +1,4 @@
+import InputPassword from './input-password';
+import './style.less';
+export { type InputPasswordProps } from './input-password';
+export default InputPassword;

package/dist/es/components/input-password/index.js

@@ -0,0 +1,3 @@
+import InputPassword from "./input-password";
+import "./style.less";
+export default InputPassword;

package/dist/es/components/input-password/input-password.d.ts

@@ -0,0 +1,12 @@
+import { ButtonProps, InputProps } from 'antd-mobile';
+import { NativeProps } from 'antd-mobile/es/utils/native-props';
+import { FC, ReactNode } from 'react';
+export type InputPasswordProps = NativeProps & Omit<InputProps, 'type' | 'className' | 'style'> & {
+    inputClassName?: string;
+    inputStyle?: InputProps['style'];
+    visible?: boolean;
+    onVisibleChange?(v: boolean): void;
+    renderToggle?: false | ((visible: boolean, props: ButtonProps) => ReactNode);
+};
+declare const InputPassword: FC<InputPasswordProps>;
+export default InputPassword;