shopee-ui-react 0.0.1-security → 2.10.49

package/es/components/input/Input.js

@@ -0,0 +1,468 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import React, { forwardRef, useRef, useState, useMemo, useImperativeHandle } from 'react';
+import classNames from 'classnames';
+import RcTextArea from 'rc-textarea';
+import stopPropagationHandler from '../../utils/stopPropagationHandler';
+import { isRegExp } from '../../utils/helper';
+import useMergedState from '../../hooks/useMergedState';
+import Icon from '../icon';
+import ConfigProvider from '../config-provider';
+import { formatValue } from './utils';
+var Input = /*#__PURE__*/forwardRef(function (props, ref) {
+  var value = props.value,
+      defaultValue = props.defaultValue,
+      maxLength = props.maxLength,
+      unicodeNormalized = props.unicodeNormalized,
+      type = props.type,
+      precision = props.precision,
+      restriction = props.restriction,
+      isRound = props.isRound,
+      min = props.min,
+      max = props.max,
+      resize = props.resize,
+      autosize = props.autosize,
+      disableEnter = props.disableEnter,
+      customizePlaceholder = props.placeholder,
+      restrictionType = props.restrictionType,
+      suspendBeforeClear = props.suspendBeforeClear,
+      disabled = props.disabled,
+      customizePrefixCls = props.prefixCls,
+      help = props.help,
+      helpText = props.helpText,
+      warningText = props.warningText,
+      error = props.error,
+      errorMessage = props.errorMessage,
+      showWordLimit = props.showWordLimit,
+      clearable = props.clearable,
+      propsClassName = props.className,
+      rows = props.rows,
+      containerRef = props.containerRef,
+      prefixLabel = props.prefixLabel,
+      prefixIcon = props.prefixIcon,
+      prefix = props.prefix,
+      suffix = props.suffix,
+      suffixLabel = props.suffixLabel,
+      suffixIcon = props.suffixIcon,
+      size = props.size,
+      focusHighLight = props.focusHighLight,
+      bordered = props.bordered,
+      formatter = props.formatter,
+      parser = props.parser,
+      onSuffixIconClicked = props.onSuffixIconClicked,
+      onPrefixIconClicked = props.onPrefixIconClicked,
+      onChange = props.onChange,
+      onClick = props.onClick,
+      onFocus = props.onFocus,
+      onBlur = props.onBlur,
+      onClear = props.onClear,
+      onPressEnter = props.onPressEnter,
+      onKeyPress = props.onKeyPress;
+
+  if (formatter && !parser || parser && !formatter) {
+    // eslint-disable-next-line no-console
+    console.warn('[ShopeeUIReact warn][Input]: formatter should use with parser in number input');
+  }
+
+  if (showWordLimit && !maxLength) {
+    // eslint-disable-next-line no-console
+    console.warn('[ShopeeUIReact warn][Input]: showWordLimit should use with maxLength in text input');
+  }
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      focused = _useState2[0],
+      setFocused = _useState2[1];
+
+  var focusRef = useRef(false);
+  var inputRef = useRef();
+  var textareaRef = useRef();
+
+  var _useMergedState = useMergedState('', {
+    value: value,
+    defaultValue: defaultValue,
+    onChange: onChange,
+    postState: function postState(val) {
+      var result = formatValue(val, {
+        unicodeNormalized: unicodeNormalized,
+        maxLength: maxLength,
+        type: type,
+        isFocus: focusRef.current,
+        max: max,
+        min: min,
+        precision: precision,
+        isRound: isRound
+      });
+      return result;
+    }
+  }),
+      _useMergedState2 = _slicedToArray(_useMergedState, 2),
+      currentValue = _useMergedState2[0],
+      setCurrentValue = _useMergedState2[1];
+
+  var displayValue = useMemo(function () {
+    var result = typeof formatter === 'function' ? formatter(currentValue) : currentValue;
+    return result;
+  }, [currentValue, formatter]);
+
+  var _React$useContext = React.useContext(ConfigProvider.ConfigContext),
+      getPrefixCls = _React$useContext.getPrefixCls,
+      contextLocale = _React$useContext.locale;
+
+  var locale = contextLocale.Input;
+  var prefixCls = getPrefixCls('input', customizePrefixCls);
+  var placeholder = useMemo(function () {
+    return customizePlaceholder || locale.placeholder;
+  }, [customizePlaceholder, locale]);
+  var computedRestriction = useMemo(function () {
+    if (restriction) {
+      return restriction;
+    }
+
+    if (type === 'numeric') {
+      var decimalExp = precision === 0 ? '' : '\\.{0,1}';
+      var rangExp = precision === undefined ? '*' : "{0,".concat(precision, "}");
+      return new RegExp("^-?(\\d+".concat(decimalExp, "\\d").concat(rangExp, ")?$"));
+    }
+  }, [restriction, type, precision]);
+  var computedPlaceholder = useMemo(function () {
+    var base = 0;
+    var isNumber = type === 'numeric';
+    var result = isNumber ? placeholder || base.toFixed(precision) : placeholder;
+    return result === undefined ? 'Input' : result;
+  }, [type, placeholder, precision]);
+  var computedRestrictionType = useMemo(function () {
+    return type === 'numeric' ? 'value' : restrictionType;
+  }, [type, restrictionType]);
+  var nativeProps = useMemo(function () {
+    // remove below props when using v-bind at native input
+    var removeProps = ['value', 'defaultValue', 'rows', 'resize', 'bordered', 'containerRef', 'restriction', 'error', 'errorMessage', 'prefix', 'suffix', 'prefixLabel', 'prefixIcon', 'suffixLabel', 'suffixIcon', 'showWordLimit', 'helpText', 'warningText', 'autosize', 'className', 'prefixCls', 'placeholder', 'focusHighLight', 'disableEnter', 'onClear', 'onChange', 'clearable', 'onFoucs', 'onBlur', 'onPressEnter', 'onSuffixIconClicked', 'onPrefixIconClicked', 'formatter', 'parser'];
+    var result = {};
+    Object.keys(props).forEach(function (key) {
+      if (key === 'restrictionType') {
+        // eslint-disable-next-line no-param-reassign
+        key = key.toLowerCase();
+      }
+
+      if (unicodeNormalized) {
+        removeProps.push('maxLength');
+      }
+
+      if (!removeProps.includes(key)) {
+        // eslint-disable-next-line react/destructuring-assignment
+        var propValue = props[key];
+        result[key] = _typeof(propValue) === 'object' ? Object.assign({}, propValue) : propValue;
+      }
+    });
+    return result;
+  }, [props, unicodeNormalized]); // ------- start: local handlers -------
+
+  var triggerFocus = function triggerFocus() {
+    if (type === 'textarea' && textareaRef.current) {
+      textareaRef.current.focus();
+    } else if (inputRef.current) {
+      inputRef.current.focus();
+    }
+  };
+
+  var triggerBlur = function triggerBlur() {
+    if (type === 'textarea' && textareaRef.current) {
+      textareaRef.current.blur();
+    } else if (inputRef.current) {
+      inputRef.current.blur();
+    }
+  };
+
+  var restrictionTest = function restrictionTest(val) {
+    if (typeof computedRestriction === 'function') {
+      return computedRestriction(val);
+    }
+
+    if (isRegExp(computedRestriction)) {
+      return computedRestriction.test(val);
+    }
+
+    if (computedRestriction === 'number') {
+      return /^\d*$/.test(val);
+    }
+
+    return true;
+  };
+
+  var computedClassName = useMemo(function () {
+    var _classNames;
+
+    return classNames("".concat(prefixCls, "__inner"), ["".concat(prefixCls, "__inner--").concat(size || 'normal')], (_classNames = {
+      focused: focused,
+      disabled: disabled,
+      error: error
+    }, _defineProperty(_classNames, "".concat(prefixCls, "__borderless"), !bordered), _defineProperty(_classNames, 'active-clearable', clearable && !!currentValue && currentValue.length), _defineProperty(_classNames, 'high-light', focusHighLight), _classNames));
+  }, [prefixCls, size, focused, disabled, error, bordered, clearable, focusHighLight, currentValue]); // ------- end: local handlers -------
+  // ------- start: event handlers -------
+
+  /**
+   * 默认在clearable状态下点击X会清空value，若为true则不清空
+   */
+
+  var suspendBeforeClearTest = function suspendBeforeClearTest() {
+    if (typeof suspendBeforeClear === 'function') {
+      return suspendBeforeClear();
+    }
+
+    if (typeof suspendBeforeClear === 'boolean') {
+      return suspendBeforeClear;
+    }
+
+    return false;
+  };
+
+  var hanldeClear = function hanldeClear(event) {
+    if (disabled) {
+      return;
+    }
+
+    if (!suspendBeforeClearTest()) {
+      setCurrentValue('');
+    }
+
+    triggerFocus();
+    stopPropagationHandler(event);
+
+    if (onClear) {
+      onClear(event);
+    }
+  };
+
+  var handleKeyPress = function handleKeyPress(event) {
+    var code = event.key;
+
+    if (code === 'Enter') {
+      if (typeof onPressEnter === 'function') {
+        onPressEnter();
+      }
+
+      if (disableEnter) {
+        event.preventDefault();
+      }
+    }
+
+    if (typeof onKeyPress === 'function') {
+      onKeyPress(event);
+    }
+  };
+
+  var handleClick = function handleClick(event) {
+    if (typeof onClick === 'function') {
+      onClick(event);
+    }
+  };
+
+  var handleFocus = function handleFocus(event) {
+    focusRef.current = true;
+    setFocused(true);
+
+    if (typeof onFocus === 'function') {
+      onFocus(event);
+    }
+  };
+
+  var handleBlur = function handleBlur(event) {
+    focusRef.current = false;
+    setFocused(false);
+    Promise.resolve().then(function () {
+      setCurrentValue(currentValue);
+
+      if (typeof onBlur === 'function') {
+        onBlur(event);
+      }
+    });
+  };
+
+  var handleChange = function handleChange(event) {
+    if (computedRestriction) {
+      var isRestrictInput = computedRestrictionType === 'input';
+      var dataToCheck = isRestrictInput ? event.nativeEvent.data : event.target.value;
+      dataToCheck = typeof parser === 'function' ? parser(dataToCheck) : dataToCheck; // 如果没通过检测，就不会改变值
+
+      if ((!isRestrictInput || dataToCheck) && !restrictionTest(dataToCheck)) {
+        inputRef.current.value = currentValue;
+        return;
+      }
+    }
+
+    var newValue = event.target.value;
+    newValue = typeof parser === 'function' ? parser(newValue) : newValue;
+    setCurrentValue(newValue);
+  }; // ------- end: event handlers -------
+  // ------- start: export methods -------
+
+
+  useImperativeHandle(ref, function () {
+    return {
+      focus: function focus() {
+        triggerFocus();
+      },
+      blur: function blur() {
+        triggerBlur();
+      }
+    };
+  }); // ------- end: export methods -------
+  // ------- start: render methods -------
+
+  /** 渲染 help */
+
+  var renderHelp = function renderHelp() {
+    var isRenderHelpText = helpText && !help;
+    return /*#__PURE__*/React.createElement(React.Fragment, null, isRenderHelpText && /*#__PURE__*/React.createElement("p", {
+      className: "".concat(prefixCls, "__help-text") // eslint-disable-next-line react/no-danger
+      ,
+      dangerouslySetInnerHTML: {
+        __html: helpText
+      }
+    }), help && /*#__PURE__*/React.createElement("div", {
+      className: "".concat(prefixCls, "t__help-text")
+    }, help));
+  };
+
+  var renderWarning = function renderWarning() {
+    return warningText ? /*#__PURE__*/React.createElement("div", {
+      className: "".concat(prefixCls, "__warning-text")
+    }, /*#__PURE__*/React.createElement(Icon, {
+      type: "notice-circle-s"
+    }), warningText) : /*#__PURE__*/React.createElement(React.Fragment, null);
+  };
+  /** 渲染 error */
+
+
+  var renderError = function renderError() {
+    return error ? /*#__PURE__*/React.createElement("p", {
+      className: "".concat(prefixCls, "__error-msg") // eslint-disable-next-line react/no-danger
+      ,
+      dangerouslySetInnerHTML: {
+        __html: errorMessage
+      }
+    }) : /*#__PURE__*/React.createElement(React.Fragment, null);
+  };
+  /** 渲染 limit */
+
+
+  var renderWordLimit = function renderWordLimit() {
+    var textLength = currentValue ? currentValue.length : 0;
+    var isWordLimitVisible = showWordLimit && maxLength && ['text', 'textarea'].includes(type);
+    return isWordLimitVisible ? /*#__PURE__*/React.createElement("span", {
+      className: "".concat(prefixCls, "__count")
+    }, "".concat(textLength, "/").concat(maxLength)) : /*#__PURE__*/React.createElement(React.Fragment, null);
+  };
+  /** 渲染 input 前缀 */
+
+
+  var renderInputPrefix = function renderInputPrefix() {
+    var hasPrefix = prefixLabel || prefixIcon || prefix;
+    var prefixIconNode = typeof prefixIcon === 'string' ? /*#__PURE__*/React.createElement(Icon, {
+      className: "".concat(prefixCls, "__prefix-icon"),
+      type: prefixIcon
+    }) : prefixIcon;
+    return hasPrefix ? /*#__PURE__*/React.createElement("div", {
+      className: "".concat(prefixCls, "__prefix")
+    }, !!prefixLabel && /*#__PURE__*/React.createElement(React.Fragment, null, prefixLabel, /*#__PURE__*/React.createElement("span", {
+      className: "".concat(prefixCls, "__prefix-split")
+    })), prefixIconNode && /*#__PURE__*/React.createElement("span", {
+      onClick: function onClick() {
+        return onPrefixIconClicked && onPrefixIconClicked();
+      }
+    }, prefixIconNode), prefix) : /*#__PURE__*/React.createElement(React.Fragment, null);
+  };
+  /** 渲染 input 后缀 */
+
+
+  var renderInputSuffix = function renderInputSuffix() {
+    var isWordLimitVisible = showWordLimit && maxLength && ['text', 'textarea'].includes(type) && !disabled;
+    var hasExtaContent = suffix || suffixLabel || suffixIcon || isWordLimitVisible;
+    var hasSuffix = clearable || hasExtaContent;
+    var suffixIconNode = typeof suffixIcon === 'string' ? /*#__PURE__*/React.createElement(Icon, {
+      className: "".concat(prefixCls, "__suffix-icon"),
+      type: suffixIcon
+    }) : suffixIcon;
+    return hasSuffix ? /*#__PURE__*/React.createElement("div", {
+      className: classNames("".concat(prefixCls, "__suffix"), _defineProperty({}, "".concat(prefixCls, "__suffix-padding"), hasExtaContent))
+    }, clearable && /*#__PURE__*/React.createElement(Icon, {
+      onClick: hanldeClear,
+      className: "".concat(prefixCls, "__clear-btn"),
+      type: "round-close-s"
+    }), suffixLabel && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
+      className: "".concat(prefixCls, "__suffix-split")
+    }), suffixLabel), !suffixLabel && renderWordLimit(), suffixIconNode && /*#__PURE__*/React.createElement("span", {
+      onClick: function onClick() {
+        return onSuffixIconClicked && onSuffixIconClicked();
+      }
+    }, suffixIconNode), suffix) : /*#__PURE__*/React.createElement(React.Fragment, null);
+  };
+
+  var renderInput = function renderInput() {
+    return /*#__PURE__*/React.createElement("div", {
+      ref: containerRef,
+      className: classNames(prefixCls, propsClassName),
+      onClick: handleClick
+    }, /*#__PURE__*/React.createElement("div", {
+      className: computedClassName
+    }, renderInputPrefix(), /*#__PURE__*/React.createElement("input", _extends({
+      className: "".concat(prefixCls, "__input"),
+      ref: inputRef,
+      type: type,
+      value: displayValue,
+      placeholder: computedPlaceholder
+    }, nativeProps, {
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      onChange: handleChange,
+      onKeyPress: handleKeyPress
+    })), renderInputSuffix()), renderError(), renderHelp(), renderWarning());
+  };
+
+  var renderTextarea = function renderTextarea() {
+    return /*#__PURE__*/React.createElement("div", {
+      ref: containerRef,
+      className: classNames(prefixCls, "".concat(prefixCls, "__area"), propsClassName),
+      onClick: handleClick
+    }, /*#__PURE__*/React.createElement(RcTextArea, _extends({}, nativeProps, {
+      ref: textareaRef,
+      prefixCls: "".concat(prefixCls, "__textarea"),
+      autoSize: autosize,
+      className: computedClassName,
+      value: displayValue,
+      rows: rows,
+      style: {
+        resize: resize
+      },
+      onChange: handleChange,
+      maxLength: maxLength,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      onPressEnter: onPressEnter,
+      placeholder: computedPlaceholder
+    })), clearable && /*#__PURE__*/React.createElement("span", {
+      className: "".concat(prefixCls, "__clear-btn"),
+      onClick: hanldeClear
+    }, /*#__PURE__*/React.createElement(Icon, {
+      type: "round-close-s"
+    })), renderWordLimit(), renderError(), renderHelp(), renderWarning());
+  }; // ------- end: render methods -------
+
+
+  var component = type === 'textarea' ? renderTextarea() : renderInput();
+  return component;
+});
+Input.defaultProps = {
+  type: 'text',
+  resize: 'vertical',
+  bordered: true,
+  defaultValue: '',
+  rows: 2,
+  restrictionType: 'input',
+  placeholder: '',
+  focusHighLight: false,
+  disableEnter: true
+};
+export default Input;

package/es/components/input/InputGroup.d.ts

@@ -0,0 +1,4 @@
+import { FunctionComponent } from 'react';
+import { InputGroupProps } from './types';
+declare const InputGroup: FunctionComponent<InputGroupProps>;
+export default InputGroup;

package/es/components/input/InputGroup.js

@@ -0,0 +1,33 @@
+import React from 'react';
+import ConfigProvider from '../config-provider';
+
+var InputGroup = function InputGroup(props) {
+  var customizePrefixCls = props.prefixCls,
+      _props$prependWidth = props.prependWidth,
+      prependWidth = _props$prependWidth === void 0 ? 120 : _props$prependWidth,
+      appendWidth = props.appendWidth,
+      prepend = props.prepend,
+      append = props.append,
+      children = props.children;
+
+  var _React$useContext = React.useContext(ConfigProvider.ConfigContext),
+      getPrefixCls = _React$useContext.getPrefixCls;
+
+  var prefixCls = getPrefixCls('input-group', customizePrefixCls);
+  var appendStyle = appendWidth ? {
+    width: "".concat(appendWidth, "px")
+  } : undefined;
+  return /*#__PURE__*/React.createElement("div", {
+    className: prefixCls
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "__prepend"),
+    style: {
+      width: "".concat(prependWidth, "px")
+    }
+  }, prepend), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "__append"),
+    style: appendStyle
+  }, append), !prepend && !append && children);
+};
+
+export default InputGroup;

package/es/components/input/index.d.ts

@@ -0,0 +1,8 @@
+import Input from './Input';
+import InputGroup from './InputGroup';
+declare type InternalInputType = typeof Input;
+interface ExportInputInterface extends InternalInputType {
+    Group: typeof InputGroup;
+}
+declare const InputExport: ExportInputInterface;
+export default InputExport;

package/es/components/input/index.js

@@ -0,0 +1,5 @@
+import Input from './Input';
+import InputGroup from './InputGroup';
+var InputExport = Input;
+InputExport.Group = InputGroup;
+export default InputExport;

package/es/components/input/types.d.ts

@@ -0,0 +1,126 @@
+import React from 'react';
+export declare type Size = 'x-large' | 'large' | 'normal' | 'small';
+export declare type RestrictionType = 'value' | 'input';
+declare type Resize = 'vertical' | 'both' | 'horizontal' | 'none';
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'prefix' | 'type' | 'onChange'> {
+    /** prefix of classname */
+    prefixCls?: string;
+    /** the type of input */
+    type?: string;
+    /** the size of input */
+    size?: Size;
+    /** default value of input */
+    defaultValue?: string;
+    /** value of input */
+    value?: string;
+    /** whether the input is disabled */
+    disabled?: boolean;
+    /** the native resize */
+    resize?: Resize;
+    /** precision of input value, only works for type=numeric */
+    precision?: number;
+    /** the max value of number input, only works for type=numeric */
+    max?: number;
+    /** the min value of number input, only works for type=numeric */
+    min?: number;
+    /** rows of textarea  */
+    rows?: number;
+    /** whether the textarea will auto adjust its size */
+    autosize?: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
+    /** the native min length */
+    maxLength?: number;
+    /** whether show error message */
+    error?: boolean;
+    /** error message (will be used as dangerouslySetInnerHTML) */
+    errorMessage?: string;
+    /** prefix label */
+    prefixLabel?: string | React.ReactNode;
+    /** prefix icon */
+    prefixIcon?: string | React.ReactNode;
+    /** prefix element */
+    prefix?: string | React.ReactNode;
+    /** suffix label */
+    suffixLabel?: string | React.ReactNode;
+    /** suffix icon */
+    suffixIcon?: string | React.ReactNode;
+    /** suffix element */
+    suffix?: string | React.ReactNode;
+    /** the restriction of input. Only effective at inputEvent */
+    restriction?: string | ((value: string) => boolean) | RegExp;
+    /**
+     * the restriction type of input
+     * when the type is `input`, it will only restrict the current input
+     * when the type is `value`, it will restrict the whole value
+     * */
+    restrictionType?: RestrictionType;
+    /** whether show word limit */
+    showWordLimit?: boolean;
+    /** the help message of input，will be used as dangerouslySetInnerHTML */
+    helpText?: string;
+    /** the warning message of input */
+    warningText?: string;
+    /** help element */
+    help?: string | React.ReactNode;
+    /** className */
+    className?: string;
+    /** whether the input in clearable */
+    clearable?: boolean;
+    /** whether should suspend clear */
+    suspendBeforeClear?: boolean | (() => boolean);
+    /** wether use Number.toFixed or direct intercept, only works for type=numeric */
+    isRound?: boolean;
+    /** wwhether to caculate the string by utf-16, instead of the default utf-8 */
+    unicodeNormalized?: boolean;
+    /** whether highlight when input focus  */
+    focusHighLight?: boolean;
+    /** whether has border style */
+    bordered?: boolean;
+    /** whether disable enter key only work when type is not textarea */
+    disableEnter?: boolean;
+    /** ref of container */
+    containerRef?: React.MutableRefObject<HTMLDivElement>;
+    /** children */
+    children?: React.ReactNode;
+    /** 格式化函数 */
+    formatter?: (value: string) => string;
+    /** 从 formatter 中取值的函数 */
+    parser?: (value: string) => string;
+    /** trigger after clearing */
+    onClear?: (event: React.MouseEvent) => void;
+    /** trigger when clicked */
+    onClick?: (event: React.MouseEvent) => void;
+    /** trigger when focus */
+    onFocus?: (event: React.FocusEvent) => void;
+    /** trigger when blur */
+    onBlur?: (event: React.FocusEvent) => void;
+    /** trigger when changed */
+    onChange?: (value: string) => void;
+    /** trigger when enter pressed */
+    onPressEnter?: () => void;
+    /** trigger when prefix icon clicked */
+    onPrefixIconClicked?: () => void;
+    /** trigger when suffix icon clicked */
+    onSuffixIconClicked?: () => void;
+}
+export interface InputGroupProps {
+    /** prefix of classname */
+    prefixCls?: string;
+    /** width of prepend node */
+    prependWidth?: number;
+    /** width of append node */
+    appendWidth?: number;
+    /** custom prepend node */
+    prepend?: React.ReactNode;
+    /** custom append node */
+    append?: React.ReactNode;
+    /** children of InputGroup */
+    children?: React.ReactNode;
+}
+export interface InputRef {
+    focus: () => void;
+    blur: () => void;
+}
+export {};

package/es/components/input/utils.d.ts

@@ -0,0 +1,17 @@
+declare const getNumberValue: (originValue: number | string, options?: {
+    max?: number;
+    min?: number;
+    precision?: number;
+    isRound?: boolean;
+}) => string;
+declare const formatValue: (originValue: string, options?: {
+    unicodeNormalized?: boolean;
+    maxLength?: number;
+    type?: string;
+    isFocus?: boolean;
+    max?: number;
+    min?: number;
+    precision?: number;
+    isRound?: boolean;
+}) => string;
+export { formatValue, getNumberValue, };