@web-utils/component 2.7.20 → 2.7.22

package/dist/components/fy-form/index.js

@@ -1,363 +1,379 @@
-import { d as P } from "../../chunks/detail.d67573b1.js";
-import { i as N } from "../../chunks/init.7c58eb34.js";
-import { s as _, d as D, u as j, h as L, i as V, j as $, k as z, o as I, l as M } from "../../chunks/util.23fe58fb.js";
-import { c as A, b as B, g as W, a as R, f as G } from "../../chunks/dataformat.65b92bfe.js";
-import { s as H } from "../../chunks/dic.70feb9b4.js";
-import { p as U } from "../../chunks/packages.1fc9ccba.js";
-import { isBlank as u } from "@web-utils/core";
-import { n as q } from "../../chunks/vueComponentNormalizer.71e2aa87.js";
-const K = (t, i, s, r) => {
-  if (!r)
+var __async = (__this, __arguments, generator) => new Promise((resolve, reject) => {
+  var fulfilled = (value) => {
+    try {
+      step(generator.next(value));
+    } catch (e) {
+      reject(e);
+    }
+  }, rejected = (value) => {
+    try {
+      step(generator.throw(value));
+    } catch (e) {
+      reject(e);
+    }
+  }, step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+  step((generator = generator.apply(__this, __arguments)).next());
+});
+import { d as detail } from "../../chunks/detail.d47a021c.js";
+import { i as init } from "../../chunks/init.e0133910.js";
+import { s as setPx, d as deepClone, u as uploadFun, x as setAsVal, g as getAsVal, v as filterParams, D as DIC_PROPS, o as optVal, y as clearVal } from "../../chunks/util.89913643.js";
+import { b as calcCount, c as calcCascader, g as getComponent, a as getPlaceholder, f as formInitVal } from "../../chunks/dataformat.9cc4428a.js";
+import { s as sendDic } from "../../chunks/dic.9de2fe5a.js";
+import { p as packages } from "../../chunks/packages.419bde01.js";
+import { isBlank } from "@web-utils/core";
+import { n as normalizeComponent } from "../../chunks/vueComponentNormalizer.77ec6792.js";
+const mock = (column, dic, defaultForm, run) => {
+  if (!run)
     return;
   if (!window.Mock) {
-    U.logs("mock");
+    packages.logs("mock");
     return;
   }
-  const e = (window.Mock || {}).Random, o = {};
-  function a({ en: h }) {
-    return h ? e.name(!0) : e.cname();
+  const Random = (window.Mock || {}).Random, form = {};
+  function createName({ en }) {
+    return en ? Random.name(!0) : Random.cname();
   }
-  function n({ max: h, min: l, precision: f }) {
-    if (f) {
-      const c = `${e.float(l, h, f)}`, m = c.indexOf(".") + 1;
-      return Number(c.substring(0, m + f));
+  function createNumber({ max, min, precision }) {
+    if (precision) {
+      const number = `${Random.float(min, max, precision)}`, index = number.indexOf(".") + 1;
+      return Number(number.substring(0, index + precision));
     } else
-      return e.integer(l, h);
+      return Random.integer(min, max);
   }
-  function d({ header: h, footer: l }) {
-    let f = e.url();
-    const c = f.indexOf("://");
-    return h === !1 ? f = f.substring(c + 3) : f = `http://${f.substring(c + 3)}`, f;
+  function createUrl({ header, footer }) {
+    let url = Random.url();
+    const index = url.indexOf("://");
+    return header === !1 ? url = url.substring(index + 3) : url = `http://${url.substring(index + 3)}`, url;
   }
-  function F({ format: h, now: l }) {
-    return l ? e.now(h) : e.datetime(h);
+  function createDatetime({ format, now }) {
+    return now ? Random.now(format) : Random.datetime(format);
   }
-  function x({ min: h, max: l }) {
-    return e.csentence(h, l);
+  function createText({ min, max }) {
+    return Random.csentence(min, max);
   }
-  function C() {
-    return e.county(!0);
+  function createCounty() {
+    return Random.county(!0);
   }
-  function T({ dic: h, props: l, columnType: f, multiple: c }) {
-    const m = l.value || "value", b = h.length;
-    if (["checkbox"].includes(f) || c) {
-      const v = n({
+  function createDic({ dic: dic2, props, columnType, multiple }) {
+    const value = props.value || "value", len = dic2.length;
+    if (["checkbox"].includes(columnType) || multiple) {
+      const number = createNumber({
         min: 1,
-        max: b
-      }), y = [];
-      for (let O = 0; O < v; O++) {
-        let g = !0;
-        for (; g; ) {
-          const E = n({
+        max: len
+      }), result = [];
+      for (let i = 0; i < number; i++) {
+        let flag = !0;
+        for (; flag; ) {
+          const numbers = createNumber({
             min: 0,
-            max: b - 1
-          }), k = h[E][m];
-          y.includes(k) || (y.push(k), g = !1);
+            max: len - 1
+          }), values = dic2[numbers][value];
+          result.includes(values) || (result.push(values), flag = !1);
         }
       }
-      return y;
+      return result;
     } else {
-      const v = n({
+      const number = createNumber({
         min: 0,
-        max: b - 1
+        max: len - 1
       });
-      return h[v][m];
+      return dic2[number][value];
     }
   }
-  function w() {
-    Object.keys(t).forEach((h) => {
-      const l = t[h];
-      if (l.mock && typeof l.mock == "object") {
-        const f = l.mock;
-        switch (f.dic = typeof l.dicData == "string" ? i[l.dicData] : l.dicData || [], f.props = l.props || {}, f.columnType = l.type, f.multiple = l.multiple, f.type) {
+  function create() {
+    Object.keys(column).forEach((index) => {
+      const ele = column[index];
+      if (ele.mock && typeof ele.mock == "object") {
+        const params = ele.mock;
+        switch (params.dic = typeof ele.dicData == "string" ? dic[ele.dicData] : ele.dicData || [], params.props = ele.props || {}, params.columnType = ele.type, params.multiple = ele.multiple, params.type) {
           case "name":
-            o[l.prop] = a(f);
+            form[ele.prop] = createName(params);
             break;
           case "number":
-            o[l.prop] = n(f);
+            form[ele.prop] = createNumber(params);
             break;
           case "datetime":
-            o[l.prop] = F(f);
+            form[ele.prop] = createDatetime(params);
             break;
           case "word":
-            o[l.prop] = x(f);
+            form[ele.prop] = createText(params);
             break;
           case "url":
-            o[l.prop] = d(f);
+            form[ele.prop] = createUrl(params);
             break;
           case "county":
-            o[l.prop] = C();
+            form[ele.prop] = createCounty();
             break;
           case "dic":
-            o[l.prop] = T(f);
+            form[ele.prop] = createDic(params);
             break;
         }
       } else
-        l.mock instanceof Function && (o[l.prop] = l.mock(s));
+        ele.mock instanceof Function && (form[ele.prop] = ele.mock(defaultForm));
     });
   }
-  return w(), o;
+  return create(), form;
 };
-var J = function() {
-  var t = this, i = t.$createElement, s = t._self._c || i;
-  return s("div", {
+var render = function() {
+  var _vm = this, _h = _vm.$createElement, _c = _vm._self._c || _h;
+  return _c("div", {
     class: ["avue-form", {
-      "avue--detail": t.isDetail
+      "avue--detail": _vm.isDetail
     }],
     style: {
-      width: t.setPx(t.parentOption.formWidth, "100%")
+      width: _vm.setPx(_vm.parentOption.formWidth, "100%")
     }
-  }, [s("ElForm", {
+  }, [_c("ElForm", {
     ref: "form",
     attrs: {
-      "status-icon": t.parentOption.statusIcon,
-      model: t.form,
-      "label-suffix": t.labelSuffix,
-      size: t.$AVUE.formSize || t.controlSize,
-      "label-position": t.parentOption.labelPosition,
-      "label-width": t.setPx(t.parentOption.labelWidth, t.labelWidth)
+      "status-icon": _vm.parentOption.statusIcon,
+      model: _vm.form,
+      "label-suffix": _vm.labelSuffix,
+      size: _vm.$AVUE.formSize || _vm.controlSize,
+      "label-position": _vm.parentOption.labelPosition,
+      "label-width": _vm.setPx(_vm.parentOption.labelWidth, _vm.labelWidth)
     },
     nativeOn: {
-      submit: function(r) {
-        r.preventDefault();
+      submit: function($event) {
+        $event.preventDefault();
       }
     }
-  }, [s("ElRow", {
+  }, [_c("ElRow", {
     class: {
-      "avue-form__tabs": t.isTabs
+      "avue-form__tabs": _vm.isTabs
     },
     attrs: {
       span: 24
     }
-  }, [t._l(t.columnOption, function(r, p) {
-    return s("FormGroup", {
-      key: r.prop,
+  }, [_vm._l(_vm.columnOption, function(item, index) {
+    return _c("FormGroup", {
+      key: item.prop,
       attrs: {
-        tabs: t.isTabs,
-        arrow: r.arrow,
-        collapse: r.collapse,
-        display: t.vaildDisplay(r),
-        icon: r.icon,
-        index: p,
-        header: !t.isTabs,
-        active: t.activeName,
-        label: r.label
+        tabs: _vm.isTabs,
+        arrow: item.arrow,
+        collapse: item.collapse,
+        display: _vm.vaildDisplay(item),
+        icon: item.icon,
+        index,
+        header: !_vm.isTabs,
+        active: _vm.activeName,
+        label: item.label
       },
       on: {
-        change: t.handleGroupClick
+        change: _vm.handleGroupClick
       },
-      scopedSlots: t._u([t.getSlotName(r, "H", t.$scopedSlots) ? {
+      scopedSlots: _vm._u([_vm.getSlotName(item, "H", _vm.$scopedSlots) ? {
         key: "header",
         fn: function() {
-          return [t._t(t.getSlotName(r, "H"), null, {
-            column: r
+          return [_vm._t(_vm.getSlotName(item, "H"), null, {
+            column: item
           })];
         },
         proxy: !0
       } : null], null, !0)
-    }, [t.isTabs && p === 1 ? s("ElTabs", {
+    }, [_vm.isTabs && index === 1 ? _c("ElTabs", {
       staticClass: "avue-form__tabs",
       attrs: {
         slot: "tabs",
-        type: t.tabsType
+        type: _vm.tabsType
       },
       on: {
-        "tab-click": t.handleTabClick
+        "tab-click": _vm.handleTabClick
       },
       slot: "tabs",
       model: {
-        value: t.activeName,
-        callback: function(e) {
-          t.activeName = e;
+        value: _vm.activeName,
+        callback: function($$v) {
+          _vm.activeName = $$v;
         },
         expression: "activeName"
       }
-    }, [t._l(t.columnOption, function(e, o) {
-      return [t.vaildDisplay(e) && o !== 0 ? s("ElTabPane", {
-        key: o,
+    }, [_vm._l(_vm.columnOption, function(tabs, sIndex) {
+      return [_vm.vaildDisplay(tabs) && sIndex !== 0 ? _c("ElTabPane", {
+        key: sIndex,
         attrs: {
-          name: `${o}`
+          name: `${sIndex}`
         }
-      }, [s("span", {
+      }, [_c("span", {
         attrs: {
           slot: "label"
         },
         slot: "label"
-      }, [t.getSlotName(e, "H", t.$scopedSlots) ? t._t(t.getSlotName(e, "H"), null, {
-        column: t.column
-      }) : [s("i", {
-        class: e.icon
-      }, [t._v(" ")]), t._v(" " + t._s(e.label) + " ")]], 2)]) : t._e()];
-    })], 2) : t._e(), s("div", {
+      }, [_vm.getSlotName(tabs, "H", _vm.$scopedSlots) ? _vm._t(_vm.getSlotName(tabs, "H"), null, {
+        column: _vm.column
+      }) : [_c("i", {
+        class: tabs.icon
+      }, [_vm._v(" ")]), _vm._v(" " + _vm._s(tabs.label) + " ")]], 2)]) : _vm._e()];
+    })], 2) : _vm._e(), _c("div", {
       directives: [{
         name: "show",
         rawName: "v-show",
-        value: t.isGroupShow(r, p),
+        value: _vm.isGroupShow(item, index),
         expression: "isGroupShow(item, index)"
       }],
       class: ["avue-form__group", {
-        "avue-form__group--flex": r.flex === !1
+        "avue-form__group--flex": item.flex === !1
       }]
-    }, [t._l(r.column, function(e, o) {
-      return [t.vaildDisplay(e) ? s("ElCol", {
-        key: o,
+    }, [_vm._l(item.column, function(column, cindex) {
+      return [_vm.vaildDisplay(column) ? _c("ElCol", {
+        key: cindex,
         class: ["avue-form__row", {
-          "avue--detail avue--detail__column": t.vaildDetail(e)
-        }, e.className],
+          "avue--detail avue--detail__column": _vm.vaildDetail(column)
+        }, column.className],
         style: {
-          paddingLeft: t.gutter,
-          paddingRight: t.gutter
+          paddingLeft: _vm.gutter,
+          paddingRight: _vm.gutter
         },
         attrs: {
-          span: t.getSpan(e),
-          md: t.getSpan(e),
-          sm: e.smSpan || r.smSpan || 12,
-          xs: e.xsSpan || r.xmSpan || 24,
-          offset: e.offset || r.offset,
-          push: e.push || r.push,
-          pull: e.pull || r.pull
+          span: _vm.getSpan(column),
+          md: _vm.getSpan(column),
+          sm: column.smSpan || item.smSpan || 12,
+          xs: column.xsSpan || item.xmSpan || 24,
+          offset: column.offset || item.offset,
+          push: column.push || item.push,
+          pull: column.pull || item.pull
         }
-      }, [s("ElFormItem", {
-        class: `avue-form__item--${e.labelPosition || r.labelPosition || ""}`,
+      }, [_c("ElFormItem", {
+        class: `avue-form__item--${column.labelPosition || item.labelPosition || ""}`,
         attrs: {
-          prop: e.prop,
-          label: e.label,
-          rules: e.rules,
-          "label-position": e.labelPosition || r.labelPosition || t.parentOption.labelPosition,
-          "label-width": t.getLabelWidth(e, r)
+          prop: column.prop,
+          label: column.label,
+          rules: column.rules,
+          "label-position": column.labelPosition || item.labelPosition || _vm.parentOption.labelPosition,
+          "label-width": _vm.getLabelWidth(column, item)
         },
-        scopedSlots: t._u([t.getSlotName(e, "L", t.$scopedSlots) ? {
+        scopedSlots: _vm._u([_vm.getSlotName(column, "L", _vm.$scopedSlots) ? {
           key: "label",
           fn: function() {
-            return [t._t(t.getSlotName(e, "L"), null, {
-              column: e,
-              value: t.form[e.prop],
-              readonly: e.readonly || t.readonly,
-              disabled: t.getDisabled(e),
-              size: e.size || t.controlSize,
-              dic: t.DIC[e.prop]
+            return [_vm._t(_vm.getSlotName(column, "L"), null, {
+              column,
+              value: _vm.form[column.prop],
+              readonly: column.readonly || _vm.readonly,
+              disabled: _vm.getDisabled(column),
+              size: column.size || _vm.controlSize,
+              dic: _vm.DIC[column.prop]
             })];
           },
           proxy: !0
-        } : e.labelTip ? {
+        } : column.labelTip ? {
           key: "label",
           fn: function() {
-            return [s("ElTooltip", {
+            return [_c("ElTooltip", {
               staticClass: "item",
               attrs: {
                 effect: "dark",
-                placement: e.labelTipPlacement || "top-start"
+                placement: column.labelTipPlacement || "top-start"
               }
-            }, [s("div", {
+            }, [_c("div", {
               attrs: {
                 slot: "content"
               },
               domProps: {
-                innerHTML: t._s(e.labelTip)
+                innerHTML: _vm._s(column.labelTip)
               },
               slot: "content"
-            }), s("i", {
+            }), _c("i", {
               staticClass: "el-icon-info"
-            })]), s("span", [t._v(" " + t._s(e.label) + t._s(t.labelSuffix))])];
+            })]), _c("span", [_vm._v(" " + _vm._s(column.label) + _vm._s(_vm.labelSuffix))])];
           },
           proxy: !0
-        } : null, t.getSlotName(e, "E", t.$scopedSlots) ? {
+        } : null, _vm.getSlotName(column, "E", _vm.$scopedSlots) ? {
           key: "error",
-          fn: function(a) {
-            return [t._t(t.getSlotName(e, "E"), null, null, Object.assign(a, {
-              column: e,
-              value: t.form[e.prop],
-              readonly: t.readonly || e.readonly,
-              disabled: t.getDisabled(e),
-              size: e.size || t.controlSize,
-              dic: t.DIC[e.prop]
+          fn: function(scope) {
+            return [_vm._t(_vm.getSlotName(column, "E"), null, null, Object.assign(scope, {
+              column,
+              value: _vm.form[column.prop],
+              readonly: _vm.readonly || column.readonly,
+              disabled: _vm.getDisabled(column),
+              size: column.size || _vm.controlSize,
+              dic: _vm.DIC[column.prop]
             }))];
           }
         } : null], null, !0)
-      }, [s(t.validTip(e) ? "div" : "elTooltip", {
+      }, [_c(_vm.validTip(column) ? "div" : "elTooltip", {
         tag: "Component",
         attrs: {
-          disabled: t.validTip(e),
-          content: e.tip || t.getPlaceholder(e),
-          placement: e.tipPlacement
+          disabled: _vm.validTip(column),
+          content: column.tip || _vm.getPlaceholder(column),
+          placement: column.tipPlacement
         }
-      }, [t.$scopedSlots[e.prop] ? t._t(e.prop, null, {
-        value: t.form[e.prop],
-        column: e,
-        label: t.form[`$${e.prop}`],
-        size: e.size || t.controlSize,
-        readonly: t.readonly || e.readonly,
-        disabled: t.getDisabled(e),
-        dic: t.DIC[e.prop]
-      }) : s("FormTemp", t._b({
-        ref: e.prop,
+      }, [_vm.$scopedSlots[column.prop] ? _vm._t(column.prop, null, {
+        value: _vm.form[column.prop],
+        column,
+        label: _vm.form[`$${column.prop}`],
+        size: column.size || _vm.controlSize,
+        readonly: _vm.readonly || column.readonly,
+        disabled: _vm.getDisabled(column),
+        dic: _vm.DIC[column.prop]
+      }) : _c("FormTemp", _vm._b({
+        ref: column.prop,
         refInFor: !0,
         attrs: {
-          column: e,
-          dic: t.DIC[e.prop],
-          props: t.parentOption.props,
-          "props-http": t.parentOption.propsHttp,
-          disabled: t.getDisabled(e),
-          readonly: e.readonly || t.readonly,
-          enter: t.parentOption.enter,
-          size: e.size || t.controlSize,
-          "column-slot": t.columnSlot
+          column,
+          dic: _vm.DIC[column.prop],
+          props: _vm.parentOption.props,
+          "props-http": _vm.parentOption.propsHttp,
+          disabled: _vm.getDisabled(column),
+          readonly: column.readonly || _vm.readonly,
+          enter: _vm.parentOption.enter,
+          size: column.size || _vm.controlSize,
+          "column-slot": _vm.columnSlot
         },
         on: {
-          enter: t.submit,
-          change: function(a) {
-            return t.propChange(r.column, e);
+          enter: _vm.submit,
+          change: function($event) {
+            return _vm.propChange(item.column, column);
           }
         },
-        scopedSlots: t._u([t._l(t.getSlotName(e, "T", t.$scopedSlots) ? [e] : [], function(a) {
+        scopedSlots: _vm._u([_vm._l(_vm.getSlotName(column, "T", _vm.$scopedSlots) ? [column] : [], function(sItem) {
           return {
-            key: t.getSlotName(e, "T"),
-            fn: function(n) {
-              return [t._t(t.getSlotName(a, "T"), null, null, n)];
+            key: _vm.getSlotName(column, "T"),
+            fn: function(scope) {
+              return [_vm._t(_vm.getSlotName(sItem, "T"), null, null, scope)];
             }
           };
-        }), t._l(t.columnSlot, function(a) {
+        }), _vm._l(_vm.columnSlot, function(ssItem) {
           return {
-            key: a,
-            fn: function(n) {
-              return [t._t(a, null, null, n)];
+            key: ssItem,
+            fn: function(scope) {
+              return [_vm._t(ssItem, null, null, scope)];
             }
           };
         })], null, !0),
         model: {
-          value: t.form[e.prop],
-          callback: function(a) {
-            t.$set(t.form, e.prop, a);
+          value: _vm.form[column.prop],
+          callback: function($$v) {
+            _vm.$set(_vm.form, column.prop, $$v);
           },
           expression: "form[column.prop]"
         }
-      }, "FormTemp", t.uploadFun(e), !1))], 2)], 1)], 1) : t._e(), t.vaildDisplay(e) && e.row && e.span !== 24 && e.count ? s("div", {
-        key: `line${o}`,
+      }, "FormTemp", _vm.uploadFun(column), !1))], 2)], 1)], 1) : _vm._e(), _vm.vaildDisplay(column) && column.row && column.span !== 24 && column.count ? _c("div", {
+        key: `line${cindex}`,
         staticClass: "avue-form__line",
         style: {
-          width: `${e.count / 24 * 100}%`
+          width: `${column.count / 24 * 100}%`
         }
-      }) : t._e()];
-    }), !t.isDetail && !t.isMenu ? s("FyFormMenu", {
-      scopedSlots: t._u([{
+      }) : _vm._e()];
+    }), !_vm.isDetail && !_vm.isMenu ? _c("FyFormMenu", {
+      scopedSlots: _vm._u([{
         key: "menuForm",
-        fn: function(e) {
-          return [t._t("menuForm", null, null, e)];
+        fn: function(scope) {
+          return [_vm._t("menuForm", null, null, scope)];
         }
       }], null, !0)
-    }) : t._e()], 2)], 1);
-  }), !t.isDetail && t.isMenu ? s("FyFormMenu", {
-    scopedSlots: t._u([{
+    }) : _vm._e()], 2)], 1);
+  }), !_vm.isDetail && _vm.isMenu ? _c("FyFormMenu", {
+    scopedSlots: _vm._u([{
       key: "menuForm",
-      fn: function(r) {
-        return [t._t("menuForm", null, null, r)];
+      fn: function(scope) {
+        return [_vm._t("menuForm", null, null, scope)];
       }
     }], null, !0)
-  }) : t._e()], 2)], 1)], 1);
-}, Q = [];
-const X = {
+  }) : _vm._e()], 2)], 1)], 1);
+}, staticRenderFns = [];
+const __vue2_script = {
   name: "FyForm",
-  mixins: [N],
+  mixins: [init],
   provide() {
     return {
       formSafe: this
@@ -401,7 +417,7 @@ const X = {
   },
   computed: {
     columnSlot() {
-      return Object.keys(this.$scopedSlots).filter((t) => !this.propOption.map((i) => i.prop).includes(t));
+      return Object.keys(this.$scopedSlots).filter((item) => !this.propOption.map((ele) => ele.prop).includes(item));
     },
     labelSuffix() {
       return this.parentOption.labelSuffix || ":";
@@ -425,7 +441,7 @@ const X = {
       return this.boxType === "view";
     },
     gutter() {
-      return _((this.parentOption.gutter || 10) / 2);
+      return setPx((this.parentOption.gutter || 10) / 2);
     },
     detail() {
       return this.parentOption.detail;
@@ -443,35 +459,35 @@ const X = {
       return this.columnOption.length;
     },
     dynamicOption() {
-      const t = [];
-      return this.propOption.forEach((i) => {
-        i.type === "dynamic" && this.vaildDisplay(i) && t.push(i);
-      }), t;
+      const list = [];
+      return this.propOption.forEach((ele) => {
+        ele.type === "dynamic" && this.vaildDisplay(ele) && list.push(ele);
+      }), list;
     },
     propOption() {
-      const t = [];
-      return this.columnOption.forEach((i) => {
-        i.display !== !1 && i.column.forEach((s) => {
-          t.push(s);
+      const list = [];
+      return this.columnOption.forEach((option) => {
+        option.display !== !1 && option.column.forEach((column) => {
+          list.push(column);
         });
-      }), t;
+      }), list;
     },
     parentOption() {
       return this.tableOption || {};
     },
     columnOption() {
-      const t = this.tableOption.column || [], i = D(this.tableOption.group) || [], s = this.tableOption.footer || [];
-      return i.unshift({
+      const column = this.tableOption.column || [], group = deepClone(this.tableOption.group) || [], footer = this.tableOption.footer || [];
+      return group.unshift({
         header: !1,
-        column: t
-      }), s.length !== 0 && i.push({
+        column
+      }), footer.length !== 0 && group.push({
         header: !1,
-        column: s
-      }), i.forEach((r) => {
-        r.column = r.column || [], r.column.forEach((p, e) => {
-          p.display !== !1 && !this.isMobile && (p = A(p, this.itemSpanDefault, e === 0));
-        }), r.column = B(r.column), r.column = r.column.sort((p, e) => (e.order || 0) - (p.order || 0));
-      }), i;
+        column: footer
+      }), group.forEach((ele) => {
+        ele.column = ele.column || [], ele.column.forEach((column2, cindex) => {
+          column2.display !== !1 && !this.isMobile && (column2 = calcCount(column2, this.itemSpanDefault, cindex === 0));
+        }), ele.column = calcCascader(ele.column), ele.column = ele.column.sort((a, b) => (b.order || 0) - (a.order || 0));
+      }), group;
     },
     menuPosition: function() {
       return this.parentOption.menuPosition ? this.parentOption.menuPosition : "center";
@@ -516,8 +532,8 @@ const X = {
       immediate: !0
     },
     allDisabled: {
-      handler(t) {
-        this.$emit("update:status", t);
+      handler(val) {
+        this.$emit("update:status", val);
       },
       deep: !0,
       immediate: !0
@@ -529,116 +545,116 @@ const X = {
     });
   },
   beforeDestroy() {
-    Object.keys(this.formBind).forEach((t) => {
-      this.formBind[t].forEach((i) => {
-        i();
+    Object.keys(this.formBind).forEach((ele) => {
+      this.formBind[ele].forEach((unWatch) => {
+        unWatch();
       });
     });
   },
   methods: {
-    setPx: _,
-    deepClone: D,
-    getComponent: W,
-    getPlaceholder: R,
-    uploadFun: j,
-    getDisabled(t) {
-      return this.vaildDetail(t) || this.isDetail || this.vaildDisabled(t) || this.allDisabled;
+    setPx,
+    deepClone,
+    getComponent,
+    getPlaceholder,
+    uploadFun,
+    getDisabled(column) {
+      return this.vaildDetail(column) || this.isDetail || this.vaildDisabled(column) || this.allDisabled;
     },
-    getSpan(t) {
-      return t.span || this.parentOption.span || this.itemSpanDefault;
+    getSpan(column) {
+      return column.span || this.parentOption.span || this.itemSpanDefault;
     },
-    isGroupShow(t, i) {
-      return this.isTabs ? i == this.activeName || i == 0 : !0;
+    isGroupShow(item, index) {
+      return this.isTabs ? index == this.activeName || index == 0 : !0;
     },
     // 初始化表单
     dataFormat() {
-      const t = G(this.propOption).tableForm, i = this.value, s = {};
-      Object.entries(Object.assign(t, i)).forEach((r) => {
-        const p = r[0], e = r[1];
-        u(i[p]) ? s[p] = e : s[p] = i[p];
-      }), this.$set(this, "form", s), this.setLabel(), this.setControl(), this.setVal(), setTimeout(() => {
+      const formDefault = formInitVal(this.propOption).tableForm, formValue = this.value, form = {};
+      Object.entries(Object.assign(formDefault, formValue)).forEach((ele) => {
+        const key = ele[0], value = ele[1];
+        isBlank(formValue[key]) ? form[key] = value : form[key] = formValue[key];
+      }), this.$set(this, "form", form), this.setLabel(), this.setControl(), this.setVal(), setTimeout(() => {
         this.formCreate = !0, this.clearValidate();
       });
     },
     setControl() {
-      this.propOption.forEach((t) => {
-        const i = t.prop, s = t.bind, r = t.control;
-        if (!this.formBind[i]) {
-          const p = [];
-          if (s) {
-            const e = this.$watch(`form.${i}`, (a, n) => {
-              a != n && L(this.form, s, a);
-            }), o = this.$watch(`form.${s}`, (a, n) => {
-              a != n && this.$set(this.form, i, a);
+      this.propOption.forEach((column) => {
+        const prop = column.prop, bind = column.bind, control = column.control;
+        if (!this.formBind[prop]) {
+          const bindList = [];
+          if (bind) {
+            const formProp = this.$watch(`form.${prop}`, (n, o) => {
+              n != o && setAsVal(this.form, bind, n);
+            }), formDeep = this.$watch(`form.${bind}`, (n, o) => {
+              n != o && this.$set(this.form, prop, n);
             });
-            p.push(e), p.push(o), this.$set(this.form, i, V(this.form, s));
+            bindList.push(formProp), bindList.push(formDeep), this.$set(this.form, prop, getAsVal(this.form, bind));
           }
-          if (r) {
-            const e = () => {
-              const a = r(this.form[t.prop], this.form) || {};
-              Object.keys(a).forEach((n) => {
-                const d = Object.assign(this.objectOption[n] || {}, a[n]);
-                this.$set(this.objectOption, n, d), a[n].dicData && (this.DIC[n] = a[n].dicData);
+          if (control) {
+            const callback = () => {
+              const controlList = control(this.form[column.prop], this.form) || {};
+              Object.keys(controlList).forEach((item) => {
+                const ele = Object.assign(this.objectOption[item] || {}, controlList[item]);
+                this.$set(this.objectOption, item, ele), controlList[item].dicData && (this.DIC[item] = controlList[item].dicData);
               });
-            }, o = this.$watch(`form.${i}`, () => {
-              e();
+            }, formControl = this.$watch(`form.${prop}`, () => {
+              callback();
             });
-            p.push(o), e();
+            bindList.push(formControl), callback();
           }
-          this.formBind[i] = p;
+          this.formBind[prop] = bindList;
         }
       });
     },
     setForm() {
-      Object.keys(this.value).forEach((t) => {
-        this.$set(this.form, t, this.value[t]);
+      Object.keys(this.value).forEach((ele) => {
+        this.$set(this.form, ele, this.value[ele]);
       });
     },
     setVal() {
       this.$emit("input", this.form), this.$emit("change", this.form);
     },
     setLabel() {
-      this.tableOption.filterNull === !0 && (this.form = $(this.form, [""], !1)), this.tableOption.filterDic == !0 ? this.form = $(this.form, ["$"], !1) : this.propOption.forEach((t) => {
-        let i;
-        const s = this.DIC[t.prop];
-        u(s) || (i = P(this.form, t, this.tableOption, s), i ? this.$set(this.form, `$${t.prop}`, i) : this.$delete(this.form, `$${t.prop}`));
+      this.tableOption.filterNull === !0 && (this.form = filterParams(this.form, [""], !1)), this.tableOption.filterDic == !0 ? this.form = filterParams(this.form, ["$"], !1) : this.propOption.forEach((column) => {
+        let result;
+        const DIC = this.DIC[column.prop];
+        isBlank(DIC) || (result = detail(this.form, column, this.tableOption, DIC), result ? this.$set(this.form, `$${column.prop}`, result) : this.$delete(this.form, `$${column.prop}`));
       });
     },
-    handleGroupClick(t) {
-      this.$emit("tab-click", t);
+    handleGroupClick(activeNames) {
+      this.$emit("tab-click", activeNames);
     },
-    handleTabClick(t, i) {
-      this.$emit("tab-click", t, i);
+    handleTabClick(tab, event) {
+      this.$emit("tab-click", tab, event);
     },
-    getLabelWidth(t, i) {
-      let s;
-      return u(t.labelWidth) ? u(i.labelWidth) ? s = this.parentOption.labelWidth : s = i.labelWidth : s = t.labelWidth, _(s, this.labelWidth);
+    getLabelWidth(column, item) {
+      let result;
+      return isBlank(column.labelWidth) ? isBlank(item.labelWidth) ? result = this.parentOption.labelWidth : result = item.labelWidth : result = column.labelWidth, setPx(result, this.labelWidth);
     },
     // 对部分表单字段进行校验的方法
-    validateField(t) {
-      return this.$refs.form.validateField(t);
+    validateField(val) {
+      return this.$refs.form.validateField(val);
     },
-    validTip(t) {
-      return !t.tip || t.type === "upload";
+    validTip(column) {
+      return !column.tip || column.type === "upload";
     },
-    getPropRef(t) {
-      return this.$refs[t][0];
+    getPropRef(prop) {
+      return this.$refs[prop][0];
     },
-    handleChange(t, i) {
+    handleChange(list, column) {
       this.$nextTick(() => {
-        const s = i.cascader, r = s.join(",");
-        s.forEach((p) => {
-          const e = p, o = this.form[i.prop], a = this.findObject(t, e);
-          u(a) || (this.formList.includes(r) && s.forEach((n) => {
-            this.form[n] = "", this.$set(this.DIC, n, []);
-          }), !(u(s) || u(o) || u(a)) && H({
-            column: a,
-            value: o,
+        const cascader = column.cascader, str = cascader.join(",");
+        cascader.forEach((item) => {
+          const columnNextProp = item, value = this.form[column.prop], columnNext = this.findObject(list, columnNextProp);
+          isBlank(columnNext) || (this.formList.includes(str) && cascader.forEach((ele) => {
+            this.form[ele] = "", this.$set(this.DIC, ele, []);
+          }), !(isBlank(cascader) || isBlank(value) || isBlank(columnNext)) && sendDic({
+            column: columnNext,
+            value,
             form: this.form
-          }).then((n) => {
-            this.formList.includes(r) || this.formList.push(r);
-            const d = n || [];
-            this.$set(this.DIC, e, d), !u(d) && !u(d) && !u(a.cascaderIndex) && u(this.form[e]) && (this.form[e] = d[a.cascaderIndex][(a.props || {}).value || z.value]);
+          }).then((res) => {
+            this.formList.includes(str) || this.formList.push(str);
+            const dic = res || [];
+            this.$set(this.DIC, columnNextProp, dic), !isBlank(dic) && !isBlank(dic) && !isBlank(columnNext.cascaderIndex) && isBlank(this.form[columnNextProp]) && (this.form[columnNextProp] = dic[columnNext.cascaderIndex][(columnNext.props || {}).value || DIC_PROPS.value]);
           }));
         });
       });
@@ -646,85 +662,87 @@ const X = {
     handlePrint() {
       this.$Print(this.$el);
     },
-    propChange(t, i) {
-      i.cascader && this.handleChange(t, i);
+    propChange(option, column) {
+      column.cascader && this.handleChange(option, column);
     },
     handleMock() {
-      this.isMock && (this.columnOption.forEach((t) => {
-        const i = K(t.column, this.DIC, this.form, this.isMock);
-        u(i) || Object.keys(i).forEach((s) => {
-          this.form[s] = i[s];
+      this.isMock && (this.columnOption.forEach((column) => {
+        const form = mock(column.column, this.DIC, this.form, this.isMock);
+        isBlank(form) || Object.keys(form).forEach((ele) => {
+          this.form[ele] = form[ele];
         });
       }), this.$nextTick(() => {
         this.clearValidate(), this.$emit("mock-change", this.form);
       }));
     },
-    vaildDetail(t) {
-      let i;
+    vaildDetail(column) {
+      let key;
       if (this.detail)
         return !1;
-      if (!u(t.detail))
-        i = "detail";
+      if (!isBlank(column.detail))
+        key = "detail";
       else if (this.isAdd)
-        i = "addDetail";
+        key = "addDetail";
       else if (this.isEdit)
-        i = "editDetail";
+        key = "editDetail";
       else if (this.isView)
         return !1;
-      return i ? t[i] === !0 : !1;
+      return key ? column[key] === !0 : !1;
     },
     // 验证表单是否禁止
-    vaildDisabled(t) {
-      let i;
+    vaildDisabled(column) {
+      let key;
       if (this.disabled)
         return !0;
-      if (!u(t.disabled))
-        i = "disabled";
+      if (!isBlank(column.disabled))
+        key = "disabled";
       else if (this.isAdd)
-        i = "addDisabled";
+        key = "addDisabled";
       else if (this.isEdit)
-        i = "editDisabled";
+        key = "editDisabled";
       else if (this.isView)
         return !0;
-      return i ? t[i] === !0 : !1;
+      return key ? column[key] === !0 : !1;
     },
     // 验证表单是否显隐
-    vaildDisplay(t) {
-      let i;
-      return u(t.display) ? this.isAdd ? i = "addDisplay" : this.isEdit ? i = "editDisplay" : this.isView && (i = "viewDisplay") : i = "display", i ? I(t[i], !0) : !0;
-    },
-    async clearValidate(t) {
-      var i;
-      (i = this.$refs.form) == null || i.clearValidate(t);
+    vaildDisplay(column) {
+      let key;
+      return isBlank(column.display) ? this.isAdd ? key = "addDisplay" : this.isEdit ? key = "editDisplay" : this.isView && (key = "viewDisplay") : key = "display", key ? optVal(column[key], !0) : !0;
+    },
+    clearValidate(list) {
+      return __async(this, null, function* () {
+        var _a;
+        (_a = this.$refs.form) == null || _a.clearValidate(list);
+      });
     },
     validateCellForm() {
-      return new Promise((t) => {
-        this.$refs.form.validate((i, s) => {
-          t(s);
+      return new Promise((resolve) => {
+        this.$refs.form.validate((valid, msg) => {
+          resolve(msg);
         });
       });
     },
-    validate(t) {
-      this.$refs.form.validate((i, s) => {
-        const r = [], p = [], e = {};
-        this.dynamicOption.forEach((o) => {
-          const a = o.children.type === "form";
-          p.push(o.prop), a ? u(this.$refs[o.prop][0].$refs.temp.$refs.main) || this.$refs[o.prop][0].$refs.temp.$refs.main.forEach((n) => {
-            r.push(n.validateCellForm());
-          }) : r.push(this.$refs[o.prop][0].$refs.temp.$refs.main.validateCellForm());
-        }), Promise.all(r).then((o) => {
-          o.forEach((n, d) => {
-            u(n) || (e[p[d]] = n);
+    validate(callback) {
+      this.$refs.form.validate((valid, msg) => {
+        const dynamicList = [], dynamicName = [], dynamicError = {};
+        this.dynamicOption.forEach((ele) => {
+          const isForm = ele.children.type === "form";
+          dynamicName.push(ele.prop), isForm ? isBlank(this.$refs[ele.prop][0].$refs.temp.$refs.main) || this.$refs[ele.prop][0].$refs.temp.$refs.main.forEach((ele2) => {
+            dynamicList.push(ele2.validateCellForm());
+          }) : dynamicList.push(this.$refs[ele.prop][0].$refs.temp.$refs.main.validateCellForm());
+        }), Promise.all(dynamicList).then((res) => {
+          res.forEach((error, index) => {
+            isBlank(error) || (dynamicError[dynamicName[index]] = error);
           });
-          const a = Object.assign(e, s);
-          u(a) ? (this.show(), t(!0, this.hide)) : t(!1, this.hide, a);
+          const result = Object.assign(dynamicError, msg);
+          isBlank(result) ? (this.show(), callback(!0, this.hide)) : callback(!1, this.hide, result);
         });
       });
     },
-    resetForm(t = !0) {
-      if (t) {
-        const i = this.propOption.map((s) => s.prop);
-        this.form = M(this.form, i, (this.tableOption.filterParams || []).concat([this.rowKey]));
+    resetForm(reset = !0) {
+      if (reset) {
+        const propList = this.propOption.map((ele) => ele.prop);
+        this.form = clearVal(this.form, propList, (this.tableOption.filterParams || []).concat([this.rowKey]));
       }
       this.$nextTick(() => {
         this.clearValidate(), this.$emit("reset-change");
@@ -740,29 +758,29 @@ const X = {
       this.allDisabled = !1;
     },
     submit() {
-      this.validate((t, i) => {
-        t ? this.$emit("submit", $(this.form, ["$"]), this.hide) : this.$emit("error", i);
+      this.validate((valid, msg) => {
+        valid ? this.$emit("submit", filterParams(this.form, ["$"]), this.hide) : this.$emit("error", msg);
       });
     }
   }
-}, S = {};
-var Y = /* @__PURE__ */ q(
-  X,
-  J,
-  Q,
+}, __cssModules = {};
+var __component__ = /* @__PURE__ */ normalizeComponent(
+  __vue2_script,
+  render,
+  staticRenderFns,
   !1,
-  Z,
+  __vue2_injectStyles,
   null,
   null,
   null
 );
-function Z(t) {
-  for (let i in S)
-    this[i] = S[i];
+function __vue2_injectStyles(context) {
+  for (let o in __cssModules)
+    this[o] = __cssModules[o];
 }
-const lt = /* @__PURE__ */ function() {
-  return Y.exports;
+const FyForm = /* @__PURE__ */ function() {
+  return __component__.exports;
 }();
 export {
-  lt as default
+  FyForm as default
 };