@vxe-ui/plugin-render-element 4.2.3 → 4.3.0

package/lib/index.umd.js

@@ -0,0 +1,2962 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('vue'), require('xe-utils'), require('dayjs')) :
+	typeof define === 'function' && define.amd ? define(['vue', 'xe-utils', 'dayjs'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.VxeUIPluginRenderElement = factory(global.Vue, global.XEUtils, global.dayjs));
+})(this, (function (require$$0, require$$3, require$$3$1) { 'use strict';
+
+	function getDefaultExportFromCjs (x) {
+		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+	}
+
+	var lib = {};
+
+	var table = {};
+
+	var comp = {};
+
+	var store = {};
+
+	var hasRequiredStore;
+
+	function requireStore () {
+		if (hasRequiredStore) return store;
+		hasRequiredStore = 1;
+
+		Object.defineProperty(store, "__esModule", {
+		  value: true
+		});
+		store.globalConfig = store.componentMaps = void 0;
+		store.globalConfig = {};
+		store.componentMaps = {};
+		return store;
+	}
+
+	var hasRequiredComp;
+
+	function requireComp () {
+		if (hasRequiredComp) return comp;
+		hasRequiredComp = 1;
+
+		Object.defineProperty(comp, "__esModule", {
+		  value: true
+		});
+		comp.getCurrComponent = getCurrComponent;
+		comp.hasInputType = hasInputType;
+		var _vue = require$$0;
+		var _store = requireStore();
+		function getCurrComponent(name) {
+		  var comp = _store.componentMaps[name] || (_store.globalConfig.ElementPlus ? _store.globalConfig.ElementPlus[name] : null);
+		  if (comp) {
+		    return comp;
+		  }
+		  return (0, _vue.resolveComponent)(name);
+		}
+		function hasInputType(renderOpts) {
+		  switch (renderOpts.name) {
+		    case 'ElInput':
+		    case 'ElInputNumber':
+		    case 'ElTextarea':
+		      return true;
+		  }
+		  return false;
+		}
+		return comp;
+	}
+
+	var hasRequiredTable;
+
+	function requireTable () {
+		if (hasRequiredTable) return table;
+		hasRequiredTable = 1;
+
+		Object.defineProperty(table, "__esModule", {
+		  value: true
+		});
+		table.defineTableRender = defineTableRender;
+		var _vue = require$$0;
+		var _comp = requireComp();
+		var _xeUtils = _interopRequireDefault(require$$3);
+		var _dayjs = _interopRequireDefault(require$$3$1);
+		function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+		function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+		function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+		function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+		function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e; }
+		function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+		function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+		/**
+		 * 表格 - 渲染器
+		 */
+		function defineTableRender(VxeUI) {
+		  function isEmptyValue(cellValue) {
+		    return cellValue === null || cellValue === undefined || cellValue === '';
+		  }
+		  function getOnName(type) {
+		    return 'on' + type.substring(0, 1).toLocaleUpperCase() + type.substring(1);
+		  }
+		  function getModelProp(renderOpts) {
+		    return 'modelValue';
+		  }
+		  function getModelEvent(renderOpts) {
+		    return 'update:modelValue';
+		  }
+		  function getChangeEvent(renderOpts) {
+		    var type = 'change';
+		    switch (renderOpts.name) {
+		      case 'ElAutocomplete':
+		        type = 'select';
+		        break;
+		      case 'ElInput':
+		      case 'ElInputNumber':
+		        type = 'input';
+		        break;
+		    }
+		    return type;
+		  }
+		  function toDayStringDate(value, format) {
+		    return (0, _dayjs["default"])(value, format).toDate();
+		  }
+		  function toDayDateString(date, format) {
+		    return (0, _dayjs["default"])(date).format(format);
+		  }
+		  function parseDate(value, props) {
+		    return value && props.valueFormat ? toDayStringDate(value, props.valueFormat) : value;
+		  }
+		  function getFormatDate(value, props, defaultFormat) {
+		    return value ? toDayDateString(parseDate(value, props), props.format || props.valueFormat || defaultFormat) : value;
+		  }
+		  function getFormatDates(values, props, separator, defaultFormat) {
+		    return _xeUtils["default"].map(values, function (date) {
+		      return getFormatDate(date, props, defaultFormat);
+		    }).join(separator);
+		  }
+		  function equalDateRange(cellValue, data, props, defaultFormat) {
+		    cellValue = getFormatDate(cellValue, props, defaultFormat);
+		    return cellValue >= getFormatDate(data[0], props, defaultFormat) && cellValue <= getFormatDate(data[1], props, defaultFormat);
+		  }
+		  function getCellEditFilterProps(renderOpts, params, value, defaultProps) {
+		    return _xeUtils["default"].assign({}, defaultProps, renderOpts.props, _defineProperty({}, getModelProp(), value));
+		  }
+		  function formatText(cellValue) {
+		    return '' + (isEmptyValue(cellValue) ? '' : cellValue);
+		  }
+		  function updateFilterChangeOption(params, checked, option) {
+		    var $table = params.$table;
+		    $table.updateFilterOptionStatus(option, checked);
+		  }
+		  function saveFilterEvent(params) {
+		    var $table = params.$table,
+		      column = params.column;
+		    $table.saveFilterByEvent(new Event('change'), column);
+		  }
+		  function getCellLabelVNs(renderOpts, params, cellLabel) {
+		    var placeholder = renderOpts.placeholder;
+		    return [(0, _vue.h)('span', {
+		      "class": 'vxe-cell--label'
+		    }, placeholder && isEmptyValue(cellLabel) ? [(0, _vue.h)('span', {
+		      "class": 'vxe-cell--placeholder'
+		    }, formatText(VxeUI.getI18n(placeholder)))] : formatText(cellLabel))];
+		  }
+		  var blurEvent = 'blur';
+		  var clearEvent = 'clear';
+		  /**
+		  * 组件事件处理
+		  * @param renderOpts
+		  * @param params
+		  * @param modelFunc
+		  * @param changeFunc
+		  */
+		  function getComponentOns(renderOpts, params, eFns, eventOns) {
+		    var events = renderOpts.events;
+		    var modelEvent = getModelEvent();
+		    var changeEvent = getChangeEvent(renderOpts);
+		    var _ref = eFns || {},
+		      modelFunc = _ref.model,
+		      changeFunc = _ref.change,
+		      blurFunc = _ref.blur,
+		      clearFunc = _ref.clear;
+		    var ons = {};
+		    _xeUtils["default"].objectEach(events, function (func, key) {
+		      ons[getOnName(key)] = function () {
+		        if (!_xeUtils["default"].isFunction(func)) {
+		          console.error("Parameter \"".concat(func, "\" is not a method"));
+		        }
+		        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+		          args[_key] = arguments[_key];
+		        }
+		        func.apply(void 0, [params].concat(args));
+		      };
+		    });
+		    if (modelFunc) {
+		      ons[getOnName(modelEvent)] = function (targetEvnt) {
+		        modelFunc(targetEvnt);
+		        if (events && events[modelEvent]) {
+		          events[modelEvent](params, targetEvnt);
+		        }
+		      };
+		    }
+		    if (changeFunc) {
+		      ons[getOnName(changeEvent)] = function () {
+		        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+		          args[_key2] = arguments[_key2];
+		        }
+		        changeFunc.apply(void 0, args);
+		        if (events && events[changeEvent]) {
+		          events[changeEvent].apply(events, [params].concat(args));
+		        }
+		      };
+		    }
+		    if (blurFunc) {
+		      ons[getOnName(blurEvent)] = function () {
+		        for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+		          args[_key3] = arguments[_key3];
+		        }
+		        blurFunc.apply(void 0, args);
+		        if (events && events[blurEvent]) {
+		          events[blurEvent].apply(events, [params].concat(args));
+		        }
+		      };
+		    }
+		    if (clearFunc) {
+		      ons[getOnName(clearEvent)] = function () {
+		        for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+		          args[_key4] = arguments[_key4];
+		        }
+		        clearFunc.apply(void 0, args);
+		        if (events && events[clearEvent]) {
+		          events[clearEvent].apply(events, [params].concat(args));
+		        }
+		      };
+		    }
+		    return ons;
+		  }
+		  function getEditOns(renderOpts, params) {
+		    var $table = params.$table,
+		      row = params.row,
+		      column = params.column;
+		    return getComponentOns(renderOpts, params, {
+		      model: function model(value) {
+		        // 处理 model 值双向绑定
+		        _xeUtils["default"].set(row, column.field, value);
+		      },
+		      change: function change() {
+		        // 处理 change 事件相关逻辑
+		        $table.updateStatus(params);
+		      }
+		    });
+		  }
+		  function getFilterOns(renderOpts, params, option, changeFunc) {
+		    return getComponentOns(renderOpts, params, {
+		      model: function model(value) {
+		        // 处理 model 值双向绑定
+		        option.data = value;
+		      },
+		      change: changeFunc
+		    });
+		  }
+		  function getFloatingFilterOns(renderOpts, params, option) {
+		    var $table = params.$table,
+		      column = params.column;
+		    if ((0, _comp.hasInputType)(renderOpts)) {
+		      return getComponentOns(renderOpts, params, {
+		        model: function model(value) {
+		          // 处理 model 值双向绑定
+		          option.data = value;
+		        },
+		        change: function change() {
+		          updateFilterChangeOption(params, !isEmptyValue(option.data), option);
+		        },
+		        clear: function clear() {
+		          updateFilterChangeOption(params, !isEmptyValue(option.data), option);
+		          saveFilterEvent(params);
+		        },
+		        blur: function blur() {
+		          $table.saveFilterByEvent(new Event('change'), column);
+		        }
+		      });
+		    }
+		    return getComponentOns(renderOpts, params, {
+		      model: function model(value) {
+		        // 处理 model 值双向绑定
+		        option.data = value;
+		      },
+		      clear: function clear() {
+		        updateFilterChangeOption(params, !isEmptyValue(option.data), option);
+		        $table.saveFilterByEvent(new Event('change'), column);
+		      },
+		      change: function change() {
+		        updateFilterChangeOption(params, !isEmptyValue(option.data), option);
+		        $table.saveFilterByEvent(new Event('change'), column);
+		      }
+		    });
+		  }
+		  function matchCascaderData(index, list, values, labels) {
+		    var val = values[index];
+		    if (list && values.length > index) {
+		      _xeUtils["default"].each(list, function (item) {
+		        if (item.value === val) {
+		          labels.push(item.label);
+		          matchCascaderData(++index, item.children, values, labels);
+		        }
+		      });
+		    }
+		  }
+		  function getSelectCellValue(renderOpts, params) {
+		    var _renderOpts$options = renderOpts.options,
+		      options = _renderOpts$options === void 0 ? [] : _renderOpts$options,
+		      optionGroups = renderOpts.optionGroups,
+		      _renderOpts$props = renderOpts.props,
+		      props = _renderOpts$props === void 0 ? {} : _renderOpts$props,
+		      _renderOpts$optionPro = renderOpts.optionProps,
+		      optionProps = _renderOpts$optionPro === void 0 ? {} : _renderOpts$optionPro,
+		      _renderOpts$optionGro = renderOpts.optionGroupProps,
+		      optionGroupProps = _renderOpts$optionGro === void 0 ? {} : _renderOpts$optionGro;
+		    var $table = params.$table,
+		      rowid = params.rowid,
+		      row = params.row,
+		      column = params.column;
+		    var filterable = props.filterable,
+		      multiple = props.multiple;
+		    var labelProp = optionProps.label || 'label';
+		    var valueProp = optionProps.value || 'value';
+		    var groupOptions = optionGroupProps.options || 'options';
+		    var cellValue = _xeUtils["default"].get(row, column.field);
+		    var colid = column.id;
+		    var cellData;
+		    if (filterable) {
+		      var internalData = $table.internalData;
+		      var fullAllDataRowIdData = internalData.fullAllDataRowIdData;
+		      var rest = fullAllDataRowIdData[rowid];
+		      if (rest) {
+		        cellData = rest.cellData;
+		        if (!cellData) {
+		          cellData = rest.cellData = {};
+		        }
+		      }
+		      if (rest && cellData[colid] && cellData[colid].value === cellValue) {
+		        return cellData[colid].label;
+		      }
+		    }
+		    if (!isEmptyValue(cellValue)) {
+		      var selectlabel = _xeUtils["default"].map(multiple ? cellValue : [cellValue], optionGroups ? function (value) {
+		        var selectItem;
+		        for (var index = 0; index < optionGroups.length; index++) {
+		          selectItem = _xeUtils["default"].find(optionGroups[index][groupOptions], function (item) {
+		            return item[valueProp] === value;
+		          });
+		          if (selectItem) {
+		            break;
+		          }
+		        }
+		        return selectItem ? selectItem[labelProp] : value;
+		      } : function (value) {
+		        var selectItem = _xeUtils["default"].find(options, function (item) {
+		          return item[valueProp] === value;
+		        });
+		        return selectItem ? selectItem[labelProp] : value;
+		      }).join(', ');
+		      if (cellData && options && options.length) {
+		        cellData[colid] = {
+		          value: cellValue,
+		          label: selectlabel
+		        };
+		      }
+		      return selectlabel;
+		    }
+		    return '';
+		  }
+		  function getCascaderCellValue(renderOpts, params) {
+		    var _renderOpts$props2 = renderOpts.props,
+		      props = _renderOpts$props2 === void 0 ? {} : _renderOpts$props2;
+		    var row = params.row,
+		      column = params.column;
+		    var cellValue = _xeUtils["default"].get(row, column.field);
+		    var values = cellValue || [];
+		    var labels = [];
+		    matchCascaderData(0, props.options, values, labels);
+		    return (props.showAllLevels === false ? labels.slice(labels.length - 1, labels.length) : labels).join(" ".concat(props.separator || '/', " "));
+		  }
+		  function getDatePickerCellValue(renderOpts, params) {
+		    var _renderOpts$props3 = renderOpts.props,
+		      props = _renderOpts$props3 === void 0 ? {} : _renderOpts$props3;
+		    var row = params.row,
+		      column = params.column;
+		    var _props$rangeSeparator = props.rangeSeparator,
+		      rangeSeparator = _props$rangeSeparator === void 0 ? '-' : _props$rangeSeparator;
+		    var cellValue = _xeUtils["default"].get(row, column.field);
+		    switch (props.type) {
+		      case 'week':
+		        cellValue = getFormatDate(cellValue, props, 'YYYYwWW');
+		        break;
+		      case 'month':
+		        cellValue = getFormatDate(cellValue, props, 'YYYY-MM');
+		        break;
+		      case 'year':
+		        cellValue = getFormatDate(cellValue, props, 'YYYY');
+		        break;
+		      case 'dates':
+		        cellValue = getFormatDates(cellValue, props, ', ', 'YYYY-MM-DD');
+		        break;
+		      case 'daterange':
+		        cellValue = getFormatDates(cellValue, props, " ".concat(rangeSeparator, " "), 'YYYY-MM-DD');
+		        break;
+		      case 'datetimerange':
+		        cellValue = getFormatDates(cellValue, props, " ".concat(rangeSeparator, " "), 'YYYY-MM-DD HH:ss:mm');
+		        break;
+		      case 'monthrange':
+		        cellValue = getFormatDates(cellValue, props, " ".concat(rangeSeparator, " "), 'YYYY-MM');
+		        break;
+		      default:
+		        cellValue = getFormatDate(cellValue, props, 'YYYY-MM-DD');
+		    }
+		    return cellValue;
+		  }
+		  function getTimePickerCellValue(renderOpts, params) {
+		    var _renderOpts$props4 = renderOpts.props,
+		      props = _renderOpts$props4 === void 0 ? {} : _renderOpts$props4;
+		    var row = params.row,
+		      column = params.column;
+		    var isRange = props.isRange,
+		      _props$format = props.format,
+		      format = _props$format === void 0 ? 'HH:mm:ss' : _props$format,
+		      _props$rangeSeparator2 = props.rangeSeparator,
+		      rangeSeparator = _props$rangeSeparator2 === void 0 ? '-' : _props$rangeSeparator2;
+		    var cellValue = _xeUtils["default"].get(row, column.field);
+		    if (cellValue && isRange) {
+		      cellValue = _xeUtils["default"].map(cellValue, function (date) {
+		        return toDayDateString(parseDate(date, props), format);
+		      }).join(" ".concat(rangeSeparator, " "));
+		    }
+		    return toDayDateString(parseDate(cellValue, props), format);
+		  }
+		  function createEditRender(defaultProps) {
+		    return function (renderOpts, params) {
+		      var row = params.row,
+		        column = params.column;
+		      var name = renderOpts.name,
+		        attrs = renderOpts.attrs,
+		        props = renderOpts.props;
+		      var cellValue = _xeUtils["default"].get(row, column.field);
+		      return [(0, _vue.h)((0, _comp.getCurrComponent)(name), _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, attrs), props), getCellEditFilterProps(renderOpts, params, cellValue, defaultProps)), getEditOns(renderOpts, params)))];
+		    };
+		  }
+		  function defaultButtonEditRender(renderOpts, params) {
+		    var attrs = renderOpts.attrs,
+		      props = renderOpts.props;
+		    return [(0, _vue.h)((0, _comp.getCurrComponent)('el-button'), _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, attrs), props), getCellEditFilterProps(renderOpts, params, null)), getComponentOns(renderOpts, params)), cellText(renderOpts.content))];
+		  }
+		  function defaultButtonsEditRender(renderOpts, params) {
+		    var children = renderOpts.children;
+		    if (children) {
+		      return children.map(function (childRenderOpts) {
+		        return defaultButtonEditRender(childRenderOpts, params)[0];
+		      });
+		    }
+		    return [];
+		  }
+		  function createFilterRender(defaultProps) {
+		    return function (renderOpts, params) {
+		      var column = params.column;
+		      var name = renderOpts.name,
+		        attrs = renderOpts.attrs,
+		        props = renderOpts.props;
+		      return [(0, _vue.h)('div', {
+		        "class": 'vxe-table--filter-element-wrapper'
+		      }, column.filters.map(function (option, oIndex) {
+		        var optionValue = option.data;
+		        return (0, _vue.h)((0, _comp.getCurrComponent)(name), _objectSpread(_objectSpread(_objectSpread(_objectSpread({
+		          key: oIndex
+		        }, attrs), props), getCellEditFilterProps(renderOpts, params, optionValue, defaultProps)), getFilterOns(renderOpts, params, option, function () {
+		          // 处理 change 事件相关逻辑
+		          handleConfirmFilter(params, !!option.data, option);
+		        })));
+		      }))];
+		    };
+		  }
+		  function createFloatingFilterRender(defaultProps) {
+		    return function (renderOpts, params) {
+		      var option = params.option;
+		      var name = renderOpts.name,
+		        attrs = renderOpts.attrs,
+		        props = renderOpts.props;
+		      var optionValue = option.data;
+		      return [(0, _vue.h)((0, _comp.getCurrComponent)(name), _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, attrs), props), getCellEditFilterProps(renderOpts, params, optionValue, defaultProps)), getFloatingFilterOns(renderOpts, params, option)))];
+		    };
+		  }
+		  function handleConfirmFilter(params, checked, option) {
+		    var $panel = params.$panel;
+		    $panel.changeOption(null, checked, option);
+		  }
+		  /**
+		   * 模糊匹配
+		   * @param params
+		   */
+		  function defaultFuzzyFilterMethod(params) {
+		    var option = params.option,
+		      row = params.row,
+		      column = params.column;
+		    var data = option.data;
+		    var cellValue = _xeUtils["default"].get(row, column.field);
+		    return _xeUtils["default"].toValueString(cellValue).indexOf(data) > -1;
+		  }
+		  /**
+		   * 精确匹配
+		   * @param params
+		   */
+		  function defaultExactFilterMethod(params) {
+		    var option = params.option,
+		      row = params.row,
+		      column = params.column;
+		    var data = option.data;
+		    var cellValue = _xeUtils["default"].get(row, column.field);
+		    /* eslint-disable eqeqeq */
+		    return cellValue === data;
+		  }
+		  function renderOptions(options, optionProps) {
+		    var labelProp = optionProps.label || 'label';
+		    var valueProp = optionProps.value || 'value';
+		    return _xeUtils["default"].map(options, function (item, oIndex) {
+		      return (0, _vue.h)((0, _comp.getCurrComponent)('el-option'), {
+		        key: oIndex,
+		        value: item[valueProp],
+		        label: item[labelProp],
+		        disabled: item.disabled
+		      });
+		    });
+		  }
+		  function cellText(cellValue) {
+		    return [formatText(cellValue)];
+		  }
+		  function createExportMethod(getExportCellValue) {
+		    return function (params) {
+		      var row = params.row,
+		        column = params.column,
+		        options = params.options;
+		      return options && options.original ? _xeUtils["default"].get(row, column.field) : getExportCellValue(column.editRender || column.cellRender, params);
+		    };
+		  }
+		  function defaultFilterOptions() {
+		    return [{
+		      data: null
+		    }];
+		  }
+		  VxeUI.renderer.mixin({
+		    ElAutocomplete: {
+		      tableAutoFocus: 'input',
+		      renderTableDefault: createEditRender(),
+		      renderTableEdit: createEditRender(),
+		      createTableFilterOptions: defaultFilterOptions,
+		      renderTableFilter: createFilterRender(),
+		      tableFilterDefaultMethod: defaultExactFilterMethod
+		    },
+		    ElInput: {
+		      tableAutoFocus: 'input',
+		      renderTableDefault: createEditRender(),
+		      renderTableEdit: createEditRender(),
+		      createTableFilterOptions: defaultFilterOptions,
+		      renderTableFilter: createFilterRender(),
+		      renderTableFloatingFilter: createFloatingFilterRender(),
+		      tableFilterDefaultMethod: defaultFuzzyFilterMethod
+		    },
+		    ElInputNumber: {
+		      tableAutoFocus: 'input',
+		      renderTableDefault: createEditRender(),
+		      renderTableEdit: createEditRender(),
+		      createTableFilterOptions: defaultFilterOptions,
+		      renderTableFilter: createFilterRender(),
+		      renderTableFloatingFilter: createFloatingFilterRender(),
+		      tableFilterDefaultMethod: defaultFuzzyFilterMethod
+		    },
+		    ElSelect: {
+		      tableAutoFocus: 'input',
+		      renderTableEdit: function renderTableEdit(renderOpts, params) {
+		        var _renderOpts$options2 = renderOpts.options,
+		          options = _renderOpts$options2 === void 0 ? [] : _renderOpts$options2,
+		          optionGroups = renderOpts.optionGroups,
+		          _renderOpts$optionPro2 = renderOpts.optionProps,
+		          optionProps = _renderOpts$optionPro2 === void 0 ? {} : _renderOpts$optionPro2,
+		          _renderOpts$optionGro2 = renderOpts.optionGroupProps,
+		          optionGroupProps = _renderOpts$optionGro2 === void 0 ? {} : _renderOpts$optionGro2;
+		        var row = params.row,
+		          column = params.column;
+		        var attrs = renderOpts.attrs;
+		        var cellValue = _xeUtils["default"].get(row, column.field);
+		        var props = getCellEditFilterProps(renderOpts, params, cellValue);
+		        var ons = getEditOns(renderOpts, params);
+		        if (optionGroups) {
+		          var groupOptions = optionGroupProps.options || 'options';
+		          var groupLabel = optionGroupProps.label || 'label';
+		          return [(0, _vue.h)((0, _comp.getCurrComponent)('el-select'), _objectSpread(_objectSpread(_objectSpread({}, attrs), props), ons), {
+		            "default": function _default() {
+		              return _xeUtils["default"].map(optionGroups, function (group, gIndex) {
+		                return (0, _vue.h)((0, _comp.getCurrComponent)('el-option-group'), {
+		                  key: gIndex,
+		                  label: group[groupLabel]
+		                }, {
+		                  "default": function _default() {
+		                    return renderOptions(group[groupOptions], optionProps);
+		                  }
+		                });
+		              });
+		            }
+		          })];
+		        }
+		        return [(0, _vue.h)((0, _comp.getCurrComponent)('el-select'), _objectSpread(_objectSpread(_objectSpread({}, props), attrs), ons), {
+		          "default": function _default() {
+		            return renderOptions(options, optionProps);
+		          }
+		        })];
+		      },
+		      renderTableCell: function renderTableCell(renderOpts, params) {
+		        return getCellLabelVNs(renderOpts, params, getSelectCellValue(renderOpts, params));
+		      },
+		      createTableFilterOptions: defaultFilterOptions,
+		      renderTableFilter: function renderTableFilter(renderOpts, params) {
+		        var _renderOpts$options3 = renderOpts.options,
+		          options = _renderOpts$options3 === void 0 ? [] : _renderOpts$options3,
+		          optionGroups = renderOpts.optionGroups,
+		          _renderOpts$optionPro3 = renderOpts.optionProps,
+		          optionProps = _renderOpts$optionPro3 === void 0 ? {} : _renderOpts$optionPro3,
+		          _renderOpts$optionGro3 = renderOpts.optionGroupProps,
+		          optionGroupProps = _renderOpts$optionGro3 === void 0 ? {} : _renderOpts$optionGro3;
+		        var groupOptions = optionGroupProps.options || 'options';
+		        var groupLabel = optionGroupProps.label || 'label';
+		        var column = params.column;
+		        var attrs = renderOpts.attrs;
+		        return [(0, _vue.h)('div', {
+		          "class": 'vxe-table--filter-element-wrapper'
+		        }, optionGroups ? column.filters.map(function (option, oIndex) {
+		          var optionValue = option.data;
+		          var props = getCellEditFilterProps(renderOpts, params, optionValue);
+		          return (0, _vue.h)((0, _comp.getCurrComponent)('el-select'), _objectSpread(_objectSpread(_objectSpread({
+		            key: oIndex
+		          }, attrs), props), getFilterOns(renderOpts, params, option, function () {
+		            // 处理 change 事件相关逻辑
+		            handleConfirmFilter(params, props.multiple ? option.data && option.data.length > 0 : !_xeUtils["default"].eqNull(option.data), option);
+		          })), {
+		            "default": function _default() {
+		              return _xeUtils["default"].map(optionGroups, function (group, gIndex) {
+		                return (0, _vue.h)((0, _comp.getCurrComponent)('el-option-group'), {
+		                  key: gIndex,
+		                  label: group[groupLabel]
+		                }, {
+		                  "default": function _default() {
+		                    return renderOptions(group[groupOptions], optionProps);
+		                  }
+		                });
+		              });
+		            }
+		          });
+		        }) : column.filters.map(function (option, oIndex) {
+		          var optionValue = option.data;
+		          var props = getCellEditFilterProps(renderOpts, params, optionValue);
+		          return (0, _vue.h)((0, _comp.getCurrComponent)('el-select'), _objectSpread(_objectSpread(_objectSpread({
+		            key: oIndex
+		          }, attrs), props), getFilterOns(renderOpts, params, option, function () {
+		            // 处理 change 事件相关逻辑
+		            handleConfirmFilter(params, props.multiple ? option.data && option.data.length > 0 : !_xeUtils["default"].eqNull(option.data), option);
+		          })), {
+		            "default": function _default() {
+		              return renderOptions(options, optionProps);
+		            }
+		          });
+		        }))];
+		      },
+		      tableFilterDefaultMethod: function tableFilterDefaultMethod(params) {
+		        var option = params.option,
+		          row = params.row,
+		          column = params.column;
+		        var data = option.data;
+		        var field = column.field,
+		          renderOpts = column.filterRender;
+		        var _renderOpts$props5 = renderOpts.props,
+		          props = _renderOpts$props5 === void 0 ? {} : _renderOpts$props5;
+		        var cellValue = _xeUtils["default"].get(row, field);
+		        if (props.multiple) {
+		          if (_xeUtils["default"].isArray(cellValue)) {
+		            return _xeUtils["default"].includeArrays(cellValue, data);
+		          }
+		          return data.indexOf(cellValue) > -1;
+		        }
+		        /* eslint-disable eqeqeq */
+		        return cellValue == data;
+		      },
+		      tableExportMethod: createExportMethod(getSelectCellValue)
+		    },
+		    ElCascader: {
+		      tableAutoFocus: 'input',
+		      renderTableEdit: createEditRender(),
+		      renderTableCell: function renderTableCell(renderOpts, params) {
+		        return getCellLabelVNs(renderOpts, params, getCascaderCellValue(renderOpts, params));
+		      },
+		      tableExportMethod: createExportMethod(getCascaderCellValue)
+		    },
+		    ElDatePicker: {
+		      tableAutoFocus: 'input',
+		      renderTableEdit: createEditRender(),
+		      renderTableCell: function renderTableCell(renderOpts, params) {
+		        return getCellLabelVNs(renderOpts, params, getDatePickerCellValue(renderOpts, params));
+		      },
+		      createTableFilterOptions: defaultFilterOptions,
+		      renderTableFilter: function renderTableFilter(renderOpts, params) {
+		        var column = params.column;
+		        var name = renderOpts.name,
+		          attrs = renderOpts.attrs;
+		        return [(0, _vue.h)('div', {
+		          "class": 'vxe-table--filter-element-wrapper'
+		        }, column.filters.map(function (option, oIndex) {
+		          var optionValue = option.data;
+		          return (0, _vue.h)((0, _comp.getCurrComponent)(name), _objectSpread(_objectSpread(_objectSpread({
+		            key: oIndex
+		          }, attrs), getCellEditFilterProps(renderOpts, params, optionValue)), getFilterOns(renderOpts, params, option, function () {
+		            // 处理 change 事件相关逻辑
+		            handleConfirmFilter(params, !!option.data, option);
+		          })));
+		        }))];
+		      },
+		      renderTableFloatingFilter: createFloatingFilterRender(),
+		      tableFilterDefaultMethod: function tableFilterDefaultMethod(params) {
+		        var option = params.option,
+		          row = params.row,
+		          column = params.column;
+		        var data = option.data;
+		        var renderOpts = column.filterRender;
+		        var _renderOpts$props6 = renderOpts.props,
+		          props = _renderOpts$props6 === void 0 ? {} : _renderOpts$props6;
+		        var cellValue = _xeUtils["default"].get(row, column.field);
+		        if (data) {
+		          switch (props.type) {
+		            case 'daterange':
+		              return equalDateRange(cellValue, data, props, 'YYYY-MM-DD');
+		            case 'datetimerange':
+		              return equalDateRange(cellValue, data, props, 'YYYY-MM-DD HH:ss:mm');
+		            case 'monthrange':
+		              return equalDateRange(cellValue, data, props, 'YYYY-MM');
+		            default:
+		              return cellValue === data;
+		          }
+		        }
+		        return false;
+		      },
+		      tableExportMethod: createExportMethod(getDatePickerCellValue)
+		    },
+		    ElTimePicker: {
+		      tableAutoFocus: 'input',
+		      renderTableEdit: createEditRender(),
+		      renderTableCell: function renderTableCell(renderOpts, params) {
+		        return getCellLabelVNs(renderOpts, params, getTimePickerCellValue(renderOpts, params));
+		      },
+		      tableExportMethod: createExportMethod(getTimePickerCellValue)
+		    },
+		    ElTimeSelect: {
+		      tableAutoFocus: 'input',
+		      renderTableEdit: createEditRender()
+		    },
+		    ElRate: {
+		      renderTableDefault: createEditRender(),
+		      renderTableEdit: createEditRender(),
+		      createTableFilterOptions: defaultFilterOptions,
+		      renderTableFilter: createFilterRender(),
+		      tableFilterDefaultMethod: defaultExactFilterMethod
+		    },
+		    ElSwitch: {
+		      renderTableDefault: createEditRender(),
+		      renderTableEdit: createEditRender(),
+		      renderTableFilter: function renderTableFilter(renderOpts, params) {
+		        var column = params.column;
+		        var name = renderOpts.name,
+		          attrs = renderOpts.attrs;
+		        return [(0, _vue.h)('div', {
+		          "class": 'vxe-table--filter-element-wrapper'
+		        }, column.filters.map(function (option, oIndex) {
+		          var optionValue = option.data;
+		          return (0, _vue.h)((0, _comp.getCurrComponent)(name), _objectSpread(_objectSpread(_objectSpread({
+		            key: oIndex
+		          }, attrs), getCellEditFilterProps(renderOpts, params, optionValue)), getFilterOns(renderOpts, params, option, function () {
+		            // 处理 change 事件相关逻辑
+		            handleConfirmFilter(params, _xeUtils["default"].isBoolean(option.data), option);
+		          })));
+		        }))];
+		      },
+		      tableFilterDefaultMethod: defaultExactFilterMethod
+		    },
+		    ElSlider: {
+		      renderTableDefault: createEditRender(),
+		      renderTableEdit: createEditRender(),
+		      createTableFilterOptions: defaultFilterOptions,
+		      renderTableFilter: createFilterRender(),
+		      tableFilterDefaultMethod: defaultExactFilterMethod
+		    },
+		    ElButton: {
+		      renderTableDefault: defaultButtonEditRender
+		    },
+		    ElButtons: {
+		      renderTableDefault: defaultButtonsEditRender
+		    }
+		  });
+		}
+		return table;
+	}
+
+	var form = {};
+
+	var hasRequiredForm;
+
+	function requireForm () {
+		if (hasRequiredForm) return form;
+		hasRequiredForm = 1;
+
+		Object.defineProperty(form, "__esModule", {
+		  value: true
+		});
+		form.defineFormRender = defineFormRender;
+		var _vue = require$$0;
+		var _comp = requireComp();
+		var _xeUtils = _interopRequireDefault(require$$3);
+		function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+		function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+		function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+		function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+		function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e; }
+		function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+		function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+		/**
+		 * 表单 - 渲染器
+		 */
+		function defineFormRender(VxeUI) {
+		  function isEmptyValue(cellValue) {
+		    return cellValue === null || cellValue === undefined || cellValue === '';
+		  }
+		  function getOnName(type) {
+		    return 'on' + type.substring(0, 1).toLocaleUpperCase() + type.substring(1);
+		  }
+		  function getModelProp(renderOpts) {
+		    return 'modelValue';
+		  }
+		  function getModelEvent(renderOpts) {
+		    return 'update:modelValue';
+		  }
+		  function getChangeEvent(renderOpts) {
+		    var type = 'change';
+		    switch (renderOpts.name) {
+		      case 'ElAutocomplete':
+		        type = 'select';
+		        break;
+		      case 'ElInput':
+		      case 'ElInputNumber':
+		        type = 'input';
+		        break;
+		    }
+		    return type;
+		  }
+		  function getItemProps(renderOpts, params, value, defaultProps) {
+		    return _xeUtils["default"].assign({}, defaultProps, renderOpts.props, _defineProperty({}, getModelProp(), value));
+		  }
+		  function formatText(cellValue) {
+		    return '' + (isEmptyValue(cellValue) ? '' : cellValue);
+		  }
+		  function getOns(renderOpts, params, inputFunc, changeFunc) {
+		    var events = renderOpts.events;
+		    var modelEvent = getModelEvent();
+		    var changeEvent = getChangeEvent(renderOpts);
+		    var isSameEvent = changeEvent === modelEvent;
+		    var ons = {};
+		    _xeUtils["default"].objectEach(events, function (func, key) {
+		      ons[getOnName(key)] = function () {
+		        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+		          args[_key] = arguments[_key];
+		        }
+		        func.apply(void 0, [params].concat(args));
+		      };
+		    });
+		    if (inputFunc) {
+		      ons[getOnName(modelEvent)] = function (targetEvnt) {
+		        inputFunc(targetEvnt);
+		        if (events && events[modelEvent]) {
+		          events[modelEvent](params, targetEvnt);
+		        }
+		        if (isSameEvent && changeFunc) {
+		          changeFunc(targetEvnt);
+		        }
+		      };
+		    }
+		    if (!isSameEvent && changeFunc) {
+		      ons[getOnName(changeEvent)] = function () {
+		        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+		          args[_key2] = arguments[_key2];
+		        }
+		        changeFunc.apply(void 0, args);
+		        if (events && events[changeEvent]) {
+		          events[changeEvent].apply(events, [params].concat(args));
+		        }
+		      };
+		    }
+		    return ons;
+		  }
+		  function getItemOns(renderOpts, params) {
+		    var $form = params.$form,
+		      data = params.data,
+		      field = params.field;
+		    return getOns(renderOpts, params, function (value) {
+		      // 处理 model 值双向绑定
+		      _xeUtils["default"].set(data, field, value);
+		    }, function () {
+		      // 处理 change 事件相关逻辑
+		      $form.updateStatus(params);
+		      if (renderOpts.changeToSubmit) {
+		        $form.handleSubmitEvent(new Event('change'));
+		      }
+		    });
+		  }
+		  function renderOptions(options, optionProps) {
+		    var labelProp = optionProps.label || 'label';
+		    var valueProp = optionProps.value || 'value';
+		    return _xeUtils["default"].map(options, function (item, oIndex) {
+		      return (0, _vue.h)((0, _comp.getCurrComponent)('el-option'), {
+		        key: oIndex,
+		        value: item[valueProp],
+		        label: item[labelProp],
+		        disabled: item.disabled
+		      });
+		    });
+		  }
+		  function cellText(cellValue) {
+		    return [formatText(cellValue)];
+		  }
+		  function createFormItemRender(defaultProps) {
+		    return function (renderOpts, params) {
+		      var data = params.data,
+		        field = params.field;
+		      var name = renderOpts.name;
+		      var attrs = renderOpts.attrs;
+		      var itemValue = _xeUtils["default"].get(data, field);
+		      return [(0, _vue.h)((0, _comp.getCurrComponent)(name), _objectSpread(_objectSpread(_objectSpread({}, attrs), getItemProps(renderOpts, params, itemValue, defaultProps)), getItemOns(renderOpts, params)))];
+		    };
+		  }
+		  function defaultButtonItemRender(renderOpts, params) {
+		    var attrs = renderOpts.attrs;
+		    var props = getItemProps(renderOpts, params, null);
+		    return [(0, _vue.h)((0, _comp.getCurrComponent)('el-button'), _objectSpread(_objectSpread(_objectSpread({}, attrs), props), getOns(renderOpts, params)), {
+		      "default": function _default() {
+		        return cellText(renderOpts.content || props.content);
+		      }
+		    })];
+		  }
+		  function defaultButtonsItemRender(renderOpts, params) {
+		    var children = renderOpts.children;
+		    if (children) {
+		      return children.map(function (childRenderOpts) {
+		        return defaultButtonItemRender(childRenderOpts, params)[0];
+		      });
+		    }
+		    return [];
+		  }
+		  /**
+		   * 已废弃
+		   * @deprecated
+		   */
+		  function createOldFormItemRadioAndCheckboxRender() {
+		    return function (renderOpts, params) {
+		      var name = renderOpts.name,
+		        _renderOpts$options = renderOpts.options,
+		        options = _renderOpts$options === void 0 ? [] : _renderOpts$options,
+		        _renderOpts$optionPro = renderOpts.optionProps,
+		        optionProps = _renderOpts$optionPro === void 0 ? {} : _renderOpts$optionPro,
+		        attrs = renderOpts.attrs;
+		      var data = params.data,
+		        field = params.field;
+		      var labelProp = optionProps.label || 'label';
+		      var valueProp = optionProps.value || 'value';
+		      var itemValue = _xeUtils["default"].get(data, field);
+		      return [(0, _vue.h)((0, _comp.getCurrComponent)("".concat(name, "Group")), _objectSpread(_objectSpread(_objectSpread({}, attrs), getItemProps(renderOpts, params, itemValue)), getItemOns(renderOpts, params)), {
+		        "default": function _default() {
+		          return options.map(function (option, oIndex) {
+		            return (0, _vue.h)((0, _comp.getCurrComponent)(name), {
+		              key: oIndex,
+		              label: option[valueProp],
+		              disabled: option.disabled
+		            }, {
+		              "default": function _default() {
+		                return cellText(option[labelProp]);
+		              }
+		            });
+		          });
+		        }
+		      })];
+		    };
+		  }
+		  VxeUI.renderer.mixin({
+		    ElAutocomplete: {
+		      renderFormItemContent: createFormItemRender()
+		    },
+		    ElInput: {
+		      renderFormItemContent: createFormItemRender()
+		    },
+		    ElInputNumber: {
+		      renderFormItemContent: createFormItemRender()
+		    },
+		    ElSelect: {
+		      renderFormItemContent: function renderFormItemContent(renderOpts, params) {
+		        var _renderOpts$options2 = renderOpts.options,
+		          options = _renderOpts$options2 === void 0 ? [] : _renderOpts$options2,
+		          optionGroups = renderOpts.optionGroups,
+		          _renderOpts$optionPro2 = renderOpts.optionProps,
+		          optionProps = _renderOpts$optionPro2 === void 0 ? {} : _renderOpts$optionPro2,
+		          _renderOpts$optionGro = renderOpts.optionGroupProps,
+		          optionGroupProps = _renderOpts$optionGro === void 0 ? {} : _renderOpts$optionGro;
+		        var data = params.data,
+		          field = params.field;
+		        var attrs = renderOpts.attrs;
+		        var itemValue = _xeUtils["default"].get(data, field);
+		        var props = getItemProps(renderOpts, params, itemValue);
+		        var ons = getItemOns(renderOpts, params);
+		        if (optionGroups) {
+		          var groupOptions = optionGroupProps.options || 'options';
+		          var groupLabel = optionGroupProps.label || 'label';
+		          return [(0, _vue.h)((0, _comp.getCurrComponent)('el-select'), _objectSpread(_objectSpread(_objectSpread({}, attrs), props), ons), {
+		            "default": function _default() {
+		              return _xeUtils["default"].map(optionGroups, function (group, gIndex) {
+		                return (0, _vue.h)((0, _comp.getCurrComponent)('el-option-group'), {
+		                  label: group[groupLabel],
+		                  key: gIndex
+		                }, {
+		                  "default": function _default() {
+		                    return renderOptions(group[groupOptions], optionProps);
+		                  }
+		                });
+		              });
+		            }
+		          })];
+		        }
+		        return [(0, _vue.h)((0, _comp.getCurrComponent)('el-select'), _objectSpread(_objectSpread(_objectSpread({}, attrs), props), ons), {
+		          "default": function _default() {
+		            return renderOptions(options, optionProps);
+		          }
+		        })];
+		      }
+		    },
+		    ElCascader: {
+		      renderFormItemContent: createFormItemRender()
+		    },
+		    ElDatePicker: {
+		      renderFormItemContent: createFormItemRender()
+		    },
+		    ElTimePicker: {
+		      renderFormItemContent: createFormItemRender()
+		    },
+		    ElTimeSelect: {
+		      renderFormItemContent: createFormItemRender()
+		    },
+		    ElRate: {
+		      renderFormItemContent: createFormItemRender()
+		    },
+		    ElSwitch: {
+		      renderFormItemContent: createFormItemRender()
+		    },
+		    ElSlider: {
+		      renderFormItemContent: createFormItemRender()
+		    },
+		    ElRadioGroup: {
+		      renderFormItemContent: function renderFormItemContent(renderOpts, params) {
+		        var _renderOpts$options3 = renderOpts.options,
+		          options = _renderOpts$options3 === void 0 ? [] : _renderOpts$options3,
+		          _renderOpts$optionPro3 = renderOpts.optionProps,
+		          optionProps = _renderOpts$optionPro3 === void 0 ? {} : _renderOpts$optionPro3,
+		          attrs = renderOpts.attrs;
+		        var data = params.data,
+		          field = params.field;
+		        var labelProp = optionProps.label || 'label';
+		        var valueProp = optionProps.value || 'value';
+		        var itemValue = _xeUtils["default"].get(data, field);
+		        return [(0, _vue.h)((0, _comp.getCurrComponent)('el-radio-group'), _objectSpread(_objectSpread(_objectSpread({}, attrs), getItemProps(renderOpts, params, itemValue)), getItemOns(renderOpts, params)), {
+		          "default": function _default() {
+		            return options.map(function (option, oIndex) {
+		              return (0, _vue.h)((0, _comp.getCurrComponent)('el-radio'), {
+		                key: oIndex,
+		                value: option[valueProp],
+		                disabled: option.disabled
+		              }, {
+		                "default": function _default() {
+		                  return cellText(option[labelProp]);
+		                }
+		              });
+		            });
+		          }
+		        })];
+		      }
+		    },
+		    ElCheckboxGroup: {
+		      renderFormItemContent: function renderFormItemContent(renderOpts, params) {
+		        var _renderOpts$options4 = renderOpts.options,
+		          options = _renderOpts$options4 === void 0 ? [] : _renderOpts$options4,
+		          _renderOpts$optionPro4 = renderOpts.optionProps,
+		          optionProps = _renderOpts$optionPro4 === void 0 ? {} : _renderOpts$optionPro4,
+		          attrs = renderOpts.attrs;
+		        var data = params.data,
+		          field = params.field;
+		        var labelProp = optionProps.label || 'label';
+		        var valueProp = optionProps.value || 'value';
+		        var itemValue = _xeUtils["default"].get(data, field);
+		        return [(0, _vue.h)((0, _comp.getCurrComponent)('el-checkbox-group'), _objectSpread(_objectSpread(_objectSpread({}, attrs), getItemProps(renderOpts, params, itemValue)), getItemOns(renderOpts, params)), {
+		          "default": function _default() {
+		            return options.map(function (option, oIndex) {
+		              return (0, _vue.h)((0, _comp.getCurrComponent)('el-checkbox'), {
+		                key: oIndex,
+		                value: option[valueProp],
+		                label: option[labelProp],
+		                disabled: option.disabled
+		              });
+		            });
+		          }
+		        })];
+		      }
+		    },
+		    ElButton: {
+		      renderFormItemContent: defaultButtonItemRender
+		    },
+		    // 已废弃
+		    ElRadio: {
+		      renderFormItemContent: createOldFormItemRadioAndCheckboxRender()
+		    },
+		    ElCheckbox: {
+		      renderFormItemContent: createOldFormItemRadioAndCheckboxRender()
+		    },
+		    ElButtons: {
+		      renderFormItemContent: defaultButtonsItemRender
+		    }
+		  });
+		}
+		return form;
+	}
+
+	var formDesign = {};
+
+	var inputWidget = {};
+
+	var hasRequiredInputWidget;
+
+	function requireInputWidget () {
+		if (hasRequiredInputWidget) return inputWidget;
+		hasRequiredInputWidget = 1;
+
+		Object.defineProperty(inputWidget, "__esModule", {
+		  value: true
+		});
+		inputWidget.createWidgetElInput = createWidgetElInput;
+		var _vue = require$$0;
+		var _comp = requireComp();
+		function createWidgetElInput(VxeUI) {
+		  var getWidgetElInputConfig = function getWidgetElInputConfig(params) {
+		    return {
+		      title: '输入框',
+		      icon: 'vxe-icon-input',
+		      options: {
+		        placeholder: '请输入'
+		      }
+		    };
+		  };
+		  var WidgetElInputFormComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormComponent = VxeUI.getComponent('VxeForm');
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var VxeUISwitchComponent = VxeUI.getComponent('VxeSwitch');
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget;
+		        var options = widget.options;
+		        return (0, _vue.h)(VxeUIFormComponent, {
+		          "class": 'vxe-form-design--widget-render-form-wrapper',
+		          vertical: true,
+		          span: 24,
+		          titleBold: true,
+		          titleOverflow: true,
+		          data: options
+		        }, {
+		          "default": function _default() {
+		            return [(0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.name')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)((0, _comp.getCurrComponent)('el-input'), {
+		                  modelValue: widget.title,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.title = val;
+		                  }
+		                });
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.placeholder'),
+		              field: 'placeholder',
+		              itemRender: {
+		                name: 'ElInput'
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.required')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)(VxeUISwitchComponent, {
+		                  modelValue: widget.required,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.required = val;
+		                  }
+		                });
+		              }
+		            })];
+		          }
+		        });
+		      };
+		    }
+		  });
+		  var WidgetElInputViewComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var changeEvent = function changeEvent() {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        if ($formView) {
+		          var itemValue = $formView ? $formView.getItemValue(widget) : null;
+		          $formView.updateWidgetStatus(widget, itemValue);
+		        }
+		      };
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        var options = widget.options;
+		        return (0, _vue.h)(VxeUIFormItemComponent, {
+		          "class": ['vxe-form-design--widget-render-form-item'],
+		          field: widget.field,
+		          title: widget.title
+		        }, {
+		          "default": function _default() {
+		            return (0, _vue.h)((0, _comp.getCurrComponent)('el-input'), {
+		              modelValue: $formView ? $formView.getItemValue(widget) : null,
+		              placeholder: options.placeholder,
+		              onChange: changeEvent,
+		              'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                if ($formView) {
+		                  $formView.setItemValue(widget, val);
+		                }
+		              }
+		            });
+		          }
+		        });
+		      };
+		    }
+		  });
+		  return {
+		    getWidgetElInputConfig: getWidgetElInputConfig,
+		    WidgetElInputFormComponent: WidgetElInputFormComponent,
+		    WidgetElInputViewComponent: WidgetElInputViewComponent
+		  };
+		}
+		return inputWidget;
+	}
+
+	var textareaWidget = {};
+
+	var hasRequiredTextareaWidget;
+
+	function requireTextareaWidget () {
+		if (hasRequiredTextareaWidget) return textareaWidget;
+		hasRequiredTextareaWidget = 1;
+
+		Object.defineProperty(textareaWidget, "__esModule", {
+		  value: true
+		});
+		textareaWidget.createWidgetElTextarea = createWidgetElTextarea;
+		var _vue = require$$0;
+		var _comp = requireComp();
+		function createWidgetElTextarea(VxeUI) {
+		  var getWidgetElTextareaConfig = function getWidgetElTextareaConfig(params) {
+		    return {
+		      title: '文本域',
+		      icon: 'vxe-icon-textarea',
+		      options: {
+		        placeholder: '请输入'
+		      }
+		    };
+		  };
+		  var WidgetElTextareaFormComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormComponent = VxeUI.getComponent('VxeForm');
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var VxeUISwitchComponent = VxeUI.getComponent('VxeSwitch');
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget;
+		        return (0, _vue.h)(VxeUIFormComponent, {
+		          "class": 'vxe-form-design--widget-render-form-wrapper',
+		          vertical: true,
+		          span: 24,
+		          titleBold: true,
+		          titleOverflow: true,
+		          data: widget.options
+		        }, {
+		          "default": function _default() {
+		            return [(0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.name')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)((0, _comp.getCurrComponent)('el-input'), {
+		                  modelValue: widget.title,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.title = val;
+		                  }
+		                });
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.placeholder'),
+		              field: 'placeholder',
+		              itemRender: {
+		                name: 'ElInput'
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.required')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)(VxeUISwitchComponent, {
+		                  modelValue: widget.required,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.required = val;
+		                  }
+		                });
+		              }
+		            })];
+		          }
+		        });
+		      };
+		    }
+		  });
+		  var WidgetElTextareaViewComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var changeEvent = function changeEvent() {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        if ($formView) {
+		          var itemValue = $formView ? $formView.getItemValue(widget) : null;
+		          $formView.updateWidgetStatus(widget, itemValue);
+		        }
+		      };
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        var options = widget.options;
+		        return (0, _vue.h)(VxeUIFormItemComponent, {
+		          "class": ['vxe-form-design--widget-render-form-item'],
+		          field: widget.field,
+		          title: widget.title
+		        }, {
+		          "default": function _default() {
+		            return (0, _vue.h)((0, _comp.getCurrComponent)('el-input'), {
+		              modelValue: $formView ? $formView.getItemValue(widget) : null,
+		              placeholder: options.placeholder,
+		              type: 'textarea',
+		              autosize: {
+		                minRows: 2,
+		                maxRows: 4
+		              },
+		              onChange: changeEvent,
+		              'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                if ($formView) {
+		                  $formView.setItemValue(widget, val);
+		                }
+		              }
+		            });
+		          }
+		        });
+		      };
+		    }
+		  });
+		  return {
+		    getWidgetElTextareaConfig: getWidgetElTextareaConfig,
+		    WidgetElTextareaFormComponent: WidgetElTextareaFormComponent,
+		    WidgetElTextareaViewComponent: WidgetElTextareaViewComponent
+		  };
+		}
+		return textareaWidget;
+	}
+
+	var numberInputWidget = {};
+
+	var hasRequiredNumberInputWidget;
+
+	function requireNumberInputWidget () {
+		if (hasRequiredNumberInputWidget) return numberInputWidget;
+		hasRequiredNumberInputWidget = 1;
+
+		Object.defineProperty(numberInputWidget, "__esModule", {
+		  value: true
+		});
+		numberInputWidget.createWidgetElInputNumber = createWidgetElInputNumber;
+		var _vue = require$$0;
+		var _comp = requireComp();
+		function createWidgetElInputNumber(VxeUI) {
+		  var getWidgetElInputNumberConfig = function getWidgetElInputNumberConfig(params) {
+		    return {
+		      title: '数字',
+		      icon: 'vxe-icon-number',
+		      options: {
+		        placeholder: '请输入'
+		      }
+		    };
+		  };
+		  var WidgetElInputNumberFormComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormComponent = VxeUI.getComponent('VxeForm');
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var VxeUISwitchComponent = VxeUI.getComponent('VxeSwitch');
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget;
+		        return (0, _vue.h)(VxeUIFormComponent, {
+		          "class": 'vxe-form-design--widget-render-form-wrapper',
+		          vertical: true,
+		          span: 24,
+		          titleBold: true,
+		          titleOverflow: true,
+		          data: widget.options
+		        }, {
+		          "default": function _default() {
+		            return [(0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.name')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)((0, _comp.getCurrComponent)('el-input'), {
+		                  modelValue: widget.title,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.title = val;
+		                  }
+		                });
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.placeholder'),
+		              field: 'placeholder',
+		              itemRender: {
+		                name: 'ElInput'
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.required')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)(VxeUISwitchComponent, {
+		                  modelValue: widget.required,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.required = val;
+		                  }
+		                });
+		              }
+		            })];
+		          }
+		        });
+		      };
+		    }
+		  });
+		  var WidgetElInputNumberViewComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var changeEvent = function changeEvent() {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        if ($formView) {
+		          var itemValue = $formView ? $formView.getItemValue(widget) : null;
+		          $formView.updateWidgetStatus(widget, itemValue);
+		        }
+		      };
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        var options = widget.options;
+		        return (0, _vue.h)(VxeUIFormItemComponent, {
+		          "class": ['vxe-form-design--widget-render-form-item'],
+		          field: widget.field,
+		          title: widget.title
+		        }, {
+		          "default": function _default() {
+		            return (0, _vue.h)((0, _comp.getCurrComponent)('el-input-number'), {
+		              modelValue: $formView ? $formView.getItemValue(widget) : null,
+		              placeholder: options.placeholder,
+		              onChange: changeEvent,
+		              'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                if ($formView) {
+		                  $formView.setItemValue(widget, val);
+		                }
+		              }
+		            });
+		          }
+		        });
+		      };
+		    }
+		  });
+		  return {
+		    getWidgetElInputNumberConfig: getWidgetElInputNumberConfig,
+		    WidgetElInputNumberFormComponent: WidgetElInputNumberFormComponent,
+		    WidgetElInputNumberViewComponent: WidgetElInputNumberViewComponent
+		  };
+		}
+		return numberInputWidget;
+	}
+
+	var datePickerWidget = {};
+
+	var hasRequiredDatePickerWidget;
+
+	function requireDatePickerWidget () {
+		if (hasRequiredDatePickerWidget) return datePickerWidget;
+		hasRequiredDatePickerWidget = 1;
+
+		Object.defineProperty(datePickerWidget, "__esModule", {
+		  value: true
+		});
+		datePickerWidget.createWidgetElDatePicker = createWidgetElDatePicker;
+		var _vue = require$$0;
+		var _comp = requireComp();
+		function createWidgetElDatePicker(VxeUI) {
+		  var getWidgetElDatePickerConfig = function getWidgetElDatePickerConfig(params) {
+		    return {
+		      title: '日期',
+		      icon: 'vxe-icon-input',
+		      options: {
+		        placeholder: '请选择'
+		      }
+		    };
+		  };
+		  var WidgetElDatePickerFormComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormComponent = VxeUI.getComponent('VxeForm');
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var VxeUISwitchComponent = VxeUI.getComponent('VxeSwitch');
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget;
+		        return (0, _vue.h)(VxeUIFormComponent, {
+		          "class": 'vxe-form-design--widget-render-form-wrapper',
+		          vertical: true,
+		          span: 24,
+		          titleBold: true,
+		          titleOverflow: true,
+		          data: widget.options
+		        }, {
+		          "default": function _default() {
+		            return [(0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.name')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)((0, _comp.getCurrComponent)('el-input'), {
+		                  modelValue: widget.title,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.title = val;
+		                  }
+		                });
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.placeholder'),
+		              field: 'placeholder',
+		              itemRender: {
+		                name: 'ElDatePicker'
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.required')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)(VxeUISwitchComponent, {
+		                  modelValue: widget.required,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.required = val;
+		                  }
+		                });
+		              }
+		            })];
+		          }
+		        });
+		      };
+		    }
+		  });
+		  var WidgetElDatePickerViewComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var changeEvent = function changeEvent() {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        if ($formView) {
+		          var itemValue = $formView ? $formView.getItemValue(widget) : null;
+		          $formView.updateWidgetStatus(widget, itemValue);
+		        }
+		      };
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        var options = widget.options;
+		        return (0, _vue.h)(VxeUIFormItemComponent, {
+		          "class": ['vxe-form-design--widget-render-form-item'],
+		          field: widget.field,
+		          title: widget.title
+		        }, {
+		          "default": function _default() {
+		            return (0, _vue.h)((0, _comp.getCurrComponent)('el-date-picker'), {
+		              modelValue: $formView ? $formView.getItemValue(widget) : null,
+		              placeholder: options.placeholder,
+		              onChange: changeEvent,
+		              'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                if ($formView) {
+		                  $formView.setItemValue(widget, val);
+		                }
+		              }
+		            });
+		          }
+		        });
+		      };
+		    }
+		  });
+		  return {
+		    getWidgetElDatePickerConfig: getWidgetElDatePickerConfig,
+		    WidgetElDatePickerFormComponent: WidgetElDatePickerFormComponent,
+		    WidgetElDatePickerViewComponent: WidgetElDatePickerViewComponent
+		  };
+		}
+		return datePickerWidget;
+	}
+
+	var selectWidget = {};
+
+	var use = {};
+
+	var hasRequiredUse;
+
+	function requireUse () {
+		if (hasRequiredUse) return use;
+		hasRequiredUse = 1;
+
+		Object.defineProperty(use, "__esModule", {
+		  value: true
+		});
+		use.useWidgetPropDataSource = useWidgetPropDataSource;
+		var _vue = require$$0;
+		function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+		function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+		function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+		function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+		function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+		function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+		function useWidgetPropDataSource(VxeUI, props, isSubOption) {
+		  var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		  var VxeUIButtonComponent = VxeUI.getComponent('VxeButton');
+		  var VxeUITextareaComponent = VxeUI.getComponent('VxeTextarea');
+		  var VxeUITipComponent = VxeUI.getComponent('VxeTip');
+		  var optionsContent = (0, _vue.ref)('');
+		  var expandIndexList = (0, _vue.ref)([]);
+		  var addOptionEvent = function addOptionEvent() {
+		    var renderParams = props.renderParams;
+		    var widget = renderParams.widget;
+		    var options = widget.options.options || [];
+		    options.push({
+		      value: VxeUI.getI18n('vxe.formDesign.widgetProp.dataSource.defValue', [options.length + 1])
+		    });
+		    widget.options.options = _toConsumableArray(options);
+		  };
+		  var subRE = /^(\s|\t)+/;
+		  var hasSubOption = function hasSubOption(str) {
+		    return subRE.test(str);
+		  };
+		  var expandAllOption = function expandAllOption() {
+		    var renderParams = props.renderParams;
+		    var widget = renderParams.widget;
+		    var options = widget.options.options || [];
+		    var indexList = [];
+		    options.forEach(function (group, gIndex) {
+		      var options = group.options;
+		      if (options && options.length) {
+		        indexList.push(gIndex);
+		      }
+		    });
+		    expandIndexList.value = indexList;
+		  };
+		  var toggleExpandOption = function toggleExpandOption(item, gIndex) {
+		    if (expandIndexList.value.includes(gIndex)) {
+		      expandIndexList.value = expandIndexList.value.filter(function (num) {
+		        return num !== gIndex;
+		      });
+		    } else {
+		      expandIndexList.value.push(gIndex);
+		    }
+		  };
+		  var confirmBatchAddOptionEvent = function confirmBatchAddOptionEvent() {
+		    var renderParams = props.renderParams;
+		    var widget = renderParams.widget;
+		    var optList = [];
+		    var rowList = optionsContent.value.split('\n');
+		    var prevGroup = null;
+		    if (isSubOption) {
+		      rowList.forEach(function (str, index) {
+		        var nextStr = rowList[index + 1];
+		        var value = str.trim();
+		        if (!value) {
+		          return;
+		        }
+		        var item = {
+		          value: value
+		        };
+		        if (prevGroup) {
+		          if (hasSubOption(str)) {
+		            prevGroup.options.push(item);
+		            return;
+		          }
+		          prevGroup = null;
+		          optList.push(item);
+		        } else {
+		          optList.push(item);
+		        }
+		        if (nextStr) {
+		          if (hasSubOption(nextStr)) {
+		            prevGroup = Object.assign(item, {
+		              options: []
+		            });
+		          }
+		        }
+		      });
+		    } else {
+		      rowList.forEach(function (str) {
+		        optList.push({
+		          value: str.trim()
+		        });
+		      });
+		    }
+		    widget.options.options = optList;
+		    expandAllOption();
+		  };
+		  var openPopupEditEvent = function openPopupEditEvent() {
+		    var _widget$options$optio;
+		    var renderParams = props.renderParams;
+		    var widget = renderParams.widget;
+		    var contList = [];
+		    (_widget$options$optio = widget.options.options) === null || _widget$options$optio === void 0 || _widget$options$optio.forEach(function (group) {
+		      var _group$options;
+		      contList.push(group.value);
+		      (_group$options = group.options) === null || _group$options === void 0 || _group$options.forEach(function (item) {
+		        contList.push("\t".concat(item.value));
+		      });
+		    });
+		    optionsContent.value = contList.join('\n');
+		    VxeUI.modal.open({
+		      title: "".concat(widget.title, " - ").concat(VxeUI.getI18n('vxe.formDesign.widgetProp.dataSource.batchEditOption')),
+		      width: 500,
+		      height: '50vh ',
+		      resize: true,
+		      showFooter: true,
+		      showCancelButton: true,
+		      showConfirmButton: true,
+		      confirmButtonText: VxeUI.getI18n('vxe.formDesign.widgetProp.dataSource.buildOption'),
+		      onConfirm: confirmBatchAddOptionEvent,
+		      slots: {
+		        "default": function _default() {
+		          return (0, _vue.h)('div', {
+		            "class": 'vxe-form-design--widget-form-item-data-source-popup'
+		          }, [(0, _vue.h)(VxeUITipComponent, {
+		            status: 'primary',
+		            title: '',
+		            content: VxeUI.getI18n("vxe.formDesign.widgetProp.dataSource.".concat(isSubOption ? 'batchEditSubTip' : 'batchEditTip'))
+		          }), (0, _vue.h)(VxeUITextareaComponent, {
+		            resize: 'none',
+		            modelValue: optionsContent.value,
+		            'onUpdate:modelValue': function onUpdateModelValue(val) {
+		              optionsContent.value = val;
+		            }
+		          })]);
+		        }
+		      }
+		    });
+		  };
+		  var renderOption = function renderOption(item, hasFirstLevel, isExpand, gIndex, hasSub, isFirst, isLast) {
+		    return (0, _vue.h)('div', {
+		      "class": ['vxe-form-design--widget-form-item-data-source-option', {
+		        'is--first': isFirst,
+		        'is--last': isLast
+		      }]
+		    }, [(0, _vue.h)('div', {
+		      "class": 'vxe-form-design--widget-expand-btn'
+		    }, hasFirstLevel && hasSub ? [(0, _vue.h)('i', {
+		      "class": isExpand ? VxeUI.getIcon().FORM_DESIGN_WIDGET_OPTION_EXPAND_CLOSE : VxeUI.getIcon().FORM_DESIGN_WIDGET_OPTION_EXPAND_OPEN,
+		      onClick: function onClick() {
+		        toggleExpandOption(item, gIndex);
+		      }
+		    })] : []), (0, _vue.h)('input', {
+		      "class": 'vxe-default-input',
+		      value: item.value,
+		      onInput: function onInput(evnt) {
+		        item.value = evnt.currentTarget.value;
+		      }
+		    }), (0, _vue.h)(VxeUIButtonComponent, {
+		      status: 'danger',
+		      mode: 'text',
+		      icon: VxeUI.getIcon().FORM_DESIGN_WIDGET_DELETE
+		    })]);
+		  };
+		  var renderOptions = function renderOptions() {
+		    var renderParams = props.renderParams;
+		    var widget = renderParams.widget;
+		    var options = widget.options;
+		    var groups = options.options;
+		    var optVNs = [];
+		    if (groups) {
+		      groups.forEach(function (group, gIndex) {
+		        var options = group.options;
+		        var isExpand = expandIndexList.value.includes(gIndex);
+		        if (options && options.length) {
+		          optVNs.push(renderOption(group, true, isExpand, gIndex, true, gIndex === 0, gIndex === groups.length - 1));
+		          if (isExpand) {
+		            optVNs.push((0, _vue.h)('div', {
+		              "class": 'vxe-form-design--widget-form-item-data-source-sub-option'
+		            }, options.map(function (item) {
+		              return renderOption(item, false, isExpand, 0, false, false, false);
+		            })));
+		          }
+		        } else {
+		          optVNs.push(renderOption(group, true, isExpand, gIndex, false, gIndex === 0, gIndex === groups.length - 1));
+		        }
+		      });
+		    }
+		    return optVNs;
+		  };
+		  (0, _vue.watch)(function () {
+		    return props.renderParams.widget;
+		  }, function () {
+		    expandAllOption();
+		  });
+		  (0, _vue.onMounted)(function () {
+		    expandAllOption();
+		  });
+		  return {
+		    renderDataSourceFormItem: function renderDataSourceFormItem() {
+		      return (0, _vue.h)(VxeUIFormItemComponent, {
+		        title: VxeUI.getI18n('vxe.formDesign.widgetProp.dataSource.name'),
+		        field: 'options'
+		      }, {
+		        "default": function _default() {
+		          return [(0, _vue.h)('div', {}, [(0, _vue.h)(VxeUIButtonComponent, {
+		            status: 'primary',
+		            mode: 'text',
+		            content: VxeUI.getI18n('vxe.formDesign.widgetProp.dataSource.addOption'),
+		            onClick: addOptionEvent
+		          }), (0, _vue.h)(VxeUIButtonComponent, {
+		            status: 'primary',
+		            mode: 'text',
+		            content: VxeUI.getI18n('vxe.formDesign.widgetProp.dataSource.batchEditOption'),
+		            onClick: openPopupEditEvent
+		          })]), (0, _vue.h)('div', {
+		            "class": 'vxe-form-design--widget-form-item-data-source'
+		          }, renderOptions())];
+		        }
+		      });
+		    }
+		  };
+		}
+		return use;
+	}
+
+	var hasRequiredSelectWidget;
+
+	function requireSelectWidget () {
+		if (hasRequiredSelectWidget) return selectWidget;
+		hasRequiredSelectWidget = 1;
+
+		Object.defineProperty(selectWidget, "__esModule", {
+		  value: true
+		});
+		selectWidget.createWidgetElSelect = createWidgetElSelect;
+		var _vue = require$$0;
+		var _use = requireUse();
+		var _comp = requireComp();
+		var _xeUtils = _interopRequireDefault(require$$3);
+		function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+		function createWidgetElSelect(VxeUI) {
+		  var getWidgetElSelectConfig = function getWidgetElSelectConfig(params) {
+		    return {
+		      title: '下拉框',
+		      icon: 'vxe-icon-select',
+		      options: {
+		        placeholder: '请选择',
+		        options: _xeUtils["default"].range(0, 3).map(function (v, i) {
+		          return {
+		            value: VxeUI.getI18n('vxe.formDesign.widgetProp.dataSource.defValue', [i + 1])
+		          };
+		        })
+		      }
+		    };
+		  };
+		  var WidgetElSelectFormComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormComponent = VxeUI.getComponent('VxeForm');
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var VxeUISwitchComponent = VxeUI.getComponent('VxeSwitch');
+		      var _useWidgetPropDataSou = (0, _use.useWidgetPropDataSource)(VxeUI, props, false),
+		        renderDataSourceFormItem = _useWidgetPropDataSou.renderDataSourceFormItem;
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget;
+		        return (0, _vue.h)(VxeUIFormComponent, {
+		          "class": 'vxe-form-design--widget-render-form-wrapper',
+		          vertical: true,
+		          span: 24,
+		          titleBold: true,
+		          titleOverflow: true,
+		          data: widget.options
+		        }, {
+		          "default": function _default() {
+		            return [(0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.name')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)((0, _comp.getCurrComponent)('el-input'), {
+		                  modelValue: widget.title,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.title = val;
+		                  }
+		                });
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.placeholder'),
+		              field: 'placeholder',
+		              itemRender: {
+		                name: 'ElInput'
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.required')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)(VxeUISwitchComponent, {
+		                  modelValue: widget.required,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.required = val;
+		                  }
+		                });
+		              }
+		            }), renderDataSourceFormItem()];
+		          }
+		        });
+		      };
+		    }
+		  });
+		  var WidgetElSelectViewComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var changeEvent = function changeEvent() {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        if ($formView) {
+		          var itemValue = $formView ? $formView.getItemValue(widget) : null;
+		          $formView.updateWidgetStatus(widget, itemValue);
+		        }
+		      };
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        var options = widget.options;
+		        return (0, _vue.h)(VxeUIFormItemComponent, {
+		          "class": ['vxe-form-design--widget-render-form-item'],
+		          field: widget.field,
+		          title: widget.title
+		        }, {
+		          "default": function _default() {
+		            return (0, _vue.h)((0, _comp.getCurrComponent)('el-select'), {
+		              modelValue: $formView ? $formView.getItemValue(widget) : null,
+		              placeholder: options.placeholder,
+		              onChange: changeEvent,
+		              'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                if ($formView) {
+		                  $formView.setItemValue(widget, val);
+		                }
+		              }
+		            }, {
+		              "default": function _default() {
+		                return options.options ? options.options.map(function (item) {
+		                  return (0, _vue.h)((0, _comp.getCurrComponent)('el-option'), {
+		                    label: item.value,
+		                    value: item.value
+		                  });
+		                }) : [];
+		              }
+		            });
+		          }
+		        });
+		      };
+		    }
+		  });
+		  return {
+		    getWidgetElSelectConfig: getWidgetElSelectConfig,
+		    WidgetElSelectFormComponent: WidgetElSelectFormComponent,
+		    WidgetElSelectViewComponent: WidgetElSelectViewComponent
+		  };
+		}
+		return selectWidget;
+	}
+
+	var radioWidget = {};
+
+	var hasRequiredRadioWidget;
+
+	function requireRadioWidget () {
+		if (hasRequiredRadioWidget) return radioWidget;
+		hasRequiredRadioWidget = 1;
+
+		Object.defineProperty(radioWidget, "__esModule", {
+		  value: true
+		});
+		radioWidget.createWidgetElRadio = createWidgetElRadio;
+		var _vue = require$$0;
+		var _use = requireUse();
+		var _comp = requireComp();
+		var _xeUtils = _interopRequireDefault(require$$3);
+		function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+		function createWidgetElRadio(VxeUI) {
+		  var getWidgetElRadioConfig = function getWidgetElRadioConfig(params) {
+		    return {
+		      title: '单选框',
+		      icon: 'vxe-icon-radio-checked',
+		      options: {
+		        options: _xeUtils["default"].range(0, 3).map(function (v, i) {
+		          return {
+		            value: VxeUI.getI18n('vxe.formDesign.widgetProp.dataSource.defValue', [i + 1])
+		          };
+		        })
+		      }
+		    };
+		  };
+		  var WidgetElRadioFormComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormComponent = VxeUI.getComponent('VxeForm');
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var VxeUISwitchComponent = VxeUI.getComponent('VxeSwitch');
+		      var _useWidgetPropDataSou = (0, _use.useWidgetPropDataSource)(VxeUI, props, false),
+		        renderDataSourceFormItem = _useWidgetPropDataSou.renderDataSourceFormItem;
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget;
+		        return (0, _vue.h)(VxeUIFormComponent, {
+		          "class": 'vxe-form-design--widget-render-form-wrapper',
+		          vertical: true,
+		          span: 24,
+		          titleBold: true,
+		          titleOverflow: true,
+		          data: widget.options
+		        }, {
+		          "default": function _default() {
+		            return [(0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.name')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)((0, _comp.getCurrComponent)('el-input'), {
+		                  modelValue: widget.title,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.title = val;
+		                  }
+		                });
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.placeholder'),
+		              field: 'placeholder',
+		              itemRender: {
+		                name: 'ElInput'
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.required')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)(VxeUISwitchComponent, {
+		                  modelValue: widget.required,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.required = val;
+		                  }
+		                });
+		              }
+		            }), renderDataSourceFormItem()];
+		          }
+		        });
+		      };
+		    }
+		  });
+		  var WidgetElRadioViewComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var changeEvent = function changeEvent() {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        if ($formView) {
+		          var itemValue = $formView ? $formView.getItemValue(widget) : null;
+		          $formView.updateWidgetStatus(widget, itemValue);
+		        }
+		      };
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        var options = widget.options;
+		        return (0, _vue.h)(VxeUIFormItemComponent, {
+		          "class": ['vxe-form-design--widget-render-form-item'],
+		          field: widget.field,
+		          title: widget.title
+		        }, {
+		          "default": function _default() {
+		            return (0, _vue.h)((0, _comp.getCurrComponent)('el-radio-group'), {
+		              modelValue: $formView ? $formView.getItemValue(widget) : null,
+		              onChange: changeEvent,
+		              'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                if ($formView) {
+		                  $formView.setItemValue(widget, val);
+		                }
+		              }
+		            }, {
+		              "default": function _default() {
+		                return options.options ? options.options.map(function (item, index) {
+		                  return (0, _vue.h)((0, _comp.getCurrComponent)('el-radio'), {
+		                    key: index,
+		                    value: item.value
+		                  }, {
+		                    "default": function _default() {
+		                      return "".concat(item.value || '');
+		                    }
+		                  });
+		                }) : [];
+		              }
+		            });
+		          }
+		        });
+		      };
+		    }
+		  });
+		  return {
+		    getWidgetElRadioConfig: getWidgetElRadioConfig,
+		    WidgetElRadioFormComponent: WidgetElRadioFormComponent,
+		    WidgetElRadioViewComponent: WidgetElRadioViewComponent
+		  };
+		}
+		return radioWidget;
+	}
+
+	var checkboxWidget = {};
+
+	var hasRequiredCheckboxWidget;
+
+	function requireCheckboxWidget () {
+		if (hasRequiredCheckboxWidget) return checkboxWidget;
+		hasRequiredCheckboxWidget = 1;
+
+		Object.defineProperty(checkboxWidget, "__esModule", {
+		  value: true
+		});
+		checkboxWidget.createWidgetElCheckbox = createWidgetElCheckbox;
+		var _vue = require$$0;
+		var _use = requireUse();
+		var _comp = requireComp();
+		var _xeUtils = _interopRequireDefault(require$$3);
+		function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+		function createWidgetElCheckbox(VxeUI) {
+		  var getWidgetElCheckboxConfig = function getWidgetElCheckboxConfig(params) {
+		    return {
+		      title: '复选框',
+		      icon: 'vxe-icon-checkbox-checked',
+		      options: {
+		        options: _xeUtils["default"].range(0, 3).map(function (v, i) {
+		          return {
+		            value: VxeUI.getI18n('vxe.formDesign.widgetProp.dataSource.defValue', [i + 1])
+		          };
+		        })
+		      }
+		    };
+		  };
+		  var WidgetElCheckboxFormComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormComponent = VxeUI.getComponent('VxeForm');
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var VxeUISwitchComponent = VxeUI.getComponent('VxeSwitch');
+		      var _useWidgetPropDataSou = (0, _use.useWidgetPropDataSource)(VxeUI, props, false),
+		        renderDataSourceFormItem = _useWidgetPropDataSou.renderDataSourceFormItem;
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget;
+		        return (0, _vue.h)(VxeUIFormComponent, {
+		          "class": 'vxe-form-design--widget-render-form-wrapper',
+		          vertical: true,
+		          span: 24,
+		          titleBold: true,
+		          titleOverflow: true,
+		          data: widget.options
+		        }, {
+		          "default": function _default() {
+		            return [(0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.name')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)((0, _comp.getCurrComponent)('el-input'), {
+		                  modelValue: widget.title,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.title = val;
+		                  }
+		                });
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.placeholder'),
+		              field: 'placeholder',
+		              itemRender: {
+		                name: 'ElInput'
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.required')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)(VxeUISwitchComponent, {
+		                  modelValue: widget.required,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.required = val;
+		                  }
+		                });
+		              }
+		            }), renderDataSourceFormItem()];
+		          }
+		        });
+		      };
+		    }
+		  });
+		  var WidgetElCheckboxViewComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var changeEvent = function changeEvent() {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        if ($formView) {
+		          var itemValue = $formView ? $formView.getItemValue(widget) : null;
+		          $formView.updateWidgetStatus(widget, itemValue);
+		        }
+		      };
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        var options = widget.options;
+		        return (0, _vue.h)(VxeUIFormItemComponent, {
+		          "class": ['vxe-form-design--widget-render-form-item'],
+		          field: widget.field,
+		          title: widget.title
+		        }, {
+		          "default": function _default() {
+		            return (0, _vue.h)((0, _comp.getCurrComponent)('el-checkbox-group'), {
+		              modelValue: $formView ? $formView.getItemValue(widget) : null,
+		              onChange: changeEvent,
+		              'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                if ($formView) {
+		                  $formView.setItemValue(widget, val);
+		                }
+		              }
+		            }, {
+		              "default": function _default() {
+		                return options.options ? options.options.map(function (item, index) {
+		                  return (0, _vue.h)((0, _comp.getCurrComponent)('el-checkbox'), {
+		                    key: index,
+		                    value: item.value
+		                  }, {
+		                    "default": function _default() {
+		                      return "".concat(item.value);
+		                    }
+		                  });
+		                }) : [];
+		              }
+		            });
+		          }
+		        });
+		      };
+		    }
+		  });
+		  return {
+		    getWidgetElCheckboxConfig: getWidgetElCheckboxConfig,
+		    WidgetElCheckboxFormComponent: WidgetElCheckboxFormComponent,
+		    WidgetElCheckboxViewComponent: WidgetElCheckboxViewComponent
+		  };
+		}
+		return checkboxWidget;
+	}
+
+	var switchWidget = {};
+
+	var hasRequiredSwitchWidget;
+
+	function requireSwitchWidget () {
+		if (hasRequiredSwitchWidget) return switchWidget;
+		hasRequiredSwitchWidget = 1;
+
+		Object.defineProperty(switchWidget, "__esModule", {
+		  value: true
+		});
+		switchWidget.createWidgetElSwitch = createWidgetElSwitch;
+		var _vue = require$$0;
+		var _comp = requireComp();
+		function createWidgetElSwitch(VxeUI) {
+		  var getWidgetElSwitchConfig = function getWidgetElSwitchConfig(params) {
+		    return {
+		      title: '是/否',
+		      icon: 'vxe-icon-switch',
+		      options: {}
+		    };
+		  };
+		  var WidgetElSwitchFormComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormComponent = VxeUI.getComponent('VxeForm');
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var VxeUISwitchComponent = VxeUI.getComponent('VxeSwitch');
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget;
+		        return (0, _vue.h)(VxeUIFormComponent, {
+		          "class": 'vxe-form-design--widget-render-form-wrapper',
+		          vertical: true,
+		          span: 24,
+		          titleBold: true,
+		          titleOverflow: true,
+		          data: widget.options
+		        }, {
+		          "default": function _default() {
+		            return [(0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.name')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)((0, _comp.getCurrComponent)('el-input'), {
+		                  modelValue: widget.title,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.title = val;
+		                  }
+		                });
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.placeholder'),
+		              field: 'placeholder',
+		              itemRender: {
+		                name: 'ElInput'
+		              }
+		            }), (0, _vue.h)(VxeUIFormItemComponent, {
+		              title: VxeUI.getI18n('vxe.formDesign.widgetProp.required')
+		            }, {
+		              "default": function _default() {
+		                return (0, _vue.h)(VxeUISwitchComponent, {
+		                  modelValue: widget.required,
+		                  'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                    widget.required = val;
+		                  }
+		                });
+		              }
+		            })];
+		          }
+		        });
+		      };
+		    }
+		  });
+		  var WidgetElSwitchViewComponent = (0, _vue.defineComponent)({
+		    props: {
+		      renderOpts: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      },
+		      renderParams: {
+		        type: Object,
+		        "default": function _default() {
+		          return {};
+		        }
+		      }
+		    },
+		    emits: [],
+		    setup: function setup(props) {
+		      var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
+		      var changeEvent = function changeEvent() {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        if ($formView) {
+		          var itemValue = $formView ? $formView.getItemValue(widget) : null;
+		          $formView.updateWidgetStatus(widget, itemValue);
+		        }
+		      };
+		      return function () {
+		        var renderParams = props.renderParams;
+		        var widget = renderParams.widget,
+		          $formView = renderParams.$formView;
+		        return (0, _vue.h)(VxeUIFormItemComponent, {
+		          "class": ['vxe-form-design--widget-render-form-item'],
+		          field: widget.field,
+		          title: widget.title
+		        }, {
+		          "default": function _default() {
+		            return (0, _vue.h)((0, _comp.getCurrComponent)('el-switch'), {
+		              modelValue: $formView ? $formView.getItemValue(widget) : null,
+		              onChange: changeEvent,
+		              'onUpdate:modelValue': function onUpdateModelValue(val) {
+		                if ($formView) {
+		                  $formView.setItemValue(widget, val);
+		                }
+		              }
+		            });
+		          }
+		        });
+		      };
+		    }
+		  });
+		  return {
+		    getWidgetElSwitchConfig: getWidgetElSwitchConfig,
+		    WidgetElSwitchFormComponent: WidgetElSwitchFormComponent,
+		    WidgetElSwitchViewComponent: WidgetElSwitchViewComponent
+		  };
+		}
+		return switchWidget;
+	}
+
+	var hasRequiredFormDesign;
+
+	function requireFormDesign () {
+		if (hasRequiredFormDesign) return formDesign;
+		hasRequiredFormDesign = 1;
+
+		Object.defineProperty(formDesign, "__esModule", {
+		  value: true
+		});
+		formDesign.defineFormDesignRender = defineFormDesignRender;
+		var _vue = require$$0;
+		var _inputWidget = requireInputWidget();
+		var _textareaWidget = requireTextareaWidget();
+		var _numberInputWidget = requireNumberInputWidget();
+		var _datePickerWidget = requireDatePickerWidget();
+		var _selectWidget = requireSelectWidget();
+		var _radioWidget = requireRadioWidget();
+		var _checkboxWidget = requireCheckboxWidget();
+		var _switchWidget = requireSwitchWidget();
+		/**
+		 * 表单设计器 - 渲染器
+		 */
+		function defineFormDesignRender(VxeUI) {
+		  var _createWidgetElInput = (0, _inputWidget.createWidgetElInput)(VxeUI),
+		    getWidgetElInputConfig = _createWidgetElInput.getWidgetElInputConfig,
+		    WidgetElInputViewComponent = _createWidgetElInput.WidgetElInputViewComponent,
+		    WidgetElInputFormComponent = _createWidgetElInput.WidgetElInputFormComponent;
+		  var _createWidgetElTextar = (0, _textareaWidget.createWidgetElTextarea)(VxeUI),
+		    getWidgetElTextareaConfig = _createWidgetElTextar.getWidgetElTextareaConfig,
+		    WidgetElTextareaViewComponent = _createWidgetElTextar.WidgetElTextareaViewComponent,
+		    WidgetElTextareaFormComponent = _createWidgetElTextar.WidgetElTextareaFormComponent;
+		  var _createWidgetElInputN = (0, _numberInputWidget.createWidgetElInputNumber)(VxeUI),
+		    getWidgetElInputNumberConfig = _createWidgetElInputN.getWidgetElInputNumberConfig,
+		    WidgetElInputNumberViewComponent = _createWidgetElInputN.WidgetElInputNumberViewComponent,
+		    WidgetElInputNumberFormComponent = _createWidgetElInputN.WidgetElInputNumberFormComponent;
+		  var _createWidgetElDatePi = (0, _datePickerWidget.createWidgetElDatePicker)(VxeUI),
+		    getWidgetElDatePickerConfig = _createWidgetElDatePi.getWidgetElDatePickerConfig,
+		    WidgetElDatePickerViewComponent = _createWidgetElDatePi.WidgetElDatePickerViewComponent,
+		    WidgetElDatePickerFormComponent = _createWidgetElDatePi.WidgetElDatePickerFormComponent;
+		  var _createWidgetElSelect = (0, _selectWidget.createWidgetElSelect)(VxeUI),
+		    getWidgetElSelectConfig = _createWidgetElSelect.getWidgetElSelectConfig,
+		    WidgetElSelectViewComponent = _createWidgetElSelect.WidgetElSelectViewComponent,
+		    WidgetElSelectFormComponent = _createWidgetElSelect.WidgetElSelectFormComponent;
+		  var _createWidgetElRadio = (0, _radioWidget.createWidgetElRadio)(VxeUI),
+		    getWidgetElRadioConfig = _createWidgetElRadio.getWidgetElRadioConfig,
+		    WidgetElRadioViewComponent = _createWidgetElRadio.WidgetElRadioViewComponent,
+		    WidgetElRadioFormComponent = _createWidgetElRadio.WidgetElRadioFormComponent;
+		  var _createWidgetElCheckb = (0, _checkboxWidget.createWidgetElCheckbox)(VxeUI),
+		    getWidgetElCheckboxConfig = _createWidgetElCheckb.getWidgetElCheckboxConfig,
+		    WidgetElCheckboxViewComponent = _createWidgetElCheckb.WidgetElCheckboxViewComponent,
+		    WidgetElCheckboxFormComponent = _createWidgetElCheckb.WidgetElCheckboxFormComponent;
+		  var _createWidgetElSwitch = (0, _switchWidget.createWidgetElSwitch)(VxeUI),
+		    getWidgetElSwitchConfig = _createWidgetElSwitch.getWidgetElSwitchConfig,
+		    WidgetElSwitchViewComponent = _createWidgetElSwitch.WidgetElSwitchViewComponent,
+		    WidgetElSwitchFormComponent = _createWidgetElSwitch.WidgetElSwitchFormComponent;
+		  VxeUI.renderer.mixin({
+		    ElInputWidget: {
+		      createFormDesignWidgetConfig: getWidgetElInputConfig,
+		      renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElInputViewComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      },
+		      renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElInputFormComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      }
+		    },
+		    ElTextareaWidget: {
+		      createFormDesignWidgetConfig: getWidgetElTextareaConfig,
+		      renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElTextareaViewComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      },
+		      renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElTextareaFormComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      }
+		    },
+		    ElNumberInputWidget: {
+		      createFormDesignWidgetConfig: getWidgetElInputNumberConfig,
+		      renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElInputNumberViewComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      },
+		      renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElInputNumberFormComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      }
+		    },
+		    ElDatePickerWidget: {
+		      createFormDesignWidgetConfig: getWidgetElDatePickerConfig,
+		      renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElDatePickerViewComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      },
+		      renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElDatePickerFormComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      }
+		    },
+		    ElSelectWidget: {
+		      createFormDesignWidgetConfig: getWidgetElSelectConfig,
+		      renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElSelectViewComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      },
+		      renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElSelectFormComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      }
+		    },
+		    ElRadioWidget: {
+		      createFormDesignWidgetConfig: getWidgetElRadioConfig,
+		      renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElRadioViewComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      },
+		      renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElRadioFormComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      }
+		    },
+		    ElCheckboxWidget: {
+		      createFormDesignWidgetConfig: getWidgetElCheckboxConfig,
+		      createFormDesignWidgetFieldValue: function createFormDesignWidgetFieldValue() {
+		        return [];
+		      },
+		      renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElCheckboxViewComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      },
+		      renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElCheckboxFormComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      }
+		    },
+		    ElSwitchWidget: {
+		      createFormDesignWidgetConfig: getWidgetElSwitchConfig,
+		      renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElSwitchViewComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      },
+		      renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+		        return (0, _vue.h)(WidgetElSwitchFormComponent, {
+		          renderOpts: renderOpts,
+		          renderParams: renderParams
+		        });
+		      }
+		    }
+		  });
+		}
+		return formDesign;
+	}
+
+	var hasRequiredLib;
+
+	function requireLib () {
+		if (hasRequiredLib) return lib;
+		hasRequiredLib = 1;
+		(function (exports$1) {
+
+			Object.defineProperty(exports$1, "__esModule", {
+			  value: true
+			});
+			exports$1["default"] = exports$1.VxeUIPluginRenderElement = void 0;
+			var _table = requireTable();
+			var _form = requireForm();
+			var _formDesign = requireFormDesign();
+			var _store = requireStore();
+			var _xeUtils = _interopRequireDefault(require$$3);
+			function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+			function getEventTarget(evnt) {
+			  var target = evnt.target;
+			  if (target && target.shadowRoot && evnt.composed) {
+			    return evnt.composedPath()[0] || target;
+			  }
+			  return target;
+			}
+			/**
+			 * 检查触发源是否属于目标节点
+			 */
+			function getEventTargetNode(evnt, container, className) {
+			  var targetElem;
+			  var target = getEventTarget(evnt);
+			  var rootEl = document.documentElement || document.querySelector('html');
+			  while (target && target.nodeType && target !== rootEl) {
+			    if (className && target.className && target.className.split && target.className.split(' ').indexOf(className) > -1) {
+			      targetElem = target;
+			    } else if (target === container) {
+			      return {
+			        flag: className ? !!targetElem : true,
+			        container: container,
+			        targetElem: targetElem
+			      };
+			    }
+			    target = target.parentElement;
+			  }
+			  return {
+			    flag: false
+			  };
+			}
+			function toComponentName(name) {
+			  if (name) {
+			    return name.slice(0, 1).toUpperCase() + name.slice(1);
+			  }
+			  return name;
+			}
+			var VxeUIPluginRenderElement = exports$1.VxeUIPluginRenderElement = {
+			  component: function component(comp) {
+			    if (comp && comp.name) {
+			      var kcName = _xeUtils["default"].kebabCase(comp.name);
+			      var ccName = toComponentName(_xeUtils["default"].camelCase(comp.name));
+			      _store.componentMaps[kcName] = comp;
+			      _store.componentMaps[ccName] = comp;
+			    } else {
+			      console.error('[@vxe-ui/plugin-render-element 4.3.0] error component.', comp);
+			    }
+			  },
+			  install: function install(VxeUI, options) {
+			    var pluginOpts = Object.assign({}, options);
+			    if (options) {
+			      options.ElementPlus;
+			      Object.assign(_store.globalConfig, options);
+			    }
+			    // 检查版本
+			    if (VxeUI.checkVersion) {
+			      var pVersion = 4;
+			      var sVersion = 11;
+			      if (!VxeUI.checkVersion(VxeUI.tableVersion, pVersion, sVersion)) {
+			        console.error("[@vxe-ui/plugin-render-element 4.3.0] ".concat(VxeUI.getI18n('vxe.error.errorVersion', ["vxe-table@".concat(VxeUI.tableVersion || '?'), "vxe-table v".concat(pVersion, ".").concat(sVersion, "+")]), " https://vxeui.com/other4/#/plugin-render-element/install"));
+			      }
+			    } else {
+			      if (!/^(4)\./.test(VxeUI.uiVersion || VxeUI.tableVersion)) {
+			        console.error('[@vxe-ui/plugin-render-element 4.3.0] Requires vxe-table 4.7.0+ version. https://vxeui.com/other4/#/plugin-render-element/install');
+			      }
+			    }
+			    /**
+			     * 事件兼容性处理
+			     */
+			    function handleClearEvent(params) {
+			      var $event = params.$event;
+			      var bodyElem = document.body;
+			      var prefixCls = "".concat(pluginOpts.prefixCls || 'el').replace(/-$/, '');
+			      if (
+			      // 远程搜索
+			      getEventTargetNode($event, bodyElem, "".concat(prefixCls, "-autocomplete-suggestion")).flag ||
+			      // 下拉框
+			      getEventTargetNode($event, bodyElem, "".concat(prefixCls, "-select-dropdown")).flag ||
+			      // 级联
+			      getEventTargetNode($event, bodyElem, "".concat(prefixCls, "-cascader__dropdown")).flag || getEventTargetNode($event, bodyElem, "".concat(prefixCls, "-cascader-menus")).flag ||
+			      // 日期
+			      getEventTargetNode($event, bodyElem, "".concat(prefixCls, "-time-panel")).flag || getEventTargetNode($event, bodyElem, "".concat(prefixCls, "-picker-panel")).flag ||
+			      // 颜色
+			      getEventTargetNode($event, bodyElem, "".concat(prefixCls, "-color-dropdown")).flag) {
+			        return false;
+			      }
+			    }
+			    (0, _table.defineTableRender)(VxeUI);
+			    (0, _form.defineFormRender)(VxeUI);
+			    (0, _formDesign.defineFormDesignRender)(VxeUI);
+			    VxeUI.interceptor.add('event.clearFilter', handleClearEvent);
+			    VxeUI.interceptor.add('event.clearEdit', handleClearEvent);
+			    VxeUI.interceptor.add('event.clearAreas', handleClearEvent);
+			    // 兼容老版本
+			    VxeUI.interceptor.add('event.clearActived', handleClearEvent);
+			  }
+			};
+			if (typeof window !== 'undefined') {
+			  if (window.VxeUI && window.VxeUI.use) {
+			    window.VxeUI.use(VxeUIPluginRenderElement);
+			  }
+			  if (window.ElementPlus) {
+			    _store.globalConfig.ElementPlus = window.ElementPlus;
+			  }
+			}
+			exports$1["default"] = VxeUIPluginRenderElement; 
+		} (lib));
+		return lib;
+	}
+
+	var libExports = requireLib();
+	var index = /*@__PURE__*/getDefaultExportFromCjs(libExports);
+
+	return index;
+
+}));