@qsxy/element-plus-react 1.0.0-next.1

package/dist/Input/InputRange.js

@@ -0,0 +1,353 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Input/InputRange.tsx
+var InputRange_exports = {};
+__export(InputRange_exports, {
+  default: () => InputRange_default
+});
+module.exports = __toCommonJS(InputRange_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_cloneDeep = __toESM(require("lodash/cloneDeep"));
+var import_head = __toESM(require("lodash/head"));
+var import_isObject = __toESM(require("lodash/isObject"));
+var import_last = __toESM(require("lodash/last"));
+var import_noop = __toESM(require("lodash/noop"));
+var import_toFinite = __toESM(require("lodash/toFinite"));
+var import_react = __toESM(require("react"));
+var import_Icon = require("../Icon");
+var import_Util = require("../Util");
+var import_hooks = require("../hooks");
+var import_prefix = require("../hooks/prefix");
+var import_InputGroup = __toESM(require("./InputGroup"));
+var InputRange = (0, import_react.forwardRef)((props, ref) => {
+  const {
+    name,
+    clearable,
+    startPlaceholder,
+    endPlaceholder,
+    type,
+    classPrefix = "range",
+    active,
+    prefix,
+    suffix,
+    onChange,
+    append,
+    prepend,
+    precision = 0,
+    error,
+    warning
+  } = props;
+  const [value, setValue] = (0, import_hooks.useControlled)(props.value, props.defaultValue);
+  const { b, e, be, bm, ebm, is } = (0, import_hooks.useClassNames)(classPrefix);
+  const [canClear, setCanClear] = (0, import_react.useState)(false);
+  const [focus, setFocus] = (0, import_react.useState)(false);
+  const disabled = (0, import_hooks.useDisabled)(props.disabled);
+  const size = (0, import_hooks.useSize)(props.size);
+  const timeRef = (0, import_react.useRef)(null);
+  const isCtrlKey = (0, import_react.useRef)(false);
+  const valueRef = (0, import_react.useRef)(value);
+  const startInputRef = (0, import_react.useRef)(null);
+  const endInputRef = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    valueRef.current = value;
+  }, [value]);
+  const onMouseEnter = (0, import_react.useCallback)(() => {
+    setCanClear(clearable && (0, import_Util.isNotEmpty)(value));
+  }, [clearable, value]);
+  const onMouseLeave = (0, import_react.useCallback)(() => {
+    setCanClear(false);
+  }, []);
+  const onInput = (0, import_react.useCallback)(
+    (inputVal, pos) => {
+      if (type === "number") {
+        inputVal = inputVal.split("").filter((item, index) => {
+          if (item === "-" && index > 0) {
+            return false;
+          }
+          return true;
+        }).join("");
+      }
+      let res = pos === "start" ? [inputVal, value == null ? void 0 : value[value.length - 1]] : [value == null ? void 0 : value[0], inputVal];
+      setValue((0, import_cloneDeep.default)(res));
+      setCanClear(clearable && (0, import_Util.isNotEmpty)(inputVal));
+      if (type === "number" && !inputVal.endsWith(".")) {
+        res = pos === "start" ? [(0, import_Util.isEmpty)(inputVal) ? null : (0, import_toFinite.default)(inputVal), (0, import_toFinite.default)(value == null ? void 0 : value[value.length - 1])] : [(0, import_toFinite.default)(value == null ? void 0 : value[0]), (0, import_Util.isEmpty)(inputVal) ? null : (0, import_toFinite.default)(inputVal)];
+        if (pos === "start" && startInputRef.current) {
+          startInputRef.current.value = (0, import_Util.isEmpty)(inputVal) ? "" : inputVal;
+        } else if (pos === "end" && endInputRef.current) {
+          endInputRef.current.value = (0, import_Util.isEmpty)(inputVal) ? "" : inputVal;
+        }
+        if ((0, import_Util.isNotEmpty)(res[0]) && (0, import_Util.isNotEmpty)(res[1])) {
+          onChange == null ? void 0 : onChange(res);
+        }
+      } else {
+        if ((0, import_Util.isNotEmpty)(res[0]) && (0, import_Util.isNotEmpty)(res[1])) {
+          onChange == null ? void 0 : onChange(res);
+        }
+      }
+    },
+    [clearable, onChange, setValue, type, value]
+  );
+  const onFocus = (0, import_react.useCallback)(() => {
+    timeRef.current && clearTimeout(timeRef.current);
+    timeRef.current = setTimeout(() => {
+      setFocus(true);
+    }, 250);
+  }, []);
+  const onBlur = (0, import_react.useCallback)(
+    (pos) => {
+      var _a, _b;
+      timeRef.current && clearTimeout(timeRef.current);
+      timeRef.current = setTimeout(() => {
+        setFocus(false);
+      }, 250);
+      let res, formatVal;
+      if ((0, import_Util.isEmpty)(value == null ? void 0 : value[0])) {
+        res = [null, value == null ? void 0 : value[value.length - 1]];
+        setValue(res);
+        onChange == null ? void 0 : onChange(res);
+        if (startInputRef.current) {
+          startInputRef.current.value = "";
+        }
+      }
+      if ((0, import_Util.isEmpty)(value == null ? void 0 : value[value.length - 1])) {
+        res = [value == null ? void 0 : value[0], null];
+        setValue(res);
+        onChange == null ? void 0 : onChange(res);
+        if (endInputRef.current) {
+          endInputRef.current.value = "";
+        }
+      }
+      if (type === "number" && valueRef.current) {
+        const val = pos === "start" ? (0, import_toFinite.default)((_a = valueRef.current) == null ? void 0 : _a[0]) : (0, import_toFinite.default)((_b = valueRef.current) == null ? void 0 : _b[value.length - 1]);
+        formatVal = (0, import_Util.formatNumber)(val, precision);
+        res = pos === "start" ? [formatVal, value == null ? void 0 : value[value.length - 1]] : [value == null ? void 0 : value[0], formatVal];
+        setValue(res);
+        if ((0, import_Util.isNotEmpty)(res[0]) && (0, import_Util.isNotEmpty)(res[1])) {
+          onChange == null ? void 0 : onChange(res);
+        }
+        if (pos === "start" && startInputRef.current) {
+          startInputRef.current.value = (0, import_Util.isEmpty)(formatVal) ? "" : formatVal;
+        } else if (pos === "end" && endInputRef.current) {
+          endInputRef.current.value = (0, import_Util.isEmpty)(formatVal) ? "" : formatVal;
+        }
+      }
+    },
+    [onChange, precision, setValue, type, value]
+  );
+  const onClear = (0, import_react.useCallback)(
+    (event) => {
+      event.stopPropagation();
+      setValue(["", ""]);
+      setCanClear(false);
+      onChange == null ? void 0 : onChange(["", ""]);
+    },
+    [onChange, setValue]
+  );
+  const onKeyDown = (0, import_react.useCallback)((event, pos) => {
+    var _a;
+    if (event.ctrlKey) {
+      isCtrlKey.current = true;
+    }
+    if (isCtrlKey.current) {
+      if (!["c", "v", "x"].includes(event.key)) {
+        event.preventDefault();
+      }
+    } else if (!["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "-", ".", "ArrowLeft", "ArrowRight", "Backspace", "Delete"].includes(event.key)) {
+      event.preventDefault();
+    }
+    const val = (_a = valueRef.current) == null ? void 0 : _a[pos === "start" ? 0 : 1];
+    if ((0, import_Util.isNotEmpty)(val)) {
+      if ((val + "").indexOf(".") > -1 && event.key === ".") {
+        event.preventDefault();
+      }
+      if ((val + "").indexOf("-") > -1 && event.key === "-") {
+        event.preventDefault();
+      }
+    }
+  }, []);
+  const onKeyUp = (0, import_react.useCallback)(() => {
+    isCtrlKey.current = false;
+  }, []);
+  const preffixSlot = (0, import_react.useMemo)(() => {
+    var _a;
+    if (prefix && (0, import_isObject.default)(prefix)) {
+      let nodeType = prefix == null ? void 0 : prefix.type;
+      nodeType = (nodeType == null ? void 0 : nodeType.displayName) || nodeType;
+      if (nodeType === "ElIcon") {
+        return (0, import_react.cloneElement)(prefix, {
+          ...prefix.props,
+          className: (0, import_classnames.default)((_a = prefix.props) == null ? void 0 : _a.className, `${import_prefix.globalKey}-range__icon`)
+        });
+      }
+    }
+    return prefix;
+  }, [prefix]);
+  const suffixSlot = (0, import_react.useMemo)(() => {
+    var _a;
+    if (suffix) {
+      if ((0, import_isObject.default)(suffix)) {
+        let nodeType = suffix == null ? void 0 : suffix.type;
+        nodeType = (nodeType == null ? void 0 : nodeType.displayName) || nodeType;
+        if (nodeType === "ElIcon") {
+          return (0, import_react.cloneElement)(suffix, {
+            ...suffix.props,
+            className: (0, import_classnames.default)((_a = suffix.props) == null ? void 0 : _a.className, `${import_prefix.globalKey}-input__icon ${import_prefix.globalKey}-range__close-icon`)
+          });
+        }
+      } else {
+        return /* @__PURE__ */ import_react.default.createElement("span", { className: `${import_prefix.globalKey}-range__end-icon` }, suffix);
+      }
+    }
+    return null;
+  }, [suffix]);
+  const content = (0, import_react.useMemo)(
+    () => /* @__PURE__ */ import_react.default.createElement(
+      "div",
+      {
+        className: (0, import_classnames.default)(
+          b`range-editor`,
+          b("input-range", false),
+          be("input", "wrapper", false),
+          be("tooltip", "trigger", false),
+          is({ active: active || focus, disabled, warning, error }),
+          { [bm("input-range", size, false)]: size },
+          append || prepend ? null : props.className
+        ),
+        ref,
+        onClick: props.onClick,
+        style: append || prepend ? {} : props.style,
+        onMouseEnter,
+        onMouseLeave
+      },
+      preffixSlot,
+      /* @__PURE__ */ import_react.default.createElement(
+        "input",
+        {
+          ref: startInputRef,
+          name: name instanceof Array ? (0, import_head.default)(name) : "",
+          readOnly: props.readOnly,
+          placeholder: startPlaceholder,
+          disabled,
+          className: b`input`,
+          value: value instanceof Array ? value == null ? void 0 : value[0] : "",
+          onInput: (event) => onInput(event.target.value, "start"),
+          onFocus,
+          onBlur: () => {
+            onBlur("start");
+          },
+          onKeyDown: type === "number" ? (event) => onKeyDown(event, "start") : import_noop.default,
+          onKeyUp: type === "number" ? onKeyUp : import_noop.default
+        }
+      ),
+      /* @__PURE__ */ import_react.default.createElement("span", { className: b`separator` }, props.rangeSeparator),
+      /* @__PURE__ */ import_react.default.createElement(
+        "input",
+        {
+          ref: endInputRef,
+          name: name instanceof Array ? (0, import_last.default)(name) : "",
+          readOnly: props.readOnly,
+          placeholder: endPlaceholder,
+          disabled,
+          className: b`input`,
+          value: value instanceof Array ? value == null ? void 0 : value[value.length - 1] : "",
+          onInput: (event) => onInput(event.target.value, "end"),
+          onFocus,
+          onBlur: () => {
+            onBlur("end");
+          },
+          onKeyDown: type === "number" ? (event) => onKeyDown(event, "end") : import_noop.default,
+          onKeyUp: type === "number" ? onKeyUp : import_noop.default
+        }
+      ),
+      (canClear ? null : suffixSlot) ?? /* @__PURE__ */ import_react.default.createElement(
+        import_Icon.Icon,
+        {
+          prefix: "fal",
+          name: "circle-xmark",
+          className: (0, import_classnames.default)(be("input", "icon", false), e`close-icon`, { [ebm("close", "icon", "hidden")]: !canClear }),
+          onClick: onClear
+        }
+      )
+    ),
+    [
+      b,
+      be,
+      is,
+      active,
+      focus,
+      warning,
+      error,
+      bm,
+      size,
+      append,
+      prepend,
+      props.className,
+      props.onClick,
+      props.style,
+      props.readOnly,
+      props.rangeSeparator,
+      ref,
+      onMouseEnter,
+      onMouseLeave,
+      preffixSlot,
+      name,
+      startPlaceholder,
+      disabled,
+      value,
+      onFocus,
+      type,
+      onKeyUp,
+      endPlaceholder,
+      canClear,
+      suffixSlot,
+      e,
+      ebm,
+      onClear,
+      onInput,
+      onBlur,
+      onKeyDown
+    ]
+  );
+  if (append || prepend) {
+    return /* @__PURE__ */ import_react.default.createElement(import_InputGroup.default, { prepend, append, className: props.className, style: props.style }, content);
+  } else {
+    return content;
+  }
+});
+InputRange.defaultProps = {
+  name: ["", ""],
+  startPlaceholder: "请输入",
+  endPlaceholder: "请输入",
+  type: "text",
+  clearable: true,
+  rangeSeparator: "到"
+};
+InputRange.displayName = "InputRange";
+var InputRange_default = InputRange;

package/dist/Input/TextArea.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TextareaProps, TextareaRef } from './typings';
+declare const TextArea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<TextareaRef>>;
+export default TextArea;

package/dist/Input/TextArea.js

@@ -0,0 +1,118 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Input/TextArea.tsx
+var TextArea_exports = {};
+__export(TextArea_exports, {
+  default: () => TextArea_default
+});
+module.exports = __toCommonJS(TextArea_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_hooks = require("../hooks");
+var TextArea = (0, import_react.forwardRef)((props, ref) => {
+  const { name, title, error, placeholder, readOnly, plain, rows, classPrefix = "textarea", onFocus, onBlur, onChange, warning, maxLength, showWordLimit, ...rest } = props;
+  const { b, m, e, is } = (0, import_hooks.useClassNames)(classPrefix);
+  const [value, setValue] = (0, import_hooks.useControlled)(props.value, props.defaultValue);
+  const [focus, setFocus] = (0, import_react.useState)(false);
+  const disabled = (0, import_hooks.useDisabled)(props.disabled);
+  const containerRef = (0, import_react.useRef)(null);
+  const inputRef = (0, import_react.useRef)(null);
+  const inputOver = (0, import_react.useRef)(true);
+  const [htmlInputProps] = (0, import_hooks.partitionHTMLProps)(rest);
+  const handleInput = (0, import_react.useCallback)(
+    (event) => {
+      if (inputOver.current) {
+        setValue(event.target.value);
+        onChange == null ? void 0 : onChange(event.target.value);
+      }
+    },
+    [onChange, setValue]
+  );
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    get input() {
+      return inputRef.current;
+    },
+    getValue: () => value,
+    setValue,
+    onClear: () => {
+      setValue("");
+      onChange == null ? void 0 : onChange("");
+    },
+    clear: () => {
+      setValue("");
+      onChange == null ? void 0 : onChange("");
+    },
+    focus: () => {
+      var _a;
+      return (_a = inputRef.current) == null ? void 0 : _a.focus();
+    },
+    blur: () => {
+      var _a;
+      return (_a = inputRef.current) == null ? void 0 : _a.blur();
+    }
+  }));
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b(), m`suffix`, is({ focus, disabled, plain }), props.className), style: props.style, ref: containerRef }, /* @__PURE__ */ import_react.default.createElement(
+    "textarea",
+    {
+      rows,
+      name,
+      title,
+      value,
+      className: (0, import_classnames.default)(e`inner`, props.className, is({ error, warning })),
+      style: props.innerStyle,
+      placeholder,
+      readOnly,
+      disabled,
+      maxLength,
+      onChange: handleInput,
+      ref: inputRef,
+      onFocus: (0, import_react.useCallback)(
+        (event) => {
+          setFocus(true);
+          onFocus == null ? void 0 : onFocus.call(void 0, event);
+        },
+        [onFocus]
+      ),
+      onBlur: (0, import_react.useCallback)(
+        (event) => {
+          setFocus(false);
+          onBlur == null ? void 0 : onBlur.call(void 0, event);
+        },
+        [onBlur]
+      ),
+      ...htmlInputProps
+    }
+  ), maxLength && showWordLimit ? /* @__PURE__ */ import_react.default.createElement("span", { className: e`count` }, typeof value === "string" ? value.length : 0, " / ", maxLength) : null);
+});
+TextArea.defaultProps = {
+  placeholder: "请输入",
+  style: { width: "100%" }
+};
+TextArea.displayName = "TextArea";
+var TextArea_default = TextArea;

package/dist/Input/index.d.ts

@@ -0,0 +1,4 @@
+export { default as InputRange } from '../Input/InputRange';
+export { default as Input } from './Input';
+export { default as InputGroup } from './InputGroup';
+export type { InputProps, InputRangeProps, InputRef, TextareaProps, TextareaRef } from './typings';

package/dist/Input/index.js

@@ -0,0 +1,45 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Input/index.ts
+var Input_exports = {};
+__export(Input_exports, {
+  Input: () => import_Input.default,
+  InputGroup: () => import_InputGroup.default,
+  InputRange: () => import_InputRange.default
+});
+module.exports = __toCommonJS(Input_exports);
+var import_InputRange = __toESM(require("../Input/InputRange"));
+var import_Input = __toESM(require("./Input"));
+var import_InputGroup = __toESM(require("./InputGroup"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Input,
+  InputGroup,
+  InputRange
+});

package/dist/Input/typings.d.ts

@@ -0,0 +1,87 @@
+import React from 'react';
+import { BaseProps, FormControlBaseProps, NativeProps, TypeAttributes } from '../types/common';
+export type LiteralUnion<T extends U, U> = T | (U & {});
+export type ValueType = React.AllHTMLAttributes<HTMLInputElement>['value'];
+export type BaseInputRef = {
+    getValue: () => ValueType;
+    setValue: (value: ValueType) => void;
+    onClear: (event?: any) => void;
+    clear: (event?: any) => void;
+    focus: () => void;
+    blur: () => void;
+    showClear?: (value: ValueType) => void;
+    hideClear?: () => void;
+};
+export type InputRef = {
+    ref: React.MutableRefObject<HTMLDivElement>;
+    input: React.MutableRefObject<HTMLInputElement>;
+} & BaseInputRef;
+export type TextareaRef = {
+    input: HTMLTextAreaElement;
+} & BaseInputRef;
+export interface InputProps extends FormControlBaseProps<ValueType>, BaseProps, NativeProps, Omit<React.AllHTMLAttributes<HTMLInputElement>, 'defaultValue' | 'size' | 'prefix' | 'type' | 'onInput' | 'onChange' | 'style' | 'children'> {
+    size?: TypeAttributes.Size;
+    defaultValue?: ValueType;
+    type?: LiteralUnion<'color' | 'date' | 'datetime-local' | 'email' | 'file' | 'hidden' | 'image' | 'number' | 'password' | 'range' | 'search' | 'tel' | 'text' | 'time' | 'url' | 'week', string>;
+    prefix?: React.ReactElement<any> | string | number;
+    suffix?: React.ReactElement<any> | string | number;
+    prepend?: React.ReactElement<any> | string | number;
+    append?: React.ReactElement | string | number;
+    clearable?: boolean;
+    showPassword?: boolean;
+    plain?: boolean;
+    error?: boolean;
+    warning?: boolean;
+    debounceInput?: boolean;
+    debounceTime?: number;
+    innerStyle?: React.CSSProperties;
+    startPlaceholder?: string;
+    endPlaceholder?: string;
+    maxLength?: number;
+    minLength?: number;
+    showWordLimit?: boolean;
+    hiddenValue?: boolean;
+    onClear?: (e: MouseEvent) => void;
+    onChange?: (value: ValueType, event?: React.ChangeEvent) => void;
+}
+export interface InputGroupProps extends BaseProps, NativeProps {
+    prepend?: React.ReactElement<any> | string | number;
+    append?: React.ReactElement | string | number;
+}
+export interface TextareaProps extends Omit<React.AllHTMLAttributes<HTMLInputElement>, 'defaultValue' | 'size' | 'prefix' | 'type' | 'onInput' | 'onChange' | 'style' | 'children'>, FormControlBaseProps<ValueType>, BaseProps, NativeProps {
+    defaultValue?: ValueType;
+    error?: boolean;
+    warning?: boolean;
+    plain?: boolean;
+    rows?: number;
+    innerStyle?: React.CSSProperties;
+    maxLength?: number;
+    minLength?: number;
+    showWordLimit?: boolean;
+    onChange?: (value: ValueType, event?: React.ChangeEvent) => void;
+}
+export type InputRangeValueType = [string | null, string | null] | [number | null, number | null];
+export interface InputRangeProps<T = InputRangeValueType> extends Omit<FormControlBaseProps<T>, 'name' | 'onChange'>, BaseProps, NativeProps {
+    name?: [string, string];
+    size?: TypeAttributes.Size;
+    readOnly?: boolean;
+    active?: boolean;
+    onClick?: React.MouseEventHandler<HTMLDivElement>;
+    type?: 'text' | 'hidden' | 'number';
+    prefix?: React.ReactElement<any> | string | number;
+    suffix?: React.ReactElement<any> | string | number;
+    prepend?: React.ReactElement<any> | string | number;
+    append?: React.ReactElement | string | number;
+    precision?: number;
+    clearable?: boolean;
+    plain?: boolean;
+    error?: boolean;
+    warning?: boolean;
+    rangeSeparator?: string;
+    debounceInput?: boolean;
+    innerStyle?: React.CSSProperties;
+    startPlaceholder?: string;
+    endPlaceholder?: string;
+    onClear?: (e: MouseEvent) => void;
+    onChange?: (value: InputRangeValueType | null, event?: Event) => void;
+}

package/dist/Input/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Input/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/InputNumber/InputNumber.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { InputNumberProps, InputNumberRef } from './typings';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<InputNumberProps<import("./typings").ValueType> & React.RefAttributes<InputNumberRef>>>;
+export default _default;