You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
365 lines
11 KiB
365 lines
11 KiB
import _typeof from "@babel/runtime/helpers/esm/typeof";
|
|
import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
|
|
import _extends from "@babel/runtime/helpers/esm/extends";
|
|
import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
|
|
import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
|
|
import _createClass from "@babel/runtime/helpers/esm/createClass";
|
|
import _inherits from "@babel/runtime/helpers/esm/inherits";
|
|
import _createSuper from "@babel/runtime/helpers/esm/createSuper";
|
|
import * as React from 'react';
|
|
import classNames from 'classnames';
|
|
import omit from "rc-util/es/omit";
|
|
import ClearableLabeledInput from './ClearableLabeledInput';
|
|
import { ConfigConsumer } from '../config-provider';
|
|
import SizeContext from '../config-provider/SizeContext';
|
|
import devWarning from '../_util/devWarning';
|
|
import { getInputClassName, hasPrefixSuffix } from './utils';
|
|
export function fixControlledValue(value) {
|
|
if (typeof value === 'undefined' || value === null) {
|
|
return '';
|
|
}
|
|
|
|
return String(value);
|
|
}
|
|
export function resolveOnChange(target, e, onChange, targetValue) {
|
|
if (!onChange) {
|
|
return;
|
|
}
|
|
|
|
var event = e;
|
|
|
|
if (e.type === 'click') {
|
|
// Clone a new target for event.
|
|
// Avoid the following usage, the setQuery method gets the original value.
|
|
//
|
|
// const [query, setQuery] = React.useState('');
|
|
// <Input
|
|
// allowClear
|
|
// value={query}
|
|
// onChange={(e)=> {
|
|
// setQuery((prevStatus) => e.target.value);
|
|
// }}
|
|
// />
|
|
var currentTarget = target.cloneNode(true); // click clear icon
|
|
|
|
event = Object.create(e, {
|
|
target: {
|
|
value: currentTarget
|
|
},
|
|
currentTarget: {
|
|
value: currentTarget
|
|
}
|
|
});
|
|
currentTarget.value = '';
|
|
onChange(event);
|
|
return;
|
|
} // Trigger by composition event, this means we need force change the input value
|
|
|
|
|
|
if (targetValue !== undefined) {
|
|
event = Object.create(e, {
|
|
target: {
|
|
value: target
|
|
},
|
|
currentTarget: {
|
|
value: target
|
|
}
|
|
});
|
|
target.value = targetValue;
|
|
onChange(event);
|
|
return;
|
|
}
|
|
|
|
onChange(event);
|
|
}
|
|
export function triggerFocus(element, option) {
|
|
if (!element) return;
|
|
element.focus(option); // Selection content
|
|
|
|
var _ref = option || {},
|
|
cursor = _ref.cursor;
|
|
|
|
if (cursor) {
|
|
var len = element.value.length;
|
|
|
|
switch (cursor) {
|
|
case 'start':
|
|
element.setSelectionRange(0, 0);
|
|
break;
|
|
|
|
case 'end':
|
|
element.setSelectionRange(len, len);
|
|
break;
|
|
|
|
default:
|
|
element.setSelectionRange(0, len);
|
|
}
|
|
}
|
|
}
|
|
|
|
var Input = /*#__PURE__*/function (_React$Component) {
|
|
_inherits(Input, _React$Component);
|
|
|
|
var _super = _createSuper(Input);
|
|
|
|
function Input(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Input);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.direction = 'ltr';
|
|
|
|
_this.focus = function (option) {
|
|
triggerFocus(_this.input, option);
|
|
};
|
|
|
|
_this.saveClearableInput = function (input) {
|
|
_this.clearableInput = input;
|
|
};
|
|
|
|
_this.saveInput = function (input) {
|
|
_this.input = input;
|
|
};
|
|
|
|
_this.onFocus = function (e) {
|
|
var onFocus = _this.props.onFocus;
|
|
|
|
_this.setState({
|
|
focused: true
|
|
}, _this.clearPasswordValueAttribute);
|
|
|
|
onFocus === null || onFocus === void 0 ? void 0 : onFocus(e);
|
|
};
|
|
|
|
_this.onBlur = function (e) {
|
|
var onBlur = _this.props.onBlur;
|
|
|
|
_this.setState({
|
|
focused: false
|
|
}, _this.clearPasswordValueAttribute);
|
|
|
|
onBlur === null || onBlur === void 0 ? void 0 : onBlur(e);
|
|
};
|
|
|
|
_this.handleReset = function (e) {
|
|
_this.setValue('', function () {
|
|
_this.focus();
|
|
});
|
|
|
|
resolveOnChange(_this.input, e, _this.props.onChange);
|
|
};
|
|
|
|
_this.renderInput = function (prefixCls, size, bordered) {
|
|
var input = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
|
|
var _this$props = _this.props,
|
|
className = _this$props.className,
|
|
addonBefore = _this$props.addonBefore,
|
|
addonAfter = _this$props.addonAfter,
|
|
customizeSize = _this$props.size,
|
|
disabled = _this$props.disabled,
|
|
htmlSize = _this$props.htmlSize; // Fix https://fb.me/react-unknown-prop
|
|
|
|
var otherProps = omit(_this.props, ['prefixCls', 'onPressEnter', 'addonBefore', 'addonAfter', 'prefix', 'suffix', 'allowClear', // Input elements must be either controlled or uncontrolled,
|
|
// specify either the value prop, or the defaultValue prop, but not both.
|
|
'defaultValue', 'size', 'inputType', 'bordered', 'htmlSize', 'showCount']);
|
|
return /*#__PURE__*/React.createElement("input", _extends({
|
|
autoComplete: input.autoComplete
|
|
}, otherProps, {
|
|
onChange: _this.handleChange,
|
|
onFocus: _this.onFocus,
|
|
onBlur: _this.onBlur,
|
|
onKeyDown: _this.handleKeyDown,
|
|
className: classNames(getInputClassName(prefixCls, bordered, customizeSize || size, disabled, _this.direction), _defineProperty({}, className, className && !addonBefore && !addonAfter)),
|
|
ref: _this.saveInput,
|
|
size: htmlSize
|
|
}));
|
|
};
|
|
|
|
_this.clearPasswordValueAttribute = function () {
|
|
// https://github.com/ant-design/ant-design/issues/20541
|
|
_this.removePasswordTimeout = setTimeout(function () {
|
|
if (_this.input && _this.input.getAttribute('type') === 'password' && _this.input.hasAttribute('value')) {
|
|
_this.input.removeAttribute('value');
|
|
}
|
|
});
|
|
};
|
|
|
|
_this.handleChange = function (e) {
|
|
_this.setValue(e.target.value, _this.clearPasswordValueAttribute);
|
|
|
|
resolveOnChange(_this.input, e, _this.props.onChange);
|
|
};
|
|
|
|
_this.handleKeyDown = function (e) {
|
|
var _this$props2 = _this.props,
|
|
onPressEnter = _this$props2.onPressEnter,
|
|
onKeyDown = _this$props2.onKeyDown;
|
|
|
|
if (onPressEnter && e.keyCode === 13) {
|
|
onPressEnter(e);
|
|
}
|
|
|
|
onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(e);
|
|
};
|
|
|
|
_this.renderShowCountSuffix = function (prefixCls) {
|
|
var value = _this.state.value;
|
|
var _this$props3 = _this.props,
|
|
maxLength = _this$props3.maxLength,
|
|
suffix = _this$props3.suffix,
|
|
showCount = _this$props3.showCount; // Max length value
|
|
|
|
var hasMaxLength = Number(maxLength) > 0;
|
|
|
|
if (suffix || showCount) {
|
|
var valueLength = _toConsumableArray(fixControlledValue(value)).length;
|
|
|
|
var dataCount = null;
|
|
|
|
if (_typeof(showCount) === 'object') {
|
|
dataCount = showCount.formatter({
|
|
count: valueLength,
|
|
maxLength: maxLength
|
|
});
|
|
} else {
|
|
dataCount = "".concat(valueLength).concat(hasMaxLength ? " / ".concat(maxLength) : '');
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, !!showCount && /*#__PURE__*/React.createElement("span", {
|
|
className: classNames("".concat(prefixCls, "-show-count-suffix"), _defineProperty({}, "".concat(prefixCls, "-show-count-has-suffix"), !!suffix))
|
|
}, dataCount), suffix);
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
_this.renderComponent = function (_ref2) {
|
|
var getPrefixCls = _ref2.getPrefixCls,
|
|
direction = _ref2.direction,
|
|
input = _ref2.input;
|
|
var _this$state = _this.state,
|
|
value = _this$state.value,
|
|
focused = _this$state.focused;
|
|
var _this$props4 = _this.props,
|
|
customizePrefixCls = _this$props4.prefixCls,
|
|
_this$props4$bordered = _this$props4.bordered,
|
|
bordered = _this$props4$bordered === void 0 ? true : _this$props4$bordered;
|
|
var prefixCls = getPrefixCls('input', customizePrefixCls);
|
|
_this.direction = direction;
|
|
|
|
var showCountSuffix = _this.renderShowCountSuffix(prefixCls);
|
|
|
|
return /*#__PURE__*/React.createElement(SizeContext.Consumer, null, function (size) {
|
|
return /*#__PURE__*/React.createElement(ClearableLabeledInput, _extends({
|
|
size: size
|
|
}, _this.props, {
|
|
prefixCls: prefixCls,
|
|
inputType: "input",
|
|
value: fixControlledValue(value),
|
|
element: _this.renderInput(prefixCls, size, bordered, input),
|
|
handleReset: _this.handleReset,
|
|
ref: _this.saveClearableInput,
|
|
direction: direction,
|
|
focused: focused,
|
|
triggerFocus: _this.focus,
|
|
bordered: bordered,
|
|
suffix: showCountSuffix
|
|
}));
|
|
});
|
|
};
|
|
|
|
var value = typeof props.value === 'undefined' ? props.defaultValue : props.value;
|
|
_this.state = {
|
|
value: value,
|
|
focused: false,
|
|
// eslint-disable-next-line react/no-unused-state
|
|
prevValue: props.value
|
|
};
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Input, [{
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.clearPasswordValueAttribute();
|
|
} // Since polyfill `getSnapshotBeforeUpdate` need work with `componentDidUpdate`.
|
|
// We keep an empty function here.
|
|
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate() {}
|
|
}, {
|
|
key: "getSnapshotBeforeUpdate",
|
|
value: function getSnapshotBeforeUpdate(prevProps) {
|
|
if (hasPrefixSuffix(prevProps) !== hasPrefixSuffix(this.props)) {
|
|
devWarning(this.input !== document.activeElement, 'Input', "When Input is focused, dynamic add or remove prefix / suffix will make it lose focus caused by dom structure change. Read more: https://ant.design/components/input/#FAQ");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.removePasswordTimeout) {
|
|
clearTimeout(this.removePasswordTimeout);
|
|
}
|
|
}
|
|
}, {
|
|
key: "blur",
|
|
value: function blur() {
|
|
this.input.blur();
|
|
}
|
|
}, {
|
|
key: "setSelectionRange",
|
|
value: function setSelectionRange(start, end, direction) {
|
|
this.input.setSelectionRange(start, end, direction);
|
|
}
|
|
}, {
|
|
key: "select",
|
|
value: function select() {
|
|
this.input.select();
|
|
}
|
|
}, {
|
|
key: "setValue",
|
|
value: function setValue(value, callback) {
|
|
if (this.props.value === undefined) {
|
|
this.setState({
|
|
value: value
|
|
}, callback);
|
|
} else {
|
|
callback === null || callback === void 0 ? void 0 : callback();
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderComponent);
|
|
}
|
|
}], [{
|
|
key: "getDerivedStateFromProps",
|
|
value: function getDerivedStateFromProps(nextProps, _ref3) {
|
|
var prevValue = _ref3.prevValue;
|
|
var newState = {
|
|
prevValue: nextProps.value
|
|
};
|
|
|
|
if (nextProps.value !== undefined || prevValue !== nextProps.value) {
|
|
newState.value = nextProps.value;
|
|
}
|
|
|
|
if (nextProps.disabled) {
|
|
newState.focused = false;
|
|
}
|
|
|
|
return newState;
|
|
}
|
|
}]);
|
|
|
|
return Input;
|
|
}(React.Component);
|
|
|
|
Input.defaultProps = {
|
|
type: 'text'
|
|
};
|
|
export default Input; |