shineout 1.12.2 → 1.12.3

package/esm/Input/Group.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import PropTypes from 'prop-types';
+import { InputGroupProps } from './Props';
+declare function Group(props: InputGroupProps): JSX.Element[];
+declare namespace Group {
+    var propTypes: {
+        children: PropTypes.Requireable<any>;
+    };
+}
+export default Group;

package/esm/Input/Group.js

@@ -0,0 +1,25 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import React, { Children, cloneElement } from 'react';
+import PropTypes from 'prop-types';
+
+function Group(props) {
+  var children = props.children,
+      style = props.style,
+      inputFocus = props.inputFocus,
+      other = _objectWithoutPropertiesLoose(props, ["children", "style", "inputFocus"]);
+
+  return Children.toArray(children).map(function (child, i) {
+    if (typeof child === 'string') {
+      return React.createElement("span", {
+        key: i
+      }, child);
+    }
+
+    return cloneElement(child, other);
+  });
+}
+
+Group.propTypes = {
+  children: PropTypes.any
+};
+export default Group;

package/esm/Input/Input.d.ts

@@ -0,0 +1,24 @@
+import React, { PureComponent } from 'react';
+import { Props } from './Props';
+declare class Input extends PureComponent<Props> {
+    static defaultProps: any;
+    enterLock: boolean;
+    ref: HTMLInputElement;
+    enterPress: boolean;
+    constructor(props: Props);
+    defaultInfo: (value?: string | undefined) => string | Error | null;
+    bindRef(el: HTMLInputElement): void;
+    getTrim: () => boolean;
+    isValidNumber(val: string): boolean;
+    formatValue(val: string): string;
+    fixValue(val: string): string;
+    invalidNumber(value: string): boolean;
+    handleChange(e: React.ChangeEvent, clearClick: boolean): void;
+    handleKeyDown(e: React.KeyboardEvent): void;
+    handleKeyUp(e: React.KeyboardEvent): void;
+    handleBlur(e: React.FocusEvent<HTMLInputElement>): void;
+    handleAutoSelect(event: React.FocusEvent): void;
+    renderInfo(): JSX.Element | null;
+    render(): (false | JSX.Element | null | undefined)[];
+}
+export default Input;

package/esm/Input/Input.js

@@ -0,0 +1,307 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React, { PureComponent } from 'react';
+import classnames from 'classnames';
+import config from '../config';
+import { inputTitleClass } from '../InputTitle/styles';
+import cleanProps from '../utils/cleanProps';
+import Clear from './clear';
+import { inputClass } from './styles';
+import InputTitle from '../InputTitle';
+
+function regLength(size) {
+  return /\d+/.test(String(size)) && size > 0 ? "{0," + size + "}" : '*';
+}
+
+function fillNumber(val) {
+  return val.replace(/^(-)?(\.\d+)(?!=\.).*/g, '$10$2') // eslint-disable-next-line no-useless-escape
+  .replace(/(-|^)0+(?=0\.?|[^0\.])/g, '$1').replace(/\.$/, '');
+}
+
+var DefaultValue = {
+  type: 'text'
+};
+
+var Input =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(Input, _PureComponent);
+
+  function Input(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "enterLock", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "ref", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "enterPress", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "defaultInfo", function (value) {
+      if (!value || value.length === 0) return null;
+      var info = _this.props.info;
+      var text = value.length + " / " + info;
+      if (typeof info === 'number' && value.length <= info) return text;
+      return new Error(text);
+    });
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "getTrim", function () {
+      var trim = _this.props.trim;
+      if (trim !== undefined) return trim;
+      if (config.trim !== undefined) return config.trim;
+      return false;
+    });
+
+    _this.enterLock = false;
+    _this.handleChange = _this.handleChange.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleKeyDown = _this.handleKeyDown.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleKeyUp = _this.handleKeyUp.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleBlur = _this.handleBlur.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleAutoSelect = _this.handleAutoSelect.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.bindRef = _this.bindRef.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = Input.prototype;
+
+  _proto.bindRef = function bindRef(el) {
+    var forwardedRef = this.props.forwardedRef;
+    this.ref = el;
+    if (forwardedRef) forwardedRef(el);
+  };
+
+  _proto.isValidNumber = function isValidNumber(val) {
+    var numType = this.props.numType;
+    var noNeg = numType === 'non-negative' || numType === 'positive';
+    var regExp = new RegExp("^(" + (noNeg ? '' : '-') + ")?\\d*\\.?\\d*$", 'g');
+    return regExp.test(val);
+  };
+
+  _proto.formatValue = function formatValue(val) {
+    var value = val;
+    var _this$props = this.props,
+        type = _this$props.type,
+        digits = _this$props.digits,
+        integerLimit = _this$props.integerLimit,
+        numType = _this$props.numType;
+    var noNeg = numType === 'non-negative' || numType === 'positive';
+    if (type !== 'number') return value;
+    var regExp = new RegExp("^(" + (noNeg ? '' : '-') + ")?(\\d" + regLength(integerLimit) + ")(" + (digits !== 0 ? "\\.\\d" + regLength(digits) : '') + ")?.*$", 'g');
+    value = value.replace(regExp, '$1$2$3');
+    return value;
+  };
+
+  _proto.fixValue = function fixValue(val) {
+    var _this$props2 = this.props,
+        type = _this$props2.type,
+        digits = _this$props2.digits,
+        autoFix = _this$props2.autoFix,
+        numType = _this$props2.numType;
+    if (type !== 'number' || val === '') return val;
+    if (/^[.-]+$/.test(val)) return '';
+    var fixVal = fillNumber(val);
+    if (numType === 'positive' && Number(fixVal) <= 0) return '';
+
+    if (digits !== undefined && autoFix) {
+      if (digits > 0) {
+        fixVal = parseFloat(fixVal).toFixed(digits);
+      } else {
+        fixVal = parseInt(fixVal, 10).toString();
+      }
+    }
+
+    return fixVal;
+  };
+
+  _proto.invalidNumber = function invalidNumber(value) {
+    var _this$props3 = this.props,
+        digits = _this$props3.digits,
+        type = _this$props3.type,
+        integerLimit = _this$props3.integerLimit;
+    if (type !== 'number') return false;
+    var reg = '^-?';
+
+    if (!integerLimit) {
+      reg += "\\d*";
+    } else if (integerLimit > 0) {
+      reg += "\\d{0," + integerLimit + "}";
+    }
+
+    if (digits === undefined) {
+      reg += '\\.?\\d*';
+    } else if (digits >= 0) {
+      reg += "\\.?\\d{0," + digits + "}";
+    }
+
+    reg += '$';
+    reg = new RegExp(reg);
+    return !reg.test(value);
+  };
+
+  _proto.handleChange = function handleChange(e, clearClick) {
+    var _this$props4 = this.props,
+        type = _this$props4.type,
+        clearable = _this$props4.clearable,
+        coin = _this$props4.coin;
+
+    if (clearClick) {
+      this.ref.focus();
+      if (typeof clearable === 'function') clearable();
+    }
+
+    var value = e.target.value;
+
+    if (clearClick && this.props.clearToUndefined) {
+      this.props.onChange(value);
+      return;
+    }
+
+    if (type === 'number') {
+      if (typeof value !== 'number') {
+        value = String(value).replace(/。/g, '.');
+
+        if (coin) {
+          value = value.replace(/,/g, '');
+        }
+      }
+
+      if (!this.isValidNumber(value)) {
+        return;
+      }
+
+      value = this.formatValue(value);
+    }
+
+    this.props.onChange(value);
+  };
+
+  _proto.handleKeyDown = function handleKeyDown(e) {
+    var onKeyDown = this.props.onKeyDown;
+    if (e.keyCode === 13) this.enterPress = true;
+    if (onKeyDown) onKeyDown(e);
+  };
+
+  _proto.handleKeyUp = function handleKeyUp(e) {
+    var _this$props5 = this.props,
+        onKeyUp = _this$props5.onKeyUp,
+        onEnterPress = _this$props5.onEnterPress;
+
+    if (this.enterPress && e.keyCode === 13 && onEnterPress) {
+      onEnterPress(e.target.value, e);
+      this.enterPress = false;
+    }
+
+    if (onKeyUp) onKeyUp(e);
+  };
+
+  _proto.handleBlur = function handleBlur(e) {
+    var value = e.target.value;
+    var _this$props6 = this.props,
+        forceChange = _this$props6.forceChange,
+        onChange = _this$props6.onChange,
+        onBlur = _this$props6.onBlur,
+        clearToUndefined = _this$props6.clearToUndefined;
+    var newVal = this.fixValue(value);
+    var shouldKeepUndefined = clearToUndefined && newVal === '' && this.props.value === undefined;
+
+    if (!shouldKeepUndefined && !this.invalidNumber(newVal)) {
+      if (this.getTrim()) newVal = newVal.trim();
+      var change = forceChange || onChange;
+      change(newVal);
+      e.target.value = newVal;
+    }
+
+    if (onBlur) onBlur(e);
+  };
+
+  _proto.handleAutoSelect = function handleAutoSelect(event) {
+    var onFocus = this.props.onFocus;
+    var autoSelect = this.props.autoSelect;
+
+    if (autoSelect) {
+      ;
+      event.currentTarget.select();
+    }
+
+    if (typeof onFocus === 'function') {
+      onFocus(event);
+    }
+  };
+
+  _proto.renderInfo = function renderInfo() {
+    var info = this.props.info;
+    var notNumber = typeof info !== 'number';
+    if (typeof info !== 'function' && notNumber) return null;
+    var textInfo = notNumber ? info : this.defaultInfo;
+    var res = textInfo(this.props.value); // empty
+
+    if (!res) return null;
+    var isError = res instanceof Error;
+    var text = isError ? res.message : res;
+    return React.createElement("div", {
+      key: "info",
+      style: {
+        minWidth: 'auto'
+      },
+      className: inputClass('bottom-right', isError ? 'error' : 'tip')
+    }, text);
+  };
+
+  _proto.render = function render() {
+    var _this$props7 = this.props,
+        type = _this$props7.type,
+        defaultValue = _this$props7.defaultValue,
+        digits = _this$props7.digits,
+        className = _this$props7.className,
+        clearable = _this$props7.clearable,
+        htmlName = _this$props7.htmlName,
+        forceChange = _this$props7.forceChange,
+        onEnterPress = _this$props7.onEnterPress,
+        forwardedRef = _this$props7.forwardedRef,
+        innerTitle = _this$props7.innerTitle,
+        inputFocus = _this$props7.inputFocus,
+        clearToUndefined = _this$props7.clearToUndefined,
+        placeholder = _this$props7.placeholder,
+        coin = _this$props7.coin,
+        other = _objectWithoutPropertiesLoose(_this$props7, ["type", "defaultValue", "digits", "className", "clearable", "htmlName", "forceChange", "onEnterPress", "forwardedRef", "innerTitle", "inputFocus", "clearToUndefined", "placeholder", "coin"]);
+
+    var value = this.props.value == null || this.props.value === undefined ? '' : this.props.value;
+    var needClearUndefined = clearToUndefined && this.props.value !== undefined;
+    var showClear = !other.disabled && clearable && (value !== '' || needClearUndefined);
+    var mc = classnames(className, showClear && inputClass('clearable'), innerTitle && inputTitleClass('hidable', 'item'));
+    var isNumber = className && className.indexOf(inputClass('number')) > -1;
+    return [React.createElement(InputTitle, {
+      className: isNumber ? inputClass('number-title-box') : undefined,
+      key: "input",
+      innerTitle: innerTitle,
+      open: !!inputFocus || !!value
+    }, React.createElement("input", _extends({}, cleanProps(other), {
+      placeholder: needClearUndefined ? '' : placeholder,
+      className: mc || undefined,
+      name: other.name || htmlName,
+      type: type === 'password' ? type : 'text',
+      value: value,
+      ref: this.bindRef,
+      key: "input",
+      onChange: this.handleChange,
+      onKeyDown: this.handleKeyDown,
+      onKeyUp: this.handleKeyUp,
+      onBlur: this.handleBlur,
+      onFocus: this.handleAutoSelect
+    }))), showClear && React.createElement(Clear, {
+      onClick: this.handleChange,
+      key: "close",
+      clearResult: needClearUndefined ? undefined : ''
+    }), this.renderInfo()];
+  };
+
+  return Input;
+}(PureComponent);
+
+_defineProperty(Input, "defaultProps", DefaultValue);
+
+export default Input;

package/esm/Input/Number.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import React, { PureComponent } from 'react';
+import { InputNumber, NumberValue } from './Props';
+declare class Number extends PureComponent<InputNumber> {
+    static defaultProps: any;
+    hold: boolean;
+    handleAddClick: React.MouseEventHandler<HTMLAnchorElement>;
+    handleSubClick: React.MouseEventHandler<HTMLAnchorElement>;
+    keyPressTimeOut: NodeJS.Timer;
+    constructor(props: InputNumber);
+    componentWillUnmount(): void;
+    handleChange(value?: NumberValue, check?: boolean, isEmpty?: boolean): void;
+    handleBlur(e: React.FocusEvent<HTMLInputElement>): void;
+    changeValue(mod: number): void;
+    longPress(mod: number): void;
+    handleKeyDown(e: React.KeyboardEvent): void;
+    handleCalc(mod: number, e: React.MouseEvent): void;
+    handleKeyUp(): void;
+    handleMouseUp(e: React.MouseEvent): void;
+    renderArrowGroup(): JSX.Element[];
+    renderRTL(): JSX.Element[];
+    render(): JSX.Element[];
+}
+export default Number;

package/esm/Input/Number.js

@@ -0,0 +1,275 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React, { PureComponent } from 'react';
+import icons from '../icons';
+import Input from './Input';
+import { inputClass } from './styles';
+import { isRTL } from '../config';
+import { sub } from '../utils/numbers';
+import { getDirectionClass } from '../utils/classname';
+var DefaultValue = {
+  step: 1,
+  allowNull: false,
+  hideArrow: false
+};
+
+var Number =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(Number, _PureComponent);
+
+  function Number(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "hold", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "handleAddClick", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "handleSubClick", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "keyPressTimeOut", void 0);
+
+    _this.handleBlur = _this.handleBlur.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleChange = _this.handleChange.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleAddClick = _this.handleCalc.bind(_assertThisInitialized(_assertThisInitialized(_this)), props.step);
+    _this.handleSubClick = _this.handleCalc.bind(_assertThisInitialized(_assertThisInitialized(_this)), -props.step);
+    _this.handleMouseUp = _this.handleMouseUp.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleKeyDown = _this.handleKeyDown.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleKeyUp = _this.handleKeyUp.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = Number.prototype;
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.hold = false;
+    if (this.keyPressTimeOut) clearTimeout(this.keyPressTimeOut);
+  } // handleChange(value: NumberValue) {
+  //   this.handleChange(NumberValue)
+  // }
+  ;
+
+  _proto.handleChange = function handleChange(value, check, isEmpty) {
+    if (isEmpty || value === undefined) {
+      this.props.onChange(value);
+      return;
+    }
+
+    if (!check) {
+      if (new RegExp('^-?\\d*\\.?\\d*$').test(value)) {
+        this.props.onChange(value);
+      }
+
+      return;
+    }
+
+    var _this$props = this.props,
+        digits = _this$props.digits,
+        _this$props$step = _this$props.step,
+        step = _this$props$step === void 0 ? DefaultValue.step : _this$props$step,
+        numType = _this$props.numType,
+        _this$props$allowNull = _this$props.allowNull,
+        allowNull = _this$props$allowNull === void 0 ? DefaultValue.allowNull : _this$props$allowNull;
+
+    if (numType === 'positive' && value <= 0) {
+      value = allowNull ? null : undefined;
+    } else if (typeof digits === 'number') {
+      value = parseFloat(value.toFixed(digits));
+    } else {
+      var stepStr = step.toString();
+      var dot = stepStr.lastIndexOf('.');
+      if (dot >= 0) value = parseFloat(value.toFixed(stepStr.length - dot));
+    }
+
+    var _this$props2 = this.props,
+        min = _this$props2.min,
+        max = _this$props2.max;
+    if (max !== undefined && value > max) value = max;
+    if (min !== undefined && value < min) value = min;
+
+    if (value !== this.props.value) {
+      this.props.onChange(value);
+    }
+  };
+
+  _proto.handleBlur = function handleBlur(e) {
+    this.hold = false;
+    var value = parseFloat(e.target.value); // for the empty
+
+    if (e.target.value === '' && this.props.allowNull) {
+      value = null;
+    } // eslint-disable-next-line no-restricted-globals
+
+
+    if (isNaN(value)) value = 0;
+
+    if (this.props.clearToUndefined && e.target.value === '' && this.props.value === undefined) {
+      this.handleChange(undefined, true, true);
+    } else {
+      this.handleChange(value, true, value === null);
+    }
+
+    this.props.onBlur(e);
+  };
+
+  _proto.changeValue = function changeValue(mod) {
+    if (this.props.disabled) return;
+    var val = this.props.value;
+    if (val === 0) val = '0';
+    var value = parseFloat(("" + (val || '')).replace(/,/g, '')); // eslint-disable-next-line
+
+    if (isNaN(value)) value = 0;
+    var _this$props3 = this.props,
+        numType = _this$props3.numType,
+        integerLimit = _this$props3.integerLimit;
+    var calculateVal = sub(value, mod);
+
+    if (numType === 'positive' && calculateVal <= 0) {
+      return;
+    }
+
+    if (numType === 'non-negative' && calculateVal < 0) {
+      return;
+    }
+
+    if (integerLimit && String(parseInt(calculateVal, 10)).length > integerLimit) {
+      return;
+    }
+
+    this.handleChange(calculateVal, true);
+  };
+
+  _proto.longPress = function longPress(mod) {
+    var _this2 = this;
+
+    if (!this.hold) return;
+    setTimeout(function () {
+      _this2.changeValue(mod);
+
+      _this2.longPress(mod);
+    }, 50);
+  };
+
+  _proto.handleKeyDown = function handleKeyDown(e) {
+    var _this3 = this;
+
+    var _this$props$step2 = this.props.step,
+        step = _this$props$step2 === void 0 ? DefaultValue.step : _this$props$step2;
+    this.hold = true;
+    if (e.keyCode !== 38 && e.keyCode !== 40) return;
+    e.preventDefault();
+    var mod = e.keyCode === 38 ? step : -step;
+    this.changeValue(mod);
+    if (this.keyPressTimeOut) clearTimeout(this.keyPressTimeOut);
+    this.keyPressTimeOut = setTimeout(function () {
+      _this3.longPress(mod);
+    }, 600);
+  };
+
+  _proto.handleCalc = function handleCalc(mod, e) {
+    var _this4 = this;
+
+    var onMouseDown = this.props.onMouseDown;
+    if (onMouseDown) onMouseDown(e);
+    this.hold = true;
+    this.changeValue(mod);
+    this.keyPressTimeOut = setTimeout(function () {
+      _this4.longPress(mod);
+    }, 1000);
+  };
+
+  _proto.handleKeyUp = function handleKeyUp() {
+    this.hold = false;
+    if (this.keyPressTimeOut) clearTimeout(this.keyPressTimeOut);
+  };
+
+  _proto.handleMouseUp = function handleMouseUp(e) {
+    var onMouseUp = this.props.onMouseUp;
+    if (onMouseUp) onMouseUp(e);
+    this.hold = false;
+    if (this.keyPressTimeOut) clearTimeout(this.keyPressTimeOut);
+  };
+
+  _proto.renderArrowGroup = function renderArrowGroup() {
+    var hideArrow = this.props.hideArrow;
+    if (hideArrow) return [];
+    return [React.createElement("a", {
+      key: "up" // do not need the tab to focus
+      ,
+      tabIndex: -1,
+      className: inputClass('number-up'),
+      onMouseDown: this.handleAddClick,
+      onMouseUp: this.handleMouseUp,
+      onMouseLeave: this.handleMouseUp
+    }, icons.AngleRight), React.createElement("a", {
+      key: "down" // do not need the tab to focus
+      ,
+      tabIndex: -1,
+      className: inputClass('number-down'),
+      onMouseDown: this.handleSubClick,
+      onMouseUp: this.handleMouseUp,
+      onMouseLeave: this.handleMouseUp
+    }, icons.AngleRight)];
+  };
+
+  _proto.renderRTL = function renderRTL() {
+    var _this$props4 = this.props,
+        onChange = _this$props4.onChange,
+        allowNull = _this$props4.allowNull,
+        hideArrow = _this$props4.hideArrow,
+        value = _this$props4.value,
+        defaultValue = _this$props4.defaultValue,
+        other = _objectWithoutPropertiesLoose(_this$props4, ["onChange", "allowNull", "hideArrow", "value", "defaultValue"]);
+
+    return [].concat(this.renderArrowGroup(), [React.createElement(Input, _extends({
+      key: "input",
+      value: value
+    }, other, {
+      className: inputClass(!hideArrow && getDirectionClass('number'), 'rtl'),
+      onChange: this.handleChange,
+      onKeyDown: this.handleKeyDown,
+      onKeyUp: this.handleKeyUp,
+      onBlur: this.handleBlur,
+      type: "number"
+    }))]);
+  };
+
+  _proto.render = function render() {
+    var _this$props5 = this.props,
+        onChange = _this$props5.onChange,
+        allowNull = _this$props5.allowNull,
+        hideArrow = _this$props5.hideArrow,
+        defaultValue = _this$props5.defaultValue,
+        value = _this$props5.value,
+        other = _objectWithoutPropertiesLoose(_this$props5, ["onChange", "allowNull", "hideArrow", "defaultValue", "value"]);
+
+    var rtl = isRTL();
+
+    if (rtl) {
+      return this.renderRTL();
+    }
+
+    return [React.createElement(Input, _extends({
+      key: "input",
+      value: value
+    }, other, {
+      className: inputClass(!hideArrow && getDirectionClass('number')),
+      onChange: this.handleChange,
+      onKeyDown: this.handleKeyDown,
+      onKeyUp: this.handleKeyUp,
+      onBlur: this.handleBlur,
+      type: "number"
+    }))].concat(this.renderArrowGroup());
+  };
+
+  return Number;
+}(PureComponent);
+
+_defineProperty(Number, "defaultProps", DefaultValue);
+
+export default Number;

package/esm/Input/Password.d.ts

@@ -0,0 +1,12 @@
+import { PureComponent } from 'react';
+import { InputPassword } from './Props';
+declare class Password extends PureComponent<InputPassword> {
+    static defaultProps: {
+        value: string;
+        point: string;
+    };
+    constructor(props: InputPassword);
+    handleChange(val: string): void;
+    render(): JSX.Element;
+}
+export default Password;