vft 0.0.494 → 0.0.495

package/es/components/super-form/use/use-form-events.js

@@ -1,269 +1,303 @@
-import { FormCompEnum as j } from "../../../utils/form-register.js";
+import { FormCompEnum as T } from "../../../utils/form-register.js";
 import "@vueuse/core";
-import { isDef as H, isFunction as A, isString as x, isObject as m, isArray as V, deepMerge as nt, findDifferentValuesForObj as rt, isNullOrUndefined as J, isEmpty as st, isEmptyObject as lt } from "@vft/utils";
+import { isFunction as b, isDef as H, isString as g, isObject as j, isArray as C, deepMerge as ot, findDifferentValuesForObj as st, isNullOrUndefined as J, isEmpty as at, isEmptyObject as ct } from "@vft/utils";
 import "../../config-provider/hooks/use-global-config.js";
-import { unref as n, toRaw as S, nextTick as Q } from "vue";
-import { get as ot, cloneDeep as B, uniqBy as at, isEqual as ft, set as X } from "lodash-es";
+import { toRaw as I, unref as n, nextTick as Q } from "vue";
+import { get as lt, cloneDeep as A, uniqBy as ft, isEqual as ut, set as X } from "lodash-es";
 import "../../form/index.js";
 import { formatToDate as W } from "@vft/utils/date";
-import { isInput as ct, isDatePicker as ut } from "../component-map.js";
-import { handleInputNumberValue as dt } from "./helper.js";
-function _(p, v) {
-  const { show: o, ifShow: f } = p;
-  let h = !0, c = !0;
-  return typeof o == "boolean" ? h = o : typeof o == "function" && (h = o({
+import { isInput as dt, isDatePicker as ht } from "../component-map.js";
+import { handleInputNumberValue as pt } from "./helper.js";
+function L(p, F) {
+  const { show: c, ifShow: l } = p;
+  let y = !0, u = !0;
+  return typeof c == "boolean" ? y = c : typeof c == "function" && (y = c({
     field: p.field,
-    model: v,
+    model: F,
     values: {
-      ...v
+      ...F
     },
     schema: p
-  })), typeof f == "boolean" ? c = f : typeof f == "function" && (c = f({
+  })), typeof l == "boolean" ? u = l : typeof l == "function" && (u = l({
     field: p.field,
-    model: v,
+    model: F,
     values: {
-      ...v
+      ...F
     },
     schema: p
-  })), h && c;
+  })), y && u;
 }
-function pt(p, v = {}) {
-  const o = /^\[(.+)\]$/;
-  if (o.test(p)) {
-    const f = p.match(o);
-    if (f && f[1]) {
-      const h = f[1].split(",");
-      if (!h.length)
+function Ft(p, F = {}) {
+  const c = /^\[(.+)\]$/;
+  if (c.test(p)) {
+    const l = p.match(c);
+    if (l && l[1]) {
+      const y = l[1].split(",");
+      if (!y.length)
         return;
-      const c = [];
-      return h.forEach((y, O) => {
-        X(c, O, v[y.trim()]);
-      }), c.filter(Boolean).length ? c : void 0;
+      const u = [];
+      return y.forEach((v, V) => {
+        X(u, V, F[v.trim()]);
+      }), u.filter(Boolean).length ? u : void 0;
     }
   }
 }
-function ht(p, v = {}) {
-  const o = /^\{(.+)\}$/;
-  if (o.test(p)) {
-    const f = p.match(o);
-    if (f && f[1]) {
-      const h = f[1].split(",");
-      if (!h.length)
+function yt(p, F = {}) {
+  const c = /^\{(.+)\}$/;
+  if (c.test(p)) {
+    const l = p.match(c);
+    if (l && l[1]) {
+      const y = l[1].split(",");
+      if (!y.length)
         return;
-      const c = {};
-      return h.forEach((y) => {
-        X(c, y.trim(), v[y.trim()]);
-      }), Object.values(c).filter(Boolean).length ? c : void 0;
+      const u = {};
+      return y.forEach((v) => {
+        X(u, v.trim(), F[v.trim()]);
+      }), Object.values(u).filter(Boolean).length ? u : void 0;
     }
   }
 }
-function Ot({
+function Ct({
   emit: p,
-  getProps: v,
-  formModel: o,
-  getSchema: f,
-  defaultValueRef: h,
-  formElRef: c,
-  schemaRef: y,
-  handleFormValues: O,
-  initValues: T
+  getProps: F,
+  formModel: c,
+  getSchema: l,
+  defaultValueRef: y,
+  formElRef: u,
+  schemaRef: v,
+  handleFormValues: V,
+  initValues: S
 }) {
   async function Y(t) {
-    const { resetFunc: e, submitOnReset: s } = n(v);
-    e && A(e) && await e();
-    const r = n(c);
-    if (r) {
+    const { resetFunc: i, submitOnReset: r } = n(F);
+    i && b(i) && await i();
+    const o = n(u);
+    if (o) {
       if (t?.length)
-        return r.resetFields(t);
-      Object.keys(o).forEach((a) => {
-        const l = n(f).find((u) => u.field === a), i = B(h.value[a]);
-        o[a] = ct(l?.type) ? i || "" : i;
-      }), Q(() => D()), p("reset", S(o)), s && await U();
+        return o.resetFields(t);
+      Object.keys(c).forEach((s) => {
+        const a = n(l).find((f) => f.field === s), e = A(y.value[s]);
+        c[s] = dt(a?.type) ? e || "" : e;
+      }), Q(() => O()), p("reset", I(c)), r && await z();
     }
   }
-  async function q(t, e = !0) {
-    const s = n(f).map((i) => i.field).filter(Boolean), r = ".", a = s.filter(
-      (i) => String(i).indexOf(r) >= 0
-    ), l = [];
-    s.forEach((i) => {
-      const u = n(f).find((d) => d.field === i);
-      let b = ot(t, i);
-      const I = Reflect.has(t, i);
-      b = dt(u?.type, b);
-      const { componentProps: z } = u || {};
-      let w = z;
-      typeof z == "function" && (w = w({ formModel: n(o) }));
-      const G = pt(i, t) || ht(i, t);
-      if (I || G) {
-        const d = G || b;
-        if (M(i))
-          if (Array.isArray(d)) {
-            const F = [];
-            for (const E of d)
-              F.push(E ? W(E) : null);
-            n(o)[i] = F;
+  async function q(t, i = !0) {
+    const r = n(l).map((e) => e.field).filter(Boolean), o = ".", s = r.filter(
+      (e) => String(e).indexOf(o) >= 0
+    ), a = [];
+    r.forEach((e) => {
+      const f = n(l).find((h) => h.field === e);
+      let d = lt(t, e);
+      const m = Reflect.has(t, e);
+      d = pt(f?.type, d);
+      const { componentProps: w } = f || {};
+      let D = w;
+      typeof w == "function" && (D = D({ formModel: n(c) }));
+      const G = Ft(e, t) || yt(e, t);
+      if (m || G) {
+        const h = G || d;
+        if (tt(e))
+          if (Array.isArray(h)) {
+            const E = [];
+            for (const B of h)
+              E.push(B ? W(B) : null);
+            n(c)[e] = E;
           } else
-            n(o)[i] = d ? w?.valueFormat ? d : W(d) : null;
+            n(c)[e] = h ? D?.valueFormat ? h : W(h) : null;
         else
-          n(o)[i] = d;
-        w?.onChange && w?.onChange(d), l.push(i);
+          n(c)[e] = h;
+        D?.onChange && D?.onChange(h), a.push(e);
       } else
-        a.forEach((d) => {
+        s.forEach((h) => {
           try {
-            const F = d.split(".").reduce((E, it) => E[it], t);
-            H(F) && (n(o)[d] = n(F), l.push(d));
+            const E = h.split(".").reduce((B, rt) => B[rt], t);
+            H(E) && (n(c)[h] = n(E), a.push(h));
           } catch {
-            H(h.value[d]) && (n(o)[d] = B(
-              n(h.value[d])
+            H(y.value[h]) && (n(c)[h] = A(
+              n(y.value[h])
             ));
           }
         });
-    }), e && Q(async () => {
-      await $(l).catch((i) => {
+    }), i && Q(async () => {
+      await $(a).catch((e) => {
       });
     });
   }
   async function Z(t) {
-    const e = B(n(f));
+    const i = A(n(l));
     if (!t)
       return;
-    let s = x(t) ? [t] : t;
-    x(t) && (s = [t]);
-    for (const r of s)
-      L(r, e);
-    y.value = e;
+    let r = g(t) ? [t] : t;
+    g(t) && (r = [t]);
+    for (const o of r)
+      P(o, i);
+    v.value = i;
   }
-  function L(t, e) {
-    if (x(t)) {
-      const s = e.findIndex((r) => r.field === t);
-      s !== -1 && (delete o[t], e.splice(s, 1));
+  function P(t, i) {
+    if (g(t)) {
+      const r = i.findIndex((o) => o.field === t);
+      r !== -1 && (delete c[t], i.splice(r, 1));
     }
   }
-  async function K(t, e, s = !1) {
-    const r = B(n(f)), a = r.findIndex((i) => i.field === e), l = m(t) ? [t] : t;
-    if (!e || a === -1 || s) {
-      s ? r.unshift(...l) : r.push(...l), y.value = r, g(t);
+  async function K(t, i, r = !1) {
+    const o = A(n(l)), s = o.findIndex((e) => e.field === i), a = j(t) ? [t] : t;
+    if (!i || s === -1 || r) {
+      r ? o.unshift(...a) : o.push(...a), v.value = o, x(t);
       return;
     }
-    a !== -1 && r.splice(a + 1, 0, ...l), g(t), y.value = r;
+    s !== -1 && o.splice(s + 1, 0, ...a), x(t), v.value = o;
   }
   async function k(t) {
-    let e = [];
-    if (m(t) && e.push(t), V(t) && (e = [...t]), !e.every(
-      (r) => r.type === j.Divider || Reflect.has(r, "field") && r.field
+    let i = [];
+    if (j(t) && i.push(t), C(t) && (i = [...t]), !i.every(
+      (o) => o.type === T.Divider || Reflect.has(o, "field") && o.field
     )) {
       console.error(
         "All children of the form Schema array that need to be updated must contain the `field` field"
       );
       return;
     }
-    y.value = e;
+    v.value = i;
   }
   async function N(t) {
-    let e = [];
-    if (m(t) && e.push(t), V(t) && (e = [...t]), !e.every(
-      (l) => l.type === j.Divider || Reflect.has(l, "field") && l.field
+    let i = [];
+    if (j(t) && i.push(t), C(t) && (i = [...t]), !i.every(
+      (a) => a.type === T.Divider || Reflect.has(a, "field") && a.field
     )) {
       console.error(
         "All children of the form Schema array that need to be updated must contain the `field` field"
       );
       return;
     }
-    const r = [], a = [];
-    n(f).forEach((l) => {
-      let i;
-      if (e.forEach((u) => {
-        l.field === u.field && (i = u), u.defaultValue && u.field && r.push(u.field);
-      }), i !== void 0 && l.field === i.field) {
-        const u = nt(l, i);
-        a.push(u);
+    const o = [], s = [];
+    n(l).forEach((a) => {
+      let e;
+      if (i.forEach((f) => {
+        a.field === f.field && (e = f), f.defaultValue && f.field && o.push(f.field);
+      }), e !== void 0 && a.field === e.field) {
+        const f = ot(a, e);
+        s.push(f);
       } else
-        a.push(l);
-    }), g(a, r), y.value = at(a, "field");
+        s.push(a);
+    }), x(s, o), v.value = ft(s, "field");
   }
-  function g(t, e, s = !0) {
-    if (V(e) && e?.length === 0)
+  function x(t, i, r = !0) {
+    if (C(i) && i?.length === 0)
       return;
-    let r = [];
-    m(t) && r.push(t), V(t) && (r = [...t]);
-    const a = {}, l = C();
-    r.forEach((i) => {
-      i.type !== j.Divider && Reflect.has(i, "field") && i.field && !J(i.defaultValue) && (!(i.field in l) || J(l[i.field]) || st(l[i.field])) && (a[i.field] = i.defaultValue);
-    }), lt(a) || q(a, s);
+    let o = [];
+    j(t) && o.push(t), C(t) && (o = [...t]);
+    const s = {}, a = _();
+    o.forEach((e) => {
+      e.type !== T.Divider && Reflect.has(e, "field") && e.field && !J(e.defaultValue) && (!(e.field in a) || J(a[e.field]) || at(a[e.field])) && (s[e.field] = e.defaultValue);
+    }), ct(s) || q(s, r);
   }
-  function C(t = !1) {
-    if (!n(c)) return {};
-    const s = O(S(n(o)));
+  function _(t = !1) {
+    if (!n(u)) return {};
+    const r = V(I(n(c)));
     if (t)
-      return s;
-    const r = n(f).filter((l) => _(l, n(o))).map((l) => l.field).filter(Boolean), a = {};
-    return r.forEach((l) => {
-      l in s && (a[l] = s[l]);
-    }), a;
+      return r;
+    const o = n(l).filter((d) => L(d, n(c))).map((d) => d.field).filter(Boolean), s = {};
+    o.forEach((d) => {
+      d in r && (s[d] = r[d]);
+    });
+    const a = n(l), e = {};
+    o.forEach((d) => {
+      if (d in s) {
+        const m = a.find((D) => D.field === d);
+        let w = s[d];
+        m?.formatter && b(m.formatter) && (w = m.formatter(
+          w,
+          d,
+          s,
+          m
+        )), e[d] = w;
+      }
+    });
+    const { formatter: f } = n(F);
+    return f && b(f) ? f(e) : e;
   }
-  function R(t) {
-    return n(c) ? S(n(o))[t] : {};
+  function R(t, i, r) {
+    const s = n(l).find((a) => a.field === t);
+    return s?.formatter && b(s.formatter) ? s.formatter(i, t, r, s) : i;
   }
   function M(t) {
-    return n(f).some((e) => e.field === t ? ut(e.type) : !1);
+    if (!n(u)) return {};
+    if (!(t in n(c)))
+      return {};
+    const r = V(I(n(c))), o = r[t];
+    return R(t, o, r);
+  }
+  function tt(t) {
+    return n(l).some((i) => i.field === t ? ht(i.type) : !1);
   }
   async function $(t) {
-    return t || (t = n(f).filter((s) => _(s, n(o))).map((s) => s.field).filter(Boolean)), n(c)?.validateField(t);
+    return t || (t = n(l).filter((r) => L(r, n(c))).map((r) => r.field).filter(Boolean)), n(u)?.validateField(t);
   }
-  async function P(t) {
-    return t || (t = n(f).filter((s) => _(s, n(o))).map((s) => s.field).filter(Boolean)), await n(c)?.validate(t, () => {
+  async function U(t) {
+    return t || (t = n(l).filter((r) => L(r, n(c))).map((r) => r.field).filter(Boolean)), await n(u)?.validate(t, () => {
     });
   }
-  async function D(t) {
-    await n(c)?.clearValidate(t);
+  async function O(t) {
+    await n(u)?.clearValidate(t);
   }
-  async function tt(t, e) {
-    await D(t), await N([{ field: t, itemProps: { error: e } }]);
+  async function et(t, i) {
+    await O(t), await N([{ field: t, itemProps: { error: i } }]);
   }
-  async function et(t, e) {
-    await n(c)?.scrollToField(t, e);
+  async function it(t, i) {
+    await n(u)?.scrollToField(t, i);
   }
-  async function U(t) {
-    const { autoCleanErrorMessage: e, watchDataIsChange: s } = n(v);
-    t && t.preventDefault(), e && await D();
-    const { submitFunc: r, beforeSubmitFunc: a } = n(v);
-    if (a && A(a) && await a(), r && A(r)) {
-      await r();
+  async function z(t) {
+    const { autoCleanErrorMessage: i, watchDataIsChange: r } = n(F);
+    t && t.preventDefault(), i && await O();
+    const { submitFunc: o, beforeSubmitFunc: s } = n(F);
+    if (s && b(s) && await s(), o && b(o)) {
+      await o();
       return;
     }
-    if (n(c))
+    if (n(u))
       try {
-        if (!await P())
+        if (!await U())
           return;
-        const u = C();
-        if (s) {
-          const b = ft(T.value, u), I = rt(T.value, u);
-          p("submit", u, !b, I);
+        const f = _();
+        if (r) {
+          const d = ut(S.value, f), m = st(S.value, f);
+          p("submit", f, !d, m);
         } else
-          p("submit", u);
-      } catch (i) {
-        if (i?.outOfDate === !1 && i?.errorFields)
+          p("submit", f);
+      } catch (e) {
+        if (e?.outOfDate === !1 && e?.errorFields)
           return;
-        throw new Error(i.message);
+        throw new Error(e.message);
       }
   }
+  function nt() {
+    const t = V(I(n(c))), i = n(l), r = {};
+    Object.keys(t).forEach((s) => {
+      const a = i.find((f) => f.field === s);
+      let e = t[s];
+      a?.formatter && b(a.formatter) && (e = a.formatter(e, s, t, a)), r[s] = e;
+    });
+    const { formatter: o } = n(F);
+    return o && b(o) ? o(r) : r;
+  }
   return {
-    handleSubmit: U,
-    clearValidate: D,
-    validate: P,
+    handleSubmit: z,
+    clearValidate: O,
+    validate: U,
     validateField: $,
-    getFieldsValue: C,
+    getFieldsValue: _,
     updateSchema: N,
     resetSchema: k,
     appendSchemaByField: K,
     removeSchemaByField: Z,
     resetFields: Y,
     setFieldsValue: q,
-    scrollToField: et,
-    getFieldValue: R,
-    setFormItemError: tt
+    scrollToField: it,
+    getFieldValue: M,
+    setFormItemError: et,
+    getFormattedFormModel: nt
   };
 }
 export {
-  Ot as useFormEvents
+  Ct as useFormEvents
 };