@teamnovu/kit-vue-forms 0.1.13 → 0.1.15

package/dist/index.js

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