@effect-app/vue-components 1.8.6 → 1.8.8

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

@@ -1,11 +1,13 @@
-import type { StandardSchemaV1Issue } from "@tanstack/vue-form";
-import { type OmegaError } from "./OmegaFormStuff";
+import { type OmegaError, type OmegaFormApi } from "./OmegaFormStuff";
 type __VLS_Props = {
-    errors: readonly OmegaError[];
-    generalErrors: (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined;
+    form: OmegaFormApi<any, any>;
+    fieldMap: Map<string, {
+        id: string;
+        label: string;
+    }>;
 };
 declare var __VLS_6: {
-    errors: readonly OmegaError[];
+    errors: OmegaError[];
     showedGeneralErrors: string[];
 };
 type __VLS_Slots = {} & {

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

@@ -120,7 +120,6 @@ export declare const duplicateSchema: <From, To>(schema: S.Schema<To, From, neve
 export declare const generateMetaFromSchema: <From, To>(schema: S.Schema<To, From, never>) => {
     schema: S.Schema<To, From, never>;
     meta: MetaRecord<To>;
-    filterItems?: FilterItems;
 };
 export declare const generateInputStandardSchemaFromFieldMeta: (meta: FieldMeta) => StandardSchemaV1<any, any>;
 export declare const nullableInput: <A, I, R>(schema: S.Schema<A, I, R>, defaultValue: () => A) => S.transform<import("effect/Schema").NullOr<S.Schema<A, I, R>> & {

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

@@ -2,7 +2,7 @@ import { type DeepKeys, DeepValue, StandardSchemaV1Issue, ValidationError, Valid
 import { Effect, Order, S } from "effect-app";
 import { ComputedRef, type InjectionKey } from "vue";
 import { MergedInputProps } from "./InputProps";
-import { BaseProps, DefaultTypeProps, type FilterItems, type FormProps, type MetaRecord, type NestedKeyOf, OmegaAutoGenMeta, OmegaError, type OmegaFormApi, OmegaFormState, OmegaInputProps, ShowErrorsOn } from "./OmegaFormStuff";
+import { BaseProps, DefaultTypeProps, type FormProps, type MetaRecord, type NestedKeyOf, OmegaAutoGenMeta, OmegaError, type OmegaFormApi, OmegaFormState, OmegaInputProps, ShowErrorsOn } from "./OmegaFormStuff";
 type keysRule<T> = {
     keys?: NestedKeyOf<T>[];
     banKeys?: "You should only use one of banKeys or keys, not both, moron";
@@ -41,7 +41,6 @@ export type OmegaConfig<T> = {
 };
 export interface OF<From, To> extends OmegaFormApi<From, To> {
     meta: MetaRecord<From>;
-    filterItems?: FilterItems;
     clear: () => void;
     i18nNamespace?: string;
     registerField: (field: ComputedRef<{

package/dist/vue-components.es16.js

@@ -1,8 +1,8 @@
-(function(){"use strict";try{if(typeof document<"u"){var a=document.createElement("style");if(a.appendChild(document.createTextNode(".v-enter-from[data-v-4f889c81],.v-leave-to[data-v-4f889c81]{max-height:0px;grid-template-rows:0fr;opacity:0}.v-enter-active[data-v-4f889c81],.v-leave-active[data-v-4f889c81]{display:grid;transition:all .15s}.v-enter-to[data-v-4f889c81],.v-leave-from[data-v-4f889c81]{grid-template-rows:1fr;max-height:50vh;opacity:1}.error-alert[data-v-4f889c81]{transition-behavior:allow-discrete;display:grid;overflow:hidden;min-height:0}.error-alert>*[data-v-4f889c81]{min-height:0}.error-list[data-v-4f889c81]{list-style-position:inside}div.error-list[data-v-4f889c81]{container-type:inline-size;display:grid;grid-template-columns:auto 1fr auto;gap:1.5em;align-items:start}@container (max-width: 27.125rem){div.error-list[data-v-4f889c81]{grid-template-columns:auto 1fr}.error-link[data-v-4f889c81]{grid-column:1 / -1;justify-self:end}}@container (max-width: 17.75rem){div.error-list[data-v-4f889c81]{grid-template-columns:1fr}.error-message[data-v-4f889c81]{grid-column:1 / -1}}.error-item[data-v-4f889c81]{display:contents}a[data-v-4f889c81]{min-width:min-content}.error-link[data-v-4f889c81]{align-items:center;color:inherit;display:inline-flex;flex-wrap:wrap;gap:.25em;padding-bottom:1em;text-decoration:none}")),document.head.appendChild(a),window.customElements){const e=window.customElements.define;window.customElements.define=function(n,t){const i=t.prototype.connectedCallback;return t.prototype.connectedCallback=function(){if(i&&i.call(this),this.shadowRoot){const r=document.createElement("style");r.appendChild(document.createTextNode(".v-enter-from[data-v-4f889c81],.v-leave-to[data-v-4f889c81]{max-height:0px;grid-template-rows:0fr;opacity:0}.v-enter-active[data-v-4f889c81],.v-leave-active[data-v-4f889c81]{display:grid;transition:all .15s}.v-enter-to[data-v-4f889c81],.v-leave-from[data-v-4f889c81]{grid-template-rows:1fr;max-height:50vh;opacity:1}.error-alert[data-v-4f889c81]{transition-behavior:allow-discrete;display:grid;overflow:hidden;min-height:0}.error-alert>*[data-v-4f889c81]{min-height:0}.error-list[data-v-4f889c81]{list-style-position:inside}div.error-list[data-v-4f889c81]{container-type:inline-size;display:grid;grid-template-columns:auto 1fr auto;gap:1.5em;align-items:start}@container (max-width: 27.125rem){div.error-list[data-v-4f889c81]{grid-template-columns:auto 1fr}.error-link[data-v-4f889c81]{grid-column:1 / -1;justify-self:end}}@container (max-width: 17.75rem){div.error-list[data-v-4f889c81]{grid-template-columns:1fr}.error-message[data-v-4f889c81]{grid-column:1 / -1}}.error-item[data-v-4f889c81]{display:contents}a[data-v-4f889c81]{min-width:min-content}.error-link[data-v-4f889c81]{align-items:center;color:inherit;display:inline-flex;flex-wrap:wrap;gap:.25em;padding-bottom:1em;text-decoration:none}")),this.shadowRoot.appendChild(r)}},e.call(window.customElements,n,t)}}}}catch(e){console.error("vite-plugin-css-injected-by-js",e)}})();
+(function(){"use strict";try{if(typeof document<"u"){var a=document.createElement("style");if(a.appendChild(document.createTextNode(".v-enter-from[data-v-6dbb0b00],.v-leave-to[data-v-6dbb0b00]{max-height:0px;grid-template-rows:0fr;opacity:0}.v-enter-active[data-v-6dbb0b00],.v-leave-active[data-v-6dbb0b00]{display:grid;transition:all .15s}.v-enter-to[data-v-6dbb0b00],.v-leave-from[data-v-6dbb0b00]{grid-template-rows:1fr;max-height:50vh;opacity:1}.error-alert[data-v-6dbb0b00]{transition-behavior:allow-discrete;display:grid;overflow:hidden;min-height:0}.error-alert>*[data-v-6dbb0b00]{min-height:0}.error-list[data-v-6dbb0b00]{list-style-position:inside}div.error-list[data-v-6dbb0b00]{container-type:inline-size;display:grid;grid-template-columns:auto 1fr auto;gap:1.5em;align-items:start}@container (max-width: 27.125rem){div.error-list[data-v-6dbb0b00]{grid-template-columns:auto 1fr}.error-link[data-v-6dbb0b00]{grid-column:1 / -1;justify-self:end}}@container (max-width: 17.75rem){div.error-list[data-v-6dbb0b00]{grid-template-columns:1fr}.error-message[data-v-6dbb0b00]{grid-column:1 / -1}}.error-item[data-v-6dbb0b00]{display:contents}a[data-v-6dbb0b00]{min-width:min-content}.error-link[data-v-6dbb0b00]{align-items:center;color:inherit;display:inline-flex;flex-wrap:wrap;gap:.25em;padding-bottom:1em;text-decoration:none}")),document.head.appendChild(a),window.customElements){const e=window.customElements.define;window.customElements.define=function(r,t){const i=t.prototype.connectedCallback;return t.prototype.connectedCallback=function(){if(i&&i.call(this),this.shadowRoot){const d=document.createElement("style");d.appendChild(document.createTextNode(".v-enter-from[data-v-6dbb0b00],.v-leave-to[data-v-6dbb0b00]{max-height:0px;grid-template-rows:0fr;opacity:0}.v-enter-active[data-v-6dbb0b00],.v-leave-active[data-v-6dbb0b00]{display:grid;transition:all .15s}.v-enter-to[data-v-6dbb0b00],.v-leave-from[data-v-6dbb0b00]{grid-template-rows:1fr;max-height:50vh;opacity:1}.error-alert[data-v-6dbb0b00]{transition-behavior:allow-discrete;display:grid;overflow:hidden;min-height:0}.error-alert>*[data-v-6dbb0b00]{min-height:0}.error-list[data-v-6dbb0b00]{list-style-position:inside}div.error-list[data-v-6dbb0b00]{container-type:inline-size;display:grid;grid-template-columns:auto 1fr auto;gap:1.5em;align-items:start}@container (max-width: 27.125rem){div.error-list[data-v-6dbb0b00]{grid-template-columns:auto 1fr}.error-link[data-v-6dbb0b00]{grid-column:1 / -1;justify-self:end}}@container (max-width: 17.75rem){div.error-list[data-v-6dbb0b00]{grid-template-columns:1fr}.error-message[data-v-6dbb0b00]{grid-column:1 / -1}}.error-item[data-v-6dbb0b00]{display:contents}a[data-v-6dbb0b00]{min-width:min-content}.error-link[data-v-6dbb0b00]{align-items:center;color:inherit;display:inline-flex;flex-wrap:wrap;gap:.25em;padding-bottom:1em;text-decoration:none}")),this.shadowRoot.appendChild(d)}},e.call(window.customElements,r,t)}}}}catch(e){console.error("vite-plugin-css-injected-by-js",e)}})();
 import r from "./vue-components.es29.js";
 
 import o from "./vue-components.es31.js";
-const e = /* @__PURE__ */ o(r, [["__scopeId", "data-v-4f889c81"]]);
+const e = /* @__PURE__ */ o(r, [["__scopeId", "data-v-6dbb0b00"]]);
 export {
   e as default
 };

package/dist/vue-components.es29.js

@@ -1,53 +1,63 @@
-import { defineComponent as y, getCurrentInstance as E, computed as C, createBlock as n, openBlock as e, Transition as x, withCtx as o, createElementBlock as d, createCommentVNode as B, renderSlot as b, normalizeProps as I, guardReactiveProps as w, resolveDynamicComponent as s, unref as a, normalizeClass as V, createElementVNode as c, toDisplayString as u, Fragment as p, renderList as _, createTextVNode as k } from "vue";
-import { mdiLink as N } from "@mdi/js";
-import { useIntl as z } from "./vue-components.es3.js";
+import { defineComponent as x, getCurrentInstance as E, computed as h, createBlock as o, openBlock as t, Transition as I, withCtx as a, createElementBlock as m, createCommentVNode as w, renderSlot as O, normalizeProps as S, guardReactiveProps as V, resolveDynamicComponent as s, unref as i, normalizeClass as N, createElementVNode as d, toDisplayString as c, Fragment as M, renderList as b, createTextVNode as k } from "vue";
+import { mdiLink as j } from "@mdi/js";
+import { Array as z, Option as y } from "effect-app";
+import { useIntl as A } from "./vue-components.es3.js";
 const D = {
   key: 0,
   class: "error-alert"
-}, G = { class: "text-h6 mb-3" }, L = { class: "font-weight-medium" }, M = { class: "error-message" }, O = ["href"], P = { key: 1 }, A = /* @__PURE__ */ y({
+}, G = { class: "text-h6 mb-3" }, L = { class: "font-weight-medium" }, P = { class: "error-message" }, T = ["href"], $ = { key: 1 }, K = /* @__PURE__ */ x({
   __name: "OmegaErrorsInternal",
   props: {
-    errors: {},
-    generalErrors: {}
+    form: {},
+    fieldMap: {}
   },
-  setup(t) {
-    const m = E()?.appContext.components.VAlert, h = t, { trans: g } = z(), f = C(() => h.generalErrors ? h.generalErrors.filter((i) => !!i).flatMap(
-      (i) => Object.values(i).filter((l) => !!l).flatMap(
+  setup(B) {
+    const f = E()?.appContext.components.VAlert, u = B, v = u.form.useStore((e) => e.errors), C = u.form.useStore((e) => e.fieldMeta), n = h(
+      () => z.filterMap(
+        Object.entries(C.value),
+        ([e, l]) => (l.errors ?? []).length && u.fieldMap.get(e)?.id ? y.some({
+          label: u.fieldMap.get(e).label,
+          inputId: u.fieldMap.get(e).id,
+          errors: (l.errors ?? []).map((r) => r.message).filter(Boolean)
+        }) : y.none()
+      )
+    ), { trans: _ } = A(), p = h(() => v.value ? v.value.filter((e) => !!e).flatMap(
+      (e) => Object.values(e).filter((l) => !!l).flatMap(
         (l) => l.filter(
           (r) => !!r?.message
         ).map((r) => r.message)
       )
     ) : []);
-    return (i, l) => (e(), n(x, null, {
-      default: o(() => [
-        t.errors.length || f.value.length ? (e(), d("div", D, [
-          b(i.$slots, "default", I(w({ errors: t.errors, showedGeneralErrors: f.value })), () => [
-            (e(), n(s(a(m) ? "v-alert" : "div"), {
-              class: V([a(m) ? "mb-4" : "error-alert-content", "mb-4"]),
+    return (e, l) => (t(), o(I, null, {
+      default: a(() => [
+        n.value.length || p.value.length ? (t(), m("div", D, [
+          O(e.$slots, "default", S(V({ errors: n.value, showedGeneralErrors: p.value })), () => [
+            (t(), o(s(i(f) ? "v-alert" : "div"), {
+              class: N([i(f) ? "mb-4" : "error-alert-content", "mb-4"]),
               type: "error",
               variant: "tonal",
               role: "alert",
               "aria-live": "polite"
             }, {
-              default: o(() => [
-                c("div", G, u(a(g)("form.includes_error")) + ": ", 1),
-                t.errors.length ? (e(), n(s(t.errors.length > 1 ? "ul" : "div"), {
+              default: a(() => [
+                d("div", G, c(i(_)("form.includes_error")) + ": ", 1),
+                n.value.length ? (t(), o(s(n.value.length > 1 ? "ul" : "div"), {
                   key: 0,
                   class: "error-list"
                 }, {
-                  default: o(() => [
-                    (e(!0), d(p, null, _(t.errors, (r) => (e(), n(s(t.errors.length > 1 ? "li" : "div"), {
+                  default: a(() => [
+                    (t(!0), m(M, null, b(n.value, (r) => (t(), o(s(n.value.length > 1 ? "li" : "div"), {
                       key: r.inputId,
                       class: "error-item"
                     }, {
-                      default: o(() => [
-                        c("div", L, u(r.label), 1),
-                        c("div", M, [
-                          (e(), n(s(r.errors.length > 1 ? "ul" : "div"), { class: "error-list" }, {
-                            default: o(() => [
-                              (e(!0), d(p, null, _(r.errors, (v) => (e(), n(s(r.errors.length > 1 ? "li" : "span"), { key: v }, {
-                                default: o(() => [
-                                  k(u(v), 1)
+                      default: a(() => [
+                        d("div", L, c(r.label), 1),
+                        d("div", P, [
+                          (t(), o(s(r.errors.length > 1 ? "ul" : "div"), { class: "error-list" }, {
+                            default: a(() => [
+                              (t(!0), m(M, null, b(r.errors, (g) => (t(), o(s(r.errors.length > 1 ? "li" : "span"), { key: g }, {
+                                default: a(() => [
+                                  k(c(g), 1)
                                 ]),
                                 _: 2
                               }, 1024))), 128))
@@ -55,37 +65,37 @@ const D = {
                             _: 2
                           }, 1024))
                         ]),
-                        c("a", {
+                        d("a", {
                           href: `#${r.inputId}`,
                           class: "error-link"
                         }, [
-                          (e(), n(s(a(m) ? "v-icon" : "i"), {
-                            icon: a(N),
+                          (t(), o(s(i(f) ? "v-icon" : "i"), {
+                            icon: i(j),
                             "aria-hidden": "true"
                           }, {
-                            default: o(() => [...l[0] || (l[0] = [
-                              c("i", null, "🔗", -1)
+                            default: a(() => [...l[0] || (l[0] = [
+                              d("i", null, "🔗", -1)
                             ])]),
                             _: 1
                           }, 8, ["icon"])),
-                          k(" " + u(a(g)("form.fix_input")), 1)
-                        ], 8, O)
+                          k(" " + c(i(_)("form.fix_input")), 1)
+                        ], 8, T)
                       ]),
                       _: 2
                     }, 1024))), 128))
                   ]),
                   _: 1
-                })) : (e(), d("span", P, u(f.value[0]), 1))
+                })) : (t(), m("span", $, c(p.value[0]), 1))
               ]),
               _: 1
             }, 8, ["class"]))
           ], !0)
-        ])) : B("", !0)
+        ])) : w("", !0)
       ]),
       _: 3
     }));
   }
 });
 export {
-  A as default
+  K as default
 };

package/dist/vue-components.es7.js

@@ -1,72 +1,71 @@
-import { useForm as T } from "@tanstack/vue-form";
-import { Data as W, S as U, Effect as l, Array as g, Option as E, Fiber as F } from "effect-app";
+import { useForm as J } from "@tanstack/vue-form";
+import { Data as q, S as U, Effect as a, Fiber as y, Option as K, Array as L } from "effect-app";
 import { runtimeFiberAsPromise as k } from "./vue-components.es12.js";
-import { isObject as z } from "./vue-components.es13.js";
-import { computed as $, onUnmounted as A, onMounted as Q, onBeforeUnmount as X, watch as N, h as D } from "vue";
-import { usePreventClose as Y } from "./vue-components.es8.js";
-import Z from "./vue-components.es14.js";
-import C from "./vue-components.es15.js";
-import ee from "./vue-components.es16.js";
-import { generateMetaFromSchema as re } from "./vue-components.es9.js";
-import te from "./vue-components.es5.js";
-import se from "./vue-components.es17.js";
-import { trace as _ } from "./vue-components.es18.js";
-import { context as M } from "./vue-components.es19.js";
-class ne extends W.TaggedError("FormErrors") {
+import { isObject as B } from "./vue-components.es13.js";
+import { computed as O, onUnmounted as M, onMounted as G, onBeforeUnmount as T, ref as W, watch as z, h as A } from "vue";
+import { usePreventClose as Q } from "./vue-components.es8.js";
+import X from "./vue-components.es14.js";
+import Y from "./vue-components.es15.js";
+import Z from "./vue-components.es16.js";
+import { generateMetaFromSchema as C } from "./vue-components.es9.js";
+import ee from "./vue-components.es5.js";
+import re from "./vue-components.es17.js";
+import { trace as $ } from "./vue-components.es18.js";
+import { context as b } from "./vue-components.es19.js";
+class te extends q.TaggedError("FormErrors") {
 }
-const h = (c) => function(o) {
+const p = (c) => function(n) {
   return {
     render() {
-      return D(o, {
+      return A(n, {
         form: c,
         ...this.$attrs
       }, this.$slots);
     }
   };
-}, oe = (c) => function(o) {
+}, se = (c) => function(n) {
   return {
     setup() {
       return {
         ...c
       };
     },
-    render({ errors: S, generalErrors: w, showErrors: v }) {
-      return D(o, {
-        errors: S,
-        generalErrors: w,
-        showErrors: v,
+    render({ fieldMap: h, form: S }) {
+      return A(n, {
+        form: S,
+        fieldMap: h,
         ...this.$attrs
       }, this.$slots);
     }
   };
-}, ye = (c, a, o) => {
+}, ve = (c, o, n) => {
   if (!c) throw new Error("Schema is required");
-  const S = U.standardSchemaV1(c), w = U.decode(c), { filterItems: v, meta: p } = re(c), m = $(() => {
-    if (o?.persistency?.id)
-      return o.persistency.id;
-    const e = window.location.pathname, r = Object.keys(p);
+  const h = U.standardSchemaV1(c), S = U.decode(c), { meta: f } = C(c), d = O(() => {
+    if (n?.persistency?.id)
+      return n.persistency.id;
+    const e = window.location.pathname, r = Object.keys(f);
     return `${e}-${r.join("-")}`;
-  }), R = () => {
+  }), N = () => {
     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());
   };
-  function j(e, r) {
+  function E(e, r) {
     for (const t in r)
-      r[t] && z(r[t]) ? (e[t] || (e[t] = {}), j(e[t], r[t])) : e[t] = r[t];
+      r[t] && B(r[t]) ? (e[t] || (e[t] = {}), E(e[t], r[t])) : e[t] = r[t];
     return e;
   }
-  const x = $(() => {
-    if (a?.defaultValues && !o?.persistency?.overrideDefaultValues)
-      return a?.defaultValues;
+  const _ = O(() => {
+    if (o?.defaultValues && !n?.persistency?.overrideDefaultValues)
+      return o?.defaultValues;
     let e;
-    const r = o?.persistency;
+    const r = n?.persistency;
     if (!r?.policies || r.policies.length === 0) return {};
     if (r.policies.includes("querystring"))
       try {
-        const s = new URLSearchParams(window.location.search).get(m.value);
-        R(), s && (e = JSON.parse(s));
+        const s = new URLSearchParams(window.location.search).get(d.value);
+        N(), s && (e = JSON.parse(s));
       } catch (t) {
         console.error(t);
       }
@@ -78,146 +77,114 @@ const h = (c) => function(o) {
       if (t)
         try {
           const s = JSON.parse(
-            t.getItem(m.value) || "{}"
+            t.getItem(d.value) || "{}"
           );
-          t.removeItem(m.value), e = s;
+          t.removeItem(d.value), e = s;
         } catch (s) {
           console.error(s);
         }
     }
-    if (e ??= {}, a?.defaultValues == null)
+    if (e ??= {}, o?.defaultValues == null)
       return e;
     {
-      const t = a?.defaultValues;
-      return j(t, e);
+      const t = o?.defaultValues;
+      return E(t, e);
     }
-  }), H = (e, r) => e ? M.with(_.setSpan(M.active(), e), r) : r(), u = T({
-    ...a,
+  }), D = (e, r) => e ? b.with($.setSpan(b.active(), e), r) : r(), l = J({
+    ...o,
     validators: {
-      onSubmit: S,
-      ...a?.validators || {}
+      onSubmit: h,
+      ...o?.validators || {}
     },
-    onSubmit: a?.onSubmit ? ({ formApi: e, meta: r, value: t }) => H(r?.currentSpan, async () => {
-      const s = await l.runPromise(w(t)), n = a.onSubmit({
+    onSubmit: o?.onSubmit ? ({ formApi: e, meta: r, value: t }) => D(r?.currentSpan, async () => {
+      const s = await a.runPromise(S(t)), i = o.onSubmit({
         formApi: e,
         meta: r,
         value: s
       });
-      return F.isFiber(n) && F.isRuntimeFiber(n) ? await k(n) : l.isEffect(n) ? await l.runPromise(
-        n.pipe(
+      return y.isFiber(i) && y.isRuntimeFiber(i) ? await k(i) : a.isEffect(i) ? await a.runPromise(
+        i.pipe(
           // meta?.currentSpan
           //   ? Effect.withParentSpan(meta.currentSpan)
           //   : (_) => _,
-          l.flatMap((d) => F.join(d))
+          a.flatMap((m) => y.join(m))
         )
-      ) : n;
+      ) : i;
     }) : void 0,
-    defaultValues: x.value
-  }), J = () => {
-    Object.keys(p).forEach((e) => {
-      u.setFieldValue(e, void 0);
+    defaultValues: _.value
+  }), I = () => {
+    Object.keys(f).forEach((e) => {
+      l.setFieldValue(e, void 0);
     });
-  }, V = (e) => e.reduce((r, t) => {
+  }, g = (e) => e.reduce((r, t) => {
     const s = t.split(".");
-    return s.reduce((n, d, G) => (G === s.length - 1 ? n[d] = u.getFieldValue(t) : n[d] = n[d] ?? {}, n[d]), r), r;
-  }, {}), O = (e) => {
+    return s.reduce((i, m, H) => (H === s.length - 1 ? i[m] = l.getFieldValue(t) : i[m] = i[m] ?? {}, i[m]), r), r;
+  }, {}), F = (e) => {
     if (e) {
-      if (g.isArray(e.keys))
-        return V(e.keys);
-      if (g.isArray(e.banKeys)) {
-        const r = Object.keys(p).filter((t) => e.banKeys?.includes(t));
-        return V(r);
+      if (L.isArray(e.keys))
+        return g(e.keys);
+      if (L.isArray(e.banKeys)) {
+        const r = Object.keys(f).filter((t) => e.banKeys?.includes(t));
+        return g(r);
       }
-      return u.store.state.values;
+      return l.store.state.values;
     }
-  }, b = () => {
-    const e = o?.persistency;
+  }, w = () => {
+    const e = n?.persistency;
     if (!(!e?.policies || e.policies.length === 0) && (e.policies.includes("local") || e.policies.includes("session"))) {
       const r = e.policies.includes("local") ? localStorage : sessionStorage;
       if (!r) return;
-      const t = O(e);
-      return r.setItem(m.value, JSON.stringify(t));
+      const t = F(e);
+      return r.setItem(d.value, JSON.stringify(t));
     }
-  }, P = () => {
-    const e = o?.persistency;
+  }, V = () => {
+    const e = n?.persistency;
     if (!(!e?.policies || e.policies.length === 0) && e.policies.includes("querystring")) {
-      const r = O(e), t = new URLSearchParams(window.location.search);
-      t.set(m.value, JSON.stringify(r));
+      const r = F(e), t = new URLSearchParams(window.location.search);
+      t.set(d.value, JSON.stringify(r));
       const s = new URL(window.location.href);
       s.search = t.toString(), window.history.replaceState({}, "", s.toString());
     }
   };
-  A(b), Q(() => {
-    window.addEventListener("beforeunload", b), window.addEventListener("blur", P);
-  }), X(() => {
-    window.removeEventListener("beforeunload", b), window.removeEventListener("blur", P);
+  M(w), G(() => {
+    window.addEventListener("beforeunload", w), window.addEventListener("blur", V);
+  }), T(() => {
+    window.removeEventListener("beforeunload", w), window.removeEventListener("blur", V);
   });
-  const I = (e) => l.currentSpan.pipe(
-    l.option,
-    l.flatMap(
-      (r) => l.promise(() => u.handleSubmit(E.isSome(r) ? { currentSpan: r.value, ...e } : e))
+  const P = (e) => a.currentSpan.pipe(
+    a.option,
+    a.flatMap(
+      (r) => a.promise(() => l.handleSubmit(K.isSome(r) ? { currentSpan: r.value, ...e } : e))
     )
-  ), q = (e) => e?.checkErrors ? I(e?.meta).pipe(l.flatMap(l.fnUntraced(function* () {
-    const r = u.getAllErrors();
+  ), R = (e) => e?.checkErrors ? P(e?.meta).pipe(a.flatMap(a.fnUntraced(function* () {
+    const r = l.getAllErrors();
     if (Object.keys(r.fields).length || r.form.errors.length)
-      return yield* new ne({ form: r.form, fields: r.fields });
-  }))) : I(e?.meta), B = u.handleSubmit, f = /* @__PURE__ */ new Map(), i = Object.assign(u, {
-    i18nNamespace: o?.i18nNamespace,
-    meta: p,
-    filterItems: v,
-    clear: J,
+      return yield* new te({ form: r.form, fields: r.fields });
+  }))) : P(e?.meta), x = l.handleSubmit, v = W(/* @__PURE__ */ new Map()), u = Object.assign(l, {
+    i18nNamespace: n?.i18nNamespace,
+    meta: f,
+    clear: I,
     handleSubmit: (e) => {
-      const r = _.getSpan(M.active());
-      return B({ currentSpan: r, ...e });
+      const r = $.getSpan(b.active());
+      return x({ currentSpan: r, ...e });
     },
     // /** @experimental */
-    handleSubmitEffect: q,
+    handleSubmitEffect: R,
     registerField: (e) => {
-      N(e, (r) => f.set(r.name, { label: r.label, id: r.id }), { immediate: !0 }), A(() => f.delete(e.value.name));
+      z(e, (r) => v.value.set(r.name, { label: r.label, id: r.id }), { immediate: !0 }), M(() => v.value.delete(e.value.name));
     }
-  }), y = i.useStore((e) => e.errors), K = i.useStore(
-    (e) => g.filterMap(
-      Object.entries(e.fieldMeta),
-      ([r, t]) => (t.errors ?? []).length && f.get(r)?.id ? E.some({
-        label: f.get(r).label,
-        inputId: f.get(r).id,
-        errors: (t.errors ?? []).map((s) => s.message).filter(Boolean)
-      }) : E.none()
-    )
-  );
-  N(
-    () => [i.filterItems, y.value],
-    () => {
-      const e = i.filterItems, r = y.value;
-      return e ? r ? (Object.values(r).filter(
-        (s) => !!s
-      ).flatMap(
-        (s) => Object.values(s).flat().map((n) => n.message)
-      ).some((s) => s === e.message) && e.items.forEach((s) => {
-        const n = i.getFieldMeta(s);
-        n && i.setFieldMeta(s, {
-          ...n,
-          errorMap: {
-            onSubmit: [
-              { path: [s], message: e.message }
-            ]
-          }
-        });
-      }), {}) : {} : {};
-    }
-  );
-  const L = { generalErrors: y, errors: K };
-  return o?.ignorePreventCloseEvents || Y(() => i.useStore((e) => e.isDirty)), Object.assign(i, {
-    errorContext: L,
-    Form: h(i)(se),
-    Input: h(i)(o?.input ?? te),
-    Field: u.Field,
-    Errors: oe(L)(ee),
-    Array: h(i)(Z),
-    AutoGen: h(i)(C)
+  }), j = { form: u, fieldMap: v };
+  return n?.ignorePreventCloseEvents || Q(() => u.useStore((e) => e.isDirty)), Object.assign(u, {
+    errorContext: j,
+    Form: p(u)(re),
+    Input: p(u)(n?.input ?? ee),
+    Field: l.Field,
+    Errors: se(j)(Z),
+    Array: p(u)(X),
+    AutoGen: p(u)(Y)
   });
 };
 export {
-  ne as FormErrors,
-  ye as useOmegaForm
+  te as FormErrors,
+  ve as useOmegaForm
 };

package/dist/vue-components.es9.js

@@ -1,162 +1,163 @@
-import { S as n, Option as c, pipe as q } from "effect-app";
-import { getMetadataFromSchema as U } from "@effect-app/vue/form";
-import { useIntl as _, getTransformationFrom as N } from "./vue-components.es3.js";
-const w = n.NonEmptyArray(n.String), E = (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 = {}) => {
+import { S as n, Option as L } from "effect-app";
+import { getMetadataFromSchema as M } from "@effect-app/vue/form";
+import { useIntl as U, getTransformationFrom as _ } from "./vue-components.es3.js";
+n.NonEmptyArray(n.String);
+const E = (e) => n.AST.isUnion(e) && e.types.find((i) => i._tag === "UndefinedKeyword" || i === n.Null.ast), f = (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, u = ({ meta: e = {}, parent: i = "", property: t, propertySignatures: d }, o = {}) => {
   if (t && t._tag === "Transformation")
-    return m({
+    return u({
       parent: i,
       meta: e,
       property: t.from
     });
   if (t?._tag === "TypeLiteral" && "propertySignatures" in t)
-    return m({
+    return u({
       meta: e,
       propertySignatures: t.propertySignatures
     });
-  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 (d) {
+    for (const r of d) {
+      const p = i ? `${i}.${r.name.toString()}` : r.name.toString(), a = f(r.type), l = !a, O = r.type;
       if (n.AST.isUnion(r.type)) {
-        const T = r.type.types.filter(
+        const S = r.type.types.filter(
           (s) => s._tag !== "UndefinedKeyword" && s !== n.Null.ast
-        ).map(N);
-        if (T.some(
+        ).map(_);
+        if (S.some(
           (s) => "propertySignatures" in s
         )) {
           if (!a) {
-            const s = m({
-              parent: l,
+            const s = u({
+              parent: p,
               property: r.type,
-              meta: { required: u, nullableOrUndefined: a }
+              meta: { required: l, nullableOrUndefined: a }
             });
-            o[l] = s;
+            o[p] = s;
           }
-          for (const s of T)
+          for (const s of S)
             "propertySignatures" in s && Object.assign(
               o,
-              m({
-                parent: l,
+              u({
+                parent: p,
                 propertySignatures: s.propertySignatures,
-                meta: { required: u, nullableOrUndefined: a }
+                meta: { required: l, nullableOrUndefined: a }
               })
             );
         } else {
-          const s = T.filter(n.AST.isTupleType);
+          const s = S.filter(n.AST.isTupleType);
           if (s.length > 0) {
-            const f = s[0];
-            if (o[l] = {
+            const y = s[0];
+            if (o[p] = {
               type: "multiple",
-              members: f.elements,
-              rest: f.rest,
-              required: u,
+              members: y.elements,
+              rest: y.rest,
+              required: l,
               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,
+            }, y.rest && y.rest.length > 0) {
+              const g = y.rest[0];
+              if (g.type._tag === "TypeLiteral" && "propertySignatures" in g.type)
+                for (const m of g.type.propertySignatures) {
+                  const T = `${p}.${m.name.toString()}`, c = u({
+                    parent: T,
+                    property: m.type,
                     meta: {
-                      required: !g(y.type),
-                      nullableOrUndefined: g(y.type)
+                      required: !f(m.type),
+                      nullableOrUndefined: f(m.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 x of O.type.propertySignatures) {
-                        const M = `${b}.${x.name.toString()}`, v = m({
-                          parent: M,
-                          property: x.type,
+                  if (c && typeof c == "object" && "type" in c && (o[T] = c, c.type === "multiple" && n.AST.isTupleType(m.type) && m.type.rest && m.type.rest.length > 0)) {
+                    const v = m.type.rest[0];
+                    if (v.type._tag === "TypeLiteral" && "propertySignatures" in v.type)
+                      for (const h of v.type.propertySignatures) {
+                        const A = `${T}.${h.name.toString()}`, x = u({
+                          parent: A,
+                          property: h.type,
                           meta: {
-                            required: !g(x.type),
-                            nullableOrUndefined: g(x.type)
+                            required: !f(h.type),
+                            nullableOrUndefined: f(h.type)
                           }
                         });
-                        v && typeof v == "object" && "type" in v && (o[M] = v);
+                        x && typeof x == "object" && "type" in x && (o[A] = x);
                       }
                   }
                 }
             }
           } else {
-            const f = m({
-              parent: l,
+            const y = u({
+              parent: p,
               property: r.type,
-              meta: { required: u, nullableOrUndefined: a }
+              meta: { required: l, nullableOrUndefined: a }
             });
-            o[l] = f;
+            o[p] = y;
           }
         }
-      } else if ("propertySignatures" in A)
+      } else if ("propertySignatures" in O)
         Object.assign(
           o,
-          m({
-            parent: l,
-            propertySignatures: A.propertySignatures,
-            meta: { required: u, nullableOrUndefined: a }
+          u({
+            parent: p,
+            propertySignatures: O.propertySignatures,
+            meta: { required: l, 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 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()}`;
+          const b = r.type.rest[0].type;
+          if (b._tag === "TypeLiteral" && "propertySignatures" in b)
+            for (const s of b.propertySignatures) {
+              const y = `${p}.${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,
+                const g = s.type.rest[0].type;
+                if (g._tag === "TypeLiteral" && "propertySignatures" in g)
+                  for (const m of g.propertySignatures) {
+                    const T = `${y}.${m.name.toString()}`, c = u({
+                      parent: T,
+                      property: m.type,
                       meta: {
-                        required: !g(y.type),
-                        nullableOrUndefined: g(y.type)
+                        required: !f(m.type),
+                        nullableOrUndefined: f(m.type)
                       }
                     });
-                    o[b] = S;
+                    o[T] = c;
                   }
                 else
-                  o[f] = {
+                  o[y] = {
                     type: "multiple",
                     members: s.type.elements,
                     rest: s.type.rest,
-                    required: !g(s.type),
-                    nullableOrUndefined: g(s.type)
+                    required: !f(s.type),
+                    nullableOrUndefined: f(s.type)
                   };
               } else {
-                const d = m({
-                  parent: f,
+                const g = u({
+                  parent: y,
                   property: s.type,
                   meta: {
-                    required: !g(s.type),
-                    nullableOrUndefined: g(s.type)
+                    required: !f(s.type),
+                    nullableOrUndefined: f(s.type)
                   }
                 });
-                o[f] = d;
+                o[y] = g;
               }
             }
         } else
-          o[l] = {
+          o[p] = {
             type: "multiple",
             members: r.type.elements,
             rest: r.type.rest,
-            required: u,
+            required: l,
             nullableOrUndefined: a
           };
       else {
-        const T = m({
-          parent: l,
+        const S = u({
+          parent: p,
           property: r.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: u && (r.type._tag !== "StringKeyword" || U(r.type).minLength),
+            required: l && (r.type._tag !== "StringKeyword" || M(r.type).minLength),
             nullableOrUndefined: a
           }
         });
-        o[l] = T;
+        o[p] = S;
       }
     }
     return o;
@@ -165,19 +166,19 @@ const w = n.NonEmptyArray(n.String), E = (e) => n.AST.isUnion(e) && e.types.find
     const r = E(t);
     if (Object.hasOwnProperty.call(e, "required") || (e.required = !r), n.AST.isUnion(t)) {
       const a = t.types.find(
-        (u) => u._tag !== "UndefinedKeyword" && u !== n.Null.ast
+        (l) => l._tag !== "UndefinedKeyword" && l !== n.Null.ast
       );
-      return "propertySignatures" in a ? m({
+      return "propertySignatures" in a ? u({
         propertySignatures: a.propertySignatures,
         parent: i,
         meta: e
       }) : t.types.every(n.AST.isLiteral) ? {
         ...e,
         type: "select",
-        members: t.types.map((u) => u.literal)
+        members: t.types.map((l) => l.literal)
       } : {
         ...e,
-        ...m({
+        ...u({
           parent: i,
           meta: e,
           property: a
@@ -191,11 +192,11 @@ const w = n.NonEmptyArray(n.String), E = (e) => n.AST.isUnion(e) && e.types.find
         members: t.elements,
         rest: t.rest
       };
-    const l = n.AST.getAnnotation(
+    const p = n.AST.getAnnotation(
       t,
       n.AST.JSONSchemaAnnotationId
-    ).pipe(c.getOrElse(() => ({})));
-    return e = { ...e, ...l }, "from" in t ? m({
+    ).pipe(L.getOrElse(() => ({})));
+    return e = { ...e, ...p }, "from" in t ? u({
       parent: i,
       meta: e,
       property: t.from
@@ -203,48 +204,34 @@ const w = n.NonEmptyArray(n.String), E = (e) => n.AST.isUnion(e) && e.types.find
       t,
       n.AST.TitleAnnotationId
     ).pipe(
-      c.getOrElse(() => "unknown")
+      L.getOrElse(() => "unknown")
     ), e);
   }
   return o;
-}, L = (e) => {
+}, q = (e) => {
   const i = e.ast, t = {};
   if (i._tag === "Transformation" || i._tag === "Refinement")
-    return L(n.make(i.from));
+    return q(n.make(i.from));
   if ("propertySignatures" in i) {
-    const p = m({
+    const d = u({
       propertySignatures: i.propertySignatures
     });
-    if (Object.values(p).every((r) => r && "type" in r))
-      return p;
-    const o = (r, l = "") => {
+    if (Object.values(d).every((r) => r && "type" in r))
+      return d;
+    const o = (r, p = "") => {
       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);
+        const l = p ? `${p}.${a}` : a;
+        r[a] && typeof r[a] == "object" && "type" in r[a] ? t[l] = r[a] : r[a] && typeof r[a] == "object" && o(r[a], l);
       }
     };
-    o(p);
+    o(d);
   }
   return t;
-}, P = (e) => n.extend(e, n.Struct({})), F = (e) => {
-  const i = L(e), t = q(
-    e.ast,
-    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(w)(p)),
-    c.zipWith(
-      n.AST.getMessageAnnotation(e.ast),
-      (p, o) => ({
-        items: p,
-        message: o("")
-      })
-    ),
-    c.getOrUndefined
-  );
-  return { schema: e, meta: i, filterItems: t };
-}, j = (e) => {
-  const { trans: i } = _();
+}, K = (e) => n.extend(e, n.Struct({})), I = (e) => {
+  const i = q(e);
+  return { schema: e, meta: i };
+}, P = (e) => {
+  const { trans: i } = U();
   let t;
   switch (e.type) {
     case "string":
@@ -326,12 +313,12 @@ const w = n.NonEmptyArray(n.String), E = (e) => n.AST.isUnion(e) && e.types.find
       message: () => i("validation.empty")
     })
   ) : t = n.NullishOr(t), n.standardSchemaV1(t);
-}, R = (e, i) => n.NullOr(e).pipe(
+}, F = (e, i) => n.NullOr(e).pipe(
   n.transform(n.typeSchema(e), {
     decode: (t) => t ?? i(),
     encode: (t) => t
   })
-), k = [
+), N = [
   "button",
   "checkbox",
   "color",
@@ -347,12 +334,12 @@ const w = n.NonEmptyArray(n.String), E = (e) => n.AST.isUnion(e) && e.types.find
   "text",
   "time",
   "url"
-], J = (e) => k.includes(e) ? e : "text";
+], j = (e) => N.includes(e) ? e : "text";
 export {
-  m as createMeta,
-  P as duplicateSchema,
-  j as generateInputStandardSchemaFromFieldMeta,
-  F as generateMetaFromSchema,
-  J as getInputType,
-  R as nullableInput
+  u as createMeta,
+  K as duplicateSchema,
+  P as generateInputStandardSchemaFromFieldMeta,
+  I as generateMetaFromSchema,
+  j as getInputType,
+  F as nullableInput
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "1.8.6",
+  "version": "1.8.8",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
     "effect": "^3.18.0",

package/src/components/OmegaForm/OmegaErrorsInternal.vue

@@ -74,27 +74,45 @@
 <script setup lang="ts">
 import { mdiLink } from "@mdi/js"
 import type { StandardSchemaV1Issue } from "@tanstack/vue-form"
+import { Array as Array$, Option } from "effect-app"
 import { computed, getCurrentInstance } from "vue"
 import { useIntl } from "../../utils"
-import { type OmegaError } from "./OmegaFormStuff"
+import { type OmegaError, type OmegaFormApi } from "./OmegaFormStuff"
 
 const instance = getCurrentInstance()
 const vuetified = instance?.appContext.components["VAlert"]
 
 const props = defineProps<
   {
-    errors: readonly OmegaError[]
-    generalErrors: (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined
+    form: OmegaFormApi<any, any>
+    fieldMap: Map<string, { id: string; label: string }>
   }
 >()
 
+const generalErrors = props.form.useStore((state) => state.errors)
+const fieldMeta = props.form.useStore((state) => state.fieldMeta)
+const errors = computed(() =>
+  Array$.filterMap(
+    Object
+      .entries(fieldMeta.value),
+    ([key, m]): Option.Option<OmegaError> =>
+      ((m as any).errors ?? []).length && props.fieldMap.get(key)?.id
+        ? Option.some({
+          label: props.fieldMap.get(key)!.label,
+          inputId: props.fieldMap.get(key)!.id,
+          errors: ((m as any).errors ?? []).map((e: any) => e.message).filter(Boolean)
+        })
+        : Option.none()
+  )
+)
+
 const { trans } = useIntl()
 
 const showedGeneralErrors = computed(() => {
-  if (!props.generalErrors) return []
+  if (!generalErrors.value) return []
 
-  return props
-    .generalErrors
+  return generalErrors
+    .value
     .filter((record): record is Record<string, StandardSchemaV1Issue[]> => Boolean(record))
     .flatMap((errorRecord) =>
       Object

package/src/components/OmegaForm/OmegaFormStuff.ts

@@ -1,4 +1,4 @@
-import { type Effect, Option, pipe, type Record, S } from "effect-app"
+import { type Effect, Option, type Record, S } from "effect-app"
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { getMetadataFromSchema } from "@effect-app/vue/form"
 import { type DeepKeys, type FieldAsyncValidateOrFn, type FieldValidateOrFn, type FormApi, type FormAsyncValidateOrFn, type FormOptions, type FormState, type FormValidateOrFn, type StandardSchemaV1, type VueFormApi } from "@tanstack/vue-form"
@@ -650,27 +650,10 @@ export const generateMetaFromSchema = <From, To>(
 ): {
   schema: S.Schema<To, From, never>
   meta: MetaRecord<To>
-  filterItems?: FilterItems
 } => {
   const meta = flattenMeta(schema)
 
-  const filterItems = pipe(
-    schema.ast,
-    Option.liftPredicate((s) => s._tag === "Refinement" && "filter" in s),
-    Option.flatMap((s) => S.AST.getJSONSchemaAnnotation(s)),
-    Option.filter((s) => "items" in s),
-    Option.filterMap(({ items }) => S.decodeUnknownOption(isArrayOfString)(items)),
-    Option.zipWith(
-      S.AST.getMessageAnnotation(schema.ast),
-      (items, message) => ({
-        items,
-        message: message("" as unknown as S.ParseResult.ParseIssue)
-      })
-    ),
-    Option.getOrUndefined
-  )
-
-  return { schema, meta, filterItems }
+  return { schema, meta }
 }
 
 export const generateInputStandardSchemaFromFieldMeta = (

package/src/components/OmegaForm/useOmegaForm.ts

@@ -6,13 +6,13 @@ import { type DeepKeys, DeepValue, type FormAsyncValidateOrFn, type FormValidate
 import { Array, Data, Effect, Fiber, Option, Order, S } from "effect-app"
 import { runtimeFiberAsPromise } from "effect-app/utils"
 import { isObject } from "effect/Predicate"
-import { Component, computed, ComputedRef, ConcreteComponent, h, type InjectionKey, onBeforeUnmount, onMounted, onUnmounted, Ref, watch } from "vue"
+import { Component, computed, ComputedRef, ConcreteComponent, h, type InjectionKey, onBeforeUnmount, onMounted, onUnmounted, Ref, ref, watch } from "vue"
 import { usePreventClose } from "./blockDialog"
 import { MergedInputProps } from "./InputProps"
 import OmegaArray from "./OmegaArray.vue"
 import OmegaAutoGen from "./OmegaAutoGen.vue"
 import OmegaErrorsInternal from "./OmegaErrorsInternal.vue"
-import { BaseProps, DefaultTypeProps, type FilterItems, type FormProps, generateMetaFromSchema, type MetaRecord, type NestedKeyOf, OmegaAutoGenMeta, OmegaError, type OmegaFormApi, OmegaFormState, OmegaInputProps, ShowErrorsOn } from "./OmegaFormStuff"
+import { BaseProps, DefaultTypeProps, type FormProps, generateMetaFromSchema, type MetaRecord, type NestedKeyOf, OmegaAutoGenMeta, OmegaError, type OmegaFormApi, OmegaFormState, OmegaInputProps, ShowErrorsOn } from "./OmegaFormStuff"
 import OmegaInput from "./OmegaInput.vue"
 import OmegaForm from "./OmegaWrapper.vue"
 
@@ -65,13 +65,8 @@ const fHoc = (form: OF<any, any>) => {
 }
 
 const eHoc = (errorProps: {
-  generalErrors: Readonly<
-    Ref<
-      (Record<string, StandardSchemaV1Issue[]> | undefined)[],
-      (Record<string, StandardSchemaV1Issue[]> | undefined)[]
-    >
-  >
-  errors: Readonly<Ref<(OmegaError | undefined)[], (OmegaError | undefined)[]>>
+  form: OF<any, any>
+  fieldMap: Ref<Map<string, { id: string; label: string }>>
 }) => {
   return function FormHoc<P>(
     WrappedComponent: Component<P>
@@ -82,11 +77,10 @@ const eHoc = (errorProps: {
           ...errorProps
         }
       },
-      render({ errors, generalErrors, showErrors }: any) {
+      render({ fieldMap, form }: any) {
         return h(WrappedComponent, {
-          errors,
-          generalErrors,
-          showErrors,
+          form,
+          fieldMap,
           ...this.$attrs
         } as any, this.$slots)
       }
@@ -115,7 +109,6 @@ export type OmegaConfig<T> = {
 
 export interface OF<From, To> extends OmegaFormApi<From, To> {
   meta: MetaRecord<From>
-  filterItems?: FilterItems
   clear: () => void
   i18nNamespace?: string
   registerField: (
@@ -611,7 +604,7 @@ export const useOmegaForm = <
   const standardSchema = S.standardSchemaV1(schema)
   const decode = S.decode(schema)
 
-  const { filterItems, meta } = generateMetaFromSchema(schema)
+  const { meta } = generateMetaFromSchema(schema)
 
   const persistencyKey = computed(() => {
     if (omegaConfig?.persistency?.id) {
@@ -863,12 +856,11 @@ export const useOmegaForm = <
 
   const handleSubmit = form.handleSubmit
 
-  const fieldMap = new Map<string, { label: string; id: string }>()
+  const fieldMap = ref(new Map<string, { label: string; id: string }>())
 
   const formWithExtras: OF<From, To> = Object.assign(form, {
     i18nNamespace: omegaConfig?.i18nNamespace,
     meta,
-    filterItems,
     clear,
     handleSubmit: (meta?: Record<string, any>) => {
       const span = api.trace.getSpan(api.context.active())
@@ -877,67 +869,12 @@ export const useOmegaForm = <
     // /** @experimental */
     handleSubmitEffect,
     registerField: (field: ComputedRef<{ name: string; label: string; id: string }>) => {
-      watch(field, (f) => fieldMap.set(f.name, { label: f.label, id: f.id }), { immediate: true })
-      onUnmounted(() => fieldMap.delete(field.value.name)) // todo; perhap only when owned (id match)
+      watch(field, (f) => fieldMap.value.set(f.name, { label: f.label, id: f.id }), { immediate: true })
+      onUnmounted(() => fieldMap.value.delete(field.value.name)) // todo; perhap only when owned (id match)
     }
   })
 
-  const errors = formWithExtras.useStore((state) => state.errors)
-  const fieldErrors = formWithExtras.useStore((state) =>
-    Array.filterMap(
-      Object
-        .entries(state.fieldMeta),
-      ([key, m]): Option.Option<OmegaError> =>
-        ((m as any).errors ?? []).length && fieldMap.get(key)?.id
-          ? Option.some({
-            label: fieldMap.get(key)!.label,
-            inputId: fieldMap.get(key)!.id,
-            errors: ((m as any).errors ?? []).map((e: any) => e.message).filter(Boolean)
-          })
-          : Option.none()
-    )
-  )
-
-  watch(
-    () => [formWithExtras.filterItems, errors.value],
-    () => {
-      const filterItems: FilterItems | undefined = formWithExtras.filterItems
-      const currentErrors = errors.value
-      if (!filterItems) return {}
-      if (!currentErrors) return {}
-      const errorList = Object
-        .values(currentErrors)
-        .filter(
-          (fieldErrors): fieldErrors is Record<string, StandardSchemaV1Issue[]> => Boolean(fieldErrors)
-        )
-        .flatMap((fieldErrors) =>
-          Object
-            .values(fieldErrors)
-            .flat()
-            .map((issue: StandardSchemaV1Issue) => issue.message)
-        )
-
-      if (errorList.some((e) => e === filterItems.message)) {
-        // TODO: Investigate if filterItems.items should be typed based on DeepKeys<To>.
-        filterItems.items.forEach((item: keyof From) => {
-          const m = formWithExtras.getFieldMeta(item as any)
-          if (m) {
-            formWithExtras.setFieldMeta(item as any, {
-              ...m,
-              errorMap: {
-                onSubmit: [
-                  { path: [item as string], message: filterItems.message }
-                ]
-              }
-            })
-          }
-        })
-      }
-      return {}
-    }
-  )
-
-  const errorContext = { generalErrors: errors, errors: fieldErrors }
+  const errorContext = { form: formWithExtras, fieldMap }
 
   if (!omegaConfig?.ignorePreventCloseEvents) {
     usePreventClose(() => formWithExtras.useStore((state) => state.isDirty))