amis 2.0.0-rc.9 → 2.0.2

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

@@ -0,0 +1,145 @@
+import React from 'react';
+import { OptionsControlProps, Option } from 'amis-core';
+import { Api, ActionObject } from 'amis-core';
+import { FormOptionsSchema, SchemaApi } from '../../Schema';
+import { TransferControlSchema } from './Transfer';
+import type { SchemaClassName } from '../../Schema';
+import type { TooltipObject } from 'amis-ui/lib/components/TooltipWrapper';
+/**
+ * Select 下拉选择框。
+ * 文档：https://baidu.gitee.io/amis/docs/components/form/select
+ */
+export interface SelectControlSchema extends FormOptionsSchema {
+    type: 'select' | 'multi-select';
+    /**
+     * 自动完成 API，当输入部分文字的时候，会将这些文字通过 ${term} 可以取到，发送给接口。
+     * 接口可以返回匹配到的选项，帮助用户输入。
+     */
+    autoComplete?: SchemaApi;
+    /**
+     * 可以自定义菜单展示。
+     */
+    menuTpl?: string;
+    /**
+     * 当在value值未匹配到当前options中的选项时，是否value值对应文本飘红显示
+     */
+    showInvalidMatch: boolean;
+    /**
+     * 边框模式，全边框，还是半边框，或者没边框。
+     */
+    borderMode?: 'full' | 'half' | 'none';
+    /**
+     * 勾选展示模式
+     */
+    selectMode?: 'table' | 'group' | 'tree' | 'chained' | 'associated';
+    /**
+     * 当 selectMode 为 associated 时用来定义左侧的选项
+     */
+    leftOptions?: Array<Option>;
+    /**
+     * 当 selectMode 为 associated 时用来定义左侧的选择模式
+     */
+    leftMode?: 'tree' | 'list';
+    /**
+     * 当 selectMode 为 associated 时用来定义右侧的选择模式
+     */
+    rightMode?: 'table' | 'list' | 'tree' | 'chained';
+    /**
+     * 搜索结果展示模式
+     */
+    searchResultMode?: 'table' | 'list' | 'tree' | 'chained';
+    /**
+     * 当 selectMode 为 table 时定义表格列信息。
+     */
+    columns?: Array<any>;
+    /**
+     * 当 searchResultMode 为 table 时定义表格列信息。
+     */
+    searchResultColumns?: Array<any>;
+    /**
+     * 可搜索？
+     */
+    searchable?: boolean;
+    /**
+     * 搜索 API
+     */
+    searchApi?: SchemaApi;
+    /**
+     * 单个选项的高度，主要用于虚拟渲染
+     */
+    itemHeight?: number;
+    /**
+     * 在选项数量达到多少时开启虚拟渲染
+     */
+    virtualThreshold?: number;
+    /**
+     * 可多选条件下，是否可全选
+     */
+    checkAll?: boolean;
+    /**
+     * 可多选条件下，是否默认全选中所有值
+     */
+    defaultCheckAll?: boolean;
+    /**
+     * 可多选条件下，全选项文案，默认 ”全选“
+     */
+    checkAllLabel?: string;
+    /**
+     * 标签的最大展示数量，超出数量后以收纳浮层的方式展示，仅在多选模式开启后生效
+     */
+    maxTagCount?: number;
+    /**
+     * 收纳标签的Popover配置
+     */
+    overflowTagPopover?: object;
+    /**
+     * 选项的自定义CSS类名
+     */
+    optionClassName?: SchemaClassName;
+}
+export interface SelectProps extends OptionsControlProps {
+    autoComplete?: Api;
+    searchable?: boolean;
+    showInvalidMatch?: boolean;
+    defaultOpen?: boolean;
+    useMobileUI?: boolean;
+    maxTagCount?: number;
+    overflowTagPopover?: TooltipObject;
+}
+export declare type SelectRendererEvent = 'change' | 'blur' | 'focus' | 'add' | 'edit' | 'delete';
+export default class SelectControl extends React.Component<SelectProps, any> {
+    static defaultProps: Partial<SelectProps>;
+    input: any;
+    unHook: Function;
+    lazyloadRemote: Function;
+    lastTerm: string;
+    constructor(props: SelectProps);
+    componentDidUpdate(prevProps: SelectProps): void;
+    componentWillUnmount(): void;
+    inputRef(ref: any): void;
+    foucs(): void;
+    getValue(value: Option | Array<Option> | string | void): string | void | Option | Option[];
+    dispatchEvent(eventName: SelectRendererEvent, eventData?: any): Promise<void>;
+    changeValue(value: Option | Array<Option> | string | void): Promise<void>;
+    loadRemote(input: string): Promise<(() => void) | {
+        options: Option[];
+    }>;
+    mergeOptions(options: Array<object>): Option[];
+    renderMenu(option: Option, state: any): JSX.Element;
+    reload(): void;
+    option2value(): void;
+    renderOtherMode(): JSX.Element;
+    doAction(action: ActionObject, data: object, throwErrors: boolean): any;
+    render(): JSX.Element;
+}
+export interface TransferDropDownProps extends OptionsControlProps, Omit<TransferControlSchema, 'type' | 'options' | 'inputClassName' | 'className' | 'descriptionClassName'> {
+    borderMode?: 'full' | 'half' | 'none';
+    useMobileUI?: boolean;
+}
+export declare class SelectControlRenderer extends SelectControl {
+}
+export declare class MultiSelectControlRenderer extends SelectControl {
+    static defaultProps: {
+        multiple: boolean;
+    };
+}

package/esm/renderers/Form/Select.js

@@ -0,0 +1,310 @@
+/**
+ * amis v2.0.2
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __awaiter, __generator, __assign, __rest, __decorate, __metadata } from 'tslib';
+import React from 'react';
+import cx from 'classnames';
+import { isEffectiveApi, isApiOutdated, createObject, normalizeOptions, isMobile, autobind, OptionsControl } from 'amis-core';
+import find from 'lodash/find';
+import debouce from 'lodash/debounce';
+import { Select, TransferDropDown, Spinner } from 'amis-ui';
+import { BaseTransferRenderer } from './Transfer.js';
+
+var SelectControl = /** @class */ (function (_super) {
+    __extends(SelectControl, _super);
+    function SelectControl(props) {
+        var _this = _super.call(this, props) || this;
+        _this.lastTerm = ''; // 用来记录上一次搜索时关键字
+        _this.changeValue = _this.changeValue.bind(_this);
+        _this.lazyloadRemote = debouce(_this.loadRemote.bind(_this), 250, {
+            trailing: true,
+            leading: false
+        });
+        _this.inputRef = _this.inputRef.bind(_this);
+        return _this;
+    }
+    SelectControl.prototype.componentDidUpdate = function (prevProps) {
+        var props = this.props;
+        if (isEffectiveApi(props.autoComplete, props.data) &&
+            isApiOutdated(prevProps.autoComplete, props.autoComplete, prevProps.data, props.data)) {
+            this.lazyloadRemote(this.lastTerm);
+        }
+    };
+    SelectControl.prototype.componentWillUnmount = function () {
+        this.unHook && this.unHook();
+    };
+    SelectControl.prototype.inputRef = function (ref) {
+        this.input = ref;
+    };
+    SelectControl.prototype.foucs = function () {
+        this.input && this.input.focus();
+    };
+    SelectControl.prototype.getValue = function (value) {
+        var _a = this.props, joinValues = _a.joinValues, extractValue = _a.extractValue, delimiter = _a.delimiter, multiple = _a.multiple, valueField = _a.valueField, options = _a.options;
+        var newValue = value;
+        (Array.isArray(value) ? value : value ? [value] : []).forEach(function (option) {
+            find(options, function (item) {
+                return item[valueField || 'value'] == option[valueField || 'value'];
+            });
+        });
+        if (joinValues) {
+            if (multiple) {
+                newValue = Array.isArray(value)
+                    ? value
+                        .map(function (item) { return item[valueField || 'value']; })
+                        .join(delimiter)
+                    : value
+                        ? value[valueField || 'value']
+                        : '';
+            }
+            else {
+                newValue = newValue ? newValue[valueField || 'value'] : '';
+            }
+        }
+        else if (extractValue) {
+            if (multiple) {
+                newValue = Array.isArray(value)
+                    ? value.map(function (item) { return item[valueField || 'value']; })
+                    : value
+                        ? [value[valueField || 'value']]
+                        : [];
+            }
+            else {
+                newValue = newValue ? newValue[valueField || 'value'] : '';
+            }
+        }
+        return newValue;
+    };
+    SelectControl.prototype.dispatchEvent = function (eventName, eventData) {
+        if (eventData === void 0) { eventData = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var event, _a, dispatchEvent, options, data, rendererEvent;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        event = 'on' + eventName.charAt(0).toUpperCase() + eventName.slice(1);
+                        _a = this.props, dispatchEvent = _a.dispatchEvent, options = _a.options, data = _a.data;
+                        return [4 /*yield*/, dispatchEvent(eventName, createObject(data, {
+                                options: options,
+                                value: ['onEdit', 'onDelete'].includes(event)
+                                    ? eventData
+                                    : eventData && eventData.value
+                            }))];
+                    case 1:
+                        rendererEvent = _b.sent();
+                        if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                            return [2 /*return*/];
+                        }
+                        // 触发外部方法
+                        this.props[event](eventData);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SelectControl.prototype.changeValue = function (value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, onChange, setOptions, options, data, dispatchEvent, newValue, additonalOptions, rendererEvent;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, onChange = _a.onChange, setOptions = _a.setOptions, options = _a.options, data = _a.data, dispatchEvent = _a.dispatchEvent;
+                        newValue = this.getValue(value);
+                        additonalOptions = [];
+                        // 不设置没法回显
+                        additonalOptions.length && setOptions(options.concat(additonalOptions));
+                        return [4 /*yield*/, dispatchEvent('change', createObject(data, {
+                                value: newValue,
+                                options: options
+                            }))];
+                    case 1:
+                        rendererEvent = _b.sent();
+                        if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                            return [2 /*return*/];
+                        }
+                        onChange === null || onChange === void 0 ? void 0 : onChange(newValue);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SelectControl.prototype.loadRemote = function (input) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, autoComplete, env, data, setOptions, setLoading, formInited, addHook, ctx, ret, options, combinedOptions;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, autoComplete = _a.autoComplete, env = _a.env, data = _a.data, setOptions = _a.setOptions, setLoading = _a.setLoading, formInited = _a.formInited, addHook = _a.addHook;
+                        if (!env || !env.fetcher) {
+                            throw new Error('fetcher is required');
+                        }
+                        if (!formInited) {
+                            this.unHook && this.unHook();
+                            return [2 /*return*/, (this.unHook = addHook(this.loadRemote.bind(this, input), 'init'))];
+                        }
+                        this.lastTerm = input;
+                        ctx = createObject(data, {
+                            term: input,
+                            value: input
+                        });
+                        if (!isEffectiveApi(autoComplete, ctx)) {
+                            return [2 /*return*/, Promise.resolve({
+                                    options: []
+                                })];
+                        }
+                        setLoading(true);
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, env.fetcher(autoComplete, ctx)];
+                    case 2:
+                        ret = _b.sent();
+                        options = (ret.data && ret.data.options) || ret.data || [];
+                        combinedOptions = this.mergeOptions(options);
+                        setOptions(combinedOptions);
+                        return [2 /*return*/, {
+                                options: combinedOptions
+                            }];
+                    case 3:
+                        setLoading(false);
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SelectControl.prototype.mergeOptions = function (options) {
+        var _a = this.props, selectedOptions = _a.selectedOptions, _b = _a.valueField, valueField = _b === void 0 ? 'value' : _b;
+        var combinedOptions = normalizeOptions(options, undefined, valueField).concat();
+        if (Array.isArray(selectedOptions) && selectedOptions.length) {
+            selectedOptions.forEach(function (option) {
+                if (!find(combinedOptions, function (item) { return item.value == option.value; })) {
+                    combinedOptions.push(__assign(__assign({}, option), { hidden: true }));
+                }
+            });
+        }
+        return combinedOptions;
+    };
+    SelectControl.prototype.renderMenu = function (option, state) {
+        var _a = this.props, menuTpl = _a.menuTpl, render = _a.render, data = _a.data, optionClassName = _a.optionClassName;
+        return render("menu/".concat(state.index), menuTpl, {
+            showNativeTitle: true,
+            className: cx('Select-option-content', optionClassName),
+            data: createObject(createObject(data, state), option)
+        });
+    };
+    SelectControl.prototype.reload = function () {
+        var reload = this.props.reloadOptions;
+        reload && reload();
+    };
+    SelectControl.prototype.option2value = function () { };
+    SelectControl.prototype.renderOtherMode = function () {
+        var _a = this.props, selectMode = _a.selectMode, rest = __rest(_a, ["selectMode"]);
+        return (React.createElement(TransferDropdownRenderer, __assign({}, rest, { selectMode: selectMode === 'group' ? 'list' : selectMode })));
+    };
+    SelectControl.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') {
+            var value = this.getValue(resetValue !== null && resetValue !== void 0 ? resetValue : '');
+            onChange === null || onChange === void 0 ? void 0 : onChange(value);
+        }
+    };
+    SelectControl.prototype.render = function () {
+        var _this = this;
+        var _a = this.props, autoComplete = _a.autoComplete, searchable = _a.searchable, showInvalidMatch = _a.showInvalidMatch, options = _a.options, className = _a.className, loading = _a.loading; _a.value; var selectedOptions = _a.selectedOptions, multi = _a.multi, multiple = _a.multiple, placeholder = _a.placeholder; _a.id; var classPrefix = _a.classPrefix; _a.classnames; var creatable = _a.creatable; _a.inline; var noResultsText = _a.noResultsText, render = _a.render, menuTpl = _a.menuTpl, borderMode = _a.borderMode, selectMode = _a.selectMode, env = _a.env, useMobileUI = _a.useMobileUI, rest = __rest(_a, ["autoComplete", "searchable", "showInvalidMatch", "options", "className", "loading", "value", "selectedOptions", "multi", "multiple", "placeholder", "id", "classPrefix", "classnames", "creatable", "inline", "noResultsText", "render", "menuTpl", "borderMode", "selectMode", "env", "useMobileUI"]);
+        if (noResultsText) {
+            noResultsText = render('noResultText', noResultsText);
+        }
+        var mobileUI = useMobileUI && isMobile();
+        return (React.createElement("div", { className: cx("".concat(classPrefix, "SelectControl"), className) }, ['table', 'list', 'group', 'tree', 'chained', 'associated'].includes(selectMode) ? (this.renderOtherMode()) : (React.createElement(Select, __assign({}, rest, { useMobileUI: useMobileUI, popOverContainer: mobileUI && env && env.getModalContainer
+                ? env.getModalContainer
+                : mobileUI
+                    ? undefined
+                    : rest.popOverContainer, borderMode: borderMode, placeholder: placeholder, multiple: multiple || multi, ref: this.inputRef, value: selectedOptions, options: options, loadOptions: isEffectiveApi(autoComplete) ? this.lazyloadRemote : undefined, showInvalidMatch: showInvalidMatch, creatable: creatable, searchable: searchable || !!autoComplete, onChange: this.changeValue, onBlur: function (e) { return _this.dispatchEvent('blur', e); }, onFocus: function (e) { return _this.dispatchEvent('focus', e); }, onAdd: function () { return _this.dispatchEvent('add'); }, onEdit: function (item) { return _this.dispatchEvent('edit', item); }, onDelete: function (item) { return _this.dispatchEvent('delete', item); }, loading: loading, noResultsText: noResultsText, renderMenu: menuTpl ? this.renderMenu : undefined })))));
+    };
+    SelectControl.defaultProps = {
+        clearable: false,
+        searchable: false,
+        multiple: false,
+        showInvalidMatch: false
+    };
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Object]),
+        __metadata("design:returntype", void 0)
+    ], SelectControl.prototype, "renderMenu", null);
+    return SelectControl;
+}(React.Component));
+var TransferDropdownRenderer = /** @class */ (function (_super) {
+    __extends(TransferDropdownRenderer, _super);
+    function TransferDropdownRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TransferDropdownRenderer.prototype.renderItem = function (item) {
+        var labelField = this.props.labelField;
+        return "".concat(item.scopeLabel || '').concat(item[labelField || 'label']);
+    };
+    TransferDropdownRenderer.prototype.render = function () {
+        var _a;
+        var _b = this.props, className = _b.className; _b.classnames; var selectedOptions = _b.selectedOptions, sortable = _b.sortable, loading = _b.loading, searchable = _b.searchable, searchResultMode = _b.searchResultMode, showArrow = _b.showArrow, deferLoad = _b.deferLoad, disabled = _b.disabled, clearable = _b.clearable, selectTitle = _b.selectTitle, selectMode = _b.selectMode, multiple = _b.multiple, columns = _b.columns, leftMode = _b.leftMode, borderMode = _b.borderMode, useMobileUI = _b.useMobileUI, popOverContainer = _b.popOverContainer, maxTagCount = _b.maxTagCount, overflowTagPopover = _b.overflowTagPopover;
+        // 目前 LeftOptions 没有接口可以动态加载
+        // 为了方便可以快速实现动态化，让选项的第一个成员携带
+        // LeftOptions 信息
+        var _c = this.props, options = _c.options, leftOptions = _c.leftOptions, leftDefaultValue = _c.leftDefaultValue;
+        if (selectMode === 'associated' &&
+            options &&
+            options.length === 1 &&
+            options[0].leftOptions &&
+            Array.isArray(options[0].children)) {
+            leftOptions = options[0].leftOptions;
+            leftDefaultValue = (_a = options[0].leftDefaultValue) !== null && _a !== void 0 ? _a : leftDefaultValue;
+            options = options[0].children;
+        }
+        return (React.createElement(React.Fragment, null,
+            React.createElement(TransferDropDown, { selectMode: selectMode, className: className, value: selectedOptions, disabled: disabled, clearable: clearable, options: options, onChange: this.handleChange, option2value: this.option2value, itemRender: this.renderItem, sortable: sortable, searchResultMode: searchResultMode, onSearch: searchable ? this.handleSearch : undefined, showArrow: showArrow, onDeferLoad: deferLoad, selectTitle: selectTitle, multiple: multiple, columns: columns, leftMode: leftMode, leftOptions: leftOptions, borderMode: borderMode, useMobileUI: useMobileUI, popOverContainer: popOverContainer, maxTagCount: maxTagCount, overflowTagPopover: overflowTagPopover }),
+            React.createElement(Spinner, { overlay: true, key: "info", show: loading })));
+    };
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Object)
+    ], TransferDropdownRenderer.prototype, "renderItem", null);
+    return TransferDropdownRenderer;
+}(BaseTransferRenderer));
+/** @class */ ((function (_super) {
+    __extends(SelectControlRenderer, _super);
+    function SelectControlRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SelectControlRenderer = __decorate([
+        OptionsControl({
+            type: 'select'
+        })
+    ], SelectControlRenderer);
+    return SelectControlRenderer;
+})(SelectControl));
+/** @class */ ((function (_super) {
+    __extends(MultiSelectControlRenderer, _super);
+    function MultiSelectControlRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MultiSelectControlRenderer.defaultProps = {
+        multiple: true
+    };
+    MultiSelectControlRenderer = __decorate([
+        OptionsControl({
+            type: 'multi-select'
+        })
+    ], MultiSelectControlRenderer);
+    return MultiSelectControlRenderer;
+})(SelectControl));
+
+export { SelectControl as default };

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

@@ -0,0 +1,59 @@
+import React from 'react';
+import { FormControlProps } from 'amis-core';
+import { TableCell } from '../Table';
+import { SchemaPopOver } from '../PopOver';
+import { SchemaQuickEdit } from '../QuickEdit';
+import { SchemaCopyable } from '../Copyable';
+import { FormBaseControlSchema, SchemaTpl } from '../../Schema';
+/**
+ * Static
+ * 文档：https://baidu.gitee.io/amis/docs/components/form/static
+ */
+export interface StaticExactControlSchema extends FormBaseControlSchema {
+    type: 'static';
+    /**
+     * 内容模板， 支持 HTML
+     */
+    tpl?: SchemaTpl;
+    /**
+     * 内容模板，不支持 HTML
+     */
+    text?: SchemaTpl;
+    /**
+     * 配置查看详情功能
+     */
+    popOver?: SchemaPopOver;
+    /**
+     * 配置快速编辑功能
+     */
+    quickEdit?: SchemaQuickEdit;
+    /**
+     * 配置点击复制功能
+     */
+    copyable?: SchemaCopyable;
+    /**
+     * 边框模式，默认是无边框的
+     */
+    borderMode?: 'full' | 'half' | 'none';
+}
+export interface StaticProps extends FormControlProps {
+    placeholder?: string;
+    tpl?: string;
+    text?: string;
+}
+export default class StaticControl extends React.Component<StaticProps, any> {
+    static defaultProps: {
+        placeholder: string;
+    };
+    constructor(props: StaticProps);
+    handleQuickChange(values: any, saveImmediately: boolean | any): Promise<void>;
+    render(): JSX.Element;
+}
+export declare class StaticControlRenderer extends StaticControl {
+}
+export declare class StaticFieldRenderer extends TableCell {
+    static defaultProps: {
+        wrapperComponent: string;
+    };
+    render(): JSX.Element;
+}

package/esm/renderers/Form/Static.js

@@ -0,0 +1,109 @@
+/**
+ * amis v2.0.2
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __awaiter, __generator, __rest, __assign, __decorate } from 'tslib';
+import React from 'react';
+import { extendObject, ucFirst, FormItem } from 'amis-core';
+import '../Table/index.js';
+import { HocPopOver } from '../PopOver.js';
+import { HocQuickEdit } from '../QuickEdit.js';
+import { HocCopyable } from '../Copyable.js';
+import omit from 'lodash/omit';
+import { TableCell } from '../Table/TableCell.js';
+
+var StaticControl = /** @class */ (function (_super) {
+    __extends(StaticControl, _super);
+    function StaticControl(props) {
+        var _this = _super.call(this, props) || this;
+        _this.handleQuickChange = _this.handleQuickChange.bind(_this);
+        return _this;
+    }
+    StaticControl.prototype.handleQuickChange = function (values, saveImmediately) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, onBulkChange, onAction, data;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, onBulkChange = _a.onBulkChange, onAction = _a.onAction, data = _a.data;
+                        if (!(saveImmediately && saveImmediately.api)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, onAction(null, {
+                                actionType: 'ajax',
+                                api: saveImmediately.api
+                            }, extendObject(data, values), true)];
+                    case 1:
+                        _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        onBulkChange && onBulkChange(values, saveImmediately === true);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    StaticControl.prototype.render = function () {
+        var _a;
+        var _b = this.props, className = _b.className, value = _b.value, label = _b.label, type = _b.type, render = _b.render; _b.children; var data = _b.data, cx = _b.classnames, name = _b.name, disabled = _b.disabled, $schema = _b.$schema, defaultValue = _b.defaultValue, borderMode = _b.borderMode, rest = __rest(_b, ["className", "value", "label", "type", "render", "children", "data", "classnames", "name", "disabled", "$schema", "defaultValue", "borderMode"]);
+        var subType = /^static/.test(type)
+            ? type.substring(7) || (rest.tpl ? 'tpl' : 'plain')
+            : type;
+        var field = __assign(__assign({ label: label, name: name }, $schema), { type: subType });
+        return (React.createElement("div", { className: cx('Form-static', (_a = {},
+                _a["Form-static--border".concat(ucFirst(borderMode))] = borderMode,
+                _a)) },
+            React.createElement(StaticFieldRenderer, __assign({}, __assign(__assign({}, rest), { name: name, render: render, field: field, value: value === defaultValue ? undefined : value, className: className, onQuickChange: this.handleQuickChange, data: data, disabled: disabled, classnames: cx })))));
+    };
+    StaticControl.defaultProps = {
+        placeholder: '-'
+    };
+    return StaticControl;
+}(React.Component));
+/** @class */ ((function (_super) {
+    __extends(StaticControlRenderer, _super);
+    function StaticControlRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    StaticControlRenderer = __decorate([
+        FormItem({
+            test: /(^|\/)static(\-[^\/]+)?$/,
+            weight: -90,
+            strictMode: false,
+            sizeMutable: false,
+            name: 'static'
+        })
+    ], StaticControlRenderer);
+    return StaticControlRenderer;
+})(StaticControl));
+var StaticFieldRenderer = /** @class */ (function (_super) {
+    __extends(StaticFieldRenderer, _super);
+    function StaticFieldRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    StaticFieldRenderer.prototype.render = function () {
+        var _a = this.props; _a.type; var className = _a.className, render = _a.render, style = _a.style, Component = _a.wrapperComponent; _a.labelClassName; var value = _a.value, data = _a.data, children = _a.children, width = _a.width, inputClassName = _a.inputClassName; _a.label; var tabIndex = _a.tabIndex, onKeyUp = _a.onKeyUp, field = _a.field, rest = __rest(_a, ["type", "className", "render", "style", "wrapperComponent", "labelClassName", "value", "data", "children", "width", "inputClassName", "label", "tabIndex", "onKeyUp", "field"]);
+        var schema = __assign(__assign({}, field), { className: inputClassName, type: (field && field.type) || 'plain' });
+        var body = children
+            ? children
+            : render('field', schema, __assign(__assign({}, omit(rest, Object.keys(schema))), { value: value, data: data }));
+        if (width) {
+            style = style || {};
+            style.width = style.width || width;
+        }
+        if (!Component) {
+            return body;
+        }
+        return (React.createElement(Component, { style: style, className: className, tabIndex: tabIndex, onKeyUp: onKeyUp }, body));
+    };
+    StaticFieldRenderer.defaultProps = __assign(__assign({}, TableCell.defaultProps), { wrapperComponent: 'div' });
+    StaticFieldRenderer = __decorate([
+        HocQuickEdit(),
+        HocPopOver({
+            position: 'right'
+        }),
+        HocCopyable()
+    ], StaticFieldRenderer);
+    return StaticFieldRenderer;
+}(TableCell));
+
+export { StaticFieldRenderer, StaticControl as default };

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

@@ -0,0 +1,54 @@
+import React from 'react';
+import { FormControlProps } from 'amis-core';
+import { IconSchema } from '../Icon';
+import { FormBaseControlSchema } from '../../Schema';
+/**
+ * Switch
+ * 文档：https://baidu.gitee.io/amis/docs/components/form/switch
+ */
+export interface SwitchControlSchema extends FormBaseControlSchema {
+    /**
+     * 指定为多行文本输入框
+     */
+    type: 'switch';
+    /**
+     * 勾选值
+     */
+    trueValue?: boolean | string | number;
+    /**
+     * 未勾选值
+     */
+    falseValue?: boolean | string | number;
+    /**
+     * 选项说明
+     */
+    option?: string;
+    /**
+     * 开启时显示的内容
+     */
+    onText?: string | IconSchema;
+    /**
+     * 关闭时显示的内容
+     */
+    offText?: string | IconSchema;
+    /** 开关尺寸 */
+    size?: 'sm' | 'md';
+}
+export interface SwitchProps extends FormControlProps {
+    option?: string;
+    trueValue?: any;
+    falseValue?: any;
+    size?: 'sm';
+}
+export declare type SwitchRendererEvent = 'change';
+export default class SwitchControl extends React.Component<SwitchProps, any> {
+    static defaultProps: {
+        trueValue: boolean;
+        falseValue: boolean;
+        optionAtLeft: boolean;
+    };
+    handleChange(checked: string | number | boolean): Promise<void>;
+    render(): JSX.Element;
+}
+export declare class SwitchControlRenderer extends SwitchControl {
+}