amis-ui 6.13.0-beta.8 → 6.13.0

package/esm/components/ColorPicker.js

@@ -0,0 +1,260 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { __extends, __decorate, __metadata } from 'tslib';
+import React__default from 'react';
+import { findDOMNode } from 'react-dom';
+import { SketchPicker, GithubPicker } from 'react-color';
+import { Icon } from './icons.js';
+import { Overlay, PopOver, isObject, autobind, themeable, localeable, uncontrollable } from 'amis-core';
+import PopUp from './PopUp.js';
+
+/**
+ * @file ColorPicker
+ * @description 颜色选择器组件
+ * @author fex
+ */
+var ColorControl = /** @class */ (function (_super) {
+    __extends(ColorControl, _super);
+    function ColorControl(props) {
+        var _this = _super.call(this, props) || this;
+        _this.state = {
+            isOpened: false,
+            isFocused: false,
+            inputValue: _this.props.value || '',
+            tempValue: _this.props.value || ''
+        };
+        _this.open = _this.open.bind(_this);
+        _this.close = _this.close.bind(_this);
+        _this.focus = _this.focus.bind(_this);
+        _this.blur = _this.blur.bind(_this);
+        _this.handleChange = _this.handleChange.bind(_this);
+        _this.handleTempChange = _this.handleTempChange.bind(_this);
+        _this.handleConfirm = _this.handleConfirm.bind(_this);
+        _this.handleFocus = _this.handleFocus.bind(_this);
+        _this.handleBlur = _this.handleBlur.bind(_this);
+        _this.clearValue = _this.clearValue.bind(_this);
+        _this.handleInputChange = _this.handleInputChange.bind(_this);
+        _this.handleClick = _this.handleClick.bind(_this);
+        _this.preview = React__default.createRef();
+        _this.input = React__default.createRef();
+        return _this;
+    }
+    ColorControl.prototype.componentDidUpdate = function (prevProps) {
+        var props = this.props;
+        if (prevProps.value !== props.value) {
+            this.setState({
+                inputValue: props.value || ''
+            });
+        }
+    };
+    ColorControl.prototype.handleFocus = function () {
+        this.setState({
+            isFocused: true
+        });
+    };
+    ColorControl.prototype.handleBlur = function () {
+        this.setState({
+            isFocused: false,
+            inputValue: this.props.value
+        });
+    };
+    ColorControl.prototype.focus = function () {
+        this.input.current && this.input.current.focus();
+    };
+    ColorControl.prototype.blur = function () {
+        this.input.current && this.input.current.blur();
+    };
+    ColorControl.prototype.open = function (fn) {
+        if (this.props.disabled) {
+            return;
+        }
+        this.setState({
+            isOpened: true
+        }, fn);
+    };
+    ColorControl.prototype.close = function () {
+        this.setState({
+            isOpened: false
+        });
+    };
+    ColorControl.prototype.clearValue = function () {
+        var _a = this.props, onChange = _a.onChange, resetValue = _a.resetValue;
+        onChange(resetValue || '');
+    };
+    ColorControl.prototype.handleClick = function () {
+        this.state.isOpened ? this.close() : this.open(this.focus);
+    };
+    ColorControl.prototype.handleInputChange = function (e) {
+        var _this = this;
+        if (!this.props.allowCustomColor) {
+            return;
+        }
+        var onChange = this.props.onChange;
+        this.setState({
+            inputValue: e.currentTarget.value
+        }, function () {
+            var isValidated = _this.validateColor(_this.state.inputValue);
+            if (isValidated) {
+                onChange(_this.state.inputValue);
+            }
+        });
+    };
+    ColorControl.prototype.validateColor = function (value) {
+        if (value === '') {
+            return false;
+        }
+        if (value === 'inherit') {
+            return false;
+        }
+        if (value === 'transparent') {
+            return false;
+        }
+        var image = document.createElement('img');
+        image.style.color = 'rgb(0, 0, 0)';
+        image.style.color = value;
+        if (image.style.color !== 'rgb(0, 0, 0)') {
+            return true;
+        }
+        image.style.color = 'rgb(255, 255, 255)';
+        image.style.color = value;
+        return image.style.color !== 'rgb(255, 255, 255)';
+    };
+    ColorControl.prototype.handleChange = function (color) {
+        var _a = this.props, onChange = _a.onChange, format = _a.format
+        // closeOnSelect
+        ;
+        if (format === 'rgba') {
+            onChange("rgba(".concat(color.rgb.r, ", ").concat(color.rgb.g, ", ").concat(color.rgb.b, ", ").concat(color.rgb.a, ")"));
+        }
+        else if (format === 'rgb') {
+            onChange("rgb(".concat(color.rgb.r, ", ").concat(color.rgb.g, ", ").concat(color.rgb.b, ")"));
+        }
+        else if (format === 'hexa') {
+            onChange(this.rgbaToHex(color.rgb.r, color.rgb.g, color.rgb.b, color.rgb.a));
+        }
+        else if (format === 'hsl') {
+            onChange("hsl(".concat(Math.round(color.hsl.h), ", ").concat(Math.round(color.hsl.s * 100), "%, ").concat(Math.round(color.hsl.l * 100), "%)"));
+        }
+        else {
+            onChange(color.hex);
+        }
+        // closeOnSelect && this.close();
+    };
+    ColorControl.prototype.handleTempChange = function (color) {
+        var tempValue = this.state.tempValue;
+        var format = this.props.format;
+        if (format === 'rgba') {
+            tempValue = "rgba(".concat(color.rgb.r, ", ").concat(color.rgb.g, ", ").concat(color.rgb.b, ", ").concat(color.rgb.a, ")");
+        }
+        else if (format === 'rgb') {
+            tempValue = "rgb(".concat(color.rgb.r, ", ").concat(color.rgb.g, ", ").concat(color.rgb.b, ")");
+        }
+        else if (format === 'hexa') {
+            tempValue = this.rgbaToHex(color.rgb.r, color.rgb.g, color.rgb.b, color.rgb.a);
+        }
+        else if (format === 'hsl') {
+            tempValue = "hsl(".concat(Math.round(color.hsl.h), ", ").concat(Math.round(color.hsl.s * 100), "%, ").concat(Math.round(color.hsl.l * 100), "%)");
+        }
+        else {
+            tempValue = color.hex;
+        }
+        this.setState({ tempValue: tempValue });
+    };
+    ColorControl.prototype.handleConfirm = function () {
+        var onChange = this.props.onChange;
+        var tempValue = this.state.tempValue;
+        onChange(tempValue);
+        this.close();
+    };
+    /**
+     * Converts an RGBA color to an 8-digit hex color.
+     *
+     * @param r - Red component (0-255)
+     * @param g - Green component (0-255)
+     * @param b - Blue component (0-255)
+     * @param a - Alpha component (1-100)
+     * @returns The hex color string in the format #RRGGBBAA
+     */
+    ColorControl.prototype.rgbaToHex = function (r, g, b, a) {
+        if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
+            return "#00000000";
+        }
+        if (typeof a === 'undefined' || a > 1) {
+            a = 1;
+        }
+        if (a < 0.01) {
+            a = 0;
+        }
+        var toHex = function (n) { return n.toString(16).padStart(2, '0').toUpperCase(); };
+        var alphaHex = toHex(Math.round(a * 255));
+        var redHex = toHex(r);
+        var greenHex = toHex(g);
+        var blueHex = toHex(b);
+        return "#".concat(redHex).concat(greenHex).concat(blueHex).concat(alphaHex);
+    };
+    ColorControl.prototype.render = function () {
+        var _this = this;
+        var _a = this.props, ns = _a.classPrefix, className = _a.className, popoverClassName = _a.popoverClassName, value = _a.value, placeholder = _a.placeholder, disabled = _a.disabled, popOverContainer = _a.popOverContainer, popOverContainerSelector = _a.popOverContainerSelector, format = _a.format, clearable = _a.clearable, placement = _a.placement, cx = _a.classnames, presetColors = _a.presetColors, allowCustomColor = _a.allowCustomColor, mobileUI = _a.mobileUI;
+        var __ = this.props.translate;
+        var isOpened = this.state.isOpened;
+        var isFocused = this.state.isFocused;
+        var tempValue = this.state.tempValue;
+        return (React__default.createElement("div", { className: cx("ColorPicker", {
+                'is-disabled': disabled,
+                'is-focused': isFocused,
+                'is-opened': isOpened
+            }, className) },
+            React__default.createElement("span", { onClick: this.handleClick, className: cx('ColorPicker-preview') },
+                React__default.createElement("i", { ref: this.preview, className: "".concat(ns, "ColorPicker-previewIcon"), style: { background: this.state.inputValue || '#ccc' } })),
+            React__default.createElement("input", { ref: this.input, type: "text", autoComplete: "off", size: 10, className: cx('ColorPicker-input'), value: this.state.inputValue || '', placeholder: __(placeholder), disabled: disabled, onChange: this.handleInputChange, onFocus: this.handleFocus, onBlur: this.handleBlur, onClick: this.handleClick, readOnly: mobileUI }),
+            clearable && !disabled && value ? (React__default.createElement("a", { onClick: this.clearValue, className: cx('ColorPicker-clear') },
+                React__default.createElement(Icon, { icon: "input-clear", className: "icon" }))) : null,
+            React__default.createElement("span", { className: cx('ColorPicker-arrow') },
+                React__default.createElement(Icon, { icon: "right-arrow-bold", className: "icon", onClick: this.handleClick })),
+            !mobileUI && isOpened ? (React__default.createElement(Overlay, { placement: placement || 'auto', target: function () { return findDOMNode(_this); }, onHide: this.close, container: popOverContainer || (function () { return findDOMNode(_this); }), containerSelector: popOverContainerSelector, rootClose: false, show: true },
+                React__default.createElement(PopOver, { classPrefix: ns, className: cx('ColorPicker-popover', popoverClassName), onHide: this.close, overlay: true }, allowCustomColor ? (React__default.createElement(SketchPicker, { styles: {}, disableAlpha: !!~['rgb', 'hex'].indexOf(format), color: value, presetColors: presetColors, onChangeComplete: this.handleChange })) : (React__default.createElement(GithubPicker, { color: value, colors: Array.isArray(presetColors)
+                        ? presetColors
+                            .filter(function (item) { return typeof item === 'string' || isObject(item); })
+                            .map(function (item) {
+                            return typeof item === 'string'
+                                ? item
+                                : isObject(item)
+                                    ? item === null || item === void 0 ? void 0 : item.color
+                                    : item;
+                        })
+                        : undefined, onChangeComplete: this.handleChange }))))) : null,
+            mobileUI && (React__default.createElement(PopUp, { className: cx("".concat(ns, "ColorPicker-popup")), container: popOverContainer, isShow: isOpened, onHide: this.handleClick, showConfirm: true, onConfirm: this.handleConfirm }, allowCustomColor ? (React__default.createElement(SketchPicker, { styles: {}, disableAlpha: !!~['rgb', 'hex'].indexOf(format), color: tempValue, presetColors: presetColors, onChangeComplete: this.handleTempChange })) : (React__default.createElement(GithubPicker, { color: tempValue, colors: Array.isArray(presetColors)
+                    ? presetColors
+                        .filter(function (item) { return typeof item === 'string' || isObject(item); })
+                        .map(function (item) {
+                        return typeof item === 'string'
+                            ? item
+                            : isObject(item)
+                                ? item === null || item === void 0 ? void 0 : item.color
+                                : item;
+                    })
+                    : undefined, onChangeComplete: this.handleTempChange }))))));
+    };
+    ColorControl.defaultProps = {
+        format: 'hex',
+        clearable: true,
+        placeholder: 'ColorPicker.placeholder',
+        allowCustomColor: true
+        // closeOnSelect: true
+    };
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [String]),
+        __metadata("design:returntype", void 0)
+    ], ColorControl.prototype, "validateColor", null);
+    return ColorControl;
+}(React__default.PureComponent));
+var ColorPicker = themeable(localeable(uncontrollable(ColorControl, {
+    value: 'onChange'
+})));
+
+export { ColorControl, ColorPicker as default };

package/esm/components/Combo.d.ts

@@ -0,0 +1,354 @@
+/**
+ * 纯组件版本的 combo 实现
+ *
+ * 只能用在 <Form> 里面。
+ *
+ * 示例:
+ *
+ * <Form
+ *   defaultValues={{a: 1, b: 2, arr: [{a: 1, b: 2}]}}
+ *   onSubmit={values => console.log(values)}
+ * >
+ *   {({control, getValues, setValue, handleSubmit}) => (
+ *     <>
+ *       <Combo
+ *         name="arr"
+ *         control={control}
+ *         label="Combo"
+ *         mode="horizontal"
+ *         itemRender={({
+ *           control,
+ *           getValues,
+ *           setValue,
+ *           handleSubmit
+ *         }) => (
+ *           <>
+ *             <Controller
+ *               name="a"
+ *               label="A"
+ *               mode="horizontal"
+ *               horizontal={{justify: true}}
+ *               control={control}
+ *               rules={{maxLength: 20}}
+ *               render={({field, fieldState}) => (
+ *                 <InputBox
+ *                   {...field}
+ *                   hasError={fieldState.error}
+ *                   disabled={false}
+ *                 />
+ *               )}
+ *             />
+ *
+ *             <Controller
+ *               name="b"
+ *               control={control}
+ *               rules={{maxLength: 20}}
+ *               render={({field, fieldState}) => (
+ *                 <InputBox
+ *                   {...field}
+ *                   hasError={fieldState.error}
+ *                   disabled={false}
+ *                 />
+ *               )}
+ *             />
+ *           </>
+ *         )}
+ *       />
+ *     </>
+ *   )}
+ * </Form>
+ */
+/// <reference types="hoist-non-react-statics" />
+import { ClassNamesFn, LocaleProps, ThemeProps, TranslateFn } from 'amis-core';
+import React from 'react';
+import { Control, RegisterOptions, UseFieldArrayProps, UseFormReturn } from 'react-hook-form';
+import { FormFieldProps } from './FormField';
+export interface ComboProps<T = any> extends ThemeProps, LocaleProps, Omit<FormFieldProps, 'children' | 'errors' | 'hasError' | 'className'>, UseFieldArrayProps {
+    itemRender: (methods: UseFormReturn, index: number) => JSX.Element | null;
+    control: Control<any>;
+    fieldClassName?: string;
+    rules?: Omit<RegisterOptions, 'valueAsNumber' | 'valueAsDate' | 'setValueAs' | 'disabled'> & {
+        [propName: string]: any;
+    };
+    /**
+     * 要不要包裹 label 之类的
+     */
+    wrap?: boolean;
+    /**
+     * 是否多行模式
+     */
+    multiLine?: boolean;
+    itemsWrapperClassName?: string;
+    itemClassName?: string;
+    scaffold?: Record<string, any>;
+    addButtonClassName?: string;
+    addButtonText?: string;
+    addButtonLevel?: string;
+    addButtonSize?: string;
+    addable?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    removable?: boolean;
+}
+export declare function Combo({ control, name, wrap, mode, label, labelAlign, labelClassName, description, fieldClassName, className, style, multiLine, itemsWrapperClassName, itemClassName, addButtonClassName, addButtonLevel, addButtonSize, itemRender, translate: __, classnames: cx, addable, scaffold, addButtonText, removable, rules, isRequired, minLength, maxLength }: ComboProps): React.JSX.Element;
+export interface ComboItemProps {
+    value: any;
+    control: Control<any>;
+    itemRender: (methods: UseFormReturn, index: number) => JSX.Element | null;
+    update: (index: number, data: Record<string, any>) => void;
+    index: number;
+    translate: TranslateFn;
+    classnames: ClassNamesFn;
+    formRef: (form: UseFormReturn | null, index: number) => void;
+}
+export declare function ComboItem({ value, itemRender, index, translate, update, classnames: cx, formRef }: ComboItemProps): React.JSX.Element;
+declare const _default: {
+    new (props: Omit<Omit<ComboProps<any>, keyof LocaleProps> & {
+        locale?: string | undefined;
+        translate?: ((str: string, ...args: any[]) => string) | undefined;
+    }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps): {
+        ref: any;
+        childRef(ref: any): void;
+        getWrappedInstance(): any;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<string>;
+    ComposedComponent: React.ComponentType<{
+        new (props: Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }): {
+            ref: any;
+            childRef(ref: any): void;
+            getWrappedInstance(): any;
+            render(): React.JSX.Element;
+            context: unknown;
+            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>) => {} | Pick<{}, K_1> | null) | Pick<{}, K_1> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>;
+            state: Readonly<{}>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            componentDidMount?(): void;
+            shouldComponentUpdate?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextState: Readonly<{}>, nextContext: any): boolean;
+            componentWillUnmount?(): void;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, prevState: Readonly<{}>): any;
+            componentDidUpdate?(prevProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, prevState: Readonly<{}>, snapshot?: any): void;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        displayName: string;
+        contextType: React.Context<string>;
+        ComposedComponent: React.ComponentType<typeof Combo>;
+    } & import("hoist-non-react-statics").NonReactStatics<typeof Combo, {}> & {
+        ComposedComponent: typeof Combo;
+    }>;
+} & import("hoist-non-react-statics").NonReactStatics<{
+    new (props: Omit<ComboProps<any>, keyof LocaleProps> & {
+        locale?: string | undefined;
+        translate?: ((str: string, ...args: any[]) => string) | undefined;
+    }): {
+        ref: any;
+        childRef(ref: any): void;
+        getWrappedInstance(): any;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>) => {} | Pick<{}, K_1> | null) | Pick<{}, K_1> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<string>;
+    ComposedComponent: React.ComponentType<typeof Combo>;
+} & import("hoist-non-react-statics").NonReactStatics<typeof Combo, {}> & {
+    ComposedComponent: typeof Combo;
+}, {}> & {
+    ComposedComponent: {
+        new (props: Omit<ComboProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }): {
+            ref: any;
+            childRef(ref: any): void;
+            getWrappedInstance(): any;
+            render(): React.JSX.Element;
+            context: unknown;
+            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>) => {} | Pick<{}, K_1> | null) | Pick<{}, K_1> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>;
+            state: Readonly<{}>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            componentDidMount?(): void;
+            shouldComponentUpdate?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextState: Readonly<{}>, nextContext: any): boolean;
+            componentWillUnmount?(): void;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, prevState: Readonly<{}>): any;
+            componentDidUpdate?(prevProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, prevState: Readonly<{}>, snapshot?: any): void;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<ComboProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        displayName: string;
+        contextType: React.Context<string>;
+        ComposedComponent: React.ComponentType<typeof Combo>;
+    } & import("hoist-non-react-statics").NonReactStatics<typeof Combo, {}> & {
+        ComposedComponent: typeof Combo;
+    };
+};
+export default _default;