@vxe-ui/plugin-render-antd 4.0.3 → 4.0.5

package/dist/index.umd.js

@@ -42,22 +42,1158 @@
     1: [function (require, module, exports) {
       "use strict";
 
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.createWidgetACheckbox = createWidgetACheckbox;
+      var _vue = require("vue");
+      var _use = require("./use");
+      var _xeUtils = _interopRequireDefault(require("xe-utils"));
+      function _interopRequireDefault(e) {
+        return e && e.__esModule ? e : {
+          "default": e
+        };
+      }
+      function createWidgetACheckbox(VxeUI) {
+        var getWidgetACheckboxConfig = function getWidgetACheckboxConfig(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 WidgetACheckboxFormComponent = (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 VxeUIInputComponent = VxeUI.getComponent('VxeInput');
+            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)(VxeUIInputComponent, {
+                        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 WidgetACheckboxViewComponent = (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 checkboxOptions = (0, _vue.computed)(function () {
+              var renderParams = props.renderParams;
+              var widget = renderParams.widget;
+              var options = widget.options;
+              return options.options.map(function (item) {
+                return {
+                  label: item.value,
+                  value: item.value
+                };
+              });
+            });
+            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.updateItemStatus(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, _vue.resolveComponent)('a-checkbox-group'), {
+                    value: $formView ? $formView.getItemValue(widget) : null,
+                    options: checkboxOptions.value,
+                    onChange: changeEvent,
+                    'onUpdate:value': function onUpdateValue(val) {
+                      if ($formView) {
+                        $formView.setItemValue(widget, val);
+                      }
+                    }
+                  });
+                }
+              });
+            };
+          }
+        });
+        return {
+          getWidgetACheckboxConfig: getWidgetACheckboxConfig,
+          WidgetACheckboxFormComponent: WidgetACheckboxFormComponent,
+          WidgetACheckboxViewComponent: WidgetACheckboxViewComponent
+        };
+      }
+    }, {
+      "./use": 10,
+      "vue": "vue",
+      "xe-utils": "xe-utils"
+    }],
+    2: [function (require, module, exports) {
+      "use strict";
+
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
       exports.createWidgetADatePicker = createWidgetADatePicker;
       var _vue = require("vue");
-      function createWidgetADatePicker(VxeUI) {
-        var getWidgetADatePickerConfig = function getWidgetADatePickerConfig(params) {
+      function createWidgetADatePicker(VxeUI) {
+        var getWidgetADatePickerConfig = function getWidgetADatePickerConfig(params) {
+          return {
+            title: '日期',
+            icon: 'vxe-icon-input',
+            options: {
+              placeholder: ''
+            }
+          };
+        };
+        var WidgetADatePickerFormComponent = (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 VxeUIInputComponent = VxeUI.getComponent('VxeInput');
+            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)(VxeUIInputComponent, {
+                        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: 'VxeInput'
+                    }
+                  }), (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 WidgetADatePickerViewComponent = (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.updateItemStatus(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, _vue.resolveComponent)('a-date-picker'), {
+                    value: $formView ? $formView.getItemValue(widget) : null,
+                    placeholder: options.placeholder,
+                    onChange: changeEvent,
+                    'onUpdate:value': function onUpdateValue(val) {
+                      if ($formView) {
+                        $formView.setItemValue(widget, val);
+                      }
+                    }
+                  });
+                }
+              });
+            };
+          }
+        });
+        return {
+          getWidgetADatePickerConfig: getWidgetADatePickerConfig,
+          WidgetADatePickerFormComponent: WidgetADatePickerFormComponent,
+          WidgetADatePickerViewComponent: WidgetADatePickerViewComponent
+        };
+      }
+    }, {
+      "vue": "vue"
+    }],
+    3: [function (require, module, exports) {
+      "use strict";
+
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.defineFormDesignRender = defineFormDesignRender;
+      var _vue = require("vue");
+      var _inputWidget = require("./input-widget");
+      var _textareaWidget = require("./textarea-widget");
+      var _numberInputWidget = require("./number-input-widget");
+      var _datePickerWidget = require("./date-picker-widget");
+      var _selectWidget = require("./select-widget");
+      var _radioWidget = require("./radio-widget");
+      var _checkboxWidget = require("./checkbox-widget");
+      var _switchWidget = require("./switch-widget");
+      /**
+       * 表单设计器 - 渲染器
+       */
+      function defineFormDesignRender(VxeUI) {
+        var _createWidgetAInput = (0, _inputWidget.createWidgetAInput)(VxeUI),
+          getWidgetAInputConfig = _createWidgetAInput.getWidgetAInputConfig,
+          WidgetAInputViewComponent = _createWidgetAInput.WidgetAInputViewComponent,
+          WidgetAInputFormComponent = _createWidgetAInput.WidgetAInputFormComponent;
+        var _createWidgetATextare = (0, _textareaWidget.createWidgetATextarea)(VxeUI),
+          getWidgetATextareaConfig = _createWidgetATextare.getWidgetATextareaConfig,
+          WidgetATextareaViewComponent = _createWidgetATextare.WidgetATextareaViewComponent,
+          WidgetATextareaFormComponent = _createWidgetATextare.WidgetATextareaFormComponent;
+        var _createWidgetAInputNu = (0, _numberInputWidget.createWidgetAInputNumber)(VxeUI),
+          getWidgetAInputNumberConfig = _createWidgetAInputNu.getWidgetAInputNumberConfig,
+          WidgetAInputNumberViewComponent = _createWidgetAInputNu.WidgetAInputNumberViewComponent,
+          WidgetAInputNumberFormComponent = _createWidgetAInputNu.WidgetAInputNumberFormComponent;
+        var _createWidgetADatePic = (0, _datePickerWidget.createWidgetADatePicker)(VxeUI),
+          getWidgetADatePickerConfig = _createWidgetADatePic.getWidgetADatePickerConfig,
+          WidgetADatePickerViewComponent = _createWidgetADatePic.WidgetADatePickerViewComponent,
+          WidgetADatePickerFormComponent = _createWidgetADatePic.WidgetADatePickerFormComponent;
+        var _createWidgetASelect = (0, _selectWidget.createWidgetASelect)(VxeUI),
+          getWidgetASelectConfig = _createWidgetASelect.getWidgetASelectConfig,
+          WidgetASelectViewComponent = _createWidgetASelect.WidgetASelectViewComponent,
+          WidgetASelectFormComponent = _createWidgetASelect.WidgetASelectFormComponent;
+        var _createWidgetARadio = (0, _radioWidget.createWidgetARadio)(VxeUI),
+          getWidgetARadioConfig = _createWidgetARadio.getWidgetARadioConfig,
+          WidgetARadioViewComponent = _createWidgetARadio.WidgetARadioViewComponent,
+          WidgetARadioFormComponent = _createWidgetARadio.WidgetARadioFormComponent;
+        var _createWidgetACheckbo = (0, _checkboxWidget.createWidgetACheckbox)(VxeUI),
+          getWidgetACheckboxConfig = _createWidgetACheckbo.getWidgetACheckboxConfig,
+          WidgetACheckboxViewComponent = _createWidgetACheckbo.WidgetACheckboxViewComponent,
+          WidgetACheckboxFormComponent = _createWidgetACheckbo.WidgetACheckboxFormComponent;
+        var _createWidgetASwitch = (0, _switchWidget.createWidgetASwitch)(VxeUI),
+          getWidgetASwitchConfig = _createWidgetASwitch.getWidgetASwitchConfig,
+          WidgetASwitchViewComponent = _createWidgetASwitch.WidgetASwitchViewComponent,
+          WidgetASwitchFormComponent = _createWidgetASwitch.WidgetASwitchFormComponent;
+        VxeUI.renderer.mixin({
+          AInputWidget: {
+            createFormDesignWidgetConfig: getWidgetAInputConfig,
+            renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetAInputViewComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            },
+            renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetAInputFormComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            }
+          },
+          ATextareaWidget: {
+            createFormDesignWidgetConfig: getWidgetATextareaConfig,
+            renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetATextareaViewComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            },
+            renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetATextareaFormComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            }
+          },
+          ANumberInputWidget: {
+            createFormDesignWidgetConfig: getWidgetAInputNumberConfig,
+            renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetAInputNumberViewComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            },
+            renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetAInputNumberFormComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            }
+          },
+          ADatePickerWidget: {
+            createFormDesignWidgetConfig: getWidgetADatePickerConfig,
+            renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetADatePickerViewComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            },
+            renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetADatePickerFormComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            }
+          },
+          ASelectWidget: {
+            createFormDesignWidgetConfig: getWidgetASelectConfig,
+            renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetASelectViewComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            },
+            renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetASelectFormComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            }
+          },
+          ARadioWidget: {
+            createFormDesignWidgetConfig: getWidgetARadioConfig,
+            renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetARadioViewComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            },
+            renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetARadioFormComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            }
+          },
+          ACheckboxWidget: {
+            createFormDesignWidgetConfig: getWidgetACheckboxConfig,
+            createFormDesignWidgetFieldValue: function createFormDesignWidgetFieldValue() {
+              return [];
+            },
+            renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetACheckboxViewComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            },
+            renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetACheckboxFormComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            }
+          },
+          ASwitchWidget: {
+            createFormDesignWidgetConfig: getWidgetASwitchConfig,
+            renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetASwitchViewComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            },
+            renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
+              return (0, _vue.h)(WidgetASwitchFormComponent, {
+                renderOpts: renderOpts,
+                renderParams: renderParams
+              });
+            }
+          }
+        });
+      }
+    }, {
+      "./checkbox-widget": 1,
+      "./date-picker-widget": 2,
+      "./input-widget": 4,
+      "./number-input-widget": 5,
+      "./radio-widget": 6,
+      "./select-widget": 7,
+      "./switch-widget": 8,
+      "./textarea-widget": 9,
+      "vue": "vue"
+    }],
+    4: [function (require, module, exports) {
+      "use strict";
+
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.createWidgetAInput = createWidgetAInput;
+      var _vue = require("vue");
+      function createWidgetAInput(VxeUI) {
+        var getWidgetAInputConfig = function getWidgetAInputConfig(params) {
+          return {
+            title: '输入框',
+            icon: 'vxe-icon-input',
+            options: {
+              placeholder: ''
+            }
+          };
+        };
+        var WidgetAInputFormComponent = (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 VxeUIInputComponent = VxeUI.getComponent('VxeInput');
+            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)(VxeUIInputComponent, {
+                        modelValue: widget.title,
+                        placeholder: options.placeholder,
+                        'onUpdate:modelValue': function onUpdateModelValue(val) {
+                          widget.title = val;
+                        }
+                      });
+                    }
+                  }), (0, _vue.h)(VxeUIFormItemComponent, {
+                    title: VxeUI.getI18n('vxe.formDesign.widgetProp.placeholder'),
+                    field: 'placeholder',
+                    itemRender: {
+                      name: 'VxeInput'
+                    }
+                  }), (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 WidgetAInputViewComponent = (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.updateItemStatus(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, _vue.resolveComponent)('a-input'), {
+                    value: $formView ? $formView.getItemValue(widget) : null,
+                    onChange: changeEvent,
+                    'onUpdate:value': function onUpdateValue(val) {
+                      if ($formView) {
+                        $formView.setItemValue(widget, val);
+                      }
+                    }
+                  });
+                }
+              });
+            };
+          }
+        });
+        return {
+          getWidgetAInputConfig: getWidgetAInputConfig,
+          WidgetAInputFormComponent: WidgetAInputFormComponent,
+          WidgetAInputViewComponent: WidgetAInputViewComponent
+        };
+      }
+    }, {
+      "vue": "vue"
+    }],
+    5: [function (require, module, exports) {
+      "use strict";
+
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.createWidgetAInputNumber = createWidgetAInputNumber;
+      var _vue = require("vue");
+      function createWidgetAInputNumber(VxeUI) {
+        var getWidgetAInputNumberConfig = function getWidgetAInputNumberConfig(params) {
+          return {
+            title: '数字',
+            icon: 'vxe-icon-number',
+            options: {
+              placeholder: '请输入'
+            }
+          };
+        };
+        var WidgetAInputNumberFormComponent = (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 VxeUIInputComponent = VxeUI.getComponent('VxeInput');
+            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)(VxeUIInputComponent, {
+                        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 WidgetAInputNumberViewComponent = (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.updateItemStatus(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, _vue.resolveComponent)('a-input-number'), {
+                    value: $formView ? $formView.getItemValue(widget) : null,
+                    placeholder: options.placeholder,
+                    onChange: changeEvent,
+                    'onUpdate:value': function onUpdateValue(val) {
+                      if ($formView) {
+                        $formView.setItemValue(widget, val);
+                      }
+                    }
+                  });
+                }
+              });
+            };
+          }
+        });
+        return {
+          getWidgetAInputNumberConfig: getWidgetAInputNumberConfig,
+          WidgetAInputNumberFormComponent: WidgetAInputNumberFormComponent,
+          WidgetAInputNumberViewComponent: WidgetAInputNumberViewComponent
+        };
+      }
+    }, {
+      "vue": "vue"
+    }],
+    6: [function (require, module, exports) {
+      "use strict";
+
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.createWidgetARadio = createWidgetARadio;
+      var _vue = require("vue");
+      var _use = require("./use");
+      var _xeUtils = _interopRequireDefault(require("xe-utils"));
+      function _interopRequireDefault(e) {
+        return e && e.__esModule ? e : {
+          "default": e
+        };
+      }
+      function createWidgetARadio(VxeUI) {
+        var getWidgetARadioConfig = function getWidgetARadioConfig(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 WidgetARadioFormComponent = (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 VxeUIInputComponent = VxeUI.getComponent('VxeInput');
+            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)(VxeUIInputComponent, {
+                        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 WidgetARadioViewComponent = (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 radioOptions = (0, _vue.computed)(function () {
+              var renderParams = props.renderParams;
+              var widget = renderParams.widget;
+              var options = widget.options;
+              return options.options.map(function (item) {
+                return {
+                  label: item.value,
+                  value: item.value
+                };
+              });
+            });
+            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.updateItemStatus(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, _vue.resolveComponent)('a-radio-group'), {
+                    value: $formView ? $formView.getItemValue(widget) : null,
+                    options: radioOptions.value,
+                    onChange: changeEvent,
+                    'onUpdate:value': function onUpdateValue(val) {
+                      if ($formView) {
+                        $formView.setItemValue(widget, val);
+                      }
+                    }
+                  });
+                }
+              });
+            };
+          }
+        });
+        return {
+          getWidgetARadioConfig: getWidgetARadioConfig,
+          WidgetARadioFormComponent: WidgetARadioFormComponent,
+          WidgetARadioViewComponent: WidgetARadioViewComponent
+        };
+      }
+    }, {
+      "./use": 10,
+      "vue": "vue",
+      "xe-utils": "xe-utils"
+    }],
+    7: [function (require, module, exports) {
+      "use strict";
+
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.createWidgetASelect = createWidgetASelect;
+      var _vue = require("vue");
+      var _use = require("./use");
+      var _xeUtils = _interopRequireDefault(require("xe-utils"));
+      function _interopRequireDefault(e) {
+        return e && e.__esModule ? e : {
+          "default": e
+        };
+      }
+      function createWidgetASelect(VxeUI) {
+        var getWidgetASelectConfig = function getWidgetASelectConfig(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 WidgetASelectFormComponent = (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 VxeUIInputComponent = VxeUI.getComponent('VxeInput');
+            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)(VxeUIInputComponent, {
+                        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 WidgetASelectViewComponent = (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.updateItemStatus(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, _vue.resolveComponent)('a-select'), {
+                    value: $formView ? $formView.getItemValue(widget) : null,
+                    options: options.options,
+                    placeholder: options.placeholder,
+                    onChange: changeEvent,
+                    'onUpdate:value': function onUpdateValue(val) {
+                      if ($formView) {
+                        $formView.setItemValue(widget, val);
+                      }
+                    }
+                  });
+                }
+              });
+            };
+          }
+        });
+        return {
+          getWidgetASelectConfig: getWidgetASelectConfig,
+          WidgetASelectFormComponent: WidgetASelectFormComponent,
+          WidgetASelectViewComponent: WidgetASelectViewComponent
+        };
+      }
+    }, {
+      "./use": 10,
+      "vue": "vue",
+      "xe-utils": "xe-utils"
+    }],
+    8: [function (require, module, exports) {
+      "use strict";
+
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.createWidgetASwitch = createWidgetASwitch;
+      var _vue = require("vue");
+      function createWidgetASwitch(VxeUI) {
+        var getWidgetASwitchConfig = function getWidgetASwitchConfig(params) {
           return {
-            title: '日期',
-            icon: 'vxe-icon-input',
-            options: {
-              placeholder: ''
-            }
+            title: '是/否',
+            icon: 'vxe-icon-switch',
+            options: {}
           };
         };
-        var WidgetADatePickerFormComponent = (0, _vue.defineComponent)({
+        var WidgetASwitchFormComponent = (0, _vue.defineComponent)({
           props: {
             renderOpts: {
               type: Object,
@@ -77,6 +1213,7 @@
             var VxeUIFormComponent = VxeUI.getComponent('VxeForm');
             var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
             var VxeUISwitchComponent = VxeUI.getComponent('VxeSwitch');
+            var VxeUIInputComponent = VxeUI.getComponent('VxeInput');
             return function () {
               var renderParams = props.renderParams;
               var widget = renderParams.widget;
@@ -93,7 +1230,7 @@
                     title: VxeUI.getI18n('vxe.formDesign.widgetProp.name')
                   }, {
                     "default": function _default() {
-                      return (0, _vue.h)((0, _vue.resolveComponent)('a-date-picker'), {
+                      return (0, _vue.h)(VxeUIInputComponent, {
                         modelValue: widget.title,
                         'onUpdate:modelValue': function onUpdateModelValue(val) {
                           widget.title = val;
@@ -104,7 +1241,7 @@
                     title: VxeUI.getI18n('vxe.formDesign.widgetProp.placeholder'),
                     field: 'placeholder',
                     itemRender: {
-                      name: 'VxeInput'
+                      name: 'ElInput'
                     }
                   }), (0, _vue.h)(VxeUIFormItemComponent, {
                     title: VxeUI.getI18n('vxe.formDesign.widgetProp.required')
@@ -123,7 +1260,7 @@
             };
           }
         });
-        var WidgetADatePickerViewComponent = (0, _vue.defineComponent)({
+        var WidgetASwitchViewComponent = (0, _vue.defineComponent)({
           props: {
             renderOpts: {
               type: Object,
@@ -154,18 +1291,16 @@
               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, _vue.resolveComponent)('a-date-picker'), {
-                    modelValue: $formView ? $formView.getItemValue(widget) : null,
-                    placeholder: options.placeholder,
+                  return (0, _vue.h)((0, _vue.resolveComponent)('a-switch'), {
+                    checked: $formView ? $formView.getItemValue(widget) : null,
                     onChange: changeEvent,
-                    'onUpdate:modelValue': function onUpdateModelValue(val) {
+                    'onUpdate:checked': function onUpdateChecked(val) {
                       if ($formView) {
                         $formView.setItemValue(widget, val);
                       }
@@ -177,33 +1312,33 @@
           }
         });
         return {
-          getWidgetADatePickerConfig: getWidgetADatePickerConfig,
-          WidgetADatePickerFormComponent: WidgetADatePickerFormComponent,
-          WidgetADatePickerViewComponent: WidgetADatePickerViewComponent
+          getWidgetASwitchConfig: getWidgetASwitchConfig,
+          WidgetASwitchFormComponent: WidgetASwitchFormComponent,
+          WidgetASwitchViewComponent: WidgetASwitchViewComponent
         };
       }
     }, {
       "vue": "vue"
     }],
-    2: [function (require, module, exports) {
+    9: [function (require, module, exports) {
       "use strict";
 
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
-      exports.createWidgetAInput = createWidgetAInput;
+      exports.createWidgetATextarea = createWidgetATextarea;
       var _vue = require("vue");
-      function createWidgetAInput(VxeUI) {
-        var getWidgetAInputConfig = function getWidgetAInputConfig(params) {
+      function createWidgetATextarea(VxeUI) {
+        var getWidgetATextareaConfig = function getWidgetATextareaConfig(params) {
           return {
-            title: '输入框',
-            icon: 'vxe-icon-input',
+            title: '文本域',
+            icon: 'vxe-icon-textarea',
             options: {
-              placeholder: ''
+              placeholder: '请输入'
             }
           };
         };
-        var WidgetAInputFormComponent = (0, _vue.defineComponent)({
+        var WidgetATextareaFormComponent = (0, _vue.defineComponent)({
           props: {
             renderOpts: {
               type: Object,
@@ -223,26 +1358,25 @@
             var VxeUIFormComponent = VxeUI.getComponent('VxeForm');
             var VxeUIFormItemComponent = VxeUI.getComponent('VxeFormItem');
             var VxeUISwitchComponent = VxeUI.getComponent('VxeSwitch');
+            var VxeUIInputComponent = VxeUI.getComponent('VxeInput');
             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
+                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, _vue.resolveComponent)('a-input'), {
+                      return (0, _vue.h)(VxeUIInputComponent, {
                         modelValue: widget.title,
-                        placeholder: options.placeholder,
                         'onUpdate:modelValue': function onUpdateModelValue(val) {
                           widget.title = val;
                         }
@@ -252,7 +1386,7 @@
                     title: VxeUI.getI18n('vxe.formDesign.widgetProp.placeholder'),
                     field: 'placeholder',
                     itemRender: {
-                      name: 'VxeInput'
+                      name: 'ElInput'
                     }
                   }), (0, _vue.h)(VxeUIFormItemComponent, {
                     title: VxeUI.getI18n('vxe.formDesign.widgetProp.required')
@@ -271,7 +1405,7 @@
             };
           }
         });
-        var WidgetAInputViewComponent = (0, _vue.defineComponent)({
+        var WidgetATextareaViewComponent = (0, _vue.defineComponent)({
           props: {
             renderOpts: {
               type: Object,
@@ -302,16 +1436,22 @@
               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, _vue.resolveComponent)('a-input'), {
-                    modelValue: $formView ? $formView.getItemValue(widget) : null,
+                  return (0, _vue.h)((0, _vue.resolveComponent)('a-textarea'), {
+                    value: $formView ? $formView.getItemValue(widget) : null,
+                    placeholder: options.placeholder,
+                    autoSize: {
+                      minRows: 2,
+                      maxRows: 4
+                    },
                     onChange: changeEvent,
-                    'onUpdate:modelValue': function onUpdateModelValue(val) {
+                    'onUpdate:value': function onUpdateValue(val) {
                       if ($formView) {
                         $formView.setItemValue(widget, val);
                       }
@@ -323,75 +1463,262 @@
           }
         });
         return {
-          getWidgetAInputConfig: getWidgetAInputConfig,
-          WidgetAInputFormComponent: WidgetAInputFormComponent,
-          WidgetAInputViewComponent: WidgetAInputViewComponent
+          getWidgetATextareaConfig: getWidgetATextareaConfig,
+          WidgetATextareaFormComponent: WidgetATextareaFormComponent,
+          WidgetATextareaViewComponent: WidgetATextareaViewComponent
         };
       }
     }, {
       "vue": "vue"
     }],
-    3: [function (require, module, exports) {
+    10: [function (require, module, exports) {
       "use strict";
 
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
-      exports.defineFormDesignRender = defineFormDesignRender;
+      exports.useWidgetPropDataSource = useWidgetPropDataSource;
       var _vue = require("vue");
-      var _aInput = require("./a-input");
-      var _aDatePicker = require("./a-date-picker");
-      /**
-       * 表单设计器 - 渲染器
-       */
-      function defineFormDesignRender(VxeUI) {
-        var _createWidgetAInput = (0, _aInput.createWidgetAInput)(VxeUI),
-          getWidgetAInputConfig = _createWidgetAInput.getWidgetAInputConfig,
-          WidgetAInputViewComponent = _createWidgetAInput.WidgetAInputViewComponent,
-          WidgetAInputFormComponent = _createWidgetAInput.WidgetAInputFormComponent;
-        var _createWidgetADatePic = (0, _aDatePicker.createWidgetADatePicker)(VxeUI),
-          getWidgetADatePickerConfig = _createWidgetADatePic.getWidgetADatePickerConfig,
-          WidgetADatePickerViewComponent = _createWidgetADatePic.WidgetADatePickerViewComponent,
-          WidgetADatePickerFormComponent = _createWidgetADatePic.WidgetADatePickerFormComponent;
-        VxeUI.renderer.mixin({
-          AInput: {
-            createFormDesignWidgetConfig: getWidgetAInputConfig,
-            renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
-              return (0, _vue.h)(WidgetAInputViewComponent, {
-                renderOpts: renderOpts,
-                renderParams: renderParams
-              });
-            },
-            renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
-              return (0, _vue.h)(WidgetAInputFormComponent, {
-                renderOpts: renderOpts,
-                renderParams: renderParams
-              });
+      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);
             }
-          },
-          ADatePicker: {
-            createFormDesignWidgetConfig: getWidgetADatePickerConfig,
-            renderFormDesignWidgetView: function renderFormDesignWidgetView(renderOpts, renderParams) {
-              return (0, _vue.h)(WidgetADatePickerViewComponent, {
-                renderOpts: renderOpts,
-                renderParams: renderParams
-              });
-            },
-            renderFormDesignWidgetFormView: function renderFormDesignWidgetFormView(renderOpts, renderParams) {
-              return (0, _vue.h)(WidgetADatePickerFormComponent, {
-                renderOpts: renderOpts,
-                renderParams: renderParams
+          });
+          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.target.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())];
+              }
+            });
+          }
+        };
       }
     }, {
-      "./a-date-picker": 1,
-      "./a-input": 2,
       "vue": "vue"
     }],
-    4: [function (require, module, exports) {
+    11: [function (require, module, exports) {
       "use strict";
 
       Object.defineProperty(exports, "__esModule", {
@@ -681,7 +2008,7 @@
       "vue": "vue",
       "xe-utils": "xe-utils"
     }],
-    5: [function (require, module, exports) {
+    12: [function (require, module, exports) {
       "use strict";
 
       Object.defineProperty(exports, "__esModule", {
@@ -752,11 +2079,11 @@
       }
       var _default = exports["default"] = VxeUIPluginRenderAntd;
     }, {
-      "./form": 4,
+      "./form": 11,
       "./form-design": 3,
-      "./table": 6
+      "./table": 13
     }],
-    6: [function (require, module, exports) {
+    13: [function (require, module, exports) {
       "use strict";
 
       Object.defineProperty(exports, "__esModule", {
@@ -945,12 +2272,29 @@
             return getCellLabelVNs(renderOpts, params, getDatePickerCellValue(renderOpts, params, defaultFormat));
           };
         }
+        function formatTimePicker(defaultFormat) {
+          return function (renderOpts, params) {
+            var _renderOpts$props = renderOpts.props,
+              props = _renderOpts$props === void 0 ? {} : _renderOpts$props;
+            var row = params.row,
+              column = params.column;
+            var cellValue = _xeUtils["default"].get(row, column.field);
+            try {
+              if (cellValue) {
+                if (!_xeUtils["default"].isString(cellValue)) {
+                  cellValue = cellValue.format ? cellValue.format(props.format || props.valueFormat || defaultFormat) : _xeUtils["default"].toDateString(cellValue, dateFormatToVxeFormat(props.format || props.valueFormat || defaultFormat));
+                }
+              }
+            } catch (e) {}
+            return getCellLabelVNs(renderOpts, params, cellValue);
+          };
+        }
         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$props2 = renderOpts.props,
+            props = _renderOpts$props2 === void 0 ? {} : _renderOpts$props2,
             _renderOpts$optionPro = renderOpts.optionProps,
             optionProps = _renderOpts$optionPro === void 0 ? {} : _renderOpts$optionPro,
             _renderOpts$optionGro = renderOpts.optionGroupProps,
@@ -983,8 +2327,8 @@
           return '';
         }
         function getCascaderCellValue(renderOpts, params) {
-          var _renderOpts$props2 = renderOpts.props,
-            props = _renderOpts$props2 === void 0 ? {} : _renderOpts$props2;
+          var _renderOpts$props3 = renderOpts.props,
+            props = _renderOpts$props3 === void 0 ? {} : _renderOpts$props3;
           var row = params.row,
             column = params.column;
           var cellValue = _xeUtils["default"].get(row, column.field);
@@ -994,8 +2338,8 @@
           return (props.showAllLevels === false ? labels.slice(labels.length - 1, labels.length) : labels).join(" ".concat(props.separator || '/', " "));
         }
         function getRangePickerCellValue(renderOpts, params) {
-          var _renderOpts$props3 = renderOpts.props,
-            props = _renderOpts$props3 === void 0 ? {} : _renderOpts$props3;
+          var _renderOpts$props4 = renderOpts.props,
+            props = _renderOpts$props4 === void 0 ? {} : _renderOpts$props4;
           var row = params.row,
             column = params.column;
           var cellValue = _xeUtils["default"].get(row, column.field);
@@ -1007,8 +2351,8 @@
           return cellValue;
         }
         function getTreeSelectCellValue(renderOpts, params) {
-          var _renderOpts$props4 = renderOpts.props,
-            props = _renderOpts$props4 === void 0 ? {} : _renderOpts$props4;
+          var _renderOpts$props5 = renderOpts.props,
+            props = _renderOpts$props5 === void 0 ? {} : _renderOpts$props5;
           var treeData = props.treeData,
             treeCheckable = props.treeCheckable;
           var row = params.row,
@@ -1027,13 +2371,31 @@
           return cellValue;
         }
         function getDatePickerCellValue(renderOpts, params, defaultFormat) {
-          var _renderOpts$props5 = renderOpts.props,
-            props = _renderOpts$props5 === void 0 ? {} : _renderOpts$props5;
+          var _renderOpts$props6 = renderOpts.props,
+            props = _renderOpts$props6 === void 0 ? {} : _renderOpts$props6;
           var row = params.row,
             column = params.column;
           var cellValue = _xeUtils["default"].get(row, column.field);
           try {
             if (cellValue) {
+              if (!defaultFormat) {
+                if (renderOpts.name === 'ADatePicker') {
+                  switch (props.picker) {
+                    case 'week':
+                      defaultFormat = 'YYYY-WW周';
+                      break;
+                    case 'month':
+                      defaultFormat = 'YYYY-MM';
+                      break;
+                    case 'year':
+                      defaultFormat = 'YYYY';
+                      break;
+                    default:
+                      defaultFormat = props.showTime ? 'YYYY-MM-DD HH:mm:ss' : 'YYYY-MM-DD';
+                      break;
+                  }
+                }
+              }
               cellValue = cellValue.format ? cellValue.format(props.format || defaultFormat) : _xeUtils["default"].toDateString(cellValue, dateFormatToVxeFormat(props.format || defaultFormat));
             }
           } catch (e) {}
@@ -1130,21 +2492,21 @@
         }
         VxeUI.renderer.mixin({
           AAutoComplete: {
-            tableAutoFocus: 'input.ant-input',
+            tableAutoFocus: 'input',
             renderTableDefault: createEditRender(),
             renderTableEdit: createEditRender(),
             renderTableFilter: createFilterRender(),
             tableFilterDefaultMethod: defaultExactFilterMethod
           },
           AInput: {
-            tableAutoFocus: 'input.ant-input',
+            tableAutoFocus: 'input',
             renderTableDefault: createEditRender(),
             renderTableEdit: createEditRender(),
             renderTableFilter: createFilterRender(),
             tableFilterDefaultMethod: defaultFuzzyFilterMethod
           },
           AInputNumber: {
-            tableAutoFocus: 'input.ant-input-number-input',
+            tableAutoFocus: 'input',
             renderTableDefault: createEditRender(),
             renderTableEdit: createEditRender(),
             renderTableFilter: createFilterRender(),
@@ -1214,8 +2576,8 @@
               var data = option.data;
               var field = column.field,
                 renderOpts = column.filterRender;
-              var _renderOpts$props6 = renderOpts.props,
-                props = _renderOpts$props6 === void 0 ? {} : _renderOpts$props6;
+              var _renderOpts$props7 = renderOpts.props,
+                props = _renderOpts$props7 === void 0 ? {} : _renderOpts$props7;
               var cellValue = _xeUtils["default"].get(row, field);
               if (props.mode === 'multiple') {
                 if (_xeUtils["default"].isArray(cellValue)) {
@@ -1237,8 +2599,8 @@
           },
           ADatePicker: {
             renderTableEdit: createEditRender(),
-            renderTableCell: formatDatePicker('YYYY-MM-DD'),
-            tableExportMethod: createDatePickerExportMethod('YYYY-MM-DD')
+            renderTableCell: formatDatePicker(),
+            tableExportMethod: createDatePickerExportMethod()
           },
           AMonthPicker: {
             renderTableEdit: createEditRender(),
@@ -1259,7 +2621,7 @@
           },
           ATimePicker: {
             renderTableEdit: createEditRender(),
-            renderTableCell: formatDatePicker('HH:mm:ss'),
+            renderTableCell: formatTimePicker('HH:mm:ss'),
             tableExportMethod: createDatePickerExportMethod('HH:mm:ss')
           },
           ATreeSelect: {
@@ -1310,5 +2672,5 @@
       "vue": "vue",
       "xe-utils": "xe-utils"
     }]
-  }, {}, [5]);
+  }, {}, [12]);
 });