@teamnovu/kit-vue-forms 0.1.8 → 0.1.10

package/dist/components/Field.vue.d.ts

@@ -19,6 +19,7 @@ declare const _default: <TData extends object, TPath extends Paths<TData>>(__VLS
             touched: boolean;
             dirty: boolean;
             setData: (newData: PickProps<TData, TPath>) => void;
+            setInitialData: (newData: PickProps<TData, TPath>) => void;
             onBlur: () => void;
             onFocus: () => void;
             reset: () => void;

package/dist/index.js

@@ -1,57 +1,58 @@
 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 c, unref as d, isRef as D, reactive as P, toRefs as W, shallowReactive as q, toRef as S, onScopeDispose as H, ref as k, watch as w, getCurrentScope as Q, onBeforeUnmount as X, defineComponent as $, renderSlot as j, normalizeProps as z, guardReactiveProps as B, resolveComponent as Y, createBlock as A, openBlock as C, withCtx as M, 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 u, unref as d, isRef as O, reactive as D, toRefs as W, shallowReactive as q, toRef as _, onScopeDispose as H, ref as k, watch as w, getCurrentScope as Q, onBeforeUnmount as X, defineComponent as $, renderSlot as j, normalizeProps as z, guardReactiveProps as B, resolveComponent as Y, createBlock as A, openBlock as C, withCtx as M, resolveDynamicComponent as x, mergeProps as ee } from "vue";
 import { cloneDeep as re } from "lodash-es";
 import "zod";
-function g(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 I(t) {
+  return t === "" ? [] : t.split(/\s*\.\s*/).filter(Boolean);
 }
-function _(r, e) {
-  return (Array.isArray(e) ? e : K(e)).reduce(
+function P(t, e) {
+  return (Array.isArray(e) ? e : I(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), o = s.at(-1);
-  if (!o && D(r))
-    r.value = t;
-  else if (D(r)) {
-    const n = s.slice(0, -1).reduce(
+function te(t, e, r) {
+  const s = Array.isArray(e) ? e : I(e), o = s.at(-1);
+  if (o) {
+    const i = s.slice(0, -1).reduce(
       (p, h) => p[h],
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      d(r)
+      d(t)
     );
-    n[o] = t;
-  } else
-    return;
+    i[o] = r;
+  } else {
+    if (!O(t))
+      return;
+    t.value = r;
+  }
 }
-const U = (r, e) => c({
+const K = (t, e) => u({
   get() {
-    return _(d(r), d(e));
+    return P(d(t), d(e));
   },
-  set(t) {
-    te(r, d(e), t);
+  set(r) {
+    te(t, d(e), r);
   }
 });
-function R(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, i]) => [o.slice(r.length), i]
     )
   );
   return {
-    general: r.general,
+    general: t.general,
     // Keep general errors
     propertyErrors: s
   };
@@ -68,59 +69,62 @@ class ae {
     this.rc > 0 && (this.rc -= 1, this.rc === 0 && this.drop && this.drop());
   }
 }
-function oe(r) {
-  const e = P({
-    value: r.value,
-    path: r.path,
-    initialValue: c(() => Object.freeze(g(r.initialValue))),
-    errors: r.errors,
+function oe(t) {
+  const e = D({
+    value: t.value,
+    path: t.path,
+    initialValue: u(() => Object.freeze(g(t.initialValue))),
+    errors: t.errors,
     touched: !1
-  }), t = c(() => JSON.stringify(e.value) !== JSON.stringify(e.initialValue)), s = (a) => {
-    e.value = a;
+  }), r = u(() => JSON.stringify(e.value) !== JSON.stringify(e.initialValue)), s = (c) => {
+    e.value = c;
   }, o = () => {
     e.touched = !0;
-  }, n = () => {
+  }, i = () => {
   }, p = () => {
     e.value = g(e.initialValue), e.touched = !1, e.errors = [];
-  }, h = (a) => {
-    e.errors = a;
-  }, V = () => {
+  }, h = (c) => {
+    r.value || s(g(c)), e.initialValue = c;
+  }, V = (c) => {
+    e.errors = c;
+  }, n = () => {
     e.errors = [];
-  }, i = W(e);
+  }, a = W(e);
   return {
-    data: i.value,
-    path: i.path,
-    initialValue: i.initialValue,
-    errors: i.errors,
-    touched: i.touched,
-    dirty: t,
+    data: a.value,
+    path: a.path,
+    initialValue: a.initialValue,
+    errors: a.errors,
+    touched: a.touched,
+    dirty: r,
     setData: s,
+    setInitialData: h,
     onBlur: o,
-    onFocus: n,
+    onFocus: i,
     reset: p,
-    setErrors: h,
-    clearErrors: V
+    setErrors: V,
+    clearErrors: n
   };
 }
-function ne(r, e) {
-  const t = /* @__PURE__ */ new Map(), s = q(/* @__PURE__ */ new Map()), o = (a) => {
-    const u = d(a.path);
-    s.set(u, a);
-  }, n = (a) => {
+function ie(t, e) {
+  const r = /* @__PURE__ */ new Map(), s = q(/* @__PURE__ */ new Map()), o = (a) => {
+    const c = d(a.path);
+    s.set(c, a);
+  }, i = (a) => {
     s.delete(a);
   }, p = (a) => {
-    var u;
-    t.has(a) ? (u = t.get(a)) == null || u.inc() : t.set(a, new ae(() => n(a)));
+    var c;
+    r.has(a) ? (c = r.get(a)) == null || c.inc() : r.set(a, new ae(() => i(a)));
   }, h = (a) => {
-    var u;
-    t.has(a) && ((u = t.get(a)) == null || u.dec());
+    var c;
+    r.has(a) && ((c = r.get(a)) == null || c.dec());
   }, V = (a) => {
     if (!s.has(a)) {
       const v = oe({
         path: a,
-        value: U(S(r, "data"), a),
-        initialValue: c(() => _(r.initialData, a)),
-        errors: c({
+        value: K(_(t, "data"), a),
+        initialValue: u(() => P(t.initialData, a)),
+        errors: u({
           get() {
             return e.errors.value.propertyErrors[a] || [];
           },
@@ -131,84 +135,84 @@ function ne(r, e) {
       });
       o(v);
     }
-    const u = s.get(a);
+    const c = s.get(a);
     return p(a), H(() => {
       h(a);
-    }), u;
-  }, i = (a) => V(a.path);
+    }), c;
+  }, n = (a) => V(a.path);
   return {
-    fields: c(() => [...s.values()]),
+    fields: u(() => [...s.values()]),
     getField: V,
     registerField: o,
-    deregisterField: n,
-    defineField: i
+    deregisterField: i,
+    defineField: n
   };
 }
-function ie(r) {
-  const e = c(() => r.fields.value.some((s) => d(s.dirty))), t = c(() => r.fields.value.some((s) => d(s.touched)));
+function ne(t) {
+  const e = u(() => t.fields.value.some((s) => d(s.dirty))), r = u(() => 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 U(...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((i) => i[s]).filter(Boolean);
     return {
-      ...t,
-      [s]: I(...o)
+      ...r,
+      [s]: U(...o)
     };
   }, {});
 }
-function O(...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: U(r.general, s.general),
+      propertyErrors: ce(r.propertyErrors ?? {}, s.propertyErrors ?? {})
     }),
     e
   );
 }
-function N(r) {
+function N(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) => {
-    const n = o.path.join(".");
+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 i = o.path.join(".");
     return {
       ...s,
-      [n]: [...s[n] ?? [], o.message]
+      [i]: [...s[i] ?? [], o.message]
     };
   }, {});
   return {
     general: e,
-    propertyErrors: t
+    propertyErrors: r
   };
 }
 const m = {
@@ -225,10 +229,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: {
@@ -246,13 +250,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: {}
         }
       };
@@ -260,89 +264,89 @@ 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: O(t.errors, s.errors)
+      isValid: r.isValid && s.isValid,
+      errors: S(r.errors, s.errors)
     };
   }
 }
-function b(r) {
-  return c(() => new pe(
-    d(r.schema),
-    d(r.validateFn)
+function b(t) {
+  return u(() => new pe(
+    d(t.schema),
+    d(t.validateFn)
   ));
 }
-function he(r, e) {
-  const t = P({
+function he(t, e) {
+  const r = D({
     validators: k([b(e)]),
     isValidated: !1,
     errors: d(e.errors) ?? m.errors
-  }), s = (i = m.errors) => {
-    t.errors = O(d(e.errors) ?? m.errors, i);
+  }), s = (n = m.errors) => {
+    r.errors = S(d(e.errors) ?? m.errors, n);
   };
   w(() => d(e.errors), async () => {
-    if (t.isValidated) {
-      const i = await n();
-      s(i.errors);
+    if (r.isValidated) {
+      const n = await i();
+      s(n.errors);
     } else
       s();
   }, { immediate: !0 }), w(
-    [() => t.validators],
-    async (i) => {
-      if (t.isValidated)
-        if (i) {
-          const a = await n();
-          t.errors = a.errors;
+    [() => r.validators],
+    async (n) => {
+      if (r.isValidated)
+        if (n) {
+          const a = await i();
+          r.errors = a.errors;
         } else
-          t.errors = m.errors;
+          r.errors = m.errors;
     },
     { immediate: !0 }
-  ), w(() => r.data, () => {
-    t.isValidated && p();
+  ), w(() => t.data, () => {
+    r.isValidated && p();
   });
-  const o = (i) => {
-    const a = D(i) ? i : b(i);
-    return t.validators.push(a), Q() && X(() => {
-      t.validators = t.validators.filter(
-        (u) => u !== a
+  const o = (n) => {
+    const a = O(n) ? n : b(n);
+    return r.validators.push(a), Q() && X(() => {
+      r.validators = r.validators.filter(
+        (c) => c !== a
       );
     }), a;
   };
-  async function n() {
-    const i = await Promise.all(
-      t.validators.filter((v) => d(v) !== void 0).map((v) => d(v).validate(r.data))
-    ), a = i.every((v) => v.isValid);
-    let { errors: u } = m;
+  async function i() {
+    const n = await Promise.all(
+      r.validators.filter((v) => d(v) !== void 0).map((v) => d(v).validate(t.data))
+    ), a = n.every((v) => v.isValid);
+    let { errors: c } = m;
     if (!a) {
-      const v = i.map((F) => F.errors);
-      u = O(...v);
+      const v = n.map((F) => F.errors);
+      c = S(...v);
     }
     return {
-      errors: u,
+      errors: c,
       isValid: a
     };
   }
   const p = async () => {
-    const i = await n();
-    return s(i.errors), t.isValidated = !0, {
-      isValid: !N(i.errors),
-      errors: t.errors
+    const n = await i();
+    return s(n.errors), r.isValidated = !0, {
+      isValid: !N(n.errors),
+      errors: r.errors
     };
-  }, h = c(() => !N(t.errors)), V = () => {
-    t.isValidated = !1, t.errors = d(e.errors) ?? m.errors;
+  }, h = u(() => !N(r.errors)), V = () => {
+    r.isValidated = !1, r.errors = d(e.errors) ?? m.errors;
   };
   return {
-    ...W(t),
+    ...W(r),
     validateForm: p,
     defineValidator: o,
     isValid: h,
@@ -350,51 +354,51 @@ function he(r, e) {
   };
 }
 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 = _(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]) => [
+          Object.entries(s.errors.propertyErrors).map(([o, i]) => [
             R(this.path, o),
-            n
+            i
           ])
         ) : {}
       }
     };
   }
 }
-function me(r, e, t) {
-  const s = U(r.data, e), o = c(() => _(r.initialData.value, e)), n = (l) => ({
+function me(t, e, r) {
+  const s = K(t.data, e), o = u(() => P(t.initialData.value, e)), i = (l) => ({
     ...l,
-    path: c(() => d(l.path).replace(e + ".", "")),
+    path: u(() => d(l.path).replace(e + ".", "")),
     setData: (f) => {
       l.setData(f);
     }
   }), p = (l) => {
-    const f = R(e, l), y = r.getField(f);
-    return y ? n(y) : {};
+    const f = R(e, l), y = t.getField(f);
+    return y ? i(y) : {};
   }, h = (l) => {
-    const f = R(e, l.path), y = r.defineField({
+    const f = R(e, l.path), y = t.defineField({
       ...l,
       path: f
     });
-    return n(y);
-  }, V = c(() => r.fields.value.filter((l) => {
+    return i(y);
+  }, V = u(() => t.fields.value.filter((l) => {
     const f = l.path.value;
     return f.startsWith(e + ".") || f === e;
-  }).map((l) => n(l))), i = () => r.fields.value.filter((l) => {
+  }).map((l) => i(l))), n = () => 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(() => r.isValid.value), F = c(() => r.isValidated.value), J = c(() => se(d(r.errors), e));
+  }), a = u(() => n().some((l) => l.dirty.value)), c = u(() => n().some((l) => l.touched.value)), v = u(() => t.isValid.value), F = u(() => t.isValidated.value), J = u(() => se(d(t.errors), e));
   return {
     data: s,
     fields: V,
@@ -402,53 +406,53 @@ function me(r, e, t) {
     defineField: h,
     getField: p,
     isDirty: a,
-    isTouched: u,
+    isTouched: c,
     isValid: v,
     isValidated: F,
     errors: J,
     defineValidator: (l) => {
-      const f = D(l) ? l : b(l), y = c(
+      const f = O(l) ? l : b(l), y = u(
         () => new ve(e, d(f))
       );
-      return r.defineValidator(y), f;
+      return t.defineValidator(y), f;
     },
-    reset: () => i().forEach((l) => l.reset()),
-    validateForm: () => r.validateForm(),
+    reset: () => n().forEach((l) => l.reset()),
+    validateForm: () => t.validateForm(),
     getSubForm: (l, f) => {
       const y = R(e, l);
-      return r.getSubForm(
+      return t.getSubForm(
         y,
         f
       );
     }
   };
 }
-function Pe(r) {
-  const e = c(() => Object.freeze(g(r.initialData))), t = k(g(e)), s = P({
+function Pe(t) {
+  const e = u(() => Object.freeze(g(t.initialData))), r = k(g(e)), s = D({
     initialData: e,
-    data: t
+    data: r
   });
   w(e, (a) => {
     s.data = g(a);
   });
-  const o = he(s, r), n = ne(s, o), p = ie(n), h = () => {
-    t.value = g(e), o.reset(), n.fields.value.forEach(
+  const o = he(s, t), i = ie(s, o), p = ne(i), h = () => {
+    r.value = g(e), o.reset(), i.fields.value.forEach(
       (a) => a.reset()
     );
   };
-  function V(a, u) {
-    return me(i, a);
+  function V(a, c) {
+    return me(n, a);
   }
-  const i = {
-    ...n,
+  const n = {
+    ...i,
     ...o,
     ...p,
     reset: h,
     getSubForm: V,
-    initialData: S(s, "initialData"),
-    data: S(s, "data")
+    initialData: _(s, "initialData"),
+    data: _(s, "data")
   };
-  return i;
+  return n;
 }
 const _e = /* @__PURE__ */ $({
   __name: "Field",
@@ -459,11 +463,11 @@ const _e = /* @__PURE__ */ $({
     path: {},
     errors: {}
   },
-  setup(r) {
-    const e = r, t = e.form.defineField({
+  setup(t) {
+    const e = t, r = e.form.defineField({
       path: e.path
-    }), s = P(t);
-    return (o, n) => j(o.$slots, "default", z(B(s)));
+    }), s = D(r);
+    return (o, i) => j(o.$slots, "default", z(B(s)));
   }
 }), Se = /* @__PURE__ */ $({
   inheritAttrs: !1,
@@ -474,16 +478,16 @@ const _e = /* @__PURE__ */ $({
     form: {},
     path: {}
   },
-  setup(r) {
-    return (e, t) => {
+  setup(t) {
+    return (e, r) => {
       const s = Y("Field");
       return C(), A(s, {
         form: e.form,
         path: e.path
       }, {
-        default: M(({ errors: o, data: n, setData: p }) => [
+        default: M(({ errors: o, data: i, setData: p }) => [
           (C(), A(x(e.component), ee({ ...e.componentProps, ...e.$attrs }, {
-            "model-value": n,
+            "model-value": i,
             errors: o,
             name: e.path,
             "onUpdate:modelValue": p
@@ -498,20 +502,20 @@ const _e = /* @__PURE__ */ $({
       }, 8, ["form", "path"]);
     };
   }
-}), Oe = /* @__PURE__ */ $({
+}), be = /* @__PURE__ */ $({
   __name: "FormPart",
   props: {
     form: {},
     path: {}
   },
-  setup(r) {
-    const e = r, t = c(() => e.form.getSubForm(e.path));
-    return (s, o) => j(s.$slots, "default", z(B({ subform: t.value })));
+  setup(t) {
+    const e = t, r = u(() => e.form.getSubForm(e.path));
+    return (s, o) => j(s.$slots, "default", z(B({ subform: r.value })));
   }
 });
 export {
   _e as Field,
   Se as FormFieldWrapper,
-  Oe as FormPart,
+  be as FormPart,
   Pe as useForm
 };

package/dist/types/form.d.ts

@@ -13,6 +13,7 @@ export interface FormField<T, P extends string> {
     touched: Ref<boolean>;
     dirty: Ref<boolean>;
     setData: (newData: T) => void;
+    setInitialData: (newData: T) => void;
     onBlur: () => void;
     onFocus: () => void;
     reset: () => void;

package/package.json

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

package/src/composables/useField.ts

@@ -41,6 +41,17 @@ export function useField<T, K extends string>(options: UseFieldOptions<T, K>): F
     state.errors = []
   }
 
+  /**
+   * Sets the initial data for the field. If the field is not dirty, it also updates the current data.
+   * @param newData - The new initial data to set.
+   */
+  const setInitialData = (newData: T): void => {
+    if (!dirty.value) {
+      setData(cloneRefValue(newData))
+    }
+    state.initialValue = newData
+  }
+
   const setErrors = (newErrors: ValidationErrorMessage[]): void => {
     state.errors = newErrors
   }
@@ -59,6 +70,7 @@ export function useField<T, K extends string>(options: UseFieldOptions<T, K>): F
     touched: refs.touched as FormField<T, K>['touched'],
     dirty,
     setData,
+    setInitialData,
     onBlur,
     onFocus,
     reset,

package/src/types/form.ts

@@ -15,6 +15,7 @@ export interface FormField<T, P extends string> {
   touched: Ref<boolean>
   dirty: Ref<boolean>
   setData: (newData: T) => void
+  setInitialData: (newData: T) => void
   onBlur: () => void
   onFocus: () => void
   reset: () => void

package/src/utils/path.ts

@@ -22,11 +22,13 @@ export function setNestedValue<T, K extends Paths<T>>(obj: MaybeRef<T>, path: K
 
   const lastKey = keys.at(-1)!
 
-  if (!lastKey && isRef(obj)) {
+  if (!lastKey) {
+    if (!isRef(obj)) {
+      // We cannot do anything here as we have nothing we can assign to
+      return
+    }
+
     obj.value = value
-  } else if (!isRef(obj)) {
-    // We cannot do anything here as we have nothing we can assign to
-    return
   } else {
     const target = keys
       .slice(0, -1)