@effect-app/vue-components 0.14.2 → 0.14.5

package/dist/types/components/OmegaForm/OmegaFormStuff.d.ts

@@ -1,4 +1,4 @@
-import { S, type Record, type Effect } from "effect-app";
+import { S, type Effect } from "effect-app";
 import { type FormAsyncValidateOrFn, type FormValidateOrFn, type StandardSchemaV1, type FormApi, type VueFormApi, type FormOptions, type DeepKeys, type FieldValidateOrFn, type FieldAsyncValidateOrFn, type FormState } from "@tanstack/vue-form";
 import { OmegaFormReturn } from "./useOmegaForm";
 import { OmegaFieldInternalApi } from "./InputProps";

package/dist/types/components/OmegaForm/useOmegaForm.d.ts

@@ -1,5 +1,5 @@
 import { DeepKeys } from "@tanstack/vue-form";
-import { type Record, S } from "effect-app";
+import { S } from "effect-app";
 import { type NestedKeyOf, type FilterItems, type FormProps, type MetaRecord, type OmegaFormApi, TypeOverride, FieldValidators } from "./OmegaFormStuff";
 import { type InjectionKey } from "vue";
 import { InputProps } from "./InputProps";

package/dist/vue-components.es10.js

@@ -1,200 +1,248 @@
-import { S as t, Option as g, pipe as S } from "effect-app";
-import { useIntl as v } from "./vue-components.es3.js";
-const x = t.NonEmptyArray(t.String), T = (e) => t.AST.isUnion(e) && e.types.find((i) => i._tag === "UndefinedKeyword" || i === t.Null.ast), h = (e) => !e || !t.AST.isUnion(e) ? !1 : e.types.find((i) => i._tag === "UndefinedKeyword") ? "undefined" : e.types.find((i) => i === t.Null.ast) ? "null" : !1, m = ({ meta: e = {}, parent: i = "", property: n, propertySignatures: a }, u = {}) => {
-  if (n && n._tag === "Transformation")
+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 = {}) => {
+  if (t && t._tag === "Transformation")
     return m({
       parent: i,
       meta: e,
-      property: n.from
+      property: t.from
     });
-  if (n?._tag === "TypeLiteral" && "propertySignatures" in n)
+  if (t?._tag === "TypeLiteral" && "propertySignatures" in t)
     return m({
       meta: e,
-      propertySignatures: n.propertySignatures
+      propertySignatures: t.propertySignatures
     });
-  if (a) {
-    for (const s of a) {
-      const o = i ? `${i}.${s.name.toString()}` : s.name.toString(), r = h(s.type), l = !r, d = s.type;
-      if (t.AST.isUnion(s.type)) {
-        const p = s.type.types.filter(
-          (f) => f._tag !== "UndefinedKeyword" && f !== t.Null.ast
+  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 (n.AST.isUnion(r.type)) {
+        const d = r.type.types.filter(
+          (a) => a._tag !== "UndefinedKeyword" && a !== n.Null.ast
         );
-        if (p.some(
-          (f) => "propertySignatures" in f
+        if (d.some(
+          (a) => "propertySignatures" in a
         )) {
-          const f = m({
-            parent: o,
-            property: s.type,
-            meta: { required: l, nullableOrUndefined: r }
+          const a = m({
+            parent: u,
+            property: r.type,
+            meta: { required: p, nullableOrUndefined: s }
           });
-          u[o] = f;
-          for (const c of p)
-            "propertySignatures" in c && Object.assign(
-              u,
+          l[u] = a;
+          for (const g of d)
+            "propertySignatures" in g && Object.assign(
+              l,
               m({
-                parent: o,
-                propertySignatures: c.propertySignatures,
-                meta: { required: l, nullableOrUndefined: r }
+                parent: u,
+                propertySignatures: g.propertySignatures,
+                meta: { required: p, nullableOrUndefined: s }
               })
             );
         } else {
-          const f = m({
-            parent: o,
-            property: s.type,
-            meta: { required: l, nullableOrUndefined: r }
+          const a = m({
+            parent: u,
+            property: r.type,
+            meta: { required: p, nullableOrUndefined: s }
           });
-          u[o] = f;
+          l[u] = a;
         }
       }
-      if ("propertySignatures" in d)
+      if ("propertySignatures" in b)
         Object.assign(
-          u,
+          l,
           m({
-            parent: o,
-            propertySignatures: d.propertySignatures,
-            meta: { required: l, nullableOrUndefined: r }
+            parent: u,
+            propertySignatures: b.propertySignatures,
+            meta: { required: p, nullableOrUndefined: s }
           })
         );
+      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,
+                      meta: {
+                        required: !y(T.type),
+                        nullableOrUndefined: y(T.type)
+                      }
+                    });
+                    l[h] = x;
+                  }
+                else
+                  l[g] = {
+                    type: "multiple",
+                    members: a.type.elements,
+                    rest: a.type.rest,
+                    required: !y(a.type),
+                    nullableOrUndefined: y(a.type)
+                  };
+              } else {
+                const c = m({
+                  parent: g,
+                  property: a.type,
+                  meta: {
+                    required: !y(a.type),
+                    nullableOrUndefined: y(a.type)
+                  }
+                });
+                l[g] = c;
+              }
+            }
+        } else
+          l[u] = {
+            type: "multiple",
+            members: r.type.elements,
+            rest: r.type.rest,
+            required: p,
+            nullableOrUndefined: s
+          };
       else {
-        const p = m({
-          parent: o,
-          property: s.type,
-          meta: { required: l, nullableOrUndefined: r }
+        const d = m({
+          parent: u,
+          property: r.type,
+          meta: { required: p, nullableOrUndefined: s }
         });
-        u[o] = p;
+        l[u] = d;
       }
     }
-    return u;
+    return l;
   }
-  if (n) {
-    const s = T(n);
-    if (Object.hasOwnProperty.call(e, "required") || (e.required = !s), t.AST.isUnion(n)) {
-      const r = n.types.find(
-        (l) => l._tag !== "UndefinedKeyword" && l !== t.Null.ast
+  if (t) {
+    const r = L(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
       );
-      return "propertySignatures" in r ? m({
-        propertySignatures: r.propertySignatures,
+      return "propertySignatures" in s ? m({
+        propertySignatures: s.propertySignatures,
         parent: i,
         meta: e
-      }) : n.types.every(t.AST.isLiteral) ? {
+      }) : t.types.every(n.AST.isLiteral) ? {
         ...e,
         type: "select",
-        members: n.types.map((l) => l.literal)
+        members: t.types.map((p) => p.literal)
       } : {
         ...e,
         ...m({
           parent: i,
           meta: e,
-          property: r
+          property: s
         })
       };
     }
-    if (t.AST.isTupleType(n))
+    if (n.AST.isTupleType(t))
       return {
         ...e,
         type: "multiple",
-        members: n.elements,
-        rest: n.rest
+        members: t.elements,
+        rest: t.rest
       };
-    const o = t.AST.getAnnotation(
-      n,
-      t.AST.JSONSchemaAnnotationId
-    ).pipe(g.getOrElse(() => ({})));
-    return e = { ...e, ...o }, "from" in n ? m({
+    const u = n.AST.getAnnotation(
+      t,
+      n.AST.JSONSchemaAnnotationId
+    ).pipe(f.getOrElse(() => ({})));
+    return e = { ...e, ...u }, "from" in t ? m({
       parent: i,
       meta: e,
-      property: n.from
-    }) : (e.type = t.AST.getAnnotation(
-      n,
-      t.AST.TitleAnnotationId
+      property: t.from
+    }) : (e.type = n.AST.getAnnotation(
+      t,
+      n.AST.TitleAnnotationId
     ).pipe(
-      g.getOrElse(() => "unknown")
+      f.getOrElse(() => "unknown")
     ), e);
   }
-  return u;
-}, y = (e) => {
-  const i = e.ast, n = {};
+  return l;
+}, v = (e) => {
+  const i = e.ast, t = {};
   if (i._tag === "Transformation" || i._tag === "Refinement")
-    return y(t.make(i.from));
+    return v(n.make(i.from));
   if ("propertySignatures" in i) {
-    const a = m({
+    const o = m({
       propertySignatures: i.propertySignatures
     });
-    if (Object.values(a).every((s) => s && "type" in s))
-      return a;
-    const u = (s, o = "") => {
-      for (const r in s) {
-        const l = o ? `${o}.${r}` : r;
-        s[r] && typeof s[r] == "object" && "type" in s[r] ? n[l] = s[r] : s[r] && typeof s[r] == "object" && u(s[r], l);
+    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);
       }
     };
-    u(a);
+    l(o);
   }
-  return n;
-}, M = (e) => t.extend(e, t.Struct({})), N = (e) => {
-  const i = y(e), n = S(
+  return t;
+}, N = (e) => n.extend(e, n.Struct({})), _ = (e) => {
+  const i = v(e), t = O(
     e.ast,
-    g.liftPredicate((a) => a._tag === "Refinement" && "filter" in a),
-    g.flatMap((a) => t.AST.getJSONSchemaAnnotation(a)),
-    g.filter((a) => "items" in a),
-    g.filterMap(
-      ({ items: a }) => t.decodeUnknownOption(x)(a)
+    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)
     ),
-    g.zipWith(
-      t.AST.getMessageAnnotation(e.ast),
-      (a, u) => ({
-        items: a,
-        message: u("")
+    f.zipWith(
+      n.AST.getMessageAnnotation(e.ast),
+      (o, l) => ({
+        items: o,
+        message: l("")
       })
     ),
-    g.getOrUndefined
+    f.getOrUndefined
   );
-  return { schema: e, meta: i, filterItems: n };
-}, L = (e) => {
-  const { trans: i } = v();
-  let n;
+  return { schema: e, meta: i, filterItems: t };
+}, k = (e) => {
+  const { trans: i } = A();
+  let t;
   switch (e.type) {
     case "string":
-      n = t.String.annotations({
+      t = n.String.annotations({
         message: () => i("validation.empty")
-      }), e.format === "email" && (n = t.compose(
-        n,
-        t.Email.annotations({
+      }), e.format === "email" && (t = n.compose(
+        t,
+        n.Email.annotations({
           message: () => i("validation.email.invalid")
         })
-      )), e.required && n.annotations({
+      )), e.required && t.annotations({
         message: () => i("validation.empty")
-      }), e.maxLength && (n = n.pipe(t.maxLength(e.maxLength)).annotations({
+      }), e.maxLength && (t = t.pipe(n.maxLength(e.maxLength)).annotations({
         message: () => i("validation.string.maxLength", {
           maxLength: e.maxLength
         })
-      })), e.minLength && (n = n.pipe(t.minLength(e.minLength)).annotations({
+      })), e.minLength && (t = t.pipe(n.minLength(e.minLength)).annotations({
         message: () => i("validation.string.minLength", {
           minLength: e.minLength
         })
       }));
       break;
     case "number":
-      n = t.Number.annotations({
+      t = n.Number.annotations({
         message: () => i("validation.empty")
-      }), e.required && n.annotations({
+      }), e.required && t.annotations({
         message: () => i("validation.empty")
-      }), e.minimum && (n = n.pipe(t.greaterThanOrEqualTo(e.minimum)).annotations({
+      }), e.minimum && (t = t.pipe(n.greaterThanOrEqualTo(e.minimum)).annotations({
         message: () => i("validation.number.min", {
           minimum: e.minimum,
           isExclusive: !0
         })
-      })), e.maximum && (n = n.pipe(t.lessThanOrEqualTo(e.maximum)).annotations({
+      })), e.maximum && (t = t.pipe(n.lessThanOrEqualTo(e.maximum)).annotations({
         message: () => i("validation.number.max", {
           maximum: e.maximum,
           isExclusive: !0
         })
-      })), e.exclusiveMinimum && (n = n.pipe(t.greaterThan(e.exclusiveMinimum)).annotations({
+      })), e.exclusiveMinimum && (t = t.pipe(n.greaterThan(e.exclusiveMinimum)).annotations({
         message: () => i("validation.number.min", {
           minimum: e.exclusiveMinimum,
           isExclusive: !1
         })
-      })), e.exclusiveMaximum && (n = n.pipe(t.lessThan(e.exclusiveMaximum)).annotations({
+      })), e.exclusiveMaximum && (t = t.pipe(n.lessThan(e.exclusiveMaximum)).annotations({
         message: () => i("validation.number.max", {
           maximum: e.exclusiveMaximum,
           isExclusive: !1
@@ -202,7 +250,7 @@ const x = t.NonEmptyArray(t.String), T = (e) => t.AST.isUnion(e) && e.types.find
       }));
       break;
     case "select":
-      n = t.Literal(...e.members).annotations({
+      t = n.Literal(...e.members).annotations({
         message: () => ({
           message: i("validation.not_a_valid", {
             type: "select",
@@ -213,7 +261,7 @@ const x = t.NonEmptyArray(t.String), T = (e) => t.AST.isUnion(e) && e.types.find
       });
       break;
     case "multiple":
-      n = t.Array(t.String).annotations({
+      t = n.Array(n.String).annotations({
         message: () => i("validation.not_a_valid", {
           type: "multiple",
           message: e.members.join(", ")
@@ -221,28 +269,28 @@ const x = t.NonEmptyArray(t.String), T = (e) => t.AST.isUnion(e) && e.types.find
       });
       break;
     case "boolean":
-      n = t.Boolean;
+      t = n.Boolean;
       break;
     // todo: switch must be exhaustive or have default case, otherwise falls through with schema undefined.
     case "unknown":
-      n = t.Unknown;
+      t = n.Unknown;
       break;
   }
-  return e.required ? n.pipe(
-    t.annotations({
+  return e.required ? t.pipe(
+    n.annotations({
       message: () => i("validation.empty")
     })
-  ) : n = t.NullishOr(n), t.standardSchemaV1(n);
-}, U = (e, i) => t.NullOr(e).pipe(
-  t.transform(t.typeSchema(e), {
-    decode: (n) => n ?? i(),
-    encode: (n) => n
+  ) : t = n.NullishOr(t), n.standardSchemaV1(t);
+}, w = (e, i) => n.NullOr(e).pipe(
+  n.transform(n.typeSchema(e), {
+    decode: (t) => t ?? i(),
+    encode: (t) => t
   })
 );
 export {
   m as createMeta,
-  M as duplicateSchema,
-  L as generateInputStandardSchemaFromFieldMeta,
-  N as generateMetaFromSchema,
-  U as nullableInput
+  N as duplicateSchema,
+  k as generateInputStandardSchemaFromFieldMeta,
+  _ as generateMetaFromSchema,
+  w as nullableInput
 };

package/dist/vue-components.es7.js

@@ -1,6 +1,5 @@
-import { defineComponent as y, computed as u, onMounted as c, provide as g, createElementBlock as M, openBlock as p, Fragment as v, renderList as _, createBlock as h, resolveDynamicComponent as k, withCtx as F, renderSlot as S, mergeProps as $ } from "vue";
-import { createMeta as A } from "./vue-components.es10.js";
-const C = /* @__PURE__ */ y({
+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({
   inheritAttrs: !1,
   __name: "OmegaArray",
   props: {
@@ -10,41 +9,23 @@ const C = /* @__PURE__ */ y({
     items: {}
   },
   setup(l) {
-    const t = l, i = t.form.useStore((e) => e.values), m = u(() => t.name.split(".").reduce((e, a) => e[a], i.value));
-    c(async () => {
-      t.defaultItems && !m.value && t.form.setFieldValue(t.name, t.defaultItems);
+    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);
     });
-    const f = u(() => {
-      const e = t.form.meta[t.name];
-      if (e && e.type === "multiple") {
-        const a = e.rest.reduce((r, n) => n.type._tag === "TypeLiteral" ? {
-          ...r,
-          propertySignatures: [
-            ...r.propertySignatures || [],
-            ...n.type.propertySignatures
-          ]
-        } : {
-          ...r,
-          property: n.type
-        }, {}), s = A({ ...a, meta: e });
-        return (r) => {
-          if (r.endsWith("]")) return s;
-          const n = r.split("]."), d = n[n.length - 1];
-          return s[d];
-        };
-      }
-      return (a) => {
-      };
+    const d = m(() => (r) => {
+      const a = r.replace(/\[\d+\]/g, "");
+      return t.form.meta[a];
     });
-    return g("getMetaFromArray", f), (e, a) => (p(!0), M(v, null, _(m.value, (s, o) => (p(), h(k(e.form.Field), {
-      key: `${e.name}[${Number(o)}]`,
-      name: `${e.name}[${Number(o)}]`
+    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: F(({ field: r, state: n }) => [
-        S(e.$slots, "default", $({ ref_for: !0 }, {
-          subField: r,
-          subState: n,
-          index: Number(o)
+      default: _(({ field: c, state: f }) => [
+        $(e.$slots, "default", k({ ref_for: !0 }, {
+          subField: c,
+          subState: f,
+          index: Number(n)
         }))
       ]),
       _: 2
@@ -52,5 +33,5 @@ const C = /* @__PURE__ */ y({
   }
 });
 export {
-  C as default
+  P as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "0.14.2",
+  "version": "0.14.5",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
     "@tanstack/vue-form": "^1.2.4",
@@ -50,8 +50,8 @@
   "dependencies": {
     "highlight.js": "^11.11.1",
     "vue3-highlightjs": "^1.0.5",
-    "@effect-app/vue": "2.51.11",
-    "effect-app": "3.0.10"
+    "@effect-app/vue": "2.51.13",
+    "effect-app": "3.1.0"
   },
   "scripts": {
     "build": "pnpm build:run",

package/src/components/OmegaForm/OmegaArray.vue

@@ -29,9 +29,7 @@
 >
 import { computed, onMounted, provide } from "vue"
 import {
-  type CreateMeta,
   type OmegaInputProps,
-  createMeta,
 } from "./OmegaFormStuff"
 import { type DeepValue, type DeepKeys } from "@tanstack/vue-form"
 
@@ -52,10 +50,8 @@ defineOptions({
 
 const store = props.form.useStore(state => state.values)
 const items = computed(() => {
-  return props.name.split(".").reduce((acc, curr) => {
-    if (curr === "items") {
-      return acc[curr]
-    }
+  const normalizedPath = props.name.replace(/\[/g, ".").replace(/\]/g, "")
+  return normalizedPath.split(".").reduce((acc, curr) => {
     return acc[curr] as typeof store.value
   }, store.value)
 })
@@ -67,34 +63,14 @@ onMounted(async () => {
 })
 
 const getMetaFromArray = computed(() => {
-  const inputMeta = props.form.meta[props.name]
-  if (inputMeta && inputMeta.type === "multiple") {
-    const result = inputMeta.rest.reduce<CreateMeta>((acc, curr) => {
-      if (curr.type._tag === "TypeLiteral") {
-        return {
-          ...acc,
-          propertySignatures: [
-            ...(acc.propertySignatures || []),
-            ...curr.type.propertySignatures,
-          ],
-        } as CreateMeta
-      }
-      return {
-        ...acc,
-        property: curr.type,
-      } as CreateMeta
-    }, {} as CreateMeta)
+  const getMeta = (path: string) => {
+    // Transform path like 'a[0].b[11].c' into 'a.b.c'
+    const simplifiedPath = path.replace(/\[\d+\]/g, '')
 
-    const arrayMeta = createMeta({ ...result, meta: inputMeta })
-    const getMeta = (index: string) => {
-      if (index.endsWith("]")) return arrayMeta
-      const parts = index.split("].")
-      const key = parts[parts.length - 1]
-      return arrayMeta[key as keyof typeof arrayMeta]
-    }
-    return getMeta
+    return props.form.meta[simplifiedPath as keyof typeof props.form.meta]
   }
-  return (_: string) => undefined
+  
+  return getMeta
 })
 
 provide("getMetaFromArray", getMetaFromArray)

package/src/components/OmegaForm/OmegaFormStuff.ts

@@ -255,6 +255,7 @@ export const createMeta = <T = any>(
       const key = parent ? `${parent}.${p.name.toString()}` : p.name.toString()
       const nullableOrUndefined = isNullableOrUndefined(p.type)
       const isRequired = !nullableOrUndefined
+      
 
       const typeToProcess = p.type
       if (S.AST.isUnion(p.type)) {
@@ -308,12 +309,79 @@ export const createMeta = <T = any>(
           })
         )
       } else {
-        const newMeta = createMeta<T>({
-          parent: key,
-          property: p.type,
-          meta: { required: isRequired, nullableOrUndefined },
-        })
-        acc[key as NestedKeyOf<T>] = newMeta as FieldMeta
+        // Check if this is an array type
+        if (S.AST.isTupleType(p.type)) {
+          // Check if it has struct elements
+          const hasStructElements = p.type.rest.length > 0 && 
+            p.type.rest[0].type._tag === "TypeLiteral" && 
+            "propertySignatures" in p.type.rest[0].type
+          
+          if (hasStructElements) {
+            // For arrays with struct elements, only create meta for nested fields, not the array itself
+            const elementType = p.type.rest[0].type
+            if (elementType._tag === "TypeLiteral" && "propertySignatures" in elementType) {
+              // Process each property in the array element
+              for (const prop of elementType.propertySignatures) {
+                const propKey = `${key}.${prop.name.toString()}`
+                
+                // Check if the property is another array
+                if (S.AST.isTupleType(prop.type) && prop.type.rest.length > 0) {
+                  const nestedElementType = prop.type.rest[0].type
+                  if (nestedElementType._tag === "TypeLiteral" && "propertySignatures" in nestedElementType) {
+                    // Array with struct elements - process nested fields
+                    for (const nestedProp of nestedElementType.propertySignatures) {
+                      const nestedKey = `${propKey}.${nestedProp.name.toString()}`
+                      const nestedMeta = createMeta<T>({
+                        parent: nestedKey,
+                        property: nestedProp.type,
+                        meta: {
+                          required: !isNullableOrUndefined(nestedProp.type),
+                          nullableOrUndefined: isNullableOrUndefined(nestedProp.type)
+                        }
+                      })
+                      acc[nestedKey as NestedKeyOf<T>] = nestedMeta as FieldMeta
+                    }
+                  } else {
+                    // Array with primitive elements - create meta for the array itself
+                    acc[propKey as NestedKeyOf<T>] = {
+                      type: "multiple",
+                      members: prop.type.elements,
+                      rest: prop.type.rest,
+                      required: !isNullableOrUndefined(prop.type),
+                      nullableOrUndefined: isNullableOrUndefined(prop.type)
+                    } as FieldMeta
+                  }
+                } else {
+                  const fieldMeta = createMeta<T>({
+                    parent: propKey,
+                    property: prop.type,
+                    meta: {
+                      required: !isNullableOrUndefined(prop.type),
+                      nullableOrUndefined: isNullableOrUndefined(prop.type)
+                    }
+                  })
+                  acc[propKey as NestedKeyOf<T>] = fieldMeta as FieldMeta
+                }
+              }
+            }
+          } else {
+            // For arrays with primitive elements, create the array meta
+            acc[key as NestedKeyOf<T>] = {
+              type: "multiple",
+              members: p.type.elements,
+              rest: p.type.rest,
+              required: isRequired,
+              nullableOrUndefined
+            } as FieldMeta
+          }
+        } else {
+          const newMeta = createMeta<T>({
+            parent: key,
+            property: p.type,
+            meta: { required: isRequired, nullableOrUndefined },
+          })
+          acc[key as NestedKeyOf<T>] = newMeta as FieldMeta
+        }
       }
     }
     return acc