vft 0.0.375 → 0.0.376

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

@@ -1,384 +1,265 @@
-import { isDef, isFunction, isString, isObject, isArray, deepMerge, findDifferentValuesForObj, isNullOrUndefined, isEmpty, isEmptyObject } from "@vft/utils";
-import { formatToDate } from "@vft/utils/date";
-import { get, cloneDeep, uniqBy, isEqual, set } from "lodash-es";
-import { unref, toRaw, nextTick } from "vue";
-import { isInput, FormCompEnum, isDatePicker } from "../component-map.js";
-import { handleInputNumberValue } from "./helper.js";
-function isFieldVisible(schema, formModel) {
-  const { show, ifShow } = schema;
-  let isShow = true;
-  let isIfShow = true;
-  if (typeof show === "boolean") {
-    isShow = show;
-  } else if (typeof show === "function") {
-    isShow = show({
-      field: schema.field,
-      model: formModel,
-      values: {
-        ...formModel
-      },
-      schema
-    });
-  }
-  if (typeof ifShow === "boolean") {
-    isIfShow = ifShow;
-  } else if (typeof ifShow === "function") {
-    isIfShow = ifShow({
-      field: schema.field,
-      model: formModel,
-      values: {
-        ...formModel
-      },
-      schema
-    });
-  }
-  return isShow && isIfShow;
+import { isDef as H, isFunction as j, isString as A, isObject as V, isArray as I, deepMerge as nt, findDifferentValuesForObj as rt, isNullOrUndefined as J, isEmpty as st, isEmptyObject as lt } from "@vft/utils";
+import { formatToDate as Q } from "@vft/utils/date";
+import { get as ot, cloneDeep as m, uniqBy as at, isEqual as ct, set as X } from "lodash-es";
+import { unref as n, toRaw as x, nextTick as W } from "vue";
+import { isInput as ft, FormCompEnum as S, isDatePicker as ut } from "../component-map.js";
+import { handleInputNumberValue as dt } from "./helper.js";
+function _(h, y) {
+  const { show: o, ifShow: c } = h;
+  let p = !0, f = !0;
+  return typeof o == "boolean" ? p = o : typeof o == "function" && (p = o({
+    field: h.field,
+    model: y,
+    values: {
+      ...y
+    },
+    schema: h
+  })), typeof c == "boolean" ? f = c : typeof c == "function" && (f = c({
+    field: h.field,
+    model: y,
+    values: {
+      ...y
+    },
+    schema: h
+  })), p && f;
 }
-function tryConstructArray(field, values = {}) {
-  const pattern = /^\[(.+)\]$/;
-  if (pattern.test(field)) {
-    const match = field.match(pattern);
-    if (match && match[1]) {
-      const keys = match[1].split(",");
-      if (!keys.length) {
-        return void 0;
-      }
-      const result = [];
-      keys.forEach((k, index) => {
-        set(result, index, values[k.trim()]);
-      });
-      return result.filter(Boolean).length ? result : void 0;
+function ht(h, y = {}) {
+  const o = /^\[(.+)\]$/;
+  if (o.test(h)) {
+    const c = h.match(o);
+    if (c && c[1]) {
+      const p = c[1].split(",");
+      if (!p.length)
+        return;
+      const f = [];
+      return p.forEach((F, B) => {
+        X(f, B, y[F.trim()]);
+      }), f.filter(Boolean).length ? f : void 0;
     }
   }
 }
-function tryConstructObject(field, values = {}) {
-  const pattern = /^\{(.+)\}$/;
-  if (pattern.test(field)) {
-    const match = field.match(pattern);
-    if (match && match[1]) {
-      const keys = match[1].split(",");
-      if (!keys.length) {
+function pt(h, y = {}) {
+  const o = /^\{(.+)\}$/;
+  if (o.test(h)) {
+    const c = h.match(o);
+    if (c && c[1]) {
+      const p = c[1].split(",");
+      if (!p.length)
         return;
-      }
-      const result = {};
-      keys.forEach((k) => {
-        set(result, k.trim(), values[k.trim()]);
-      });
-      return Object.values(result).filter(Boolean).length ? result : void 0;
+      const f = {};
+      return p.forEach((F) => {
+        X(f, F.trim(), y[F.trim()]);
+      }), Object.values(f).filter(Boolean).length ? f : void 0;
     }
   }
 }
-function useFormEvents({
-  emit,
-  getProps,
-  formModel,
-  getSchema,
-  defaultValueRef,
-  formElRef,
-  schemaRef,
-  handleFormValues,
-  initValues
+function Et({
+  emit: h,
+  getProps: y,
+  formModel: o,
+  getSchema: c,
+  defaultValueRef: p,
+  formElRef: f,
+  schemaRef: F,
+  handleFormValues: B,
+  initValues: T
 }) {
-  async function resetFields(props) {
-    const { resetFunc, submitOnReset } = unref(getProps);
-    resetFunc && isFunction(resetFunc) && await resetFunc();
-    const formEl = unref(formElRef);
-    if (!formEl) return;
-    if (props?.length) {
-      return formEl.resetFields(props);
+  async function Y(t) {
+    const { resetFunc: e, submitOnReset: s } = n(y);
+    e && j(e) && await e();
+    const r = n(f);
+    if (r) {
+      if (t?.length)
+        return r.resetFields(t);
+      Object.keys(o).forEach((a) => {
+        const l = n(c).find((u) => u.field === a), i = m(p.value[a]);
+        o[a] = ft(l?.type) ? i || "" : i;
+      }), W(() => D()), h("reset", x(o)), s && await U();
     }
-    Object.keys(formModel).forEach((key) => {
-      const schema = unref(getSchema).find((item) => item.field === key);
-      const defaultValue = cloneDeep(defaultValueRef.value[key]);
-      formModel[key] = isInput(schema?.type) ? defaultValue || "" : defaultValue;
-    });
-    nextTick(() => clearValidate());
-    emit("reset", toRaw(formModel));
-    submitOnReset && await handleSubmit();
   }
-  async function setFieldsValue(values, autoValidate = true) {
-    const fields = unref(getSchema).map((item) => item.field).filter(Boolean);
-    const delimiter = ".";
-    const nestKeyArray = fields.filter(
-      (item) => String(item).indexOf(delimiter) >= 0
-    );
-    const validKeys = [];
-    fields.forEach((key) => {
-      const schema = unref(getSchema).find((item) => item.field === key);
-      let value = get(values, key);
-      const hasKey = Reflect.has(values, key);
-      value = handleInputNumberValue(schema?.type, value);
-      const { componentProps } = schema || {};
-      let _props = componentProps;
-      if (typeof componentProps === "function") {
-        _props = _props({ formModel: unref(formModel) });
-      }
-      const constructValue = tryConstructArray(key, values) || tryConstructObject(key, values);
-      if (hasKey || !!constructValue) {
-        const fieldValue = constructValue || value;
-        if (itemIsDateType(key)) {
-          if (Array.isArray(fieldValue)) {
-            const arr = [];
-            for (const ele of fieldValue) {
-              arr.push(ele ? formatToDate(ele) : null);
-            }
-            unref(formModel)[key] = arr;
-          } else {
-            unref(formModel)[key] = fieldValue ? _props?.valueFormat ? fieldValue : formatToDate(fieldValue) : null;
-          }
-        } else {
-          unref(formModel)[key] = fieldValue;
-        }
-        if (_props?.onChange) {
-          _props?.onChange(fieldValue);
-        }
-        validKeys.push(key);
-      } else {
-        nestKeyArray.forEach((nestKey) => {
+  async function q(t, e = !0) {
+    const s = n(c).map((i) => i.field).filter(Boolean), r = ".", a = s.filter(
+      (i) => String(i).indexOf(r) >= 0
+    ), l = [];
+    s.forEach((i) => {
+      const u = n(c).find((d) => d.field === i);
+      let b = ot(t, i);
+      const C = 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 = ht(i, t) || pt(i, t);
+      if (C || G) {
+        const d = G || b;
+        if (M(i))
+          if (Array.isArray(d)) {
+            const v = [];
+            for (const E of d)
+              v.push(E ? Q(E) : null);
+            n(o)[i] = v;
+          } else
+            n(o)[i] = d ? w?.valueFormat ? d : Q(d) : null;
+        else
+          n(o)[i] = d;
+        w?.onChange && w?.onChange(d), l.push(i);
+      } else
+        a.forEach((d) => {
           try {
-            const value2 = nestKey.split(".").reduce((out, item) => out[item], values);
-            if (isDef(value2)) {
-              unref(formModel)[nestKey] = unref(value2);
-              validKeys.push(nestKey);
-            }
-          } catch (e) {
-            if (isDef(defaultValueRef.value[nestKey])) {
-              unref(formModel)[nestKey] = cloneDeep(
-                unref(defaultValueRef.value[nestKey])
-              );
-            }
+            const v = d.split(".").reduce((E, it) => E[it], t);
+            H(v) && (n(o)[d] = n(v), l.push(d));
+          } catch {
+            H(p.value[d]) && (n(o)[d] = m(
+              n(p.value[d])
+            ));
           }
         });
-      }
-    });
-    if (autoValidate) {
-      nextTick(async () => {
-        await validateField(validKeys).catch((_) => {
-        });
+    }), e && W(async () => {
+      await $(l).catch((i) => {
       });
-    }
+    });
   }
-  async function removeSchemaByField(fields) {
-    const schemaList = cloneDeep(unref(getSchema));
-    if (!fields) {
+  async function Z(t) {
+    const e = m(n(c));
+    if (!t)
       return;
-    }
-    let fieldList = isString(fields) ? [fields] : fields;
-    if (isString(fields)) {
-      fieldList = [fields];
-    }
-    for (const field of fieldList) {
-      _removeSchemaByFeild(field, schemaList);
-    }
-    schemaRef.value = schemaList;
+    let s = A(t) ? [t] : t;
+    A(t) && (s = [t]);
+    for (const r of s)
+      L(r, e);
+    F.value = e;
   }
-  function _removeSchemaByFeild(field, schemaList) {
-    if (isString(field)) {
-      const index = schemaList.findIndex((schema) => schema.field === field);
-      if (index !== -1) {
-        delete formModel[field];
-        schemaList.splice(index, 1);
-      }
+  function L(t, e) {
+    if (A(t)) {
+      const s = e.findIndex((r) => r.field === t);
+      s !== -1 && (delete o[t], e.splice(s, 1));
     }
   }
-  async function appendSchemaByField(schema, prefixField, first = false) {
-    const schemaList = cloneDeep(unref(getSchema));
-    const index = schemaList.findIndex((schema2) => schema2.field === prefixField);
-    const _schemaList = isObject(schema) ? [schema] : schema;
-    if (!prefixField || index === -1 || first) {
-      first ? schemaList.unshift(..._schemaList) : schemaList.push(..._schemaList);
-      schemaRef.value = schemaList;
-      _setDefaultValue(schema);
+  async function K(t, e, s = !1) {
+    const r = m(n(c)), a = r.findIndex((i) => i.field === e), l = V(t) ? [t] : t;
+    if (!e || a === -1 || s) {
+      s ? r.unshift(...l) : r.push(...l), F.value = r, O(t);
       return;
     }
-    if (index !== -1) {
-      schemaList.splice(index + 1, 0, ..._schemaList);
-    }
-    _setDefaultValue(schema);
-    schemaRef.value = schemaList;
+    a !== -1 && r.splice(a + 1, 0, ...l), O(t), F.value = r;
   }
-  async function resetSchema(data) {
-    let updateData = [];
-    if (isObject(data)) {
-      updateData.push(data);
-    }
-    if (isArray(data)) {
-      updateData = [...data];
-    }
-    const hasField = updateData.every(
-      (item) => item.type === FormCompEnum.DIVIDER || Reflect.has(item, "field") && item.field
-    );
-    if (!hasField) {
+  async function R(t) {
+    let e = [];
+    if (V(t) && e.push(t), I(t) && (e = [...t]), !e.every(
+      (r) => r.type === S.DIVIDER || Reflect.has(r, "field") && r.field
+    )) {
       console.error(
         "All children of the form Schema array that need to be updated must contain the `field` field"
       );
       return;
     }
-    schemaRef.value = updateData;
+    F.value = e;
   }
-  async function updateSchema(data) {
-    let updateData = [];
-    if (isObject(data)) {
-      updateData.push(data);
-    }
-    if (isArray(data)) {
-      updateData = [...data];
-    }
-    const hasField = updateData.every(
-      (item) => item.type === FormCompEnum.DIVIDER || Reflect.has(item, "field") && item.field
-    );
-    if (!hasField) {
+  async function N(t) {
+    let e = [];
+    if (V(t) && e.push(t), I(t) && (e = [...t]), !e.every(
+      (l) => l.type === S.DIVIDER || Reflect.has(l, "field") && l.field
+    )) {
       console.error(
         "All children of the form Schema array that need to be updated must contain the `field` field"
       );
       return;
     }
-    const willChangeValueFields = [];
-    const schema = [];
-    unref(getSchema).forEach((val) => {
-      let _val;
-      updateData.forEach((item) => {
-        if (val.field === item.field) {
-          _val = item;
-        }
-        if (item.defaultValue && item.field) {
-          willChangeValueFields.push(item.field);
-        }
-      });
-      if (_val !== void 0 && val.field === _val.field) {
-        const newSchema = deepMerge(val, _val);
-        schema.push(newSchema);
-      } else {
-        schema.push(val);
-      }
-    });
-    _setDefaultValue(schema, willChangeValueFields);
-    schemaRef.value = uniqBy(schema, "field");
+    const r = [], a = [];
+    n(c).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);
+      } else
+        a.push(l);
+    }), O(a, r), F.value = at(a, "field");
   }
-  function _setDefaultValue(data, willChangeValueFields, autoValidate = true) {
-    if (isArray(willChangeValueFields) && willChangeValueFields?.length === 0) {
+  function O(t, e, s = !0) {
+    if (I(e) && e?.length === 0)
       return;
-    }
-    let schemas = [];
-    if (isObject(data)) {
-      schemas.push(data);
-    }
-    if (isArray(data)) {
-      schemas = [...data];
-    }
-    const obj = {};
-    const currentFieldsValue = getFieldsValue();
-    schemas.forEach((item) => {
-      if (item.type !== FormCompEnum.DIVIDER && Reflect.has(item, "field") && item.field && !isNullOrUndefined(item.defaultValue) && (!(item.field in currentFieldsValue) || isNullOrUndefined(currentFieldsValue[item.field]) || isEmpty(currentFieldsValue[item.field]))) {
-        obj[item.field] = item.defaultValue;
-      }
-    });
-    if (!isEmptyObject(obj)) {
-      setFieldsValue(obj, autoValidate);
-    }
+    let r = [];
+    V(t) && r.push(t), I(t) && (r = [...t]);
+    const a = {}, l = g();
+    r.forEach((i) => {
+      i.type !== S.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);
   }
-  function getFieldsValue(showHideData = false) {
-    const formEl = unref(formElRef);
-    if (!formEl) return {};
-    const allFormData = handleFormValues(toRaw(unref(formModel)));
-    if (showHideData) {
-      return allFormData;
-    }
-    const visibleFields = unref(getSchema).filter((schema) => isFieldVisible(schema, unref(formModel))).map((schema) => schema.field).filter(Boolean);
-    const visibleFormData = {};
-    visibleFields.forEach((field) => {
-      if (field in allFormData) {
-        visibleFormData[field] = allFormData[field];
-      }
-    });
-    return visibleFormData;
+  function g(t = !1) {
+    if (!n(f)) return {};
+    const s = B(x(n(o)));
+    if (t)
+      return s;
+    const r = n(c).filter((l) => _(l, n(o))).map((l) => l.field).filter(Boolean), a = {};
+    return r.forEach((l) => {
+      l in s && (a[l] = s[l]);
+    }), a;
   }
-  function getFieldValue(field) {
-    const formEl = unref(formElRef);
-    if (!formEl) return {};
-    return toRaw(unref(formModel))[field];
+  function k(t) {
+    return n(f) ? x(n(o))[t] : {};
   }
-  function itemIsDateType(key) {
-    return unref(getSchema).some((item) => {
-      return item.field === key ? isDatePicker(item.type) : false;
-    });
+  function M(t) {
+    return n(c).some((e) => e.field === t ? ut(e.type) : !1);
   }
-  async function validateField(nameList) {
-    if (!nameList) {
-      const visibleFields = unref(getSchema).filter((schema) => isFieldVisible(schema, unref(formModel))).map((schema) => schema.field).filter(Boolean);
-      nameList = visibleFields;
-    }
-    return unref(formElRef)?.validateField(nameList);
+  async function $(t) {
+    return t || (t = n(c).filter((s) => _(s, n(o))).map((s) => s.field).filter(Boolean)), n(f)?.validateField(t);
   }
-  async function validate(nameList) {
-    if (!nameList) {
-      const visibleFields = unref(getSchema).filter((schema) => isFieldVisible(schema, unref(formModel))).map((schema) => schema.field).filter(Boolean);
-      nameList = visibleFields;
-    }
-    return await unref(formElRef)?.validate(nameList, () => {
+  async function P(t) {
+    return t || (t = n(c).filter((s) => _(s, n(o))).map((s) => s.field).filter(Boolean)), await n(f)?.validate(t, () => {
     });
   }
-  async function clearValidate(name) {
-    await unref(formElRef)?.clearValidate(name);
+  async function D(t) {
+    await n(f)?.clearValidate(t);
   }
-  async function setFormItemError(field, errMess) {
-    await clearValidate(field);
-    await updateSchema([{ field, itemProps: { error: errMess } }]);
+  async function tt(t, e) {
+    await D(t), await N([{ field: t, itemProps: { error: e } }]);
   }
-  async function scrollToField(name, options) {
-    await unref(formElRef)?.scrollToField(name, options);
+  async function et(t, e) {
+    await n(f)?.scrollToField(t, e);
   }
-  async function handleSubmit(e) {
-    const { autoCleanErrorMessage, watchDataIsChange } = unref(getProps);
-    e && e.preventDefault();
-    autoCleanErrorMessage && await clearValidate();
-    const { submitFunc, beforeSubmitFunc } = unref(getProps);
-    if (beforeSubmitFunc && isFunction(beforeSubmitFunc)) {
-      await beforeSubmitFunc();
-    }
-    if (submitFunc && isFunction(submitFunc)) {
-      await submitFunc();
+  async function U(t) {
+    const { autoCleanErrorMessage: e, watchDataIsChange: s } = n(y);
+    t && t.preventDefault(), e && await D();
+    const { submitFunc: r, beforeSubmitFunc: a } = n(y);
+    if (a && j(a) && await a(), r && j(r)) {
+      await r();
       return;
     }
-    const formEl = unref(formElRef);
-    if (!formEl) return;
-    try {
-      const values = await validate();
-      if (!values) {
-        return;
-      }
-      const res = getFieldsValue();
-      if (watchDataIsChange) {
-        const isChange = isEqual(initValues.value, res);
-        const changeData = findDifferentValuesForObj(initValues.value, res);
-        emit("submit", res, !isChange, changeData);
-      } else {
-        emit("submit", res);
+    if (n(f))
+      try {
+        if (!await P())
+          return;
+        const u = g();
+        if (s) {
+          const b = ct(T.value, u), C = rt(T.value, u);
+          h("submit", u, !b, C);
+        } else
+          h("submit", u);
+      } catch (i) {
+        if (i?.outOfDate === !1 && i?.errorFields)
+          return;
+        throw new Error(i.message);
       }
-    } catch (error) {
-      if (error?.outOfDate === false && error?.errorFields) {
-        return;
-      }
-      throw new Error(error.message);
-    }
   }
   return {
-    handleSubmit,
-    clearValidate,
-    validate,
-    validateField,
-    getFieldsValue,
-    updateSchema,
-    resetSchema,
-    appendSchemaByField,
-    removeSchemaByField,
-    resetFields,
-    setFieldsValue,
-    scrollToField,
-    getFieldValue,
-    setFormItemError
+    handleSubmit: U,
+    clearValidate: D,
+    validate: P,
+    validateField: $,
+    getFieldsValue: g,
+    updateSchema: N,
+    resetSchema: R,
+    appendSchemaByField: K,
+    removeSchemaByField: Z,
+    resetFields: Y,
+    setFieldsValue: q,
+    scrollToField: et,
+    getFieldValue: k,
+    setFormItemError: tt
   };
 }
 export {
-  useFormEvents
+  Et as useFormEvents
 };