@effect-app/vue-components 2.10.5 → 2.10.7

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

@@ -25,6 +25,7 @@ export declare class FormErrors<From> extends FormErrors_base<{
     }>;
 }> {
 }
+export declare const useErrorLabel: (form: OF<any, any>) => (propsName: string) => string;
 export type Policies = "local" | "session" | "querystring";
 export type defaultValuesPriorityUnion = "tanstack" | "persistency" | "schema";
 export type OmegaConfig<T> = {

package/dist/vue-components.es10.js

@@ -1,233 +1,238 @@
 import { useForm as B } from "@tanstack/vue-form";
-import { Data as K, S as $, Effect as l, Fiber as x, Option as P, Array as F } from "effect-app";
+import { Data as K, S as V, Effect as f, Fiber as $, Option as P, Array as F } from "effect-app";
 import { runtimeFiberAsPromise as T } from "./vue-components.es17.js";
-import { computed as U, onUnmounted as N, onMounted as G, onBeforeUnmount as z, watch as W, ref as Q, h as H } from "vue";
+import { computed as x, onUnmounted as W, onMounted as z, onBeforeUnmount as G, watch as D, ref as Z, h as H } from "vue";
+import { useIntl as Q } from "./vue-components.es3.js";
 import X from "./vue-components.es18.js";
 import Y from "./vue-components.es19.js";
-import Z from "./vue-components.es20.js";
-import { generateMetaFromSchema as C, deepMerge as D, defaultsValueFromSchema as ee } from "./vue-components.es12.js";
-import re from "./vue-components.es6.js";
-import te from "./vue-components.es8.js";
-import se from "./vue-components.es21.js";
-import { trace as R } from "./vue-components.es22.js";
-import { context as L } from "./vue-components.es23.js";
-class ne extends K.TaggedError("FormErrors") {
+import C from "./vue-components.es20.js";
+import { generateMetaFromSchema as ee, deepMerge as R, defaultsValueFromSchema as re } from "./vue-components.es12.js";
+import te from "./vue-components.es6.js";
+import se from "./vue-components.es8.js";
+import ne from "./vue-components.es21.js";
+import { trace as N } from "./vue-components.es22.js";
+import { context as U } from "./vue-components.es23.js";
+class oe extends K.TaggedError("FormErrors") {
 }
-const g = (a) => function(n) {
+const g = (i) => function(n) {
   return {
     render() {
       return H(n, {
-        form: a,
+        form: i,
         ...this.$attrs
       }, this.$slots);
     }
   };
-}, oe = (a) => function(n) {
+}, ie = (i) => {
+  const { formatMessage: l } = Q(), n = (a) => a.replace(/([A-Z])/g, " $1").replace(/^./, (d) => d.toUpperCase()).trim(), m = (a) => l ? l({ id: `general.fields.${a}`, defaultMessage: n(a) }) : n(a);
+  return (a) => i.i18nNamespace ? l({ id: `${i.i18nNamespace}.fields.${a}`, defaultMessage: m(a) }) : m(a);
+}, ae = (i) => function(n) {
   return {
     setup() {
-      const { fieldMap: b, form: h } = a, y = h.useStore((d) => d.errors), m = h.useStore((d) => d.fieldMeta), M = h.useStore((d) => d.errorMap), j = U(() => {
-        const d = F.filterMap(
-          Object.entries(m.value),
-          ([O, f]) => {
-            const S = f.errors ?? [];
-            if (!S.length) return P.none();
-            const c = b.value.get(O);
-            return c ? P.some({
-              label: c.label,
-              inputId: c.id,
+      const { fieldMap: m, form: p } = i, a = p.useStore((s) => s.errors), d = p.useStore((s) => s.fieldMeta), M = p.useStore((s) => s.errorMap), j = ie(p), A = x(() => {
+        const s = F.filterMap(
+          Object.entries(d.value),
+          ([E, v]) => {
+            const h = v.errors ?? [];
+            if (!h.length) return P.none();
+            const u = m.value.get(E);
+            return u ? P.some({
+              label: u.label,
+              inputId: u.id,
               // Only show the first error
-              errors: [S[0]?.message].filter(Boolean)
+              errors: [h[0]?.message].filter(Boolean)
             }) : P.none();
           }
-        ), o = [];
+        ), O = [];
         if (M.value.onSubmit) {
-          for (const [O, f] of Object.entries(M.value.onSubmit))
-            if (F.isArray(f) && f.length)
-              for (const S of f) {
-                const c = S;
-                if (c?.path && F.isArray(c.path) && c.path.length) {
-                  const E = c.path.join(".");
-                  if (!b.value.has(E)) {
-                    o.push({
-                      label: E,
-                      inputId: E,
-                      errors: [c.message].filter(Boolean)
+          for (const [E, v] of Object.entries(M.value.onSubmit))
+            if (F.isArray(v) && v.length)
+              for (const h of v) {
+                const u = h;
+                if (u?.path && F.isArray(u.path) && u.path.length) {
+                  const y = u.path.join(".");
+                  if (!m.value.has(y)) {
+                    O.push({
+                      label: j(y),
+                      inputId: y,
+                      errors: [u.message].filter(Boolean)
                     });
                     break;
                   }
                 }
               }
         }
-        return [...d, ...o];
+        return [...s, ...O];
       });
       return {
-        generalErrors: y,
-        errors: j
+        generalErrors: a,
+        errors: A
       };
     },
-    render({ errors: b, generalErrors: h }) {
+    render({ errors: m, generalErrors: p }) {
       return H(n, {
-        errors: b,
-        generalErrors: h,
+        errors: m,
+        generalErrors: p,
         ...this.$attrs
       }, this.$slots);
     }
   };
-}, v = (a, u) => a.includes(u), be = (a, u, n) => {
-  if (!a) throw new Error("Schema is required");
-  const b = $.standardSchemaV1(a), h = $.decode(a), { meta: y } = C(a), m = U(() => {
+}, b = (i, l) => i.includes(l), ge = (i, l, n) => {
+  if (!i) throw new Error("Schema is required");
+  const m = V.standardSchemaV1(i), p = V.decode(i), { meta: a } = ee(i), d = x(() => {
     if (n?.persistency?.id)
       return n.persistency.id;
-    const e = window.location.pathname, r = Object.keys(y);
+    const e = window.location.pathname, r = Object.keys(a);
     return `${e}-${r.join("-")}`;
   }), M = () => {
     const e = new URLSearchParams(window.location.search);
-    e.delete(m.value);
+    e.delete(d.value);
     const r = new URL(window.location.href);
     r.search = e.toString(), window.history.replaceState({}, "", r.toString());
-  }, j = U(() => {
+  }, j = x(() => {
     let e;
     const r = n?.persistency;
     if (
       // query string has higher priority than local/session storage
-      r?.policies && !e && (v(r.policies, "local") || v(r.policies, "session"))
+      r?.policies && !e && (b(r.policies, "local") || b(r.policies, "session"))
     ) {
-      const s = v(r.policies, "local") ? localStorage : sessionStorage;
-      if (s)
+      const o = b(r.policies, "local") ? localStorage : sessionStorage;
+      if (o)
         try {
           const t = JSON.parse(
-            s.getItem(m.value) || "{}"
+            o.getItem(d.value) || "{}"
           );
-          s.removeItem(m.value), e = t;
+          o.removeItem(d.value), e = t;
         } catch (t) {
           console.error(t);
         }
     }
-    if (r?.policies && v(r.policies, "querystring"))
+    if (r?.policies && b(r.policies, "querystring"))
       try {
-        const t = new URLSearchParams(window.location.search).get(m.value);
-        M(), t && (e = D(e || {}, JSON.parse(t)));
-      } catch (s) {
-        console.error(s);
+        const t = new URLSearchParams(window.location.search).get(d.value);
+        M(), t && (e = R(e || {}, JSON.parse(t)));
+      } catch (o) {
+        console.error(o);
       }
     e ??= {};
-    const i = {
-      tanstack: u?.defaultValues || {},
+    const c = {
+      tanstack: l?.defaultValues || {},
       persistency: e,
-      schema: ee(a)
+      schema: re(i)
     };
     return (n?.defaultValuesPriority || ["tanstack", "persistency", "schema"]).reverse().reduce(
-      (s, t) => Object.keys(s).length ? D(s, i[t]) : i[t],
+      (o, t) => Object.keys(o).length ? R(o, c[t]) : c[t],
       {}
     );
-  }), d = (e, r) => e ? L.with(R.setSpan(L.active(), e), r) : r(), o = B({
-    ...u,
+  }), A = (e, r) => e ? U.with(N.setSpan(U.active(), e), r) : r(), s = B({
+    ...l,
     validators: {
-      onSubmit: b,
-      ...u?.validators || {}
+      onSubmit: m,
+      ...l?.validators || {}
     },
-    onSubmit: u?.onSubmit ? ({ formApi: e, meta: r, value: i }) => d(r?.currentSpan, async () => {
-      const s = await l.runPromise(h(i)), t = u.onSubmit({
+    onSubmit: l?.onSubmit ? ({ formApi: e, meta: r, value: c }) => A(r?.currentSpan, async () => {
+      const o = await f.runPromise(p(c)), t = l.onSubmit({
         formApi: e,
         meta: r,
-        value: s
+        value: o
       });
-      return x.isFiber(t) && x.isRuntimeFiber(t) ? await T(t) : l.isEffect(t) ? await l.runPromise(
+      return $.isFiber(t) && $.isRuntimeFiber(t) ? await T(t) : f.isEffect(t) ? await f.runPromise(
         t.pipe(
           // meta?.currentSpan
           //   ? Effect.withParentSpan(meta.currentSpan)
           //   : (_) => _,
-          l.flatMap((p) => x.join(p))
+          f.flatMap((S) => $.join(S))
         )
       ) : t;
     }) : void 0,
     defaultValues: j.value
   }), O = () => {
-    Object.keys(y).forEach((e) => {
-      o.setFieldValue(e, void 0);
+    Object.keys(a).forEach((e) => {
+      s.setFieldValue(e, void 0);
     });
-  }, f = (e) => e.reduce((r, i) => {
-    const s = i.split(".");
-    return s.reduce((t, p, A) => (A === s.length - 1 ? t[p] = o.getFieldValue(i) : t[p] = t[p] ?? {}, t[p]), r), r;
-  }, {}), S = (e) => {
+  }, E = (e) => e.reduce((r, c) => {
+    const o = c.split(".");
+    return o.reduce((t, S, _) => (_ === o.length - 1 ? t[S] = s.getFieldValue(c) : t[S] = t[S] ?? {}, t[S]), r), r;
+  }, {}), v = (e) => {
     if (e) {
       if (F.isArray(e.keys))
-        return f(e.keys);
+        return E(e.keys);
       if (F.isArray(e.banKeys)) {
-        const r = Object.keys(y).filter((i) => e.banKeys?.includes(i));
-        return f(r);
+        const r = Object.keys(a).filter((c) => e.banKeys?.includes(c));
+        return E(r);
       }
-      return o.store.state.values;
+      return s.store.state.values;
     }
-  }, c = () => {
+  }, h = () => {
     const e = n?.persistency;
-    if (!(!e?.policies || e.policies.length === 0) && (v(e.policies, "local") || v(e.policies, "session"))) {
-      const r = v(e.policies, "local") ? localStorage : sessionStorage;
+    if (!(!e?.policies || e.policies.length === 0) && (b(e.policies, "local") || b(e.policies, "session"))) {
+      const r = b(e.policies, "local") ? localStorage : sessionStorage;
       if (!r) return;
-      const i = S(e);
-      return r.setItem(m.value, JSON.stringify(i));
+      const c = v(e);
+      return r.setItem(d.value, JSON.stringify(c));
     }
-  }, E = () => {
+  }, u = () => {
     const e = n?.persistency;
-    if (!(!e?.policies || e.policies.length === 0) && v(e.policies, "querystring")) {
-      const r = S(e), i = new URLSearchParams(window.location.search);
-      i.set(m.value, JSON.stringify(r));
-      const s = new URL(window.location.href);
-      s.search = i.toString(), window.history.replaceState({}, "", s.toString());
+    if (!(!e?.policies || e.policies.length === 0) && b(e.policies, "querystring")) {
+      const r = v(e), c = new URLSearchParams(window.location.search);
+      c.set(d.value, JSON.stringify(r));
+      const o = new URL(window.location.href);
+      o.search = c.toString(), window.history.replaceState({}, "", o.toString());
     }
-  }, V = (e) => {
-    o.store.state.isDirty && e.preventDefault();
+  }, y = (e) => {
+    s.store.state.isDirty && e.preventDefault();
   };
-  if (N(c), G(() => {
-    window.addEventListener("beforeunload", c), window.addEventListener("blur", E), n?.preventWindowExit && n.preventWindowExit !== "nope" && window.addEventListener("beforeunload", V);
-  }), z(() => {
-    window.removeEventListener("beforeunload", c), window.removeEventListener("blur", E), n?.preventWindowExit && n.preventWindowExit !== "nope" && window.removeEventListener("beforeunload", V);
+  if (W(h), z(() => {
+    window.addEventListener("beforeunload", h), window.addEventListener("blur", u), n?.preventWindowExit && n.preventWindowExit !== "nope" && window.addEventListener("beforeunload", y);
+  }), G(() => {
+    window.removeEventListener("beforeunload", h), window.removeEventListener("blur", u), n?.preventWindowExit && n.preventWindowExit !== "nope" && window.removeEventListener("beforeunload", y);
   }), n?.preventWindowExit === "prevent-and-reset") {
-    const e = o.useStore((t) => t.isSubmitting), r = o.useStore((t) => t.submissionAttempts), i = o.useStore((t) => t.canSubmit), s = o.useStore((t) => t.values);
-    W([e, r], ([t, p], [A]) => {
-      A && !t && p > 0 && i.value && o.reset(s.value);
+    const e = s.useStore((t) => t.isSubmitting), r = s.useStore((t) => t.submissionAttempts), c = s.useStore((t) => t.canSubmit), o = s.useStore((t) => t.values);
+    D([e, r], ([t, S], [_]) => {
+      _ && !t && S > 0 && c.value && s.reset(o.value);
     });
   }
-  const k = (e) => l.currentSpan.pipe(
-    l.option,
-    l.flatMap(
-      (r) => l.promise(() => o.handleSubmit(P.isSome(r) ? { currentSpan: r.value, ...e } : e))
+  const k = (e) => f.currentSpan.pipe(
+    f.option,
+    f.flatMap(
+      (r) => f.promise(() => s.handleSubmit(P.isSome(r) ? { currentSpan: r.value, ...e } : e))
     )
-  ), J = (e) => e?.checkErrors ? k(e?.meta).pipe(l.flatMap(l.fnUntraced(function* () {
-    const r = o.getAllErrors();
+  ), J = (e) => e?.checkErrors ? k(e?.meta).pipe(f.flatMap(f.fnUntraced(function* () {
+    const r = s.getAllErrors();
     if (Object.keys(r.fields).length || r.form.errors.length)
-      return yield* new ne({ form: r.form, fields: r.fields });
-  }))) : k(e?.meta), q = o.handleSubmit, _ = Q(/* @__PURE__ */ new Map()), w = Object.assign(o, {
+      return yield* new oe({ form: r.form, fields: r.fields });
+  }))) : k(e?.meta), q = s.handleSubmit, L = Z(/* @__PURE__ */ new Map()), w = Object.assign(s, {
     i18nNamespace: n?.i18nNamespace,
     ignorePreventCloseEvents: n?.ignorePreventCloseEvents,
-    meta: y,
+    meta: a,
     clear: O,
     handleSubmit: (e) => {
-      const r = R.getSpan(L.active());
+      const r = N.getSpan(U.active());
       return q({ currentSpan: r, ...e });
     },
     // /** @experimental */
     handleSubmitEffect: J,
     registerField: (e) => {
-      W(e, (r) => _.value.set(r.name, { label: r.label, id: r.id }), { immediate: !0 }), N(() => _.value.delete(e.value.name));
+      D(e, (r) => L.value.set(r.name, { label: r.label, id: r.id }), { immediate: !0 }), W(() => L.value.delete(e.value.name));
     }
-  }), I = { form: w, fieldMap: _ };
+  }), I = { form: w, fieldMap: L };
   return Object.assign(w, {
     // Type-level properties for performance optimization (not used at runtime)
     _paths: void 0,
     _keys: void 0,
-    _schema: a,
+    _schema: i,
     errorContext: I,
-    Form: g(w)(se),
-    Input: g(w)(n?.input ?? re),
-    TaggedUnion: g(w)(te),
-    Field: o.Field,
-    Errors: oe(I)(Z),
+    Form: g(w)(ne),
+    Input: g(w)(n?.input ?? te),
+    TaggedUnion: g(w)(se),
+    Field: s.Field,
+    Errors: ae(I)(C),
     Array: g(w)(X),
     AutoGen: g(w)(Y)
   });
 };
 export {
-  ne as FormErrors,
-  be as useOmegaForm
+  oe as FormErrors,
+  ie as useErrorLabel,
+  ge as useOmegaForm
 };

package/dist/vue-components.es12.js

@@ -1,270 +1,273 @@
-import { S as i, Option as M } from "effect-app";
+import { S as r, Option as q } from "effect-app";
 import { getMetadataFromSchema as k } from "@effect-app/vue/form";
-import { useIntl as V, getTransformationFrom as q } from "./vue-components.es3.js";
+import { useIntl as V, getTransformationFrom as _ } 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), 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, w = (e) => {
+const $ = (e) => r.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKeyword" || n === r.Null.ast), g = (e) => !e || !r.AST.isUnion(e) ? !1 : e.types.find((n) => n._tag === "UndefinedKeyword") ? "undefined" : e.types.find((n) => n === r.Null.ast) ? "null" : !1, L = (e) => {
   const n = [];
   for (const t of e)
-    if (i.AST.isUnion(t)) {
-      const l = w(t.types);
-      n.push(...l);
+    if (r.AST.isUnion(t)) {
+      const p = L(t.types);
+      n.push(...p);
     } else
       n.push(t);
   return n;
-}, m = ({ meta: e = {}, parent: n = "", property: t, propertySignatures: l }, o = {}) => {
+}, f = ({ meta: e = {}, parent: n = "", property: t, propertySignatures: p }, o = {}) => {
   if (t && t._tag === "Transformation")
-    return m({
+    return f({
       parent: n,
       meta: e,
       property: t.from
     });
   if (t?._tag === "TypeLiteral" && "propertySignatures" in t)
-    return m({
+    return f({
       meta: e,
       propertySignatures: t.propertySignatures
     });
-  if (l) {
-    for (const s of l) {
-      const r = n ? `${n}.${s.name.toString()}` : s.name.toString(), p = g(s.type);
+  if (p) {
+    for (const s of p) {
+      const i = n ? `${n}.${s.name.toString()}` : s.name.toString(), l = g(s.type);
       let a;
-      e._isNullableDiscriminatedUnion && s.name.toString() === "_tag" || e.required === !1 ? a = !1 : a = !p;
-      const f = s.type;
-      if (i.AST.isUnion(s.type)) {
-        const S = w(s.type.types).filter(
-          (u) => u._tag !== "UndefinedKeyword" && u !== i.Null.ast
-        ).map(q);
-        if (S.some(
+      e._isNullableDiscriminatedUnion && s.name.toString() === "_tag" || e.required === !1 ? a = !1 : a = !l;
+      const m = s.type;
+      if (r.AST.isUnion(s.type)) {
+        const c = L(s.type.types).filter(
+          (u) => u._tag !== "UndefinedKeyword" && u !== r.Null.ast
+        ).map(_);
+        if (c.some(
           (u) => "propertySignatures" in u
         )) {
-          if (!p) {
-            const u = m({
-              parent: r,
+          if (!l) {
+            const u = f({
+              parent: i,
               property: s.type,
-              meta: { required: a, nullableOrUndefined: p }
+              meta: { required: a, nullableOrUndefined: l }
             });
-            o[r] = u;
+            o[i] = u;
           }
-          for (const u of S)
+          for (const u of c)
             if ("propertySignatures" in u) {
-              const y = p && S.length > 1;
+              const y = l && c.length > 1;
               Object.assign(
                 o,
-                m({
-                  parent: r,
+                f({
+                  parent: i,
                   propertySignatures: u.propertySignatures,
                   meta: y ? { _isNullableDiscriminatedUnion: !0 } : {}
                 })
               );
             }
         } else {
-          const u = S.filter(i.AST.isTupleType);
+          const u = c.filter(r.AST.isTupleType);
           if (u.length > 0) {
             const y = u[0];
-            if (o[r] = {
+            if (o[i] = {
               type: "multiple",
               members: y.elements,
               rest: y.rest,
               required: a,
-              nullableOrUndefined: p
+              nullableOrUndefined: l
             }, y.rest && y.rest.length > 0) {
-              const b = y.rest[0];
-              if (b.type._tag === "TypeLiteral" && "propertySignatures" in b.type)
-                for (const c of b.type.propertySignatures) {
-                  const h = `${r}.${c.name.toString()}`, x = m({
+              const S = y.rest[0];
+              if (S.type._tag === "TypeLiteral" && "propertySignatures" in S.type)
+                for (const d of S.type.propertySignatures) {
+                  const h = `${i}.${d.name.toString()}`, T = f({
                     parent: h,
-                    property: c.type,
+                    property: d.type,
                     meta: {
-                      required: !g(c.type),
-                      nullableOrUndefined: g(c.type)
+                      required: !g(d.type),
+                      nullableOrUndefined: g(d.type)
                     }
                   });
-                  if (x && typeof x == "object" && "type" in x && (o[h] = x, x.type === "multiple" && i.AST.isTupleType(c.type) && c.type.rest && c.type.rest.length > 0)) {
-                    const U = c.type.rest[0];
-                    if (U.type._tag === "TypeLiteral" && "propertySignatures" in U.type)
-                      for (const A of U.type.propertySignatures) {
-                        const L = `${h}.${A.name.toString()}`, O = m({
-                          parent: L,
+                  if (T && typeof T == "object" && "type" in T && (o[h] = T, T.type === "multiple" && r.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 M = `${h}.${A.name.toString()}`, O = f({
+                          parent: M,
                           property: A.type,
                           meta: {
                             required: !g(A.type),
                             nullableOrUndefined: g(A.type)
                           }
                         });
-                        O && typeof O == "object" && "type" in O && (o[L] = O);
+                        O && typeof O == "object" && "type" in O && (o[M] = O);
                       }
                   }
                 }
             }
           } else {
-            const y = m({
-              parent: r,
+            const y = f({
+              parent: i,
               property: s.type,
-              meta: { required: a, nullableOrUndefined: p }
+              meta: { required: a, nullableOrUndefined: l }
             });
-            o[r] = y;
+            o[i] = y;
           }
         }
-      } else if ("propertySignatures" in f)
-        Object.assign(
-          o,
-          m({
-            parent: r,
-            propertySignatures: f.propertySignatures,
-            meta: { required: a, nullableOrUndefined: p }
-          })
-        );
-      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 S = s.type.rest[0].type;
-          if (S._tag === "TypeLiteral" && "propertySignatures" in S)
-            for (const d of S.propertySignatures) {
-              const u = `${r}.${d.name.toString()}`;
-              if (i.AST.isTupleType(d.type) && d.type.rest.length > 0) {
-                const y = d.type.rest[0].type;
-                if (y._tag === "TypeLiteral" && "propertySignatures" in y)
-                  for (const b of y.propertySignatures) {
-                    const c = `${u}.${b.name.toString()}`, h = m({
-                      parent: c,
-                      property: b.type,
-                      meta: {
-                        required: !g(b.type),
-                        nullableOrUndefined: g(b.type)
-                      }
-                    });
-                    o[c] = h;
-                  }
-                else
-                  o[u] = {
-                    type: "multiple",
-                    members: d.type.elements,
-                    rest: d.type.rest,
-                    required: !g(d.type),
-                    nullableOrUndefined: g(d.type)
-                  };
-              } else {
-                const y = m({
-                  parent: u,
-                  property: d.type,
-                  meta: {
-                    required: !g(d.type),
-                    nullableOrUndefined: g(d.type)
-                  }
-                });
-                o[u] = y;
+      } else {
+        const b = _(m);
+        if ("propertySignatures" in b)
+          Object.assign(
+            o,
+            f({
+              parent: i,
+              propertySignatures: b.propertySignatures,
+              meta: { required: a, nullableOrUndefined: l }
+            })
+          );
+        else if (r.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 v = s.type.rest[0].type;
+            if (v._tag === "TypeLiteral" && "propertySignatures" in v)
+              for (const u of v.propertySignatures) {
+                const y = `${i}.${u.name.toString()}`;
+                if (r.AST.isTupleType(u.type) && u.type.rest.length > 0) {
+                  const S = u.type.rest[0].type;
+                  if (S._tag === "TypeLiteral" && "propertySignatures" in S)
+                    for (const d of S.propertySignatures) {
+                      const h = `${y}.${d.name.toString()}`, T = f({
+                        parent: h,
+                        property: d.type,
+                        meta: {
+                          required: !g(d.type),
+                          nullableOrUndefined: g(d.type)
+                        }
+                      });
+                      o[h] = T;
+                    }
+                  else
+                    o[y] = {
+                      type: "multiple",
+                      members: u.type.elements,
+                      rest: u.type.rest,
+                      required: !g(u.type),
+                      nullableOrUndefined: g(u.type)
+                    };
+                } else {
+                  const S = f({
+                    parent: y,
+                    property: u.type,
+                    meta: {
+                      required: !g(u.type),
+                      nullableOrUndefined: g(u.type)
+                    }
+                  });
+                  o[y] = S;
+                }
               }
+          } else
+            o[i] = {
+              type: "multiple",
+              members: s.type.elements,
+              rest: s.type.rest,
+              required: a,
+              nullableOrUndefined: l
+            };
+        else {
+          const c = f({
+            parent: i,
+            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: a && (s.type._tag !== "StringKeyword" || k(s.type).minLength),
+              nullableOrUndefined: l
             }
-        } else
-          o[r] = {
-            type: "multiple",
-            members: s.type.elements,
-            rest: s.type.rest,
-            required: a,
-            nullableOrUndefined: p
-          };
-      else {
-        const T = m({
-          parent: r,
-          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: a && (s.type._tag !== "StringKeyword" || k(s.type).minLength),
-            nullableOrUndefined: p
-          }
-        });
-        o[r] = T;
+          });
+          o[i] = c;
+        }
       }
     }
     return o;
   }
   if (t) {
     const s = $(t);
-    if (Object.hasOwnProperty.call(e, "required") || (e.required = !s), i.AST.isUnion(t)) {
-      const p = w(t.types), a = p.find(
-        (f) => f._tag !== "UndefinedKeyword" && f !== i.Null.ast
+    if (Object.hasOwnProperty.call(e, "required") || (e.required = !s), r.AST.isUnion(t)) {
+      const l = L(t.types), a = l.find(
+        (m) => m._tag !== "UndefinedKeyword" && m !== r.Null.ast
       );
-      return "propertySignatures" in a ? m({
+      return "propertySignatures" in a ? f({
         propertySignatures: a.propertySignatures,
         parent: n,
         meta: e
-      }) : p.every(i.AST.isLiteral) ? {
+      }) : l.every(r.AST.isLiteral) ? {
         ...e,
         type: "select",
-        members: p.map((f) => f.literal)
+        members: l.map((m) => m.literal)
       } : {
         ...e,
-        ...m({
+        ...f({
           parent: n,
           meta: e,
           property: a
         })
       };
     }
-    if (i.AST.isTupleType(t))
+    if (r.AST.isTupleType(t))
       return {
         ...e,
         type: "multiple",
         members: t.elements,
         rest: t.rest
       };
-    const r = i.AST.getAnnotation(
+    const i = r.AST.getAnnotation(
       t,
-      i.AST.JSONSchemaAnnotationId
-    ).pipe(M.getOrElse(() => ({})));
-    return e = { ...e, ...r }, "from" in t ? m({
+      r.AST.JSONSchemaAnnotationId
+    ).pipe(q.getOrElse(() => ({})));
+    return e = { ...e, ...i }, "from" in t ? f({
       parent: n,
       meta: e,
       property: t.from
-    }) : (e.type = i.AST.getAnnotation(
+    }) : (e.type = r.AST.getAnnotation(
       t,
-      i.AST.TitleAnnotationId
+      r.AST.TitleAnnotationId
     ).pipe(
-      M.getOrElse(() => "unknown")
+      q.getOrElse(() => "unknown")
     ), e);
   }
   return o;
 }, N = (e) => {
-  const n = e.ast, t = {}, l = {};
+  const n = e.ast, t = {}, p = {};
   if (n._tag === "Transformation" || n._tag === "Refinement")
-    return N(i.make(n.from));
+    return N(r.make(n.from));
   if (n._tag === "Union") {
-    const r = (n.types || []).filter((a) => a._tag !== "UndefinedKeyword" && a !== i.Null.ast).map(q);
-    if (r.every((a) => a._tag === "TypeLiteral" && "propertySignatures" in a) && r.length > 0) {
+    const i = (n.types || []).filter((a) => a._tag !== "UndefinedKeyword" && a !== r.Null.ast).map(_);
+    if (i.every((a) => a._tag === "TypeLiteral" && "propertySignatures" in a) && i.length > 0) {
       const a = [];
-      for (const f of r)
-        if ("propertySignatures" in f) {
-          const T = f.propertySignatures.find(
-            (d) => d.name.toString() === "_tag"
+      for (const m of i)
+        if ("propertySignatures" in m) {
+          const b = m.propertySignatures.find(
+            (v) => v.name.toString() === "_tag"
           );
-          T && i.AST.isLiteral(T.type) && a.push(T.type.literal);
-          const S = m({
-            propertySignatures: f.propertySignatures
+          b && r.AST.isLiteral(b.type) && a.push(b.type.literal);
+          const c = f({
+            propertySignatures: m.propertySignatures
           });
-          Object.assign(t, S);
+          Object.assign(t, c);
         }
       return a.length > 0 && (t._tag = {
         type: "select",
         members: a,
         required: !0
-      }), { meta: t, defaultValues: l };
+      }), { meta: t, defaultValues: p };
     }
   }
   if ("propertySignatures" in n) {
-    const o = m({
+    const o = f({
       propertySignatures: n.propertySignatures
     });
-    if (Object.values(o).every((r) => r && "type" in r))
-      return { meta: o, defaultValues: l };
-    const s = (r, p = "") => {
-      for (const a in r) {
-        const f = p ? `${p}.${a}` : a;
-        r[a] && typeof r[a] == "object" && "type" in r[a] ? t[f] = r[a] : r[a] && typeof r[a] == "object" && s(r[a], f);
+    if (Object.values(o).every((i) => i && "type" in i))
+      return { meta: o, defaultValues: p };
+    const s = (i, l = "") => {
+      for (const a in i) {
+        const m = l ? `${l}.${a}` : a;
+        i[a] && typeof i[a] == "object" && "type" in i[a] ? t[m] = i[a] : i[a] && typeof i[a] == "object" && s(i[a], m);
       }
     };
     s(o);
   }
-  return { meta: t, defaultValues: l };
-}, B = (e) => i.extend(e, i.Struct({})), J = (e) => {
+  return { meta: t, defaultValues: p };
+}, B = (e) => r.extend(e, r.Struct({})), J = (e) => {
   const { meta: n } = N(e);
   return { schema: e, meta: n };
 }, z = (e) => {
@@ -272,48 +275,48 @@ const $ = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
   let t;
   switch (e.type) {
     case "string":
-      t = i.String.annotations({
+      t = r.String.annotations({
         message: () => n("validation.empty")
-      }), e.format === "email" && (t = i.compose(
+      }), e.format === "email" && (t = r.compose(
         t,
-        i.Email.annotations({
+        r.Email.annotations({
           message: () => n("validation.email.invalid")
         })
       )), e.required && (t = t.annotations({
         message: () => n("validation.empty")
-      }).pipe(i.minLength(1)).annotations({
+      }).pipe(r.minLength(1)).annotations({
         message: () => n("validation.empty")
-      })), typeof e.maxLength == "number" && (t = t.pipe(i.maxLength(e.maxLength)).annotations({
+      })), typeof e.maxLength == "number" && (t = t.pipe(r.maxLength(e.maxLength)).annotations({
         message: () => n("validation.string.maxLength", {
           maxLength: e.maxLength
         })
-      })), typeof e.minLength == "number" && (t = t.pipe(i.minLength(e.minLength)).annotations({
+      })), typeof e.minLength == "number" && (t = t.pipe(r.minLength(e.minLength)).annotations({
         message: () => n("validation.string.minLength", {
           minLength: e.minLength
         })
       }));
       break;
     case "number":
-      t = i.Number.annotations({
+      t = r.Number.annotations({
         message: () => n("validation.empty")
       }), e.required && t.annotations({
         message: () => n("validation.empty")
-      }), typeof e.minimum == "number" && (t = t.pipe(i.greaterThanOrEqualTo(e.minimum)).annotations({
+      }), typeof e.minimum == "number" && (t = t.pipe(r.greaterThanOrEqualTo(e.minimum)).annotations({
         message: () => n(e.minimum === 0 ? "validation.number.positive" : "validation.number.min", {
           minimum: e.minimum,
           isExclusive: !0
         })
-      })), typeof e.maximum == "number" && (t = t.pipe(i.lessThanOrEqualTo(e.maximum)).annotations({
+      })), typeof e.maximum == "number" && (t = t.pipe(r.lessThanOrEqualTo(e.maximum)).annotations({
         message: () => n("validation.number.max", {
           maximum: e.maximum,
           isExclusive: !0
         })
-      })), typeof e.exclusiveMinimum == "number" && (t = t.pipe(i.greaterThan(e.exclusiveMinimum)).annotations({
+      })), typeof e.exclusiveMinimum == "number" && (t = t.pipe(r.greaterThan(e.exclusiveMinimum)).annotations({
         message: () => n(e.exclusiveMinimum === 0 ? "validation.number.positive" : "validation.number.min", {
           minimum: e.exclusiveMinimum,
           isExclusive: !1
         })
-      })), typeof e.exclusiveMaximum == "number" && (t = t.pipe(i.lessThan(e.exclusiveMaximum)).annotations({
+      })), typeof e.exclusiveMaximum == "number" && (t = t.pipe(r.lessThan(e.exclusiveMaximum)).annotations({
         message: () => n("validation.number.max", {
           maximum: e.exclusiveMaximum,
           isExclusive: !1
@@ -321,7 +324,7 @@ const $ = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
       }));
       break;
     case "select":
-      t = i.Literal(...e.members).annotations({
+      t = r.Literal(...e.members).annotations({
         message: () => ({
           message: n("validation.not_a_valid", {
             type: "select",
@@ -332,7 +335,7 @@ const $ = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
       });
       break;
     case "multiple":
-      t = i.Array(i.String).annotations({
+      t = r.Array(r.String).annotations({
         message: () => n("validation.not_a_valid", {
           type: "multiple",
           message: e.members.join(", ")
@@ -340,22 +343,22 @@ const $ = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
       });
       break;
     case "boolean":
-      t = i.Boolean;
+      t = r.Boolean;
       break;
     case "unknown":
-      t = i.Unknown;
+      t = r.Unknown;
       break;
     default:
-      console.warn(`Unhandled field type: ${e}`), t = i.Unknown;
+      console.warn(`Unhandled field type: ${e}`), t = r.Unknown;
       break;
   }
   return e.required ? t.pipe(
-    i.annotations({
+    r.annotations({
       message: () => n("validation.empty")
     })
-  ) : t = i.NullishOr(t), i.standardSchemaV1(t);
-}, C = (e, n) => i.NullOr(e).pipe(
-  i.transform(i.typeSchema(e), {
+  ) : t = r.NullishOr(t), r.standardSchemaV1(t);
+}, C = (e, n) => r.NullOr(e).pipe(
+  r.transform(r.typeSchema(e), {
     decode: (t) => t ?? n(),
     encode: (t) => t
   })
@@ -378,71 +381,71 @@ const $ = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
 ], G = (e) => K.includes(e) ? e : "text";
 function j(e, n) {
   const t = { ...e };
-  for (const l in n)
-    Array.isArray(n[l]) ? t[l] = n[l] : n[l] && E(n[l]) ? t[l] = j(t[l], n[l]) : t[l] = n[l];
+  for (const p in n)
+    Array.isArray(n[p]) ? t[p] = n[p] : n[p] && E(n[p]) ? t[p] = j(t[p], n[p]) : t[p] = n[p];
   return t;
 }
-function _(e) {
+function U(e) {
   return e && "fields" in e && typeof e.fields == "object";
 }
 function F(e) {
   return e && "members" in e && Array.isArray(e.members);
 }
-const v = (e, n = {}) => {
+const x = (e, n = {}) => {
   const t = e.ast;
   if (t?.defaultValue)
     return t.defaultValue();
   if (g(e.ast) === "null")
     return null;
   if (g(e.ast) !== "undefined") {
-    if (_(e)) {
-      const l = {};
+    if (U(e)) {
+      const p = {};
       for (const [o, s] of Object.entries(e.fields)) {
-        const r = s?.ast;
-        if (r?.defaultValue)
+        const i = s?.ast;
+        if (i?.defaultValue)
           try {
-            l[o] = r.defaultValue();
+            p[o] = i.defaultValue();
             continue;
           } catch {
           }
-        const p = v(s, n[o] || {});
-        p !== void 0 && (l[o] = p);
+        const l = x(s, n[o] || {});
+        l !== void 0 && (p[o] = l);
       }
-      return { ...l, ...n };
+      return { ...p, ...n };
     }
-    if (e?.from && _(e.from))
-      return v(e.from, n);
+    if (e?.from && U(e.from))
+      return x(e.from, n);
     if (F(e)) {
-      const l = e.members.reduce((o, s) => (_(s) && Object.entries(s.fields).forEach(([r, p]) => {
-        const a = p.ast, f = o[r]?.ast;
-        (!o[r] || a?.defaultValue && !f?.defaultValue) && (o[r] = p);
+      const p = e.members.reduce((o, s) => (U(s) && Object.entries(s.fields).forEach(([i, l]) => {
+        const a = l.ast, m = o[i]?.ast;
+        (!o[i] || a?.defaultValue && !m?.defaultValue) && (o[i] = l);
       }), o), {});
-      return Object.entries(l).reduce((o, [s, r]) => (o[s] = v(r, n[s] || {}), o), n);
+      return Object.entries(p).reduce((o, [s, i]) => (o[s] = x(i, n[s] || {}), o), n);
     }
     if (Object.keys(n).length === 0)
       switch (e.ast._tag) {
         case "Refinement":
-          return v(i.make(e.ast.from), n);
+          return x(r.make(e.ast.from), n);
         case "Transformation": {
-          const l = i.make(e.ast.from);
-          return v(l, n);
+          const p = r.make(e.ast.from);
+          return x(p, n);
         }
         case "TypeLiteral": {
-          const l = { ...n };
+          const p = { ...n };
           for (const o of t.propertySignatures) {
-            const s = o.name.toString(), r = o.type;
-            if (r._tag === "Transformation" && r.defaultValue) {
-              l[s] = r.defaultValue();
+            const s = o.name.toString(), i = o.type;
+            if (i._tag === "Transformation" && i.defaultValue) {
+              p[s] = i.defaultValue();
               continue;
             }
-            if (r.defaultValue) {
-              l[s] = r.defaultValue();
+            if (i.defaultValue) {
+              p[s] = i.defaultValue();
               continue;
             }
-            const p = i.make(r), a = v(p, n[s] || {});
-            a !== void 0 && (l[s] = a);
+            const l = r.make(i), a = x(l, n[s] || {});
+            a !== void 0 && (p[s] = a);
           }
-          return l;
+          return p;
         }
         case "StringKeyword":
           return "";
@@ -452,9 +455,9 @@ const v = (e, n = {}) => {
   }
 };
 export {
-  m as createMeta,
+  f as createMeta,
   j as deepMerge,
-  v as defaultsValueFromSchema,
+  x as defaultsValueFromSchema,
   B as duplicateSchema,
   z as generateInputStandardSchemaFromFieldMeta,
   J as generateMetaFromSchema,

package/dist/vue-components.es6.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "2.10.5",
+  "version": "2.10.7",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
     "effect": "^3.19.3",
@@ -53,8 +53,8 @@
     "highlight.js": "^11.11.1",
     "mitt": "^3.0.1",
     "vue3-highlightjs": "^1.0.5",
-    "@effect-app/vue": "2.93.5",
-    "effect-app": "3.15.0"
+    "effect-app": "3.15.0",
+    "@effect-app/vue": "2.93.5"
   },
   "scripts": {
     "build": "pnpm build:run",

package/src/components/OmegaForm/OmegaFormStuff.ts

@@ -8,12 +8,6 @@ import { getTransformationFrom, useIntl } from "../../utils"
 import { type OmegaFieldInternalApi } from "./InputProps"
 import { type OF, type OmegaFormReturn } from "./useOmegaForm"
 
-type Compute<T> =
-  & {
-    [K in keyof T]: T[K]
-  }
-  & {}
-
 export type FieldPath<T> = unknown extends T ? string
   // technically we cannot have primitive at the root
   : T extends string | boolean | number | null | undefined | symbol | bigint ? ""
@@ -507,18 +501,19 @@ export const createMeta = <T = any>(
             acc[key as NestedKeyOf<T>] = newMeta as FieldMeta
           }
         }
-      } else if ("propertySignatures" in typeToProcess) {
-        Object.assign(
-          acc,
-          createMeta<T>({
-            parent: key,
-            propertySignatures: typeToProcess.propertySignatures,
-            meta: { required: isRequired, nullableOrUndefined }
-          })
-        )
       } else {
-        // Check if this is an array type
-        if (S.AST.isTupleType(p.type)) {
+        // Unwrap transformations (like ExtendedClass) to check for propertySignatures
+        const unwrappedTypeToProcess = getTransformationFrom(typeToProcess)
+        if ("propertySignatures" in unwrappedTypeToProcess) {
+          Object.assign(
+            acc,
+            createMeta<T>({
+              parent: key,
+              propertySignatures: unwrappedTypeToProcess.propertySignatures,
+              meta: { required: isRequired, nullableOrUndefined }
+            })
+          )
+        } else 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"

package/src/components/OmegaForm/OmegaInput.vue

@@ -14,7 +14,7 @@
         :field="field"
         :state="state"
         :register="form.registerField"
-        :label="label ?? i18n()"
+        :label="label ?? errori18n(propsName)"
         :meta="meta"
       >
         <template
@@ -41,9 +41,9 @@
 >
 import { type DeepKeys } from "@tanstack/vue-form"
 import { computed, inject, type Ref, useAttrs } from "vue"
-import { useIntl } from "../../utils"
 import { type FieldMeta, generateInputStandardSchemaFromFieldMeta, type OmegaInputPropsBase } from "./OmegaFormStuff"
 import OmegaInternalInput from "./OmegaInternalInput.vue"
+import { useErrorLabel } from "./useOmegaForm"
 
 const props = defineProps<OmegaInputPropsBase<From, To, Name>>()
 
@@ -88,19 +88,5 @@ const schema = computed(() => {
   return generateInputStandardSchemaFromFieldMeta(meta.value)
 })
 
-const { formatMessage } = useIntl()
-const humanize = (str: string) => {
-  return str
-    .replace(/([A-Z])/g, " $1") // Add space before capital letters
-    .replace(/^./, (char) => char.toUpperCase()) // Capitalize the first letter
-    .trim() // Remove leading/trailing spaces
-}
-const fallback = () =>
-  formatMessage
-    ? formatMessage({ id: `general.fields.${propsName.value}`, defaultMessage: humanize(props.name) })
-    : humanize(props.name)
-const i18n = () =>
-  props.form.i18nNamespace
-    ? formatMessage({ id: `${props.form.i18nNamespace}.fields.${propsName.value}`, defaultMessage: fallback() })
-    : fallback()
+const errori18n = useErrorLabel(props.form)
 </script>

package/src/components/OmegaForm/useOmegaForm.ts

@@ -6,6 +6,7 @@ import { type DeepKeys, DeepValue, type FormAsyncValidateOrFn, type FormValidate
 import { Array, Data, Effect, Fiber, Option, Order, S } from "effect-app"
 import { runtimeFiberAsPromise, UnionToTuples } from "effect-app/utils"
 import { Component, computed, ComputedRef, ConcreteComponent, h, type InjectionKey, onBeforeUnmount, onMounted, onUnmounted, Ref, ref, watch } from "vue"
+import { useIntl } from "../../utils"
 import { MergedInputProps } from "./InputProps"
 import OmegaArray from "./OmegaArray.vue"
 import OmegaAutoGen from "./OmegaAutoGen.vue"
@@ -63,6 +64,26 @@ const fHoc = (form: OF<any, any>) => {
   }
 }
 
+export const useErrorLabel = (form: OF<any, any>) => {
+  const { formatMessage } = useIntl()
+  const humanize = (str: string) => {
+    return str
+      .replace(/([A-Z])/g, " $1") // Add space before capital letters
+      .replace(/^./, (char) => char.toUpperCase()) // Capitalize the first letter
+      .trim() // Remove leading/trailing spaces
+  }
+  const fallback = (propsName: string) =>
+    formatMessage
+      ? formatMessage({ id: `general.fields.${propsName}`, defaultMessage: humanize(propsName) })
+      : humanize(propsName)
+  const i18n = (propsName: string) =>
+    form.i18nNamespace
+      ? formatMessage({ id: `${form.i18nNamespace}.fields.${propsName}`, defaultMessage: fallback(propsName) })
+      : fallback(propsName)
+
+  return i18n
+}
+
 const eHoc = (errorProps: {
   form: OF<any, any>
   fieldMap: Ref<Map<string, { id: string; label: string }>>
@@ -77,6 +98,8 @@ const eHoc = (errorProps: {
         const fieldMeta = form.useStore((state) => state.fieldMeta)
         const errorMap = form.useStore((state) => state.errorMap)
 
+        const errorLabel = useErrorLabel(form)
+
         const errors = computed(() => {
           // Collect errors from fieldMeta (field-level errors for registered fields)
           const fieldErrors = Array.filterMap(
@@ -114,7 +137,7 @@ const eHoc = (errorProps: {
                     // Registered fields will already have their errors from fieldMeta
                     if (!fieldMap.value.has(fieldPath)) {
                       submitErrors.push({
-                        label: fieldPath,
+                        label: errorLabel(fieldPath),
                         inputId: fieldPath,
                         errors: [issAny.message].filter(Boolean)
                       })