@teamnovu/kit-vue-forms 0.1.20 → 0.1.22

package/dist/index.js

@@ -1,71 +1,146 @@
 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 d, 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 ce, renderList as ue } 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 d, shallowRef as I, watch as D, computed as V, isRef as O, reactive as A, toRefs as K, shallowReactive as te, toRef as U, onScopeDispose as re, triggerRef as ae, ref as J, getCurrentScope as se, onBeforeUnmount as ne, defineComponent as C, renderSlot as k, normalizeProps as T, guardReactiveProps as N, resolveComponent as ie, createBlock as z, openBlock as H, withCtx as B, 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(), d(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 fe(t, e) {
-  const r = Array.isArray(e) ? e : W(e);
-  return !!D(t, r.slice(0, -1));
+function he(r, t) {
+  const e = /* @__PURE__ */ new Set();
+  return t.map((a) => {
+    const s = [...r.get(a) ?? []], n = s.findIndex((c) => !e.has(c)), p = (n === -1 ? [] : s.slice(n))[0];
+    if (p)
+      return e.add(p), {
+        id: p,
+        item: a
+      };
+    const v = crypto.randomUUID();
+    return r.set(a, s.concat([v])), e.add(v), {
+      id: v,
+      item: a
+    };
+  });
+}
+function G(r, t, e) {
+  const a = new fe(e == null ? void 0 : e.hashFn), s = r.getField(t), n = I([]);
+  return D(
+    s.data,
+    (c) => {
+      n.value = he(a, c);
+    },
+    {
+      immediate: !0,
+      flush: "sync"
+    }
+  ), {
+    fields: n,
+    push: (c) => {
+      const i = s.data.value ?? [];
+      s.setData([...i, c]);
+    },
+    remove: (c) => {
+      const i = s.data.value ?? [];
+      s.setData(
+        (i == null ? void 0 : i.filter((h) => h !== d(c))) ?? []
+      );
+    },
+    removeByIndex: (c) => {
+      const i = s.data.value ?? [];
+      s.setData((i == null ? void 0 : i.filter((h, l) => l !== c)) ?? []);
+    },
+    errors: s.errors,
+    dirty: s.dirty
+  };
 }
-function D(t, e) {
-  return (Array.isArray(e) ? e : W(e)).reduce(
+function W(r) {
+  return r === "" ? [] : r.split(/\s*\.\s*/).filter(Boolean);
+}
+function pe(r, t) {
+  const e = Array.isArray(t) ? t : W(t);
+  return !!S(r, e.slice(0, -1));
+}
+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]),
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      d(t)
+      d(r)
     );
-    n[s] = r;
+    n[s] = e;
   } else {
-    if (!k(t))
+    if (!O(r))
       return;
-    t.value = r;
+    r.value = e;
   }
 }
-const L = (t, e) => v({
+const Z = (r, t) => V({
   get() {
-    return D(d(t), d(e));
+    return S(d(r), d(t));
   },
-  set(r) {
-    he(t, d(e), r);
+  set(e) {
+    ve(r, d(t), e);
   }
 });
-function b(t, e) {
-  return !t && !e ? "" : !t && e ? e : !e && t ? t : `${t}.${e}`;
+function b(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,196 +149,191 @@ class me {
     this.rc > 0 && (this.rc -= 1, this.rc === 0 && this.drop && this.drop());
   }
 }
-function pe(t) {
-  const r = {
+function ye(r) {
+  const e = {
     ...{
       existsInForm: !0
     },
-    ...t
-  }, a = j(Object.freeze(g(r.initialValue))), s = _({
-    value: r.value,
-    path: r.path,
+    ...r
+  }, a = I(Object.freeze(g(e.initialValue))), s = A({
+    value: e.value,
+    path: e.path,
     initialValue: a,
-    errors: r.errors,
+    errors: e.errors,
     touched: !1
   });
-  P(
-    j(r.initialValue),
+  D(
+    I(e.initialValue),
     () => {
-      a.value = Object.freeze(g(r.initialValue)), s.value = g(r.initialValue);
+      a.value = Object.freeze(g(e.initialValue)), s.value !== d(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;
+  const n = V(() => JSON.stringify(s.value) !== JSON.stringify(s.initialValue)), f = (m) => {
+    s.value = m;
   }, 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);
-  }, V = () => {
-    const h = s.path.split(".").at(-1) || "";
-    d(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 m;
+    s.touched = !0, s.errors = [], (m = e.onBlur) == null || m.call(e);
+  }, v = () => {
+    var m;
+    (m = e.onFocus) == null || m.call(e);
+  }, c = () => {
+    const m = s.path.split(".").at(-1) || "";
+    d(e.existsInForm) && !/^\d+$/.test(m) && (s.value = g(s.initialValue)), s.touched = !1, s.errors = [];
+  }, i = (m) => {
+    n.value || f(g(m)), s.initialValue = m;
+  }, h = (m) => {
+    s.errors = m;
+  }, l = () => {
     s.errors = [];
-  }, i = T(s);
+  }, o = K(s);
   return {
-    data: i.value,
-    path: i.path,
-    initialValue: i.initialValue,
-    errors: i.errors,
-    touched: i.touched,
+    data: o.value,
+    path: o.path,
+    initialValue: o.initialValue,
+    errors: o.errors,
+    touched: o.touched,
     dirty: n,
     setData: f,
-    setInitialData: l,
+    setInitialData: i,
     onBlur: p,
-    onFocus: F,
-    reset: V,
-    setErrors: c,
-    clearErrors: o
+    onFocus: v,
+    reset: c,
+    setErrors: h,
+    clearErrors: l
   };
 }
-const Ve = {
+const Fe = {
   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 = I(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 = d(o.path);
-    s.set(i, o);
-  }, p = (o) => {
-    var i;
-    n != null && n.keepValuesOnUnmount || (i = s.get(o)) == null || i.reset(), s.delete(o);
-  }, F = (o) => {
-    var i;
-    a.has(o) ? (i = a.get(o)) == null || i.inc() : a.set(o, new me(() => p(o)));
-  }, V = (o) => {
-    var i;
-    a.has(o) && ((i = a.get(o)) == null || i.dec());
-  }, l = (o) => {
-    const { path: i } = o;
-    if (!s.has(i)) {
-      const A = pe({
-        path: i,
-        value: L(I(t, "data"), i),
-        initialValue: Fe(t, i),
-        existsInForm: v(() => fe(t.data, d(i))),
-        errors: v({
+function Ee(r, t, e) {
+  const a = /* @__PURE__ */ new Map(), s = te(/* @__PURE__ */ new Map()), n = {
+    ...Fe,
+    ...e
+  }, f = (l) => {
+    const o = d(l.path);
+    s.set(o, l);
+  }, p = (l) => {
+    var o;
+    n != null && n.keepValuesOnUnmount || (o = s.get(l)) == null || o.reset(), s.delete(l);
+  }, v = (l) => {
+    var o;
+    a.has(l) ? (o = a.get(l)) == null || o.inc() : a.set(l, new Ve(() => p(l)));
+  }, c = (l) => {
+    var o;
+    a.has(l) && ((o = a.get(l)) == null || o.dec());
+  }, i = (l) => {
+    const { path: o } = l;
+    if (!s.has(o)) {
+      const M = ye({
+        path: o,
+        value: Z(U(r, "data"), o),
+        initialValue: ge(r, o),
+        existsInForm: V(() => pe(r.data, d(o))),
+        errors: V({
           get() {
-            return e.errors.value.propertyErrors[i] || [];
+            return t.errors.value.propertyErrors[o] || [];
           },
           set(E) {
-            e.errors.value.propertyErrors[i] = E;
+            t.errors.value.propertyErrors[o] = 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, d(i)),
-            (R = o.onBlur) == null ? void 0 : R.call(o)
+            (E = n == null ? void 0 : n.onBlur) == null ? void 0 : E.call(n, d(o)),
+            (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, d(i)),
-            (R = o.onFocus) == null ? void 0 : R.call(o)
+            (E = n == null ? void 0 : n.onFocus) == null ? void 0 : E.call(n, d(o)),
+            (P = l.onFocus) == null ? void 0 : P.call(l)
           ]);
         }
       });
-      f(A);
+      f(M);
     }
-    const h = s.get(i);
-    return F(i), te(() => {
-      V(i);
-    }), h;
-  }, c = (o) => l(o);
+    const m = s.get(o);
+    return v(o), re(() => {
+      c(o);
+    }), m;
+  }, h = (l) => i(l);
   return {
-    fields: v(() => [...s.values()]),
-    getField: (o) => l({ path: o }),
+    fields: V(() => [...s.values()]),
+    getField: (l) => i({ path: l }),
     registerField: f,
     deregisterField: p,
-    defineField: c
+    defineField: h
   };
 }
-function ge(t) {
-  const e = v(() => t.fields.value.some((a) => d(a.dirty))), r = v(() => t.fields.value.some((a) => d(a.touched)));
+function we(r) {
+  const t = V(() => r.fields.value.some((a) => d(a.dirty))), e = V(() => r.fields.value.some((a) => d(a.touched)));
   return {
-    isDirty: e,
-    isTouched: r
-  };
-}
-function G(t, e) {
-  return (r) => async (a) => {
-    a.preventDefault(), d(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 j(...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,28 +341,28 @@ function Re(t) {
     };
   }, {});
   return {
-    general: e,
-    propertyErrors: r
+    general: t,
+    propertyErrors: e
   };
 }
-const y = {
+const F = {
   isValid: !0,
   errors: {
     general: [],
     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)
-      return y;
-    const a = Re(r.error);
+      return F;
+    const e = await this.schema.safeParseAsync(t);
+    if (e.success)
+      return F;
+    const a = Pe(e.error);
     return {
       isValid: !1,
       errors: {
@@ -302,138 +372,138 @@ class Pe {
     };
   }
 }
-class De {
-  constructor(e) {
-    this.validateFn = e;
+class be {
+  constructor(t) {
+    this.validateFn = t;
   }
-  async validate(e) {
+  async validate(t) {
     if (!this.validateFn)
-      return y;
+      return F;
     try {
-      const r = await this.validateFn(e);
-      return r.isValid ? y : r;
-    } catch (r) {
+      const e = await this.validateFn(t);
+      return e.isValid ? F : 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 Ie {
+  constructor(t, e) {
+    R(this, "schemaValidator");
+    R(this, "functionValidator");
+    this.schema = t, this.validateFn = e, this.schemaValidator = new Se(this.schema), this.functionValidator = new be(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: j(e.errors, a.errors)
     };
   }
 }
-function U(t) {
-  return v(() => new Se(
-    d(t.schema),
-    d(t.validateFn)
+function x(r) {
+  return V(() => new Ie(
+    d(r.schema),
+    d(r.validateFn)
   ));
 }
-function be(t, e) {
-  const r = _({
-    validators: J([U(e)]),
+function ke(r, t) {
+  const e = A({
+    validators: J([x(t)]),
     isValidated: !1,
-    errors: d(e.errors) ?? y.errors
-  }), a = (l = y.errors) => {
-    r.errors = C(d(e.errors) ?? y.errors, l);
+    errors: d(t.errors) ?? F.errors
+  }), a = (i = F.errors) => {
+    e.errors = j(d(t.errors) ?? F.errors, i);
   };
-  P(() => d(e.errors), async () => {
-    if (r.isValidated) {
-      const l = await n();
-      a(l.errors);
+  D(() => d(t.errors), async () => {
+    if (e.isValidated) {
+      const i = await n();
+      a(i.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 (i) => {
+      if (e.isValidated)
+        if (i) {
+          const h = await n();
+          e.errors = h.errors;
         } else
-          r.errors = y.errors;
+          e.errors = F.errors;
     },
     { immediate: !0 }
-  ), P([() => t.data, () => d(e.schema)], () => {
-    r.isValidated && f();
+  ), D([() => r.data, () => d(t.schema)], () => {
+    e.isValidated && f();
   });
-  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 = (i) => {
+    const h = O(i) ? i : x(i);
+    return e.validators.push(h), se() && ne(() => {
+      e.validators = e.validators.filter(
+        (l) => l !== h
       );
-    }), c;
+    }), h;
   };
   async function n() {
-    const l = await Promise.all(
-      r.validators.filter((i) => d(i) !== void 0).map((i) => d(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 i = await Promise.all(
+      e.validators.filter((o) => d(o) !== void 0).map((o) => d(o).validate(r.data))
+    ), h = i.every((o) => o.isValid);
+    let { errors: l } = F;
+    if (!h) {
+      const o = i.map((m) => m.errors);
+      l = j(...o);
     }
     return {
-      errors: o,
-      isValid: c
+      errors: l,
+      isValid: h
     };
   }
   const f = async () => {
-    const l = await n();
-    return a(l.errors), r.isValidated = !0, {
-      isValid: !O(l.errors),
-      errors: r.errors
+    const i = await n();
+    return a(i.errors), e.isValidated = !0, {
+      isValid: !_(i.errors),
+      errors: e.errors
     };
-  }, p = async (l) => {
-    const c = await n();
+  }, p = async (i) => {
+    const h = await n();
     return a({
-      general: c.errors.general,
+      general: h.errors.general,
       propertyErrors: {
-        [l]: c.errors.propertyErrors[l]
+        [i]: h.errors.propertyErrors[i]
       }
     }), {
-      isValid: !O(c.errors),
-      errors: r.errors
+      isValid: !_(h.errors),
+      errors: e.errors
     };
-  }, F = v(() => !O(r.errors)), V = () => {
-    r.isValidated = !1, r.errors = d(e.errors) ?? y.errors;
+  }, v = V(() => !_(e.errors)), c = () => {
+    e.isValidated = !1, e.errors = d(t.errors) ?? F.errors;
   };
   return {
-    ...T(r),
+    ...K(e),
     validateForm: f,
     validateField: p,
     defineValidator: s,
-    isValid: F,
-    reset: V
+    isValid: v,
+    reset: c
   };
 }
-class $e {
-  constructor(e, r) {
-    this.path = e, this.validator = r;
+class Ae {
+  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);
+      return F;
+    const a = await this.validator.validate(e);
     return {
       isValid: a.isValid,
       errors: {
@@ -447,106 +517,96 @@ class $e {
     };
   }
 }
-function _e(t, e, r, a) {
-  const s = L(t.data, e), n = v(() => D(t.initialData.value, e)), f = (u) => ({
+function Me(r, t, e, a) {
+  const s = Z(r.data, t), n = V(() => S(r.initialData.value, t)), f = (u) => ({
     ...u,
-    path: v(() => d(u.path).replace(e + ".", "")),
-    setData: (m) => {
-      u.setData(m);
+    path: V(() => d(u.path).replace(t + ".", "")),
+    setData: (y) => {
+      u.setData(y);
     }
   }), p = (u) => {
-    const m = b(e, u), w = t.getField(m);
+    const y = b(t, u), w = r.getField(y);
     return w ? f(w) : {};
-  }, F = (u) => {
-    const m = b(e, u.path), w = t.defineField({
+  }, v = (u) => {
+    const y = b(t, u.path), w = r.defineField({
       ...u,
-      path: m
+      path: y
     });
     return f(w);
-  }, V = v(() => t.fields.value.filter((u) => {
-    const m = u.path.value;
-    return m.startsWith(e + ".") || m === e;
-  }).map((u) => f(u))), l = () => t.fields.value.filter((u) => {
-    const m = u.path.value;
-    return m.startsWith(e + ".") || m === e;
-  }), c = v(
-    () => l().some((u) => u.dirty.value)
-  ), o = v(
-    () => l().some((u) => u.touched.value)
-  ), i = v(() => t.isValid.value), h = v(() => t.isValidated.value), A = v(
-    () => ve(d(t.errors), e)
-  ), z = {
+  }, c = V(() => r.fields.value.filter((u) => {
+    const y = u.path.value;
+    return y.startsWith(t + ".") || y === t;
+  }).map((u) => f(u))), i = () => r.fields.value.filter((u) => {
+    const y = u.path.value;
+    return y.startsWith(t + ".") || y === t;
+  }), h = V(() => i().some((u) => u.dirty.value)), l = V(() => i().some((u) => u.touched.value)), o = V(() => r.isValid.value), m = V(() => r.isValidated.value), M = V(() => me(d(r.errors), t)), $ = {
     data: s,
-    fields: V,
+    fields: c,
     initialData: n,
-    defineField: F,
+    defineField: v,
     getField: p,
-    isDirty: c,
-    isTouched: o,
-    isValid: i,
-    isValidated: h,
-    errors: A,
+    isDirty: h,
+    isTouched: l,
+    isValid: o,
+    isValidated: m,
+    errors: M,
     defineValidator: (u) => {
-      const m = k(u) ? u : U(u), w = v(
-        () => new $e(e, d(m))
+      const y = O(u) ? u : x(u), w = V(
+        () => new Ae(t, d(y))
       );
-      return t.defineValidator(w), m;
+      return r.defineValidator(w), y;
     },
-    reset: () => l().forEach((u) => u.reset()),
-    validateForm: () => t.validateForm(),
-    getSubForm: (u, m) => {
-      const w = b(e, u);
-      return t.getSubForm(
+    reset: () => i().forEach((u) => u.reset()),
+    validateForm: () => r.validateForm(),
+    getSubForm: (u, y) => {
+      const w = b(t, u);
+      return r.getSubForm(
         w,
-        m
+        y
       );
-    }
-  }, q = G(z, r ?? {});
-  return {
-    ...z,
-    submitHandler: q
+    },
+    submitHandler: (u) => L($, e ?? {})(u),
+    useFieldArray: (u, y) => G($, u, y)
   };
+  return $;
 }
-function Ue(t) {
-  const e = v(() => g(t.initialData)), r = J(g(e)), a = _({
-    initialData: e,
-    data: r
+function Oe(r) {
+  const t = V(() => g(r.initialData)), e = J(g(t)), a = A({
+    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 = ke(a, r), n = Ee(a, s, {
+    keepValuesOnUnmount: r.keepValuesOnUnmount,
     onBlur: async (c) => {
-      d(t.validationStrategy) === "onTouch" && s.validateField(c);
+      d(r.validationStrategy) === "onTouch" && s.validateField(c);
     }
-  }), f = ge(n), p = () => {
-    r.value = g(e), s.reset();
+  }), f = we(n), p = () => {
+    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 = {
+  d(r.validationStrategy) === "onFormOpen" && s.validateForm();
+  const v = {
     ...n,
     ...s,
     ...f,
     reset: p,
-    getSubForm: F,
-    initialData: I(a, "initialData"),
-    data: I(a, "data")
-  }, l = G(V, t);
-  return d(t.validationStrategy) === "onFormOpen" && s.validateForm(), {
-    ...V,
-    submitHandler: l
+    initialData: U(a, "initialData"),
+    data: U(a, "data"),
+    submitHandler: (c) => L(v, r)(c),
+    getSubForm: (c, i) => Me(v, c, r),
+    useFieldArray: (c, i) => G(v, c, i)
   };
+  return v;
 }
-const ke = /* @__PURE__ */ x({
+const Ce = /* @__PURE__ */ C({
   __name: "Field",
   props: {
     form: {},
@@ -558,13 +618,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 = A(e);
+    return (s, n) => k(s.$slots, "default", T(N(a)));
   }
-}), xe = /* @__PURE__ */ x({
+}), Te = /* @__PURE__ */ C({
   inheritAttrs: !1,
   __name: "FormFieldWrapper",
   props: {
@@ -573,29 +633,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 }, {
+          (H(), z(oe(r.component), le({ ...r.componentProps, ...t.$attrs }, {
             "model-value": n,
             errors: s,
-            name: t.path,
+            name: r.path,
             "onUpdate:modelValue": f
           }), ce({
             default: B(() => [
-              $(e.$slots, "default")
+              k(t.$slots, "default")
             ]),
             _: 2
           }, [
-            ue(e.$slots, (p, F) => ({
-              name: F,
-              fn: B((V) => [
-                $(e.$slots, F, M(N(V ?? {})))
+            ue(t.$slots, (p, v) => ({
+              name: v,
+              fn: B((c) => [
+                k(t.$slots, v, T(N(c ?? {})))
               ])
             }))
           ]), 1040, ["model-value", "errors", "name", "onUpdate:modelValue"]))
@@ -604,20 +664,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 = V(() => t.form.getSubForm(t.path));
+    return (a, s) => k(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,
+  Oe as useForm
 };