@teamnovu/kit-vue-forms 0.1.14 → 0.1.16

package/dist/index.js

@@ -1,65 +1,70 @@
-var G = Object.defineProperty;
-var L = (t, e, r) => e in t ? G(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
-var w = (t, e, r) => L(t, typeof e != "symbol" ? e + "" : e, r);
-import { toValue as Z, toRaw as q, computed as u, unref as d, isRef as j, shallowRef as _, reactive as D, watch as F, toRefs as W, shallowReactive as H, toRef as S, onScopeDispose as Q, watchEffect as X, triggerRef as Y, ref as k, getCurrentScope as x, onBeforeUnmount as ee, defineComponent as $, renderSlot as C, normalizeProps as B, guardReactiveProps as I, resolveComponent as re, createBlock as A, openBlock as M, withCtx as z, resolveDynamicComponent as te, mergeProps as se } from "vue";
-import { cloneDeep as ae } from "lodash-es";
+var H = Object.defineProperty;
+var Z = (t, e, r) => e in t ? H(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var S = (t, e, r) => Z(t, typeof e != "symbol" ? e + "" : e, r);
+import { toValue as q, toRaw as Q, computed as p, unref as d, isRef as U, shallowRef as B, reactive as $, watch as P, toRefs as J, shallowReactive as X, toRef as O, onScopeDispose as Y, watchEffect as ee, triggerRef as re, ref as L, getCurrentScope as te, onBeforeUnmount as ae, defineComponent as k, renderSlot as b, normalizeProps as M, guardReactiveProps as z, resolveComponent as se, createBlock as K, openBlock as T, withCtx as j, resolveDynamicComponent as ne, mergeProps as oe, createSlots as ie, renderList as le } from "vue";
+import { cloneDeep as ce } from "lodash-es";
 import "zod";
-function y(t) {
-  const e = Z(t), r = q(e);
-  return ae(r);
+function g(t) {
+  const e = q(t), r = Q(e);
+  return ce(r);
 }
-function K(t) {
+function W(t) {
   return t === "" ? [] : t.split(/\s*\.\s*/).filter(Boolean);
 }
-function P(t, e) {
-  return (Array.isArray(e) ? e : K(e)).reduce(
-    (s, i) => s == null ? void 0 : s[i],
+function ue(t, e) {
+  const r = Array.isArray(e) ? e : W(e);
+  return !!D(t, r.slice(0, -1));
+}
+function D(t, e) {
+  return (Array.isArray(e) ? e : W(e)).reduce(
+    (a, s) => a == null ? void 0 : a[s],
     t
   );
 }
-function ie(t, e, r) {
-  const s = Array.isArray(e) ? e : K(e), i = s.at(-1);
-  if (i) {
-    const n = s.slice(0, -1).reduce(
-      (h, v) => h == null ? void 0 : h[v],
+function de(t, e, r) {
+  const a = Array.isArray(e) ? e : W(e), s = a.at(-1);
+  if (s) {
+    const n = a.slice(0, -1).reduce(
+      (f, m) => ((f == null ? void 0 : f[m]) === void 0 && (f[m] = {}), f == null ? void 0 : f[m]),
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       d(t)
     );
-    n[i] = r;
+    n[s] = r;
   } else {
-    if (!j(t))
+    if (!U(t))
       return;
     t.value = r;
   }
 }
-const U = (t, e) => u({
+const x = (t, e) => p({
   get() {
-    return P(d(t), d(e));
+    return D(d(t), d(e));
   },
   set(r) {
-    ie(t, d(e), r);
+    de(t, d(e), r);
   }
 });
-function R(t, e) {
+function _(t, e) {
   return !t && !e ? "" : !t && e ? e : !e && t ? t : `${t}.${e}`;
 }
-function ne(t, e) {
+function fe(t, e) {
   if (!e)
     return t;
-  const r = `${e}.`, s = Object.fromEntries(
-    Object.entries(t.propertyErrors).filter(([i]) => i.startsWith(r)).map(
-      ([i, n]) => [i.slice(r.length), n]
-    )
+  const r = `${e}.`, a = Object.fromEntries(
+    Object.entries(t.propertyErrors).filter(([s]) => s.startsWith(r)).map(([s, n]) => [
+      s.slice(r.length),
+      n
+    ])
   );
   return {
     general: t.general,
     // Keep general errors
-    propertyErrors: s
+    propertyErrors: a
   };
 }
-class oe {
+class he {
   constructor(e) {
-    w(this, "rc", 1);
+    S(this, "rc", 1);
     this.drop = e;
   }
   inc() {
@@ -69,139 +74,173 @@ class oe {
     this.rc > 0 && (this.rc -= 1, this.rc === 0 && this.drop && this.drop());
   }
 }
-function le(t) {
-  const e = _(Object.freeze(y(t.initialValue))), r = D({
-    value: t.value,
-    path: t.path,
-    initialValue: e,
-    errors: t.errors,
+function pe(t) {
+  const r = {
+    ...{
+      existsInForm: !0
+    },
+    ...t
+  }, a = B(Object.freeze(g(r.initialValue))), s = $({
+    value: r.value,
+    path: r.path,
+    initialValue: a,
+    errors: r.errors,
     touched: !1
   });
-  F(
-    _(t.initialValue),
+  P(
+    B(r.initialValue),
     () => {
-      e.value = Object.freeze(y(t.initialValue)), r.value = y(t.initialValue);
+      a.value = Object.freeze(g(r.initialValue)), s.value = g(r.initialValue);
     },
     { flush: "sync" }
   );
-  const s = u(() => JSON.stringify(r.value) !== JSON.stringify(r.initialValue)), i = (f) => {
-    r.value = f;
-  }, n = () => {
-    r.touched = !0;
-  }, h = () => {
-  }, v = () => {
-    r.value = y(r.initialValue), r.touched = !1, r.errors = [];
-  }, V = (f) => {
-    s.value || i(y(f)), r.initialValue = f;
-  }, o = (f) => {
-    r.errors = f;
-  }, a = () => {
-    r.errors = [];
-  }, c = W(r);
+  const n = p(() => JSON.stringify(s.value) !== JSON.stringify(s.initialValue)), f = (h) => {
+    s.value = h;
+  }, m = () => {
+    var h;
+    s.touched = !0, s.errors = [], (h = r.onBlur) == null || h.call(r);
+  }, y = () => {
+    var h;
+    (h = r.onFocus) == null || h.call(r);
+  }, V = () => {
+    const h = s.path.split(".").at(-1) || "";
+    d(r.existsInForm) && !/^\d+$/.test(h) && (s.value = g(s.initialValue)), s.touched = !1, s.errors = [];
+  }, l = (h) => {
+    n.value || f(g(h)), s.initialValue = h;
+  }, c = (h) => {
+    s.errors = h;
+  }, i = () => {
+    s.errors = [];
+  }, o = J(s);
   return {
-    data: c.value,
-    path: c.path,
-    initialValue: c.initialValue,
-    errors: c.errors,
-    touched: c.touched,
-    dirty: s,
-    setData: i,
-    setInitialData: V,
-    onBlur: n,
-    onFocus: h,
-    reset: v,
-    setErrors: o,
-    clearErrors: a
+    data: o.value,
+    path: o.path,
+    initialValue: o.initialValue,
+    errors: o.errors,
+    touched: o.touched,
+    dirty: n,
+    setData: f,
+    setInitialData: l,
+    onBlur: m,
+    onFocus: y,
+    reset: V,
+    setErrors: c,
+    clearErrors: i
   };
 }
-function ce(t) {
-  const e = _(t());
-  return X(
+const ve = {
+  keepValuesOnUnmount: !0
+};
+function me(t) {
+  const e = B(t());
+  return ee(
     () => {
-      e.value = t(), Y(e);
+      e.value = t(), re(e);
     },
     { flush: "sync" }
   ), e;
 }
-function ue(t, e) {
-  const r = /* @__PURE__ */ new Map(), s = H(/* @__PURE__ */ new Map()), i = (a) => {
-    const c = d(a.path);
-    s.set(c, a);
-  }, n = (a) => {
-    s.delete(a);
-  }, h = (a) => {
-    var c;
-    r.has(a) ? (c = r.get(a)) == null || c.inc() : r.set(a, new oe(() => n(a)));
-  }, v = (a) => {
-    var c;
-    r.has(a) && ((c = r.get(a)) == null || c.dec());
-  }, V = (a) => {
-    if (!s.has(a)) {
-      const f = le({
-        path: a,
-        value: U(S(t, "data"), a),
-        initialValue: ce(
-          () => P(t.initialData, a)
-        ),
-        errors: u({
+function Ve(t, e, r) {
+  const a = /* @__PURE__ */ new Map(), s = X(/* @__PURE__ */ new Map()), n = {
+    ...ve,
+    ...r
+  }, f = (i) => {
+    const o = d(i.path);
+    s.set(o, i);
+  }, m = (i) => {
+    var o;
+    n != null && n.keepValuesOnUnmount || (o = s.get(i)) == null || o.reset(), s.delete(i);
+  }, y = (i) => {
+    var o;
+    a.has(i) ? (o = a.get(i)) == null || o.inc() : a.set(i, new he(() => m(i)));
+  }, V = (i) => {
+    var o;
+    a.has(i) && ((o = a.get(i)) == null || o.dec());
+  }, l = (i) => {
+    const { path: o } = i;
+    if (!s.has(o)) {
+      const N = pe({
+        path: o,
+        value: x(O(t, "data"), o),
+        initialValue: me(() => D(t.initialData, o)),
+        existsInForm: p(() => ue(t.data, d(o))),
+        errors: p({
           get() {
-            return e.errors.value.propertyErrors[a] || [];
+            return e.errors.value.propertyErrors[o] || [];
           },
           set(E) {
-            e.errors.value.propertyErrors[a] = E;
+            e.errors.value.propertyErrors[o] = E;
           }
-        })
+        }),
+        onBlur: async () => {
+          var E, R;
+          await Promise.all(
+            [
+              (E = n == null ? void 0 : n.onBlur) == null ? void 0 : E.call(n, d(o)),
+              (R = i.onBlur) == null ? void 0 : R.call(i)
+            ]
+          );
+        },
+        onFocus: async () => {
+          var E, R;
+          await Promise.all(
+            [
+              (E = n == null ? void 0 : n.onFocus) == null ? void 0 : E.call(n, d(o)),
+              (R = i.onFocus) == null ? void 0 : R.call(i)
+            ]
+          );
+        }
       });
-      i(f);
+      f(N);
     }
-    const c = s.get(a);
-    return h(a), Q(() => {
-      v(a);
-    }), c;
-  }, o = (a) => V(a.path);
+    const h = s.get(o);
+    return y(o), Y(() => {
+      V(o);
+    }), h;
+  }, c = (i) => l(i);
   return {
-    fields: u(() => [...s.values()]),
-    getField: V,
-    registerField: i,
-    deregisterField: n,
-    defineField: o
+    fields: p(() => [...s.values()]),
+    getField: (i) => l({ path: i }),
+    registerField: f,
+    deregisterField: m,
+    defineField: c
   };
 }
-function de(t) {
-  const e = u(() => t.fields.value.some((s) => d(s.dirty))), r = u(() => t.fields.value.some((s) => d(s.touched)));
+function ye(t) {
+  const e = p(() => t.fields.value.some((a) => d(a.dirty))), r = p(() => t.fields.value.some((a) => d(a.touched)));
   return {
     isDirty: e,
     isTouched: r
   };
 }
-function fe(t) {
+function Fe(t) {
   return t.filter(
-    (e, r, s) => s.indexOf(e) === r
+    (e, r, a) => a.indexOf(e) === r
   );
 }
-function J(...t) {
+function G(...t) {
   return t.slice(1).reduce((e, r) => {
     if (!e && !r)
       return;
-    const s = ((r == null ? void 0 : r.length) ?? 0) > 0;
+    const a = ((r == null ? void 0 : r.length) ?? 0) > 0;
     if (!e && ((r == null ? void 0 : r.length) ?? 0) > 0)
       return r;
-    if (!s)
+    if (!a)
       return e;
-    const i = (e ?? []).concat(r);
-    return fe(i);
+    const s = (e ?? []).concat(r);
+    return Fe(s);
   }, t[0]);
 }
-function he(...t) {
-  return t.map((r) => Object.keys(r)).flat().reduce((r, s) => {
-    const i = t.map((n) => n[s]).filter(Boolean);
+function ge(...t) {
+  return t.map((r) => Object.keys(r)).flat().reduce((r, a) => {
+    const s = t.map((n) => n[a]).filter(Boolean);
     return {
       ...r,
-      [s]: J(...i)
+      [a]: G(...s)
     };
   }, {});
 }
-function b(...t) {
+function C(...t) {
   if (!t.length)
     return {
       general: [],
@@ -209,24 +248,24 @@ function b(...t) {
     };
   const e = t[0];
   return t.length === 1 ? e : t.slice(1).reduce(
-    (r, s) => ({
-      general: J(r.general, s.general),
-      propertyErrors: he(r.propertyErrors ?? {}, s.propertyErrors ?? {})
+    (r, a) => ({
+      general: G(r.general, a.general),
+      propertyErrors: ge(r.propertyErrors ?? {}, a.propertyErrors ?? {})
     }),
     e
   );
 }
-function N(t) {
-  var s;
-  const e = (((s = t.general) == null ? void 0 : s.length) ?? 0) > 0, r = Object.entries(t.propertyErrors).filter(([, i]) => i == null ? void 0 : i.length).length > 0;
+function A(t) {
+  var a;
+  const e = (((a = t.general) == null ? void 0 : a.length) ?? 0) > 0, r = Object.entries(t.propertyErrors).filter(([, s]) => s == null ? void 0 : s.length).length > 0;
   return e || r;
 }
-function pe(t) {
-  const e = t.issues.filter((s) => s.path.length === 0).map((s) => s.message), r = t.issues.filter((s) => s.path.length > 0).reduce((s, i) => {
-    const n = i.path.join(".");
+function Ee(t) {
+  const e = t.issues.filter((a) => a.path.length === 0).map((a) => a.message), r = t.issues.filter((a) => a.path.length > 0).reduce((a, s) => {
+    const n = s.path.join(".");
     return {
-      ...s,
-      [n]: [...s[n] ?? [], i.message]
+      ...a,
+      [n]: [...a[n] ?? [], s.message]
     };
   }, {});
   return {
@@ -234,43 +273,43 @@ function pe(t) {
     propertyErrors: r
   };
 }
-const m = {
+const F = {
   isValid: !0,
   errors: {
     general: [],
     propertyErrors: {}
   }
 };
-class ve {
+class we {
   constructor(e) {
     this.schema = e;
   }
   async validate(e) {
     if (!this.schema)
-      return m;
+      return F;
     const r = await this.schema.safeParseAsync(e);
     if (r.success)
-      return m;
-    const s = pe(r.error);
+      return F;
+    const a = Ee(r.error);
     return {
       isValid: !1,
       errors: {
-        general: s.general ?? [],
-        propertyErrors: s.propertyErrors ?? {}
+        general: a.general ?? [],
+        propertyErrors: a.propertyErrors ?? {}
       }
     };
   }
 }
-class me {
+class Re {
   constructor(e) {
     this.validateFn = e;
   }
   async validate(e) {
     if (!this.validateFn)
-      return m;
+      return F;
     try {
       const r = await this.validateFn(e);
-      return r.isValid ? m : r;
+      return r.isValid ? F : r;
     } catch (r) {
       return {
         isValid: !1,
@@ -282,112 +321,124 @@ class me {
     }
   }
 }
-class Ve {
+class Pe {
   constructor(e, r) {
-    w(this, "schemaValidator");
-    w(this, "functionValidator");
-    this.schema = e, this.validateFn = r, this.schemaValidator = new ve(this.schema), this.functionValidator = new me(this.validateFn);
+    S(this, "schemaValidator");
+    S(this, "functionValidator");
+    this.schema = e, this.validateFn = r, this.schemaValidator = new we(this.schema), this.functionValidator = new Re(this.validateFn);
   }
   async validate(e) {
-    const [r, s] = await Promise.all([
+    const [r, a] = await Promise.all([
       this.schemaValidator.validate(e),
       this.functionValidator.validate(e)
     ]);
     return {
-      isValid: r.isValid && s.isValid,
-      errors: b(r.errors, s.errors)
+      isValid: r.isValid && a.isValid,
+      errors: C(r.errors, a.errors)
     };
   }
 }
-function O(t) {
-  return u(() => new Ve(
+function I(t) {
+  return p(() => new Pe(
     d(t.schema),
     d(t.validateFn)
   ));
 }
-function ye(t, e) {
-  const r = D({
-    validators: k([O(e)]),
+function De(t, e) {
+  const r = $({
+    validators: L([I(e)]),
     isValidated: !1,
-    errors: d(e.errors) ?? m.errors
-  }), s = (o = m.errors) => {
-    r.errors = b(d(e.errors) ?? m.errors, o);
+    errors: d(e.errors) ?? F.errors
+  }), a = (l = F.errors) => {
+    r.errors = C(d(e.errors) ?? F.errors, l);
   };
-  F(() => d(e.errors), async () => {
+  P(() => d(e.errors), async () => {
     if (r.isValidated) {
-      const o = await n();
-      s(o.errors);
+      const l = await n();
+      a(l.errors);
     } else
-      s();
-  }, { immediate: !0 }), F(
+      a();
+  }, { immediate: !0 }), P(
     [() => r.validators],
-    async (o) => {
+    async (l) => {
       if (r.isValidated)
-        if (o) {
-          const a = await n();
-          r.errors = a.errors;
+        if (l) {
+          const c = await n();
+          r.errors = c.errors;
         } else
-          r.errors = m.errors;
+          r.errors = F.errors;
     },
     { immediate: !0 }
-  ), F([() => t.data, () => d(e.schema)], () => {
-    r.isValidated && h();
+  ), P([() => t.data, () => d(e.schema)], () => {
+    r.isValidated && f();
   });
-  const i = (o) => {
-    const a = j(o) ? o : O(o);
-    return r.validators.push(a), x() && ee(() => {
+  const s = (l) => {
+    const c = U(l) ? l : I(l);
+    return r.validators.push(c), te() && ae(() => {
       r.validators = r.validators.filter(
-        (c) => c !== a
+        (i) => i !== c
       );
-    }), a;
+    }), c;
   };
   async function n() {
-    const o = await Promise.all(
-      r.validators.filter((f) => d(f) !== void 0).map((f) => d(f).validate(t.data))
-    ), a = o.every((f) => f.isValid);
-    let { errors: c } = m;
-    if (!a) {
-      const f = o.map((E) => E.errors);
-      c = b(...f);
+    const l = await Promise.all(
+      r.validators.filter((o) => d(o) !== void 0).map((o) => d(o).validate(t.data))
+    ), c = l.every((o) => o.isValid);
+    let { errors: i } = F;
+    if (!c) {
+      const o = l.map((h) => h.errors);
+      i = C(...o);
     }
     return {
-      errors: c,
-      isValid: a
+      errors: i,
+      isValid: c
     };
   }
-  const h = async () => {
-    const o = await n();
-    return s(o.errors), r.isValidated = !0, {
-      isValid: !N(o.errors),
+  const f = async () => {
+    const l = await n();
+    return a(l.errors), r.isValidated = !0, {
+      isValid: !A(l.errors),
       errors: r.errors
     };
-  }, v = u(() => !N(r.errors)), V = () => {
-    r.isValidated = !1, r.errors = d(e.errors) ?? m.errors;
+  }, m = async (l) => {
+    const c = await n();
+    return a({
+      general: c.errors.general,
+      propertyErrors: {
+        [l]: c.errors.propertyErrors[l]
+      }
+    }), {
+      isValid: !A(c.errors),
+      errors: r.errors
+    };
+  }, y = p(() => !A(r.errors)), V = () => {
+    r.isValidated = !1, r.errors = d(e.errors) ?? F.errors;
   };
   return {
-    ...W(r),
-    validateForm: h,
-    defineValidator: i,
-    isValid: v,
+    ...J(r),
+    validateForm: f,
+    validateField: m,
+    defineValidator: s,
+    isValid: y,
     reset: V
   };
 }
-class ge {
+class Se {
   constructor(e, r) {
     this.path = e, this.validator = r;
   }
   async validate(e) {
-    const r = P(e, this.path);
+    const r = D(e, this.path);
     if (!this.validator)
-      return m;
-    const s = await this.validator.validate(r);
+      return F;
+    const a = await this.validator.validate(r);
     return {
-      isValid: s.isValid,
+      isValid: a.isValid,
       errors: {
-        general: s.errors.general || [],
-        propertyErrors: s.errors.propertyErrors ? Object.fromEntries(
-          Object.entries(s.errors.propertyErrors).map(([i, n]) => [
-            R(this.path, i),
+        general: a.errors.general || [],
+        propertyErrors: a.errors.propertyErrors ? Object.fromEntries(
+          Object.entries(a.errors.propertyErrors).map(([s, n]) => [
+            _(this.path, s),
             n
           ])
         ) : {}
@@ -395,100 +446,117 @@ class ge {
     };
   }
 }
-function Ee(t, e, r) {
-  const s = U(t.data, e), i = u(() => P(t.initialData.value, e)), n = (l) => ({
-    ...l,
-    path: u(() => d(l.path).replace(e + ".", "")),
-    setData: (p) => {
-      l.setData(p);
+function _e(t, e, r) {
+  const a = x(t.data, e), s = p(() => D(t.initialData.value, e)), n = (u) => ({
+    ...u,
+    path: p(() => d(u.path).replace(e + ".", "")),
+    setData: (v) => {
+      u.setData(v);
     }
-  }), h = (l) => {
-    const p = R(e, l), g = t.getField(p);
-    return g ? n(g) : {};
-  }, v = (l) => {
-    const p = R(e, l.path), g = t.defineField({
-      ...l,
-      path: p
+  }), f = (u) => {
+    const v = _(e, u), w = t.getField(v);
+    return w ? n(w) : {};
+  }, m = (u) => {
+    const v = _(e, u.path), w = t.defineField({
+      ...u,
+      path: v
     });
-    return n(g);
-  }, V = u(() => t.fields.value.filter((l) => {
-    const p = l.path.value;
-    return p.startsWith(e + ".") || p === e;
-  }).map((l) => n(l))), o = () => t.fields.value.filter((l) => {
-    const p = l.path.value;
-    return p.startsWith(e + ".") || p === e;
-  }), a = u(() => o().some((l) => l.dirty.value)), c = u(() => o().some((l) => l.touched.value)), f = u(() => t.isValid.value), E = u(() => t.isValidated.value), T = u(() => ne(d(t.errors), e));
+    return n(w);
+  }, y = p(() => t.fields.value.filter((u) => {
+    const v = u.path.value;
+    return v.startsWith(e + ".") || v === e;
+  }).map((u) => n(u))), V = () => t.fields.value.filter((u) => {
+    const v = u.path.value;
+    return v.startsWith(e + ".") || v === e;
+  }), l = p(() => V().some((u) => u.dirty.value)), c = p(() => V().some((u) => u.touched.value)), i = p(() => t.isValid.value), o = p(() => t.isValidated.value), h = p(() => fe(d(t.errors), e));
   return {
-    data: s,
-    fields: V,
-    initialData: i,
-    defineField: v,
-    getField: h,
-    isDirty: a,
+    data: a,
+    fields: y,
+    initialData: s,
+    defineField: m,
+    getField: f,
+    isDirty: l,
     isTouched: c,
-    isValid: f,
-    isValidated: E,
-    errors: T,
-    defineValidator: (l) => {
-      const p = j(l) ? l : O(l), g = u(
-        () => new ge(e, d(p))
+    isValid: i,
+    isValidated: o,
+    errors: h,
+    defineValidator: (u) => {
+      const v = U(u) ? u : I(u), w = p(
+        () => new Se(e, d(v))
       );
-      return t.defineValidator(g), p;
+      return t.defineValidator(w), v;
     },
-    reset: () => o().forEach((l) => l.reset()),
+    reset: () => V().forEach((u) => u.reset()),
     validateForm: () => t.validateForm(),
-    getSubForm: (l, p) => {
-      const g = R(e, l);
+    getSubForm: (u, v) => {
+      const w = _(e, u);
       return t.getSubForm(
-        g,
-        p
+        w,
+        v
       );
     }
   };
 }
 function Oe(t) {
-  const e = u(() => Object.freeze(y(t.initialData))), r = k(y(e)), s = D({
+  const e = p(
+    () => Object.freeze(g(t.initialData))
+  ), r = L(g(e)), a = $({
     initialData: e,
     data: r
   });
-  F(e, (a) => {
-    s.data = y(a);
-  }, { flush: "sync" });
-  const i = ye(s, t), n = ue(s, i), h = de(n), v = () => {
-    r.value = y(e), i.reset(), n.fields.value.forEach(
-      (a) => a.reset()
-    );
+  P(
+    e,
+    (c) => {
+      a.data = g(c);
+    },
+    { flush: "sync" }
+  );
+  const s = De(a, t), n = Ve(a, s, {
+    keepValuesOnUnmount: t.keepValuesOnUnmount,
+    onBlur: async (c) => {
+      d(t.validationStrategy) === "onTouch" && s.validateField(c);
+    }
+  }), f = ye(n), m = (c) => async (i) => {
+    i.preventDefault(), d(t.validationStrategy) !== "none" && await s.validateForm(), s.isValid.value && await c(a.data);
+  }, y = () => {
+    r.value = g(e), s.reset();
+    for (const c of n.fields.value)
+      c.reset();
   };
-  function V(a, c) {
-    return Ee(o, a);
+  function V(c, i) {
+    return _e(l, c);
   }
-  const o = {
+  const l = {
     ...n,
-    ...i,
-    ...h,
-    reset: v,
+    ...s,
+    ...f,
+    reset: y,
     getSubForm: V,
-    initialData: S(s, "initialData"),
-    data: S(s, "data")
+    submitHandler: m,
+    initialData: O(a, "initialData"),
+    data: O(a, "data")
   };
-  return o;
+  return d(t.validationStrategy) === "onFormOpen" && s.validateForm(), l;
 }
-const je = /* @__PURE__ */ $({
+const Ce = /* @__PURE__ */ k({
   __name: "Field",
   props: {
     form: {},
     value: {},
     initialValue: {},
     path: {},
-    errors: {}
+    errors: {},
+    existsInForm: {},
+    onBlur: { type: Function },
+    onFocus: { type: Function }
   },
   setup(t) {
     const e = t, r = e.form.defineField({
       path: e.path
-    }), s = D(r);
-    return (i, n) => C(i.$slots, "default", B(I(s)));
+    }), a = $(r);
+    return (s, n) => b(s.$slots, "default", M(z(a)));
   }
-}), $e = /* @__PURE__ */ $({
+}), Ie = /* @__PURE__ */ k({
   inheritAttrs: !1,
   __name: "FormFieldWrapper",
   props: {
@@ -499,42 +567,49 @@ const je = /* @__PURE__ */ $({
   },
   setup(t) {
     return (e, r) => {
-      const s = re("Field");
-      return M(), A(s, {
+      const a = se("Field");
+      return T(), K(a, {
         form: e.form,
         path: e.path
       }, {
-        default: z(({ errors: i, data: n, setData: h }) => [
-          (M(), A(te(e.component), se({ ...e.componentProps, ...e.$attrs }, {
+        default: j(({ errors: s, data: n, setData: f }) => [
+          (T(), K(ne(e.component), oe({ ...e.componentProps, ...e.$attrs }, {
             "model-value": n,
-            errors: i,
+            errors: s,
             name: e.path,
-            "onUpdate:modelValue": h
-          }), {
-            default: z(() => [
-              C(e.$slots, "default")
+            "onUpdate:modelValue": f
+          }), ie({
+            default: j(() => [
+              b(e.$slots, "default")
             ]),
             _: 2
-          }, 1040, ["model-value", "errors", "name", "onUpdate:modelValue"]))
+          }, [
+            le(e.$slots, (m, y) => ({
+              name: y,
+              fn: j((V) => [
+                b(e.$slots, y, M(z(V ?? {})))
+              ])
+            }))
+          ]), 1040, ["model-value", "errors", "name", "onUpdate:modelValue"]))
         ]),
         _: 3
       }, 8, ["form", "path"]);
     };
   }
-}), Ce = /* @__PURE__ */ $({
+}), Ue = /* @__PURE__ */ k({
   __name: "FormPart",
   props: {
     form: {},
     path: {}
   },
   setup(t) {
-    const e = t, r = u(() => e.form.getSubForm(e.path));
-    return (s, i) => C(s.$slots, "default", B(I({ subform: r.value })));
+    const e = t, r = p(() => e.form.getSubForm(e.path));
+    return (a, s) => b(a.$slots, "default", M(z({ subform: r.value })));
   }
 });
 export {
-  je as Field,
-  $e as FormFieldWrapper,
-  Ce as FormPart,
+  Ce as Field,
+  Ie as FormFieldWrapper,
+  Ue as FormPart,
   Oe as useForm
 };