@effect-app/vue-components 2.11.5 → 3.0.0

package/dist/vue-components.es12.js

@@ -1,8 +1,8 @@
-import { S as i, Option as k } from "effect-app";
+import { S as i, Option as q } from "effect-app";
 import { getMetadataFromSchema as V } from "@effect-app/vue/form";
-import { useIntl as j, getTransformationFrom as U } from "./vue-components.es3.js";
-import { isObject as E } from "./vue-components.es16.js";
-const $ = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKeyword" || n === i.Null.ast), S = (e) => !e || !i.AST.isUnion(e) ? !1 : e.types.find((n) => n._tag === "UndefinedKeyword") ? "undefined" : e.types.find((n) => n === i.Null.ast) ? "null" : !1, _ = (e) => {
+import { useIntl as E, getTransformationFrom as U } from "./vue-components.es3.js";
+import { isObject as $ } from "./vue-components.es16.js";
+const j = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKeyword" || n === i.Null.ast), g = (e) => !e || !i.AST.isUnion(e) ? !1 : e.types.find((n) => n._tag === "UndefinedKeyword") ? "undefined" : e.types.find((n) => n === i.Null.ast) ? "null" : !1, _ = (e) => {
   const n = [];
   for (const t of e)
     if (i.AST.isUnion(t)) {
@@ -20,76 +20,74 @@ const $ = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
     });
   if (t?._tag === "TypeLiteral" && "propertySignatures" in t)
     return y({
-      parent: n,
-      // Pass parent to maintain the key prefix for nested structures
       meta: e,
       propertySignatures: t.propertySignatures
     });
   if (o) {
     for (const s of o) {
-      const a = n ? `${n}.${s.name.toString()}` : s.name.toString(), u = S(s.type);
-      let l;
-      e._isNullableDiscriminatedUnion && s.name.toString() === "_tag" || e.required === !1 ? l = !1 : l = !u;
-      const b = s.type;
+      const l = n ? `${n}.${s.name.toString()}` : s.name.toString(), a = g(s.type);
+      let f;
+      e._isNullableDiscriminatedUnion && s.name.toString() === "_tag" || e.required === !1 ? f = !1 : f = !a;
+      const p = s.type;
       if (i.AST.isUnion(s.type)) {
-        const d = _(s.type.types).filter(
-          (p) => p._tag !== "UndefinedKeyword" && p !== i.Null.ast
+        const c = _(s.type.types).filter(
+          (u) => u._tag !== "UndefinedKeyword" && u !== i.Null.ast
         ).map(U);
-        if (d.some(
-          (p) => "propertySignatures" in p
+        if (c.some(
+          (u) => "propertySignatures" in u
         )) {
-          if (!u) {
-            const p = y({
-              parent: a,
+          if (!a) {
+            const u = y({
+              parent: l,
               property: s.type,
-              meta: { required: l, nullableOrUndefined: u }
+              meta: { required: f, nullableOrUndefined: a }
             });
-            p && typeof p == "object" && !("type" in p) ? Object.assign(r, p) : r[a] = p;
+            r[l] = u;
           }
-          for (const p of d)
-            if ("propertySignatures" in p) {
-              const m = u && d.length > 1;
+          for (const u of c)
+            if ("propertySignatures" in u) {
+              const m = a && c.length > 1;
               Object.assign(
                 r,
                 y({
-                  parent: a,
-                  propertySignatures: p.propertySignatures,
+                  parent: l,
+                  propertySignatures: u.propertySignatures,
                   meta: m ? { _isNullableDiscriminatedUnion: !0 } : {}
                 })
               );
             }
         } else {
-          const p = d.filter(i.AST.isTupleType);
-          if (p.length > 0) {
-            const m = p[0];
-            if (r[a] = {
+          const u = c.filter(i.AST.isTupleType);
+          if (u.length > 0) {
+            const m = u[0];
+            if (r[l] = {
               type: "multiple",
               members: m.elements,
               rest: m.rest,
-              required: l,
-              nullableOrUndefined: u
+              required: f,
+              nullableOrUndefined: a
             }, m.rest && m.rest.length > 0) {
-              const g = m.rest[0];
-              if (g.type._tag === "TypeLiteral" && "propertySignatures" in g.type)
-                for (const c of g.type.propertySignatures) {
-                  const x = `${a}.${c.name.toString()}`, v = y({
-                    parent: x,
-                    property: c.type,
+              const T = m.rest[0];
+              if (T.type._tag === "TypeLiteral" && "propertySignatures" in T.type)
+                for (const d of T.type.propertySignatures) {
+                  const h = `${l}.${d.name.toString()}`, v = y({
+                    parent: h,
+                    property: d.type,
                     meta: {
-                      required: !S(c.type),
-                      nullableOrUndefined: S(c.type)
+                      required: !g(d.type),
+                      nullableOrUndefined: g(d.type)
                     }
                   });
-                  if (v && typeof v == "object" && "type" in v && (r[x] = v, v.type === "multiple" && i.AST.isTupleType(c.type) && c.type.rest && c.type.rest.length > 0)) {
-                    const w = c.type.rest[0];
+                  if (v && typeof v == "object" && "type" in v && (r[h] = v, v.type === "multiple" && i.AST.isTupleType(d.type) && d.type.rest && d.type.rest.length > 0)) {
+                    const w = d.type.rest[0];
                     if (w.type._tag === "TypeLiteral" && "propertySignatures" in w.type)
                       for (const A of w.type.propertySignatures) {
-                        const L = `${x}.${A.name.toString()}`, O = y({
+                        const L = `${h}.${A.name.toString()}`, O = y({
                           parent: L,
                           property: A.type,
                           meta: {
-                            required: !S(A.type),
-                            nullableOrUndefined: S(A.type)
+                            required: !g(A.type),
+                            nullableOrUndefined: g(A.type)
                           }
                         });
                         O && typeof O == "object" && "type" in O && (r[L] = O);
@@ -99,109 +97,109 @@ const $ = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
             }
           } else {
             const m = y({
-              parent: a,
+              parent: l,
               property: s.type,
-              meta: { required: l, nullableOrUndefined: u }
+              meta: { required: f, nullableOrUndefined: a }
             });
-            r[a] = m;
+            r[l] = m;
           }
         }
       } else {
-        const f = U(b);
-        if ("propertySignatures" in f)
+        const S = U(p);
+        if ("propertySignatures" in S)
           Object.assign(
             r,
             y({
-              parent: a,
-              propertySignatures: f.propertySignatures,
-              meta: { required: l, nullableOrUndefined: u }
+              parent: l,
+              propertySignatures: S.propertySignatures,
+              meta: { required: f, nullableOrUndefined: a }
             })
           );
         else if (i.AST.isTupleType(s.type))
           if (s.type.rest.length > 0 && s.type.rest[0].type._tag === "TypeLiteral" && "propertySignatures" in s.type.rest[0].type) {
-            const T = s.type.rest[0].type;
-            if (T._tag === "TypeLiteral" && "propertySignatures" in T)
-              for (const p of T.propertySignatures) {
-                const m = `${a}.${p.name.toString()}`;
-                if (i.AST.isTupleType(p.type) && p.type.rest.length > 0) {
-                  const g = p.type.rest[0].type;
-                  if (g._tag === "TypeLiteral" && "propertySignatures" in g)
-                    for (const c of g.propertySignatures) {
-                      const x = `${m}.${c.name.toString()}`, v = y({
-                        parent: x,
-                        property: c.type,
+            const b = s.type.rest[0].type;
+            if (b._tag === "TypeLiteral" && "propertySignatures" in b)
+              for (const u of b.propertySignatures) {
+                const m = `${l}.${u.name.toString()}`;
+                if (i.AST.isTupleType(u.type) && u.type.rest.length > 0) {
+                  const T = u.type.rest[0].type;
+                  if (T._tag === "TypeLiteral" && "propertySignatures" in T)
+                    for (const d of T.propertySignatures) {
+                      const h = `${m}.${d.name.toString()}`, v = y({
+                        parent: h,
+                        property: d.type,
                         meta: {
-                          required: !S(c.type),
-                          nullableOrUndefined: S(c.type)
+                          required: !g(d.type),
+                          nullableOrUndefined: g(d.type)
                         }
                       });
-                      r[x] = v;
+                      r[h] = v;
                     }
                   else
                     r[m] = {
                       type: "multiple",
-                      members: p.type.elements,
-                      rest: p.type.rest,
-                      required: !S(p.type),
-                      nullableOrUndefined: S(p.type)
+                      members: u.type.elements,
+                      rest: u.type.rest,
+                      required: !g(u.type),
+                      nullableOrUndefined: g(u.type)
                     };
                 } else {
-                  const g = y({
+                  const T = y({
                     parent: m,
-                    property: p.type,
+                    property: u.type,
                     meta: {
-                      required: !S(p.type),
-                      nullableOrUndefined: S(p.type)
+                      required: !g(u.type),
+                      nullableOrUndefined: g(u.type)
                     }
                   });
-                  r[m] = g;
+                  r[m] = T;
                 }
               }
           } else
-            r[a] = {
+            r[l] = {
               type: "multiple",
               members: s.type.elements,
               rest: s.type.rest,
-              required: l,
-              nullableOrUndefined: u
+              required: f,
+              nullableOrUndefined: a
             };
         else {
-          const d = y({
-            parent: a,
+          const c = y({
+            parent: l,
             property: s.type,
             meta: {
               // an empty string is valid for a S.String field, so we should not mark it as required
               // TODO: handle this better via the createMeta minLength parsing
-              required: l && (s.type._tag !== "StringKeyword" || V(s.type).minLength),
-              nullableOrUndefined: u
+              required: f && (s.type._tag !== "StringKeyword" || V(s.type).minLength),
+              nullableOrUndefined: a
             }
           });
-          r[a] = d;
+          r[l] = c;
         }
       }
     }
     return r;
   }
   if (t) {
-    const s = $(t);
+    const s = j(t);
     if (Object.hasOwnProperty.call(e, "required") || (e.required = !s), i.AST.isUnion(t)) {
-      const u = _(t.types), l = u.find(
-        (b) => b._tag !== "UndefinedKeyword" && b !== i.Null.ast
+      const a = _(t.types), f = a.find(
+        (p) => p._tag !== "UndefinedKeyword" && p !== i.Null.ast
       );
-      return "propertySignatures" in l ? y({
-        propertySignatures: l.propertySignatures,
+      return "propertySignatures" in f ? y({
+        propertySignatures: f.propertySignatures,
         parent: n,
         meta: e
-      }) : u.every(i.AST.isLiteral) ? {
+      }) : a.every(i.AST.isLiteral) ? {
         ...e,
         type: "select",
-        members: u.map((b) => b.literal)
+        members: a.map((p) => p.literal)
       } : {
         ...e,
         ...y({
           parent: n,
           meta: e,
-          property: l
+          property: f
         })
       };
     }
@@ -213,7 +211,7 @@ const $ = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
     } : (e = { ...i.AST.getAnnotation(
       t,
       i.AST.JSONSchemaAnnotationId
-    ).pipe(k.getOrElse(() => ({}))), ...e }, "from" in t ? y({
+    ).pipe(q.getOrElse(() => ({}))), ...e }, "from" in t ? y({
       parent: n,
       meta: e,
       property: t.from
@@ -221,69 +219,64 @@ const $ = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
       t,
       i.AST.TitleAnnotationId
     ).pipe(
-      k.getOrElse(() => "unknown")
+      q.getOrElse(() => "unknown")
     ), e));
   }
   return r;
-}, q = (e, n = "") => {
+}, N = (e, n = "") => {
   const t = {};
   for (const o in e) {
     const r = e[o], s = n ? `${n}.${o}` : o;
-    r && typeof r == "object" && "type" in r ? t[s] = r : r && typeof r == "object" && Object.assign(t, q(r, s));
+    r && typeof r == "object" && "type" in r ? t[s] = r : r && typeof r == "object" && Object.assign(t, N(r, s));
   }
   return t;
-}, N = (e) => {
-  const n = e.ast, t = {}, o = {}, r = {}, s = {};
+}, k = (e) => {
+  const n = e.ast, t = {}, o = {}, r = {};
   if (n._tag === "Transformation" || n._tag === "Refinement")
-    return N(i.make(n.from));
+    return k(i.make(n.from));
   if (n._tag === "Union") {
-    const l = (n.types || []).filter((f) => f._tag !== "UndefinedKeyword" && f !== i.Null.ast).map(U);
-    if (l.every((f) => f._tag === "TypeLiteral" && "propertySignatures" in f) && l.length > 0) {
-      const f = [];
-      for (const d of l)
-        if ("propertySignatures" in d) {
-          const T = d.propertySignatures.find(
-            (g) => g.name.toString() === "_tag"
+    const a = (n.types || []).filter((p) => p._tag !== "UndefinedKeyword" && p !== i.Null.ast).map(U);
+    if (a.every((p) => p._tag === "TypeLiteral" && "propertySignatures" in p) && a.length > 0) {
+      const p = [];
+      for (const S of a)
+        if ("propertySignatures" in S) {
+          const c = S.propertySignatures.find(
+            (m) => m.name.toString() === "_tag"
           );
-          let p = null;
-          T && i.AST.isLiteral(T.type) && (p = T.type.literal, f.push(p));
-          const m = y({
-            propertySignatures: d.propertySignatures
+          let b = null;
+          c && i.AST.isLiteral(c.type) && (b = c.type.literal, p.push(b));
+          const u = y({
+            propertySignatures: S.propertySignatures
           });
-          if (p) {
-            r[p] = q(m);
-            const g = i.make(d);
-            s[p] = h(g);
-          }
-          Object.assign(t, m);
+          b && (r[b] = N(u)), Object.assign(t, u);
         }
-      return f.length > 0 && (t._tag = {
+      return p.length > 0 && (t._tag = {
         type: "select",
-        members: f,
+        members: p,
         required: !0
-      }), { meta: t, defaultValues: o, unionMeta: r, unionDefaultValues: s };
+      }), { meta: t, defaultValues: o, unionMeta: r };
     }
   }
   if ("propertySignatures" in n) {
-    const a = y({
+    const s = y({
       propertySignatures: n.propertySignatures
     });
-    if (Object.values(a).every((l) => l && "type" in l))
-      return { meta: a, defaultValues: o, unionMeta: r, unionDefaultValues: s };
-    const u = (l, b = "") => {
-      for (const f in l) {
-        const d = b ? `${b}.${f}` : f;
-        l[f] && typeof l[f] == "object" && "type" in l[f] ? t[d] = l[f] : l[f] && typeof l[f] == "object" && u(l[f], d);
+    if (Object.values(s).every((a) => a && "type" in a))
+      return { meta: s, defaultValues: o, unionMeta: r };
+    const l = (a, f = "") => {
+      for (const p in a) {
+        const S = f ? `${f}.${p}` : p;
+        a[p] && typeof a[p] == "object" && "type" in a[p] ? t[S] = a[p] : a[p] && typeof a[p] == "object" && l(a[p], S);
       }
     };
-    u(a);
+    l(s);
   }
-  return { meta: t, defaultValues: o, unionMeta: r, unionDefaultValues: s };
+  return { meta: t, defaultValues: o, unionMeta: r };
 }, B = (e) => i.extend(e, i.Struct({})), z = (e) => {
-  const { meta: n, unionDefaultValues: t, unionMeta: o } = N(e);
-  return { schema: e, meta: n, unionMeta: o, unionDefaultValues: t };
+  const { meta: n, unionMeta: t } = k(e);
+  return { schema: e, meta: n, unionMeta: t };
 }, C = (e, n) => {
-  n || (n = j().trans);
+  n || (n = E().trans);
   let t;
   switch (e.type) {
     case "string":
@@ -394,7 +387,7 @@ const $ = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
 function F(e, n) {
   const t = { ...e };
   for (const o in n)
-    Array.isArray(n[o]) ? t[o] = n[o] : n[o] && E(n[o]) ? t[o] = F(t[o], n[o]) : t[o] = n[o];
+    Array.isArray(n[o]) ? t[o] = n[o] : n[o] && $(n[o]) ? t[o] = F(t[o], n[o]) : t[o] = n[o];
   return t;
 }
 function M(e) {
@@ -403,59 +396,59 @@ function M(e) {
 function P(e) {
   return e && "members" in e && Array.isArray(e.members);
 }
-const h = (e, n = {}) => {
+const x = (e, n = {}) => {
   const t = e.ast;
   if (t?.defaultValue)
     return t.defaultValue();
-  if (S(e.ast) === "null")
+  if (g(e.ast) === "null")
     return null;
-  if (S(e.ast) !== "undefined") {
+  if (g(e.ast) !== "undefined") {
     if (M(e)) {
       const o = {};
       for (const [r, s] of Object.entries(e.fields)) {
-        const a = s?.ast;
-        if (a?.defaultValue)
+        const l = s?.ast;
+        if (l?.defaultValue)
           try {
-            o[r] = a.defaultValue();
+            o[r] = l.defaultValue();
             continue;
           } catch {
           }
-        const u = h(s, n[r] || {});
-        u !== void 0 && (o[r] = u);
+        const a = x(s, n[r] || {});
+        a !== void 0 && (o[r] = a);
       }
       return { ...o, ...n };
     }
     if (e?.from && M(e.from))
-      return h(e.from, n);
+      return x(e.from, n);
     if (P(e)) {
-      const o = e.members.reduce((r, s) => (M(s) && Object.entries(s.fields).forEach(([a, u]) => {
-        const l = u.ast, b = r[a]?.ast;
-        (!r[a] || l?.defaultValue && !b?.defaultValue) && (r[a] = u);
+      const o = e.members.reduce((r, s) => (M(s) && Object.entries(s.fields).forEach(([l, a]) => {
+        const f = a.ast, p = r[l]?.ast;
+        (!r[l] || f?.defaultValue && !p?.defaultValue) && (r[l] = a);
       }), r), {});
-      return Object.entries(o).reduce((r, [s, a]) => (r[s] = h(a, n[s] || {}), r), n);
+      return Object.entries(o).reduce((r, [s, l]) => (r[s] = x(l, n[s] || {}), r), n);
     }
     if (Object.keys(n).length === 0)
       switch (e.ast._tag) {
         case "Refinement":
-          return h(i.make(e.ast.from), n);
+          return x(i.make(e.ast.from), n);
         case "Transformation": {
           const o = i.make(e.ast.from);
-          return h(o, n);
+          return x(o, n);
         }
         case "TypeLiteral": {
           const o = { ...n };
           for (const r of t.propertySignatures) {
-            const s = r.name.toString(), a = r.type;
-            if (a._tag === "Transformation" && a.defaultValue) {
-              o[s] = a.defaultValue();
+            const s = r.name.toString(), l = r.type;
+            if (l._tag === "Transformation" && l.defaultValue) {
+              o[s] = l.defaultValue();
               continue;
             }
-            if (a.defaultValue) {
-              o[s] = a.defaultValue();
+            if (l.defaultValue) {
+              o[s] = l.defaultValue();
               continue;
             }
-            const u = i.make(a), l = h(u, n[s] || {});
-            l !== void 0 && (o[s] = l);
+            const a = i.make(l), f = x(a, n[s] || {});
+            f !== void 0 && (o[s] = f);
           }
           return o;
         }
@@ -469,11 +462,11 @@ const h = (e, n = {}) => {
 export {
   y as createMeta,
   F as deepMerge,
-  h as defaultsValueFromSchema,
+  x as defaultsValueFromSchema,
   B as duplicateSchema,
   C as generateInputStandardSchemaFromFieldMeta,
   z as generateMetaFromSchema,
   H as getInputType,
-  S as isNullableOrUndefined,
+  g as isNullableOrUndefined,
   G as nullableInput
 };

package/dist/vue-components.es6.js

@@ -1,9 +1,9 @@
-import { defineComponent as M, computed as o, useAttrs as $, inject as k, createBlock as m, openBlock as i, resolveDynamicComponent as A, withCtx as s, createCommentVNode as S, mergeProps as w, unref as I, createSlots as P, renderSlot as u, normalizeProps as f, guardReactiveProps as c } from "vue";
+import { defineComponent as F, computed as l, useAttrs as A, inject as M, createBlock as i, openBlock as f, resolveDynamicComponent as S, withCtx as u, createCommentVNode as w, mergeProps as I, unref as L, createSlots as P, renderSlot as c, normalizeProps as d, guardReactiveProps as v } from "vue";
 import { useIntl as j } from "./vue-components.es3.js";
 import { generateInputStandardSchemaFromFieldMeta as B } from "./vue-components.es12.js";
 import E from "./vue-components.es7.js";
 import { useErrorLabel as N } from "./vue-components.es10.js";
-const V = /* @__PURE__ */ M({
+const V = /* @__PURE__ */ F({
   inheritAttrs: !1,
   __name: "OmegaInput",
   props: {
@@ -13,49 +13,52 @@ const V = /* @__PURE__ */ M({
     name: {},
     inputClass: {}
   },
-  setup(r) {
-    const e = r, l = o(() => e.name), d = $(), p = o(() => {
+  setup(a) {
+    const e = a, n = l(() => e.name), p = A(), g = l(() => {
       if (e.inputClass !== null)
-        return e.inputClass !== void 0 ? e.inputClass : d.class;
-    }), v = k(
+        return e.inputClass !== void 0 ? e.inputClass : p.class;
+    }), s = M(
       "getMetaFromArray",
       null
-    ), a = o(() => {
-      const t = v?.value?.(e.name);
-      return t || e.form.meta[l.value];
-    }), { trans: g } = j(), C = o(() => {
-      if (!a.value)
+    ), o = l(() => s?.value && s.value(e.name) ? s.value(n.value) : e.form.meta[n.value]), $ = l(() => {
+      const t = o.value;
+      if (!t) return n.value;
+      const r = t;
+      return `${n.value}-${r.type}-${r.minLength ?? ""}-${r.maxLength ?? ""}-${r.minimum ?? ""}-${r.maximum ?? ""}`;
+    }), { trans: C } = j(), b = l(() => {
+      if (!o.value)
         throw console.log(e.name, Object.keys(e.form.meta), e.form.meta), new Error("Meta is undefined");
-      return B(a.value, g);
-    }), b = N(e.form);
-    return (t, h) => (i(), m(A(r.form.Field), {
-      name: r.name,
+      return B(o.value, C);
+    }), h = N(e.form);
+    return (t, r) => (f(), i(S(a.form.Field), {
+      key: $.value,
+      name: a.name,
       validators: {
-        onChange: C.value,
-        ...r.validators
+        onChange: b.value,
+        ...a.validators
       }
     }, {
-      default: s(({ field: y, state: F }) => [
-        a.value ? (i(), m(E, w({ key: 0 }, { ...t.$attrs, ...t.$props, inputClass: p.value }, {
+      default: u(({ field: y, state: k }) => [
+        o.value ? (f(), i(E, I({ key: 0 }, { ...t.$attrs, ...t.$props, inputClass: g.value }, {
           field: y,
-          state: F,
-          register: r.form.registerField,
-          label: r.label ?? I(b)(l.value),
-          meta: a.value
+          state: k,
+          register: a.form.registerField,
+          label: a.label ?? L(h)(n.value),
+          meta: o.value
         }), P({
-          default: s((n) => [
-            u(t.$slots, "default", f(c(n)))
+          default: u((m) => [
+            c(t.$slots, "default", d(v(m)))
           ]),
           _: 2
         }, [
           t.$slots.label ? {
             name: "label",
-            fn: s((n) => [
-              u(t.$slots, "label", f(c(n)))
+            fn: u((m) => [
+              c(t.$slots, "label", d(v(m)))
             ]),
             key: "0"
           } : void 0
-        ]), 1040, ["field", "state", "register", "label", "meta"])) : S("", !0)
+        ]), 1040, ["field", "state", "register", "label", "meta"])) : w("", !0)
       ]),
       _: 3
     }, 8, ["name", "validators"]));

package/dist/vue-components.es8.js

@@ -1,4 +1,4 @@
-import { defineComponent as M, ref as C, computed as s, watch as b, provide as k, createBlock as F, openBlock as O, unref as f, withCtx as i, renderSlot as o, createVNode as c, createCommentVNode as S, normalizeProps as g, guardReactiveProps as d, createSlots as V, renderList as w } from "vue";
+import { defineComponent as M, ref as C, computed as s, watch as b, provide as k, createBlock as F, openBlock as O, unref as f, withCtx as c, renderSlot as o, createVNode as i, createCommentVNode as S, normalizeProps as g, guardReactiveProps as d, createSlots as V, renderList as w } from "vue";
 import A from "./vue-components.es9.js";
 const N = /* @__PURE__ */ M({
   __name: "OmegaTaggedUnion",
@@ -10,28 +10,28 @@ const N = /* @__PURE__ */ M({
     label: {}
   },
   setup(t) {
-    const n = t, m = C(null), v = s(() => n.name ? `${n.name}._tag` : "_tag"), $ = n.form.useStore((e) => e.values);
+    const n = t, r = C(null), v = s(() => n.name ? `${n.name}._tag` : "_tag"), $ = n.form.useStore((e) => e.values);
     b(
-      () => v.value.split(".").reduce((r, a) => r?.[a], $.value),
+      () => v.value.split(".").reduce((l, a) => l?.[a], $.value),
       (e) => {
-        m.value = e ?? null;
+        r.value = e ?? null;
       },
       { immediate: !0 }
     );
     const y = s(() => {
-      const e = m.value;
+      const e = r.value;
       return (a) => {
         if (!e) return null;
-        const l = n.form.unionMeta[e];
-        return l ? l[a] ?? null : null;
+        const m = n.form.unionMeta[e];
+        return m ? m[a] ?? null : null;
       };
     });
-    return k("getMetaFromArray", y), (e, r) => (O(), F(f(t.form).Field, {
+    return k("getMetaFromArray", y), (e, l) => (O(), F(f(t.form).Field, {
       name: t.name ? `${t.name}._tag` : "_tag"
     }, {
-      default: i((a) => [
+      default: c((a) => [
         o(e.$slots, "OmegaCustomInput", g(d(a)), () => [
-          c(f(t.form).Input, {
+          i(f(t.form).Input, {
             name: t.name ? `${t.name}._tag` : "_tag",
             label: t.label,
             type: t.type ?? "select",
@@ -39,15 +39,15 @@ const N = /* @__PURE__ */ M({
           }, null, 8, ["name", "label", "type", "options"])
         ]),
         o(e.$slots, "default"),
-        c(A, {
+        i(A, {
           field: a.field,
           state: a.state.value,
           name: t.name,
           form: t.form
         }, V({ _: 2 }, [
-          w(e.$slots, (l, u) => ({
+          w(e.$slots, (m, u) => ({
             name: u,
-            fn: i((h) => [
+            fn: c((h) => [
               o(e.$slots, u, g(d(h)))
             ])
           }))