@effect-app/vue-components 0.27.16 → 1.0.0-next.1

package/dist/vue-components.es7.js

@@ -1,53 +1,335 @@
-import { defineComponent as y, inject as h, computed as l, createBlock as s, openBlock as i, resolveDynamicComponent as M, withCtx as p, createCommentVNode as $, mergeProps as b, renderSlot as C, normalizeProps as k, guardReactiveProps as F } from "vue";
-import { useIntl as A } from "./vue-components.es3.js";
-import { generateInputStandardSchemaFromFieldMeta as w } from "./vue-components.es10.js";
-import I from "./vue-components.es27.js";
-const z = /* @__PURE__ */ y({
-  inheritAttrs: !1,
-  __name: "OmegaInput",
-  props: {
-    form: {},
-    name: {},
-    validators: {},
-    label: {},
-    options: {},
-    type: {}
-  },
-  setup(u) {
-    const e = u, r = h(
-      "getMetaFromArray",
-      null
-    ), t = l(() => r?.value && r.value(e.name) ? r.value(e.name) : e.form.meta[e.name]), f = l(() => {
-      if (!t.value)
-        throw console.log(e.name, Object.keys(e.form.meta), e.form.meta), new Error("Meta is undefined");
-      return w(t.value);
-    }), { formatMessage: o } = A(), d = (a) => a.replace(/([A-Z])/g, " $1").replace(/^./, (m) => m.toUpperCase()).trim(), n = () => o({ id: `general.fields.${e.name}`, defaultMessage: d(e.name) }), c = () => e.form.i18nNamespace ? o({ id: `${e.form.i18nNamespace}.fields.${e.name}`, defaultMessage: n() }) : n();
-    return (a, m) => (i(), s(M(a.form.Field), {
-      name: a.name,
-      validators: {
-        onChange: f.value,
-        ...a.validators
+import { S as n, Option as c, pipe as L } from "effect-app";
+import { getTransformationFrom as U, useIntl as _ } from "./vue-components.es3.js";
+const N = 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 = {}) => {
+  if (t && t._tag === "Transformation")
+    return m({
+      parent: i,
+      meta: e,
+      property: t.from
+    });
+  if (t?._tag === "TypeLiteral" && "propertySignatures" in t)
+    return m({
+      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 (n.AST.isUnion(r.type)) {
+        const T = r.type.types.filter(
+          (s) => s._tag !== "UndefinedKeyword" && s !== n.Null.ast
+        ).map(U);
+        if (T.some(
+          (s) => "propertySignatures" in s
+        )) {
+          if (!a) {
+            const s = m({
+              parent: l,
+              property: r.type,
+              meta: { required: u, nullableOrUndefined: a }
+            });
+            o[l] = s;
+          }
+          for (const s of T)
+            "propertySignatures" in s && Object.assign(
+              o,
+              m({
+                parent: l,
+                propertySignatures: s.propertySignatures,
+                meta: { required: u, nullableOrUndefined: a }
+              })
+            );
+        } else {
+          const s = T.filter(n.AST.isTupleType);
+          if (s.length > 0) {
+            const f = s[0];
+            if (o[l] = {
+              type: "multiple",
+              members: f.elements,
+              rest: f.rest,
+              required: u,
+              nullableOrUndefined: a
+            }, f.rest && f.rest.length > 0) {
+              const d = f.rest[0];
+              if (d.type._tag === "TypeLiteral" && "propertySignatures" in d.type)
+                for (const y of d.type.propertySignatures) {
+                  const b = `${l}.${y.name.toString()}`, S = m({
+                    parent: b,
+                    property: y.type,
+                    meta: {
+                      required: !g(y.type),
+                      nullableOrUndefined: g(y.type)
+                    }
+                  });
+                  if (S && typeof S == "object" && "type" in S && (o[b] = S, S.type === "multiple" && n.AST.isTupleType(y.type) && y.type.rest && y.type.rest.length > 0)) {
+                    const O = y.type.rest[0];
+                    if (O.type._tag === "TypeLiteral" && "propertySignatures" in O.type)
+                      for (const v of O.type.propertySignatures) {
+                        const M = `${b}.${v.name.toString()}`, x = m({
+                          parent: M,
+                          property: v.type,
+                          meta: {
+                            required: !g(v.type),
+                            nullableOrUndefined: g(v.type)
+                          }
+                        });
+                        x && typeof x == "object" && "type" in x && (o[M] = x);
+                      }
+                  }
+                }
+            }
+          } else {
+            const f = m({
+              parent: l,
+              property: r.type,
+              meta: { required: u, nullableOrUndefined: a }
+            });
+            o[l] = f;
+          }
+        }
+      } else if ("propertySignatures" in A)
+        Object.assign(
+          o,
+          m({
+            parent: l,
+            propertySignatures: A.propertySignatures,
+            meta: { required: u, nullableOrUndefined: a }
+          })
+        );
+      else if (n.AST.isTupleType(r.type))
+        if (r.type.rest.length > 0 && r.type.rest[0].type._tag === "TypeLiteral" && "propertySignatures" in r.type.rest[0].type) {
+          const h = r.type.rest[0].type;
+          if (h._tag === "TypeLiteral" && "propertySignatures" in h)
+            for (const s of h.propertySignatures) {
+              const f = `${l}.${s.name.toString()}`;
+              if (n.AST.isTupleType(s.type) && s.type.rest.length > 0) {
+                const d = s.type.rest[0].type;
+                if (d._tag === "TypeLiteral" && "propertySignatures" in d)
+                  for (const y of d.propertySignatures) {
+                    const b = `${f}.${y.name.toString()}`, S = m({
+                      parent: b,
+                      property: y.type,
+                      meta: {
+                        required: !g(y.type),
+                        nullableOrUndefined: g(y.type)
+                      }
+                    });
+                    o[b] = S;
+                  }
+                else
+                  o[f] = {
+                    type: "multiple",
+                    members: s.type.elements,
+                    rest: s.type.rest,
+                    required: !g(s.type),
+                    nullableOrUndefined: g(s.type)
+                  };
+              } else {
+                const d = m({
+                  parent: f,
+                  property: s.type,
+                  meta: {
+                    required: !g(s.type),
+                    nullableOrUndefined: g(s.type)
+                  }
+                });
+                o[f] = d;
+              }
+            }
+        } else
+          o[l] = {
+            type: "multiple",
+            members: r.type.elements,
+            rest: r.type.rest,
+            required: u,
+            nullableOrUndefined: a
+          };
+      else {
+        const T = m({
+          parent: l,
+          property: r.type,
+          meta: { required: u, nullableOrUndefined: a }
+        });
+        o[l] = T;
       }
-    }, {
-      default: p(({ field: v }) => [
-        t.value ? (i(), s(I, b({
-          key: 0,
-          field: v,
-          label: a.label ?? c(),
-          options: a.options,
-          meta: t.value,
-          type: a.type
-        }, a.$attrs), {
-          default: p((g) => [
-            C(a.$slots, "default", k(F(g)))
-          ]),
-          _: 3
-        }, 16, ["field", "label", "options", "meta", "type"])) : $("", !0)
-      ]),
-      _: 3
-    }, 8, ["name", "validators"]));
+    }
+    return o;
   }
-});
+  if (t) {
+    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
+      );
+      return "propertySignatures" in a ? m({
+        propertySignatures: a.propertySignatures,
+        parent: i,
+        meta: e
+      }) : t.types.every(n.AST.isLiteral) ? {
+        ...e,
+        type: "select",
+        members: t.types.map((u) => u.literal)
+      } : {
+        ...e,
+        ...m({
+          parent: i,
+          meta: e,
+          property: a
+        })
+      };
+    }
+    if (n.AST.isTupleType(t))
+      return {
+        ...e,
+        type: "multiple",
+        members: t.elements,
+        rest: t.rest
+      };
+    const l = n.AST.getAnnotation(
+      t,
+      n.AST.JSONSchemaAnnotationId
+    ).pipe(c.getOrElse(() => ({})));
+    return e = { ...e, ...l }, "from" in t ? m({
+      parent: i,
+      meta: e,
+      property: t.from
+    }) : (e.type = n.AST.getAnnotation(
+      t,
+      n.AST.TitleAnnotationId
+    ).pipe(
+      c.getOrElse(() => "unknown")
+    ), e);
+  }
+  return o;
+}, q = (e) => {
+  const i = e.ast, t = {};
+  if (i._tag === "Transformation" || i._tag === "Refinement")
+    return q(n.make(i.from));
+  if ("propertySignatures" in i) {
+    const p = m({
+      propertySignatures: i.propertySignatures
+    });
+    if (Object.values(p).every((r) => r && "type" in r))
+      return p;
+    const o = (r, l = "") => {
+      for (const a in r) {
+        const u = l ? `${l}.${a}` : a;
+        r[a] && typeof r[a] == "object" && "type" in r[a] ? t[u] = r[a] : r[a] && typeof r[a] == "object" && o(r[a], u);
+      }
+    };
+    o(p);
+  }
+  return t;
+}, $ = (e) => n.extend(e, n.Struct({})), K = (e) => {
+  const i = q(e), t = L(
+    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(N)(p)),
+    c.zipWith(
+      n.AST.getMessageAnnotation(e.ast),
+      (p, o) => ({
+        items: p,
+        message: o("")
+      })
+    ),
+    c.getOrUndefined
+  );
+  return { schema: e, meta: i, filterItems: t };
+}, P = (e) => {
+  const { trans: i } = _();
+  let t;
+  switch (e.type) {
+    case "string":
+      t = n.String.annotations({
+        message: () => i("validation.empty")
+      }), e.format === "email" && (t = n.compose(
+        t,
+        n.Email.annotations({
+          message: () => i("validation.email.invalid")
+        })
+      )), e.required && t.annotations({
+        message: () => i("validation.empty")
+      }), e.maxLength && (t = t.pipe(n.maxLength(e.maxLength)).annotations({
+        message: () => i("validation.string.maxLength", {
+          maxLength: e.maxLength
+        })
+      })), e.minLength && (t = t.pipe(n.minLength(e.minLength)).annotations({
+        message: () => i("validation.string.minLength", {
+          minLength: e.minLength
+        })
+      }));
+      break;
+    case "number":
+      t = n.Number.annotations({
+        message: () => i("validation.empty")
+      }), e.required && t.annotations({
+        message: () => i("validation.empty")
+      }), e.minimum && (t = t.pipe(n.greaterThanOrEqualTo(e.minimum)).annotations({
+        message: () => i("validation.number.min", {
+          minimum: e.minimum,
+          isExclusive: !0
+        })
+      })), e.maximum && (t = t.pipe(n.lessThanOrEqualTo(e.maximum)).annotations({
+        message: () => i("validation.number.max", {
+          maximum: e.maximum,
+          isExclusive: !0
+        })
+      })), e.exclusiveMinimum && (t = t.pipe(n.greaterThan(e.exclusiveMinimum)).annotations({
+        message: () => i("validation.number.min", {
+          minimum: e.exclusiveMinimum,
+          isExclusive: !1
+        })
+      })), e.exclusiveMaximum && (t = t.pipe(n.lessThan(e.exclusiveMaximum)).annotations({
+        message: () => i("validation.number.max", {
+          maximum: e.exclusiveMaximum,
+          isExclusive: !1
+        })
+      }));
+      break;
+    case "select":
+      t = n.Literal(...e.members).annotations({
+        message: () => ({
+          message: i("validation.not_a_valid", {
+            type: "select",
+            message: e.members.join(", ")
+          }),
+          override: !0
+        })
+      });
+      break;
+    case "multiple":
+      t = n.Array(n.String).annotations({
+        message: () => i("validation.not_a_valid", {
+          type: "multiple",
+          message: e.members.join(", ")
+        })
+      });
+      break;
+    case "boolean":
+      t = n.Boolean;
+      break;
+    // todo: switch must be exhaustive or have default case, otherwise falls through with schema undefined.
+    case "unknown":
+      t = n.Unknown;
+      break;
+  }
+  return e.required ? t.pipe(
+    n.annotations({
+      message: () => i("validation.empty")
+    })
+  ) : t = n.NullishOr(t), n.standardSchemaV1(t);
+}, I = (e, i) => n.NullOr(e).pipe(
+  n.transform(n.typeSchema(e), {
+    decode: (t) => t ?? i(),
+    encode: (t) => t
+  })
+);
 export {
-  z as default
+  m as createMeta,
+  $ as duplicateSchema,
+  P as generateInputStandardSchemaFromFieldMeta,
+  K as generateMetaFromSchema,
+  I as nullableInput
 };

package/dist/vue-components.es8.js

@@ -1,31 +1,4 @@
-import { ref as l, computed as p, readonly as v, provide as E, inject as f } from "vue";
-const s = Symbol();
-function g(o, i, t = "onSubmit") {
-  const r = l([]), n = (e) => {
-    r.value = r.value.filter((d) => d.inputId !== e);
-  }, c = (e) => {
-    n(e.inputId), r.value.push(e);
-  }, m = () => {
-    r.value = [];
-  }, a = p(() => t === "onSubmit" ? o.value > 0 : !0), u = {
-    errors: v(r),
-    addError: c,
-    removeError: n,
-    clearErrors: m,
-    showErrors: a,
-    generalErrors: i,
-    showErrorsOn: t ?? "onSubmit"
-  };
-  return E(s, u), u;
-}
-function O() {
-  const o = f(s);
-  if (!o)
-    throw new Error("useOmegaErrors must be used within an OmegaForm provider");
-  return o;
-}
+import f from "./vue-components.es4.js";
 export {
-  s as OmegaErrorsKey,
-  g as provideOmegaErrors,
-  O as useOmegaErrors
+  f as default
 };

package/dist/vue-components.es9.js

@@ -1,150 +1,12 @@
-import { useForm as A } from "@tanstack/vue-form";
-import { S as V, Effect as f, Fiber as w } from "effect-app";
-import { runtimeFiberAsPromise as D } from "./vue-components.es22.js";
-import { isObject as J } from "./vue-components.es23.js";
-import { computed as g, onUnmounted as K, onMounted as M, onBeforeUnmount as q, provide as x } from "vue";
-import _ from "./vue-components.es6.js";
-import { generateMetaFromSchema as $ } from "./vue-components.es10.js";
-import { trace as P } from "./vue-components.es24.js";
-import { context as S } from "./vue-components.es25.js";
-const B = Symbol("OmegaForm"), Z = (u, o, n) => {
-  if (!u) throw new Error("Schema is required");
-  const j = V.standardSchemaV1(u), E = V.decode(u), { filterItems: L, meta: d } = $(u), a = g(() => {
-    if (n?.persistency?.id)
-      return n.persistency.id;
-    const e = window.location.pathname, r = Object.keys(d);
-    return `${e}-${r.join("-")}`;
-  }), U = () => {
-    const e = new URLSearchParams(window.location.search);
-    e.delete(a.value);
-    const r = new URL(window.location.href);
-    r.search = e.toString(), window.history.replaceState({}, "", r.toString());
-  };
-  function h(e, r) {
-    for (const t in r)
-      r[t] && J(r[t]) ? (e[t] || (e[t] = {}), h(e[t], r[t])) : e[t] = r[t];
-    return e;
-  }
-  const F = g(() => {
-    if (o?.defaultValues && !n?.persistency?.overrideDefaultValues)
-      return o?.defaultValues;
-    let e;
-    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(a.value);
-        U(), s && (e = JSON.parse(s));
-      } catch (t) {
-        console.error(t);
-      }
-    if (
-      // query string has higher priority than local/session storage
-      !e && (r.policies.includes("local") || r.policies.includes("session"))
-    ) {
-      const t = r.policies.includes("local") ? localStorage : sessionStorage;
-      if (t)
-        try {
-          const s = JSON.parse(
-            t.getItem(a.value) || "{}"
-          );
-          t.removeItem(a.value), e = s;
-        } catch (s) {
-          console.error(s);
-        }
-    }
-    if (e ??= {}, o?.defaultValues == null)
-      return e;
-    {
-      const t = o?.defaultValues;
-      return h(t, e);
-    }
-  }), N = (e, r) => e ? S.with(P.setSpan(S.active(), e), r) : r(), c = A({
-    ...o,
-    validators: {
-      onSubmit: j,
-      ...o?.validators || {}
-    },
-    onSubmit: o?.onSubmit ? ({ formApi: e, meta: r, value: t }) => N(r?.currentSpan, async () => {
-      const s = await f.runPromise(E(t)), i = o.onSubmit({
-        formApi: e,
-        meta: r,
-        value: s
-      });
-      return w.isFiber(i) && w.isRuntimeFiber(i) ? await D(i) : f.isEffect(i) ? await f.runPromise(
-        i.pipe(
-          // meta?.currentSpan
-          //   ? Effect.withParentSpan(meta.currentSpan)
-          //   : (_) => _,
-          f.flatMap((l) => w.join(l))
-        )
-      ) : i;
-    }) : void 0,
-    defaultValues: F.value
-  }), O = () => {
-    Object.keys(d).forEach((e) => {
-      c.setFieldValue(e, void 0);
-    });
-  }, y = (e) => e.reduce((r, t) => {
-    const s = t.split(".");
-    return s.reduce((i, l, R) => (R === s.length - 1 ? i[l] = c.getFieldValue(t) : i[l] = i[l] ?? {}, i[l]), r), r;
-  }, {}), v = (e) => {
-    if (e) {
-      if (Array.isArray(e.keys))
-        return y(e.keys);
-      if (Array.isArray(e.banKeys)) {
-        const r = Object.keys(d).filter((t) => e.banKeys?.includes(t));
-        return y(r);
-      }
-      return c.store.state.values;
-    }
-  }, m = () => {
-    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 = v(e);
-      return r.setItem(a.value, JSON.stringify(t));
-    }
-  }, b = () => {
-    const e = n?.persistency;
-    if (!(!e?.policies || e.policies.length === 0) && e.policies.includes("querystring")) {
-      const r = v(e), t = new URLSearchParams(window.location.search);
-      t.set(a.value, JSON.stringify(r));
-      const s = new URL(window.location.href);
-      s.search = t.toString(), window.history.replaceState({}, "", s.toString());
-    }
-  };
-  K(m), M(() => {
-    window.addEventListener("beforeunload", m), window.addEventListener("blur", b);
-  }), q(() => {
-    window.removeEventListener("beforeunload", m), window.removeEventListener("blur", b);
-  });
-  const I = c.handleSubmit, p = Object.assign(c, {
-    i18nNamespace: n?.i18nNamespace,
-    meta: d,
-    filterItems: L,
-    clear: O,
-    handleSubmit: (e) => {
-      const r = P.getSpan(S.active());
-      return I({ currentSpan: r, ...e });
-    }
-    // /** @experimental */
-    // handleSubmitEffect: (meta?: Record<string, any>) =>
-    //   Effect.currentSpan.pipe(
-    //     Effect.option,
-    //     Effect
-    //       .flatMap((span) =>
-    //         Effect.promise(() => form.handleSubmit(Option.isSome(span) ? { currentSpan: span.value, ...meta } : meta))
-    //       )
-    //   )
-  });
-  return x(B, p), Object.assign(p, {
-    Input: n?.input ? n.input(p) : _,
-    Field: c.Field
-  });
-};
+import { Exit as c, Runtime as s } from "effect";
+import { dual as n, isFunction as m } from "./vue-components.es18.js";
+const i = Symbol.for("clone-trait"), u = n(2, (e, t) => i in e ? e[i](t) : Object.setPrototypeOf(t, Object.getPrototypeOf(e)));
+n(2, (e, t) => u(e, { ...e, ...m(t) ? t(e) : t }));
+const b = (e) => new Promise((t, r) => e.addObserver((o) => {
+  c.isSuccess(o) ? t(o.value) : r(s.makeFiberFailure(o.cause));
+}));
 export {
-  B as OmegaFormKey,
-  Z as useOmegaForm
+  u as clone,
+  i as cloneTrait,
+  b as runtimeFiberAsPromise
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "0.27.16",
+  "version": "1.0.0-next.1",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
     "effect": "^3.17.13",
@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@tanstack/vue-form": "^1.19.5",
+    "@tanstack/vue-form": "^1.23.0",
     "highlight.js": "^11.11.1",
     "vue3-highlightjs": "^1.0.5",
     "@effect-app/vue": "2.80.2",

package/src/components/OmegaForm/OmegaArray.vue

@@ -42,9 +42,11 @@
 <script
   setup
   lang="ts"
-  generic="// dprint ignore - somehow with 120 chars, this becomes a mess. should report it.
+  generic="
+  // dprint ignore - somehow with 120 chars, this becomes a mess. should report it.
   From extends Record<PropertyKey, any>,
-  To extends Record<PropertyKey, any>"
+  To extends Record<PropertyKey, any>
+"
 >
 import { type DeepKeys, type DeepValue } from "@tanstack/vue-form"
 import { computed, onMounted, provide } from "vue"

package/src/components/OmegaForm/OmegaAutoGen.vue

@@ -3,8 +3,7 @@
     v-for="({ name, label, ...attrs }) in children"
     :child="{ name, label, ...attrs }"
   >
-    <OmegaInput
-      :form="props.form"
+    <form.Input
       :name="name"
       :label="label"
       v-bind="attrs"
@@ -15,14 +14,15 @@
 <script
   setup
   lang="ts"
-  generic="From extends Record<PropertyKey, string>,
-  To extends Record<PropertyKey, string>"
+  generic="
+  From extends Record<PropertyKey, string>,
+  To extends Record<PropertyKey, string>
+"
 >
 import { type DeepKeys } from "@tanstack/vue-form"
 import { Array as A, Order, pipe } from "effect-app"
 import { computed } from "vue"
 import { type FieldMeta, type OmegaInputProps } from "./OmegaFormStuff"
-import OmegaInput from "./OmegaInput.vue"
 
 export type OmegaAutoGenMeta<
   From extends Record<PropertyKey, string>,

package/src/components/OmegaForm/OmegaErrorsContext.ts

@@ -1,5 +1,5 @@
 import type { StandardSchemaV1Issue } from "@tanstack/vue-form"
-import { computed, inject, type InjectionKey, provide, readonly, type Ref, ref } from "vue"
+import { computed, inject, type InjectionKey, readonly, type Ref, ref } from "vue"
 import { type OmegaError, type ShowErrorsOn } from "./OmegaFormStuff"
 
 export const OmegaErrorsKey = Symbol() as InjectionKey<{
@@ -9,15 +9,19 @@ export const OmegaErrorsKey = Symbol() as InjectionKey<{
   clearErrors: () => void
   showErrors: Ref<boolean>
   showErrorsOn: ShowErrorsOn
-  generalErrors: Ref<
-    (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined
+  generalErrors: Readonly<
+    Ref<
+      (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined
+    >
   >
 }>
 
-export function provideOmegaErrors(
+export function buildOmegaErrors(
   formSubmissionAttempts: Ref<number>,
-  generalErrors: Ref<
-    (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined
+  generalErrors: Readonly<
+    Ref<
+      (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined
+    >
   >,
   showErrorsOn: ShowErrorsOn = "onSubmit"
 ) {
@@ -51,8 +55,6 @@ export function provideOmegaErrors(
     showErrorsOn: showErrorsOn ?? "onSubmit"
   }
 
-  provide(OmegaErrorsKey, context)
-
   return context
 }