@volverjs/form-vue 1.0.0-beta.9 → 1.0.0

package/dist/index.es.js

@@ -1,336 +1,105 @@
-import { defineComponent as z, computed as w, onMounted as P, onBeforeUnmount as j, inject as B, toRefs as H, watch as p, unref as C, provide as M, readonly as E, resolveComponent as S, defineAsyncComponent as F, h as O, ref as $, toRaw as A, isProxy as ee, withModifiers as re, getCurrentInstance as te } from "vue";
-import { watchIgnorable as ae, throttleFilter as ne } from "@vueuse/core";
-import { ZodObject as Z, ZodDefault as ue, ZodNullable as le, ZodSchema as se, ZodArray as ie, ZodEffects as fe, ZodOptional as oe } from "zod";
-function J(e) {
-  return Array.isArray(e);
-}
-function de(e) {
-  return typeof e < "u";
-}
-function q(e) {
-  return e === null;
-}
-function Q(e) {
-  return typeof e == "object";
-}
-function X(e) {
-  return typeof e == "string";
-}
-function G(e) {
-  return typeof e > "u";
-}
-const ve = /^[0-9]+$/, ce = ["__proto__", "prototype", "constructor"];
-function L(e, s, t) {
-  const o = de(t) ? t : void 0;
-  if (!Q(e) || !X(s))
-    return o;
-  const u = T(s);
-  if (u.length !== 0) {
-    for (const r of u) {
-      if (r === "*")
-        continue;
-      const l = function(n) {
-        return n.map((f) => G(f) || q(f) ? f : J(f) ? l(f) : f[r]);
-      };
-      if (J(e) && !ve.test(r) ? e = l(e) : e = e[r], G(e) || q(e))
-        break;
-    }
-    return G(e) ? o : e;
-  }
-}
-function Y(e, s, t) {
-  if (!Q(e) || !X(s))
-    return;
-  const o = T(s);
-  if (o.length === 0)
-    return;
-  const u = o.length;
-  for (let r = 0; r < u; r++) {
-    const l = o[r];
-    if (r === u - 1) {
-      e[l] = t;
-      return;
-    }
-    if (l === "*" && J(e)) {
-      const n = o.slice(r + 1).join(".");
-      for (const f of e)
-        Y(f, n, t);
-      return;
-    }
-    G(e[l]) && (e[l] = {}), e = e[l];
-  }
-}
-function T(e) {
-  const s = e.split(/[.]|(?:\[(\d|\*)\])/).filter((t) => !!t);
-  return s.some((t) => ce.indexOf(t) !== -1) ? [] : s;
-}
-var d = /* @__PURE__ */ ((e) => (e.text = "text", e.number = "number", e.email = "email", e.password = "password", e.tel = "tel", e.url = "url", e.search = "search", e.date = "date", e.time = "time", e.datetimeLocal = "datetime-local", e.month = "month", e.week = "week", e.color = "color", e.select = "select", e.checkbox = "checkbox", e.radio = "radio", e.textarea = "textarea", e.radioGroup = "radioGroup", e.checkboxGroup = "checkboxGroup", e.combobox = "combobox", e.custom = "custom", e))(d || {}), k = /* @__PURE__ */ ((e) => (e.invalid = "invalid", e.valid = "valid", e.submitting = "submitting", e.updated = "updated", e.unknown = "unknown", e))(k || {});
-const me = (e, s, t, o) => z({
-  name: "VvFormField",
-  props: {
-    type: {
-      type: String,
-      validator: (u) => Object.values(d).includes(u),
-      default: d.custom
-    },
-    is: {
-      type: [Object, String],
-      default: void 0
-    },
-    name: {
-      type: [String, Number, Boolean, Symbol],
-      required: !0
-    },
-    props: {
-      type: [Object, Function],
-      default: () => ({})
-    },
-    showValid: {
-      type: Boolean,
-      default: !1
-    },
-    defaultValue: {
-      type: [String, Number, Boolean, Array, Object],
-      default: void 0
-    },
-    lazyLoad: {
-      type: Boolean,
-      default: !1
-    },
-    readonly: {
-      type: Boolean,
-      default: void 0
-    }
-  },
-  emits: ["invalid", "valid", "update:formData", "update:modelValue"],
-  expose: ["invalid", "invalidLabel", "errors"],
-  setup(u, { slots: r, emit: l }) {
-    const n = w({
-      get() {
-        if (a != null && a.formData)
-          return L(
-            Object(a.formData.value),
-            String(u.name)
-          );
-      },
-      set(i) {
-        a != null && a.formData && (Y(
-          Object(a.formData.value),
-          String(u.name),
-          i
-        ), l("update:modelValue", {
-          newValue: n.value,
-          formData: a == null ? void 0 : a.formData
-        }));
-      }
-    });
-    P(() => {
-      n.value === void 0 && u.defaultValue !== void 0 && (n.value = u.defaultValue);
-    }), j(() => {
-      h(), m();
-    });
-    const f = B(s, void 0);
-    f && f.fields.value.add(u.name);
-    const a = B(e), { props: v, name: b } = H(u), g = w(() => {
-      if (a != null && a.errors.value)
-        return L(a.errors.value, String(u.name));
-    }), V = w(() => {
-      var i;
-      return (i = g.value) == null ? void 0 : i._errors;
-    }), c = w(() => g.value !== void 0), h = p(c, () => {
-      c.value ? (l("invalid", V.value), f && f.errors.value.set(
-        u.name,
-        {
-          _errors: V.value
-        }
-      )) : (l("valid", n.value), f && f.errors.value.delete(
-        u.name
-      ));
-    }), m = p(
-      () => a == null ? void 0 : a.formData,
-      () => {
-        l("update:formData", a == null ? void 0 : a.formData);
-      },
-      { deep: !0 }
-    ), y = (i) => {
-      n.value = i;
-    }, x = w(() => {
-      let i = v.value;
-      return typeof i == "function" && (i = i(a == null ? void 0 : a.formData)), Object.keys(i).reduce(
-        (_, W) => (_[W] = C(i[W]), _),
-        {}
-      );
-    }), I = w(() => a != null && a.readonly.value ? !0 : x.value.readonly ?? u.readonly), U = w(() => ({
-      ...x.value,
-      name: x.value.name ?? u.name,
-      invalid: c.value,
-      valid: u.showValid ? !!(!c.value && n.value) : void 0,
-      type: ((i) => {
-        if ([
-          d.text,
-          d.number,
-          d.email,
-          d.password,
-          d.tel,
-          d.url,
-          d.search,
-          d.date,
-          d.time,
-          d.datetimeLocal,
-          d.month,
-          d.week,
-          d.color
-        ].includes(i))
-          return i;
-      })(u.type),
-      invalidLabel: V.value,
-      modelValue: n.value,
-      readonly: I.value,
-      "onUpdate:modelValue": y
-    }));
-    return M(t, {
-      name: E(b),
-      errors: E(g)
-    }), { component: w(() => {
-      if (u.type === d.custom)
-        return {
-          render() {
-            var i;
-            return ((i = r.default) == null ? void 0 : i.call(r, {
-              modelValue: n.value,
-              onUpdate: y,
-              submit: a == null ? void 0 : a.submit,
-              validate: a == null ? void 0 : a.validate,
-              invalid: c.value,
-              invalidLabel: V.value,
-              formData: a == null ? void 0 : a.formData.value,
-              formErrors: a == null ? void 0 : a.errors.value,
-              errors: g.value,
-              readonly: I.value
-            })) ?? r.defalut;
-          }
-        };
-      if (!((o == null ? void 0 : o.lazyLoad) ?? u.lazyLoad)) {
-        let i;
-        switch (u.type) {
-          case d.select:
-            i = S("VvSelect");
-            break;
-          case d.checkbox:
-            i = S("VvCheckbox");
-            break;
-          case d.radio:
-            i = S("VvRadio");
-            break;
-          case d.textarea:
-            i = S("VvTextarea");
-            break;
-          case d.radioGroup:
-            i = S("VvRadioGroup");
-            break;
-          case d.checkboxGroup:
-            i = S("VvCheckboxGroup");
-            break;
-          case d.combobox:
-            i = S("VvCombobox");
-            break;
-          default:
-            i = S("VvInputText");
-        }
-        if (typeof i != "string")
-          return i;
-        console.warn(
-          `[form-vue warn]: ${i} not found, the component will be loaded asynchronously. To avoid this warning, please set "lazyLoad" option.`
-        );
-      }
-      return F(async () => {
-        switch (o != null && o.sideEffects && await Promise.resolve(o.sideEffects(u.type)), u.type) {
-          case d.textarea:
-            return import("@volverjs/ui-vue/vv-textarea");
-          case d.radio:
-            return import("@volverjs/ui-vue/vv-radio");
-          case d.radioGroup:
-            return import("@volverjs/ui-vue/vv-radio-group");
-          case d.checkbox:
-            return import("@volverjs/ui-vue/vv-checkbox");
-          case d.checkboxGroup:
-            return import("@volverjs/ui-vue/vv-checkbox-group");
-          case d.select:
-            return import("@volverjs/ui-vue/vv-select");
-          case d.combobox:
-            return import("@volverjs/ui-vue/vv-combobox");
-        }
-        return import("@volverjs/ui-vue/vv-input-text");
-      });
-    }), hasProps: U, invalid: c };
-  },
-  render() {
-    return this.is ? O(this.is, this.hasProps, this.$slots) : this.type === d.custom ? O(this.component, null, this.$slots) : O(this.component, this.hasProps, this.$slots);
-  }
-}), K = (e, s = {}) => {
-  const t = (r) => {
-    let l = r;
-    for (; l instanceof fe; )
-      l = l.innerType();
-    return l instanceof oe && (l = l._def.innerType), l;
-  }, o = t(e);
+import { ref as L, computed as O, readonly as G, defineComponent as C, h as F, withModifiers as te, toRaw as B, watch as A, isProxy as ve, onMounted as q, provide as T, toRefs as Q, useId as oe, inject as U, onBeforeUnmount as P, unref as _, resolveComponent as W, defineAsyncComponent as ce, getCurrentInstance as me } from "vue";
+import { watchIgnorable as pe, throttleFilter as ye } from "@vueuse/core";
+import { ZodObject as K, ZodDefault as he, ZodNullable as be, ZodSchema as ge, ZodArray as Ve, ZodRecord as we, ZodEffects as re, ZodOptional as ae, ZodError as De } from "zod";
+var w = /* @__PURE__ */ ((e) => (e.text = "text", e.number = "number", e.email = "email", e.password = "password", e.tel = "tel", e.url = "url", e.search = "search", e.date = "date", e.time = "time", e.datetimeLocal = "datetime-local", e.month = "month", e.week = "week", e.color = "color", e.select = "select", e.checkbox = "checkbox", e.radio = "radio", e.textarea = "textarea", e.radioGroup = "radioGroup", e.checkboxGroup = "checkboxGroup", e.combobox = "combobox", e.custom = "custom", e))(w || {}), x = /* @__PURE__ */ ((e) => (e.invalid = "invalid", e.valid = "valid", e.submitting = "submitting", e.reset = "reset", e.updated = "updated", e.unknown = "unknown", e))(x || {});
+function Z(e, i = {}) {
+  const a = (u) => {
+    let o = u;
+    for (; o instanceof re; )
+      o = o.innerType();
+    return o instanceof ae && (o = o._def.innerType), o;
+  }, v = (u) => {
+    let o = u;
+    for (; o instanceof re; )
+      o = o.innerType();
+    return o instanceof ae;
+  }, n = a(e);
   return {
-    ...(o instanceof Z ? o._def.unknownKeys === "passthrough" : !1) ? s : {},
+    ...(n instanceof K ? n._def.unknownKeys === "passthrough" : !1) ? i : {},
     ...Object.fromEntries(
-      Object.entries(o.shape).map(
-        ([r, l]) => {
-          const n = s[r];
-          let f = t(l), a;
-          if (f instanceof ue && (a = f._def.defaultValue(), f = f._def.innerType), n === null && f instanceof le)
-            return [r, n];
-          if (f instanceof se) {
-            const v = l.safeParse(n);
-            if (v.success)
-              return [r, v.data ?? a];
+      Object.entries(n.shape).map(
+        ([u, o]) => {
+          const r = i[u], p = v(o);
+          let d = a(o), c;
+          if (d instanceof he && (c = d._def.defaultValue(), d = d._def.innerType), r === null && d instanceof be)
+            return [u, r];
+          if (r == null && p)
+            return [u, c];
+          if (d instanceof ge) {
+            const m = o.safeParse(r);
+            if (m.success)
+              return [u, m.data ?? c];
           }
-          if (f instanceof ie && Array.isArray(n) && n.length) {
-            const v = t(f._def.type);
-            if (v instanceof Z)
+          if (d instanceof Ve && Array.isArray(r) && r.length) {
+            const m = a(d._def.type);
+            if (m instanceof K)
               return [
-                r,
-                n.map(
-                  (b) => K(
-                    v,
-                    b && typeof b == "object" ? b : void 0
+                u,
+                r.map(
+                  (j) => Z(
+                    m,
+                    j && typeof j == "object" ? j : void 0
                   )
-                ) ?? a
+                )
               ];
           }
-          return f instanceof Z ? [
-            r,
-            K(
-              f,
-              n && typeof n == "object" ? n : a
+          if (d instanceof we && r) {
+            const m = a(d._def.valueType);
+            if (m instanceof K)
+              return [u, Object.keys(r).reduce((j, y) => (j[y] = Z(m, r[y]), j), {})];
+          }
+          return d instanceof K ? [
+            u,
+            Z(
+              d,
+              r && typeof r == "object" ? r : c
             )
-          ] : [r, a];
+          ] : [u, c];
         }
       )
     )
   };
-}, he = (e, s, t, o) => {
-  const u = $(), r = $(), l = w(() => r.value === k.invalid), n = $(), f = $(!1), a = async (c = n.value) => {
-    if (f.value)
+}
+function je(e, i, a, v, n) {
+  const l = L(), u = L(), o = O(() => u.value === x.invalid), r = L(), p = L(!1);
+  let d;
+  const c = (D) => {
+    const S = Z(e, D);
+    if (a?.class) {
+      const t = a.class;
+      return new t(S);
+    }
+    return S;
+  }, m = async (D = r.value, S) => {
+    if (d = S?.fields, p.value)
       return !0;
-    const h = await e.safeParseAsync(c);
-    return h.success ? (u.value = void 0, r.value = k.valid, n.value = h.data, !0) : (u.value = h.error.format(), r.value = k.invalid, !1);
-  }, v = async () => f.value || !await a() ? !1 : (r.value = k.submitting, !0), { ignoreUpdates: b, stop: g } = ae(
-    n,
+    const t = S?.superRefine ? await e.superRefine(S.superRefine).safeParseAsync(D) : await e.safeParseAsync(D);
+    if (!t.success) {
+      if (u.value = x.invalid, !d?.size)
+        return l.value = t.error.format(), !1;
+      const V = t.error.issues.filter(
+        ($) => d?.has($.path.join("."))
+      );
+      return V.length ? (l.value = new De(V).format(), !1) : (l.value = void 0, !0);
+    }
+    return l.value = void 0, u.value = x.valid, r.value = c(t.data), !0;
+  }, j = () => {
+    l.value = void 0, u.value = void 0, d = void 0;
+  }, y = () => {
+    r.value = c(), j(), u.value = x.reset;
+  }, f = async (D) => p.value || !await m(void 0, D) ? !1 : (u.value = x.submitting, !0), { ignoreUpdates: b, stop: g } = pe(
+    r,
     () => {
-      r.value = k.updated;
+      u.value = x.updated;
     },
     {
       deep: !0,
-      eventFilter: ne((t == null ? void 0 : t.updateThrottle) ?? 500)
+      eventFilter: ye(a?.updateThrottle ?? 500)
     }
-  ), V = z({
+  ), I = G(l), R = G(u), k = C({
     name: "VvForm",
     props: {
-      continuosValidation: {
+      continuousValidation: {
         type: Boolean,
         default: !1
       },
@@ -340,7 +109,7 @@ const me = (e, s, t, o) => z({
       },
       readonly: {
         type: Boolean,
-        default: (t == null ? void 0 : t.readonly) ?? !1
+        default: a?.readonly ?? !1
       },
       tag: {
         type: String,
@@ -349,365 +118,947 @@ const me = (e, s, t, o) => z({
       template: {
         type: [Array, Function],
         default: void 0
+      },
+      superRefine: {
+        type: Function,
+        default: void 0
+      },
+      validateFields: {
+        type: Array,
+        default: void 0
       }
     },
     emits: [
       "invalid",
-      "valid",
       "submit",
       "update:modelValue",
-      "update:readonly"
+      "update:readonly",
+      "valid",
+      "reset"
     ],
     expose: [
-      "submit",
-      "validate",
       "errors",
+      "invalid",
+      "readonly",
       "status",
+      "submit",
+      "tag",
+      "template",
       "valid",
-      "invalid",
-      "readonly"
+      "validate",
+      "clear",
+      "reset"
     ],
-    setup(c, { emit: h }) {
-      return n.value = K(
-        e,
-        A(c.modelValue)
-      ), p(
-        () => c.modelValue,
-        (m) => {
-          if (m) {
-            const y = ee(m) ? A(m) : m;
-            if (JSON.stringify(y) === JSON.stringify(A(n.value)))
+    slots: Object,
+    setup(D, { emit: S }) {
+      return r.value = c(B(D.modelValue)), A(
+        () => D.modelValue,
+        (t) => {
+          if (t) {
+            const V = ve(t) ? B(t) : t;
+            if (JSON.stringify(V) === JSON.stringify(B(r.value)))
               return;
-            n.value = typeof (y == null ? void 0 : y.clone) == "function" ? y.clone() : JSON.parse(JSON.stringify(y));
+            r.value = typeof V?.clone == "function" ? V.clone() : JSON.parse(JSON.stringify(V));
           }
         },
         { deep: !0 }
-      ), p(r, async (m) => {
-        var y, x, I, U, N;
-        if (m === k.invalid) {
-          const i = A(
-            u.value
+      ), A(u, async (t) => {
+        if (t === x.invalid) {
+          const V = B(l.value);
+          S("invalid", V), a?.onInvalid?.(
+            V
           );
-          h("invalid", i), (y = t == null ? void 0 : t.onInvalid) == null || y.call(t, i);
           return;
         }
-        if (m === k.valid) {
-          const i = A(n.value);
-          h("valid", i), (x = t == null ? void 0 : t.onValid) == null || x.call(t, i), h("update:modelValue", i), (I = t == null ? void 0 : t.onUpdate) == null || I.call(t, i);
+        if (t === x.valid) {
+          const V = B(r.value);
+          S("valid", V), a?.onValid?.(V), S("update:modelValue", V), a?.onUpdate?.(V);
           return;
         }
-        if (m === k.submitting) {
-          const i = A(n.value);
-          h("submit", i), (U = t == null ? void 0 : t.onSubmit) == null || U.call(t, i);
+        if (t === x.submitting) {
+          const V = B(r.value);
+          S("submit", V), a?.onSubmit?.(V);
+          return;
         }
-        if (m === k.updated) {
-          if ((u.value || t != null && t.continuosValidation || c.continuosValidation) && await a(), !n.value || !c.modelValue || JSON.stringify(n.value) !== JSON.stringify(c.modelValue)) {
-            const i = A(
-              n.value
-            );
-            h("update:modelValue", i), (N = t == null ? void 0 : t.onUpdate) == null || N.call(t, i);
+        if (t === x.reset) {
+          const V = B(r.value);
+          S("reset", V), a?.onReset?.(V);
+          return;
+        }
+        if (t === x.updated) {
+          if ((l.value || a?.continuousValidation || D.continuousValidation) && await m(void 0, {
+            superRefine: D.superRefine,
+            fields: d ?? new Set(D.validateFields)
+          }), !r.value || !D.modelValue || JSON.stringify(r.value) !== JSON.stringify(D.modelValue)) {
+            const V = B(r.value);
+            S("update:modelValue", V), a?.onUpdate?.(V);
           }
-          r.value === k.updated && (r.value = k.unknown);
+          u.value === x.updated && (u.value = x.unknown);
         }
-      }), P(() => {
-        f.value = c.readonly;
-      }), p(
-        () => c.readonly,
-        (m) => {
-          f.value = m;
+      }), q(() => {
+        p.value = D.readonly;
+      }), A(
+        () => D.readonly,
+        (t) => {
+          p.value = t;
         }
-      ), p(f, (m) => {
-        m !== c.readonly && h("update:readonly", f.value);
-      }), M(s, {
-        formData: n,
-        submit: v,
-        validate: a,
+      ), A(p, (t) => {
+        t !== D.readonly && S("update:readonly", p.value);
+      }), T(i, {
+        clear: j,
+        errors: I,
+        formData: r,
         ignoreUpdates: b,
+        invalid: o,
+        readonly: p,
+        reset: y,
+        status: R,
         stopUpdatesWatch: g,
-        errors: E(u),
-        status: E(r),
-        invalid: l,
-        readonly: f
+        submit: f,
+        validate: m,
+        wrappers: n
       }), {
-        formData: n,
-        submit: v,
-        validate: a,
+        clear: j,
+        errors: I,
+        formData: r,
         ignoreUpdates: b,
+        invalid: o,
+        isReadonly: p,
+        reset: y,
+        status: R,
         stopUpdatesWatch: g,
-        errors: E(u),
-        status: E(r),
-        invalid: l,
-        isReadonly: f
+        submit: () => f({
+          superRefine: D.superRefine,
+          fields: new Set(D.validateFields)
+        }),
+        validate: m,
+        wrappers: n
       };
     },
     render() {
-      const c = () => {
-        var h, m;
-        return ((m = (h = this.$slots) == null ? void 0 : h.default) == null ? void 0 : m.call(h, {
-          formData: this.formData,
-          submit: this.submit,
-          validate: this.validate,
-          ignoreUpdates: this.ignoreUpdates,
-          stopUpdatesWatch: this.stopUpdatesWatch,
-          errors: this.errors,
-          status: this.status,
-          invalid: this.invalid,
-          readonly: this.isReadonly
-        })) ?? this.$slots.default;
-      };
-      return O(
+      const D = () => this.$slots?.default?.({
+        errors: I.value,
+        formData: r.value,
+        invalid: o.value,
+        readonly: p.value,
+        status: R.value,
+        wrappers: n,
+        clear: j,
+        ignoreUpdates: b,
+        reset: y,
+        stopUpdatesWatch: g,
+        submit: f,
+        validate: m
+      }) ?? this.$slots.default;
+      return F(
         this.tag,
         {
-          onSubmit: re(this.submit, ["prevent"])
+          onSubmit: te(this.submit, ["prevent"]),
+          onReset: te(this.reset, ["prevent"])
         },
-        (this.template ?? (t == null ? void 0 : t.template)) && o ? [
-          O(
-            o,
+        (this.template ?? a?.template) && v ? [
+          F(
+            v,
             {
-              schema: this.template ?? (t == null ? void 0 : t.template)
+              schema: this.template ?? a?.template
             },
             {
-              default: c
+              default: D
             }
           )
         ] : {
-          default: c
+          default: D
         }
       );
     }
   });
   return {
-    errors: u,
-    status: r,
-    invalid: l,
-    readonly: f,
-    formData: n,
-    validate: a,
-    submit: v,
+    clear: j,
+    errors: l,
+    formData: r,
     ignoreUpdates: b,
+    invalid: o,
+    readonly: p,
+    reset: y,
+    status: u,
+    wrappers: n,
     stopUpdatesWatch: g,
-    /**
-     * An hack to add types to the default slot
-     */
-    VvForm: V
+    submit: f,
+    validate: m,
+    VvForm: k
   };
-}, ye = (e, s) => z({
-  name: "VvFormWrapper",
-  props: {
-    name: {
-      type: String,
-      required: !0
+}
+function H(e) {
+  return Array.isArray(e);
+}
+function Oe(e) {
+  return !1;
+}
+function ne(e) {
+  return e === null;
+}
+function le(e) {
+  return typeof e == "object";
+}
+function ue(e) {
+  return typeof e == "string";
+}
+function z(e) {
+  return typeof e > "u";
+}
+const Se = /^[0-9]+$/, Re = ["__proto__", "prototype", "constructor"];
+function N(e, i, a) {
+  const v = Oe() ? a : void 0;
+  if (!le(e) || !ue(i))
+    return v;
+  const n = ie(i);
+  if (n.length !== 0) {
+    for (const l of n) {
+      if (l === "*")
+        continue;
+      const u = function(o) {
+        return o.map((r) => z(r) || ne(r) ? r : H(r) ? u(r) : r[l]);
+      };
+      if (H(e) && !Se.test(l) ? e = u(e) : e = e[l], z(e) || ne(e))
+        break;
+    }
+    return z(e) ? v : e;
+  }
+}
+function X(e, i, a) {
+  if (!le(e) || !ue(i))
+    return;
+  const v = ie(i);
+  if (v.length === 0)
+    return;
+  const n = v.length;
+  for (let l = 0; l < n; l++) {
+    const u = v[l];
+    if (l === n - 1) {
+      e[u] = a;
+      return;
+    }
+    if (u === "*" && H(e)) {
+      const o = v.slice(l + 1).join(".");
+      for (const r of e)
+        X(r, o, a);
+      return;
+    }
+    z(e[u]) && (e[u] = {}), e = e[u];
+  }
+}
+function ie(e) {
+  const i = e.split(/[.]|(?:\[(\d|\*)\])/).filter((a) => !!a);
+  return i.some((a) => Re.indexOf(a) !== -1) ? [] : i;
+}
+function xe(e, i, a, v) {
+  return C({
+    name: "VvFormField",
+    props: {
+      type: {
+        type: String,
+        validator: (n) => Object.values(w).includes(n),
+        default: w.custom
+      },
+      is: {
+        type: [Object, String],
+        default: void 0
+      },
+      name: {
+        type: [String, Number, Boolean, Symbol],
+        required: !0
+      },
+      props: {
+        type: [Object, Function],
+        default: () => ({})
+      },
+      showValid: {
+        type: Boolean,
+        default: !1
+      },
+      defaultValue: {
+        type: [String, Number, Boolean, Array, Object],
+        default: void 0
+      },
+      lazyLoad: {
+        type: Boolean,
+        default: !1
+      },
+      readonly: {
+        type: Boolean,
+        default: void 0
+      }
+    },
+    emits: [
+      "invalid",
+      "update:formData",
+      "update:modelValue",
+      "valid"
+    ],
+    expose: [
+      "component",
+      "errors",
+      "hasProps",
+      "invalid",
+      "invalidLabel",
+      "is",
+      "type"
+    ],
+    slots: Object,
+    setup(n, { slots: l, emit: u }) {
+      const { props: o, name: r } = Q(n), p = oe(), d = U(i, void 0);
+      d && d.fields.value.set(p, n.name);
+      const c = U(e), m = O({
+        get() {
+          if (c?.formData)
+            return N(
+              new Object(c.formData.value),
+              String(n.name)
+            );
+        },
+        set(t) {
+          c?.formData && (X(
+            new Object(c.formData.value),
+            String(n.name),
+            t
+          ), u("update:modelValue", {
+            newValue: m.value,
+            formData: c?.formData
+          }));
+        }
+      });
+      q(() => {
+        m.value === void 0 && n.defaultValue !== void 0 && (m.value = n.defaultValue);
+      }), P(() => {
+        d && d.fields.value.delete(p);
+      });
+      const j = O(() => {
+        if (c?.errors.value)
+          return N(c.errors.value, String(n.name));
+      }), y = O(() => j.value?._errors), f = O(() => j.value !== void 0), b = A(f, (t) => {
+        if (t) {
+          u("invalid", j.value), d && d.errors.value.set(
+            String(n.name),
+            j.value
+          );
+          return;
+        }
+        u("valid", m.value), d && d.errors.value.delete(
+          n.name
+        );
+      }), g = A(
+        () => c?.formData,
+        () => {
+          u("update:formData", c?.formData);
+        },
+        { deep: !0 }
+      );
+      P(() => {
+        b(), g();
+      });
+      const I = (t) => {
+        t instanceof InputEvent && (t = t.target.value), m.value = t;
+      }, R = O(() => {
+        let t = o.value;
+        return typeof t == "function" && (t = t(c?.formData)), Object.keys(t).reduce(
+          (V, $) => (V[$] = _(t[$]), V),
+          {}
+        );
+      }), k = O(() => c?.readonly.value || d?.readonly.value ? !0 : R.value.readonly ?? n.readonly), D = O(() => ({
+        ...R.value,
+        name: R.value.name ?? n.name,
+        invalid: f.value,
+        valid: n.showValid ? !!(!f.value && m.value) : void 0,
+        type: ((t) => {
+          if ([
+            w.color,
+            w.date,
+            w.datetimeLocal,
+            w.email,
+            w.month,
+            w.number,
+            w.password,
+            w.search,
+            w.tel,
+            w.text,
+            w.time,
+            w.url,
+            w.week
+          ].includes(t))
+            return t;
+        })(n.type),
+        invalidLabel: y.value,
+        modelValue: m.value,
+        readonly: k.value,
+        "onUpdate:modelValue": I
+      }));
+      return T(a, {
+        name: G(r),
+        errors: G(j)
+      }), { component: O(() => {
+        if (n.type === w.custom)
+          return {
+            render() {
+              return l.default?.({
+                errors: j.value,
+                formData: c?.formData.value,
+                formErrors: c?.errors.value,
+                invalid: f.value,
+                invalidLabel: y.value,
+                modelValue: m.value,
+                readonly: k.value,
+                onUpdate: I,
+                submit: c?.submit,
+                validate: c?.validate
+              }) ?? l.default;
+            }
+          };
+        if (!(v?.lazyLoad ?? n.lazyLoad)) {
+          let t;
+          switch (n.type) {
+            case w.select:
+              t = W("VvSelect");
+              break;
+            case w.checkbox:
+              t = W("VvCheckbox");
+              break;
+            case w.radio:
+              t = W("VvRadio");
+              break;
+            case w.textarea:
+              t = W("VvTextarea");
+              break;
+            case w.radioGroup:
+              t = W("VvRadioGroup");
+              break;
+            case w.checkboxGroup:
+              t = W("VvCheckboxGroup");
+              break;
+            case w.combobox:
+              t = W("VvCombobox");
+              break;
+            default:
+              t = W("VvInputText");
+          }
+          if (typeof t != "string")
+            return t;
+          console.warn(
+            `[@volverjs/form-vue]: ${t} not found, the component will be loaded asynchronously. To avoid this warning, please set "lazyLoad" option.`
+          );
+        }
+        return ce(async () => {
+          switch (v?.sideEffects && await Promise.resolve(v.sideEffects(n.type)), n.type) {
+            case w.textarea:
+              return import("@volverjs/ui-vue/vv-textarea");
+            case w.radio:
+              return import("@volverjs/ui-vue/vv-radio");
+            case w.radioGroup:
+              return import("@volverjs/ui-vue/vv-radio-group");
+            case w.checkbox:
+              return import("@volverjs/ui-vue/vv-checkbox");
+            case w.checkboxGroup:
+              return import("@volverjs/ui-vue/vv-checkbox-group");
+            case w.select:
+              return import("@volverjs/ui-vue/vv-select");
+            case w.combobox:
+              return import("@volverjs/ui-vue/vv-combobox");
+          }
+          return import("@volverjs/ui-vue/vv-input-text");
+        });
+      }), hasProps: D, invalid: f };
     },
-    tag: {
-      type: String,
-      default: void 0
+    render() {
+      return this.is ? F(this.is, this.hasProps, this.$slots) : this.type === w.custom ? F(this.component, null, this.$slots) : F(this.component, this.hasProps, this.$slots);
     }
-  },
-  emits: ["invalid", "valid"],
-  expose: ["fields", "invalid"],
-  setup(o, { emit: u }) {
-    const r = B(e), l = B(s, void 0), n = $(/* @__PURE__ */ new Set()), f = $(/* @__PURE__ */ new Map()), { name: a } = H(o);
-    M(s, {
-      name: E(a),
-      errors: f,
-      fields: n
-    }), p(
-      n,
-      (b) => {
-        l != null && l.fields && b.forEach((g) => {
-          l == null || l.fields.value.add(g);
+  });
+}
+function Ie(e, i, a) {
+  return C({
+    name: "VvFormFieldsGroup",
+    props: {
+      is: {
+        type: [Object, String],
+        default: void 0
+      },
+      names: {
+        type: [Array, Object],
+        required: !0
+      },
+      props: {
+        type: [Object, Function],
+        default: () => ({})
+      },
+      showValid: {
+        type: Boolean,
+        default: !1
+      },
+      defaultValues: {
+        type: [Object],
+        default: void 0
+      },
+      readonly: {
+        type: Boolean,
+        default: void 0
+      }
+    },
+    emits: [
+      "invalid",
+      "update:formData",
+      "update:modelValue",
+      "valid"
+    ],
+    expose: [
+      "component",
+      "errors",
+      "hasProps",
+      "invalid",
+      "invalidLabels",
+      "is"
+    ],
+    slots: Object,
+    setup(v, { slots: n, emit: l }) {
+      const { props: u, names: o, defaultValues: r } = Q(v), p = oe(), d = O(() => Array.isArray(o.value) ? o.value : Object.values(o.value)), c = O(() => Array.isArray(o.value) ? o.value : Object.keys(o.value)), m = O(() => Array.isArray(o.value) ? o.value.reduce((s, h) => (s[String(h)] = h, s), {}) : o.value), j = O(() => Object.keys(m.value).reduce((s, h) => (s[String(m.value[h])] = h, s), {})), y = U(i, void 0);
+      y && d.value.forEach((s) => {
+        y.fields.value.set(`${p}-${s}`, s);
+      });
+      const f = U(e), b = O({
+        get() {
+          return f?.formData ? c.value.reduce((s, h) => (s[h] = N(
+            new Object(f.formData.value),
+            m.value[h]
+          ), s), {}) : {};
+        },
+        set(s) {
+          f?.formData && (c.value.forEach((h) => {
+            X(
+              new Object(f.formData.value),
+              m.value[h],
+              s?.[h]
+            );
+          }), l("update:modelValue", {
+            newValue: b.value,
+            formData: f?.formData
+          }));
+        }
+      });
+      q(() => {
+        r.value && d.value.forEach((s) => {
+          r.value?.[s] !== void 0 && b.value[s] === void 0 && (b.value = {
+            ...b.value,
+            [s]: r.value?.[s]
+          });
+        });
+      }), P(() => {
+        y && d.value.forEach((s) => {
+          y.fields.value.delete(
+            `${p}-${s}`
+          );
         });
+      });
+      const g = O(() => {
+        if (!f?.errors.value)
+          return;
+        const s = d.value.reduce((h, E) => {
+          if (!f.errors.value)
+            return h;
+          const ee = N(f.errors.value, String(E));
+          return ee === void 0 || (h[String(E)] = ee), h;
+        }, {});
+        if (Object.keys(s).length !== 0)
+          return s;
+      }), I = O(() => {
+        if (!g.value)
+          return;
+        const s = Object.keys(g.value).reduce((h, E) => (g.value?.[E] && (h[j.value[E]] = g.value[E]._errors), h), {});
+        if (Object.keys(s).length !== 0)
+          return s;
+      }), R = O(() => g.value !== void 0), k = O(() => c.value.reduce((s, h) => (s[h] = !!g.value?.[j.value[h]], s), {})), D = A(R, () => {
+        if (R.value) {
+          l("invalid", g.value), y && d.value.forEach((s) => {
+            if (!g.value?.[s]) {
+              y.errors.value.delete(
+                s
+              );
+              return;
+            }
+            y.errors.value.set(
+              s,
+              g.value?.[s]
+            );
+          });
+          return;
+        }
+        l("valid", b.value), y && d.value.forEach((s) => {
+          y.errors.value.delete(
+            s
+          );
+        });
+      }), S = A(
+        () => f?.formData,
+        () => {
+          l("update:formData", f?.formData);
+        },
+        { deep: !0 }
+      );
+      P(() => {
+        D(), S();
+      });
+      const t = (s) => {
+        b.value = s;
+      }, V = (s, h) => {
+        h instanceof InputEvent && (h = h.target.value), c.value.includes(s) && (b.value = {
+          ...b.value,
+          [s]: h
+        });
+      }, $ = O(() => {
+        let s = u.value;
+        return typeof s == "function" && (s = s(f?.formData)), Object.keys(s).reduce(
+          (h, E) => (h[E] = _(s[E]), h),
+          {}
+        );
+      }), Y = O(() => f?.readonly.value ? !0 : $.value.readonly ?? v.readonly), de = O(() => c.value.reduce((s, h) => (s[`onUpdate:${h}`] = (E) => {
+        V(h, E);
+      }, s), {
+        "onUpdate:modelValue": t
+      })), fe = O(() => ({
+        ...de.value,
+        ...$.value,
+        names: $.value.name ?? d.value,
+        invalid: R.value,
+        invalids: k.value,
+        valid: v.showValid ? !!(!R.value && b.value) : void 0,
+        invalidLabels: I.value,
+        modelValue: b.value,
+        readonly: Y.value
+      }));
+      return T(a, {
+        names: G(o),
+        errors: G(g)
+      }), { component: O(() => ({
+        render() {
+          return n.default?.({
+            errors: g.value,
+            formData: f?.formData.value,
+            formErrors: f?.errors.value,
+            invalid: R.value,
+            invalids: k.value,
+            invalidLabels: I.value,
+            modelValue: b.value,
+            onUpdate: t,
+            onUpdateField: V,
+            readonly: Y.value,
+            submit: f?.submit,
+            validate: f?.validate
+          }) ?? n.default;
+        }
+      })), hasProps: fe, invalid: R };
+    },
+    render() {
+      return this.is ? F(this.is, this.hasProps, this.$slots) : F(this.component, null, this.$slots);
+    }
+  });
+}
+function Fe(e, i) {
+  return C({
+    name: "VvFormWrapper",
+    props: {
+      name: {
+        type: String,
+        required: !0
       },
-      { deep: !0 }
-    ), p(
-      () => new Map(f.value),
-      (b, g) => {
-        l != null && l.errors && (Array.from(g.keys()).forEach((V) => {
-          l.errors.value.delete(V);
-        }), Array.from(b.keys()).forEach((V) => {
-          const c = b.get(V);
-          c && l.errors.value.set(V, c);
-        }));
+      tag: {
+        type: String,
+        default: void 0
       },
-      { deep: !0 }
-    );
-    const v = w(() => r != null && r.invalid.value ? f.value.size > 0 : !1);
-    return p(v, () => {
-      v.value ? u("invalid") : u("valid");
-    }), {
-      formData: r == null ? void 0 : r.formData,
-      errors: r == null ? void 0 : r.errors,
-      submit: r == null ? void 0 : r.submit,
-      validate: r == null ? void 0 : r.validate,
-      invalid: v,
-      fields: n,
-      fieldsErrors: f
-    };
-  },
-  render() {
-    var o, u;
-    return this.tag ? O(this.tag, null, {
-      default: () => {
-        var r, l;
-        return ((l = (r = this.$slots).default) == null ? void 0 : l.call(r, {
-          invalid: this.invalid,
-          formData: this.formData,
-          submit: this.submit,
-          validate: this.validate,
-          errors: this.errors,
-          fieldsErrors: this.fieldsErrors
-        })) ?? this.$slots.defalut;
+      readonly: {
+        type: Boolean,
+        default: !1
       }
-    }) : ((u = (o = this.$slots).default) == null ? void 0 : u.call(o, {
-      invalid: this.invalid,
-      formData: this.formData,
-      submit: this.submit,
-      validate: this.validate,
-      errors: this.errors,
-      fieldsErrors: this.fieldsErrors
-    })) ?? this.$slots.defalut;
-  }
-}), be = (e, s) => {
-  const t = z({
+    },
+    emits: ["invalid", "valid"],
+    expose: [
+      "clear",
+      "errors",
+      "fields",
+      "fieldsErrors",
+      "formData",
+      "invalid",
+      "readonly",
+      "reset",
+      "submit",
+      "tag",
+      "validate",
+      "validateWrapper"
+    ],
+    slots: Object,
+    setup(a, { emit: v }) {
+      const n = U(e), l = U(i, void 0), u = L(/* @__PURE__ */ new Map()), o = L(/* @__PURE__ */ new Map()), { name: r } = Q(a), p = O(() => n?.invalid.value ? o.value.size > 0 : !1);
+      A(p, (y) => {
+        if (y) {
+          v("invalid");
+          return;
+        }
+        v("valid");
+      });
+      const d = O(() => n?.readonly.value || a.readonly), c = {
+        name: G(r),
+        errors: o,
+        invalid: G(p),
+        readonly: G(d),
+        fields: u
+      };
+      T(i, c);
+      const m = O(() => new Map(u.value));
+      A(
+        m,
+        (y, f) => {
+          l?.fields && (f.forEach((b, g) => {
+            y.has(g) || l?.fields.value.delete(g);
+          }), y.forEach((b, g) => {
+            l?.fields.value.has(g) || l?.fields.value.set(g, b);
+          }));
+        },
+        { deep: !0 }
+      ), A(
+        o,
+        (y) => {
+          l?.errors && u.value.forEach((f) => {
+            if (y.has(f) || l.errors.value.delete(f), y.has(f)) {
+              const b = y.get(f);
+              b && l.errors.value.set(f, b);
+            }
+          });
+        },
+        { deep: !0 }
+      ), q(() => {
+        if (!n?.wrappers || !r.value) {
+          console.warn("[@volverjs/form-vue]: Invalid wrapper registration state");
+          return;
+        }
+        if (n.wrappers.has(r.value)) {
+          console.warn(`[@volverjs/form-vue]: wrapper name "${r.value}" is already used`);
+          return;
+        }
+        n.wrappers.set(r.value, c);
+      }), P(() => {
+        n?.wrappers && r.value && n.wrappers.delete(r.value);
+      });
+      const j = () => n?.validate(void 0, { fields: new Set(u.value.values()) }) ?? Promise.resolve(!0);
+      return {
+        errors: n?.errors,
+        fields: u,
+        fieldsErrors: o,
+        formData: n?.formData,
+        invalid: p,
+        readonly: d,
+        clear: n?.clear,
+        reset: n?.reset,
+        submit: n?.submit,
+        validate: n?.validate,
+        validateWrapper: j
+      };
+    },
+    render() {
+      const a = () => this.$slots.default?.({
+        errors: this.errors,
+        fieldsErrors: this.fieldsErrors,
+        formData: this.formData,
+        invalid: this.invalid,
+        readonly: this.readonly,
+        clear: this.clear,
+        reset: this.reset,
+        submit: this.submit,
+        validate: this.validate,
+        validateWrapper: this.validateWrapper
+      });
+      return this.tag ? F(this.tag, null, {
+        default: a
+      }) : a();
+    }
+  });
+}
+function ke(e, i) {
+  const a = C({
     name: "VvFormTemplate",
     props: {
       schema: {
         type: [Array, Function],
         required: !0
+      },
+      scope: {
+        type: Object,
+        default: () => ({})
       }
     },
-    setup(o, { slots: u }) {
-      const r = B(e);
-      if (r != null && r.formData)
+    slots: Object,
+    setup(v, { slots: n }) {
+      const l = U(e);
+      if (l?.formData)
         return () => {
-          var a;
-          const l = typeof o.schema == "function" ? o.schema(r) : o.schema;
-          let n;
-          const f = l.reduce((v, b) => {
-            const g = typeof b == "function" ? b(r) : b, {
-              vvIs: V,
-              vvName: c,
-              vvSlots: h,
-              vvChildren: m,
-              vvIf: y,
-              vvElseIf: x,
+          const u = typeof v.schema == "function" ? v.schema(
+            l,
+            v.scope
+          ) : v.schema;
+          let o;
+          const r = u.reduce((p, d) => {
+            const c = typeof d == "function" ? d(l, v.scope) : d, {
+              vvIs: m,
+              vvName: j,
+              vvSlots: y,
+              vvChildren: f,
+              vvIf: b,
+              vvElseIf: g,
               vvType: I,
-              vvDefaultValue: U,
-              vvShowValid: N,
-              vvContent: i,
-              ..._
-            } = g;
-            if (y !== void 0) {
-              if (typeof y == "string" ? n = !!L(
-                Object(r.formData.value),
-                y
-              ) : typeof y == "function" ? n = C(y(r)) : n = C(y), !n)
-                return v;
-            } else if (x !== void 0 && n !== void 0) {
-              if (n || (typeof x == "string" ? n = !!L(
-                Object(r.formData.value),
-                x
-              ) : typeof x == "function" ? n = C(x(r)) : n = C(x), !n))
-                return v;
+              vvDefaultValue: R,
+              vvShowValid: k,
+              vvContent: D,
+              ...S
+            } = c;
+            if (b !== void 0) {
+              if (typeof b == "string" ? o = !!N(
+                new Object(l.formData.value),
+                b
+              ) : typeof b == "function" ? o = _(b(l)) : o = _(b), !o)
+                return p;
+            } else if (g !== void 0 && o !== void 0) {
+              if (o || (typeof g == "string" ? o = !!N(
+                new Object(l.formData.value),
+                g
+              ) : typeof g == "function" ? o = _(g(l)) : o = _(g), !o))
+                return p;
             } else
-              n = void 0;
-            const W = m ? O(t, {
-              schema: m
-            }) : void 0;
-            return c ? (v.push(
-              O(
-                s,
+              o = void 0;
+            let t;
+            return f && (typeof m == "string" ? t = F(a, {
+              schema: f
+            }) : t = {
+              default: (V) => F(a, {
+                schema: f,
+                scope: V
+              })
+            }), j ? (p.push(
+              F(
+                i,
                 {
-                  name: c,
-                  is: V,
+                  name: j,
+                  is: m,
                   type: I,
-                  defaultValue: U,
-                  showValid: N,
-                  props: _
+                  defaultValue: R,
+                  showValid: k,
+                  props: S
                 },
-                h ?? W ?? i
+                y ?? t ?? D
               )
-            ), v) : V ? (v.push(
-              O(
-                V,
-                _,
-                h ?? W ?? i
+            ), p) : m ? (p.push(
+              F(
+                m,
+                S,
+                y ?? t ?? D
               )
-            ), v) : (m && v.push(W), v);
+            ), p) : (t && ("default" in t ? p.push(t.default(v.scope)) : p.push(t)), p);
           }, []);
-          return f.push(
-            (a = u == null ? void 0 : u.default) == null ? void 0 : a.call(u, {
-              formData: r == null ? void 0 : r.formData.value,
-              submit: r == null ? void 0 : r.submit,
-              validate: r == null ? void 0 : r.validate,
-              errors: r == null ? void 0 : r.errors.value,
-              status: r == null ? void 0 : r.status.value,
-              invalid: r == null ? void 0 : r.invalid.value
+          return r.push(
+            n?.default?.({
+              errors: l?.errors.value,
+              formData: l?.formData.value,
+              invalid: l?.invalid.value,
+              status: l?.status.value,
+              submit: l?.submit,
+              validate: l?.validate,
+              clear: l?.clear,
+              reset: l?.reset
             })
-          ), f;
+          ), r;
         };
     }
   });
-  return t;
-}, R = (e, s = {}) => {
-  const t = Symbol(), o = Symbol(), u = Symbol(), r = ye(
-    t,
-    o
-  ), l = me(
-    t,
-    o,
-    u,
-    s
-  ), n = be(t, l), {
-    VvForm: f,
-    errors: a,
-    status: v,
-    invalid: b,
-    readonly: g,
-    formData: V,
-    validate: c,
-    submit: h,
-    ignoreUpdates: m,
-    stopUpdatesWatch: y
-  } = he(e, t, s, n);
+  return a;
+}
+function J(e, i = {}) {
+  const a = Symbol("formInjectionKey"), v = Symbol("formWrapperInjectionKey"), n = Symbol("formFieldInjectionKey"), l = Symbol("formFieldsGroupInjectionKey"), u = Fe(
+    a,
+    v
+  ), o = xe(
+    a,
+    v,
+    n,
+    i
+  ), r = Ie(
+    a,
+    v,
+    l
+  ), p = ke(a, o), d = /* @__PURE__ */ new Map(), {
+    clear: c,
+    errors: m,
+    formData: j,
+    ignoreUpdates: y,
+    invalid: f,
+    readonly: b,
+    reset: g,
+    status: I,
+    stopUpdatesWatch: R,
+    submit: k,
+    validate: D,
+    VvForm: S
+  } = je(e, a, i, p, d);
   return {
-    VvForm: f,
-    VvFormWrapper: r,
-    VvFormField: l,
-    VvFormTemplate: n,
-    formInjectionKey: t,
-    formWrapperInjectionKey: o,
-    formFieldInjectionKey: u,
-    errors: a,
-    status: v,
-    invalid: b,
-    readonly: g,
-    formData: V,
-    validate: c,
-    submit: h,
-    ignoreUpdates: m,
-    stopUpdatesWatch: y
+    clear: c,
+    errors: m,
+    formData: j,
+    formFieldInjectionKey: n,
+    formInjectionKey: a,
+    formWrapperInjectionKey: v,
+    ignoreUpdates: y,
+    invalid: f,
+    readonly: b,
+    reset: g,
+    status: I,
+    stopUpdatesWatch: R,
+    submit: k,
+    validate: D,
+    wrappers: d,
+    VvForm: S,
+    VvFormField: o,
+    VvFormFieldsGroup: r,
+    VvFormTemplate: p,
+    VvFormWrapper: u
   };
-}, D = Symbol(), ke = (e) => {
-  let s = {};
-  return e.schema && (s = R(e.schema, e)), {
-    ...s,
-    install(t, { global: o = !1 } = {}) {
-      t.provide(D, e), o && (t.config.globalProperties.$vvForm = e, s != null && s.VvForm && t.component("VvForm", s.VvForm), s != null && s.VvFormWrapper && t.component("VvFormWrapper", s.VvFormWrapper), s != null && s.VvFormField && t.component("VvFormField", s.VvFormField), s != null && s.VvFormTemplate && t.component("VvFormTemplate", s.VvFormTemplate));
+}
+const se = Symbol("pluginInjectionKey");
+function Be(e) {
+  let i = {};
+  return e.schema && (i = J(e.schema, e)), {
+    ...i,
+    install(a, { global: v = !1 } = {}) {
+      a.provide(se, e), v && (a.config.globalProperties.$vvForm = e, i?.VvForm && a.component("VvForm", i.VvForm), i?.VvFormWrapper && a.component("VvFormWrapper", i.VvFormWrapper), i?.VvFormField && a.component("VvFormField", i.VvFormField), i?.VvFormFieldsGroup && a.component("VvFormFieldsGroup", i.VvFormFieldsGroup), i?.VvFormTemplate && a.component("VvFormTemplate", i.VvFormTemplate));
     }
   };
-}, we = (e, s = {}) => te() ? R(
-  e,
-  {
-    ...B(D, {}),
-    ...s
+}
+const M = /* @__PURE__ */ new Map();
+function We(e, i = {}) {
+  if (i.scope && M.has(i.scope))
+    return M.get(i.scope);
+  if (!me()) {
+    const v = J(e, i);
+    return i.scope && M.set(i.scope, v), v;
   }
-) : R(e, s), pe = (e, s = {}) => R(e, s);
+  const a = J(
+    e,
+    {
+      ...U(se, {}),
+      ...i
+    }
+  );
+  return i.scope && M.set(i.scope, a), a;
+}
+function Ue(e, i = {}) {
+  return J(e, i);
+}
 export {
-  d as FormFieldType,
-  ke as createForm,
-  K as defaultObjectBySchema,
-  pe as formFactory,
-  D as pluginInjectionKey,
-  we as useForm
+  w as FormFieldType,
+  Be as createForm,
+  Z as defaultObjectBySchema,
+  Ue as formType,
+  se as pluginInjectionKey,
+  We as useForm
 };