@tmagic/form 1.0.0-beta.1

package/dist/tmagic-form.umd.js

@@ -0,0 +1,3790 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue'), require('lodash-es'), require('@element-plus/icons'), require('element-plus'), require('sortablejs'), require('@tmagic/utils')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'vue', 'lodash-es', '@element-plus/icons', 'element-plus', 'sortablejs', '@tmagic/utils'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.TMagicForm = {}, global.vue, global.lodashEs, global.icons, global.elementPlus, global.Sortable, global.utils));
+})(this, (function (exports, vue, lodashEs, icons, elementPlus, Sortable, utils) { 'use strict';
+
+  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+  var Sortable__default = /*#__PURE__*/_interopDefaultLegacy(Sortable);
+
+  const isTableSelect = (type) => typeof type === "string" && ["table-select", "tableSelect"].includes(type);
+  const asyncLoadConfig = (value, initValue2, { asyncLoad, name, type }) => {
+    if (type === "html" && typeof asyncLoad === "object" && typeof name !== "undefined") {
+      asyncLoad.name = name;
+      value.asyncLoad = typeof initValue2.asyncLoad === "object" ? initValue2.asyncLoad : asyncLoad;
+    }
+  };
+  const isMultipleValue = (type) => typeof type === "string" && [
+    "checkbox-group",
+    "checkboxGroup",
+    "table",
+    "cascader",
+    "group-list",
+    "groupList",
+    "dynamic-tab",
+    "dynamicTab"
+  ].includes(type);
+  const initItemsValue = (mForm, value, initValue2, { items, name, extensible }) => {
+    if (Array.isArray(initValue2[name])) {
+      value[name] = initValue2[name].map((v) => init(mForm, items, v));
+    } else {
+      value[name] = init(mForm, items, initValue2[name], value[name]);
+      if (extensible) {
+        value[name] = Object.assign({}, initValue2[name], value[name]);
+      }
+    }
+  };
+  const setValue = (mForm, value, initValue2, item) => {
+    const { items, name, type, checkbox } = item;
+    if (isMultipleValue(type)) {
+      value[name] = initValue2[name] || [];
+    }
+    if (items) {
+      initItemsValue(mForm, value, initValue2, item);
+    } else {
+      value[name] = getDefaultValue(mForm, item);
+    }
+    if (type === "fieldset" && checkbox) {
+      if (typeof value[name] === "object") {
+        value[name].value = typeof initValue2[name] === "object" ? initValue2[name].value || 0 : 0;
+      }
+    }
+  };
+  const initValueItem = function(mForm, item, initValue2, value) {
+    const { items } = item;
+    const { names } = item;
+    const { type, name } = item;
+    if (isTableSelect(type) && name) {
+      value[name] = initValue2[name] || "";
+      return value;
+    }
+    asyncLoadConfig(value, initValue2, item);
+    if (name && !items && typeof initValue2[name] !== "undefined") {
+      if (typeof value[name] === "undefined") {
+        value[name] = typeof initValue2[name] === "object" ? lodashEs.cloneDeep(initValue2[name]) : initValue2[name];
+      }
+      return value;
+    }
+    if (names) {
+      return names.forEach((n) => value[n] = initValue2[n] || "");
+    }
+    if (!name) {
+      return init(mForm, items, initValue2, value);
+    }
+    setValue(mForm, value, initValue2, item);
+    return value;
+  };
+  const init = function(mForm, config = [], initValue2 = {}, value = {}) {
+    if (Array.isArray(config)) {
+      config.forEach((item) => {
+        initValueItem(mForm, item, initValue2, value);
+      });
+    }
+    return value;
+  };
+  const getDefaultValue = function(mForm, { defaultValue, type, filter, multiple }) {
+    if (typeof defaultValue === "function") {
+      return defaultValue(mForm);
+    }
+    if (defaultValue === "undefined") {
+      return void 0;
+    }
+    if (typeof defaultValue !== "undefined") {
+      return defaultValue;
+    }
+    if (type === "number" || filter === "number") {
+      return 0;
+    }
+    if (["switch", "checkbox"].includes(type)) {
+      return false;
+    }
+    if (multiple) {
+      return [];
+    }
+    return "";
+  };
+  const filterFunction = (mForm, config, props) => {
+    if (typeof config !== "function") {
+      return config;
+    }
+    return config(mForm, {
+      values: mForm?.initValues || {},
+      model: props.model,
+      parent: mForm?.parentValues || {},
+      formValue: mForm?.values || props.model,
+      prop: props.prop
+    });
+  };
+  const display = function(mForm, config, props) {
+    if (typeof config === "function") {
+      return filterFunction(mForm, config, props);
+    }
+    if (config === false) {
+      return false;
+    }
+    return true;
+  };
+  const getRules = function(mForm, rules = [], props) {
+    rules = lodashEs.cloneDeep(rules);
+    if (typeof rules === "object" && !Array.isArray(rules)) {
+      rules = [rules];
+    }
+    return rules.map((item) => {
+      if (typeof item.validator === "function") {
+        const fnc = item.validator;
+        item.validator = (rule, value, callback, source, options) => fnc({
+          rule,
+          value,
+          callback,
+          source,
+          options
+        }, {
+          values: mForm?.initValues || {},
+          model: props.model,
+          parent: mForm?.parentValues || {},
+          formValue: mForm?.values || props.model,
+          prop: props.prop
+        }, mForm);
+      }
+      return item;
+    });
+  };
+  const initValue = async (mForm, { initValues, config }) => {
+    if (!Array.isArray(config))
+      throw new Error("config\u5E94\u8BE5\u4E3A\u6570\u7EC4");
+    let valuesTmp = init(mForm, config, vue.toRaw(initValues), {});
+    const [firstForm] = config;
+    if (firstForm && typeof firstForm.onInitValue === "function") {
+      valuesTmp = await firstForm.onInitValue(mForm, {
+        formValue: valuesTmp,
+        initValue: initValues
+      });
+    }
+    return valuesTmp || {};
+  };
+
+  var _export_sfc = (sfc, props) => {
+    const target = sfc.__vccOpts || sfc;
+    for (const [key, val] of props) {
+      target[key] = val;
+    }
+    return target;
+  };
+
+  const _sfc_main$s = vue.defineComponent({
+    name: "m-form-container",
+    props: {
+      labelWidth: String,
+      expandMore: Boolean,
+      model: {
+        type: [Object, Array],
+        required: true
+      },
+      config: {
+        type: Object,
+        required: true
+      },
+      prop: {
+        type: String,
+        default: () => ""
+      },
+      stepActive: {
+        type: [String, Number]
+      },
+      size: {
+        type: String,
+        default: "small"
+      }
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      const mForm = vue.inject("mForm");
+      const expand = vue.ref(false);
+      const name = vue.computed(() => props.config.name || "");
+      const items = vue.computed(() => props.config.items);
+      const itemProp = vue.computed(() => name.value ? `${props.prop}${props.prop ? "." : ""}${name.value}` : props.prop);
+      const tagName = vue.computed(() => {
+        const component = vue.resolveComponent(`m-${items.value ? "form" : "fields"}-${type.value}`);
+        if (typeof component !== "string")
+          return component;
+        return "m-fields-text";
+      });
+      const disabled = vue.computed(() => filterFunction(mForm, props.config.disabled, props));
+      const tooltip = vue.computed(() => filterFunction(mForm, props.config.tooltip, props));
+      const extra = vue.computed(() => filterFunction(mForm, props.config.extra, props));
+      const rule = vue.computed(() => getRules(mForm, props.config.rules, props));
+      const type = vue.computed(() => {
+        let { type: type2 } = props.config;
+        if (typeof type2 === "function") {
+          type2 = type2(mForm, {
+            model: props.model
+          });
+        }
+        if (type2 === "form")
+          return "";
+        return type2?.replace(/([A-Z])/g, "-$1").toLowerCase() || (items.value ? "" : "text");
+      });
+      const display$1 = vue.computed(() => {
+        if (props.config.display === "expand") {
+          return expand.value;
+        }
+        return display(mForm, props.config.display, props);
+      });
+      vue.watchEffect(() => {
+        expand.value = props.expandMore;
+      });
+      const expandHandler = () => expand.value = !expand.value;
+      const key = (config) => config[mForm?.keyProps];
+      const filterHandler = (filter, value) => {
+        if (typeof filter === "function") {
+          return filter(mForm, value, {
+            model: props.model,
+            values: mForm?.initValues,
+            formValue: mForm?.values,
+            prop: itemProp.value
+          });
+        }
+        if (filter === "number") {
+          return +value;
+        }
+        return value;
+      };
+      const changeHandler = (onChange, value) => {
+        if (typeof onChange === "function") {
+          return onChange(mForm, value, {
+            model: props.model,
+            values: mForm?.initValues,
+            formValue: mForm?.values,
+            prop: itemProp.value
+          });
+        }
+      };
+      const trimHandler = (trim, value) => {
+        if (typeof value === "string" && trim) {
+          return value.replace(/^\s*/, "").replace(/\s*$/, "");
+        }
+      };
+      const onChangeHandler = async function(v, key2) {
+        const { filter, onChange, trim, name: name2, dynamicKey } = props.config;
+        let value = filterHandler(filter, v);
+        value = await changeHandler(onChange, value) ?? value;
+        value = trimHandler(trim, value) ?? value;
+        if ((name2 || name2 === 0) && props.model !== value && (v !== value || props.model[name2] !== value)) {
+          props.model[name2] = value;
+        }
+        if (key2 !== void 0 && dynamicKey) {
+          props.model[key2] = value;
+        }
+        emit("change", props.model);
+      };
+      return {
+        expand,
+        name,
+        type,
+        disabled,
+        itemProp,
+        items,
+        display: display$1,
+        tagName,
+        rule,
+        tooltip,
+        extra,
+        key,
+        onChangeHandler,
+        expandHandler
+      };
+    }
+  });
+  const _hoisted_1$g = ["innerHTML"];
+  const _hoisted_2$7 = ["innerHTML"];
+  const _hoisted_3$7 = ["innerHTML"];
+  const _hoisted_4$6 = /* @__PURE__ */ vue.createElementVNode("i", { class: "el-icon-warning" }, null, -1);
+  const _hoisted_5$4 = ["innerHTML"];
+  const _hoisted_6$3 = {
+    key: 4,
+    style: { "text-align": "center" }
+  };
+  function _sfc_render$p(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_m_fields_hidden = vue.resolveComponent("m-fields-hidden");
+    const _component_el_tooltip = vue.resolveComponent("el-tooltip");
+    const _component_el_form_item = vue.resolveComponent("el-form-item");
+    const _component_m_form_container = vue.resolveComponent("m-form-container");
+    const _component_el_button = vue.resolveComponent("el-button");
+    return _ctx.config ? (vue.openBlock(), vue.createElementBlock("div", {
+      key: 0,
+      style: vue.normalizeStyle(_ctx.config.tip ? "display: flex" : ""),
+      class: vue.normalizeClass([_ctx.config.className, "m-form-container"])
+    }, [
+      _ctx.type === "hidden" ? (vue.openBlock(), vue.createBlock(_component_m_fields_hidden, {
+        key: 0,
+        model: _ctx.model,
+        config: _ctx.config,
+        name: _ctx.config.name,
+        disabled: _ctx.disabled,
+        prop: _ctx.itemProp
+      }, null, 8, ["model", "config", "name", "disabled", "prop"])) : _ctx.items && !_ctx.config.text && _ctx.type && _ctx.display ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tagName), {
+        key: _ctx.key(_ctx.config),
+        size: _ctx.size,
+        model: _ctx.model,
+        config: _ctx.config,
+        name: _ctx.name,
+        prop: _ctx.itemProp,
+        "step-active": _ctx.stepActive,
+        "expand-more": _ctx.expand,
+        "label-width": _ctx.config.labelWidth || _ctx.labelWidth,
+        onChange: _ctx.onChangeHandler
+      }, null, 8, ["size", "model", "config", "name", "prop", "step-active", "expand-more", "label-width", "onChange"])) : _ctx.type && _ctx.display ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
+        vue.createVNode(_component_el_form_item, {
+          style: vue.normalizeStyle(_ctx.config.tip ? "flex: 1" : ""),
+          prop: _ctx.itemProp,
+          "label-width": _ctx.config.text ? _ctx.config.labelWidth || _ctx.labelWidth : "0",
+          rules: _ctx.rule
+        }, {
+          label: vue.withCtx(() => [
+            vue.createElementVNode("span", {
+              innerHTML: _ctx.type === "checkbox" ? "" : _ctx.config.text
+            }, null, 8, _hoisted_1$g)
+          ]),
+          default: vue.withCtx(() => [
+            _ctx.tooltip ? (vue.openBlock(), vue.createBlock(_component_el_tooltip, { key: 0 }, {
+              content: vue.withCtx(() => [
+                vue.createElementVNode("div", { innerHTML: _ctx.tooltip }, null, 8, _hoisted_2$7)
+              ]),
+              default: vue.withCtx(() => [
+                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tagName), {
+                  key: _ctx.key(_ctx.config),
+                  size: _ctx.size,
+                  model: _ctx.model,
+                  config: _ctx.config,
+                  name: _ctx.name,
+                  disabled: _ctx.disabled,
+                  prop: _ctx.itemProp,
+                  onChange: _ctx.onChangeHandler
+                }, null, 8, ["size", "model", "config", "name", "disabled", "prop", "onChange"]))
+              ]),
+              _: 1
+            })) : (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tagName), {
+              key: _ctx.key(_ctx.config),
+              size: _ctx.size,
+              model: _ctx.model,
+              config: _ctx.config,
+              name: _ctx.name,
+              disabled: _ctx.disabled,
+              prop: _ctx.itemProp,
+              onChange: _ctx.onChangeHandler
+            }, null, 8, ["size", "model", "config", "name", "disabled", "prop", "onChange"])),
+            _ctx.extra ? (vue.openBlock(), vue.createElementBlock("div", {
+              key: 2,
+              innerHTML: _ctx.extra,
+              class: "m-form-tip"
+            }, null, 8, _hoisted_3$7)) : vue.createCommentVNode("", true)
+          ]),
+          _: 1
+        }, 8, ["style", "prop", "label-width", "rules"]),
+        _ctx.config.tip ? (vue.openBlock(), vue.createBlock(_component_el_tooltip, {
+          key: 0,
+          placement: "top",
+          style: { "line-height": "40px", "margin-left": "5px" }
+        }, {
+          content: vue.withCtx(() => [
+            vue.createElementVNode("div", {
+              innerHTML: _ctx.config.tip
+            }, null, 8, _hoisted_5$4)
+          ]),
+          default: vue.withCtx(() => [
+            _hoisted_4$6
+          ]),
+          _: 1
+        })) : vue.createCommentVNode("", true)
+      ], 64)) : _ctx.items && _ctx.display ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 3 }, [
+        (_ctx.name || _ctx.name === 0 ? _ctx.model[_ctx.name] : _ctx.model) ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(_ctx.items, (item) => {
+          return vue.openBlock(), vue.createBlock(_component_m_form_container, {
+            key: _ctx.key(item),
+            model: _ctx.name || _ctx.name === 0 ? _ctx.model[_ctx.name] : _ctx.model,
+            config: item,
+            size: _ctx.size,
+            "step-active": _ctx.stepActive,
+            "expand-more": _ctx.expand,
+            "label-width": _ctx.config.labelWidth || _ctx.labelWidth,
+            prop: _ctx.itemProp,
+            onChange: _ctx.onChangeHandler
+          }, null, 8, ["model", "config", "size", "step-active", "expand-more", "label-width", "prop", "onChange"]);
+        }), 128)) : vue.createCommentVNode("", true)
+      ], 64)) : vue.createCommentVNode("", true),
+      _ctx.config.expand && _ctx.type !== "fieldset" ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_6$3, [
+        vue.createVNode(_component_el_button, {
+          type: "text",
+          onClick: _ctx.expandHandler
+        }, {
+          default: vue.withCtx(() => [
+            vue.createTextVNode(vue.toDisplayString(_ctx.expand ? "\u6536\u8D77\u914D\u7F6E" : "\u5C55\u5F00\u66F4\u591A\u914D\u7F6E"), 1)
+          ]),
+          _: 1
+        }, 8, ["onClick"])
+      ])) : vue.createCommentVNode("", true)
+    ], 6)) : vue.createCommentVNode("", true);
+  }
+  var Container = /* @__PURE__ */ _export_sfc(_sfc_main$s, [["render", _sfc_render$p]]);
+
+  const _sfc_main$r = vue.defineComponent({
+    name: "m-form-fieldset",
+    props: {
+      labelWidth: String,
+      model: {
+        type: Object,
+        default: () => ({})
+      },
+      config: {
+        type: Object,
+        default: () => ({})
+      },
+      rules: {
+        type: Object,
+        default: () => ({})
+      },
+      prop: {
+        type: String,
+        default: () => ""
+      },
+      size: String
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      const mForm = vue.inject("mForm");
+      const name = vue.computed(() => props.config.name || "");
+      const show = vue.computed(() => {
+        if (props.config.expand && name.value) {
+          return props.model[name.value]?.value;
+        }
+        return true;
+      });
+      const lWidth = vue.computed(() => {
+        if (props.config.items) {
+          return props.config.labelWidth || props.labelWidth;
+        }
+        return props.config.labelWidth || props.labelWidth || (props.config.text ? null : "0");
+      });
+      const change = () => {
+        emit("change", props.model);
+      };
+      const key = (item, index) => item[mForm?.keyProp || "__key"] ?? index;
+      return {
+        show,
+        name,
+        mForm,
+        lWidth,
+        key,
+        change
+      };
+    }
+  });
+  const _hoisted_1$f = ["innerHTML"];
+  const _hoisted_2$6 = ["innerHTML"];
+  const _hoisted_3$6 = { key: 1 };
+  const _hoisted_4$5 = ["innerHTML"];
+  const _hoisted_5$3 = ["innerHTML"];
+  const _hoisted_6$2 = { key: 2 };
+  const _hoisted_7$2 = ["innerHTML"];
+  const _hoisted_8$1 = ["innerHTML"];
+  const _hoisted_9$1 = {
+    key: 3,
+    style: { "display": "flex" }
+  };
+  const _hoisted_10$1 = { style: { "flex": "1" } };
+  const _hoisted_11 = ["src"];
+  function _sfc_render$o(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_checkbox = vue.resolveComponent("el-checkbox");
+    const _component_m_form_container = vue.resolveComponent("m-form-container");
+    return (_ctx.name ? _ctx.model[_ctx.name] : _ctx.model) ? (vue.openBlock(), vue.createElementBlock("fieldset", {
+      key: 0,
+      class: "m-fieldset",
+      style: vue.normalizeStyle(_ctx.show ? "padding: 15px 15px 0 5px;" : "border: 0")
+    }, [
+      !_ctx.show && _ctx.name ? (vue.openBlock(), vue.createBlock(_component_el_checkbox, {
+        key: 0,
+        modelValue: _ctx.model[_ctx.name].value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.name].value = $event),
+        prop: `${_ctx.prop}${_ctx.prop ? "." : ""}${_ctx.config.name}.value`,
+        "true-label": 1,
+        "false-label": 0,
+        onChange: _ctx.change
+      }, {
+        default: vue.withCtx(() => [
+          vue.createElementVNode("span", {
+            innerHTML: _ctx.config.legend
+          }, null, 8, _hoisted_1$f),
+          _ctx.config.extra ? (vue.openBlock(), vue.createElementBlock("span", {
+            key: 0,
+            innerHTML: _ctx.config.extra,
+            class: "m-form-tip"
+          }, null, 8, _hoisted_2$6)) : vue.createCommentVNode("", true)
+        ]),
+        _: 1
+      }, 8, ["modelValue", "prop", "onChange"])) : _ctx.config.checkbox && _ctx.name ? (vue.openBlock(), vue.createElementBlock("legend", _hoisted_3$6, [
+        vue.createVNode(_component_el_checkbox, {
+          modelValue: _ctx.model[_ctx.name].value,
+          "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.model[_ctx.name].value = $event),
+          prop: `${_ctx.prop}${_ctx.prop ? "." : ""}${_ctx.config.name}.value`,
+          "true-label": 1,
+          "false-label": 0,
+          onChange: _ctx.change
+        }, {
+          default: vue.withCtx(() => [
+            vue.createElementVNode("span", {
+              innerHTML: _ctx.config.legend
+            }, null, 8, _hoisted_4$5),
+            _ctx.config.extra ? (vue.openBlock(), vue.createElementBlock("span", {
+              key: 0,
+              innerHTML: _ctx.config.extra,
+              class: "m-form-tip"
+            }, null, 8, _hoisted_5$3)) : vue.createCommentVNode("", true)
+          ]),
+          _: 1
+        }, 8, ["modelValue", "prop", "onChange"])
+      ])) : (vue.openBlock(), vue.createElementBlock("legend", _hoisted_6$2, [
+        vue.createElementVNode("span", {
+          innerHTML: _ctx.config.legend
+        }, null, 8, _hoisted_7$2),
+        _ctx.config.extra ? (vue.openBlock(), vue.createElementBlock("span", {
+          key: 0,
+          innerHTML: _ctx.config.extra,
+          class: "m-form-tip"
+        }, null, 8, _hoisted_8$1)) : vue.createCommentVNode("", true)
+      ])),
+      _ctx.config.schematic && _ctx.show ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_9$1, [
+        vue.createElementVNode("div", _hoisted_10$1, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.config.items, (item, index) => {
+            return vue.openBlock(), vue.createBlock(_component_m_form_container, {
+              key: _ctx.key(item, index),
+              model: _ctx.name ? _ctx.model[_ctx.name] : _ctx.model,
+              rules: _ctx.name ? _ctx.rules[_ctx.name] : [],
+              config: item,
+              prop: _ctx.prop,
+              labelWidth: _ctx.lWidth,
+              size: _ctx.size,
+              onChange: _ctx.change
+            }, null, 8, ["model", "rules", "config", "prop", "labelWidth", "size", "onChange"]);
+          }), 128))
+        ]),
+        vue.createElementVNode("img", {
+          class: "m-form-schematic",
+          src: _ctx.config.schematic
+        }, null, 8, _hoisted_11)
+      ])) : _ctx.show ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 4 }, vue.renderList(_ctx.config.items, (item, index) => {
+        return vue.openBlock(), vue.createBlock(_component_m_form_container, {
+          key: _ctx.key(item, index),
+          model: _ctx.name ? _ctx.model[_ctx.name] : _ctx.model,
+          rules: _ctx.name ? _ctx.rules[_ctx.name] : [],
+          config: item,
+          prop: _ctx.prop,
+          labelWidth: _ctx.lWidth,
+          size: _ctx.size,
+          onChange: _ctx.change
+        }, null, 8, ["model", "rules", "config", "prop", "labelWidth", "size", "onChange"]);
+      }), 128)) : vue.createCommentVNode("", true)
+    ], 4)) : vue.createCommentVNode("", true);
+  }
+  var Fieldset = /* @__PURE__ */ _export_sfc(_sfc_main$r, [["render", _sfc_render$o]]);
+
+  const _sfc_main$q = vue.defineComponent({
+    name: "m-form-group-list-item",
+    components: { CaretRight: icons.CaretRight, CaretBottom: icons.CaretBottom },
+    props: {
+      labelWidth: String,
+      model: {
+        type: Object,
+        default: () => ({})
+      },
+      config: {
+        type: Object,
+        default: () => ({})
+      },
+      prop: String,
+      size: String,
+      index: {
+        type: [Number, String, Symbol],
+        default: 0
+      },
+      groupModel: {
+        type: Array,
+        default: () => []
+      }
+    },
+    emits: ["swap-item", "remove-item", "change"],
+    setup(props, { emit }) {
+      const mForm = vue.inject("mForm");
+      const expand = vue.ref(false);
+      vue.watchEffect(() => {
+        expand.value = !props.index;
+      });
+      const rowConfig = vue.computed(() => ({
+        type: "row",
+        span: props.config.span || 24,
+        items: props.config.items,
+        labelWidth: props.config.labelWidth,
+        [mForm?.keyProp || "__key"]: `${props.config[mForm?.keyProp || "__key"]}${String(props.index)}`
+      }));
+      const title = vue.computed(() => {
+        if (props.config.titleKey && props.model[props.config.titleKey]) {
+          return props.model[props.config.titleKey];
+        }
+        return `\u7EC4 ${String(props.index)}`;
+      });
+      const length = vue.computed(() => props.groupModel?.length || 0);
+      const itemExtra = vue.computed(() => filterFunction(mForm, props.config.itemExtra, props));
+      const removeHandler = () => emit("remove-item", props.index);
+      const changeHandler = () => emit("change");
+      const expandHandler = () => {
+        expand.value = !expand.value;
+      };
+      const showDelete = (index) => {
+        const deleteFunc = props.config.delete;
+        if (deleteFunc && typeof deleteFunc === "function") {
+          return deleteFunc(props.model, index, mForm?.values);
+        }
+        return true;
+      };
+      const changeOrder = (offset = 0) => emit("swap-item", props.index, `${String(props.index)}${offset}`);
+      const movable = () => {
+        const { movable: movable2 } = props.config;
+        if (movable2 === void 0)
+          return true;
+        if (typeof movable2 === "function") {
+          return movable2(mForm, props.index || 0, props.model, props.groupModel);
+        }
+        return movable2;
+      };
+      return {
+        expand,
+        expandHandler,
+        title,
+        showDelete,
+        removeHandler,
+        movable,
+        changeOrder,
+        itemExtra,
+        rowConfig,
+        changeHandler,
+        length,
+        Delete: icons.Delete
+      };
+    }
+  });
+  const _hoisted_1$e = { class: "m-fields-group-list-item" };
+  const _hoisted_2$5 = /* @__PURE__ */ vue.createTextVNode("\u4E0A\u79FB");
+  const _hoisted_3$5 = /* @__PURE__ */ vue.createTextVNode("\u4E0B\u79FB");
+  const _hoisted_4$4 = ["innerHTML"];
+  function _sfc_render$n(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_caret_bottom = vue.resolveComponent("caret-bottom");
+    const _component_caret_right = vue.resolveComponent("caret-right");
+    const _component_el_icon = vue.resolveComponent("el-icon");
+    const _component_el_button = vue.resolveComponent("el-button");
+    const _component_CaretRight = vue.resolveComponent("CaretRight");
+    const _component_CaretBottom = vue.resolveComponent("CaretBottom");
+    const _component_m_form_container = vue.resolveComponent("m-form-container");
+    return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$e, [
+      vue.createElementVNode("div", null, [
+        vue.createVNode(_component_el_icon, {
+          style: { "margin-right": "7px" },
+          onClick: _ctx.expandHandler
+        }, {
+          default: vue.withCtx(() => [
+            _ctx.expand ? (vue.openBlock(), vue.createBlock(_component_caret_bottom, { key: 0 })) : (vue.openBlock(), vue.createBlock(_component_caret_right, { key: 1 }))
+          ]),
+          _: 1
+        }, 8, ["onClick"]),
+        vue.createVNode(_component_el_button, {
+          type: "text",
+          onClick: _ctx.expandHandler
+        }, {
+          default: vue.withCtx(() => [
+            vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
+          ]),
+          _: 1
+        }, 8, ["onClick"]),
+        vue.withDirectives(vue.createVNode(_component_el_button, {
+          type: "text",
+          icon: _ctx.Delete,
+          style: { "color": "#f56c6c" },
+          onClick: _ctx.removeHandler
+        }, null, 8, ["icon", "onClick"]), [
+          [vue.vShow, _ctx.showDelete(parseInt(String(_ctx.index)))]
+        ]),
+        _ctx.movable() ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+          vue.withDirectives(vue.createVNode(_component_el_button, {
+            type: "text",
+            size: "small",
+            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.changeOrder(-1))
+          }, {
+            default: vue.withCtx(() => [
+              _hoisted_2$5,
+              vue.createVNode(_component_el_icon, null, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_CaretRight)
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          }, 512), [
+            [vue.vShow, _ctx.index !== 0]
+          ]),
+          vue.withDirectives(vue.createVNode(_component_el_button, {
+            type: "text",
+            size: "small",
+            onClick: _cache[1] || (_cache[1] = ($event) => _ctx.changeOrder(1))
+          }, {
+            default: vue.withCtx(() => [
+              _hoisted_3$5,
+              vue.createVNode(_component_el_icon, null, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_CaretBottom)
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          }, 512), [
+            [vue.vShow, _ctx.index !== _ctx.length - 1]
+          ])
+        ], 64)) : vue.createCommentVNode("", true),
+        _ctx.itemExtra ? (vue.openBlock(), vue.createElementBlock("span", {
+          key: 1,
+          innerHTML: _ctx.itemExtra,
+          class: "m-form-tip"
+        }, null, 8, _hoisted_4$4)) : vue.createCommentVNode("", true)
+      ]),
+      _ctx.expand ? (vue.openBlock(), vue.createBlock(_component_m_form_container, {
+        key: 0,
+        config: _ctx.rowConfig,
+        model: _ctx.model,
+        labelWidth: _ctx.labelWidth,
+        prop: `${_ctx.prop}${_ctx.prop ? "." : ""}${String(_ctx.index)}`,
+        size: _ctx.size,
+        onChange: _ctx.changeHandler
+      }, null, 8, ["config", "model", "labelWidth", "prop", "size", "onChange"])) : vue.createCommentVNode("", true)
+    ]);
+  }
+  var MFieldsGroupListItem = /* @__PURE__ */ _export_sfc(_sfc_main$q, [["render", _sfc_render$n]]);
+
+  const _sfc_main$p = vue.defineComponent({
+    name: "m-form-group-list",
+    components: { MFieldsGroupListItem },
+    props: {
+      labelWidth: String,
+      model: {
+        type: Object,
+        default: () => ({})
+      },
+      config: {
+        type: Object,
+        default: () => ({})
+      },
+      prop: {
+        type: String,
+        default: ""
+      },
+      size: String,
+      name: {
+        type: String,
+        default: ""
+      }
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      const mForm = vue.inject("mForm");
+      const addable = vue.computed(() => {
+        if (!props.name)
+          return false;
+        if (typeof props.config.addable === "function") {
+          return props.config.addable(mForm, {
+            model: props.model[props.name],
+            formValue: mForm?.values
+          });
+        }
+        return typeof props.config.addable === "undefined" ? true : props.config.addable;
+      });
+      const changeHandler = () => {
+        if (!props.name)
+          return false;
+        emit("change", props.model[props.name]);
+      };
+      const addHandler = async () => {
+        if (!props.name)
+          return false;
+        let initValues = {};
+        if (typeof props.config.defaultAdd === "function") {
+          initValues = await props.config.defaultAdd(mForm, {
+            model: props.model[props.name],
+            formValue: mForm?.values
+          });
+        } else if (props.config.defaultAdd) {
+          initValues = props.config.defaultAdd;
+        }
+        const groupValue = await initValue(mForm, {
+          config: props.config.items,
+          initValues
+        });
+        props.model[props.name].push(groupValue);
+      };
+      const removeHandler = (index) => {
+        if (!props.name)
+          return false;
+        props.model[props.name].splice(index, 1);
+        changeHandler();
+      };
+      const swapHandler = (idx1, idx2) => {
+        if (!props.name)
+          return false;
+        const [currRow] = props.model[props.name].splice(idx1, 1);
+        props.model[props.name].splice(idx2, 0, currRow);
+        changeHandler();
+      };
+      const toggleMode = () => {
+        props.config.type = "table";
+        props.config.groupItems = props.config.items;
+        props.config.items = props.config.tableItems || props.config.items.map((item) => ({
+          ...item,
+          label: item.label || item.text,
+          text: null
+        }));
+      };
+      return {
+        addable,
+        toggleMode,
+        removeHandler,
+        swapHandler,
+        changeHandler,
+        addHandler
+      };
+    }
+  });
+  const _hoisted_1$d = { class: "m-fields-group-list" };
+  const _hoisted_2$4 = ["innerHTML"];
+  const _hoisted_3$4 = {
+    key: 1,
+    class: "el-table__empty-block"
+  };
+  const _hoisted_4$3 = /* @__PURE__ */ vue.createElementVNode("span", { class: "el-table__empty-text" }, "\u6682\u65E0\u6570\u636E", -1);
+  const _hoisted_5$2 = [
+    _hoisted_4$3
+  ];
+  const _hoisted_6$1 = /* @__PURE__ */ vue.createTextVNode("\u6DFB\u52A0\u7EC4");
+  const _hoisted_7$1 = /* @__PURE__ */ vue.createTextVNode("\u5207\u6362\u4E3A\u8868\u683C");
+  function _sfc_render$m(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_m_fields_group_list_item = vue.resolveComponent("m-fields-group-list-item");
+    const _component_el_button = vue.resolveComponent("el-button");
+    return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$d, [
+      _ctx.config.extra ? (vue.openBlock(), vue.createElementBlock("div", {
+        key: 0,
+        innerHTML: _ctx.config.extra,
+        style: { "color": "rgba(0, 0, 0, 0.45)" }
+      }, null, 8, _hoisted_2$4)) : vue.createCommentVNode("", true),
+      !_ctx.model[_ctx.name] || !_ctx.model[_ctx.name].length ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3$4, _hoisted_5$2)) : (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 2 }, vue.renderList(_ctx.model[_ctx.name], (item, index) => {
+        return vue.openBlock(), vue.createBlock(_component_m_fields_group_list_item, {
+          key: index,
+          model: item,
+          config: _ctx.config,
+          prop: _ctx.prop,
+          index,
+          "label-width": _ctx.labelWidth,
+          size: _ctx.size,
+          "group-model": _ctx.model[_ctx.name],
+          onRemoveItem: _ctx.removeHandler,
+          onSwapItem: _ctx.swapHandler,
+          onChange: _ctx.changeHandler
+        }, null, 8, ["model", "config", "prop", "index", "label-width", "size", "group-model", "onRemoveItem", "onSwapItem", "onChange"]);
+      }), 128)),
+      _ctx.addable ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+        key: 3,
+        onClick: _ctx.addHandler,
+        size: "small"
+      }, {
+        default: vue.withCtx(() => [
+          _hoisted_6$1
+        ]),
+        _: 1
+      }, 8, ["onClick"])) : vue.createCommentVNode("", true),
+      _ctx.config.enableToggleMode ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+        key: 4,
+        icon: "el-icon-s-grid",
+        size: "small",
+        onClick: _ctx.toggleMode
+      }, {
+        default: vue.withCtx(() => [
+          _hoisted_7$1
+        ]),
+        _: 1
+      }, 8, ["onClick"])) : vue.createCommentVNode("", true)
+    ]);
+  }
+  var GroupList = /* @__PURE__ */ _export_sfc(_sfc_main$p, [["render", _sfc_render$m]]);
+
+  const _sfc_main$o = vue.defineComponent({
+    name: "m-form-panel",
+    components: { CaretBottom: icons.CaretBottom, CaretRight: icons.CaretRight },
+    props: {
+      labelWidth: String,
+      model: {
+        type: Object,
+        default: () => ({})
+      },
+      config: {
+        type: Object,
+        default: () => ({})
+      },
+      prop: String,
+      size: String,
+      name: String
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      const mForm = vue.inject("mForm");
+      const expand = vue.ref(props.config.expand !== false);
+      const items = vue.computed(() => props.config.items);
+      const filter = (config) => filterFunction(mForm, config, props);
+      const changeHandler = () => emit("change", props.model);
+      return {
+        mForm,
+        expand,
+        items,
+        filter,
+        changeHandler
+      };
+    }
+  });
+  const _hoisted_1$c = { class: "clearfix" };
+  const _hoisted_2$3 = ["innerHTML"];
+  const _hoisted_3$3 = {
+    key: 0,
+    style: { "display": "flex" }
+  };
+  const _hoisted_4$2 = { style: { "flex": "1" } };
+  const _hoisted_5$1 = ["src"];
+  function _sfc_render$l(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_caret_bottom = vue.resolveComponent("caret-bottom");
+    const _component_caret_right = vue.resolveComponent("caret-right");
+    const _component_el_icon = vue.resolveComponent("el-icon");
+    const _component_m_form_container = vue.resolveComponent("m-form-container");
+    const _component_el_card = vue.resolveComponent("el-card");
+    return _ctx.items && _ctx.items.length ? (vue.openBlock(), vue.createBlock(_component_el_card, {
+      key: 0,
+      class: "box-card m-form-panel",
+      "body-style": { display: _ctx.expand ? "block" : "none" }
+    }, {
+      header: vue.withCtx(() => [
+        vue.createElementVNode("div", _hoisted_1$c, [
+          vue.createElementVNode("a", {
+            href: "javascript:",
+            style: { "width": "100%", "display": "block" },
+            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.expand = !_ctx.expand)
+          }, [
+            vue.createVNode(_component_el_icon, null, {
+              default: vue.withCtx(() => [
+                _ctx.expand ? (vue.openBlock(), vue.createBlock(_component_caret_bottom, { key: 0 })) : (vue.openBlock(), vue.createBlock(_component_caret_right, { key: 1 }))
+              ]),
+              _: 1
+            }),
+            vue.createTextVNode(" " + vue.toDisplayString(_ctx.filter(_ctx.config.title)) + " ", 1),
+            _ctx.config && _ctx.config.extra ? (vue.openBlock(), vue.createElementBlock("span", {
+              key: 0,
+              innerHTML: _ctx.config.extra,
+              class: "m-form-tip"
+            }, null, 8, _hoisted_2$3)) : vue.createCommentVNode("", true)
+          ])
+        ])
+      ]),
+      default: vue.withCtx(() => [
+        vue.createElementVNode("div", null, [
+          vue.renderSlot(_ctx.$slots, "default"),
+          _ctx.config.schematic ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3$3, [
+            vue.createElementVNode("div", _hoisted_4$2, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.items, (item, index) => {
+                return vue.openBlock(), vue.createBlock(_component_m_form_container, {
+                  key: item[_ctx.mForm?.keyProp || "__key"] ?? index,
+                  config: item,
+                  model: _ctx.name ? _ctx.model[_ctx.name] : _ctx.model,
+                  prop: _ctx.prop,
+                  size: _ctx.size,
+                  "label-width": _ctx.config.labelWidth || _ctx.labelWidth,
+                  onChange: _ctx.changeHandler
+                }, null, 8, ["config", "model", "prop", "size", "label-width", "onChange"]);
+              }), 128))
+            ]),
+            vue.createElementVNode("img", {
+              class: "m-form-schematic",
+              src: _ctx.config.schematic
+            }, null, 8, _hoisted_5$1)
+          ])) : (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(_ctx.items, (item, index) => {
+            return vue.openBlock(), vue.createBlock(_component_m_form_container, {
+              key: item[_ctx.mForm?.keyProp || "__key"] ?? index,
+              config: item,
+              model: _ctx.name ? _ctx.model[_ctx.name] : _ctx.model,
+              prop: _ctx.prop,
+              size: _ctx.size,
+              "label-width": _ctx.config.labelWidth || _ctx.labelWidth,
+              onChange: _ctx.changeHandler
+            }, null, 8, ["config", "model", "prop", "size", "label-width", "onChange"]);
+          }), 128))
+        ])
+      ]),
+      _: 3
+    }, 8, ["body-style"])) : vue.createCommentVNode("", true);
+  }
+  var Panel = /* @__PURE__ */ _export_sfc(_sfc_main$o, [["render", _sfc_render$l]]);
+
+  const _sfc_main$n = vue.defineComponent({
+    name: "m-form-row",
+    props: {
+      labelWidth: String,
+      expandMore: Boolean,
+      model: {
+        type: Object,
+        default: () => ({})
+      },
+      config: {
+        type: Object,
+        default: () => ({})
+      },
+      prop: String,
+      name: String,
+      size: String
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      const mForm = vue.inject("mForm");
+      const changeHandler = () => emit("change", props.name ? props.model[props.name] : props.model);
+      return {
+        mForm,
+        display(config) {
+          return display(mForm, config.display, props);
+        },
+        changeHandler
+      };
+    }
+  });
+  function _sfc_render$k(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_m_form_container = vue.resolveComponent("m-form-container");
+    const _component_el_col = vue.resolveComponent("el-col");
+    const _component_el_row = vue.resolveComponent("el-row");
+    return vue.openBlock(), vue.createBlock(_component_el_row, { gutter: 10 }, {
+      default: vue.withCtx(() => [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.config.items, (col, index) => {
+          return vue.openBlock(), vue.createBlock(_component_el_col, {
+            style: vue.normalizeStyle(!_ctx.display(col) || col.type === "hidden" ? "display: none" : ""),
+            key: col[_ctx.mForm?.keyProp || "__key"] ?? index,
+            span: col.span || _ctx.config.span || 24 / _ctx.config.items.length
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_m_form_container, {
+                model: _ctx.name ? _ctx.model[_ctx.name] : _ctx.model,
+                config: col,
+                prop: _ctx.prop,
+                "label-width": _ctx.config.labelWidth || _ctx.labelWidth,
+                "expand-more": _ctx.expandMore,
+                size: _ctx.size,
+                onChange: _ctx.changeHandler
+              }, null, 8, ["model", "config", "prop", "label-width", "expand-more", "size", "onChange"])
+            ]),
+            _: 2
+          }, 1032, ["style", "span"]);
+        }), 128))
+      ]),
+      _: 1
+    });
+  }
+  var Row = /* @__PURE__ */ _export_sfc(_sfc_main$n, [["render", _sfc_render$k]]);
+
+  const _sfc_main$m = vue.defineComponent({
+    name: "m-form-step",
+    props: {
+      model: {
+        type: Object,
+        default: () => ({})
+      },
+      config: {
+        type: Object,
+        default: () => ({})
+      },
+      stepActive: {
+        type: Number,
+        default: () => 1
+      },
+      size: String,
+      labelWidth: String
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      const mForm = vue.inject("mForm");
+      const active = vue.ref(1);
+      vue.watchEffect(() => {
+        active.value = props.stepActive;
+      });
+      const stepClick = (index) => {
+        active.value = index + 1;
+        mForm?.$emit("update:stepActive", active.value);
+      };
+      const changeHandler = () => {
+        emit("change", props.model);
+      };
+      return { mForm, active, stepClick, changeHandler };
+    }
+  });
+  function _sfc_render$j(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_step = vue.resolveComponent("el-step");
+    const _component_el_steps = vue.resolveComponent("el-steps");
+    const _component_m_form_container = vue.resolveComponent("m-form-container");
+    return vue.openBlock(), vue.createElementBlock("div", null, [
+      vue.createVNode(_component_el_steps, {
+        active: _ctx.active,
+        "align-center": "",
+        space: _ctx.config.space
+      }, {
+        default: vue.withCtx(() => [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.config.items, (item, index) => {
+            return vue.openBlock(), vue.createBlock(_component_el_step, {
+              key: item.__key,
+              title: item.title,
+              active: _ctx.active,
+              onClick: ($event) => _ctx.stepClick(index)
+            }, null, 8, ["title", "active", "onClick"]);
+          }), 128))
+        ]),
+        _: 1
+      }, 8, ["active", "space"]),
+      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.config.items, (step, index) => {
+        return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(step.items, (item) => {
+            return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+              item ? vue.withDirectives((vue.openBlock(), vue.createBlock(_component_m_form_container, {
+                key: item[_ctx.mForm?.keyProp || "__key"],
+                config: item,
+                model: step.name ? _ctx.model[step.name] : _ctx.model,
+                prop: step.name,
+                size: _ctx.size,
+                "label-width": _ctx.config.labelWidth || _ctx.labelWidth,
+                onChange: _ctx.changeHandler
+              }, null, 8, ["config", "model", "prop", "size", "label-width", "onChange"])), [
+                [vue.vShow, _ctx.active - 1 === index]
+              ]) : vue.createCommentVNode("", true)
+            ], 64);
+          }), 256))
+        ], 64);
+      }), 256))
+    ]);
+  }
+  var MStep = /* @__PURE__ */ _export_sfc(_sfc_main$m, [["render", _sfc_render$j]]);
+
+  let loadedAMapJS = false;
+  let firstLoadingAMapJS = true;
+  const _sfc_main$l = vue.defineComponent({
+    name: "m-form-table",
+    props: {
+      name: {
+        type: String,
+        required: true
+      },
+      model: {
+        type: Object,
+        required: true,
+        default: () => ({})
+      },
+      config: {
+        type: Object,
+        required: true,
+        default: () => ({})
+      },
+      prop: {
+        type: String
+      },
+      labelWidth: {
+        type: String
+      },
+      sort: {
+        type: Boolean,
+        default: false
+      },
+      sortKey: {
+        type: String,
+        default: ""
+      },
+      text: {
+        type: String
+      },
+      size: String,
+      enableToggleMode: {
+        type: Boolean,
+        default: true
+      }
+    },
+    emits: ["change", "select"],
+    setup(props, { emit }) {
+      let timer = null;
+      const mForm = vue.inject("mForm");
+      const elTable = vue.ref();
+      const excelBtn = vue.ref();
+      const mTable = vue.ref();
+      const pagesize = vue.ref(10);
+      const pagecontext = vue.ref(0);
+      const updateKey = vue.ref(1);
+      const isFullscreen = vue.ref(false);
+      const modelName = vue.computed(() => props.name || props.config.name || "");
+      const sortChange = ({ prop, order }) => {
+        if (order === "ascending") {
+          props.model[modelName.value] = props.model[modelName.value].sort((a, b) => a[prop] - b[prop]);
+        } else if (order === "descending") {
+          props.model[modelName.value] = props.model[modelName.value].sort((a, b) => b[prop] - a[prop]);
+        }
+      };
+      const foreUpdate = () => {
+        updateKey.value += 1;
+        setTimeout(() => rowDrop());
+      };
+      const swapArray = (index1, index2) => {
+        [props.model[modelName.value][index1]] = props.model[modelName.value].splice(index2, 1, props.model[modelName.value][index1]);
+        if (props.sortKey) {
+          for (let i = props.model[modelName.value].length - 1, v = 0; i >= 0; i--, v++) {
+            props.model[modelName.value][v][props.sortKey] = i;
+          }
+        }
+        mForm?.$emit("field-change", props.prop, props.model[modelName.value]);
+      };
+      const rowDrop = () => {
+        const tableEl = elTable.value?.$el;
+        if (tableEl?.querySelectorAll(".el-table__body > tbody")) {
+          const el = tableEl.querySelectorAll(".el-table__body > tbody")[0];
+          const sortable = Sortable__default["default"].create(el, {
+            onEnd: ({ newIndex, oldIndex }) => {
+              if (typeof newIndex === "undefined")
+                return;
+              if (typeof oldIndex === "undefined")
+                return;
+              swapArray(newIndex, oldIndex);
+              emit("change", props.model[modelName.value]);
+              foreUpdate();
+              sortable.destroy();
+              mForm?.$emit("field-change", props.prop, props.model[modelName.value]);
+              utils.sleep(1e3).then(() => {
+                const eltrs = tableEl.querySelectorAll(".el-table__body > tbody > tr");
+                if (eltrs?.[newIndex]) {
+                  eltrs[newIndex].style.backgroundColor = "rgba(243, 89, 59, 0.2)";
+                  utils.sleep(1e3).then(() => {
+                    eltrs[newIndex].style.backgroundColor = "";
+                  });
+                }
+              });
+            }
+          });
+        }
+      };
+      const newHandler = async (row) => {
+        if (props.config.max && props.model[modelName.value].length >= props.config.max) {
+          elementPlus.ElMessage.error(`\u6700\u591A\u65B0\u589E\u914D\u7F6E\u4E0D\u80FD\u8D85\u8FC7${props.config.max}\u6761`);
+          return;
+        }
+        const columns = props.config.items;
+        const enumValues = props.config.enum || [];
+        let enumV = [];
+        const { length } = props.model[modelName.value];
+        const key = props.config.key || "id";
+        let inputs = {};
+        if (enumValues.length) {
+          if (length >= enumValues.length) {
+            return;
+          }
+          enumV = enumValues.filter((item) => {
+            let i = 0;
+            for (; i < length; i++) {
+              if (item[key] === props.model[modelName.value][i][key]) {
+                break;
+              }
+            }
+            return i === length;
+          });
+          if (enumV.length > 0) {
+            inputs = enumV[0];
+          }
+        } else if (Array.isArray(row)) {
+          columns.forEach((column, index) => {
+            column.name && (inputs[column.name] = row[index]);
+          });
+        } else {
+          if (typeof props.config.defaultAdd === "function") {
+            inputs = await props.config.defaultAdd(mForm, {
+              model: props.model[modelName.value],
+              formValue: mForm?.values
+            });
+          } else if (props.config.defaultAdd) {
+            inputs = props.config.defaultAdd;
+          }
+          inputs = await initValue(mForm, {
+            config: columns,
+            initValues: inputs
+          });
+        }
+        if (props.sortKey && length) {
+          inputs[props.sortKey] = props.model[modelName.value][length - 1][props.sortKey] - 1;
+        }
+        props.model[modelName.value].push(inputs);
+        emit("change", props.model[modelName.value]);
+      };
+      if (!loadedAMapJS && firstLoadingAMapJS && !globalThis.XLSX) {
+        firstLoadingAMapJS = false;
+        utils.asyncLoadJs("https://cdn.bootcdn.net/ajax/libs/xlsx/0.17.0/xlsx.full.min.js").then(() => {
+          loadedAMapJS = true;
+        }).catch(() => {
+          firstLoadingAMapJS = true;
+        });
+      }
+      vue.onMounted(() => {
+        if (props.config.defautSort) {
+          sortChange(props.config.defautSort);
+        }
+        if (props.sort && props.sortKey) {
+          props.model[modelName.value].sort((a, b) => b[props.sortKey] - a[props.sortKey]);
+        }
+        if (props.config.dropSort) {
+          rowDrop();
+        }
+      });
+      return {
+        mForm,
+        pagesize,
+        pagecontext,
+        foreUpdate,
+        isFullscreen,
+        elTable,
+        mTable,
+        excelBtn,
+        modelName,
+        updateKey,
+        ArrowDown: icons.ArrowDown,
+        ArrowUp: icons.ArrowUp,
+        Delete: icons.Delete,
+        data: vue.computed(() => props.model[modelName.value].filter((item, index) => index >= pagecontext.value * pagesize.value && index + 1 <= (pagecontext.value + 1) * pagesize.value)),
+        addable: vue.computed(() => {
+          if (!props.model[modelName.value].length) {
+            return true;
+          }
+          if (typeof props.config.addable === "function") {
+            return props.config.addable(mForm, {
+              model: props.model[modelName.value],
+              formValue: mForm?.values,
+              prop: props.prop
+            });
+          }
+          return typeof props.config.addable === "undefined" ? true : props.config.addable;
+        }),
+        selection: vue.computed(() => {
+          if (typeof props.config.selection === "function") {
+            return props.config.selection(mForm, { model: props.model[modelName.value] });
+          }
+          return props.config.selection;
+        }),
+        importable: vue.computed(() => {
+          if (typeof props.config.importable === "function") {
+            return props.config.importable(mForm, {
+              formValue: mForm?.values,
+              model: props.model[modelName.value]
+            });
+          }
+          return typeof props.config.importable === "undefined" ? false : props.config.importable;
+        }),
+        sortChange,
+        display(fuc) {
+          return display(mForm, fuc, props);
+        },
+        itemExtra(fuc, index) {
+          if (typeof fuc === "function") {
+            return fuc(mForm, {
+              values: mForm?.initValues,
+              model: props.model,
+              formValue: mForm ? mForm.values : props.model,
+              prop: props.prop,
+              index
+            });
+          }
+          return fuc;
+        },
+        newHandler,
+        removeHandler(index) {
+          props.model[modelName.value].splice(index, 1);
+          emit("change", props.model[modelName.value]);
+        },
+        selectHandle(selection, row) {
+          if (typeof props.config.selection === "string" && props.config.selection === "single") {
+            elTable.value?.clearSelection();
+            elTable.value?.toggleRowSelection(row, true);
+          }
+          emit("select", selection, row);
+          if (typeof props.config.onSelect === "function") {
+            props.config.onSelect(mForm, { selection, row });
+          }
+        },
+        toggleRowSelection(row, selected) {
+          elTable.value?.toggleRowSelection.call(elTable.value, row, selected);
+        },
+        makeConfig(config) {
+          const newConfig = lodashEs.cloneDeep(config);
+          delete newConfig.display;
+          return newConfig;
+        },
+        upHandler(index) {
+          if (timer) {
+            clearTimeout(timer);
+          }
+          timer = setTimeout(() => {
+            swapArray(index, index - 1);
+          }, 300);
+        },
+        topHandler(index) {
+          if (timer) {
+            clearTimeout(timer);
+          }
+          const moveNum = index;
+          for (let i = 0; i < moveNum; i++) {
+            swapArray(index, index - 1);
+            index -= 1;
+          }
+        },
+        downHandler(index) {
+          if (timer) {
+            clearTimeout(timer);
+          }
+          timer = setTimeout(() => {
+            swapArray(index, index + 1);
+          }, 300);
+        },
+        bottomHandler(index) {
+          if (timer) {
+            clearTimeout(timer);
+          }
+          const moveNum = props.model[modelName.value].length - 1 - index;
+          for (let i = 0; i < moveNum; i++) {
+            swapArray(index, index + 1);
+            index += 1;
+          }
+        },
+        showDelete(index) {
+          const deleteFunc = props.config.delete;
+          if (deleteFunc && typeof deleteFunc === "function") {
+            return deleteFunc(props.model[modelName.value], index, mForm?.values);
+          }
+          return true;
+        },
+        clearHandler() {
+          const len = props.model[modelName.value].length;
+          props.model[modelName.value].splice(0, len);
+          mForm?.$emit("field-change", props.prop, props.model[modelName.value]);
+        },
+        excelHandler(file) {
+          if (!file || !file.raw) {
+            return false;
+          }
+          const reader = new FileReader();
+          reader.onload = () => {
+            const data = reader.result;
+            const pdata = globalThis.XLSX.read(data, { type: "array" });
+            pdata.SheetNames.forEach((sheetName) => {
+              const arr = globalThis.XLSX.utils.sheet_to_json(pdata.Sheets[sheetName], { header: 1 });
+              if (arr?.[0]) {
+                arr.forEach((row) => {
+                  newHandler(row);
+                });
+              }
+              setTimeout(() => {
+                excelBtn.value?.clearFiles();
+              }, 300);
+            });
+          };
+          reader.readAsArrayBuffer(file.raw);
+          return false;
+        },
+        handleSizeChange(val) {
+          pagesize.value = val;
+        },
+        handleCurrentChange(val) {
+          pagecontext.value = val - 1;
+        },
+        toggleMode() {
+          const calcLabelWidth = (label) => {
+            if (!label)
+              return "0px";
+            const zhLength = label.match(/[^\x00-\xff]/g)?.length || 0;
+            const chLength = label.length - zhLength;
+            return `${Math.max(chLength * 8 + zhLength * 20, 80)}px`;
+          };
+          props.config.type = "groupList";
+          props.config.enableToggleMode = true;
+          props.config.tableItems = props.config.items;
+          props.config.items = props.config.groupItems || props.config.items.map((item) => {
+            const text = item.text || item.label;
+            const labelWidth = calcLabelWidth(text);
+            return {
+              ...item,
+              text,
+              labelWidth,
+              span: item.span || 12
+            };
+          });
+        },
+        toggleFullscreen() {
+          if (isFullscreen.value) {
+            mTable.value?.classList.remove("fixed");
+            isFullscreen.value = false;
+          } else {
+            mTable.value?.classList.add("fixed");
+            isFullscreen.value = true;
+          }
+        },
+        getProp(index) {
+          const { prop } = vue.toRefs(props);
+          return `${prop.value}${prop.value ? "." : ""}${index + 1 + pagecontext.value * pagesize.value - 1}`;
+        }
+      };
+    }
+  });
+  const _hoisted_1$b = ["innerHTML"];
+  const _hoisted_2$2 = { class: "el-form-item__content" };
+  const _hoisted_3$2 = ["innerHTML"];
+  const _hoisted_4$1 = /* @__PURE__ */ vue.createTextVNode("\u6DFB\u52A0");
+  const _hoisted_5 = /* @__PURE__ */ vue.createTextVNode(" \xA0 ");
+  const _hoisted_6 = /* @__PURE__ */ vue.createTextVNode("\u5C55\u5F00\u914D\u7F6E");
+  const _hoisted_7 = /* @__PURE__ */ vue.createTextVNode("\u5BFC\u5165EXCEL");
+  const _hoisted_8 = /* @__PURE__ */ vue.createTextVNode("\xA0 ");
+  const _hoisted_9 = /* @__PURE__ */ vue.createTextVNode("\u6E05\u7A7A");
+  const _hoisted_10 = {
+    class: "bottom",
+    style: { "text-align": "right" }
+  };
+  function _sfc_render$i(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_table_column = vue.resolveComponent("el-table-column");
+    const _component_el_button = vue.resolveComponent("el-button");
+    const _component_el_tooltip = vue.resolveComponent("el-tooltip");
+    const _component_m_form_container = vue.resolveComponent("m-form-container");
+    const _component_el_table = vue.resolveComponent("el-table");
+    const _component_el_upload = vue.resolveComponent("el-upload");
+    const _component_el_pagination = vue.resolveComponent("el-pagination");
+    return vue.openBlock(), vue.createElementBlock("div", {
+      ref: "mTable",
+      class: vue.normalizeClass(["m-fields-table", { "m-fields-table-item-extra": _ctx.config.itemExtra }])
+    }, [
+      _ctx.config.extra ? (vue.openBlock(), vue.createElementBlock("span", {
+        key: 0,
+        style: { "color": "rgba(0, 0, 0, 0.45)" },
+        innerHTML: _ctx.config.extra
+      }, null, 8, _hoisted_1$b)) : vue.createCommentVNode("", true),
+      vue.createElementVNode("div", _hoisted_2$2, [
+        vue.createVNode(_component_el_tooltip, {
+          content: "\u62D6\u62FD\u53EF\u6392\u5E8F",
+          placement: "left-start",
+          disabled: _ctx.config.dropSort !== true
+        }, {
+          default: vue.withCtx(() => [
+            _ctx.model[_ctx.modelName] ? (vue.openBlock(), vue.createBlock(_component_el_table, {
+              ref: "elTable",
+              style: { "width": "100%" },
+              data: _ctx.model[_ctx.modelName],
+              border: _ctx.config.border,
+              "max-height": _ctx.config.maxHeight,
+              "default-expand-all": true,
+              key: _ctx.updateKey,
+              onSelect: _ctx.selectHandle,
+              onSortChange: _ctx.sortChange
+            }, {
+              default: vue.withCtx(() => [
+                _ctx.config.itemExtra ? (vue.openBlock(), vue.createBlock(_component_el_table_column, {
+                  key: 0,
+                  fixed: "left",
+                  width: "30",
+                  type: "expand"
+                }, {
+                  default: vue.withCtx((scope) => [
+                    vue.createElementVNode("span", {
+                      innerHTML: _ctx.itemExtra(_ctx.config.itemExtra, scope.$index),
+                      class: "m-form-tip"
+                    }, null, 8, _hoisted_3$2)
+                  ]),
+                  _: 1
+                })) : vue.createCommentVNode("", true),
+                vue.createVNode(_component_el_table_column, {
+                  label: "\u64CD\u4F5C",
+                  width: "50",
+                  fixed: _ctx.config.fixed === false ? void 0 : "left"
+                }, {
+                  default: vue.withCtx((scope) => [
+                    vue.withDirectives(vue.createVNode(_component_el_button, {
+                      style: { "color": "#f56c6c" },
+                      type: "text",
+                      icon: _ctx.Delete,
+                      onClick: ($event) => _ctx.removeHandler(scope.$index + 1 + _ctx.pagecontext * _ctx.pagesize - 1)
+                    }, null, 8, ["icon", "onClick"]), [
+                      [vue.vShow, _ctx.showDelete(scope.$index + 1 + _ctx.pagecontext * _ctx.pagesize - 1)]
+                    ])
+                  ]),
+                  _: 1
+                }, 8, ["fixed"]),
+                _ctx.sort && _ctx.model[_ctx.modelName] && _ctx.model[_ctx.modelName].length > 1 ? (vue.openBlock(), vue.createBlock(_component_el_table_column, {
+                  key: 1,
+                  label: "\u6392\u5E8F",
+                  width: "70"
+                }, {
+                  default: vue.withCtx((scope) => [
+                    scope.$index + 1 + _ctx.pagecontext * _ctx.pagesize - 1 !== 0 ? (vue.openBlock(), vue.createBlock(_component_el_tooltip, {
+                      key: 0,
+                      content: "\u70B9\u51FB\u4E0A\u79FB\uFF0C\u53CC\u51FB\u7F6E\u9876",
+                      placement: "top"
+                    }, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(_component_el_button, {
+                          plain: "",
+                          size: "small",
+                          icon: _ctx.ArrowUp,
+                          type: "text",
+                          onClick: ($event) => _ctx.upHandler(scope.$index + 1 + _ctx.pagecontext * _ctx.pagesize - 1),
+                          onDblclick: ($event) => _ctx.topHandler(scope.$index + 1 + _ctx.pagecontext * _ctx.pagesize - 1)
+                        }, null, 8, ["icon", "onClick", "onDblclick"])
+                      ]),
+                      _: 2
+                    }, 1024)) : vue.createCommentVNode("", true),
+                    scope.$index + 1 + _ctx.pagecontext * _ctx.pagesize - 1 !== _ctx.model[_ctx.modelName].length - 1 ? (vue.openBlock(), vue.createBlock(_component_el_tooltip, {
+                      key: 1,
+                      content: "\u70B9\u51FB\u4E0B\u79FB\uFF0C\u53CC\u51FB\u7F6E\u5E95",
+                      placement: "top"
+                    }, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(_component_el_button, {
+                          plain: "",
+                          size: "small",
+                          icon: _ctx.ArrowDown,
+                          type: "text",
+                          onClick: ($event) => _ctx.downHandler(scope.$index + 1 + _ctx.pagecontext * _ctx.pagesize - 1),
+                          onDblclick: ($event) => _ctx.bottomHandler(scope.$index + 1 + _ctx.pagecontext * _ctx.pagesize - 1)
+                        }, null, 8, ["icon", "onClick", "onDblclick"])
+                      ]),
+                      _: 2
+                    }, 1024)) : vue.createCommentVNode("", true)
+                  ]),
+                  _: 1
+                })) : vue.createCommentVNode("", true),
+                _ctx.selection ? (vue.openBlock(), vue.createBlock(_component_el_table_column, {
+                  key: 2,
+                  align: "center",
+                  "header-align": "center",
+                  type: "selection",
+                  width: "45"
+                })) : vue.createCommentVNode("", true),
+                vue.createVNode(_component_el_table_column, {
+                  width: "50",
+                  label: "\u5E8F\u53F7"
+                }, {
+                  default: vue.withCtx((scope) => [
+                    vue.createTextVNode(vue.toDisplayString(scope.$index + 1 + _ctx.pagecontext * _ctx.pagesize), 1)
+                  ]),
+                  _: 1
+                }),
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.config.items, (column, index) => {
+                  return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+                    column.type !== "hidden" && _ctx.display(column.display) ? (vue.openBlock(), vue.createBlock(_component_el_table_column, {
+                      prop: column.name,
+                      width: column.width,
+                      label: column.label,
+                      sortable: column.sortable,
+                      "sort-orders": ["ascending", "descending"],
+                      key: column[_ctx.mForm?.keyProp || "__key"] ?? index,
+                      "class-name": _ctx.config.dropSort === true ? "el-table__column--dropable" : ""
+                    }, {
+                      default: vue.withCtx((scope) => [
+                        scope.$index > -1 ? (vue.openBlock(), vue.createBlock(_component_m_form_container, {
+                          key: 0,
+                          labelWidth: "0",
+                          prop: _ctx.getProp(scope.$index),
+                          rules: column.rules,
+                          config: _ctx.makeConfig(column),
+                          model: scope.row,
+                          size: _ctx.size,
+                          onChange: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("change", _ctx.model[_ctx.modelName]))
+                        }, null, 8, ["prop", "rules", "config", "model", "size"])) : vue.createCommentVNode("", true)
+                      ]),
+                      _: 2
+                    }, 1032, ["prop", "width", "label", "sortable", "class-name"])) : vue.createCommentVNode("", true)
+                  ], 64);
+                }), 256))
+              ]),
+              _: 1
+            }, 8, ["data", "border", "max-height", "onSelect", "onSortChange"])) : vue.createCommentVNode("", true)
+          ]),
+          _: 1
+        }, 8, ["disabled"]),
+        vue.renderSlot(_ctx.$slots, "default"),
+        _ctx.addable ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+          key: 0,
+          size: "small",
+          type: "primary",
+          plain: "",
+          onClick: _cache[1] || (_cache[1] = ($event) => _ctx.newHandler())
+        }, {
+          default: vue.withCtx(() => [
+            _hoisted_4$1
+          ]),
+          _: 1
+        })) : vue.createCommentVNode("", true),
+        _hoisted_5,
+        _ctx.enableToggleMode && !_ctx.isFullscreen ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+          key: 1,
+          icon: "el-icon-s-grid",
+          size: "small",
+          onClick: _ctx.toggleMode
+        }, {
+          default: vue.withCtx(() => [
+            _hoisted_6
+          ]),
+          _: 1
+        }, 8, ["onClick"])) : vue.createCommentVNode("", true),
+        _ctx.config.enableFullscreen !== false ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+          key: 2,
+          icon: "el-icon-s-grid",
+          size: "small",
+          onClick: _ctx.toggleFullscreen
+        }, {
+          default: vue.withCtx(() => [
+            vue.createTextVNode(vue.toDisplayString(_ctx.isFullscreen ? "\u9000\u51FA\u5168\u5C4F" : "\u5168\u5C4F\u7F16\u8F91"), 1)
+          ]),
+          _: 1
+        }, 8, ["onClick"])) : vue.createCommentVNode("", true),
+        _ctx.importable ? (vue.openBlock(), vue.createBlock(_component_el_upload, {
+          key: 3,
+          ref: "excelBtn",
+          action: "/noop",
+          "on-change": _ctx.excelHandler,
+          "auto-upload": false,
+          style: { "display": "inline-block" }
+        }, {
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_el_button, {
+              size: "small",
+              type: "success",
+              plain: ""
+            }, {
+              default: vue.withCtx(() => [
+                _hoisted_7
+              ]),
+              _: 1
+            })
+          ]),
+          _: 1
+        }, 8, ["on-change"])) : vue.createCommentVNode("", true),
+        _hoisted_8,
+        _ctx.importable ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+          key: 4,
+          size: "small",
+          type: "warning",
+          plain: "",
+          onClick: _cache[2] || (_cache[2] = ($event) => _ctx.clearHandler())
+        }, {
+          default: vue.withCtx(() => [
+            _hoisted_9
+          ]),
+          _: 1
+        })) : vue.createCommentVNode("", true)
+      ]),
+      vue.createElementVNode("div", _hoisted_10, [
+        vue.createVNode(_component_el_pagination, {
+          layout: "total, sizes, prev, pager, next, jumper",
+          "hide-on-single-page": _ctx.model[_ctx.modelName].length < _ctx.pagesize,
+          "current-page": _ctx.pagecontext + 1,
+          "page-sizes": [_ctx.pagesize, 60, 120, 300],
+          "page-size": _ctx.pagesize,
+          total: _ctx.model[_ctx.modelName].length,
+          onSizeChange: _ctx.handleSizeChange,
+          onCurrentChange: _ctx.handleCurrentChange
+        }, null, 8, ["hide-on-single-page", "current-page", "page-sizes", "page-size", "total", "onSizeChange", "onCurrentChange"])
+      ])
+    ], 2);
+  }
+  var Table = /* @__PURE__ */ _export_sfc(_sfc_main$l, [["render", _sfc_render$i]]);
+
+  const getActive = (mForm, props, activeTabName) => {
+    const { config, model, prop } = props;
+    const { active } = config;
+    if (typeof active === "function")
+      return active(mForm, { model, formValue: mForm?.values, prop });
+    if (+activeTabName >= props.config.items.length)
+      return "0";
+    if (typeof active !== "undefined")
+      return active;
+    return "0";
+  };
+  const tabClickHandler = (mForm, tab, props) => {
+    const { config, model, prop } = props;
+    if (typeof config.onTabClick === "function") {
+      config.onTabClick(mForm, tab, { model, formValue: mForm?.values, prop });
+    }
+    const tabConfig = config.items.find((item) => tab.name === item.status);
+    if (tabConfig && typeof tabConfig.onTabClick === "function") {
+      tabConfig.onTabClick(mForm, tab, { model, formValue: mForm?.values, prop });
+    }
+  };
+  const Tab = vue.defineComponent({
+    name: "m-form-tab",
+    props: {
+      labelWidth: String,
+      expandMore: Boolean,
+      model: {
+        type: Object,
+        default: () => ({})
+      },
+      config: {
+        type: Object,
+        default: () => ({})
+      },
+      prop: String,
+      size: String
+    },
+    emits: {
+      change(values) {
+        return values;
+      }
+    },
+    setup(props, { emit }) {
+      const mForm = vue.inject("mForm");
+      const activeTabName = vue.ref(getActive(mForm, props, ""));
+      const tabs = vue.computed(() => {
+        if (props.config.dynamic) {
+          if (!props.config.name)
+            throw new Error("dynamic tab \u5FC5\u987B\u914D\u7F6Ename");
+          return props.model[props.config.name] || [];
+        }
+        return props.config.items;
+      });
+      const filter = (config) => filterFunction(mForm, config, props);
+      vue.watchEffect(() => {
+        if (typeof props.config.activeChange === "function") {
+          props.config.activeChange(mForm, activeTabName.value, {
+            model: props.model,
+            prop: props.prop
+          });
+        }
+      });
+      return {
+        mForm,
+        activeTabName,
+        tabs,
+        filter,
+        tabItems: (tab) => props.config.dynamic ? props.config.items : tab.items,
+        tabClickHandler: (tab) => tabClickHandler(mForm, tab, props),
+        onTabAdd: () => {
+          if (!props.config.name)
+            throw new Error("dynamic tab \u5FC5\u987B\u914D\u7F6Ename");
+          if (typeof props.config.onTabAdd === "function") {
+            props.config.onTabAdd(mForm, { model: props.model });
+          } else if (tabs.value.length > 0) {
+            const newObj = lodashEs.cloneDeep(tabs.value[0]);
+            newObj.title = `\u6807\u7B7E${tabs.value.length + 1}`;
+            props.model[props.config.name].push(newObj);
+          }
+          emit("change", props.model);
+          mForm?.$emit("field-change", props.prop, props.model[props.config.name]);
+        },
+        onTabRemove: (tabName) => {
+          if (!props.config.name)
+            throw new Error("dynamic tab \u5FC5\u987B\u914D\u7F6Ename");
+          if (typeof props.config.onTabRemove === "function") {
+            props.config.onTabRemove(mForm, tabName, { model: props.model });
+          } else {
+            props.model[props.config.name].splice(+tabName, 1);
+            if (tabName < activeTabName.value || activeTabName.value >= props.model[props.config.name].length) {
+              activeTabName.value = (+activeTabName.value - 1).toString();
+              tabClickHandler(mForm, { name: activeTabName.value }, props);
+            }
+          }
+          emit("change", props.model);
+          mForm?.$emit("field-change", props.prop, props.model[props.config.name]);
+        },
+        display: (displayConfig) => display(mForm, displayConfig, props),
+        changeHandler: () => {
+          emit("change", props.model);
+          if (typeof props.config.onChange === "function") {
+            props.config.onChange(mForm, { model: props.model });
+          }
+        }
+      };
+    }
+  });
+  const _sfc_main$k = Tab;
+  function _sfc_render$h(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_m_form_container = vue.resolveComponent("m-form-container");
+    const _component_el_tab_pane = vue.resolveComponent("el-tab-pane");
+    const _component_el_tabs = vue.resolveComponent("el-tabs");
+    return vue.openBlock(), vue.createBlock(_component_el_tabs, {
+      modelValue: _ctx.activeTabName,
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.activeTabName = $event),
+      class: vue.normalizeClass(_ctx.config.dynamic ? "magic-form-dynamic-tab" : "magic-form-tab"),
+      type: _ctx.config.tabType,
+      editable: _ctx.config.editable || false,
+      "tab-position": _ctx.config.tabPosition || "top",
+      onTabClick: _ctx.tabClickHandler,
+      onTabAdd: _ctx.onTabAdd,
+      onTabRemove: _ctx.onTabRemove
+    }, {
+      default: vue.withCtx(() => [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.tabs, (tab, tabIndex) => {
+          return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+            _ctx.display(tab.display) && _ctx.tabItems(tab).length ? (vue.openBlock(), vue.createBlock(_component_el_tab_pane, {
+              key: tab[_ctx.mForm?.keyProp || "__key"] ?? tabIndex,
+              name: _ctx.filter(tab.status) || tabIndex.toString(),
+              label: _ctx.filter(tab.title),
+              lazy: tab.lazy || false
+            }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.tabItems(tab), (item) => {
+                  return vue.openBlock(), vue.createBlock(_component_m_form_container, {
+                    key: item[_ctx.mForm?.keyProp || "__key"],
+                    config: item,
+                    model: _ctx.config.dynamic ? _ctx.model[_ctx.config.name || ""][tabIndex] : tab.name ? _ctx.model[tab.name] : _ctx.model,
+                    prop: _ctx.config.dynamic ? `${_ctx.prop}${_ctx.prop ? "." : ""}${String(tabIndex)}` : _ctx.prop,
+                    size: _ctx.size,
+                    "label-width": tab.labelWidth || _ctx.labelWidth,
+                    "expand-more": _ctx.expandMore,
+                    onChange: _ctx.changeHandler
+                  }, null, 8, ["config", "model", "prop", "size", "label-width", "expand-more", "onChange"]);
+                }), 128))
+              ]),
+              _: 2
+            }, 1032, ["name", "label", "lazy"])) : vue.createCommentVNode("", true)
+          ], 64);
+        }), 256))
+      ]),
+      _: 1
+    }, 8, ["modelValue", "class", "type", "editable", "tab-position", "onTabClick", "onTabAdd", "onTabRemove"]);
+  }
+  var Tabs = /* @__PURE__ */ _export_sfc(_sfc_main$k, [["render", _sfc_render$h]]);
+
+  let $MAGIC_FORM = {};
+  const setConfig = (option) => {
+    $MAGIC_FORM = option;
+  };
+  const getConfig = (key) => $MAGIC_FORM[key];
+
+  var fieldProps = {
+    model: {
+      type: Object,
+      required: true,
+      default: () => ({})
+    },
+    name: {
+      type: String,
+      default: ""
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    size: String,
+    prop: String,
+    initValues: Object,
+    values: Object
+  };
+
+  const useAddField = (prop) => {
+    if (!prop)
+      return;
+    const mForm = vue.inject("mForm");
+    const instance = vue.getCurrentInstance();
+    vue.watch(() => instance?.proxy, (vm) => {
+      if (vm) {
+        mForm?.setField(prop, vm);
+      } else {
+        mForm?.deleteField(prop);
+      }
+    }, {
+      immediate: true
+    });
+  };
+
+  const _sfc_main$j = vue.defineComponent({
+    name: "m-fields-cascader",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      const mForm = vue.inject("mForm");
+      const vm = vue.getCurrentInstance();
+      useAddField(props.prop);
+      const requestFunc = getConfig("request");
+      const cascader = vue.ref(null);
+      const dialog = vue.ref(null);
+      const options = Array.isArray(props.config.options) ? vue.ref(props.config.options) : vue.ref([]);
+      const remoteData = vue.ref(null);
+      const setRemoteOptions = async function() {
+        const { config } = props;
+        const { option } = config;
+        if (!option)
+          return;
+        let { body } = option;
+        const postOptions = {
+          url: option.url,
+          cache: option.cache,
+          timeout: option.timeout,
+          data: {}
+        };
+        if (body && mForm) {
+          if (typeof body === "function" && props.model && mForm) {
+            body = body(mForm, {
+              model: props.model,
+              formValue: null,
+              formValues: mForm.values
+            });
+          }
+          postOptions.data = body;
+        }
+        const res = await requestFunc(postOptions);
+        remoteData.value = res[option.root];
+        if (remoteData.value && typeof option?.item === "function") {
+          options.value = option.item(res[option.root]);
+        }
+      };
+      if (typeof props.config.options === "function" && props.model && mForm) {
+        vue.watchEffect(() => options.value = props.config.options(vm, { model: props.model, formValues: mForm.values }));
+      } else if (!props.config.options || !props.config.options.length || props.config.remote) {
+        Promise.resolve(setRemoteOptions());
+      }
+      const action = vue.computed(() => {
+        if (props.config.add?.action.method === "post") {
+          return (options2) => requestFunc({
+            ...props.config?.add?.action.body,
+            ...options2
+          });
+        }
+        return null;
+      });
+      return {
+        options,
+        remoteData,
+        addButtonStyle: {
+          top: 0,
+          left: 0,
+          width: "auto"
+        },
+        dialogVisible: false,
+        cascader,
+        dialog,
+        action,
+        setRemoteOptions,
+        changeHandler: (value) => {
+          if (!cascader.value)
+            return;
+          cascader.value.query = "";
+          cascader.value.previousQuery = null;
+          emit("change", value);
+        },
+        addHandler: () => {
+          if (!dialog.value)
+            return;
+          dialog.value.dialogVisible = true;
+        },
+        editAfterAction: () => {
+          setRemoteOptions();
+        }
+      };
+    }
+  });
+  const _hoisted_1$a = {
+    class: "m-cascader",
+    style: { "width": "100%" }
+  };
+  function _sfc_render$g(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_cascader = vue.resolveComponent("el-cascader");
+    return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$a, [
+      vue.createVNode(_component_el_cascader, {
+        modelValue: _ctx.model[_ctx.name],
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.name] = $event),
+        ref: "cascader",
+        style: { "width": "100%" },
+        clearable: "",
+        filterable: "",
+        size: _ctx.size,
+        placeholder: _ctx.config.placeholder,
+        disabled: _ctx.disabled,
+        options: _ctx.options,
+        props: { multiple: _ctx.config.multiple },
+        onChange: _ctx.changeHandler
+      }, null, 8, ["modelValue", "size", "placeholder", "disabled", "options", "props", "onChange"])
+    ]);
+  }
+  var Cascader = /* @__PURE__ */ _export_sfc(_sfc_main$j, [["render", _sfc_render$g]]);
+
+  const _sfc_main$i = vue.defineComponent({
+    name: "m-fields-checkbox",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change", "input"],
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      return {
+        activeValue: vue.computed(() => {
+          if (typeof props.config.activeValue === "undefined") {
+            if (props.config.filter === "number") {
+              return 1;
+            }
+          } else {
+            return props.config.activeValue;
+          }
+          return "true";
+        }),
+        inactiveValue: vue.computed(() => {
+          if (typeof props.config.inactiveValue === "undefined") {
+            if (props.config.filter === "number") {
+              return 0;
+            }
+          } else {
+            return props.config.inactiveValue;
+          }
+          return "false";
+        }),
+        changeHandler(value) {
+          emit("change", value);
+        }
+      };
+    }
+  });
+  function _sfc_render$f(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_checkbox = vue.resolveComponent("el-checkbox");
+    return vue.openBlock(), vue.createBlock(_component_el_checkbox, {
+      modelValue: _ctx.model[_ctx.name],
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.name] = $event),
+      size: _ctx.size,
+      trueLabel: _ctx.activeValue,
+      falseLabel: _ctx.inactiveValue,
+      disabled: _ctx.disabled,
+      label: _ctx.config.text,
+      onChange: _ctx.changeHandler
+    }, null, 8, ["modelValue", "size", "trueLabel", "falseLabel", "disabled", "label", "onChange"]);
+  }
+  var Checkbox = /* @__PURE__ */ _export_sfc(_sfc_main$i, [["render", _sfc_render$f]]);
+
+  const _sfc_main$h = vue.defineComponent({
+    name: "m-fields-checkbox-group",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      if (props.model && !props.model[props.name]) {
+        props.model[props.name] = [];
+      }
+      return {
+        changeHandler: (v) => {
+          emit("change", v);
+        }
+      };
+    }
+  });
+  function _sfc_render$e(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_checkbox = vue.resolveComponent("el-checkbox");
+    const _component_el_checkbox_group = vue.resolveComponent("el-checkbox-group");
+    return vue.openBlock(), vue.createBlock(_component_el_checkbox_group, {
+      modelValue: _ctx.model[_ctx.name],
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.name] = $event),
+      size: _ctx.size,
+      disabled: _ctx.disabled,
+      onChange: _ctx.changeHandler
+    }, {
+      default: vue.withCtx(() => [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.config.options, (option) => {
+          return vue.openBlock(), vue.createBlock(_component_el_checkbox, {
+            label: option.value,
+            key: option.value
+          }, {
+            default: vue.withCtx(() => [
+              vue.createTextVNode(vue.toDisplayString(option.text), 1)
+            ]),
+            _: 2
+          }, 1032, ["label"]);
+        }), 128))
+      ]),
+      _: 1
+    }, 8, ["modelValue", "size", "disabled", "onChange"]);
+  }
+  var CheckboxGroup = /* @__PURE__ */ _export_sfc(_sfc_main$h, [["render", _sfc_render$e]]);
+
+  const _hoisted_1$9 = { key: 0 };
+  const __default__$2 = vue.defineComponent({
+    name: "m-fields-color-picker"
+  });
+  const _sfc_main$g = /* @__PURE__ */ vue.defineComponent({
+    ...__default__$2,
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change"],
+    setup(__props, { emit }) {
+      const props = __props;
+      useAddField(props.prop);
+      const changeHandler = (value) => emit("change", value);
+      return (_ctx, _cache) => {
+        const _component_el_color_picker = vue.resolveComponent("el-color-picker");
+        return _ctx.model ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$9, [
+          vue.createVNode(_component_el_color_picker, {
+            modelValue: _ctx.model[_ctx.name],
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.name] = $event),
+            size: _ctx.size,
+            disabled: _ctx.disabled,
+            showAlpha: true,
+            onChange: changeHandler
+          }, null, 8, ["modelValue", "size", "disabled"])
+        ])) : vue.createCommentVNode("", true);
+      };
+    }
+  });
+
+  const _sfc_main$f = vue.defineComponent({
+    name: "m-fields-date",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change", "input"],
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      const modelName = vue.computed(() => props.prop || props.config.name || "");
+      props.model[modelName.value] = utils.datetimeFormatter(props.model[modelName.value], "");
+      return {
+        modelName,
+        changeHandler(v) {
+          emit("change", v);
+        }
+      };
+    }
+  });
+  const _hoisted_1$8 = { key: 0 };
+  function _sfc_render$d(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_date_picker = vue.resolveComponent("el-date-picker");
+    return _ctx.model ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$8, [
+      vue.createVNode(_component_el_date_picker, {
+        modelValue: _ctx.model[_ctx.modelName],
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.modelName] = $event),
+        type: "date",
+        size: _ctx.size,
+        placeholder: _ctx.config.placeholder,
+        disabled: _ctx.disabled,
+        format: _ctx.config.format,
+        "value-format": _ctx.config.format || "YYYY-MM-DD HH:mm:ss",
+        onChange: _ctx.changeHandler
+      }, null, 8, ["modelValue", "size", "placeholder", "disabled", "format", "value-format", "onChange"])
+    ])) : vue.createCommentVNode("", true);
+  }
+  var Date$1 = /* @__PURE__ */ _export_sfc(_sfc_main$f, [["render", _sfc_render$d]]);
+
+  const _sfc_main$e = vue.defineComponent({
+    name: "m-fields-daterange",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      const { names } = props.config;
+      const value = vue.ref([]);
+      if (props.model !== void 0) {
+        if (names?.length) {
+          value.value = names.map((item) => utils.datetimeFormatter(props.model?.[item], ""));
+        } else if (props.name && props.model[props.name]) {
+          value.value = props.model[props.name].map((item) => utils.datetimeFormatter(item, ""));
+        }
+      }
+      const setValue = (v) => {
+        if (names?.length && v instanceof Array) {
+          names.forEach((item, index) => {
+            if (props.model) {
+              props.model[item] = utils.datetimeFormatter(v[index].toString(), "");
+            }
+          });
+        } else if (props.model && props.name && v instanceof Date) {
+          props.model[props.name] = utils.datetimeFormatter(v.toString(), "");
+        }
+      };
+      return {
+        value,
+        changeHandler(v) {
+          setValue(v);
+          emit("change", v);
+        }
+      };
+    }
+  });
+  function _sfc_render$c(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_date_picker = vue.resolveComponent("el-date-picker");
+    return vue.openBlock(), vue.createElementBlock("div", null, [
+      vue.createVNode(_component_el_date_picker, {
+        modelValue: _ctx.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.value = $event),
+        type: "datetimerange",
+        "range-separator": "-",
+        "start-placeholder": "\u5F00\u59CB\u65E5\u671F",
+        "end-placeholder": "\u7ED3\u675F\u65E5\u671F",
+        size: _ctx.size,
+        "unlink-panels": true,
+        disabled: _ctx.disabled,
+        onChange: _ctx.changeHandler
+      }, null, 8, ["modelValue", "size", "disabled", "onChange"])
+    ]);
+  }
+  var Daterange = /* @__PURE__ */ _export_sfc(_sfc_main$e, [["render", _sfc_render$c]]);
+
+  const _sfc_main$d = vue.defineComponent({
+    name: "m-fields-datetime",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      const value = props.model?.[props.name].toString();
+      if (props.model) {
+        if (value === "Invalid Date") {
+          props.model[props.name] = "";
+        } else {
+          props.model[props.name] = utils.datetimeFormatter(props.model[props.name], "", props.config.valueFormat);
+        }
+      }
+      return {
+        value,
+        changeHandler: (v) => {
+          emit("change", v);
+        }
+      };
+    }
+  });
+  const _hoisted_1$7 = { key: 0 };
+  function _sfc_render$b(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_date_picker = vue.resolveComponent("el-date-picker");
+    return _ctx.model ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$7, [
+      vue.createVNode(_component_el_date_picker, {
+        modelValue: _ctx.model[_ctx.name],
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.name] = $event),
+        "popper-class": "magic-datetime-picker-popper",
+        type: "datetime",
+        size: _ctx.size,
+        placeholder: _ctx.config.placeholder,
+        disabled: _ctx.disabled,
+        format: _ctx.config.format || "YYYY-MM-DD HH:mm:ss",
+        "value-format": _ctx.config.valueFormat || "YYYY-MM-DD HH:mm:ss",
+        onChange: _ctx.changeHandler
+      }, null, 8, ["modelValue", "size", "placeholder", "disabled", "format", "value-format", "onChange"])
+    ])) : vue.createCommentVNode("", true);
+  }
+  var DateTime = /* @__PURE__ */ _export_sfc(_sfc_main$d, [["render", _sfc_render$b]]);
+
+  const _hoisted_1$6 = { key: 0 };
+  const __default__$1 = vue.defineComponent({
+    name: "m-fields-display"
+  });
+  const _sfc_main$c = /* @__PURE__ */ vue.defineComponent({
+    ...__default__$1,
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    setup(__props) {
+      const props = __props;
+      const n = vue.computed(() => props.name || props.config.name || "");
+      if (props.config.initValue && n.value && props.model) {
+        props.model[n.value] = props.config.initValue;
+      }
+      useAddField(props.prop);
+      return (_ctx, _cache) => {
+        return _ctx.model ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_1$6, vue.toDisplayString(_ctx.model[vue.unref(n)]), 1)) : vue.createCommentVNode("", true);
+      };
+    }
+  });
+
+  const _sfc_main$b = vue.defineComponent({
+    name: "m-fields-dynamic-field",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      const request = getConfig("request");
+      const fieldMap = vue.reactive({
+        value: {}
+      });
+      const fieldLabelMap = vue.reactive({
+        value: {}
+      });
+      const changeFieldMap = async () => {
+        if (typeof props.config.returnFields !== "function" || !props.model)
+          return;
+        const fields = await props.config.returnFields(props.config, props.model, request);
+        fieldMap.value = {};
+        fieldLabelMap.value = {};
+        fields.forEach((v) => {
+          if (typeof v !== "object" || v.name === void 0)
+            return;
+          let oldVal = props.model?.[v.name] || "";
+          if (!oldVal && v.defaultValue !== void 0) {
+            oldVal = v.defaultValue;
+            emit("change", oldVal, v.name);
+          }
+          fieldMap.value[v.name] = oldVal;
+          fieldLabelMap.value[v.name] = v.label || "";
+        });
+      };
+      const unwatch = vue.watch(() => props.model?.[props.config.dynamicKey], (val) => {
+        if (val !== "") {
+          changeFieldMap();
+        }
+      }, {
+        immediate: true
+      });
+      vue.onBeforeUnmount(() => {
+        if (typeof unwatch === "function") {
+          unwatch();
+        }
+      });
+      return {
+        request,
+        fieldMap,
+        fieldLabelMap,
+        unwatch,
+        changeFieldMap,
+        inputChangeHandler: (key) => {
+          emit("change", fieldMap.value[key], key);
+        }
+      };
+    },
+    methods: {
+      init() {
+      }
+    }
+  });
+  const _hoisted_1$5 = { class: "m-fields-dynamic-field" };
+  function _sfc_render$a(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_input = vue.resolveComponent("el-input");
+    const _component_el_form_item = vue.resolveComponent("el-form-item");
+    const _component_el_form = vue.resolveComponent("el-form");
+    return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$5, [
+      vue.createVNode(_component_el_form, { size: "small" }, {
+        default: vue.withCtx(() => [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(Object.keys(_ctx.fieldMap.value), (key) => {
+            return vue.openBlock(), vue.createBlock(_component_el_form_item, {
+              key,
+              label: _ctx.fieldLabelMap.value[key]
+            }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(_component_el_input, {
+                  modelValue: _ctx.fieldMap.value[key],
+                  "onUpdate:modelValue": ($event) => _ctx.fieldMap.value[key] = $event,
+                  placeholder: _ctx.fieldLabelMap.value[key],
+                  onChange: ($event) => _ctx.inputChangeHandler(key)
+                }, null, 8, ["modelValue", "onUpdate:modelValue", "placeholder", "onChange"])
+              ]),
+              _: 2
+            }, 1032, ["label"]);
+          }), 128))
+        ]),
+        _: 1
+      })
+    ]);
+  }
+  var DynamicField = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["render", _sfc_render$a]]);
+
+  const __default__ = vue.defineComponent({
+    name: "m-fields-hidden"
+  });
+  const _sfc_main$a = /* @__PURE__ */ vue.defineComponent({
+    ...__default__,
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    setup(__props) {
+      const props = __props;
+      const n = vue.computed(() => props.name || props.config.name || "");
+      useAddField(props.prop);
+      return (_ctx, _cache) => {
+        return _ctx.model ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("input", {
+          key: 0,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[vue.unref(n)] = $event),
+          type: "hidden"
+        }, null, 512)), [
+          [vue.vModelText, _ctx.model[vue.unref(n)]]
+        ]) : vue.createCommentVNode("", true);
+      };
+    }
+  });
+
+  const _sfc_main$9 = vue.defineComponent({
+    name: "m-fields-link",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      const formValue = vue.ref({});
+      const editor = vue.ref();
+      const mForm = vue.inject("mForm");
+      const href = vue.computed(() => {
+        if (typeof props.config.href === "function" && props.model) {
+          return props.config.href(props.model);
+        }
+        return props.config.href || props.model?.[props.name];
+      });
+      const init = () => {
+        formValue.value = props.model?.[props.name] || {};
+      };
+      return {
+        formValue,
+        editor,
+        href,
+        formConfig: vue.computed(() => {
+          if (typeof props.config.form === "function") {
+            return props.config.form(mForm, {
+              model: props.model || {},
+              values: props.values || {}
+            });
+          }
+          return props.config.form;
+        }),
+        disable: vue.computed(() => {
+          if (typeof props.config.disabled !== "undefined") {
+            return props.config.disabled;
+          }
+          return !href.value;
+        }),
+        displayText: vue.computed(() => {
+          if (typeof props.config.displayText === "function") {
+            return props.config.displayText(mForm, { model: props.model || {} });
+          }
+          if (props.config.displayText) {
+            return props.config.displayText;
+          }
+          return "\u8DF3\u8F6C";
+        }),
+        init,
+        editHandler: () => {
+          init();
+          editor.value && (editor.value.dialogVisible = true);
+        },
+        action: (data) => {
+          if (props.model) {
+            props.model[props.name] = data;
+            formValue.value = data;
+            emit("change", props.model[props.name]);
+          }
+          editor.value && (editor.value.dialogVisible = false);
+        }
+      };
+    }
+  });
+  const _hoisted_1$4 = ["href"];
+  const _hoisted_2$1 = {
+    key: 2,
+    class: "m-fields-link"
+  };
+  const _hoisted_3$1 = /* @__PURE__ */ vue.createTextVNode("\u70B9\u51FB\u7F16\u8F91");
+  function _sfc_render$9(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_button = vue.resolveComponent("el-button");
+    const _component_m_form_dialog = vue.resolveComponent("m-form-dialog");
+    return _ctx.config.href && !_ctx.disabled ? (vue.openBlock(), vue.createElementBlock("a", {
+      key: 0,
+      target: "_blank",
+      href: _ctx.href,
+      style: vue.normalizeStyle(_ctx.config.css || {})
+    }, vue.toDisplayString(_ctx.displayText), 13, _hoisted_1$4)) : _ctx.config.href && _ctx.disabled ? (vue.openBlock(), vue.createElementBlock("span", {
+      key: 1,
+      style: vue.normalizeStyle(_ctx.config.disabledCss || {})
+    }, vue.toDisplayString(_ctx.displayText), 5)) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$1, [
+      vue.createVNode(_component_el_button, {
+        type: "text",
+        onClick: _ctx.editHandler
+      }, {
+        default: vue.withCtx(() => [
+          _hoisted_3$1
+        ]),
+        _: 1
+      }, 8, ["onClick"]),
+      vue.createVNode(_component_m_form_dialog, {
+        ref: "editor",
+        title: _ctx.config.formTitle || "\u7F16\u8F91\u6269\u5C55\u914D\u7F6E",
+        width: _ctx.config.formWidth,
+        values: _ctx.formValue,
+        config: _ctx.formConfig,
+        parentValues: _ctx.values,
+        fullscreen: _ctx.config.fullscreen,
+        onSubmit: _ctx.action
+      }, null, 8, ["title", "width", "values", "config", "parentValues", "fullscreen", "onSubmit"])
+    ]));
+  }
+  var Link = /* @__PURE__ */ _export_sfc(_sfc_main$9, [["render", _sfc_render$9]]);
+
+  const _sfc_main$8 = vue.defineComponent({
+    name: "m-fields-number",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change", "input"],
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      const mForm = vue.inject("mForm");
+      return {
+        mForm,
+        changeHandler: (value) => {
+          emit("change", value);
+        },
+        inputHandler: (v) => {
+          emit("input", v);
+          mForm?.$emit("field-input", props.prop, v);
+        }
+      };
+    }
+  });
+  function _sfc_render$8(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_input_number = vue.resolveComponent("el-input-number");
+    return _ctx.model ? (vue.openBlock(), vue.createBlock(_component_el_input_number, {
+      key: 0,
+      modelValue: _ctx.model[_ctx.name],
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.name] = $event),
+      clearable: "",
+      "controls-position": "right",
+      size: _ctx.size,
+      max: _ctx.config.max,
+      min: _ctx.config.min,
+      step: _ctx.config.step,
+      placeholder: _ctx.config.placeholder,
+      disabled: _ctx.disabled,
+      onChange: _ctx.changeHandler,
+      onInput: _ctx.inputHandler
+    }, null, 8, ["modelValue", "size", "max", "min", "step", "placeholder", "disabled", "onChange", "onInput"])) : vue.createCommentVNode("", true);
+  }
+  var Number$1 = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["render", _sfc_render$8]]);
+
+  const _sfc_main$7 = vue.defineComponent({
+    name: "m-fields-radio-group",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      return {
+        changeHandler: (v) => emit("change", v)
+      };
+    }
+  });
+  function _sfc_render$7(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_radio = vue.resolveComponent("el-radio");
+    const _component_el_radio_group = vue.resolveComponent("el-radio-group");
+    return _ctx.model ? (vue.openBlock(), vue.createBlock(_component_el_radio_group, {
+      key: 0,
+      modelValue: _ctx.model[_ctx.name],
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.name] = $event),
+      size: _ctx.size,
+      disabled: _ctx.disabled,
+      onChange: _ctx.changeHandler
+    }, {
+      default: vue.withCtx(() => [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.config.options, (option) => {
+          return vue.openBlock(), vue.createBlock(_component_el_radio, {
+            label: option.value,
+            key: option.value
+          }, {
+            default: vue.withCtx(() => [
+              vue.createTextVNode(vue.toDisplayString(option.text), 1)
+            ]),
+            _: 2
+          }, 1032, ["label"]);
+        }), 128))
+      ]),
+      _: 1
+    }, 8, ["modelValue", "size", "disabled", "onChange"])) : vue.createCommentVNode("", true);
+  }
+  var RadioGroup = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["render", _sfc_render$7]]);
+
+  const _sfc_main$6 = vue.defineComponent({
+    name: "m-fields-select",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      if (!props.model)
+        throw new Error("\u4E0D\u80FD\u6CA1\u6709model");
+      useAddField(props.prop);
+      const select = vue.ref();
+      const mForm = vue.inject("mForm");
+      const options = vue.ref([]);
+      const localOptions = vue.ref([]);
+      const loading = vue.ref(false);
+      const moreLoadingVisible = vue.ref(false);
+      const total = vue.ref(0);
+      const pgIndex = vue.ref(0);
+      const pgSize = vue.ref(20);
+      const query = vue.ref("");
+      const remoteData = vue.ref([]);
+      const remote = vue.ref(true);
+      const equalValue = (value, v) => {
+        if (typeof v === "object") {
+          const key = props.config.valueKey || "value";
+          return v[key] === value[key];
+        }
+        return value === v;
+      };
+      const mapOptions = (data) => {
+        const { option } = props.config;
+        const { text } = option;
+        const { value } = option;
+        return data.map((item) => ({
+          text: typeof text === "function" ? text(item) : item[text || "text"],
+          value: typeof value === "function" ? value(item) : item[value || "value"]
+        }));
+      };
+      const getOptions = async () => {
+        if (!props.model)
+          return [];
+        if (localOptions.value.length) {
+          return localOptions.value;
+        }
+        loading.value = true;
+        let items = [];
+        const { config } = props;
+        const { option } = config;
+        let { body } = option;
+        let postOptions = {
+          method: option.method || "POST",
+          url: option.url,
+          cache: option.cache,
+          timeout: option.timeout,
+          mode: option.mode,
+          headers: option.headers || {},
+          json: option.json || false
+        };
+        if (body) {
+          if (typeof body === "function") {
+            body = body(mForm, {
+              model: props.model,
+              formValue: mForm?.values,
+              formValues: mForm?.values
+            });
+          }
+          body.query = query.value;
+          body.pgSize = pgSize.value;
+          body.pgIndex = pgIndex.value;
+          postOptions.data = body;
+        }
+        const requestFuc = getConfig("request");
+        if (typeof option.beforeRequest === "function") {
+          postOptions = option.beforeRequest(mForm, postOptions, {
+            model: props.model,
+            formValue: mForm?.values
+          });
+        }
+        if (option.method?.toLocaleLowerCase() === "jsonp") {
+          postOptions.jsonpCallback = option.jsonpCallback || "callback";
+        }
+        let res = await requestFuc(postOptions);
+        if (typeof option.afterRequest === "function") {
+          res = option.afterRequest(mForm, res, {
+            model: props.model,
+            formValue: mForm?.values,
+            formValues: mForm?.values
+          });
+        }
+        const optionsData = res[option.root];
+        if (res.total > 0) {
+          total.value = res.total;
+        }
+        remoteData.value = remoteData.value.concat(optionsData);
+        if (optionsData) {
+          if (typeof option.item === "function") {
+            items = option.item(optionsData);
+          } else if (optionsData.map) {
+            items = mapOptions(optionsData);
+          }
+        }
+        loading.value = false;
+        const selectedOptions = [];
+        if (props.config.multiple && props.model[props.name]) {
+          options.value.forEach((o) => {
+            const isInclude = props.model?.[props.name].includes(o.value);
+            if (isInclude && !items.find((op) => op.value === o.value)) {
+              selectedOptions.push(o);
+            }
+          });
+        }
+        return pgIndex.value === 0 ? selectedOptions.concat(items) : options.value.concat(items);
+      };
+      const getInitLocalOption = async () => {
+        if (!props.model)
+          return [];
+        const value = props.model[props.name];
+        const { config } = props;
+        localOptions.value = await getOptions();
+        remote.value = false;
+        if (config.group) {
+          if (config.multiple && value.findIndex) {
+            return localOptions.value.filter((group) => group.options.findIndex((item) => value.find((v) => equalValue(item.value, v)) > -1) > -1);
+          }
+          return localOptions.value.filter((group) => group.options.findIndex((item) => equalValue(item.value, value)) > -1);
+        }
+        if (config.multiple && value.findIndex) {
+          return localOptions.value.filter((item) => value.findIndex((v) => equalValue(item.value, v)) > -1);
+        }
+        return localOptions.value.filter((item) => equalValue(item.value, value));
+      };
+      const getInitOption = async () => {
+        if (!props.model)
+          return [];
+        const { config } = props;
+        const { option } = config;
+        let options2 = [];
+        let url = option.initUrl;
+        if (!url) {
+          return getInitLocalOption();
+        }
+        if (typeof url === "function") {
+          url = await url(mForm, { model: props.model, formValue: mForm?.values });
+        }
+        const postOptions = {
+          method: option.method || "POST",
+          url,
+          data: {
+            id: props.model[props.name]
+          },
+          mode: option.mode,
+          headers: option.headers || {},
+          json: option.json || false
+        };
+        if (option.method?.toLocaleLowerCase() === "jsonp") {
+          postOptions.jsonpCallback = option.jsonpCallback || "callback";
+        }
+        const requestFuc = getConfig("request");
+        const res = await requestFuc(postOptions);
+        let initData = res[option.root];
+        if (initData) {
+          if (!Array.isArray(initData)) {
+            initData = [initData];
+          }
+          if (typeof option.item === "function") {
+            options2 = option.item(initData);
+          } else if (initData.map) {
+            options2 = mapOptions(initData);
+          }
+        }
+        return options2;
+      };
+      if (typeof props.config.options === "function") {
+        vue.watch(() => mForm?.values, () => {
+          typeof props.config.options === "function" && Promise.resolve(props.config.options(mForm, {
+            model: props.model,
+            formValues: mForm?.values,
+            formValue: mForm?.values
+          })).then((data) => {
+            options.value = data;
+          });
+        }, {
+          deep: true,
+          immediate: true
+        });
+      } else if (Array.isArray(props.config.options)) {
+        vue.watch(() => props.config.options, () => {
+          options.value = props.config.options;
+        }, { immediate: true });
+      } else if (props.config.option) {
+        vue.onBeforeMount(() => {
+          if (!props.model)
+            return;
+          const v = props.model[props.name];
+          if (Array.isArray(v) ? v.length : v) {
+            getInitOption().then((data) => {
+              options.value = data;
+            });
+          }
+        });
+      }
+      props.config.remote && vue.onMounted(() => {
+        select.value?.scrollbar.wrap$.addEventListener("scroll", async (e) => {
+          const el = e.currentTarget;
+          if (moreLoadingVisible.value) {
+            return;
+          }
+          if (el.scrollHeight - el.clientHeight - el.scrollTop > 1) {
+            return;
+          }
+          if (total.value <= options.value.length) {
+            return;
+          }
+          moreLoadingVisible.value = true;
+          pgIndex.value += 1;
+          options.value = await getOptions();
+          moreLoadingVisible.value = false;
+        });
+      });
+      return {
+        select,
+        loading,
+        remote,
+        options,
+        moreLoadingVisible,
+        getRequestFuc() {
+          return getConfig("request");
+        },
+        async getInitOption() {
+        },
+        changeHandler(value) {
+          emit("change", value);
+        },
+        async visibleHandler(visible) {
+          if (!visible)
+            return;
+          if (!props.config.remote)
+            return;
+          if (query.value && select.value) {
+            select.value.query = query.value;
+            select.value.previousQuery = query.value;
+            select.value.selectedLabel = query.value;
+          } else if (options.value.length <= (props.config.multiple ? props.model?.[props.name].length : 1)) {
+            options.value = await getOptions();
+          }
+        },
+        async editAfterAction() {
+          pgIndex.value = 0;
+          options.value = await getOptions();
+        },
+        async remoteMethod(q) {
+          if (!localOptions.value.length) {
+            query.value = q;
+            pgIndex.value = 0;
+            options.value = await getOptions();
+            if (props.config.multiple)
+              setTimeout(() => {
+                select.value?.setSelected();
+              }, 0);
+          }
+        }
+      };
+    }
+  });
+  const _hoisted_1$3 = { key: 2 };
+  function _sfc_render$6(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_option = vue.resolveComponent("el-option");
+    const _component_el_option_group = vue.resolveComponent("el-option-group");
+    const _component_el_select = vue.resolveComponent("el-select");
+    const _directive_loading = vue.resolveDirective("loading");
+    return _ctx.model ? vue.withDirectives((vue.openBlock(), vue.createBlock(_component_el_select, {
+      key: 0,
+      modelValue: _ctx.model[_ctx.name],
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.name] = $event),
+      class: "m-select",
+      ref: "select",
+      clearable: "",
+      filterable: "",
+      size: _ctx.size,
+      remote: _ctx.remote,
+      placeholder: _ctx.config.placeholder,
+      multiple: _ctx.config.multiple,
+      "value-key": _ctx.config.valueKey || "value",
+      "allow-create": _ctx.config.allowCreate,
+      disabled: _ctx.disabled,
+      "remote-method": _ctx.remoteMethod,
+      onChange: _ctx.changeHandler,
+      onVisibleChange: _ctx.visibleHandler
+    }, {
+      default: vue.withCtx(() => [
+        _ctx.config.group ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(_ctx.options, (group, index) => {
+          return vue.openBlock(), vue.createBlock(_component_el_option_group, {
+            key: group.label + index,
+            label: group.label,
+            disabled: group.disabled
+          }, {
+            default: vue.withCtx(() => [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(group.options, (item, index2) => {
+                return vue.openBlock(), vue.createBlock(_component_el_option, {
+                  key: item.label + index2,
+                  label: item.label,
+                  value: item.value,
+                  disabled: item.disabled
+                }, null, 8, ["label", "value", "disabled"]);
+              }), 128))
+            ]),
+            _: 2
+          }, 1032, ["label", "disabled"]);
+        }), 128)) : (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(_ctx.options, (option) => {
+          return vue.openBlock(), vue.createBlock(_component_el_option, {
+            label: option.text,
+            value: option.value,
+            key: _ctx.config.valueKey ? option.value[_ctx.config.valueKey] : option.value,
+            disabled: option.disabled
+          }, null, 8, ["label", "value", "disabled"]);
+        }), 128)),
+        _ctx.moreLoadingVisible ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", _hoisted_1$3, null, 512)), [
+          [_directive_loading, true]
+        ]) : vue.createCommentVNode("", true)
+      ]),
+      _: 1
+    }, 8, ["modelValue", "size", "remote", "placeholder", "multiple", "value-key", "allow-create", "disabled", "remote-method", "onChange", "onVisibleChange"])), [
+      [_directive_loading, _ctx.loading]
+    ]) : vue.createCommentVNode("", true);
+  }
+  var Select = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["render", _sfc_render$6]]);
+
+  const _sfc_main$5 = vue.defineComponent({
+    name: "m-fields-switch",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change"],
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      return {
+        n: vue.computed(() => props.name || props.config.name || ""),
+        activeValue: vue.computed(() => {
+          if (typeof props.config.activeValue === "undefined") {
+            if (props.config.filter === "number") {
+              return 1;
+            }
+          } else {
+            return props.config.activeValue;
+          }
+          return true;
+        }),
+        inactiveValue: vue.computed(() => {
+          if (typeof props.config.inactiveValue === "undefined") {
+            if (props.config.filter === "number") {
+              return 0;
+            }
+          } else {
+            return props.config.inactiveValue;
+          }
+          return false;
+        }),
+        changeHandler: (v) => {
+          emit("change", v);
+        }
+      };
+    }
+  });
+  function _sfc_render$5(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_switch = vue.resolveComponent("el-switch");
+    return _ctx.model ? (vue.openBlock(), vue.createBlock(_component_el_switch, {
+      key: 0,
+      modelValue: _ctx.model[_ctx.n],
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.n] = $event),
+      size: _ctx.size,
+      activeValue: _ctx.activeValue,
+      inactiveValue: _ctx.inactiveValue,
+      disabled: _ctx.disabled,
+      onChange: _ctx.changeHandler
+    }, null, 8, ["modelValue", "size", "activeValue", "inactiveValue", "disabled", "onChange"])) : vue.createCommentVNode("", true);
+  }
+  var Switch = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["render", _sfc_render$5]]);
+
+  const _sfc_main$4 = vue.defineComponent({
+    name: "m-fields-text",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: ["change", "input"],
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      const modelName = vue.computed(() => props.name || props.config.name || "");
+      return {
+        modelName,
+        changeHandler(v) {
+          emit("change", v);
+        },
+        inputHandler(v) {
+          const mForm = vue.inject("mForm");
+          emit("input", v);
+          mForm?.$emit("field-input", props.prop, v);
+        },
+        buttonClickHandler() {
+          const mForm = vue.inject("mForm");
+          if (typeof props.config.append === "string")
+            return;
+          if (props.config.append?.handler) {
+            props.config.append.handler(mForm, {
+              model: props.model,
+              values: mForm?.values
+            });
+          }
+        },
+        keyUpHandler($event) {
+          if (!props.model)
+            return;
+          if (!modelName.value)
+            return;
+          const arrowUp = $event.key === "ArrowUp";
+          const arrowDown = $event.key === "ArrowDown";
+          if (!arrowUp && !arrowDown) {
+            return;
+          }
+          const value = props.model[modelName.value];
+          let num;
+          let unit;
+          if (/^([0-9.]+)$/.test(value)) {
+            num = +value;
+          } else {
+            value.replace(/^([0-9.]+)([a-z%]+)$/, ($0, $1, $2) => {
+              num = +$1;
+              unit = $2;
+            });
+          }
+          if (num === void 0) {
+            return;
+          }
+          const ctrl = navigator.platform.match("Mac") ? $event.metaKey : $event.ctrlKey;
+          const shif = $event.shiftKey;
+          const alt = $event.altKey;
+          if (arrowUp) {
+            if (ctrl) {
+              num += 100;
+            } else if (alt) {
+              num = (num * 1e4 + 1e3) / 1e4;
+            } else if (shif) {
+              num = num + 10;
+            } else {
+              num += 1;
+            }
+          } else if (arrowDown) {
+            if (ctrl) {
+              num -= 100;
+            } else if (alt) {
+              num = (num * 1e4 - 1e3) / 1e4;
+            } else if (shif) {
+              num -= 10;
+            } else {
+              num -= 1;
+            }
+          }
+          props.model[modelName.value] = `${num}${unit || ""}`;
+          emit("change", props.model[modelName.value]);
+        }
+      };
+    }
+  });
+  const _hoisted_1$2 = { key: 0 };
+  function _sfc_render$4(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_button = vue.resolveComponent("el-button");
+    const _component_el_input = vue.resolveComponent("el-input");
+    return vue.openBlock(), vue.createBlock(_component_el_input, {
+      modelValue: _ctx.model[_ctx.modelName],
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.modelName] = $event),
+      clearable: "",
+      size: _ctx.size,
+      placeholder: _ctx.config.placeholder,
+      disabled: _ctx.disabled,
+      onChange: _ctx.changeHandler,
+      onInput: _ctx.inputHandler,
+      onKeyup: _cache[1] || (_cache[1] = ($event) => _ctx.keyUpHandler($event))
+    }, vue.createSlots({ _: 2 }, [
+      _ctx.config.append ? {
+        name: "append",
+        fn: vue.withCtx(() => [
+          typeof _ctx.config.append === "string" ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_1$2, vue.toDisplayString(_ctx.config.append), 1)) : vue.createCommentVNode("", true),
+          typeof _ctx.config.append === "object" && _ctx.config.append.type === "button" ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+            key: 1,
+            style: { "color": "#409eff" },
+            onClick: _ctx.buttonClickHandler
+          }, {
+            default: vue.withCtx(() => [
+              vue.createTextVNode(vue.toDisplayString(_ctx.config.append.text), 1)
+            ]),
+            _: 1
+          }, 8, ["onClick"])) : vue.createCommentVNode("", true)
+        ])
+      } : void 0
+    ]), 1032, ["modelValue", "size", "placeholder", "disabled", "onChange", "onInput"]);
+  }
+  var Text = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["render", _sfc_render$4]]);
+
+  const _sfc_main$3 = vue.defineComponent({
+    name: "m-fields-textarea",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: {
+      change(values) {
+        return values;
+      },
+      input(values) {
+        return values;
+      }
+    },
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      const mForm = vue.inject("mForm");
+      return {
+        mForm,
+        changeHandler: (v) => {
+          emit("change", v);
+        },
+        inputHandler: (v) => {
+          emit("input", v);
+          mForm?.$emit("field-input", props.prop, v);
+        }
+      };
+    }
+  });
+  const _hoisted_1$1 = { key: 0 };
+  function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_input = vue.resolveComponent("el-input");
+    return _ctx.model ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$1, [
+      vue.createVNode(_component_el_input, {
+        modelValue: _ctx.model[_ctx.name],
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.name] = $event),
+        type: "textarea",
+        size: _ctx.size,
+        clearable: "",
+        placeholder: _ctx.config.placeholder,
+        disabled: _ctx.disabled,
+        onChange: _ctx.changeHandler,
+        onInput: _ctx.inputHandler
+      }, null, 8, ["modelValue", "size", "placeholder", "disabled", "onChange", "onInput"])
+    ])) : vue.createCommentVNode("", true);
+  }
+  var Textarea = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["render", _sfc_render$3]]);
+
+  const _sfc_main$2 = vue.defineComponent({
+    name: "m-fields-time",
+    props: {
+      ...fieldProps,
+      config: {
+        type: Object,
+        required: true
+      }
+    },
+    emits: {
+      change(values) {
+        return values;
+      }
+    },
+    setup(props, { emit }) {
+      useAddField(props.prop);
+      return {
+        changeHandler: (v) => {
+          emit("change", v);
+        }
+      };
+    }
+  });
+  function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_el_time_picker = vue.resolveComponent("el-time-picker");
+    return vue.openBlock(), vue.createElementBlock("div", null, [
+      vue.createVNode(_component_el_time_picker, {
+        modelValue: _ctx.model[_ctx.name],
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.model[_ctx.name] = $event),
+        size: _ctx.size,
+        "value-format": "HH:mm:ss",
+        placeholder: _ctx.config.placeholder,
+        disabled: _ctx.disabled,
+        onChange: _ctx.changeHandler
+      }, null, 8, ["modelValue", "size", "placeholder", "disabled", "onChange"])
+    ]);
+  }
+  var Time = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$2]]);
+
+  const _sfc_main$1 = vue.defineComponent({
+    name: "m-form",
+    components: { ElForm: elementPlus.ElForm, MContainer: Container },
+    props: {
+      initValues: {
+        type: Object,
+        required: true,
+        default: () => ({})
+      },
+      parentValues: {
+        type: Object,
+        default: () => ({})
+      },
+      config: {
+        type: Array,
+        required: true,
+        default: () => []
+      },
+      labelWidth: {
+        type: String,
+        default: () => "200px"
+      },
+      disabled: {
+        type: Boolean,
+        default: () => false
+      },
+      height: {
+        type: String,
+        default: () => "auto"
+      },
+      stepActive: {
+        type: [String, Number],
+        default: () => 1
+      },
+      size: {
+        type: String,
+        default: "small"
+      },
+      inline: {
+        type: Boolean,
+        default: false
+      },
+      labelPosition: {
+        type: String,
+        default: "right"
+      },
+      keyProp: {
+        type: String,
+        default: "__key"
+      }
+    },
+    emits: ["change", "field-input", "field-change"],
+    setup(props, { emit }) {
+      const elForm = vue.ref();
+      const initialized = vue.ref(false);
+      const values = vue.ref({});
+      const fields = /* @__PURE__ */ new Map();
+      const requestFuc = getConfig("request");
+      const formState = vue.reactive({
+        keyProp: props.keyProp,
+        config: props.config,
+        initValues: props.initValues,
+        parentValues: props.parentValues,
+        values,
+        $emit: emit,
+        fields,
+        setField: (prop, field) => fields.set(prop, field),
+        getField: (prop) => fields.get(prop),
+        deleteField: (prop) => fields.delete(prop),
+        post: (options) => {
+          if (requestFuc) {
+            return requestFuc({
+              ...options,
+              method: "POST"
+            });
+          }
+        }
+      });
+      vue.provide("mForm", formState);
+      vue.watchEffect(() => {
+        initialized.value = false;
+        initValue(formState, {
+          initValues: props.initValues,
+          config: props.config
+        }).then((value) => {
+          values.value = value;
+          initialized.value = true;
+        });
+      });
+      return {
+        initialized,
+        values,
+        elForm,
+        formState,
+        changeHandler: () => {
+          emit("change", values.value);
+        },
+        resetForm: () => elForm.value?.resetFields(),
+        submitForm: async (native) => {
+          try {
+            await elForm.value?.validate();
+            return native ? values.value : lodashEs.cloneDeep(values.value);
+          } catch (invalidFields) {
+            const error = [];
+            Object.entries(invalidFields).forEach(([, ValidateError]) => {
+              ValidateError.forEach(({ field, message }) => {
+                if (field && message)
+                  error.push(`${field} -> ${message}`);
+                if (field && !message)
+                  error.push(`${field} -> \u51FA\u73B0\u9519\u8BEF`);
+                if (!field && message)
+                  error.push(`${message}`);
+              });
+            });
+            throw new Error(error.join("<br>"));
+          }
+        }
+      };
+    }
+  });
+  function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_MContainer = vue.resolveComponent("MContainer");
+    const _component_ElForm = vue.resolveComponent("ElForm");
+    return _ctx.initialized && Array.isArray(_ctx.config) ? (vue.openBlock(), vue.createBlock(_component_ElForm, {
+      key: 0,
+      class: "m-form",
+      ref: "elForm",
+      model: _ctx.values,
+      "label-width": _ctx.labelWidth,
+      disabled: _ctx.disabled,
+      style: vue.normalizeStyle(`height: ${_ctx.height}`),
+      inline: _ctx.inline,
+      "label-position": _ctx.labelPosition
+    }, {
+      default: vue.withCtx(() => [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.config, (item, index) => {
+          return vue.openBlock(), vue.createBlock(_component_MContainer, {
+            key: item[_ctx.keyProp] ?? index,
+            config: item,
+            model: _ctx.values,
+            "label-width": item.labelWidth || _ctx.labelWidth,
+            "step-active": _ctx.stepActive,
+            size: _ctx.size,
+            onChange: _ctx.changeHandler
+          }, null, 8, ["config", "model", "label-width", "step-active", "size", "onChange"]);
+        }), 128))
+      ]),
+      _: 1
+    }, 8, ["model", "label-width", "disabled", "style", "inline", "label-position"])) : vue.createCommentVNode("", true);
+  }
+  var Form = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render$1]]);
+
+  const _sfc_main = vue.defineComponent({
+    name: "m-form-dialog",
+    props: {
+      values: {
+        type: Object,
+        default: () => ({})
+      },
+      width: [Number, String],
+      fullscreen: Boolean,
+      title: String,
+      config: {
+        type: Array,
+        required: true,
+        default: () => []
+      },
+      labelWidth: [Number, String],
+      confirmText: {
+        type: String,
+        default: "\u786E\u5B9A"
+      }
+    },
+    emits: ["close", "submit", "error", "change"],
+    setup(props, { emit }) {
+      const form = vue.ref();
+      const dialogVisible = vue.ref(false);
+      const saveFetch = vue.ref(false);
+      const stepActive = vue.ref(1);
+      const bodyHeight = vue.ref(`${document.body.clientHeight - 194}px`);
+      const stepCount = vue.computed(() => {
+        const { length } = props.config;
+        for (let index = 0; index < length; index++) {
+          if (props.config[index].type === "step") {
+            return props.config[index].items.length;
+          }
+        }
+        return 0;
+      });
+      const hasStep = vue.computed(() => {
+        const { length } = props.config;
+        for (let index = 0; index < length; index++) {
+          if (props.config[index].type === "step") {
+            return true;
+          }
+        }
+        return false;
+      });
+      const cancel = () => {
+        dialogVisible.value = false;
+      };
+      const closeHandler = () => {
+        stepActive.value = 1;
+        emit("close");
+      };
+      const save = async () => {
+        try {
+          const values = await form.value?.submitForm();
+          emit("submit", values);
+        } catch (e) {
+          emit("error", e);
+        }
+      };
+      const preStep = () => {
+        stepActive.value -= 1;
+      };
+      const nextStep = () => {
+        stepActive.value += 1;
+      };
+      const changeHandler = (value) => {
+        emit("change", value);
+      };
+      return {
+        form,
+        saveFetch,
+        stepActive,
+        dialogVisible,
+        bodyHeight,
+        stepCount,
+        hasStep,
+        cancel,
+        closeHandler,
+        save,
+        preStep,
+        nextStep,
+        changeHandler
+      };
+    }
+  });
+  const _hoisted_1 = { style: { "min-height": "1px" } };
+  const _hoisted_2 = /* @__PURE__ */ vue.createTextVNode("\u53D6 \u6D88");
+  const _hoisted_3 = /* @__PURE__ */ vue.createTextVNode("\u4E0A\u4E00\u6B65");
+  const _hoisted_4 = /* @__PURE__ */ vue.createTextVNode("\u4E0B\u4E00\u6B65");
+  function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_m_form = vue.resolveComponent("m-form");
+    const _component_el_col = vue.resolveComponent("el-col");
+    const _component_el_button = vue.resolveComponent("el-button");
+    const _component_el_row = vue.resolveComponent("el-row");
+    const _component_el_dialog = vue.resolveComponent("el-dialog");
+    return vue.openBlock(), vue.createElementBlock("div", null, [
+      vue.createVNode(_component_el_dialog, {
+        modelValue: _ctx.dialogVisible,
+        "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.dialogVisible = $event),
+        "custom-class": "m-form-dialog",
+        top: "20px",
+        title: _ctx.title,
+        appendToBody: true,
+        width: _ctx.width,
+        fullscreen: _ctx.fullscreen,
+        "close-on-click-modal": false,
+        onClose: _ctx.closeHandler
+      }, {
+        footer: vue.withCtx(() => [
+          vue.createVNode(_component_el_row, { class: "dialog-footer" }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_el_col, {
+                span: 12,
+                style: { "text-align": "left" }
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createElementVNode("div", _hoisted_1, [
+                    vue.renderSlot(_ctx.$slots, "left")
+                  ])
+                ]),
+                _: 3
+              }),
+              vue.createVNode(_component_el_col, { span: 12 }, {
+                default: vue.withCtx(() => [
+                  vue.renderSlot(_ctx.$slots, "footer", {}, () => [
+                    vue.createVNode(_component_el_button, {
+                      onClick: _ctx.cancel,
+                      size: "small"
+                    }, {
+                      default: vue.withCtx(() => [
+                        _hoisted_2
+                      ]),
+                      _: 1
+                    }, 8, ["onClick"]),
+                    _ctx.hasStep && _ctx.stepActive > 1 ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+                      key: 0,
+                      type: "info",
+                      size: "small",
+                      onClick: _ctx.preStep
+                    }, {
+                      default: vue.withCtx(() => [
+                        _hoisted_3
+                      ]),
+                      _: 1
+                    }, 8, ["onClick"])) : vue.createCommentVNode("", true),
+                    _ctx.hasStep && _ctx.stepCount > _ctx.stepActive ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+                      key: 1,
+                      type: "info",
+                      size: "small",
+                      onClick: _ctx.nextStep
+                    }, {
+                      default: vue.withCtx(() => [
+                        _hoisted_4
+                      ]),
+                      _: 1
+                    }, 8, ["onClick"])) : (vue.openBlock(), vue.createBlock(_component_el_button, {
+                      key: 2,
+                      type: "primary",
+                      size: "small",
+                      loading: _ctx.saveFetch,
+                      onClick: _ctx.save
+                    }, {
+                      default: vue.withCtx(() => [
+                        vue.createTextVNode(vue.toDisplayString(_ctx.confirmText), 1)
+                      ]),
+                      _: 1
+                    }, 8, ["loading", "onClick"]))
+                  ])
+                ]),
+                _: 3
+              })
+            ]),
+            _: 3
+          })
+        ]),
+        default: vue.withCtx(() => [
+          vue.createElementVNode("div", {
+            class: "m-dialog-body",
+            style: vue.normalizeStyle(`max-height: ${_ctx.bodyHeight}; overflow-y: auto; overflow-x: hidden;`)
+          }, [
+            vue.createVNode(_component_m_form, {
+              modelValue: _ctx.stepActive,
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.stepActive = $event),
+              ref: "form",
+              config: _ctx.config,
+              "init-values": _ctx.values,
+              "label-width": _ctx.labelWidth,
+              onChange: _ctx.changeHandler
+            }, null, 8, ["modelValue", "config", "init-values", "label-width", "onChange"]),
+            vue.renderSlot(_ctx.$slots, "default")
+          ], 4)
+        ]),
+        _: 3
+      }, 8, ["modelValue", "title", "width", "fullscreen", "onClose"])
+    ]);
+  }
+  var FormDialog = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+
+  var index$1 = '';
+
+  const defaultInstallOpt = {};
+  const install = (app, opt) => {
+    const option = Object.assign(defaultInstallOpt, opt);
+    app.config.globalProperties.$MAGIC_FORM = option;
+    setConfig(option);
+    app.component(Form.name, Form);
+    app.component(FormDialog.name, FormDialog);
+    app.component(Container.name, Container);
+    app.component(Fieldset.name, Fieldset);
+    app.component(GroupList.name, GroupList);
+    app.component(Panel.name, Panel);
+    app.component(Row.name, Row);
+    app.component(MStep.name, MStep);
+    app.component(Table.name, Table);
+    app.component(Tabs.name, Tabs);
+    app.component(Text.name, Text);
+    app.component(Number$1.name, Number$1);
+    app.component(Textarea.name, Textarea);
+    app.component(_sfc_main$a.name, _sfc_main$a);
+    app.component(Date$1.name, Date$1);
+    app.component(DateTime.name, DateTime);
+    app.component(Time.name, Time);
+    app.component(Checkbox.name, Checkbox);
+    app.component(Switch.name, Switch);
+    app.component(Daterange.name, Daterange);
+    app.component(_sfc_main$g.name, _sfc_main$g);
+    app.component(CheckboxGroup.name, CheckboxGroup);
+    app.component(RadioGroup.name, RadioGroup);
+    app.component(_sfc_main$c.name, _sfc_main$c);
+    app.component(Link.name, Link);
+    app.component(Select.name, Select);
+    app.component(Cascader.name, Cascader);
+    app.component(DynamicField.name, DynamicField);
+  };
+  var index = {
+    install
+  };
+
+  exports.MCascader = Cascader;
+  exports.MCheckbox = Checkbox;
+  exports.MCheckboxGroup = CheckboxGroup;
+  exports.MColorPicker = _sfc_main$g;
+  exports.MContainer = Container;
+  exports.MDate = Date$1;
+  exports.MDateTime = DateTime;
+  exports.MDaterange = Daterange;
+  exports.MDisplay = _sfc_main$c;
+  exports.MDynamicField = DynamicField;
+  exports.MFieldset = Fieldset;
+  exports.MForm = Form;
+  exports.MFormDialog = FormDialog;
+  exports.MGroupList = GroupList;
+  exports.MHidden = _sfc_main$a;
+  exports.MLink = Link;
+  exports.MNumber = Number$1;
+  exports.MPanel = Panel;
+  exports.MRadioGroup = RadioGroup;
+  exports.MRow = Row;
+  exports.MSelect = Select;
+  exports.MSwitch = Switch;
+  exports.MTable = Table;
+  exports.MTabs = Tabs;
+  exports.MText = Text;
+  exports.MTextarea = Textarea;
+  exports.MTime = Time;
+  exports["default"] = index;
+  exports.display = display;
+  exports.fieldProps = fieldProps;
+  exports.filterFunction = filterFunction;
+  exports.getRules = getRules;
+  exports.initValue = initValue;
+  exports.useAddField = useAddField;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+  exports[Symbol.toStringTag] = 'Module';
+
+}));
+//# sourceMappingURL=tmagic-form.umd.js.map