@effect-app/vue-components 1.8.3 → 1.8.4

package/src/components/OmegaForm/OmegaInternalInput.vue

@@ -1,9 +1,6 @@
 <template>
   <slot v-bind="{ ...$attrs, ...inputProps.inputProps, field: inputProps.field }">
-    <div
-      :class="$attrs.class"
-      @focusout="setRealDirty"
-    >
+    <div :class="$attrs.class">
       <OmegaInputVuetify
         v-if="vuetified"
         v-bind="{ ...$attrs, ...inputProps }"
@@ -18,7 +15,7 @@
   generic="From extends Record<PropertyKey, any>, Name extends DeepKeys<From>"
 >
 import { type DeepKeys, useStore } from "@tanstack/vue-form"
-import { computed, type ComputedRef, getCurrentInstance, onMounted, onUnmounted, ref, useId, watch, watchEffect } from "vue"
+import { computed, type ComputedRef, getCurrentInstance, onMounted, useId } from "vue"
 import type { InputProps, OmegaFieldInternalApi } from "./InputProps"
 import type { FieldValidators, MetaRecord, NestedKeyOf, TypeOverride } from "./OmegaFormStuff"
 import OmegaInputVuetify from "./OmegaInputVuetify.vue"
@@ -34,6 +31,14 @@ const props = defineProps<{
   type?: TypeOverride
   validators?: FieldValidators<From>
 
+  register: (
+    field: ComputedRef<{
+      name: string
+      label: string
+      id: string
+    }>
+  ) => void
+
   // TODO: these should really be optional, depending on the input type (and the custom input type for custom inputs :s)
   options?: { title: string; value: string }[]
 }>()
@@ -56,6 +61,8 @@ const fieldType = computed(() => {
   return props.meta?.type || "unknown"
 })
 
+props.register(computed(() => ({ name: props.field.name, label: props.label, id })))
+
 const fieldValue = computed(() => fieldState.value.value)
 // workaround strange tanstack form issue where the errors key becomes undefined ???
 const _errors = computed(() => fieldState.value.meta.errors ?? [])
@@ -97,57 +104,12 @@ onMounted(() => {
   }
 })
 
-const { mapError, removeError, showErrors, showErrorsOn } = (props.field.form as any).errorContext // todo; update types to include extended Omega Form props
-
-const realDirty = ref(false)
-
-watchEffect(() => {
-  if (showErrors.value || showErrorsOn === "onChange") {
-    realDirty.value = true
-  }
-})
-
-const setRealDirty = () => {
-  realDirty.value = true
-}
-
-onMounted(() => {
-  if (fieldValue.value) {
-    setRealDirty()
-  }
-})
-
 const showedErrors = computed(() => {
   // single select field can be validated on change
-  if (!realDirty.value && fieldType.value !== "select") return []
+  if (!fieldState.value.meta.isDirty && fieldType.value !== "select") return []
   return errors.value
 })
 
-watch(
-  _errors,
-  (errors) => {
-    if (errors.length) {
-      mapError({
-        inputId: id,
-        errors: fieldState
-          .value
-          .meta
-          .errors
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          .map((e: any) => e.message)
-          .filter(Boolean),
-        label: props.label
-      })
-    } else {
-      removeError(id)
-    }
-  }
-)
-
-onUnmounted(() => {
-  removeError(id)
-})
-
 const wrapField = (field: OmegaFieldInternalApi<From, Name>) => {
   const handler3 = {
     get(_target: any, prop: PropertyKey, _receiver: any) {
@@ -172,7 +134,6 @@ const inputProps: ComputedRef<InputProps<From, Name>> = computed(() => ({
     min: props.meta?.type === "number" && props.meta?.minimum,
     errorMessages: showedErrors.value,
     error: !!showedErrors.value.length,
-    setRealDirty,
     type: fieldType.value,
     label: `${props.label}${props.meta?.required ? " *" : ""}`,
     options: props.options

package/src/components/OmegaForm/index.ts

@@ -1,4 +1,3 @@
-export * as OmegaErrorsContext from "./OmegaErrorsContext"
 export * from "./OmegaFormStuff"
 export { type OmegaConfig, type OmegaFormReturn, useOmegaForm } from "./useOmegaForm"
 

package/src/components/OmegaForm/useOmegaForm.ts

@@ -2,16 +2,15 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import * as api from "@opentelemetry/api"
-import { type DeepKeys, DeepValue, type FormAsyncValidateOrFn, type FormValidateOrFn, type StandardSchemaV1, StandardSchemaV1Issue, useForm, useStore, ValidationError, ValidationErrorMap } from "@tanstack/vue-form"
-import { Data, Effect, Fiber, Option, Order, S } from "effect-app"
+import { type DeepKeys, DeepValue, type FormAsyncValidateOrFn, type FormValidateOrFn, type StandardSchemaV1, StandardSchemaV1Issue, useForm, ValidationError, ValidationErrorMap } from "@tanstack/vue-form"
+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, ConcreteComponent, h, type InjectionKey, onBeforeUnmount, onMounted, onUnmounted, watch } from "vue"
+import { Component, computed, ComputedRef, ConcreteComponent, h, type InjectionKey, onBeforeUnmount, onMounted, onUnmounted, Ref, watch } from "vue"
 import { usePreventClose } from "./blockDialog"
 import { MergedInputProps } from "./InputProps"
 import OmegaArray from "./OmegaArray.vue"
 import OmegaAutoGen from "./OmegaAutoGen.vue"
-import { buildOmegaErrors } from "./OmegaErrorsContext"
 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 OmegaInput from "./OmegaInput.vue"
@@ -65,7 +64,15 @@ const fHoc = (form: OF<any, any>) => {
   }
 }
 
-const eHoc = (errorProps: ReturnType<typeof buildOmegaErrors>) => {
+const eHoc = (errorProps: {
+  generalErrors: Readonly<
+    Ref<
+      (Record<string, StandardSchemaV1Issue[]> | undefined)[],
+      (Record<string, StandardSchemaV1Issue[]> | undefined)[]
+    >
+  >
+  errors: Readonly<Ref<(OmegaError | undefined)[], (OmegaError | undefined)[]>>
+}) => {
   return function FormHoc<P>(
     WrappedComponent: Component<P>
   ): ConcreteComponent<P> {
@@ -111,6 +118,13 @@ export interface OF<From, To> extends OmegaFormApi<From, To> {
   filterItems?: FilterItems
   clear: () => void
   i18nNamespace?: string
+  registerField: (
+    field: ComputedRef<{
+      name: string
+      label: string
+      id: string
+    }>
+  ) => void
   /** @experimental */
   handleSubmitEffect: {
     /**
@@ -848,6 +862,9 @@ export const useOmegaForm = <
       : handleSubmitEffect_(options?.meta)
 
   const handleSubmit = form.handleSubmit
+
+  const fieldMap = new Map<string, { label: string; id: string }>()
+
   const formWithExtras: OF<From, To> = Object.assign(form, {
     i18nNamespace: omegaConfig?.i18nNamespace,
     meta,
@@ -858,15 +875,28 @@ export const useOmegaForm = <
       return handleSubmit({ currentSpan: span, ...meta })
     },
     // /** @experimental */
-    handleSubmitEffect
+    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)
+    }
   })
 
-  const formSubmissionAttempts = useStore(
-    formWithExtras.store,
-    (state) => state.submissionAttempts
-  )
-
   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],
@@ -907,8 +937,7 @@ export const useOmegaForm = <
     }
   )
 
-  //  provide(OmegaFormKey, formWithExtras)
-  const errorContext = buildOmegaErrors(formSubmissionAttempts, errors, omegaConfig?.showErrorsOn)
+  const errorContext = { generalErrors: errors, errors: fieldErrors }
 
   if (!omegaConfig?.ignorePreventCloseEvents) {
     usePreventClose(() => formWithExtras.useStore((state) => state.isDirty))

package/src/components/OmegaForm/useRegisterField.ts

@@ -0,0 +1,15 @@
+import { injectCertain } from "@effect-app/vue"
+import { type ComputedRef, type InjectionKey, onUnmounted, provide, watch } from "vue"
+
+const Key = Symbol("injected") as InjectionKey<Map<string, { label: string; id: string }>>
+
+export const useRegisterField = (field: ComputedRef<{ name: string; label: string; id: string }>) => {
+  const map = injectCertain(Key)
+  watch(field, (f) => map.set(f.name, { label: f.label, id: f.id }), { immediate: true })
+  onUnmounted(() => map.delete(field.value.name)) // todo; perhap only when owned
+}
+
+export const provideRegisterField = () => {
+  const map = new Map<string, { label: string; id: string }>()
+  provide(Key, map)
+}

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

@@ -1,38 +0,0 @@
-import type { StandardSchemaV1Issue } from "@tanstack/vue-form";
-import { type InjectionKey, type Ref } from "vue";
-import { type OmegaError, type ShowErrorsOn } from "./OmegaFormStuff";
-export declare const OmegaErrorsKey: InjectionKey<{
-    errors: Ref<readonly OmegaError[]>;
-    mapError: (error: OmegaError) => void;
-    removeError: (inputId: string) => void;
-    clearErrors: () => void;
-    showErrors: Ref<boolean>;
-    showErrorsOn: ShowErrorsOn;
-    generalErrors: Readonly<Ref<(Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined>>;
-}>;
-export declare function buildOmegaErrors(formSubmissionAttempts: Ref<number>, generalErrors: Readonly<Ref<(Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined>>, showErrorsOn?: ShowErrorsOn): {
-    errors: Readonly<Ref<readonly {
-        readonly label: string;
-        readonly inputId: string;
-        readonly errors: readonly string[];
-    }[], readonly {
-        readonly label: string;
-        readonly inputId: string;
-        readonly errors: readonly string[];
-    }[]>>;
-    mapError: (error: OmegaError) => void;
-    removeError: (inputId: string) => void;
-    clearErrors: () => void;
-    showErrors: import("vue").ComputedRef<boolean>;
-    generalErrors: Readonly<Ref<(Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined, (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined>>;
-    showErrorsOn: ShowErrorsOn;
-};
-export declare function useOmegaErrors(): {
-    errors: Ref<readonly OmegaError[]>;
-    mapError: (error: OmegaError) => void;
-    removeError: (inputId: string) => void;
-    clearErrors: () => void;
-    showErrors: Ref<boolean>;
-    showErrorsOn: ShowErrorsOn;
-    generalErrors: Readonly<Ref<(Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined>>;
-};

package/dist/vue-components.es25.js

@@ -1,137 +0,0 @@
-import { defineComponent as y, resolveComponent as o, createElementBlock as m, openBlock as n, createBlock as a, createCommentVNode as i, resolveDynamicComponent as d, mergeProps as u, unref as b, withCtx as h, Fragment as c, renderList as C } from "vue";
-import { getInputType as q } from "./vue-components.es10.js";
-const U = /* @__PURE__ */ y({
-  inheritAttrs: !1,
-  __name: "OmegaInputVuetify",
-  props: {
-    inputProps: {},
-    field: {}
-  },
-  emits: ["focus", "blur"],
-  setup(e) {
-    return (r, l) => {
-      const s = o("v-text-field"), P = o("v-textarea"), g = o("v-radio"), v = o("v-radio-group"), p = o("v-select"), f = o("v-autocomplete");
-      return n(), m("div", {
-        class: "omega-input",
-        onFocusout: l[4] || (l[4] = (t) => r.$emit("blur", t)),
-        onFocusin: l[5] || (l[5] = (t) => r.$emit("focus", t))
-      }, [
-        e.inputProps.type === "boolean" || e.inputProps.type === "switch" ? (n(), a(d(e.inputProps.type === "boolean" ? "v-checkbox" : "v-switch"), u({
-          key: 0,
-          id: e.inputProps.id,
-          name: e.field.name,
-          label: e.inputProps.label,
-          "error-messages": e.inputProps.errorMessages,
-          error: e.inputProps.error,
-          ripple: ""
-        }, r.$attrs, {
-          "model-value": e.field.state.value,
-          onChange: l[0] || (l[0] = (t) => e.field.handleChange(t.target.checked))
-        }), null, 16, ["id", "name", "label", "error-messages", "error", "model-value"])) : i("", !0),
-        e.inputProps.type === "email" || e.inputProps.type === "string" || e.inputProps.type === "password" ? (n(), a(s, u({
-          key: 1,
-          id: e.inputProps.id,
-          required: e.inputProps.required,
-          "min-length": e.inputProps.minLength,
-          "max-length": e.inputProps.maxLength,
-          type: b(q)(e.inputProps.type),
-          name: e.field.name,
-          label: e.inputProps.label,
-          "error-messages": e.inputProps.errorMessages,
-          error: e.inputProps.error
-        }, r.$attrs, {
-          "model-value": e.field.state.value,
-          "onUpdate:modelValue": e.field.handleChange
-        }), null, 16, ["id", "required", "min-length", "max-length", "type", "name", "label", "error-messages", "error", "model-value", "onUpdate:modelValue"])) : i("", !0),
-        e.inputProps.type === "text" ? (n(), a(P, u({
-          key: 2,
-          id: e.inputProps.id,
-          required: e.inputProps.required,
-          "min-length": e.inputProps.minLength,
-          "max-length": e.inputProps.maxLength,
-          name: e.field.name,
-          label: e.inputProps.label,
-          "error-messages": e.inputProps.errorMessages,
-          error: e.inputProps.error
-        }, r.$attrs, {
-          "model-value": e.field.state.value,
-          "onUpdate:modelValue": e.field.handleChange
-        }), null, 16, ["id", "required", "min-length", "max-length", "name", "label", "error-messages", "error", "model-value", "onUpdate:modelValue"])) : i("", !0),
-        e.inputProps.type === "number" || e.inputProps.type === "range" ? (n(), a(d(e.inputProps.type === "range" ? "v-slider" : "v-text-field"), u({
-          key: 3,
-          id: e.inputProps.id,
-          required: e.inputProps.required,
-          min: e.inputProps.min,
-          max: e.inputProps.max,
-          type: e.inputProps.type,
-          name: e.field.name,
-          label: e.inputProps.label,
-          "error-messages": e.inputProps.errorMessages,
-          error: e.inputProps.error
-        }, r.$attrs, {
-          "model-value": e.field.state.value,
-          "onUpdate:modelValue": l[1] || (l[1] = (t) => {
-            t || t === 0 ? e.field.handleChange(Number(t)) : e.field.handleChange(void 0);
-          })
-        }), null, 16, ["id", "required", "min", "max", "type", "name", "label", "error-messages", "error", "model-value"])) : i("", !0),
-        e.inputProps.type === "radio" ? (n(), a(v, u({
-          key: 4,
-          id: e.inputProps.id,
-          name: e.field.name,
-          label: e.inputProps.label,
-          "error-messages": e.inputProps.errorMessages,
-          error: e.inputProps.error
-        }, r.$attrs, {
-          "model-value": e.field.state.value,
-          "onUpdate:modelValue": e.field.handleChange
-        }), {
-          default: h(() => [
-            (n(!0), m(c, null, C(e.inputProps.options, (t) => (n(), a(g, {
-              key: t.value,
-              label: t.title,
-              value: t.value
-            }, null, 8, ["label", "value"]))), 128))
-          ]),
-          _: 1
-        }, 16, ["id", "name", "label", "error-messages", "error", "model-value", "onUpdate:modelValue"])) : i("", !0),
-        e.inputProps.type === "select" || e.inputProps.type === "multiple" ? (n(), a(p, u({
-          key: 5,
-          id: e.inputProps.id,
-          clearable: e.inputProps.type === "select",
-          required: e.inputProps.required,
-          multiple: e.inputProps.type === "multiple",
-          chips: e.inputProps.type === "multiple",
-          name: e.field.name,
-          label: e.inputProps.label,
-          items: e.inputProps.options,
-          "error-messages": e.inputProps.errorMessages,
-          error: e.inputProps.error
-        }, r.$attrs, {
-          "model-value": e.field.state.value,
-          onClear: l[2] || (l[2] = (t) => e.field.handleChange(void 0)),
-          "onUpdate:modelValue": e.field.handleChange
-        }), null, 16, ["id", "clearable", "required", "multiple", "chips", "name", "label", "items", "error-messages", "error", "model-value", "onUpdate:modelValue"])) : i("", !0),
-        e.inputProps.type === "autocomplete" || e.inputProps.type === "autocompletemultiple" ? (n(), a(f, u({
-          key: 6,
-          id: e.inputProps.id,
-          clearable: e.inputProps.type === "autocomplete",
-          multiple: e.inputProps.type === "autocompletemultiple",
-          required: e.inputProps.required,
-          name: e.field.name,
-          label: e.inputProps.label,
-          items: e.inputProps.options,
-          "error-messages": e.inputProps.errorMessages,
-          error: e.inputProps.error,
-          chips: e.inputProps.type === "autocompletemultiple"
-        }, r.$attrs, {
-          "model-value": e.field.state.value,
-          onClear: l[3] || (l[3] = (t) => e.field.handleChange(void 0)),
-          "onUpdate:modelValue": e.field.handleChange
-        }), null, 16, ["id", "clearable", "multiple", "required", "name", "label", "items", "error-messages", "error", "chips", "model-value", "onUpdate:modelValue"])) : i("", !0)
-      ], 32);
-    };
-  }
-});
-export {
-  U as default
-};

package/dist/vue-components.es30.js

@@ -1,92 +0,0 @@
-import { defineComponent as _, getCurrentInstance as y, computed as B, createBlock as n, openBlock as e, Transition as C, withCtx as o, createElementBlock as d, createCommentVNode as w, renderSlot as x, normalizeProps as b, guardReactiveProps as I, resolveDynamicComponent as l, unref as a, normalizeClass as V, createElementVNode as c, toDisplayString as u, Fragment as p, renderList as k, createTextVNode as E } from "vue";
-import { mdiLink as N } from "@mdi/js";
-import { useIntl as z } 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__ */ _({
-  __name: "OmegaErrorsInternal",
-  props: {
-    errors: {},
-    generalErrors: {},
-    showErrors: { type: Boolean }
-  },
-  setup(t) {
-    const m = y()?.appContext.components.VAlert, h = t, { trans: g } = z(), f = B(() => h.generalErrors ? h.generalErrors.filter((i) => !!i).flatMap(
-      (i) => Object.values(i).filter((s) => !!s).flatMap(
-        (s) => s.filter(
-          (r) => !!r?.message
-        ).map((r) => r.message)
-      )
-    ) : []);
-    return (i, s) => (e(), n(C, null, {
-      default: o(() => [
-        t.showErrors && (t.errors.length || f.value.length) ? (e(), d("div", D, [
-          x(i.$slots, "default", b(I({ errors: t.errors, showedGeneralErrors: f.value })), () => [
-            (e(), n(l(a(m) ? "v-alert" : "div"), {
-              class: V([a(m) ? "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(l(t.errors.length > 1 ? "ul" : "div"), {
-                  key: 0,
-                  class: "error-list"
-                }, {
-                  default: o(() => [
-                    (e(!0), d(p, null, k(t.errors, (r) => (e(), n(l(t.errors.length > 1 ? "li" : "div"), {
-                      key: r.inputId,
-                      class: "error-item"
-                    }, {
-                      default: o(() => [
-                        c("div", L, u(r.label), 1),
-                        c("div", M, [
-                          (e(), n(l(r.errors.length > 1 ? "ul" : "div"), { class: "error-list" }, {
-                            default: o(() => [
-                              (e(!0), d(p, null, k(r.errors, (v) => (e(), n(l(r.errors.length > 1 ? "li" : "span"), { key: v }, {
-                                default: o(() => [
-                                  E(u(v), 1)
-                                ]),
-                                _: 2
-                              }, 1024))), 128))
-                            ]),
-                            _: 2
-                          }, 1024))
-                        ]),
-                        c("a", {
-                          href: `#${r.inputId}`,
-                          class: "error-link"
-                        }, [
-                          (e(), n(l(a(m) ? "v-icon" : "i"), {
-                            icon: a(N),
-                            "aria-hidden": "true"
-                          }, {
-                            default: o(() => [...s[0] || (s[0] = [
-                              c("i", null, "🔗", -1)
-                            ])]),
-                            _: 1
-                          }, 8, ["icon"])),
-                          E(" " + u(a(g)("form.fix_input")), 1)
-                        ], 8, O)
-                      ]),
-                      _: 2
-                    }, 1024))), 128))
-                  ]),
-                  _: 1
-                })) : (e(), d("span", P, u(f.value[0]), 1))
-              ]),
-              _: 1
-            }, 8, ["class"]))
-          ], !0)
-        ])) : w("", !0)
-      ]),
-      _: 3
-    }));
-  }
-});
-export {
-  A as default
-};

package/dist/vue-components.es33.js

@@ -1,33 +0,0 @@
-import { defineComponent as m, createElementBlock as d, openBlock as a, withModifiers as l, createElementVNode as u, unref as s, renderSlot as b } from "vue";
-import { useStore as f } from "@tanstack/vue-form";
-import { getOmegaStore as c } from "./vue-components.es48.js";
-const p = ["disabled"], V = /* @__PURE__ */ m({
-  __name: "OmegaWrapper",
-  props: {
-    form: {},
-    disabled: { type: Boolean },
-    subscribe: {}
-  },
-  setup(e) {
-    const t = e, i = f(
-      t.form.store,
-      (o) => o.isSubmitting
-    ), n = c(
-      t.form,
-      t.subscribe
-    );
-    return (o, r) => (a(), d("form", {
-      novalidate: "",
-      onSubmit: r[0] || (r[0] = l((S) => e.form.handleSubmit(), ["prevent", "stop"]))
-    }, [
-      u("fieldset", {
-        disabled: s(i) || e.disabled
-      }, [
-        b(o.$slots, "default", { subscribedValues: s(n) }, void 0, !0)
-      ], 8, p)
-    ], 32));
-  }
-});
-export {
-  V as default
-};

package/dist/vue-components.es57.js

@@ -1,4 +0,0 @@
-var o = typeof globalThis == "object" ? globalThis : typeof self == "object" ? self : typeof window == "object" ? window : typeof global == "object" ? global : {};
-export {
-  o as _globalThis
-};

package/src/components/OmegaForm/OmegaErrorsContext.ts

@@ -1,67 +0,0 @@
-import type { StandardSchemaV1Issue } from "@tanstack/vue-form"
-import { computed, inject, type InjectionKey, readonly, type Ref, ref } from "vue"
-import { type OmegaError, type ShowErrorsOn } from "./OmegaFormStuff"
-
-export const OmegaErrorsKey = Symbol() as InjectionKey<{
-  errors: Ref<readonly OmegaError[]>
-  mapError: (error: OmegaError) => void
-  removeError: (inputId: string) => void
-  clearErrors: () => void
-  showErrors: Ref<boolean>
-  showErrorsOn: ShowErrorsOn
-  generalErrors: Readonly<
-    Ref<
-      (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined
-    >
-  >
-}>
-
-export function buildOmegaErrors(
-  formSubmissionAttempts: Ref<number>,
-  generalErrors: Readonly<
-    Ref<
-      (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined
-    >
-  >,
-  showErrorsOn: ShowErrorsOn = "onSubmit"
-) {
-  const errors = ref<OmegaError[]>([])
-
-  const removeError = (inputId: string) => {
-    errors.value = errors.value.filter((error) => error.inputId !== inputId)
-  }
-
-  const mapError = (error: OmegaError) => {
-    removeError(error.inputId)
-    errors.value.push(error)
-  }
-
-  const clearErrors = () => {
-    errors.value = []
-  }
-
-  const showErrors = computed(() => {
-    if (showErrorsOn === "onSubmit") return formSubmissionAttempts.value > 0
-    return true
-  })
-
-  const context = {
-    errors: readonly(errors),
-    mapError,
-    removeError,
-    clearErrors,
-    showErrors,
-    generalErrors,
-    showErrorsOn: showErrorsOn ?? "onSubmit"
-  }
-
-  return context
-}
-
-export function useOmegaErrors() {
-  const context = inject(OmegaErrorsKey)
-  if (!context) {
-    throw new Error("useOmegaErrors must be used within an OmegaForm provider")
-  }
-  return context
-}