@effect-app/vue-components 4.0.0-beta.32 → 4.0.0-beta.321

package/src/components/OmegaForm/OmegaInput.vue

@@ -1,19 +1,21 @@
 <template>
   <component
     :is="form.Field"
-    :key="fieldKey"
     :name="name"
-    :validators="{
-      onChange: schema,
-      ...validators
-    }"
+    :validators="validators"
   >
-    <template #default="{ field, state }">
+    <!--
+      Read `state` from `field.state`, not the Field slot's `state` prop.
+      Since @tanstack/vue-form 1.32 the slot `state` is a one-time snapshot
+      taken when the field mounts and never updates, whereas `field.state`
+      is a reactive getter backed by the field store.
+    -->
+    <template #default="{ field }">
       <OmegaInternalInput
         v-if="meta"
-        v-bind="{ ...$attrs, ...$props, inputClass: computedClass }"
-        :field="field"
-        :state="state"
+        v-bind="{ ...$attrs, ...internalInputProps, inputClass: computedClass }"
+        :field="field as any"
+        :state="field.state"
         :register="form.registerField"
         :label="label ?? errori18n(propsName)"
         :meta="meta"
@@ -40,14 +42,24 @@
   lang="ts"
   generic="From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>"
 >
+/* eslint-disable @typescript-eslint/no-explicit-any -- TanStack Form Field generic interop and slot prop typing */
 import { type DeepKeys } from "@tanstack/vue-form"
 import { computed, inject, type Ref, useAttrs } from "vue"
-import { useIntl } from "../../utils"
-import { type FieldMeta, generateInputStandardSchemaFromFieldMeta, type OmegaInputPropsBase } from "./OmegaFormStuff"
+import { useErrorLabel } from "./errors"
+import { type FieldMeta } from "./meta/types"
 import OmegaInternalInput from "./OmegaInternalInput.vue"
-import { useErrorLabel } from "./useOmegaForm"
+import { type OmegaInputPropsBase } from "./types"
 
-const props = defineProps<OmegaInputPropsBase<From, To, Name>>()
+const props = withDefaults(defineProps<OmegaInputPropsBase<From, To, Name>>(), {
+  required: undefined
+})
+const internalInputProps = computed(() => ({
+  label: props.label,
+  required: props.required,
+  type: props.type,
+  options: props.options,
+  inputs: props.form.inputs
+}))
 
 // downgrade to *as* DeepKeys<From> to avoid useless and possible infinite recursion in TS
 const propsName = computed(() => props.name as DeepKeys<From>)
@@ -57,13 +69,10 @@ defineSlots<{
   default?: (props: any) => any
 }>()
 
-defineOptions({
-  inheritAttrs: false
-})
+defineOptions({ inheritAttrs: false })
 
 const attrs = useAttrs()
 
-// Compute the class to use based on inputClass prop
 const computedClass = computed(() => {
   if (props.inputClass === null) return undefined
   if (props.inputClass !== undefined) return props.inputClass
@@ -76,33 +85,10 @@ const getMetaFromArray = inject<Ref<(name: string) => FieldMeta | null> | null>(
 )
 
 const meta = computed(() => {
-  if (getMetaFromArray?.value && getMetaFromArray.value(props.name as DeepKeys<From>)) {
-    return getMetaFromArray.value(propsName.value)
-  }
+  const fromArray = getMetaFromArray?.value?.(propsName.value)
+  if (fromArray) return fromArray
   return props.form.meta[propsName.value]
-})
-
-// Key to force Field re-mount when meta type changes (for TaggedUnion support)
-const fieldKey = computed(() => {
-  const m = meta.value
-  if (!m) return propsName.value
-  // Include type and key constraints in the key so Field re-mounts when validation rules change
-  // Cast to any since not all FieldMeta variants have these properties
-  const fm = m as any
-  return `${propsName.value}-${fm.type}-${fm.minLength ?? ""}-${fm.maxLength ?? ""}-${fm.minimum ?? ""}-${
-    fm.maximum ?? ""
-  }`
-})
-
-// Call useIntl during setup to avoid issues when computed re-evaluates
-const { trans } = useIntl()
-
-const schema = computed(() => {
-  if (!meta.value) {
-    console.log(props.name, Object.keys(props.form.meta), props.form.meta)
-    throw new Error("Meta is undefined")
-  }
-  return generateInputStandardSchemaFromFieldMeta(meta.value, trans)
+    ?? props.form.meta[propsName.value.replace(/\[\d+\]/g, "") as DeepKeys<From>]
 })
 
 const errori18n = useErrorLabel(props.form)

package/src/components/OmegaForm/OmegaInputVuetify.vue

@@ -1,7 +1,10 @@
 <template>
   <div
     class="omega-input"
-    @focusout="$emit('blur', $event)"
+    @focusout="(e) => {
+      $emit('blur', e)
+      field.handleBlur()
+    }"
     @focusin="$emit('focus', $event)"
   >
     <component
@@ -31,7 +34,12 @@
       v-if="inputProps.type === 'email'
       || inputProps.type === 'string'
       || inputProps.type === 'password'
-      || inputProps.type === 'date'"
+      || inputProps.type === 'date'
+      || inputProps.type === 'tel'
+      || inputProps.type === 'url'
+      || inputProps.type === 'color'
+      || inputProps.type === 'time'
+      || inputProps.type === 'search'"
       :id="inputProps.id"
       :required="inputProps.required"
       :min-length="inputProps.minLength"
@@ -43,7 +51,7 @@
       :error="inputProps.error"
       v-bind="$attrs"
       :model-value="state.value"
-      @update:model-value="field.handleChange"
+      @update:model-value="(v: any) => field.handleChange(v)"
     >
       <template
         v-if="$slots.label"
@@ -67,7 +75,7 @@
       :error="inputProps.error"
       v-bind="$attrs"
       :model-value="state.value"
-      @update:model-value="field.handleChange"
+      @update:model-value="(v: any) => field.handleChange(v)"
     >
       <template
         v-if="$slots.label"
@@ -79,20 +87,54 @@
         />
       </template>
     </v-textarea>
-    <component
-      :is="inputProps.type === 'range' ? 'v-slider' : 'v-text-field'"
-      v-if="inputProps.type === 'number' || inputProps.type === 'range'"
+    <!-- min/max are deliberately NOT passed as VNumberInput props: the component
+         silently withholds out-of-range values from the model (so schema errors
+         would never show) and clamps on blur. Validation stays schema-driven; the
+         bounds are exposed to AT via the spinbutton ARIA attrs, which fall through
+         to the native input. Same reasoning for precision: Vuetify's default (0)
+         would silently block decimals, so it's forced to null and typing 1.5 into
+         an int field shows the schema error instead. -->
+    <v-number-input
+      v-if="inputProps.type === 'number'"
       :id="inputProps.id"
       :required="inputProps.required"
-      :min="inputProps.min"
-      :max="inputProps.max"
-      :type="inputProps.type"
+      role="spinbutton"
+      :aria-valuemin="typeof inputProps.min === 'number' ? inputProps.min : undefined"
+      :aria-valuemax="typeof inputProps.max === 'number' ? inputProps.max : undefined"
+      :aria-valuenow="typeof state.value === 'number' ? state.value : undefined"
       :name="field.name"
       :label="inputProps.label"
       :error-messages="inputProps.errorMessages"
       :error="inputProps.error"
+      :precision="null"
+      control-variant="stacked"
       v-bind="$attrs"
-      :model-value="state.value"
+      :model-value="state.value as any"
+      @beforeinput.capture="onNumberBeforeinput"
+      @update:model-value="(v: number | null) => field.handleChange((v ?? undefined) as any)"
+    >
+      <template
+        v-if="$slots.label"
+        #label
+      >
+        <slot
+          name="label"
+          v-bind="{ required: inputProps.required, id: inputProps.id, label: inputProps.label }"
+        />
+      </template>
+    </v-number-input>
+    <v-slider
+      v-if="inputProps.type === 'range'"
+      :id="inputProps.id"
+      :required="inputProps.required"
+      :min="typeof inputProps.min === 'number' ? inputProps.min : undefined"
+      :max="typeof inputProps.max === 'number' ? inputProps.max : undefined"
+      :name="field.name"
+      :label="inputProps.label"
+      :error-messages="inputProps.errorMessages"
+      :error="inputProps.error"
+      v-bind="$attrs"
+      :model-value="state.value as any"
       @update:model-value="(e: any) => {
         if (e || e === 0) {
           field.handleChange(Number(e) as any)
@@ -110,7 +152,7 @@
           v-bind="{ required: inputProps.required, id: inputProps.id, label: inputProps.label }"
         />
       </template>
-    </component>
+    </v-slider>
     <template v-if="inputProps.type === 'radio'">
       <v-radio-group
         :id="inputProps.id"
@@ -120,7 +162,7 @@
         :error="inputProps.error"
         v-bind="$attrs"
         :model-value="state.value"
-        @update:model-value="field.handleChange"
+        @update:model-value="(v: any) => field.handleChange(v)"
       >
         <template
           v-if="$slots.label"
@@ -133,7 +175,7 @@
         </template>
         <v-radio
           v-for="option in inputProps.options"
-          :key="option.value"
+          :key="option.value as PropertyKey"
           :label="option.title"
           :value="option.value"
         />
@@ -195,6 +237,33 @@
         />
       </template>
     </v-autocomplete>
+
+    <!-- Fallback for any type not handled by a dedicated branch above (e.g. an
+         unrecognized schema type resolved to "unknown", or a custom `type` with
+         no renderer). Renders an editable text input instead of nothing. -->
+    <v-text-field
+      v-if="isUnhandledType"
+      :id="inputProps.id"
+      :required="inputProps.required"
+      :type="getInputType(inputProps.type)"
+      :name="field.name"
+      :label="inputProps.label"
+      :error-messages="inputProps.errorMessages"
+      :error="inputProps.error"
+      v-bind="$attrs"
+      :model-value="state.value"
+      @update:model-value="(v: any) => field.handleChange(v)"
+    >
+      <template
+        v-if="$slots.label"
+        #label
+      >
+        <slot
+          name="label"
+          v-bind="{ required: inputProps.required, id: inputProps.id, label: inputProps.label }"
+        />
+      </template>
+    </v-text-field>
   </div>
 </template>
 
@@ -204,10 +273,14 @@
   generic="From extends Record<PropertyKey, any>, Name extends DeepKeys<From>"
 >
 import { type DeepKeys } from "@tanstack/vue-form"
-import { getInputType } from "../OmegaForm/OmegaFormStuff"
+import { computed, useAttrs, watchEffect } from "vue"
+import { useLocale } from "vuetify"
+import { handleDecimalSeparatorBeforeinput } from "./decimalSeparatorInput"
 import type { VuetifyInputProps } from "./InputProps"
+import { getInputType } from "./inputs"
+import { typeOverrides } from "./types"
 
-defineProps<VuetifyInputProps<From, Name>>()
+const props = defineProps<VuetifyInputProps<From, Name>>()
 
 defineEmits<{
   (e: "focus", event: Event): void
@@ -217,6 +290,39 @@ defineEmits<{
 defineOptions({
   inheritAttrs: false
 })
+
+const attrs = useAttrs()
+// useLocale throws outside a Vuetify app (e.g. tests mounting with stubbed
+// vuetify components); numbers then fall back to the "." separator.
+const localeDecimalSeparator = (() => {
+  try {
+    return useLocale().decimalSeparator
+  } catch {
+    return undefined
+  }
+})()
+
+// Mirrors VNumberInput's own resolution: an explicit decimal-separator attr
+// wins, otherwise the locale decides.
+const decimalSeparator = computed(() => {
+  const explicit = (attrs["decimal-separator"] ?? attrs["decimalSeparator"]) as string | undefined
+  return explicit?.[0] || localeDecimalSeparator?.value || "."
+})
+
+const onNumberBeforeinput = (e: Event) => handleDecimalSeparatorBeforeinput(e as InputEvent, decimalSeparator.value)
+
+// True when no dedicated branch handles `inputProps.type` (it's outside the
+// built-in `typeOverrides`): the fallback text input renders and we warn.
+const isUnhandledType = computed(() => !(typeOverrides as readonly string[]).includes(props.inputProps.type))
+
+watchEffect(() => {
+  if (isUnhandledType.value) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      `[OmegaForm] Unhandled input type "${props.inputProps.type}", falling back to a text input.`
+    )
+  }
+})
 </script>
 
 <style>

package/src/components/OmegaForm/OmegaInternalInput.vue

@@ -1,8 +1,9 @@
 <template>
   <slot v-bind="{ ...inputProps.inputProps, field: inputProps.field, state: inputProps.state }">
     <div :class="rootClass">
-      <OmegaInputVuetify
-        v-if="vuetified"
+      <component
+        :is="renderComponent"
+        v-if="renderComponent"
         v-bind="{ ...attrsWithoutClass, ...inputProps, class: props.inputClass }"
       >
         <template
@@ -14,7 +15,7 @@
             v-bind="labelProps"
           />
         </template>
-      </OmegaInputVuetify>
+      </component>
     </div>
   </slot>
 </template>
@@ -24,11 +25,13 @@
   lang="ts"
   generic="From extends Record<PropertyKey, any>, Name extends DeepKeys<From>"
 >
+/* eslint-disable @typescript-eslint/no-explicit-any -- TanStack Form / Vue attrs interop */
 import { type DeepKeys, useStore } from "@tanstack/vue-form"
-import { computed, type ComputedRef, getCurrentInstance, useAttrs, useId, useSlots } from "vue"
+import { type Component, computed, type ComputedRef, getCurrentInstance, useAttrs, useId, useSlots } from "vue"
 import type { InputProps, OmegaFieldInternalApi } from "./InputProps"
-import type { FieldValidators, MetaRecord, NestedKeyOf, TypeOverride } from "./OmegaFormStuff"
+import type { MetaRecord, NestedKeyOf } from "./meta/types"
 import OmegaInputVuetify from "./OmegaInputVuetify.vue"
+import type { TypeOverride } from "./types"
 
 defineOptions({
   inheritAttrs: false
@@ -41,7 +44,6 @@ const props = withDefaults(
     meta: MetaRecord<From>[NestedKeyOf<From>]
     label: string
     type?: TypeOverride
-    validators?: FieldValidators<From>
     required?: boolean
     inputClass?: string | null
 
@@ -54,14 +56,16 @@ const props = withDefaults(
     ) => 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 }[]
+    options?: { title: string; value: unknown }[]
+
+    inputs?: Record<string, Component>
   }>(),
   {
     required: undefined,
     type: undefined,
     options: undefined,
-    validators: undefined,
-    inputClass: undefined
+    inputClass: undefined,
+    inputs: undefined
   }
 )
 
@@ -84,7 +88,8 @@ const id = useId()
 
 const fieldApi = props.field
 
-const fieldState = useStore(fieldApi.store, (state) => state)
+// Subscribed for side-effect: keeps component reactive to fieldApi.store changes
+useStore(fieldApi.store, (state) => state)
 
 // Get errors from form-level fieldMeta (persists across Field re-mounts)
 const formFieldMeta = useStore(fieldApi.form.store, (state) => state.fieldMeta)
@@ -98,6 +103,11 @@ const fieldType = computed(() => {
   return props.meta?.type || "unknown"
 })
 
+const renderComponent = computed(() =>
+  props.inputs?.[fieldType.value]
+    ?? (vuetified ? OmegaInputVuetify : undefined)
+)
+
 props.register(computed(() => ({ name: props.field.name, label: props.label, id })))
 
 // Get errors from form-level fieldMeta instead of field-level state
@@ -128,6 +138,13 @@ const handleChange: OmegaFieldInternalApi<From, Name>["handleChange"] = (value)
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           : null as any
       )
+    } else if (props.meta?.isOptionalKey) {
+      // `S.optionalKey` expects the key to be ABSENT from the submitted
+      // object, not present-with-undefined. Remove it from form state
+      // rather than setting it to `undefined`. Note: this is distinct
+      // from `required: false`, which may also just mean "empty string
+      // is valid" for unconstrained `S.String` fields.
+      props.field.form.deleteField(props.field.name)
     } else {
       // Keep the actual value (e.g., empty string for S.String fields)
       props.field.handleChange(value)
@@ -136,9 +153,11 @@ const handleChange: OmegaFieldInternalApi<From, Name>["handleChange"] = (value)
     props.field.handleChange(value)
   }
 
-  // whenever we change the field, regardless if we set it to null, we should reset onSubmit.
-  // not sure why this is not the case in tanstack form.
-  props.field.setMeta((m) => ({ ...m, errorMap: { ...m.errorMap, onSubmit: undefined } }))
+  // A change here may have materialised a nullable struct (this field is one
+  // of its children); backfill the untouched siblings so the live `values`
+  // matches what validation and decoding see.
+  const form = props.field.form as { normalizeNullableStructs?: () => void }
+  form.normalizeNullableStructs?.()
 }
 
 // Note: Default value normalization (converting empty strings to null/undefined for nullable fields)
@@ -172,6 +191,7 @@ const inputProps: ComputedRef<InputProps<From, Name>> = computed(() => ({
       ? (props.meta?.minimum
         ?? (typeof props.meta?.exclusiveMinimum === "number" ? props.meta.exclusiveMinimum + 1 : undefined))
       : undefined,
+    refinement: props.meta?.type === "number" ? props.meta?.refinement : undefined,
     errorMessages: errors.value,
     error: !!errors.value.length,
     type: fieldType.value,

package/src/components/OmegaForm/OmegaTaggedUnion.vue

@@ -8,8 +8,8 @@
 import { type DeepKeys } from "@tanstack/vue-form"
 import { computed, provide, ref, watch } from "vue"
 import { type TaggedUnionOption } from "./InputProps"
-import { type FieldPath } from "./OmegaFormStuff"
 import OmegaTaggedUnionInternal from "./OmegaTaggedUnionInternal.vue"
+import { type FieldPath } from "./types"
 import { type useOmegaForm } from "./useOmegaForm"
 
 const props = defineProps<{
@@ -30,6 +30,7 @@ watch(
   () => {
     const path = tagPath.value
     // Navigate to the nested value
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- traversing arbitrary nested values
     return path.split(".").reduce((acc: any, key) => acc?.[key], formValues.value) as string | null
   },
   (newTag) => {
@@ -74,9 +75,15 @@ provide("getMetaFromArray", getMetaFromArray)
         />
       </slot>
       <slot />
+      <!--
+        Drive the branch off `currentTag`: the tag is read from the form store
+        (the canonical state), the same single source of truth that feeds
+        `getMetaFromArray` above — rather than the `Field` slot's `state`,
+        which is only a projection of it.
+      -->
       <OmegaTaggedUnionInternal
         :field="inputProps.field as any"
-        :state="inputProps.state.value"
+        :tag="currentTag"
         :name="name"
         :form="form"
       >
@@ -91,7 +98,7 @@ provide("getMetaFromArray", getMetaFromArray)
         </template>
       </OmegaTaggedUnionInternal>
       <slot
-        v-if="inputProps.state.value"
+        v-if="currentTag"
         name="OmegaCommon"
       />
     </template>

package/src/components/OmegaForm/OmegaTaggedUnionInternal.vue

@@ -1,8 +1,8 @@
 <template>
   <slot
-    v-if="state"
-    :name="`${name ? `${name}.` : ''}${state}`"
-    v-bind="{ field, state }"
+    v-if="tag"
+    :name="`${name ? `${name}.` : ''}${tag}`"
+    v-bind="{ field, tag }"
   />
 </template>
 
@@ -17,7 +17,7 @@ import { type OmegaFieldInternalApi } from "./InputProps"
 import { type useOmegaForm } from "./useOmegaForm"
 
 const props = defineProps<{
-  state: DeepValue<From, Name>
+  tag: string | null
   field: OmegaFieldInternalApi<From, Name>
   name?: DeepKeys<From>
   form: ReturnType<typeof useOmegaForm<From, To>>
@@ -26,7 +26,7 @@ const props = defineProps<{
 const values = props.form.useStore(({ values }) => values)
 
 // Watch for _tag changes
-watch(() => props.state, (newTag, oldTag) => {
+watch(() => props.tag, (newTag, oldTag) => {
   if (newTag === null) {
     props.field.setValue(null as DeepValue<From, Name>)
   }
@@ -34,7 +34,7 @@ watch(() => props.state, (newTag, oldTag) => {
   if (newTag !== oldTag) {
     props.form.reset(values.value)
     setTimeout(() => {
-      props.field.validate("change")
+      void props.field.validate("change")
     }, 0)
   }
 }, { immediate: true })

package/src/components/OmegaForm/OmegaWrapper.vue

@@ -30,7 +30,7 @@
 import { useStore } from "@tanstack/vue-form"
 import { usePreventClose } from "./blockDialog"
 import { getOmegaStore } from "./getOmegaStore"
-import { type DefaultTypeProps, type OmegaFormApi, type OmegaFormState } from "./OmegaFormStuff"
+import { type DefaultTypeProps, type OmegaFormApi, type OmegaFormState } from "./types"
 import { type OmegaFormReturn } from "./useOmegaForm"
 
 type OmegaWrapperProps = {

package/src/components/OmegaForm/blockDialog.ts

@@ -1,5 +1,6 @@
 import mitt from "mitt"
 import { inject, type InjectionKey, provide, type Ref } from "vue"
+import { useIntl } from "../../utils"
 import { onMountedWithCleanup } from "./onMountedWithCleanup"
 
 export type DialogClosing = { prevent?: boolean | Promise<boolean> }
@@ -19,11 +20,19 @@ export const usePreventClose = (mkIsDirty: () => Ref<boolean>) => {
   if (!bus) {
     return
   }
+  const { formatMessage, trans } = useIntl()
   const isDirty = mkIsDirty()
+  const defaultMessage = "There are unsaved changes. Are you sure you want to close?"
   onMountedWithCleanup(() => {
     const onDialogClosing = (evt: DialogClosing) => {
       if (isDirty.value) {
-        if (!confirm("Es sind ungespeicherte Änderungen vorhanden. Wirklich schließen?")) {
+        // Mirror the guard pattern in errors.ts: a custom `useIntl` mock may
+        // only provide `trans`, so fall back through trans → defaultMessage.
+        const message = formatMessage
+          ? formatMessage({ id: "form.unsaved_changes_confirm", defaultMessage })
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any -- key may not be registered in the locale catalog
+          : trans?.("form.unsaved_changes_confirm") ?? defaultMessage
+        if (!confirm(message)) {
           evt.prevent = true
         }
       }
@@ -46,11 +55,14 @@ export const useOnClose = (close: () => void) => {
     bus.emit("dialog-closing", evt)
     if (evt.prevent) {
       if (typeof evt.prevent === "object" && "then" in evt.prevent) {
-        evt.prevent.then((r) => {
-          if (r !== false) {
-            close()
-          }
-        })
+        evt
+          .prevent
+          .then((r) => {
+            if (r) {
+              close()
+            }
+          })
+          .catch(console.error)
       }
     } else {
       close()

package/src/components/OmegaForm/createUseFormWithCustomInput.ts

@@ -1,21 +1,21 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- TanStack Form / Vue render-fn slot interop */
 import type { DeepKeys } from "@tanstack/vue-form"
 import { type Component, h } from "vue"
 import type { MergedInputProps } from "./InputProps"
-import { type DefaultTypeProps } from "./OmegaFormStuff"
 import OmegaInput from "./OmegaInput.vue"
+import type { OmegaConfig } from "./types"
 import { useOmegaForm } from "./useOmegaForm"
 
-export const createUseFormWithCustomInput = <
-  TypeProps = DefaultTypeProps
->(CustomInputComponent: Component) => {
+export const createUseFormWithCustomInput = (CustomInputComponent: Component) => {
   return <
     From extends Record<PropertyKey, any>,
-    To extends Record<PropertyKey, any>
+    To extends Record<PropertyKey, any>,
+    const Cfg extends OmegaConfig<To> = OmegaConfig<To>
   >(
-    ...args: Parameters<typeof useOmegaForm<From, To>>
+    schema: Parameters<typeof useOmegaForm<From, To>>[0],
+    tanstackFormOptions?: Parameters<typeof useOmegaForm<From, To>>[1],
+    omegaConfig?: Cfg
   ) => {
-    const [schema, tanstackFormOptions, omegaConfig] = args
-
     // Create a wrapper that extends OmegaInput and overrides its default slot
     const WrappedInput = {
       name: "WrappedInput",
@@ -35,7 +35,10 @@ export const createUseFormWithCustomInput = <
                   && key !== "form"
                 )
               )
-              return h(CustomInputComponent, { ...filteredAttrs, field, state, inputProps }, {
+              // A per-type registration (omegaConfig.inputs) wins over the
+              // universal CustomInputComponent; otherwise fall back to it.
+              const LeafComponent = omegaConfig?.inputs?.[inputProps.type] ?? CustomInputComponent
+              return h(LeafComponent, { ...filteredAttrs, field, state, inputProps }, {
                 // Pass through label slot if it exists
                 ...(slots.label && {
                   label: (labelProps: any) => slots.label(labelProps)
@@ -54,13 +57,12 @@ export const createUseFormWithCustomInput = <
       }
     }
 
-    const form = useOmegaForm<From, To, TypeProps>(
+    // Thread `Cfg` so `omegaConfig.inputs` keys are inferred into the `type`
+    // union (`<form.Input type="...">`), exactly like a bare `useOmegaForm`.
+    const form = useOmegaForm<From, To, Cfg>(
       schema,
       tanstackFormOptions,
-      {
-        ...omegaConfig,
-        input: WrappedInput
-      }
+      { ...omegaConfig, input: WrappedInput } as Cfg
     )
 
     return form