@teamnovu/kit-vue-forms 0.1.21 → 0.1.23

package/dist/index.js

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