amis-ui 6.13.0-beta.8 → 6.13.0

package/esm/components/formula/Picker.js

@@ -0,0 +1,454 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { __extends, __awaiter, __generator, __assign, __rest, __read, __decorate, __metadata } from 'tslib';
+import { anyChanged, isExpression, parse, autobind, themeable, localeable, uncontrollable, resolveVariableAndFilterForAsync } from 'amis-core';
+import React__default from 'react';
+import Editor, { FormulaEditor } from './Editor.js';
+import Button from '../Button.js';
+import { Icon } from '../icons.js';
+import FinalModal from '../Modal.js';
+import PopUp from '../PopUp.js';
+import FormulaInput from './Input.js';
+
+var InputSchemaType = [
+    'text',
+    'number',
+    'boolean',
+    'date',
+    'time',
+    'datetime',
+    'select',
+    'custom'
+];
+var FormulaPicker = /** @class */ (function (_super) {
+    __extends(FormulaPicker, _super);
+    function FormulaPicker(props) {
+        var _this = _super.call(this, props) || this;
+        _this.unmounted = false;
+        _this.props.onRef && _this.props.onRef(_this);
+        _this.state = {
+            isOpened: false,
+            value: _this.props.value,
+            editorValue: _this.value2EditorValue(_this.props),
+            isError: false,
+            variables: Array.isArray(props.variables) ? props.variables : []
+        };
+        return _this;
+    }
+    FormulaPicker.prototype.componentDidMount = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, variables, data, list, result;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, variables = _a.variables, data = _a.data;
+                        if (!(typeof variables === 'function')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, variables(this.props)];
+                    case 1:
+                        list = _b.sent();
+                        this.setState({ variables: list });
+                        return [3 /*break*/, 4];
+                    case 2:
+                        if (!(typeof variables === 'string' && isExpression(variables))) return [3 /*break*/, 4];
+                        return [4 /*yield*/, resolveVariableAndFilterForAsync(variables, data, '|raw')];
+                    case 3:
+                        result = _b.sent();
+                        this.setState({ variables: result });
+                        _b.label = 4;
+                    case 4:
+                        this.buildFunctions();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FormulaPicker.prototype.componentDidUpdate = function (prevProps) {
+        return __awaiter(this, void 0, void 0, function () {
+            var value, _a, variables, data, list, result;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        value = this.props.value;
+                        if (value !== prevProps.value && !this.state.isOpened) {
+                            this.setState({
+                                value: typeof value === 'string' || !this.isTextInput() ? value : '',
+                                editorValue: this.value2EditorValue(this.props)
+                            });
+                        }
+                        if (!anyChanged(['variables', 'data'], this.props, prevProps)) return [3 /*break*/, 5];
+                        _a = this.props, variables = _a.variables, data = _a.data;
+                        if (!(Array.isArray(variables) && variables !== prevProps.variables)) return [3 /*break*/, 1];
+                        this.setState({ variables: variables });
+                        return [3 /*break*/, 5];
+                    case 1:
+                        if (!(typeof variables === 'function')) return [3 /*break*/, 3];
+                        return [4 /*yield*/, variables(this.props)];
+                    case 2:
+                        list = _b.sent();
+                        this.setState({ variables: list });
+                        return [3 /*break*/, 5];
+                    case 3:
+                        if (!(typeof variables === 'string' && isExpression(variables))) return [3 /*break*/, 5];
+                        return [4 /*yield*/, resolveVariableAndFilterForAsync(variables, data, '|raw')];
+                    case 4:
+                        result = _b.sent();
+                        this.setState({ variables: result });
+                        _b.label = 5;
+                    case 5:
+                        if (prevProps.functions !== this.props.functions) {
+                            this.buildFunctions();
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FormulaPicker.prototype.componentWillUnmount = function () {
+        this.unmounted = true;
+    };
+    FormulaPicker.prototype.buildFunctions = function (functions, setState) {
+        if (functions === void 0) { functions = this.props.functions; }
+        if (setState === void 0) { setState = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var functionList;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, FormulaEditor.buildFunctions(functions, this.props.functionsFilter)];
+                    case 1:
+                        functionList = _a.sent();
+                        if (this.unmounted) {
+                            return [2 /*return*/];
+                        }
+                        if (!setState) {
+                            return [2 /*return*/, functionList];
+                        }
+                        this.setState({
+                            functions: functionList
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FormulaPicker.prototype.value2EditorValue = function (props) {
+        var value = props.value, mixedMode = props.mixedMode; props.inputSettings;
+        if (mixedMode &&
+            typeof value === 'string' &&
+            /^\s*\$\{([\s\S]+)\}\s*$/.test(value)) {
+            return RegExp.$1;
+        }
+        else if (typeof value !== 'string') {
+            var editorValue = '';
+            try {
+                editorValue = JSON.stringify(value);
+            }
+            catch (error) { }
+            return editorValue;
+        }
+        else {
+            return value
+                ? mixedMode
+                    ? isExpression(value)
+                        ? "`".concat(value.replace(/`/g, '\\`'), "`")
+                        : JSON.stringify(value)
+                    : value
+                : '';
+        }
+    };
+    FormulaPicker.prototype.isTextInput = function () {
+        var inputSettings = this.props.inputSettings;
+        return (!inputSettings ||
+            (inputSettings === null || inputSettings === void 0 ? void 0 : inputSettings.type) === 'text' ||
+            !InputSchemaType.includes(inputSettings === null || inputSettings === void 0 ? void 0 : inputSettings.type));
+    };
+    FormulaPicker.prototype.handleConfirm = function () {
+        var _a, _b;
+        var value = this.state.value;
+        if (this.props.onConfirm) {
+            this.props.onConfirm(value);
+        }
+        else {
+            (_b = (_a = this.props).onChange) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+        }
+    };
+    FormulaPicker.prototype.handleInputChange = function (value) {
+        var _this = this;
+        this.setState({ value: value }, function () { return _this.handleConfirm(); });
+    };
+    FormulaPicker.prototype.handleInputGroupChange = function (e) {
+        var onChange = this.props.onChange;
+        onChange && onChange(e.currentTarget.value);
+    };
+    FormulaPicker.prototype.handleEditorChange = function (value) {
+        this.setState({
+            editorValue: value,
+            isError: false
+        });
+    };
+    FormulaPicker.prototype.handleEditorConfirm = function () {
+        var _a, _b;
+        var _c = this.props; _c.translate; var inputSettings = _c.inputSettings;
+        var editorValue = this.state.editorValue;
+        var ast;
+        try {
+            ast = parse(editorValue, {
+                // mixedMode 弹窗中的一定是表达式
+                evalMode: this.props.mixedMode ? true : this.props.evalMode,
+                allowFilter: false
+            });
+        }
+        catch (error) {
+            this.setState({ isError: (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : true });
+            return;
+        }
+        if ((inputSettings === null || inputSettings === void 0 ? void 0 : inputSettings.type) &&
+            ['boolean', 'number'].includes(inputSettings === null || inputSettings === void 0 ? void 0 : inputSettings.type)) {
+            var result = editorValue;
+            // const schemaType = inputSettings?.type;
+            if (ast.type === 'literal' || ast.type === 'string') {
+                result = (_b = ast.value) !== null && _b !== void 0 ? _b : '';
+            }
+            this.setState({ isError: false });
+            return this.confirm(result);
+        }
+        return this.confirm(editorValue, ast);
+    };
+    FormulaPicker.prototype.confirm = function (value, ast) {
+        var _this = this;
+        var mixedMode = this.props.mixedMode;
+        var stateOnConfirm = this.state.onConfirm;
+        var validate = this.validate(value);
+        if (validate === true) {
+            var result = value;
+            if (mixedMode && typeof value === 'string') {
+                result =
+                    (ast === null || ast === void 0 ? void 0 : ast.type) === 'string'
+                        ? ast.value
+                        : (ast === null || ast === void 0 ? void 0 : ast.type) === 'template' &&
+                            ast.body.length === 1 &&
+                            ast.body[0].type === 'template_raw'
+                            ? ast.body[0].value
+                            : "${".concat(value, "}");
+            }
+            this.setState({ value: result, onConfirm: undefined }, function () {
+                _this.close(undefined, function () {
+                    stateOnConfirm
+                        ? stateOnConfirm(_this.state.value)
+                        : _this.handleConfirm();
+                });
+            });
+        }
+        else {
+            this.setState({ isError: validate });
+        }
+    };
+    FormulaPicker.prototype.handleClick = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.openEditor(this.value2EditorValue(this.props))];
+            });
+        });
+    };
+    FormulaPicker.prototype.openEditor = function (editorValue, onConfirm) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var state, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _c = [{}];
+                        return [4 /*yield*/, ((_b = (_a = this.props).onPickerOpen) === null || _b === void 0 ? void 0 : _b.call(_a, this.props))];
+                    case 1:
+                        state = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { editorValue: editorValue, isOpened: true, onConfirm: onConfirm }]);
+                        if (!state.functions) return [3 /*break*/, 3];
+                        _d = state;
+                        return [4 /*yield*/, this.buildFunctions(state.functions, false)];
+                    case 2:
+                        _d.functions = _e.sent();
+                        _e.label = 3;
+                    case 3:
+                        this.setState(state);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FormulaPicker.prototype.close = function (e, callback) {
+        this.setState({
+            isOpened: false,
+            isError: false
+        }, function () {
+            if (callback) {
+                callback();
+                return;
+            }
+        });
+    };
+    FormulaPicker.prototype.updateState = function (state) {
+        if (state === void 0) { state = {}; }
+        state.isOpened; var rest = __rest(state, ["isOpened"]);
+        this.setState(__assign(__assign({}, this.state), rest));
+    };
+    FormulaPicker.prototype.validate = function (value) {
+        var _a = this.props, __ = _a.translate, inputSettings = _a.inputSettings;
+        /** 处理非文本输入场景 */
+        if (inputSettings && !this.isTextInput()) {
+            var schemaType = inputSettings === null || inputSettings === void 0 ? void 0 : inputSettings.type;
+            var errorMsg = __('FormulaEditor.invalidValue');
+            /** 变量类型 */
+            if (typeof value === 'string') {
+                return true;
+            }
+            if (['number', 'boolean'].includes(schemaType)) {
+                return typeof value === schemaType ? true : errorMsg;
+            }
+            else if (['text', 'date', 'time', 'datetime'].includes(schemaType)) {
+                return typeof value === 'string' ? true : errorMsg;
+            }
+            else if (schemaType === 'select' && inputSettings.multiple) {
+                return Array.isArray(value) ? true : errorMsg;
+            }
+            else {
+                return true;
+            }
+        }
+        try {
+            value &&
+                parse(value, {
+                    // mixedMode 值是模版， 要 ${} 包裹表达式
+                    evalMode: this.props.mixedMode ? false : this.props.evalMode,
+                    allowFilter: false
+                });
+            return true;
+        }
+        catch (e) {
+            if (/\s(\d+:\d+)$/.test(e.message)) {
+                var _b = __read(/\s(\d+:\d+)$/.exec(e.message) || [], 2), position = _b[1];
+                return position;
+            }
+            return e.message;
+        }
+    };
+    FormulaPicker.prototype.render = function () {
+        var _a, _b, _c;
+        var _d, _e, _f, _g, _h, _j, _k, _l;
+        var _m = this.props, cx = _m.classnames, __ = _m.translate, disabled = _m.disabled, className = _m.className, style = _m.style; _m.onChange; _m.size; var borderMode = _m.borderMode, placeholder = _m.placeholder, _o = _m.mode, mode = _o === void 0 ? 'input-button' : _o, btnLabel = _m.btnLabel, level = _m.level, btnSize = _m.btnSize, icon = _m.icon, title = _m.title, clearable = _m.clearable, functions = _m.functions, children = _m.children, variableMode = _m.variableMode, mixedMode = _m.mixedMode, evalMode = _m.evalMode, popOverContainer = _m.popOverContainer, mobileUI = _m.mobileUI, inputSettings = _m.inputSettings, customInputRender = _m.customInputRender, rest = __rest(_m, ["classnames", "translate", "disabled", "className", "style", "onChange", "size", "borderMode", "placeholder", "mode", "btnLabel", "level", "btnSize", "icon", "title", "clearable", "functions", "children", "variableMode", "mixedMode", "evalMode", "popOverContainer", "mobileUI", "inputSettings", "customInputRender"]);
+        var _p = this.state, isOpened = _p.isOpened, value = _p.value, editorValue = _p.editorValue, isError = _p.isError;
+        var iconElement = React__default.createElement(Icon, { cx: cx, icon: icon, className: "Icon" });
+        return (React__default.createElement(React__default.Fragment, null,
+            children ? (children({
+                isOpened: this.state.isOpened,
+                onClick: this.handleClick,
+                setState: this.updateState,
+                value: value,
+                onChange: this.handleInputChange,
+                disabled: disabled
+            })) : (React__default.createElement("div", { className: cx('FormulaPicker', mode === 'input-group' ? 'is-input-group' : '', {
+                    'FormulaPicker--text': this.isTextInput()
+                }, className), style: style },
+                mode === 'button' && (React__default.createElement(Button, { className: cx('FormulaPicker-action', 'w-full'), level: level, size: btnSize, active: !!value, onClick: this.handleClick },
+                    iconElement ? (React__default.cloneElement(iconElement, {
+                        className: cx((_e = (_d = iconElement === null || iconElement === void 0 ? void 0 : iconElement.props) === null || _d === void 0 ? void 0 : _d.className) !== null && _e !== void 0 ? _e : '', 'FormulaPicker-icon', (_a = {},
+                            _a['is-filled'] = !!value,
+                            _a))
+                    })) : (React__default.createElement(Icon, { icon: "function", className: cx('FormulaPicker-icon', 'icon', (_b = {},
+                            _b['is-filled'] = !!value,
+                            _b)) })),
+                    React__default.createElement("span", { className: cx('FormulaPicker-label') }, __(btnLabel || 'FormulaEditor.btnLabel')))),
+                mode === 'input-button' && (React__default.createElement(React__default.Fragment, null,
+                    React__default.createElement(FormulaInput, { className: cx('FormulaPicker-input', isOpened ? 'is-active' : '', !!isError ? 'is-error' : ''), inputSettings: inputSettings, customInputRender: customInputRender, clearable: clearable, evalMode: mixedMode ? false : evalMode, variables: this.state.variables, functions: (_f = this.state.functions) !== null && _f !== void 0 ? _f : functions, value: value, onChange: this.handleInputChange, disabled: disabled, borderMode: borderMode, placeholder: placeholder }),
+                    React__default.createElement(Button, { className: cx('FormulaPicker-action'), onClick: this.handleClick },
+                        React__default.createElement(Icon, { icon: "function", className: cx('FormulaPicker-icon', 'icon', (_c = {},
+                                _c['is-filled'] = !!value,
+                                _c)) })))),
+                mode === 'input-group' && (React__default.createElement(React__default.Fragment, null,
+                    React__default.createElement(FormulaInput, { className: cx('FormulaPicker-input', isOpened ? 'is-active' : '', !!isError ? 'is-error' : ''), inputSettings: inputSettings, customInputRender: customInputRender, clearable: clearable, evalMode: mixedMode ? false : evalMode, variables: this.state.variables, functions: (_g = this.state.functions) !== null && _g !== void 0 ? _g : functions, value: value, onChange: this.handleInputChange, disabled: disabled, borderMode: borderMode, placeholder: placeholder }),
+                    React__default.createElement("a", { className: cx("FormulaPicker-toggler"), onClick: this.handleClick },
+                        React__default.createElement(Icon, { icon: "function", className: "icon" })))))),
+            mobileUI ? (React__default.createElement(PopUp, { className: cx("FormulaPicker-popup"), isShow: this.state.isOpened, showConfirm: true, onHide: this.close, onConfirm: this.handleEditorConfirm, container: popOverContainer },
+                React__default.createElement("div", { className: cx('FormulaPicker-popup-inner') },
+                    React__default.createElement(Editor, __assign({}, rest, { evalMode: mixedMode ? true : evalMode, variables: this.state.variables, functions: (_h = this.state.functions) !== null && _h !== void 0 ? _h : functions, variableMode: (_j = this.state.variableMode) !== null && _j !== void 0 ? _j : variableMode, value: editorValue, onChange: this.handleEditorChange, selfVariableName: this.props.selfVariableName })),
+                    !!isError ? (React__default.createElement("div", { className: cx('Dialog-info'), key: "info" },
+                        React__default.createElement("span", { className: cx('Dialog-error') }, __('FormulaEditor.invalidData', { err: isError })))) : null))) : (React__default.createElement(FinalModal, { size: "lg", closeOnEsc: true, show: this.state.isOpened, onHide: this.close, container: popOverContainer },
+                React__default.createElement(FinalModal.Header, { onClose: this.close, className: "font-bold" }, __(title || 'FormulaEditor.title')),
+                React__default.createElement(FinalModal.Body, null,
+                    React__default.createElement(Editor, __assign({}, rest, { evalMode: mixedMode ? true : evalMode, variables: this.state.variables, functions: (_k = this.state.functions) !== null && _k !== void 0 ? _k : functions, variableMode: (_l = this.state.variableMode) !== null && _l !== void 0 ? _l : variableMode, value: editorValue, onChange: this.handleEditorChange, selfVariableName: this.props.selfVariableName }))),
+                React__default.createElement(FinalModal.Footer, null,
+                    !!isError ? (React__default.createElement("div", { className: cx('Dialog-info'), key: "info" },
+                        React__default.createElement("span", { className: cx('Dialog-error') }, __('FormulaEditor.invalidData', { err: isError })))) : null,
+                    React__default.createElement(Button, { onClick: this.close }, __('cancel')),
+                    React__default.createElement(Button, { onClick: this.handleEditorConfirm, level: "primary" }, __('confirm')))))));
+    };
+    FormulaPicker.defaultProps = {
+        evalMode: true
+    };
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], FormulaPicker.prototype, "handleConfirm", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [String]),
+        __metadata("design:returntype", void 0)
+    ], FormulaPicker.prototype, "handleInputChange", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], FormulaPicker.prototype, "handleInputGroupChange", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [String]),
+        __metadata("design:returntype", void 0)
+    ], FormulaPicker.prototype, "handleEditorChange", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], FormulaPicker.prototype, "handleEditorConfirm", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", Promise)
+    ], FormulaPicker.prototype, "handleClick", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [String, Function]),
+        __metadata("design:returntype", Promise)
+    ], FormulaPicker.prototype, "openEditor", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Function]),
+        __metadata("design:returntype", void 0)
+    ], FormulaPicker.prototype, "close", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], FormulaPicker.prototype, "updateState", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [String]),
+        __metadata("design:returntype", void 0)
+    ], FormulaPicker.prototype, "validate", null);
+    return FormulaPicker;
+}(React__default.Component));
+var FormulaPicker$1 = themeable(localeable(uncontrollable(FormulaPicker, {
+    value: 'onChange'
+})));
+
+export { FormulaPicker, InputSchemaType, FormulaPicker$1 as default };

package/esm/components/formula/VariableList.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="hoist-non-react-statics" />
+import React from 'react';
+import { ThemeProps } from 'amis-core';
+import type { VariableItem } from './CodeEditor';
+import type { ItemRenderStates } from '../Selection';
+import type { Option } from '../Select';
+import type { TabsMode } from '../Tabs';
+import { SpinnerExtraProps } from '../Spinner';
+export interface VariableListProps extends ThemeProps, SpinnerExtraProps {
+    className?: string;
+    itemClassName?: string;
+    value?: any;
+    data: Array<VariableItem>;
+    selectMode?: 'list' | 'tree' | 'tabs';
+    tabsMode?: TabsMode;
+    itemRender?: (option: Option, states: ItemRenderStates) => JSX.Element;
+    placeholderRender?: (props: any) => JSX.Element | null;
+    onSelect?: (item: VariableItem) => void;
+    selfVariableName?: string;
+    expandTree?: boolean;
+    simplifyMemberOprs?: boolean;
+    popOverContainer?: () => HTMLElement;
+}
+declare function VariableList(props: VariableListProps): React.JSX.Element;
+declare const _default: {
+    new (props: Omit<VariableListProps, 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<VariableListProps, 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<VariableListProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<VariableListProps, 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<VariableListProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<VariableListProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<VariableListProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<VariableListProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<VariableListProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<VariableListProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<string>;
+    ComposedComponent: React.ComponentType<typeof VariableList>;
+} & import("hoist-non-react-statics").NonReactStatics<typeof VariableList, {}> & {
+    ComposedComponent: typeof VariableList;
+};
+export default _default;