@teamnovu/kit-vue-forms 0.1.4 → 0.1.6

package/dist/composables/useValidation.d.ts

@@ -18,6 +18,7 @@ export declare function useValidation<T extends FormDataDefault>(formState: {
     validateForm: () => Promise<ValidationResult>;
     defineValidator: <TData extends T>(options: ValidatorOptions<TData> | Ref<Validator<TData>>) => Ref<Validator<TData> | undefined, Validator<TData> | undefined>;
     isValid: ComputedRef<boolean>;
+    reset: () => void;
     validators: Ref<Ref<Validator<T> | undefined, Validator<T> | undefined>[], Ref<Validator<T> | undefined, Validator<T> | undefined>[]>;
     isValidated: Ref<boolean, boolean>;
     errors: Ref<{

package/dist/index.js

@@ -1,61 +1,61 @@
 var T = Object.defineProperty;
-var G = (r, e, t) => e in r ? T(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
-var E = (r, e, t) => G(r, typeof e != "symbol" ? e + "" : e, t);
-import { toValue as L, toRaw as Z, computed as d, unref as f, reactive as R, toRefs as N, shallowReactive as q, toRef as _, onScopeDispose as H, ref as W, watch as F, isRef as k, getCurrentScope as Q, onBeforeUnmount as X, defineComponent as j, renderSlot as O, normalizeProps as z, guardReactiveProps as B, resolveComponent as Y, createBlock as $, openBlock as A, withCtx as C, resolveDynamicComponent as x, mergeProps as ee } from "vue";
+var G = (t, e, r) => e in t ? T(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var F = (t, e, r) => G(t, typeof e != "symbol" ? e + "" : e, r);
+import { toValue as L, toRaw as Z, computed as c, unref as d, reactive as D, toRefs as N, shallowReactive as q, toRef as _, onScopeDispose as H, ref as W, watch as w, isRef as k, getCurrentScope as Q, onBeforeUnmount as X, defineComponent as j, renderSlot as O, normalizeProps as z, guardReactiveProps as B, resolveComponent as Y, createBlock as $, openBlock as A, withCtx as C, resolveDynamicComponent as x, mergeProps as ee } from "vue";
 import { cloneDeep as re } from "lodash-es";
 import "zod";
-function y(r) {
-  const e = L(r), t = Z(e);
-  return re(t);
+function g(t) {
+  const e = L(t), r = Z(e);
+  return re(r);
 }
-function K(r) {
-  return r === "" ? [] : r.split(/\s*\.\s*/).filter(Boolean);
+function K(t) {
+  return t === "" ? [] : t.split(/\s*\.\s*/).filter(Boolean);
 }
-function D(r, e) {
+function P(t, e) {
   return (Array.isArray(e) ? e : K(e)).reduce(
     (s, o) => s == null ? void 0 : s[o],
-    r
+    t
   );
 }
-function te(r, e, t) {
+function te(t, e, r) {
   const s = Array.isArray(e) ? e : K(e);
   if (s.length === 0)
     throw new Error("Path cannot be empty");
   const o = s.at(-1), n = s.slice(0, -1).reduce(
-    (h, v) => h[v],
+    (p, h) => p[h],
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    r
+    t
   );
-  n[o] = t;
+  n[o] = r;
 }
-const U = (r, e) => d({
+const U = (t, e) => c({
   get() {
-    return D(f(r), f(e));
+    return P(d(t), d(e));
   },
-  set(t) {
-    te(f(r), f(e), t);
+  set(r) {
+    te(d(t), d(e), r);
   }
 });
-function w(r, e) {
-  return !r && !e ? "" : !r && e ? e : !e && r ? r : `${r}.${e}`;
+function R(t, e) {
+  return !t && !e ? "" : !t && e ? e : !e && t ? t : `${t}.${e}`;
 }
-function se(r, e) {
+function se(t, e) {
   if (!e)
-    return r;
-  const t = `${e}.`, s = Object.fromEntries(
-    Object.entries(r.propertyErrors).filter(([o]) => o.startsWith(t)).map(
-      ([o, n]) => [o.slice(t.length), n]
+    return t;
+  const r = `${e}.`, s = Object.fromEntries(
+    Object.entries(t.propertyErrors).filter(([o]) => o.startsWith(r)).map(
+      ([o, n]) => [o.slice(r.length), n]
     )
   );
   return {
-    general: r.general,
+    general: t.general,
     // Keep general errors
     propertyErrors: s
   };
 }
 class ae {
   constructor(e) {
-    E(this, "rc", 1);
+    F(this, "rc", 1);
     this.drop = e;
   }
   inc() {
@@ -65,138 +65,138 @@ class ae {
     this.rc > 0 && (this.rc -= 1, this.rc === 0 && this.drop && this.drop());
   }
 }
-function oe(r) {
-  const e = R({
-    value: r.value,
-    path: r.path,
-    initialValue: d(() => Object.freeze(y(r.initialValue))),
-    errors: r.errors,
+function oe(t) {
+  const e = D({
+    value: t.value,
+    path: t.path,
+    initialValue: c(() => Object.freeze(g(t.initialValue))),
+    errors: t.errors,
     touched: !1
-  }), t = d(() => JSON.stringify(e.value) !== JSON.stringify(e.initialValue)), s = (a) => {
+  }), r = c(() => JSON.stringify(e.value) !== JSON.stringify(e.initialValue)), s = (a) => {
     e.value = a;
   }, o = () => {
     e.touched = !0;
   }, n = () => {
-  }, h = () => {
-    e.value = y(e.initialValue), e.touched = !1, e.errors = [];
-  }, v = (a) => {
+  }, p = () => {
+    e.value = g(e.initialValue), e.touched = !1, e.errors = [];
+  }, h = (a) => {
     e.errors = a;
-  }, l = () => {
+  }, V = () => {
     e.errors = [];
-  }, c = N(e);
+  }, i = N(e);
   return {
-    data: c.value,
-    path: c.path,
-    initialValue: c.initialValue,
-    errors: c.errors,
-    touched: c.touched,
-    dirty: t,
+    data: i.value,
+    path: i.path,
+    initialValue: i.initialValue,
+    errors: i.errors,
+    touched: i.touched,
+    dirty: r,
     setData: s,
     onBlur: o,
     onFocus: n,
-    reset: h,
-    setErrors: v,
-    clearErrors: l
+    reset: p,
+    setErrors: h,
+    clearErrors: V
   };
 }
-function ne(r, e) {
-  const t = /* @__PURE__ */ new Map(), s = q(/* @__PURE__ */ new Map()), o = (a) => {
-    const u = f(a.path);
+function ne(t, e) {
+  const r = /* @__PURE__ */ new Map(), s = q(/* @__PURE__ */ new Map()), o = (a) => {
+    const u = d(a.path);
     s.set(u, a);
   }, n = (a) => {
     s.delete(a);
-  }, h = (a) => {
+  }, p = (a) => {
     var u;
-    t.has(a) ? (u = t.get(a)) == null || u.inc() : t.set(a, new ae(() => n(a)));
-  }, v = (a) => {
+    r.has(a) ? (u = r.get(a)) == null || u.inc() : r.set(a, new ae(() => n(a)));
+  }, h = (a) => {
     var u;
-    t.has(a) && ((u = t.get(a)) == null || u.dec());
-  }, l = (a) => {
+    r.has(a) && ((u = r.get(a)) == null || u.dec());
+  }, V = (a) => {
     if (!s.has(a)) {
-      const g = oe({
+      const v = oe({
         path: a,
-        value: U(_(r, "data"), a),
-        initialValue: d(() => D(r.initialData, a)),
-        errors: d({
+        value: U(_(t, "data"), a),
+        initialValue: c(() => P(t.initialData, a)),
+        errors: c({
           get() {
             return e.errors.value.propertyErrors[a] || [];
           },
-          set(P) {
-            e.errors.value.propertyErrors[a] = P;
+          set(E) {
+            e.errors.value.propertyErrors[a] = E;
           }
         })
       });
-      o(g);
+      o(v);
     }
     const u = s.get(a);
-    return h(a), H(() => {
-      v(a);
+    return p(a), H(() => {
+      h(a);
     }), u;
-  }, c = (a) => l(a.path);
+  }, i = (a) => V(a.path);
   return {
-    fields: d(() => [...s.values()]),
-    getField: l,
+    fields: c(() => [...s.values()]),
+    getField: V,
     registerField: o,
     deregisterField: n,
-    defineField: c
+    defineField: i
   };
 }
-function ie(r) {
-  const e = d(() => r.fields.value.some((s) => f(s.dirty))), t = d(() => r.fields.value.some((s) => f(s.touched)));
+function ie(t) {
+  const e = c(() => t.fields.value.some((s) => d(s.dirty))), r = c(() => t.fields.value.some((s) => d(s.touched)));
   return {
     isDirty: e,
-    isTouched: t
+    isTouched: r
   };
 }
-function le(r) {
-  return r.filter(
-    (e, t, s) => s.indexOf(e) === t
+function le(t) {
+  return t.filter(
+    (e, r, s) => s.indexOf(e) === r
   );
 }
-function I(...r) {
-  return r.slice(1).reduce((e, t) => {
-    if (!e && !t)
+function I(...t) {
+  return t.slice(1).reduce((e, r) => {
+    if (!e && !r)
       return;
-    const s = ((t == null ? void 0 : t.length) ?? 0) > 0;
-    if (!e && ((t == null ? void 0 : t.length) ?? 0) > 0)
-      return t;
+    const s = ((r == null ? void 0 : r.length) ?? 0) > 0;
+    if (!e && ((r == null ? void 0 : r.length) ?? 0) > 0)
+      return r;
     if (!s)
       return e;
-    const o = (e ?? []).concat(t);
+    const o = (e ?? []).concat(r);
     return le(o);
-  }, r[0]);
+  }, t[0]);
 }
-function ce(...r) {
-  return r.map((t) => Object.keys(t)).flat().reduce((t, s) => {
-    const o = r.map((n) => n[s]).filter(Boolean);
+function ce(...t) {
+  return t.map((r) => Object.keys(r)).flat().reduce((r, s) => {
+    const o = t.map((n) => n[s]).filter(Boolean);
     return {
-      ...t,
+      ...r,
       [s]: I(...o)
     };
   }, {});
 }
-function S(...r) {
-  if (!r.length)
+function S(...t) {
+  if (!t.length)
     return {
       general: [],
       propertyErrors: {}
     };
-  const e = r[0];
-  return r.length === 1 ? e : r.slice(1).reduce(
-    (t, s) => ({
-      general: I(t.general, s.general),
-      propertyErrors: ce(t.propertyErrors ?? {}, s.propertyErrors ?? {})
+  const e = t[0];
+  return t.length === 1 ? e : t.slice(1).reduce(
+    (r, s) => ({
+      general: I(r.general, s.general),
+      propertyErrors: ce(r.propertyErrors ?? {}, s.propertyErrors ?? {})
     }),
     e
   );
 }
-function M(r) {
+function M(t) {
   var s;
-  const e = (((s = r.general) == null ? void 0 : s.length) ?? 0) > 0, t = Object.entries(r.propertyErrors).filter(([, o]) => o == null ? void 0 : o.length).length > 0;
-  return e || t;
+  const e = (((s = t.general) == null ? void 0 : s.length) ?? 0) > 0, r = Object.entries(t.propertyErrors).filter(([, o]) => o == null ? void 0 : o.length).length > 0;
+  return e || r;
 }
-function ue(r) {
-  const e = r.issues.filter((s) => s.path.length === 0).map((s) => s.message), t = r.issues.filter((s) => s.path.length > 0).reduce((s, o) => {
+function ue(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, o) => {
     const n = o.path.join(".");
     return {
       ...s,
@@ -205,7 +205,7 @@ function ue(r) {
   }, {});
   return {
     general: e,
-    propertyErrors: t
+    propertyErrors: r
   };
 }
 const m = {
@@ -222,10 +222,10 @@ class de {
   async validate(e) {
     if (!this.schema)
       return m;
-    const t = await this.schema.safeParseAsync(e);
-    if (t.success)
+    const r = await this.schema.safeParseAsync(e);
+    if (r.success)
       return m;
-    const s = ue(t.error);
+    const s = ue(r.error);
     return {
       isValid: !1,
       errors: {
@@ -243,13 +243,13 @@ class fe {
     if (!this.validateFn)
       return m;
     try {
-      const t = await this.validateFn(e);
-      return t.isValid ? m : t;
-    } catch (t) {
+      const r = await this.validateFn(e);
+      return r.isValid ? m : r;
+    } catch (r) {
       return {
         isValid: !1,
         errors: {
-          general: [t.message || "Validation error"],
+          general: [r.message || "Validation error"],
           propertyErrors: {}
         }
       };
@@ -257,108 +257,111 @@ class fe {
   }
 }
 class pe {
-  constructor(e, t) {
-    E(this, "schemaValidator");
-    E(this, "functionValidator");
-    this.schema = e, this.validateFn = t, this.schemaValidator = new de(this.schema), this.functionValidator = new fe(this.validateFn);
+  constructor(e, r) {
+    F(this, "schemaValidator");
+    F(this, "functionValidator");
+    this.schema = e, this.validateFn = r, this.schemaValidator = new de(this.schema), this.functionValidator = new fe(this.validateFn);
   }
   async validate(e) {
-    const [t, s] = await Promise.all([
+    const [r, s] = await Promise.all([
       this.schemaValidator.validate(e),
       this.functionValidator.validate(e)
     ]);
     return {
-      isValid: t.isValid && s.isValid,
-      errors: S(t.errors, s.errors)
+      isValid: r.isValid && s.isValid,
+      errors: S(r.errors, s.errors)
     };
   }
 }
-function b(r) {
-  return d(() => new pe(
-    f(r.schema),
-    f(r.validateFn)
+function b(t) {
+  return c(() => new pe(
+    d(t.schema),
+    d(t.validateFn)
   ));
 }
-function he(r, e) {
-  const t = R({
+function he(t, e) {
+  const r = D({
     validators: W([b(e)]),
     isValidated: !1,
-    errors: f(e.errors) ?? m.errors
-  });
-  F(() => f(e.errors), async () => {
-    if (t.isValidated) {
-      const l = await o();
-      n(l.errors);
+    errors: d(e.errors) ?? m.errors
+  }), s = (i = m.errors) => {
+    r.errors = S(d(e.errors) ?? m.errors, i);
+  };
+  w(() => d(e.errors), async () => {
+    if (r.isValidated) {
+      const i = await n();
+      s(i.errors);
     } else
-      n();
-  }, { immediate: !0 }), F(
-    [() => t.validators],
-    async (l) => {
-      if (t.isValidated)
-        if (l) {
-          const c = await o();
-          t.errors = c.errors;
+      s();
+  }, { immediate: !0 }), w(
+    [() => r.validators],
+    async (i) => {
+      if (r.isValidated)
+        if (i) {
+          const a = await n();
+          r.errors = a.errors;
         } else
-          t.errors = m.errors;
+          r.errors = m.errors;
     },
     { immediate: !0 }
-  ), F(() => r.data, () => {
-    t.isValidated && h();
+  ), w(() => t.data, () => {
+    r.isValidated && p();
   });
-  const s = (l) => {
-    const c = k(l) ? l : b(l);
-    return t.validators.push(c), Q() && X(() => {
-      t.validators = t.validators.filter(
-        (a) => a !== c
+  const o = (i) => {
+    const a = k(i) ? i : b(i);
+    return r.validators.push(a), Q() && X(() => {
+      r.validators = r.validators.filter(
+        (u) => u !== a
       );
-    }), c;
+    }), a;
   };
-  async function o() {
-    const l = await Promise.all(
-      t.validators.filter((u) => f(u) !== void 0).map((u) => f(u).validate(r.data))
-    ), c = l.every((u) => u.isValid);
-    let { errors: a } = m;
-    if (!c) {
-      const u = l.map((g) => g.errors);
-      a = S(...u);
+  async function n() {
+    const i = await Promise.all(
+      r.validators.filter((v) => d(v) !== void 0).map((v) => d(v).validate(t.data))
+    ), a = i.every((v) => v.isValid);
+    let { errors: u } = m;
+    if (!a) {
+      const v = i.map((E) => E.errors);
+      u = S(...v);
     }
     return {
-      errors: a,
-      isValid: c
+      errors: u,
+      isValid: a
     };
   }
-  const n = (l = m.errors) => {
-    t.errors = S(f(e.errors) ?? m.errors, l);
-  }, h = async () => {
-    const l = await o();
-    return n(l.errors), t.isValidated = !0, {
-      isValid: !M(l.errors),
-      errors: t.errors
+  const p = async () => {
+    const i = await n();
+    return s(i.errors), r.isValidated = !0, {
+      isValid: !M(i.errors),
+      errors: r.errors
     };
-  }, v = d(() => !M(t.errors));
+  }, h = c(() => !M(r.errors)), V = () => {
+    r.isValidated = !1, r.errors = d(e.errors) ?? m.errors;
+  };
   return {
-    ...N(t),
-    validateForm: h,
-    defineValidator: s,
-    isValid: v
+    ...N(r),
+    validateForm: p,
+    defineValidator: o,
+    isValid: h,
+    reset: V
   };
 }
 class ve {
-  constructor(e, t) {
-    this.path = e, this.validator = t;
+  constructor(e, r) {
+    this.path = e, this.validator = r;
   }
   async validate(e) {
-    const t = D(e, this.path);
+    const r = P(e, this.path);
     if (!this.validator)
       return m;
-    const s = await this.validator.validate(t);
+    const s = await this.validator.validate(r);
     return {
       isValid: s.isValid,
       errors: {
         general: s.errors.general || [],
         propertyErrors: s.errors.propertyErrors ? Object.fromEntries(
           Object.entries(s.errors.propertyErrors).map(([o, n]) => [
-            w(this.path, o),
+            R(this.path, o),
             n
           ])
         ) : {}
@@ -366,83 +369,83 @@ class ve {
     };
   }
 }
-function me(r, e, t) {
-  const s = U(r.data, e), o = d(() => D(r.initialData.value, e)), n = (i) => ({
-    ...i,
-    path: d(() => f(i.path).replace(e + ".", "")),
-    setData: (p) => {
-      i.setData(p);
+function me(t, e, r) {
+  const s = U(t.data, e), o = c(() => P(t.initialData.value, e)), n = (l) => ({
+    ...l,
+    path: c(() => d(l.path).replace(e + ".", "")),
+    setData: (f) => {
+      l.setData(f);
     }
-  }), h = (i) => {
-    const p = w(e, i), V = r.getField(p);
-    return V ? n(V) : {};
-  }, v = (i) => {
-    const p = w(e, i.path), V = r.defineField({
-      ...i,
-      path: p
+  }), p = (l) => {
+    const f = R(e, l), y = t.getField(f);
+    return y ? n(y) : {};
+  }, h = (l) => {
+    const f = R(e, l.path), y = t.defineField({
+      ...l,
+      path: f
     });
-    return n(V);
-  }, l = d(() => r.fields.value.filter((i) => {
-    const p = i.path.value;
-    return p.startsWith(e + ".") || p === e;
-  }).map((i) => n(i))), c = () => r.fields.value.filter((i) => {
-    const p = i.path.value;
-    return p.startsWith(e + ".") || p === e;
-  }), a = d(() => c().some((i) => i.dirty.value)), u = d(() => c().some((i) => i.touched.value)), g = d(() => r.isValid.value), P = d(() => r.isValidated.value), J = d(() => se(f(r.errors), e));
+    return n(y);
+  }, V = c(() => t.fields.value.filter((l) => {
+    const f = l.path.value;
+    return f.startsWith(e + ".") || f === e;
+  }).map((l) => n(l))), i = () => t.fields.value.filter((l) => {
+    const f = l.path.value;
+    return f.startsWith(e + ".") || f === e;
+  }), a = c(() => i().some((l) => l.dirty.value)), u = c(() => i().some((l) => l.touched.value)), v = c(() => t.isValid.value), E = c(() => t.isValidated.value), J = c(() => se(d(t.errors), e));
   return {
     data: s,
-    fields: l,
+    fields: V,
     initialData: o,
-    defineField: v,
-    getField: h,
+    defineField: h,
+    getField: p,
     isDirty: a,
     isTouched: u,
-    isValid: g,
-    isValidated: P,
+    isValid: v,
+    isValidated: E,
     errors: J,
-    defineValidator: (i) => {
-      const p = k(i) ? i : b(i), V = d(
-        () => new ve(e, f(p))
+    defineValidator: (l) => {
+      const f = k(l) ? l : b(l), y = c(
+        () => new ve(e, d(f))
       );
-      return r.defineValidator(V), p;
+      return t.defineValidator(y), f;
     },
-    reset: () => c().forEach((i) => i.reset()),
-    validateForm: () => r.validateForm(),
-    getSubForm: (i, p) => {
-      const V = w(e, i);
-      return r.getSubForm(
-        V,
-        p
+    reset: () => i().forEach((l) => l.reset()),
+    validateForm: () => t.validateForm(),
+    getSubForm: (l, f) => {
+      const y = R(e, l);
+      return t.getSubForm(
+        y,
+        f
       );
     }
   };
 }
-function Pe(r) {
-  const e = d(() => Object.freeze(y(r.initialData))), t = W(y(e)), s = R({
+function Pe(t) {
+  const e = c(() => Object.freeze(g(t.initialData))), r = W(g(e)), s = D({
     initialData: e,
-    data: t
+    data: r
   });
-  F(e, (a) => {
-    s.data = y(a);
+  w(e, (a) => {
+    s.data = g(a);
   });
-  const o = he(s, r), n = ne(s, o), h = ie(n), v = () => {
-    t.value = y(e), n.fields.value.forEach(
+  const o = he(s, t), n = ne(s, o), p = ie(n), h = () => {
+    r.value = g(e), o.reset(), n.fields.value.forEach(
       (a) => a.reset()
     );
   };
-  function l(a, u) {
-    return me(c, a);
+  function V(a, u) {
+    return me(i, a);
   }
-  const c = {
+  const i = {
     ...n,
     ...o,
-    ...h,
-    reset: v,
-    getSubForm: l,
+    ...p,
+    reset: h,
+    getSubForm: V,
     initialData: _(s, "initialData"),
     data: _(s, "data")
   };
-  return c;
+  return i;
 }
 const _e = /* @__PURE__ */ j({
   __name: "Field",
@@ -453,10 +456,10 @@ const _e = /* @__PURE__ */ j({
     path: {},
     errors: {}
   },
-  setup(r) {
-    const e = r, t = e.form.defineField({
+  setup(t) {
+    const e = t, r = e.form.defineField({
       path: e.path
-    }), s = R(t);
+    }), s = D(r);
     return (o, n) => O(o.$slots, "default", z(B(s)));
   }
 }), Se = /* @__PURE__ */ j({
@@ -468,19 +471,19 @@ const _e = /* @__PURE__ */ j({
     form: {},
     path: {}
   },
-  setup(r) {
-    return (e, t) => {
+  setup(t) {
+    return (e, r) => {
       const s = Y("Field");
       return A(), $(s, {
         form: e.form,
         path: e.path
       }, {
-        default: C(({ errors: o, data: n, setData: h }) => [
+        default: C(({ errors: o, data: n, setData: p }) => [
           (A(), $(x(e.component), ee({ ...e.componentProps, ...e.$attrs }, {
             "model-value": n,
             errors: o,
             name: e.path,
-            "onUpdate:modelValue": h
+            "onUpdate:modelValue": p
           }), {
             default: C(() => [
               O(e.$slots, "default")
@@ -498,9 +501,9 @@ const _e = /* @__PURE__ */ j({
     form: {},
     path: {}
   },
-  setup(r) {
-    const e = r, t = d(() => e.form.getSubForm(e.path));
-    return (s, o) => O(s.$slots, "default", z(B({ subform: t.value })));
+  setup(t) {
+    const e = t, r = c(() => e.form.getSubForm(e.path));
+    return (s, o) => O(s.$slots, "default", z(B({ subform: r.value })));
   }
 });
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamnovu/kit-vue-forms",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "",
   "main": "dist/index.js",
   "type": "module",

package/src/composables/useForm.ts

@@ -36,6 +36,7 @@ export function useForm<T extends FormDataDefault>(options: UseFormOptions<T>) {
 
   const reset = () => {
     data.value = cloneRefValue(initialData)
+    validationState.reset()
     fieldRegistry.fields.value.forEach(
       (field: AnyField<T>) => field.reset(),
     )

package/src/composables/useValidation.ts

@@ -122,6 +122,10 @@ export function useValidation<T extends FormDataDefault>(
     errors: unref(options.errors) ?? SuccessValidationResult.errors,
   })
 
+  const updateErrors = (newErrors: ErrorBag = SuccessValidationResult.errors) => {
+    validationState.errors = mergeErrors(unref(options.errors) ?? SuccessValidationResult.errors, newErrors)
+  }
+
   // Watch for changes in the error bag and update validation state
   watch(() => unref(options.errors), async () => {
     if (validationState.isValidated) {
@@ -198,10 +202,6 @@ export function useValidation<T extends FormDataDefault>(
     }
   }
 
-  const updateErrors = (newErrors: ErrorBag = SuccessValidationResult.errors) => {
-    validationState.errors = mergeErrors(unref(options.errors) ?? SuccessValidationResult.errors, newErrors)
-  }
-
   const validateForm = async (): Promise<ValidationResult> => {
     const validationResults = await getValidationResults()
 
@@ -217,11 +217,17 @@ export function useValidation<T extends FormDataDefault>(
 
   const isValid = computed(() => !hasErrors(validationState.errors))
 
+  const reset = () => {
+    validationState.isValidated = false
+    validationState.errors = unref(options.errors) ?? SuccessValidationResult.errors
+  }
+
   return {
     ...toRefs(validationState),
     validateForm,
     defineValidator,
     isValid,
+    reset,
   }
 }
 

package/tests/useValidation.test.ts

@@ -238,4 +238,45 @@ describe('useValidation', () => {
 
     expect(field.errors.value).toEqual(['Name error'])
   })
+
+  it('should initialize properly when using a zod schema', async () => {
+    const schema = z.object({
+      name: z.string().min(2),
+    })
+
+    const formState = { data: { name: 'A' } }
+    const validation = useValidation(formState, {
+      schema,
+    })
+
+    expect(validation.errors.value).toEqual(SuccessValidationResult.errors)
+    expect(validation.isValid.value).toEqual(true)
+
+    const result = await validation.validateForm()
+
+    expect(result.isValid).toBe(false)
+    expect(result.errors.propertyErrors.name).toEqual(['Too small: expected string to have >=2 characters']) // From schema validation
+  })
+
+  it('should reset the form errors', async () => {
+    const schema = z.object({
+      name: z.string().min(2),
+    })
+
+    const formState = { data: { name: 'A' } }
+    const validation = useValidation(formState, {
+      schema,
+    })
+
+    await validation.validateForm()
+
+    expect(validation.isValidated.value).toBe(true)
+    expect(validation.isValid.value).toBe(false)
+    expect(validation.errors.value.propertyErrors.name).toEqual(['Too small: expected string to have >=2 characters']) // From schema validation
+
+    validation.reset()
+
+    expect(validation.isValidated.value).toBe(false)
+    expect(validation.errors.value).toEqual(SuccessValidationResult.errors)
+  })
 })