amis 2.0.0-rc.10 → 2.0.0-rc.16

package/esm/renderers/Form/InputTag.d.ts

@@ -0,0 +1,108 @@
+import React from 'react';
+import { OptionsControlProps, Option } from 'amis-core';
+import { ActionObject } from 'amis-core';
+import { FormOptionsSchema } from '../../Schema';
+/**
+ * Tag 输入框
+ * 文档：https://baidu.gitee.io/amis/docs/components/form/tag
+ */
+export interface TagControlSchema extends FormOptionsSchema {
+    type: 'input-tag';
+    /**
+     * 选项提示信息
+     */
+    optionsTip?: string;
+    /**
+     * 是否为下拉模式
+     */
+    dropdown?: boolean;
+    /**
+     * 允许添加的标签的最大数量
+     */
+    max?: number;
+    /**
+     * 单个标签的最大文本长度
+     */
+    maxTagLength?: number;
+    /**
+     * 标签的最大展示数量，超出数量后以收纳浮层的方式展示，仅在多选模式开启后生效
+     */
+    maxTagCount?: number;
+    /**
+     * 收纳标签的Popover配置
+     */
+    overflowTagPopover?: object;
+    /** 是否开启批量添加模式 */
+    enableBatchAdd: boolean;
+    /**
+     * 开启批量添加后，输入多个标签的分隔符，支持传入多个符号，默认为"-"
+     *
+     * @default "-"
+     */
+    separator?: string;
+}
+export declare type InputTagValidationType = 'max' | 'maxLength';
+export interface TagProps extends OptionsControlProps {
+    placeholder?: string;
+    clearable: boolean;
+    resetValue?: any;
+    optionsTip: string;
+    dropdown?: boolean;
+    /** 是否支持批量输入 */
+    enableBatchAdd: boolean;
+    /** 开启批量添加后，输入多个标签的分隔符，支持传入多个符号，默认为英文逗号 */
+    separator?: string;
+    /** 允许添加的tag的最大数量 */
+    max?: number;
+    /** 单个标签的最大文本长度 */
+    maxTagLength?: number;
+    /** 文本输入后校验失败的callback */
+    onInputValidateFailed?(value: string | string[], validationType: InputTagValidationType): void;
+}
+export interface TagState {
+    inputValue: string;
+    isFocused?: boolean;
+    isOpened?: boolean;
+}
+export default class TagControl extends React.PureComponent<TagProps, TagState> {
+    input: React.RefObject<any>;
+    static defaultProps: {
+        resetValue: string;
+        labelField: string;
+        valueField: string;
+        multiple: boolean;
+        placeholder: string;
+        optionsTip: string;
+        separator: string;
+    };
+    state: {
+        isOpened: boolean;
+        inputValue: string;
+        isFocused: boolean;
+    };
+    componentDidUpdate(prevProps: TagProps): void;
+    doAction(action: ActionObject, data: object, throwErrors: boolean): void;
+    dispatchEvent(eventName: string, eventData?: any): Promise<boolean>;
+    /** 处理输入的内容 */
+    normalizeInputValue(inputValue: string, separator?: string): Option[];
+    normalizeOptions(options: Option[]): string | any[];
+    /** 输入的内容和存量的内容合并，过滤掉value值相同的 */
+    normalizeMergedValue(inputValue: string, normalized?: boolean): string | any[];
+    validateInputValue(inputValue: string): boolean;
+    getValue(type?: 'push' | 'pop' | 'normal', option?: any): string | any[];
+    addItem(option: Option): Promise<void>;
+    handleFocus(e: any): Promise<void>;
+    handleBlur(e: any): Promise<void>;
+    close(): void;
+    handleInputChange(text: string): void;
+    handleChange(value: Array<Option>): Promise<void>;
+    renderItem(item: Option): any;
+    handleKeyDown(evt: React.KeyboardEvent<HTMLInputElement>): Promise<void>;
+    handleOptionChange(option: Option): void;
+    getTarget(): any;
+    getParent(): any;
+    reload(): void;
+    render(): JSX.Element;
+}
+export declare class TagControlRenderer extends TagControl {
+}

package/esm/renderers/Form/InputTag.js

@@ -0,0 +1,439 @@
+/**
+ * amis v2.0.0-rc.16
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __awaiter, __generator, __assign, __decorate, __metadata } from 'tslib';
+import React from 'react';
+import { createObject, filterTree, Overlay, PopOver, autobind, OptionsControl } from 'amis-core';
+import Downshift from 'downshift';
+import find from 'lodash/find';
+import isInteger from 'lodash/isInteger';
+import unionWith from 'lodash/unionWith';
+import { findDOMNode } from 'react-dom';
+import { ResultBox, Spinner, ListMenu } from 'amis-ui';
+
+var TagControl = /** @class */ (function (_super) {
+    __extends(TagControl, _super);
+    function TagControl() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.input = React.createRef();
+        _this.state = {
+            isOpened: false,
+            inputValue: '',
+            isFocused: false
+        };
+        return _this;
+    }
+    TagControl.prototype.componentDidUpdate = function (prevProps) {
+        var props = this.props;
+        if (prevProps.value !== props.value) {
+            this.setState({
+                inputValue: ''
+            });
+        }
+    };
+    TagControl.prototype.doAction = function (action, data, throwErrors) {
+        var _a = this.props, resetValue = _a.resetValue, onChange = _a.onChange;
+        var actionType = action === null || action === void 0 ? void 0 : action.actionType;
+        if (actionType === 'clear') {
+            onChange === null || onChange === void 0 ? void 0 : onChange('');
+        }
+        else if (actionType === 'reset') {
+            onChange === null || onChange === void 0 ? void 0 : onChange(resetValue !== null && resetValue !== void 0 ? resetValue : '');
+        }
+    };
+    TagControl.prototype.dispatchEvent = function (eventName, eventData) {
+        if (eventData === void 0) { eventData = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, dispatchEvent, options, data, rendererEvent;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, dispatchEvent = _a.dispatchEvent, options = _a.options, data = _a.data;
+                        return [4 /*yield*/, dispatchEvent(eventName, createObject(data, __assign({ options: options }, eventData)))];
+                    case 1:
+                        rendererEvent = _b.sent();
+                        // 返回阻塞标识
+                        return [2 /*return*/, !!(rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented)];
+                }
+            });
+        });
+    };
+    /** 处理输入的内容 */
+    TagControl.prototype.normalizeInputValue = function (inputValue, separator) {
+        if (separator === void 0) { separator = '-'; }
+        var batchValues = [];
+        if (typeof separator === 'string') {
+            batchValues = inputValue.split(separator);
+        }
+        else {
+            batchValues.push(inputValue);
+        }
+        return batchValues
+            .filter(Boolean)
+            .map(function (item) { return ({ value: item, label: item }); });
+    };
+    TagControl.prototype.normalizeOptions = function (options) {
+        var _a = this.props, joinValues = _a.joinValues, extractValue = _a.extractValue, delimiter = _a.delimiter, valueField = _a.valueField;
+        return joinValues
+            ? options.map(function (item) { return item[valueField || 'value']; }).join(delimiter || ',')
+            : extractValue
+                ? options.map(function (item) { return item[valueField || 'value']; })
+                : options;
+    };
+    /** 输入的内容和存量的内容合并，过滤掉value值相同的 */
+    TagControl.prototype.normalizeMergedValue = function (inputValue, normalized) {
+        if (normalized === void 0) { normalized = true; }
+        var _a = this.props, selectedOptions = _a.selectedOptions; _a.joinValues; _a.extractValue; _a.delimiter; _a.valueField; var enableBatchAdd = _a.enableBatchAdd, separator = _a.separator;
+        var options = unionWith(selectedOptions.concat(), this.normalizeInputValue(inputValue, enableBatchAdd ? separator : undefined), function (origin, input) { return origin.value === input.value; });
+        return normalized ? this.normalizeOptions(options) : options;
+    };
+    TagControl.prototype.validateInputValue = function (inputValue) {
+        var _a = this.props, max = _a.max, maxTagLength = _a.maxTagLength, enableBatchAdd = _a.enableBatchAdd, separator = _a.separator, onInputValidateFailed = _a.onInputValidateFailed;
+        var normalizedValue = this.normalizeMergedValue(inputValue, false);
+        if (max != null && isInteger(max) && normalizedValue.length > max) {
+            onInputValidateFailed === null || onInputValidateFailed === void 0 ? void 0 : onInputValidateFailed(normalizedValue.map(function (item) { return item.value; }), 'max');
+            return false;
+        }
+        var addedValues = this.normalizeInputValue(inputValue, enableBatchAdd ? separator : undefined);
+        if (maxTagLength != null &&
+            isInteger(maxTagLength) &&
+            addedValues.some(function (item) { return item.value.length > maxTagLength; })) {
+            onInputValidateFailed === null || onInputValidateFailed === void 0 ? void 0 : onInputValidateFailed(addedValues.map(function (item) { return item.value; }), 'maxLength');
+            return false;
+        }
+        return true;
+    };
+    TagControl.prototype.getValue = function (type, option) {
+        if (type === void 0) { type = 'normal'; }
+        if (option === void 0) { option = {}; }
+        var _a = this.props, selectedOptions = _a.selectedOptions, joinValues = _a.joinValues, extractValue = _a.extractValue, delimiter = _a.delimiter, valueField = _a.valueField;
+        var newValue = selectedOptions.concat();
+        if (type === 'push') {
+            newValue.push(option);
+        }
+        else if (type === 'pop') {
+            newValue.pop();
+        }
+        return joinValues
+            ? newValue.map(function (item) { return item[valueField || 'value']; }).join(delimiter || ',')
+            : extractValue
+                ? newValue.map(function (item) { return item[valueField || 'value']; })
+                : newValue;
+    };
+    TagControl.prototype.addItem = function (option) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, selectedOptions, onChange, newValue, newValueRes, isPrevented;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, selectedOptions = _a.selectedOptions, onChange = _a.onChange;
+                        newValue = selectedOptions.concat();
+                        if (find(newValue, function (item) { return item.value == option.value; })) {
+                            return [2 /*return*/];
+                        }
+                        newValueRes = this.getValue('push', option);
+                        return [4 /*yield*/, this.dispatchEvent('change', {
+                                value: newValueRes
+                            })];
+                    case 1:
+                        isPrevented = _b.sent();
+                        isPrevented || onChange(newValueRes);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TagControl.prototype.handleFocus = function (e) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var newValueRes, isPrevented;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this.setState({
+                            isFocused: true,
+                            isOpened: true
+                        });
+                        newValueRes = this.getValue('normal');
+                        return [4 /*yield*/, this.dispatchEvent('focus', {
+                                value: newValueRes
+                            })];
+                    case 1:
+                        isPrevented = _c.sent();
+                        isPrevented || ((_b = (_a = this.props).onFocus) === null || _b === void 0 ? void 0 : _b.call(_a, e));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TagControl.prototype.handleBlur = function (e) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var _c, selectedOptions, onChange, value, newValueRes, isPrevented;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _c = this.props, selectedOptions = _c.selectedOptions, onChange = _c.onChange;
+                        value = this.state.inputValue.trim();
+                        if (!this.validateInputValue(value)) {
+                            this.setState({ isFocused: false, isOpened: false });
+                            return [2 /*return*/];
+                        }
+                        newValueRes = this.normalizeMergedValue(value);
+                        return [4 /*yield*/, this.dispatchEvent('blur', {
+                                value: newValueRes
+                            })];
+                    case 1:
+                        isPrevented = _d.sent();
+                        isPrevented || ((_b = (_a = this.props).onBlur) === null || _b === void 0 ? void 0 : _b.call(_a, e));
+                        this.setState({
+                            isFocused: false,
+                            isOpened: false,
+                            inputValue: ''
+                        }, value
+                            ? function () {
+                                if (selectedOptions.length !== newValueRes.length) {
+                                    onChange === null || onChange === void 0 ? void 0 : onChange(newValueRes);
+                                }
+                            }
+                            : undefined);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TagControl.prototype.close = function () {
+        this.setState({
+            isOpened: false
+        });
+    };
+    TagControl.prototype.handleInputChange = function (text) {
+        this.setState({ inputValue: text });
+    };
+    TagControl.prototype.handleChange = function (value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, joinValues, extractValue, delimiter, valueField, onChange, newValue, isPrevented;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, joinValues = _a.joinValues, extractValue = _a.extractValue, delimiter = _a.delimiter, valueField = _a.valueField, onChange = _a.onChange;
+                        newValue = Array.isArray(value) ? value.concat() : [];
+                        if (joinValues || extractValue) {
+                            newValue = value.map(function (item) { return item[valueField || 'value']; });
+                        }
+                        if (joinValues) {
+                            newValue = newValue.join(delimiter || ',');
+                        }
+                        return [4 /*yield*/, this.dispatchEvent('change', {
+                                value: newValue
+                            })];
+                    case 1:
+                        isPrevented = _b.sent();
+                        isPrevented || onChange(newValue);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TagControl.prototype.renderItem = function (item) {
+        var labelField = this.props.labelField;
+        return "".concat(item[labelField || 'label']);
+    };
+    TagControl.prototype.handleKeyDown = function (evt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, selectedOptions, onChange, delimiter, value, newValueRes, isPrevented, newValueRes, isPrevented;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, selectedOptions = _a.selectedOptions, onChange = _a.onChange, delimiter = _a.delimiter;
+                        value = this.state.inputValue.trim();
+                        if (!(selectedOptions.length && !value && evt.key == 'Backspace')) return [3 /*break*/, 2];
+                        newValueRes = this.getValue('pop');
+                        return [4 /*yield*/, this.dispatchEvent('change', {
+                                value: newValueRes
+                            })];
+                    case 1:
+                        isPrevented = _b.sent();
+                        isPrevented || onChange(newValueRes);
+                        return [3 /*break*/, 4];
+                    case 2:
+                        if (!(value && (evt.key === 'Enter' || evt.key === delimiter))) return [3 /*break*/, 4];
+                        evt.preventDefault();
+                        evt.stopPropagation();
+                        newValueRes = this.normalizeMergedValue(value);
+                        return [4 /*yield*/, this.dispatchEvent('change', {
+                                value: newValueRes
+                            })];
+                    case 3:
+                        isPrevented = _b.sent();
+                        if (!this.validateInputValue(value)) {
+                            this.setState({ isFocused: false, isOpened: false });
+                            return [2 /*return*/];
+                        }
+                        if (!isPrevented && selectedOptions.length !== newValueRes.length) {
+                            onChange(newValueRes);
+                        }
+                        this.setState({
+                            inputValue: ''
+                        });
+                        _b.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TagControl.prototype.handleOptionChange = function (option) {
+        if (this.state.inputValue || !option) {
+            return;
+        }
+        this.addItem(option);
+    };
+    TagControl.prototype.getTarget = function () {
+        return this.input.current;
+    };
+    TagControl.prototype.getParent = function () {
+        return this.input.current && findDOMNode(this.input.current).parentElement;
+    };
+    TagControl.prototype.reload = function () {
+        var reload = this.props.reloadOptions;
+        reload === null || reload === void 0 ? void 0 : reload();
+    };
+    TagControl.prototype.render = function () {
+        var _this = this;
+        var _a = this.props, className = _a.className, cx = _a.classnames, disabled = _a.disabled, placeholder = _a.placeholder, name = _a.name, clearable = _a.clearable, selectedOptions = _a.selectedOptions, loading = _a.loading, popOverContainer = _a.popOverContainer, dropdown = _a.dropdown, options = _a.options, optionsTip = _a.optionsTip, maxTagCount = _a.maxTagCount, overflowTagPopover = _a.overflowTagPopover, __ = _a.translate;
+        var finnalOptions = Array.isArray(options)
+            ? filterTree(options, function (item) {
+                return (Array.isArray(item.children) && !!item.children.length) ||
+                    (item.value !== undefined && !~selectedOptions.indexOf(item));
+            }, 0, true)
+            : [];
+        return (React.createElement(Downshift, { selectedItem: selectedOptions, isOpen: this.state.isFocused, inputValue: this.state.inputValue, onChange: this.handleOptionChange, itemToString: this.renderItem }, function (_a) {
+            var isOpen = _a.isOpen, highlightedIndex = _a.highlightedIndex, getItemProps = _a.getItemProps, getInputProps = _a.getInputProps;
+            return (React.createElement("div", { className: cx(className, "TagControl") },
+                React.createElement(ResultBox, __assign({}, getInputProps({
+                    name: name,
+                    ref: _this.input,
+                    placeholder: __(placeholder || 'Tag.placeholder'),
+                    value: _this.state.inputValue,
+                    onKeyDown: _this.handleKeyDown,
+                    onFocus: _this.handleFocus,
+                    onBlur: _this.handleBlur,
+                    disabled: disabled
+                }), { onChange: _this.handleInputChange, className: cx('TagControl-input'), result: selectedOptions, onResultChange: _this.handleChange, itemRender: _this.renderItem, clearable: clearable, maxTagCount: maxTagCount, overflowTagPopover: overflowTagPopover, allowInput: true }), loading ? React.createElement(Spinner, { size: "sm" }) : undefined),
+                dropdown !== false ? (React.createElement(Overlay, { container: popOverContainer || _this.getParent, target: _this.getTarget, placement: 'auto', show: isOpen && !!finnalOptions.length },
+                    React.createElement(PopOver, { overlay: true, className: cx('TagControl-popover'), onHide: _this.close },
+                        React.createElement(ListMenu, { options: finnalOptions, itemRender: _this.renderItem, highlightIndex: highlightedIndex, getItemProps: function (_a) {
+                                var item = _a.item, index = _a.index;
+                                return (__assign({}, getItemProps({
+                                    index: index,
+                                    item: item,
+                                    disabled: item.disabled
+                                })));
+                            } })))) : (
+                // 保留原来的展现方式，不推荐
+                React.createElement("div", { className: cx('TagControl-sug') },
+                    optionsTip ? (React.createElement("div", { className: cx('TagControl-sugTip') }, __(optionsTip))) : null,
+                    options.map(function (item, index) { return (React.createElement("div", { className: cx('TagControl-sugItem', {
+                            'is-disabled': item.disabled || disabled
+                        }), key: index, onClick: _this.addItem.bind(_this, item) }, item.label)); })))));
+        }));
+    };
+    TagControl.defaultProps = {
+        resetValue: '',
+        labelField: 'label',
+        valueField: 'value',
+        multiple: true,
+        placeholder: 'Tag.placeholder',
+        optionsTip: 'Tag.tip',
+        separator: '-'
+    };
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [String, Object]),
+        __metadata("design:returntype", Promise)
+    ], TagControl.prototype, "dispatchEvent", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [String, Object]),
+        __metadata("design:returntype", void 0)
+    ], TagControl.prototype, "getValue", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], TagControl.prototype, "handleFocus", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], TagControl.prototype, "handleBlur", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TagControl.prototype, "close", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [String]),
+        __metadata("design:returntype", void 0)
+    ], TagControl.prototype, "handleInputChange", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Array]),
+        __metadata("design:returntype", Promise)
+    ], TagControl.prototype, "handleChange", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Object)
+    ], TagControl.prototype, "renderItem", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], TagControl.prototype, "handleKeyDown", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], TagControl.prototype, "handleOptionChange", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TagControl.prototype, "getTarget", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TagControl.prototype, "getParent", null);
+    return TagControl;
+}(React.PureComponent));
+/** @class */ ((function (_super) {
+    __extends(TagControlRenderer, _super);
+    function TagControlRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TagControlRenderer = __decorate([
+        OptionsControl({
+            type: 'input-tag'
+        })
+    ], TagControlRenderer);
+    return TagControlRenderer;
+})(TagControl));
+
+export { TagControl as default };

package/esm/renderers/Form/InputText.d.ts

@@ -0,0 +1,133 @@
+import React from 'react';
+import { OptionsControlProps } from 'amis-core';
+import { ActionObject } from 'amis-core';
+import { StateChangeOptions } from 'downshift';
+import { ActionSchema } from '../Action';
+import { FormOptionsSchema, SchemaApi } from '../../Schema';
+import type { Option } from 'amis-core';
+import type { ListenerAction } from 'amis-core';
+/**
+ * Text 文本输入框。
+ * 文档：https://baidu.gitee.io/amis/docs/components/form/text
+ */
+export interface TextControlSchema extends FormOptionsSchema {
+    type: 'input-text' | 'input-email' | 'input-url' | 'input-password' | 'native-date' | 'native-time' | 'native-number';
+    addOn?: {
+        position?: 'left' | 'right';
+        label?: string;
+        icon?: string;
+        className?: string;
+    } & ActionSchema;
+    /**
+     * 是否去除首尾空白文本。
+     */
+    trimContents?: boolean;
+    /**
+     * 自动完成 API，当输入部分文字的时候，会将这些文字通过 ${term} 可以取到，发送给接口。
+     * 接口可以返回匹配到的选项，帮助用户输入。
+     */
+    autoComplete?: SchemaApi;
+    /**
+     * 边框模式，全边框，还是半边框，或者没边框。
+     */
+    borderMode?: 'full' | 'half' | 'none';
+    /**
+     * 限制文字个数
+     */
+    maxLength?: number;
+    /**
+     * 是否显示计数
+     */
+    showCounter?: boolean;
+    /**
+     * 前缀
+     */
+    prefix?: string;
+    /**
+     * 后缀
+     */
+    suffix?: string;
+    /**
+     * 自动转换值
+     */
+    transform?: {
+        /** 用户输入的字符自动转小写 */
+        lowerCase?: boolean;
+        /** 用户输入的字符自动转大写 */
+        upperCase?: boolean;
+    };
+}
+export declare type InputTextRendererEvent = 'blur' | 'focus' | 'click' | 'change' | 'enter';
+export interface TextProps extends OptionsControlProps {
+    placeholder?: string;
+    addOn?: ActionObject & {
+        position?: 'left' | 'right';
+        label?: string;
+        icon?: string;
+        className?: string;
+    };
+    creatable?: boolean;
+    clearable: boolean;
+    resetValue?: any;
+    autoComplete?: any;
+    allowInputText?: boolean;
+    spinnerClassName: string;
+    revealPassword?: boolean;
+    transform?: {
+        lowerCase?: boolean;
+        upperCase?: boolean;
+    };
+}
+export interface TextState {
+    isOpen?: boolean;
+    inputValue?: string;
+    isFocused?: boolean;
+    revealPassword?: boolean;
+}
+export default class TextControl extends React.PureComponent<TextProps, TextState> {
+    input?: HTMLInputElement;
+    highlightedIndex?: any;
+    unHook: Function;
+    constructor(props: TextProps);
+    static defaultProps: Partial<TextProps>;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: TextProps): void;
+    componentWillUnmount(): void;
+    inputRef(ref: any): void;
+    doAction(action: ListenerAction, args: any): void;
+    focus(): void;
+    clearValue(): void;
+    removeItem(index: number): void;
+    handleClick(): void;
+    handleFocus(e: any): void;
+    handleBlur(e: any): void;
+    handleInputChange(evt: React.ChangeEvent<HTMLInputElement>): Promise<void>;
+    handleKeyDown(evt: React.KeyboardEvent<HTMLInputElement>): Promise<void>;
+    handleChange(value: any): void;
+    handleStateChange(changes: StateChangeOptions<any>): void;
+    handleNormalInputChange(e: React.ChangeEvent<HTMLInputElement>): Promise<void>;
+    normalizeValue(value: Option[] | Option | undefined | null): any;
+    transformValue(value: string): string;
+    loadAutoComplete(): void;
+    reload(): void;
+    valueToString(value: any): string;
+    renderSugestMode(): JSX.Element;
+    toggleRevealPassword(): void;
+    renderNormal(): JSX.Element;
+    render(): JSX.Element;
+}
+export declare function mapItemIndex(items: Array<any>, values: Array<any>, valueField?: string): any;
+export declare class TextControlRenderer extends TextControl {
+}
+export declare class PasswordControlRenderer extends TextControl {
+}
+export declare class EmailControlRenderer extends TextControl {
+}
+export declare class UrlControlRenderer extends TextControl {
+}
+export declare class NativeDateControlRenderer extends TextControl {
+}
+export declare class NativeTimeControlRenderer extends TextControl {
+}
+export declare class NativeNumberControlRenderer extends TextControl {
+}