@teamnovu/kit-vue-forms 0.1.5 → 0.1.7

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,54 +1,51 @@
 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 E = (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) {
-  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],
+function te(t, e, r) {
+  const s = Array.isArray(e) ? e : K(e), o = s.at(-1), n = s.slice(0, -1).reduce(
+    (p, h) => p[h],
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    r
+    t
   );
-  n[o] = t;
+  n[o] = o ? r : n;
 }
-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
   };
@@ -65,138 +62,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(F) {
+            e.errors.value.propertyErrors[a] = F;
           }
         })
       });
-      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 +202,7 @@ function ue(r) {
   }, {});
   return {
     general: e,
-    propertyErrors: t
+    propertyErrors: r
   };
 }
 const m = {
@@ -222,10 +219,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 +240,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 +254,111 @@ class fe {
   }
 }
 class pe {
-  constructor(e, t) {
+  constructor(e, r) {
     E(this, "schemaValidator");
     E(this, "functionValidator");
-    this.schema = e, this.validateFn = t, this.schemaValidator = new de(this.schema), this.functionValidator = new fe(this.validateFn);
+    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
-  }), s = (l = m.errors) => {
-    t.errors = S(f(e.errors) ?? m.errors, l);
+    errors: d(e.errors) ?? m.errors
+  }), s = (i = m.errors) => {
+    r.errors = S(d(e.errors) ?? m.errors, i);
   };
-  F(() => f(e.errors), async () => {
-    if (t.isValidated) {
-      const l = await n();
-      s(l.errors);
+  w(() => d(e.errors), async () => {
+    if (r.isValidated) {
+      const i = await n();
+      s(i.errors);
     } else
       s();
-  }, { immediate: !0 }), F(
-    [() => t.validators],
-    async (l) => {
-      if (t.isValidated)
-        if (l) {
-          const c = await n();
-          t.errors = c.errors;
+  }, { 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 o = (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 n() {
-    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);
+    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((F) => F.errors);
+      u = S(...v);
     }
     return {
-      errors: a,
-      isValid: c
+      errors: u,
+      isValid: a
     };
   }
-  const h = async () => {
-    const l = await n();
-    return s(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,
+    ...N(r),
+    validateForm: p,
     defineValidator: o,
-    isValid: v
+    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 +366,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), F = 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: F,
     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 +453,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 +468,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 +498,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/docs/FormInput-example.md

@@ -0,0 +1,59 @@
+# FormInput Example
+
+To define a form input component you need a plain input component that has at least the following props and emits:
+```typescript
+interface Props {
+  modelValue: T
+  errors?: string[] | undefined // if the input should display errors
+}
+interface Emits {
+  'update:modelValue': [T]
+}
+```
+Then we can easily use the `FormFieldWrapper` component from this package.
+
+In the example below we use a text field `TextField.vue`.
+
+Example:
+```vue
+<!-- FormTextInput.vue -->
+<template>
+  <FormFieldWrapper
+    :component="TextField"
+    :component-props="$props"
+    :path="path"
+    :form="form"
+  />
+</template>
+
+<script setup lang="ts" generic="TData extends object, TPath extends Paths<TData>">
+import type { TextFieldProps } from '#components/utils/form/plainInput/TextField.vue';
+import TextField from '#components/utils/form/plainInput/TextField.vue';
+import { type Paths, FormFieldWrapper } from '@teamnovu/kit-vue-forms';
+import type {
+  ExcludedFieldProps,
+  FormComponentProps,
+} from '#types/form/FormComponentProps';
+
+export type Props<TData extends object, TPath extends Paths<TData>> =
+  FormComponentProps<TData, TPath, TextFieldProps['modelValue']> & Omit<TextFieldProps, ExcludedFieldProps>;
+
+defineProps<Props<TData, TPath>>();
+</script>
+```
+Note the usage of the generic types `TData` and `TPath` to make the component fully type-safe. With this, the `path` prop
+will only allow valid paths of the form data. Moreover, it will throw a type error if the property at `path` of the `form`
+has the wrong type. This is ensured by using the `FormComponentProps` type above.
+
+The usage of such a form input component is as follows (assuming the input should handle the "firstName" property of the form data):
+```vue
+<FormTextInput 
+  :form="form"
+  path="firstName"
+/>
+```
+Here, `form` is the Form component that was created with [`useForm`](index.md#useform). All additional props are passed
+to the underlying plain input component, e.g. `label`, `placeholder`, etc.
+
+It is recommended to use this pattern of a styled "plain input" that works with v-model and a "form input" to work with form
+and path as props for all your form inputs. Like that, you can easily use the plain component outside of forms as well.

package/docs/example.md

@@ -0,0 +1,212 @@
+# Example
+
+The following example shows how to use this library for a more complicated form with nested objects and arrays.
+The data structure of the form is as follows:
+```typescript
+{
+  person: {
+    firstName: string,
+    lastName: string | undefined,
+    address: {
+      street: string,
+      city: string,
+    },
+    hobbies: string[]
+  }
+}
+```
+
+We can create a form like this:
+
+```vue
+<template>
+  <form @submit.prevent="submit">
+    <!-- Simple form inputs -->
+    <!-- the "label" prop is passed through the FormTextField to the underlying TextField -->
+    <FormTextField
+        :form="form"
+        path="person.firstName"
+        label="First Name"
+    />
+    <FormTextField
+        :form="form"
+        path="person.lastName"
+        label="Last Name"
+    />
+
+    <!-- Oh oh, my path was wrong here, the form type does not have a property "person.middleName" -->
+    <!-- I get a typescript error that this path is not allowed
+    <FormTextField
+      :form="form"
+      path="person.middleName"
+    />
+    -->
+    <!-- Oh oh, I used a Text component (which allows "string | number | null | undefined"), but the property at the path is a boolean  -->
+    <!-- I get a typescript error that this path and form combination is not allowed
+    <FormTextField
+      :form="form"
+      path="person.isMale"
+    />
+    -->
+
+    <!-- Nested forms in subcomponents -->
+    <!-- My FormAddressField handles forms of type { street: string, city: string } -->
+    <!-- so we can make a subform for the address property of our main form -->
+    <FormPart :form="form" path="person.address" #="{ subform }">
+      <FormAddressField :form="subform" />
+    </FormPart>
+
+    <div v-for="(_, index) in unref(form.data).person.hobbies" :key="index" class="ml-4">
+      <!-- Note the path format of an array item. You just use the index number in the dot-path -->
+      <FormTextField
+          :form="form"
+          :path="`person.hobbies.${index}`"
+      />
+    </div>
+
+    <button type="button" @click="toggleComment">
+      Toggle Comment
+    </button>
+
+    <!-- If you need other data, use the data ref of the form object; don't use getField here -->
+    <!-- Alternatively, in this case you could use the variable "isCommentEnabled" that was defined in the script setup -->
+    <FormTextField
+        v-if="unref(form.data).commentEnabled"
+        :form="form"
+        path="comment"
+    />
+
+    <!-- This is a one-off special thing; I don't really want to make a FormInput out of it -->
+    <!-- I can use the Field component, or I could use form.getField in the script setup -->
+    <Field v-slot="{ data, setData, errors }" path="person.parent" :form="form">
+      <div>
+        Father: {{ data.fatherName }}
+      </div>
+      <div>
+        Mother: {{ data.motherName }}
+      </div>
+      <!-- the "errors" will be an array of strings of the errors corresponding to the property with the given path (here "person.parent") -->
+      <InputError :errors="errors" />
+      <button type="button" @click="() => setData({ fatherName: 'New Father', motherName: 'New Mother' })">
+        Change Parent Names
+      </button>
+    </Field>
+
+    <button type="submit">
+      Submit Form
+    </button>
+    
+  </form>
+</template>
+
+<script setup lang="ts">
+import { Field, useForm, FormPart } from '@teamnovu/kit-vue-forms';
+import { z } from 'zod';
+import { unref } from 'vue';
+import FormTextField from '#components/utils/form/formInput/FormTextField.vue';
+import FormAddressField from '#/FormAddressField.vue';
+import InputError from '#components/utils/form/InputError.vue';
+
+const form = useForm<{ // this type might be inferred automatically from the initialData; but here, it would not work, because lastName is not defined in the initialData
+  person: {
+    firstName: string
+    lastName?: string | undefined
+    address: {
+      street: string
+      city: string
+    }
+    hobbies: string[]
+    parent: {
+      fatherName: string
+      motherName: string
+    }
+    isMale: boolean
+  }
+  commentEnabled?: boolean
+  comment: string
+}>({
+  initialData: {
+    person: {
+      firstName: '',
+      // I don't need to define an initial value for lastName here, because it's optional; the form will still handle it correctly
+      address: {
+        street: '',
+        city: '',
+      },
+      hobbies: ['cooking', 'coding'],
+      parent: {
+        fatherName: 'Hans Müller',
+        motherName: 'Hannah Schmidt',
+      },
+      isMale: false
+    },
+    commentEnabled: false,
+    comment: '',
+  },
+  // optional zod schema for validation; might also just define part of the schema if other properties should be ignored
+  schema: z.object({
+    person: z.object({
+      hobbies: z.array(z.string().min(1, 'Hobby cannot be empty')),
+    }),
+  }),
+});
+
+const sendToBackend = async (data) => {
+  // send data object to backend
+};
+
+const submit = async () => {
+  // validate the form
+  // if the zod schema is not satisfied, isValid will be false and the errors will be set on the corresponding fields
+  // if your TextInput component handles errors correctly, it should be directly visible
+  const { isValid } = await form.validateForm();
+
+  // only submit if the form is valid
+  if (isValid) {
+    await sendToBackend(unref(form.data));
+  }
+};
+
+// To programmatically change form values, use form.getField to get a ref and a setter function
+// never modify form.data directly
+const { data: isCommentEnabled, setData: setCommentEnabled } = form.getField('commentEnabled');
+const toggleComment = () => {
+  setCommentEnabled(!unref(isCommentEnabled));
+};
+</script>
+
+```
+
+An example of the `FormAddressField` that was used above would be:
+```vue
+<!-- FormAddressField.vue -->
+<template>
+  <div>
+    <FormTextField
+      :form="form"
+      path="street"
+      label="Street Address"
+    />
+
+    <FormTextField
+      :form="form"
+      path="city"
+      label="City"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import type { Form } from '@teamnovu/kit-vue-forms';
+import FormTextField from '#components/utils/form/formInput/FormTextField.vue';
+
+interface Props {
+  form: Form<{
+    street: string
+    city: string
+  }>
+}
+
+defineProps<Props>();
+</script>
+```

package/docs/index.md

@@ -0,0 +1,26 @@
+# @teamnovu/kit-vue-forms
+
+A library for data and error handling of forms, including validation with zod schemas.
+
+## Installation
+
+```bash
+pnpm add @teamnovu/kit-vue-forms
+```
+
+## Purpose
+This package provides composables and some data components to simplify the data management of forms and associated errors.
+It was designed as a replacement of Vee-Validate with more flexibility and full type safety. We don't use a provided and injected form object,
+but pass it down as a prop to guarantee type safety.
+
+## Usage
+
+1. Wrap your plain input components into `FormFieldWrapper`, see [FormInput Example](./FormInput-example.md).
+2. Inside your parent component where you want to use a form, use the composable `useForm` to create a form object. 
+This object contains the form data, errors, and methods to define
+fields, validate the form, reset it, and create subforms for nested objects or arrays, see [here](./reference#composable-useform).
+3. Pass this form object to any form input component together with a path to the property of the form data that this input
+should manage. You can also make subforms, pass the form down to child components, etc. See the examples for inspiration.
+4. See Reference documentation for all types and methods: [here](./reference.md).
+
+An example of the most common usages can be found [here](./example.md).

package/docs/info.json

@@ -0,0 +1,3 @@
+{
+    "name": "📋 Vue Forms"
+}

package/docs/reference.md

@@ -0,0 +1,136 @@
+# Reference
+## Composable `useForm`
+This is the main composable which creates the form. It has the following signature:
+```typescript
+function useForm<T extends object>(options: {
+  // the initial data of the form
+  // reactive changes to this object will propagate to the form data
+  initialData: MaybeRefOrGetter<T>
+  // an ErrorBag object or ref of an ErrorBag object with external errors
+  // this is used e.g. for server side validation errors
+  // these errors will be merged with the internal errors of the form based on validationFn below and/or the zod schema
+  errors?: MaybeRef<ErrorBag | undefined>
+  // a zod schema of the form data
+  // this is validated based on the validationStrategy or by manually triggering validateForm on the form object 
+  schema?: MaybeRef<z.ZodType>
+  // a custom validation function which is called with the current form data
+  // this is additional to the schema for custom validations
+  validateFn?: MaybeRef<ValidationFunction<T>>
+  // if the form data of a property should be reset or kept if all fields corresponding to this property are unmounted
+  // !! currently not implemented !!
+  keepValuesOnUnmount?: MaybeRef<boolean>
+  // when validation should be done (on touch, pre submit, etc.)
+  // !! currently not implemented !!
+  validationStrategy?: MaybeRef<ValidationStrategy>
+}): Form<T>
+```
+This composable returns a `Form<T>` object.
+
+## Type `Form<T>`
+Here, `T` is the type of the form data, which is inferred from the `initialData` property of the options object passed to `useForm`.
+You can also explicitly provide a type argument to `useForm<T>` if needed (useful if the initial data is an empty object `{}`).
+
+This object has the following properties and methods:
+```typescript
+interface Form<T extends object> {
+  // the current working data of the form
+  // this might differ from initialData if the user has changed some values
+  data: Ref<T>
+  // the initial data of the form as passed to useForm
+  initialData: Readonly<Ref<T>>
+
+  // all fields of the form that are currently managed
+  fields: Ref<FieldsTuple<T>>
+
+  // defines a field such that it will be managed by the form
+  // without this, the form will not track changes, touched state or validation for this field
+  // use this like a composable
+  defineField: <P extends Paths<T>>(options: DefineFieldOptions<PickProps<T, P>, P>) => FormField<PickProps<T, P>, P>
+  // gets an already defined field by its path
+  // note: if the field was not yet defined, it will be defined automatically
+  // the output is a reactive object containing the data, errors and states as well as some methods
+  // use this like a composable
+  getField: <P extends Paths<T>>(path: P) => FormField<PickProps<T, P>, P>
+
+  // true if the form has been modified from its initial state
+  isDirty: Ref<boolean>
+  // true if any field of the form has been touched (i.e. onBlur was called on any field)
+  isTouched: Ref<boolean>
+  // true if the form data is valid based on the schema and/or the validateFn
+  isValid: Ref<boolean>
+  // true if the form has been validated at least once
+  isValidated: Ref<boolean>
+  // the ErrorBag object containing all errors of the form
+  // this is a merge of internal errors based on schema/validateFn and external errors passed to useForm
+  // the errors are structured based on the paths of the form fields
+  errors: Ref<ErrorBag>
+
+  // defines a custom validator for the form
+  // with this, a subcomponent might add a validator function and/or schema to the form
+  // without needing access to the initial useForm call
+  defineValidator: <TData extends T>(options: ValidatorOptions<TData> | Ref<Validator<TData>>) => Ref<Validator<TData> | undefined>
+
+  // resets the form data and errors, as well as the dirty, touched etc. state of all fields
+  reset: () => void
+  // manually triggers validation of the form data based on schema and/or validateFn
+  validateForm: () => Promise<ValidationResult>
+
+  // creates a subform for a nested object or array property of the form data
+  // the subform is again a Form<T> object, where T is the type of the nested property
+  // it will contain all errors that have paths starting with the path of the subform
+  // changes to the subform data will propagate to the main form data and vice versa
+  getSubForm: <P extends EntityPaths<T>>(
+      path: P,
+      options?: SubformOptions<PickEntity<T, P>>,
+  ) => Form<PickEntity<T, P>>
+}
+```
+
+## Type `ErrorBag`
+The errors in the form are structured in an `ErrorBag` object. Most errors are tied to properties in the form. However,
+there might be cases where there are errors, that cannot be tied to one property. To account for that the `ErrorBag` satisfies the following interface:
+```typescript
+interface ErrorBag {
+  // an array of general error messages not tied to a specific property
+  general: string[] | undefined
+  // a record of property paths to arrays of error messages
+  // nested properties are dot-separated and array indices are just numbers, e.g. "person.address.street" or "person.hobbies.0.name"
+  // for subforms the errors will be all errors that start with the path of the subform
+  propertyErrors: Record<string, ValidationErrorMessage[] | undefined>
+}
+```
+
+## Component `FormPart`
+A component to define a subform part for a nested object or array property of the form data. This corresponds to the
+`getSubForm` method of the `Form<T>` object, but in component form to be easily used in the template. An example usage is as follows:
+```vue
+<template>
+  <FormPart :form="form" path="person.address" #="{ subform }">
+    <MyAdddressComponent :form="subform" />
+  </FormPart>
+</template>
+```
+Here, the `subform` will be a `Form` object with the type of the `address` property of the `person` object of the main form data.
+Note that the errors of the subform will only contain the errors that start with the path of the subform.
+
+## Component `Field`
+This is a helper component to access form fields. It corresponds to the `defineField` method of the `Form<T>` object,
+but in component form to be easily used in the template.
+
+An example usage is as follows:
+```vue
+<template>
+    <Field :form="form" path="firstName" #="{ data, setData, onBlur, errors }">
+        <input :value="data" @input="setData" @blur="onBlur" />
+        <div v-if="errors.length > 0">
+            <span v-for="error in errors" :key="error">{{ error }}</span>
+        </div>
+    </Field>
+</template>
+```
+
+Note: it is recommended to use the `FormFieldWrapper` component and create a reusable form input component instead.
+
+## Component `FormFieldWrapper`
+This component is a helper component to easily create form input components based on plain input components.
+See the [FormInput Example](./FormInput-example.md) for details and an example implementation of a form input component.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamnovu/kit-vue-forms",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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

@@ -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/src/utils/path.ts

@@ -19,9 +19,6 @@ export function getNestedValue<T, K extends Paths<T>>(obj: T, path: K | SplitPat
 
 export function setNestedValue<T, K extends Paths<T>>(obj: T, path: K | SplitPath<K>, value: PickProps<T, K>): void {
   const keys = Array.isArray(path) ? path : splitPath(path)
-  if (keys.length === 0) {
-    throw new Error('Path cannot be empty')
-  }
 
   const lastKey = keys.at(-1)!
   const target = keys
@@ -32,7 +29,7 @@ export function setNestedValue<T, K extends Paths<T>>(obj: T, path: K | SplitPat
       obj as Record<string, any>,
     )
 
-  target[lastKey] = value
+  target[lastKey] = lastKey ? value : target
 }
 
 export const getLens = <T, K extends Paths<T>>(data: MaybeRef<T>, key: MaybeRef<K | SplitPath<K>>) => {

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)
+  })
 })