@effect-app/vue-components 0.14.5 → 0.15.0

package/dist/types/components/OmegaForm/OmegaArray.vue.d.ts

@@ -13,6 +13,10 @@ declare const _default: <From extends Record<PropertyKey, any>, To extends Recor
             subState: import("@tanstack/vue-form").FieldState<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>, import("@tanstack/vue-form").FieldValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FieldValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FieldAsyncValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FieldValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FieldAsyncValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FieldValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FieldAsyncValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FormValidateOrFn<From> | undefined, import("@tanstack/vue-form").FormValidateOrFn<From> | undefined, import("@tanstack/vue-form").StandardSchemaV1<From, To>, import("@tanstack/vue-form").FormValidateOrFn<From> | undefined, import("@tanstack/vue-form").FormAsyncValidateOrFn<From> | undefined, import("@tanstack/vue-form").FormValidateOrFn<From> | undefined, import("@tanstack/vue-form").FormAsyncValidateOrFn<From> | undefined>;
             index: number;
         }) => any;
+    } & {
+        field?: (props: {
+            field: import("@tanstack/vue-form").FieldApi<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>, import("@tanstack/vue-form").FieldValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FieldValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FieldAsyncValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FieldValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FieldAsyncValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FieldValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FieldAsyncValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>> | undefined, import("@tanstack/vue-form").FormValidateOrFn<From> | undefined, import("@tanstack/vue-form").FormValidateOrFn<From> | undefined, import("@tanstack/vue-form").StandardSchemaV1<From, To>, import("@tanstack/vue-form").FormValidateOrFn<From> | undefined, import("@tanstack/vue-form").FormAsyncValidateOrFn<From> | undefined, import("@tanstack/vue-form").FormValidateOrFn<From> | undefined, import("@tanstack/vue-form").FormAsyncValidateOrFn<From> | undefined, import("@tanstack/vue-form").FormAsyncValidateOrFn<From> | undefined, import("@tanstack/vue-form").FormAsyncValidateOrFn<From> | undefined>;
+        }) => any;
     };
     emit: {};
 }>) => import("vue").VNode & {

package/dist/vue-components.es10.js

@@ -1,6 +1,6 @@
-import { S as n, Option as f, pipe as O } from "effect-app";
-import { useIntl as A } from "./vue-components.es3.js";
-const M = n.NonEmptyArray(n.String), L = (e) => n.AST.isUnion(e) && e.types.find((i) => i._tag === "UndefinedKeyword" || i === n.Null.ast), y = (e) => !e || !n.AST.isUnion(e) ? !1 : e.types.find((i) => i._tag === "UndefinedKeyword") ? "undefined" : e.types.find((i) => i === n.Null.ast) ? "null" : !1, m = ({ meta: e = {}, parent: i = "", property: t, propertySignatures: o }, l = {}) => {
+import { S as n, Option as c, pipe as L } from "effect-app";
+import { useIntl as U } from "./vue-components.es3.js";
+const _ = n.NonEmptyArray(n.String), N = (e) => n.AST.isUnion(e) && e.types.find((i) => i._tag === "UndefinedKeyword" || i === n.Null.ast), g = (e) => !e || !n.AST.isUnion(e) ? !1 : e.types.find((i) => i._tag === "UndefinedKeyword") ? "undefined" : e.types.find((i) => i === n.Null.ast) ? "null" : !1, m = ({ meta: e = {}, parent: i = "", property: t, propertySignatures: p }, o = {}) => {
   if (t && t._tag === "Transformation")
     return m({
       parent: i,
@@ -12,128 +12,169 @@ const M = n.NonEmptyArray(n.String), L = (e) => n.AST.isUnion(e) && e.types.find
       meta: e,
       propertySignatures: t.propertySignatures
     });
-  if (o) {
-    for (const r of o) {
-      const u = i ? `${i}.${r.name.toString()}` : r.name.toString(), s = y(r.type), p = !s, b = r.type;
+  if (p) {
+    for (const r of p) {
+      const l = i ? `${i}.${r.name.toString()}` : r.name.toString(), a = g(r.type), u = !a, A = r.type;
       if (n.AST.isUnion(r.type)) {
-        const d = r.type.types.filter(
-          (a) => a._tag !== "UndefinedKeyword" && a !== n.Null.ast
+        const T = r.type.types.filter(
+          (s) => s._tag !== "UndefinedKeyword" && s !== n.Null.ast
         );
-        if (d.some(
-          (a) => "propertySignatures" in a
+        if (T.some(
+          (s) => "propertySignatures" in s
         )) {
-          const a = m({
-            parent: u,
-            property: r.type,
-            meta: { required: p, nullableOrUndefined: s }
-          });
-          l[u] = a;
-          for (const g of d)
-            "propertySignatures" in g && Object.assign(
-              l,
+          if (!a) {
+            const s = m({
+              parent: l,
+              property: r.type,
+              meta: { required: u, nullableOrUndefined: a }
+            });
+            o[l] = s;
+          }
+          for (const s of T)
+            "propertySignatures" in s && Object.assign(
+              o,
               m({
-                parent: u,
-                propertySignatures: g.propertySignatures,
-                meta: { required: p, nullableOrUndefined: s }
+                parent: l,
+                propertySignatures: s.propertySignatures,
+                meta: { required: u, nullableOrUndefined: a }
               })
             );
         } else {
-          const a = m({
-            parent: u,
-            property: r.type,
-            meta: { required: p, nullableOrUndefined: s }
-          });
-          l[u] = a;
+          const s = T.filter(n.AST.isTupleType);
+          if (s.length > 0) {
+            const f = s[0];
+            if (o[l] = {
+              type: "multiple",
+              members: f.elements,
+              rest: f.rest,
+              required: u,
+              nullableOrUndefined: a
+            }, f.rest && f.rest.length > 0) {
+              const d = f.rest[0];
+              if (d.type._tag === "TypeLiteral" && "propertySignatures" in d.type)
+                for (const y of d.type.propertySignatures) {
+                  const b = `${l}.${y.name.toString()}`, S = m({
+                    parent: b,
+                    property: y.type,
+                    meta: {
+                      required: !g(y.type),
+                      nullableOrUndefined: g(y.type)
+                    }
+                  });
+                  if (S && typeof S == "object" && "type" in S && (o[b] = S, S.type === "multiple" && n.AST.isTupleType(y.type) && y.type.rest && y.type.rest.length > 0)) {
+                    const O = y.type.rest[0];
+                    if (O.type._tag === "TypeLiteral" && "propertySignatures" in O.type)
+                      for (const v of O.type.propertySignatures) {
+                        const M = `${b}.${v.name.toString()}`, x = m({
+                          parent: M,
+                          property: v.type,
+                          meta: {
+                            required: !g(v.type),
+                            nullableOrUndefined: g(v.type)
+                          }
+                        });
+                        x && typeof x == "object" && "type" in x && (o[M] = x);
+                      }
+                  }
+                }
+            }
+          } else {
+            const f = m({
+              parent: l,
+              property: r.type,
+              meta: { required: u, nullableOrUndefined: a }
+            });
+            o[l] = f;
+          }
         }
-      }
-      if ("propertySignatures" in b)
+      } else if ("propertySignatures" in A)
         Object.assign(
-          l,
+          o,
           m({
-            parent: u,
-            propertySignatures: b.propertySignatures,
-            meta: { required: p, nullableOrUndefined: s }
+            parent: l,
+            propertySignatures: A.propertySignatures,
+            meta: { required: u, nullableOrUndefined: a }
           })
         );
       else if (n.AST.isTupleType(r.type))
         if (r.type.rest.length > 0 && r.type.rest[0].type._tag === "TypeLiteral" && "propertySignatures" in r.type.rest[0].type) {
-          const S = r.type.rest[0].type;
-          if (S._tag === "TypeLiteral" && "propertySignatures" in S)
-            for (const a of S.propertySignatures) {
-              const g = `${u}.${a.name.toString()}`;
-              if (n.AST.isTupleType(a.type) && a.type.rest.length > 0) {
-                const c = a.type.rest[0].type;
-                if (c._tag === "TypeLiteral" && "propertySignatures" in c)
-                  for (const T of c.propertySignatures) {
-                    const h = `${g}.${T.name.toString()}`, x = m({
-                      parent: h,
-                      property: T.type,
+          const h = r.type.rest[0].type;
+          if (h._tag === "TypeLiteral" && "propertySignatures" in h)
+            for (const s of h.propertySignatures) {
+              const f = `${l}.${s.name.toString()}`;
+              if (n.AST.isTupleType(s.type) && s.type.rest.length > 0) {
+                const d = s.type.rest[0].type;
+                if (d._tag === "TypeLiteral" && "propertySignatures" in d)
+                  for (const y of d.propertySignatures) {
+                    const b = `${f}.${y.name.toString()}`, S = m({
+                      parent: b,
+                      property: y.type,
                       meta: {
-                        required: !y(T.type),
-                        nullableOrUndefined: y(T.type)
+                        required: !g(y.type),
+                        nullableOrUndefined: g(y.type)
                       }
                     });
-                    l[h] = x;
+                    o[b] = S;
                   }
                 else
-                  l[g] = {
+                  o[f] = {
                     type: "multiple",
-                    members: a.type.elements,
-                    rest: a.type.rest,
-                    required: !y(a.type),
-                    nullableOrUndefined: y(a.type)
+                    members: s.type.elements,
+                    rest: s.type.rest,
+                    required: !g(s.type),
+                    nullableOrUndefined: g(s.type)
                   };
               } else {
-                const c = m({
-                  parent: g,
-                  property: a.type,
+                const d = m({
+                  parent: f,
+                  property: s.type,
                   meta: {
-                    required: !y(a.type),
-                    nullableOrUndefined: y(a.type)
+                    required: !g(s.type),
+                    nullableOrUndefined: g(s.type)
                   }
                 });
-                l[g] = c;
+                o[f] = d;
               }
             }
         } else
-          l[u] = {
+          o[l] = {
             type: "multiple",
             members: r.type.elements,
             rest: r.type.rest,
-            required: p,
-            nullableOrUndefined: s
+            required: u,
+            nullableOrUndefined: a
           };
       else {
-        const d = m({
-          parent: u,
+        const T = m({
+          parent: l,
           property: r.type,
-          meta: { required: p, nullableOrUndefined: s }
+          meta: { required: u, nullableOrUndefined: a }
         });
-        l[u] = d;
+        o[l] = T;
       }
     }
-    return l;
+    return o;
   }
   if (t) {
-    const r = L(t);
+    const r = N(t);
     if (Object.hasOwnProperty.call(e, "required") || (e.required = !r), n.AST.isUnion(t)) {
-      const s = t.types.find(
-        (p) => p._tag !== "UndefinedKeyword" && p !== n.Null.ast
+      const a = t.types.find(
+        (u) => u._tag !== "UndefinedKeyword" && u !== n.Null.ast
       );
-      return "propertySignatures" in s ? m({
-        propertySignatures: s.propertySignatures,
+      return "propertySignatures" in a ? m({
+        propertySignatures: a.propertySignatures,
         parent: i,
         meta: e
       }) : t.types.every(n.AST.isLiteral) ? {
         ...e,
         type: "select",
-        members: t.types.map((p) => p.literal)
+        members: t.types.map((u) => u.literal)
       } : {
         ...e,
         ...m({
           parent: i,
           meta: e,
-          property: s
+          property: a
         })
       };
     }
@@ -144,11 +185,11 @@ const M = n.NonEmptyArray(n.String), L = (e) => n.AST.isUnion(e) && e.types.find
         members: t.elements,
         rest: t.rest
       };
-    const u = n.AST.getAnnotation(
+    const l = n.AST.getAnnotation(
       t,
       n.AST.JSONSchemaAnnotationId
-    ).pipe(f.getOrElse(() => ({})));
-    return e = { ...e, ...u }, "from" in t ? m({
+    ).pipe(c.getOrElse(() => ({})));
+    return e = { ...e, ...l }, "from" in t ? m({
       parent: i,
       meta: e,
       property: t.from
@@ -156,50 +197,50 @@ const M = n.NonEmptyArray(n.String), L = (e) => n.AST.isUnion(e) && e.types.find
       t,
       n.AST.TitleAnnotationId
     ).pipe(
-      f.getOrElse(() => "unknown")
+      c.getOrElse(() => "unknown")
     ), e);
   }
-  return l;
-}, v = (e) => {
+  return o;
+}, q = (e) => {
   const i = e.ast, t = {};
   if (i._tag === "Transformation" || i._tag === "Refinement")
-    return v(n.make(i.from));
+    return q(n.make(i.from));
   if ("propertySignatures" in i) {
-    const o = m({
+    const p = m({
       propertySignatures: i.propertySignatures
     });
-    if (Object.values(o).every((r) => r && "type" in r))
-      return o;
-    const l = (r, u = "") => {
-      for (const s in r) {
-        const p = u ? `${u}.${s}` : s;
-        r[s] && typeof r[s] == "object" && "type" in r[s] ? t[p] = r[s] : r[s] && typeof r[s] == "object" && l(r[s], p);
+    if (Object.values(p).every((r) => r && "type" in r))
+      return p;
+    const o = (r, l = "") => {
+      for (const a in r) {
+        const u = l ? `${l}.${a}` : a;
+        r[a] && typeof r[a] == "object" && "type" in r[a] ? t[u] = r[a] : r[a] && typeof r[a] == "object" && o(r[a], u);
       }
     };
-    l(o);
+    o(p);
   }
   return t;
-}, N = (e) => n.extend(e, n.Struct({})), _ = (e) => {
-  const i = v(e), t = O(
+}, w = (e) => n.extend(e, n.Struct({})), $ = (e) => {
+  const i = q(e), t = L(
     e.ast,
-    f.liftPredicate((o) => o._tag === "Refinement" && "filter" in o),
-    f.flatMap((o) => n.AST.getJSONSchemaAnnotation(o)),
-    f.filter((o) => "items" in o),
-    f.filterMap(
-      ({ items: o }) => n.decodeUnknownOption(M)(o)
+    c.liftPredicate((p) => p._tag === "Refinement" && "filter" in p),
+    c.flatMap((p) => n.AST.getJSONSchemaAnnotation(p)),
+    c.filter((p) => "items" in p),
+    c.filterMap(
+      ({ items: p }) => n.decodeUnknownOption(_)(p)
     ),
-    f.zipWith(
+    c.zipWith(
       n.AST.getMessageAnnotation(e.ast),
-      (o, l) => ({
-        items: o,
-        message: l("")
+      (p, o) => ({
+        items: p,
+        message: o("")
       })
     ),
-    f.getOrUndefined
+    c.getOrUndefined
   );
   return { schema: e, meta: i, filterItems: t };
-}, k = (e) => {
-  const { trans: i } = A();
+}, K = (e) => {
+  const { trans: i } = U();
   let t;
   switch (e.type) {
     case "string":
@@ -281,7 +322,7 @@ const M = n.NonEmptyArray(n.String), L = (e) => n.AST.isUnion(e) && e.types.find
       message: () => i("validation.empty")
     })
   ) : t = n.NullishOr(t), n.standardSchemaV1(t);
-}, w = (e, i) => n.NullOr(e).pipe(
+}, P = (e, i) => n.NullOr(e).pipe(
   n.transform(n.typeSchema(e), {
     decode: (t) => t ?? i(),
     encode: (t) => t
@@ -289,8 +330,8 @@ const M = n.NonEmptyArray(n.String), L = (e) => n.AST.isUnion(e) && e.types.find
 );
 export {
   m as createMeta,
-  N as duplicateSchema,
-  k as generateInputStandardSchemaFromFieldMeta,
-  _ as generateMetaFromSchema,
-  w as nullableInput
+  w as duplicateSchema,
+  K as generateInputStandardSchemaFromFieldMeta,
+  $ as generateMetaFromSchema,
+  P as nullableInput
 };

package/dist/vue-components.es4.js

@@ -1,6 +1,6 @@
-import { defineComponent as d, inject as f, computed as o, createBlock as n, openBlock as m, resolveDynamicComponent as v, withCtx as l, createCommentVNode as c, mergeProps as y, renderSlot as g, normalizeProps as h, guardReactiveProps as C } from "vue";
-import { generateInputStandardSchemaFromFieldMeta as F } from "./vue-components.es10.js";
-import b from "./vue-components.es24.js";
+import { defineComponent as d, inject as f, computed as r, createBlock as n, openBlock as m, resolveDynamicComponent as c, withCtx as l, createCommentVNode as v, mergeProps as y, renderSlot as g, normalizeProps as h, guardReactiveProps as b } from "vue";
+import { generateInputStandardSchemaFromFieldMeta as C } from "./vue-components.es10.js";
+import F from "./vue-components.es24.js";
 const P = /* @__PURE__ */ d({
   inheritAttrs: !1,
   __name: "OmegaInput",
@@ -13,15 +13,15 @@ const P = /* @__PURE__ */ d({
     type: {}
   },
   setup(s) {
-    const a = s, r = f(
+    const a = s, o = f(
       "getMetaFromArray",
       null
-    ), t = o(() => r?.value && r.value(a.name) ? r.value(a.name) : a.form.meta[a.name]), i = o(() => {
+    ), t = r(() => o?.value && o.value(a.name) ? o.value(a.name) : a.form.meta[a.name]), i = r(() => {
       if (!t.value)
-        throw new Error("Meta is undefined");
-      return F(t.value);
+        throw console.log(a.name, Object.keys(a.form.meta), a.form.meta), new Error("Meta is undefined");
+      return C(t.value);
     });
-    return (e, M) => (m(), n(v(e.form.Field), {
+    return (e, k) => (m(), n(c(e.form.Field), {
       name: e.name,
       validators: {
         onChange: i.value,
@@ -29,7 +29,7 @@ const P = /* @__PURE__ */ d({
       }
     }, {
       default: l(({ field: p }) => [
-        t.value ? (m(), n(b, y({
+        t.value ? (m(), n(F, y({
           key: 0,
           field: p,
           label: e.label,
@@ -38,10 +38,10 @@ const P = /* @__PURE__ */ d({
           type: e.type
         }, e.$attrs), {
           default: l((u) => [
-            g(e.$slots, "default", h(C(u)))
+            g(e.$slots, "default", h(b(u)))
           ]),
           _: 2
-        }, 1040, ["field", "label", "options", "meta", "type"])) : c("", !0)
+        }, 1040, ["field", "label", "options", "meta", "type"])) : v("", !0)
       ]),
       _: 3
     }, 8, ["name", "validators"]));

package/dist/vue-components.es7.js

@@ -1,5 +1,5 @@
-import { defineComponent as i, computed as m, onMounted as p, provide as g, createElementBlock as h, openBlock as s, Fragment as v, renderList as y, createBlock as F, resolveDynamicComponent as M, withCtx as _, renderSlot as $, mergeProps as k } from "vue";
-const P = /* @__PURE__ */ i({
+import { defineComponent as F, computed as l, onMounted as P, provide as $, createElementBlock as s, openBlock as n, Fragment as u, createBlock as d, renderList as M, resolveDynamicComponent as i, withCtx as f, renderSlot as p, mergeProps as k, normalizeProps as A, guardReactiveProps as b } from "vue";
+const B = /* @__PURE__ */ F({
   inheritAttrs: !1,
   __name: "OmegaArray",
   props: {
@@ -8,30 +8,38 @@ const P = /* @__PURE__ */ i({
     defaultItems: {},
     items: {}
   },
-  setup(l) {
-    const t = l, u = t.form.useStore((e) => e.values), o = m(() => t.name.replace(/\[/g, ".").replace(/\]/g, "").split(".").reduce((r, a) => r[a], u.value));
-    p(async () => {
-      t.defaultItems && !o.value && t.form.setFieldValue(t.name, t.defaultItems);
+  setup(c) {
+    const r = c, g = r.form.useStore((e) => e.values), m = l(() => r.name.replace(/\[/g, ".").replace(/\]/g, "").split(".").reduce((a, t) => a[t], g.value));
+    P(async () => {
+      r.defaultItems && !m.value && r.form.setFieldValue(r.name, r.defaultItems);
     });
-    const d = m(() => (r) => {
-      const a = r.replace(/\[\d+\]/g, "");
-      return t.form.meta[a];
+    const v = l(() => (a) => {
+      const t = a.replace(/\[\d+\]/g, "");
+      return r.form.meta[t];
     });
-    return g("getMetaFromArray", d), (e, r) => (s(!0), h(v, null, y(o.value, (a, n) => (s(), F(M(e.form.Field), {
-      key: `${e.name}[${Number(n)}]`,
-      name: `${e.name}[${Number(n)}]`
-    }, {
-      default: _(({ field: c, state: f }) => [
-        $(e.$slots, "default", k({ ref_for: !0 }, {
-          subField: c,
-          subState: f,
-          index: Number(n)
-        }))
-      ]),
-      _: 2
-    }, 1032, ["name"]))), 128));
+    return $("getMetaFromArray", v), (e, a) => (n(), s(u, null, [
+      (n(!0), s(u, null, M(m.value, (t, o) => (n(), d(i(e.form.Field), {
+        key: `${e.name}[${Number(o)}]`,
+        name: `${e.name}[${Number(o)}]`
+      }, {
+        default: f(({ field: h, state: y }) => [
+          p(e.$slots, "default", k({ ref_for: !0 }, {
+            subField: h,
+            subState: y,
+            index: Number(o)
+          }))
+        ]),
+        _: 2
+      }, 1032, ["name"]))), 128)),
+      (n(), d(i(e.form.Field), { name: e.name }, {
+        default: f(({ field: t }) => [
+          p(e.$slots, "field", A(b({ field: t })))
+        ]),
+        _: 3
+      }, 8, ["name"]))
+    ], 64));
   }
 });
 export {
-  P as default
+  B as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "0.14.5",
+  "version": "0.15.0",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
     "@tanstack/vue-form": "^1.2.4",

package/src/components/OmegaForm/OmegaArray.vue

@@ -17,8 +17,12 @@
       />
     </template>
   </component>
+  <component :is="form.Field" :name="name">
+    <template #default="{ field }">
+      <slot name="field" v-bind="{ field }" />
+    </template>
+  </component>
 </template>
-
 <script
   setup
   lang="ts"

package/src/components/OmegaForm/OmegaFormStuff.ts

@@ -268,14 +268,16 @@ export const createMeta = <T = any>(
         )
 
         if (hasStructMembers) {
-          // Create metadata for the parent level (the union itself)
-          const parentMeta = createMeta<T>({
-            parent: key,
-            property: p.type,
-            meta: { required: isRequired, nullableOrUndefined },
-          })
-          acc[key as NestedKeyOf<T>] = parentMeta as FieldMeta
-
+          // Only create parent meta for non-NullOr unions to avoid duplicates
+          if (!nullableOrUndefined) {
+            const parentMeta = createMeta<T>({
+              parent: key,
+              property: p.type,
+              meta: { required: isRequired, nullableOrUndefined },
+            })
+            acc[key as NestedKeyOf<T>] = parentMeta as FieldMeta
+          }
+          
           // Process each non-null type and merge their metadata
           for (const nonNullType of nonNullTypes) {
             if ("propertySignatures" in nonNullType) {
@@ -290,16 +292,78 @@ export const createMeta = <T = any>(
             }
           }
         } else {
-          // If no struct members, process as regular union
-          const newMeta = createMeta<T>({
-            parent: key,
-            property: p.type,
-            meta: { required: isRequired, nullableOrUndefined },
-          })
-          acc[key as NestedKeyOf<T>] = newMeta as FieldMeta
+          // Check if any of the union types are arrays (TupleType)
+          const arrayTypes = nonNullTypes.filter(S.AST.isTupleType)
+          if (arrayTypes.length > 0) {
+            const arrayType = arrayTypes[0]  // Take the first array type
+            
+            acc[key as NestedKeyOf<T>] = {
+              type: "multiple",
+              members: arrayType.elements,
+              rest: arrayType.rest,
+              required: isRequired,
+              nullableOrUndefined
+            } as FieldMeta
+            
+            // If the array has struct elements, also create metadata for their properties
+            if (arrayType.rest && arrayType.rest.length > 0) {
+              const restElement = arrayType.rest[0]
+              if (restElement.type._tag === "TypeLiteral" && "propertySignatures" in restElement.type) {
+
+                for (const prop of restElement.type.propertySignatures) {
+                  const propKey = `${key}.${prop.name.toString()}`
+                  
+                  const propMeta = createMeta<T>({
+                    parent: propKey,
+                    property: prop.type,
+                    meta: {
+                      required: !isNullableOrUndefined(prop.type),
+                      nullableOrUndefined: isNullableOrUndefined(prop.type)
+                    }
+                  })
+                  
+                  // add to accumulator if valid
+                  if (propMeta && typeof propMeta === 'object' && 'type' in propMeta) {
+                    acc[propKey as NestedKeyOf<T>] = propMeta as FieldMeta
+                    
+                    if (propMeta.type === "multiple" && S.AST.isTupleType(prop.type) && prop.type.rest && prop.type.rest.length > 0) {
+                      const nestedRestElement = prop.type.rest[0]
+                      if (nestedRestElement.type._tag === "TypeLiteral" && "propertySignatures" in nestedRestElement.type) {
+
+                        for (const nestedProp of nestedRestElement.type.propertySignatures) {
+                          const nestedPropKey = `${propKey}.${nestedProp.name.toString()}`
+                          
+                          const nestedPropMeta = createMeta<T>({
+                            parent: nestedPropKey,
+                            property: nestedProp.type,
+                            meta: {
+                              required: !isNullableOrUndefined(nestedProp.type),
+                              nullableOrUndefined: isNullableOrUndefined(nestedProp.type)
+                            }
+                          })
+                          
+                          // add to accumulator if valid
+                          if (nestedPropMeta && typeof nestedPropMeta === 'object' && 'type' in nestedPropMeta) {
+                            acc[nestedPropKey as NestedKeyOf<T>] = nestedPropMeta as FieldMeta
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          } else {
+            // If no struct members and no arrays, process as regular union
+            const newMeta = createMeta<T>({
+              parent: key,
+              property: p.type,
+              meta: { required: isRequired, nullableOrUndefined },
+            })
+            acc[key as NestedKeyOf<T>] = newMeta as FieldMeta
+          }
         }
-      }
-      if ("propertySignatures" in typeToProcess) {
+      } else if ("propertySignatures" in typeToProcess) {
         Object.assign(
           acc,
           createMeta<T>({
@@ -380,6 +444,8 @@ export const createMeta = <T = any>(
             property: p.type,
             meta: { required: isRequired, nullableOrUndefined },
           })
+          
+          
           acc[key as NestedKeyOf<T>] = newMeta as FieldMeta
         }
       }

package/src/components/OmegaForm/OmegaInput.vue

@@ -54,6 +54,7 @@ const meta = computed(() => {
 
 const schema = computed(() => {
   if (!meta.value) {
+    console.log(props.name, Object.keys(props.form.meta), props.form.meta)
     throw new Error("Meta is undefined")
   }
   return generateInputStandardSchemaFromFieldMeta(meta.value)