@strictly/react-form 0.0.1 → 0.0.2

package/core/mobx/form_presenter.ts

@@ -4,6 +4,7 @@ import {
   assertState,
   checkValidNumber,
   type ElementOfArray,
+  map,
   type Maybe,
   toArray,
   UnreachableError,
@@ -11,18 +12,19 @@ import {
 import {
   type Accessor,
   type AnyValueType,
-  flattenAccessorsOf,
-  type FlattenedValueTypesOf,
-  flattenTypeDefsOf,
-  flattenValueTypeTo,
+  flattenAccessorsOfType,
+  type FlattenedValuesOfType,
+  flattenTypesOfType,
+  flattenValuesOfType,
+  flattenValueTo,
   jsonPathPop,
   mobxCopy,
-  type MobxValueTypeOf,
-  type ReadonlyTypeDefOf,
+  type MobxValueOfType,
+  type ReadonlyTypeOfType,
   type StrictTypeDef,
   type Type,
+  type ValueOfType,
   valuePathToTypePath,
-  type ValueTypeOf,
 } from '@strictly/define'
 import {
   computed,
@@ -39,23 +41,24 @@ import {
   type Field,
 } from 'types/field'
 import {
-  FieldConversionResult,
+  type AnnotatedFieldConversion,
+  UnreliableFieldConversionType,
 } from 'types/field_converters'
 import {
-  type ErrorTypeOfFieldAdapter,
+  type ErrorOfFieldAdapter,
   type FieldAdapter,
-  type ToTypeOfFieldAdapter,
+  type ToOfFieldAdapter,
 } from './field_adapter'
 import {
-  type FlattenedListTypeDefsOf,
-} from './flattened_list_type_defs_of'
+  type FlattenedListTypesOfType,
+} from './flattened_list_types_of_type'
 
 export type FlattenedConvertedFieldsOf<
   ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>,
 > = {
   readonly [K in keyof ValuePathsToAdapters]: Field<
-    ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>,
-    ErrorTypeOfFieldAdapter<ValuePathsToAdapters[K]>
+    ToOfFieldAdapter<ValuePathsToAdapters[K]>,
+    ErrorOfFieldAdapter<ValuePathsToAdapters[K]>
   >
 }
 
@@ -73,22 +76,20 @@ export type FlattenedTypePathsToAdaptersOf<
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-type FieldOverride<V = any> = {
-  value: V,
-}
+type FieldOverride<V = any> = Maybe<V>
 
 type FlattenedFieldOverrides<
   ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>,
 > = {
   -readonly [K in keyof ValuePathsToAdapters]?: FieldOverride<
-    ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>
+    ToOfFieldAdapter<ValuePathsToAdapters[K]>
   >
 }
 
 type FlattenedErrors<
   ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>,
 > = {
-  -readonly [K in keyof ValuePathsToAdapters]?: ErrorTypeOfFieldAdapter<ValuePathsToAdapters[K]>
+  -readonly [K in keyof ValuePathsToAdapters]?: ErrorOfFieldAdapter<ValuePathsToAdapters[K]>
 }
 
 export type ValuePathsToAdaptersOf<
@@ -105,8 +106,8 @@ export class FormPresenter<
   T extends Type,
   ValueToTypePaths extends Readonly<Record<string, string>>,
   TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<
-    FlattenedValueTypesOf<T, '*'>,
-    ValueTypeOf<ReadonlyTypeDefOf<T>>
+    FlattenedValuesOfType<T, '*'>,
+    ValueOfType<ReadonlyTypeOfType<T>>
   >,
   ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<
     TypePathsToAdapters,
@@ -114,14 +115,14 @@ export class FormPresenter<
   >,
 > {
   constructor(
-    readonly typeDef: T,
+    readonly type: T,
     private readonly adapters: TypePathsToAdapters,
   ) {
   }
 
   private maybeGetAdapterForValuePath(valuePath: keyof ValuePathsToAdapters) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const typePath = valuePathToTypePath(this.typeDef, valuePath as string, true)
+    const typePath = valuePathToTypePath(this.type, valuePath as string, true)
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return this.adapters[typePath as keyof TypePathsToAdapters]
   }
@@ -135,13 +136,13 @@ export class FormPresenter<
   }
 
   typePath<K extends keyof ValueToTypePaths>(valuePath: K): ValueToTypePaths[K] {
-    return valuePathToTypePath<ValueToTypePaths, K>(this.typeDef, valuePath, true)
+    return valuePathToTypePath<ValueToTypePaths, K>(this.type, valuePath, true)
   }
 
   setFieldValueAndValidate<K extends keyof ValuePathsToAdapters>(
     model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
     valuePath: K,
-    value: ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>,
+    value: ToOfFieldAdapter<ValuePathsToAdapters[K]>,
   ): boolean {
     return this.internalSetFieldValue(model, valuePath, value, true)
   }
@@ -149,15 +150,16 @@ export class FormPresenter<
   setFieldValue<K extends keyof ValuePathsToAdapters>(
     model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
     valuePath: K,
-    value: ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>,
+    value: ToOfFieldAdapter<ValuePathsToAdapters[K]>,
   ): boolean {
     return this.internalSetFieldValue(model, valuePath, value, false)
   }
 
-  addListItem<K extends keyof FlattenedListTypeDefsOf<T>>(
+  addListItem<K extends keyof FlattenedListTypesOfType<T>>(
     model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
     valuePath: K,
-    elementValue: Maybe<ElementOfArray<FlattenedValueTypesOf<T>[K]>>,
+    // TODO can this type be simplified?
+    elementValue: Maybe<ElementOfArray<FlattenedValuesOfType<T>[K]>> = null,
     index?: number,
   ) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -236,7 +238,7 @@ export class FormPresenter<
     })
   }
 
-  removeListItem<K extends keyof FlattenedListTypeDefsOf<T>>(
+  removeListItem<K extends keyof FlattenedListTypesOfType<T>>(
     model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
     elementValuePath: `${K}.${number}`,
   ) {
@@ -316,7 +318,7 @@ export class FormPresenter<
   private internalSetFieldValue<K extends keyof ValuePathsToAdapters>(
     model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
     valuePath: K,
-    value: ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>,
+    value: ToOfFieldAdapter<ValuePathsToAdapters[K]>,
     displayValidation: boolean,
   ): boolean {
     const { revert } = this.getAdapterForValuePath(valuePath)
@@ -327,11 +329,9 @@ export class FormPresenter<
     const conversion = revert(value, valuePath as any, model.value)
     const accessor = model.getAccessorForValuePath(valuePath)
     return runInAction(() => {
-      model.fieldOverrides[valuePath] = {
-        value,
-      }
+      model.fieldOverrides[valuePath] = [value]
       switch (conversion.type) {
-        case FieldConversionResult.Failure:
+        case UnreliableFieldConversionType.Failure:
           if (displayValidation) {
             model.errors[valuePath] = conversion.error
           }
@@ -339,7 +339,7 @@ export class FormPresenter<
             accessor.set(conversion.value[0])
           }
           return false
-        case FieldConversionResult.Success:
+        case UnreliableFieldConversionType.Success:
           delete model.errors[valuePath]
           accessor?.set(conversion.value)
           return true
@@ -377,27 +377,38 @@ export class FormPresenter<
     } = adapter
     const accessor = model.accessors[valuePath]
     const value = accessor == null ? create(valuePath, model.value) : accessor.value
-    const displayValue = convert(value, valuePath, model.value)
+    const {
+      value: displayValue,
+    } = convert(value, valuePath, model.value)
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const key = valuePath as unknown as keyof ValuePathsToAdapters
     runInAction(function () {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      model.fieldOverrides[valuePath as unknown as keyof ValuePathsToAdapters] = {
-        value: displayValue,
-      }
+      model.fieldOverrides[key] = [displayValue]
     })
   }
 
   clearAll(
     model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
-    value: ValueTypeOf<T>,
+    value: ValueOfType<T>,
   ): void {
     runInAction(() => {
       model.errors = {}
       // TODO this isn't correct, should reload from value
       model.fieldOverrides = {}
-      model.value = mobxCopy(this.typeDef, value)
+      model.value = mobxCopy(this.type, value)
     })
   }
 
+  isValuePathActive<K extends keyof ValuePathsToAdapters>(
+    model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
+    valuePath: K,
+  ): boolean {
+    const values = flattenValuesOfType(this.type, model.value)
+    const keys = new Set(Object.keys(values))
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return keys.has(valuePath as string)
+  }
+
   validateField<K extends keyof ValuePathsToAdapters>(
     model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
     valuePath: K,
@@ -409,7 +420,9 @@ export class FormPresenter<
     } = this.getAdapterForValuePath(valuePath)
     const fieldOverride = model.fieldOverrides[valuePath]
     const accessor = model.getAccessorForValuePath(valuePath)
-    const storedValue = convert(
+    const {
+      value: storedValue,
+    } = convert(
       accessor != null
         ? accessor.value
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -419,7 +432,7 @@ export class FormPresenter<
       model.value,
     )
     const value = fieldOverride != null
-      ? fieldOverride.value
+      ? fieldOverride[0]
       : storedValue
     const dirty = storedValue !== value
     assertExists(revert, 'changing field directly not supported {}', valuePath)
@@ -428,13 +441,13 @@ export class FormPresenter<
     const conversion = revert(value, valuePath as string, model.value)
     return runInAction(function () {
       switch (conversion.type) {
-        case FieldConversionResult.Failure:
+        case UnreliableFieldConversionType.Failure:
           model.errors[valuePath] = conversion.error
           if (conversion.value != null && accessor != null && dirty) {
             accessor.set(conversion.value[0])
           }
           return false
-        case FieldConversionResult.Success:
+        case UnreliableFieldConversionType.Success:
           delete model.errors[valuePath]
           if (accessor != null && dirty) {
             accessor.set(conversion.value)
@@ -476,22 +489,24 @@ export class FormPresenter<
             return success
           }
           const fieldOverride = model.fieldOverrides[adapterPath]
-          const storedValue = convert(accessor.value, valuePath, model.value)
+          const {
+            value: storedValue,
+          } = convert(accessor.value, valuePath, model.value)
           const value = fieldOverride != null
-            ? fieldOverride.value
+            ? fieldOverride[0]
             : storedValue
           // TODO more nuanced comparison
-          const dirty = fieldOverride != null && fieldOverride.value !== storedValue
+          const dirty = fieldOverride != null && fieldOverride[0] !== storedValue
 
           const conversion = revert(value, valuePath, model.value)
           switch (conversion.type) {
-            case FieldConversionResult.Failure:
+            case UnreliableFieldConversionType.Failure:
               model.errors[adapterPath] = conversion.error
               if (conversion.value != null && dirty) {
                 accessor.set(conversion.value[0])
               }
               return false
-            case FieldConversionResult.Success:
+            case UnreliableFieldConversionType.Success:
               if (dirty) {
                 accessor.set(conversion.value)
               }
@@ -506,14 +521,14 @@ export class FormPresenter<
     })
   }
 
-  createModel(value: ValueTypeOf<ReadonlyTypeDefOf<T>>): FormModel<
+  createModel(value: ValueOfType<ReadonlyTypeOfType<T>>): FormModel<
     T,
     ValueToTypePaths,
     TypePathsToAdapters,
     ValuePathsToAdapters
   > {
     return new FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>(
-      this.typeDef,
+      this.type,
       value,
       this.adapters,
     )
@@ -524,8 +539,8 @@ export class FormModel<
   T extends Type,
   ValueToTypePaths extends Readonly<Record<string, string>>,
   TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<
-    FlattenedValueTypesOf<T, '*'>,
-    ValueTypeOf<ReadonlyTypeDefOf<T>>
+    FlattenedValuesOfType<T, '*'>,
+    ValueOfType<ReadonlyTypeOfType<T>>
   >,
   ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<
     TypePathsToAdapters,
@@ -533,7 +548,7 @@ export class FormModel<
   >,
 > {
   @observable.ref
-  accessor value: MobxValueTypeOf<T>
+  accessor value: MobxValueOfType<T>
   @observable.shallow
   accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>
   @observable.shallow
@@ -542,19 +557,25 @@ export class FormModel<
   private readonly flattenedTypeDefs: Readonly<Record<string, Type>>
 
   constructor(
-    private readonly typeDef: T,
-    value: ValueTypeOf<ReadonlyTypeDefOf<T>>,
+    private readonly type: T,
+    value: ValueOfType<ReadonlyTypeOfType<T>>,
     private readonly adapters: TypePathsToAdapters,
   ) {
-    this.value = mobxCopy(typeDef, value)
-    this.flattenedTypeDefs = flattenTypeDefsOf(typeDef)
+    this.value = mobxCopy(type, value)
+    this.flattenedTypeDefs = flattenTypesOfType(type)
     // pre-populate field overrides for consistent behavior when default information is overwritten
     // then returned to
-    this.fieldOverrides = flattenValueTypeTo(
-      typeDef,
+    const conversions = flattenValueTo(
+      type,
       this.value,
       () => {},
-      (_t: StrictTypeDef, value: AnyValueType, _setter, typePath, valuePath): FieldOverride | undefined => {
+      (
+        _t: StrictTypeDef,
+        value: AnyValueType,
+        _setter,
+        typePath,
+        valuePath,
+      ): AnnotatedFieldConversion<FieldOverride> | undefined => {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const adapter = this.adapters[typePath as keyof TypePathsToAdapters]
         if (adapter == null) {
@@ -568,12 +589,13 @@ export class FormModel<
           // no need to store a temporary value if the value cannot be written back
           return
         }
-        const displayValue = convert(value, valuePath, this.value)
-        return {
-          value: displayValue,
-        }
+        return convert(value, valuePath, this.value)
       },
     )
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    this.fieldOverrides = map(conversions, function (_k, v) {
+      return v && [v.value]
+    }) as FlattenedFieldOverrides<ValuePathsToAdapters>
   }
 
   @computed
@@ -598,8 +620,8 @@ export class FormModel<
 
   @computed
   private get knownFields(): SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>> {
-    return flattenValueTypeTo(
-      this.typeDef,
+    return flattenValueTo(
+      this.type,
       this.value,
       () => {},
       // TODO swap these to valuePath, typePath in flatten
@@ -619,7 +641,7 @@ export class FormModel<
     try {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       typePath = valuePathToTypePath<ValueToTypePaths, keyof ValueToTypePaths>(
-        this.typeDef,
+        this.type,
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         valuePath as keyof ValueToTypePaths,
         true,
@@ -648,31 +670,32 @@ export class FormModel<
     const accessor = this.getAccessorForValuePath(valuePath)
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const fieldTypeDef = this.flattenedTypeDefs[typePath as string]
-    const value = fieldOverride
-      ? fieldOverride.value
-      : convert(
-        accessor != null
-          ? accessor.value
-          : fieldTypeDef != null
-          ? mobxCopy(
-            fieldTypeDef,
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            create(valuePath as string, this.value),
-          )
-          // fake values can't be copied
+    const {
+      value,
+      required,
+      readonly,
+    } = convert(
+      accessor != null
+        ? accessor.value
+        : fieldTypeDef != null
+        ? mobxCopy(
+          fieldTypeDef,
           // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          : create(valuePath as string, this.value),
+          create(valuePath as string, this.value),
+        )
+        // fake values can't be copied
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        valuePath as string,
-        this.value,
-      )
+        : create(valuePath as string, this.value),
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      valuePath as string,
+      this.value,
+    )
     const error = this.errors[valuePath]
     return {
-      value,
+      value: fieldOverride != null ? fieldOverride[0] : value,
       error,
-      // if we can't write it back, then we have to disable it
-      disabled: this.isDisabled(valuePath),
-      required: this.isRequired(valuePath),
+      readonly,
+      required,
     }
   }
 
@@ -684,22 +707,12 @@ export class FormModel<
   @computed
   // should only be referenced internally, so loosely typed
   get accessors(): Readonly<Record<string, Accessor>> {
-    return flattenAccessorsOf<T, Readonly<Record<string, Accessor>>>(
-      this.typeDef,
+    return flattenAccessorsOfType<T, Readonly<Record<string, Accessor>>>(
+      this.type,
       this.value,
-      (value: ValueTypeOf<T>): void => {
-        this.value = mobxCopy(this.typeDef, value)
+      (value: ValueOfType<T>): void => {
+        this.value = mobxCopy(this.type, value)
       },
     )
   }
-
-  protected isDisabled(_valuePath: keyof ValuePathsToAdapters): boolean {
-    // TODO infer from types
-    return false
-  }
-
-  protected isRequired(_valuePath: keyof ValuePathsToAdapters): boolean {
-    // TODO infer from types
-    return false
-  }
 }

package/core/mobx/merge_field_adapters_with_two_way_converter.ts

@@ -0,0 +1,68 @@
+import { map } from '@strictly/base'
+import {
+  chainAnnotatedFieldConverter,
+  chainUnreliableFieldConverter,
+} from 'field_converters/chain_field_converter'
+import { type TwoWayFieldConverter } from 'types/field_converters'
+import {
+  type ErrorOfFieldAdapter,
+  type FieldAdapter,
+  type FromOfFieldAdapter,
+  type ToOfFieldAdapter,
+  type ValuePathOfFieldAdapter,
+} from './field_adapter'
+
+export type MergedOfFieldAdaptersWithTwoWayConverter<
+  FieldAdapters extends Readonly<Record<string, FieldAdapter>>,
+  E,
+  Context,
+> = {
+  [K in keyof FieldAdapters]: FieldAdapter<
+    FromOfFieldAdapter<FieldAdapters[K]>,
+    ToOfFieldAdapter<FieldAdapters[K]>,
+    ErrorOfFieldAdapter<FieldAdapters[K]> | E,
+    ValuePathOfFieldAdapter<FieldAdapters[K]>,
+    Context
+  >
+}
+
+type ValuePathsOfFieldAdapters<FieldAdapters extends Readonly<Record<string, FieldAdapter>>> = {
+  [K in keyof FieldAdapters]: ValuePathOfFieldAdapter<FieldAdapters[K]>
+}[keyof FieldAdapters]
+
+type TosOfFieldAdapters<FieldAdapters extends Readonly<Record<string, FieldAdapter>>> = {
+  [K in keyof FieldAdapters]: ToOfFieldAdapter<FieldAdapters[K]>
+}[keyof FieldAdapters]
+
+export function mergeFieldAdaptersWithTwoWayConverter<
+  // must have a field adapter for every validator
+  FieldAdapters extends Readonly<Record<string, FieldAdapter>>,
+  E,
+  Context,
+>(
+  fieldAdapters: FieldAdapters,
+  converter: TwoWayFieldConverter<
+    TosOfFieldAdapters<FieldAdapters>,
+    TosOfFieldAdapters<FieldAdapters>,
+    E,
+    ValuePathsOfFieldAdapters<FieldAdapters>,
+    Context
+  >,
+): MergedOfFieldAdaptersWithTwoWayConverter<FieldAdapters, E, Context> {
+  return map<keyof FieldAdapters, FieldAdapter>(
+    fieldAdapters,
+    function (_key, adapter) {
+      return {
+        convert: chainAnnotatedFieldConverter(
+          adapter.convert.bind(adapter),
+          converter.convert.bind(converter),
+        ),
+        revert: adapter.revert && chainUnreliableFieldConverter(
+          converter.revert.bind(converter),
+          adapter.revert.bind(adapter),
+        ),
+        create: adapter.create.bind(adapter),
+      }
+    },
+  )
+}

package/core/mobx/merge_field_adapters_with_validators.ts

@@ -0,0 +1,99 @@
+import { reduce } from '@strictly/base'
+import {
+  annotations,
+  validate,
+  type Validator,
+} from '@strictly/define'
+import { type Simplify } from 'type-fest'
+import {
+  type AnnotatedFieldConversion,
+  type UnreliableFieldConversion,
+  UnreliableFieldConversionType,
+} from 'types/field_converters'
+import { type FieldAdapter } from './field_adapter'
+
+export type MergedOfFieldAdaptersWithValidators<
+  // must have a field adapter for every validator
+  FieldAdapters extends Readonly<Record<Key, FieldAdapter>>,
+  Validators extends Partial<Readonly<Record<string, Validator>>>,
+  Key extends keyof Validators = keyof Validators,
+> = Simplify<{
+  readonly [K in Key]: MergedOfFieldAdapterWithValidator<FieldAdapters[K], Validators[K]>
+} & {
+  readonly [K in Exclude<keyof FieldAdapters, Key>]: FieldAdapters[K]
+}>
+
+type MergedOfFieldAdapterWithValidator<
+  A extends FieldAdapter,
+  V extends Validator | undefined,
+> = undefined extends V ? A
+  : A extends FieldAdapter<infer From, infer To, infer E1, infer P1, infer C1>
+    ? V extends Validator<From, infer E2, infer P2, infer C2> ? FieldAdapter<From, To, E1 | E2, P1 | P2, C1 | C2>
+    : never
+  : never
+
+export function mergeAdaptersWithValidators<
+  // must have a field adapter for every validator
+  FieldAdapters extends Readonly<Record<Key, FieldAdapter>>,
+  Validators extends Readonly<Record<string, Validator>>,
+  Key extends keyof Validators = keyof Validators,
+>(
+  adapters: FieldAdapters,
+  validators: Validators,
+): MergedOfFieldAdaptersWithValidators<FieldAdapters, Validators, Key> {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return reduce<
+    Key,
+    FieldAdapter,
+    Partial<Record<Key, FieldAdapter>>
+  >(
+    adapters,
+    function (acc, key, adapter) {
+      const validator = validators[key]
+      if (validator == null) {
+        acc[key] = adapter
+        return acc
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      function revert(to: any, ...params: [any, any]): UnreliableFieldConversion {
+        const result = adapter.revert!(to, ...params)
+        if (result.type === UnreliableFieldConversionType.Failure) {
+          return result
+        }
+        const validationError = validate(validator, result.value, ...params)
+        if (validationError == null) {
+          return result
+        }
+        return {
+          type: UnreliableFieldConversionType.Failure,
+          value: [result.value] as const,
+          error: validationError,
+        }
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      function convert(from: any, ...params: [any, any]): AnnotatedFieldConversion {
+        const {
+          required: required1,
+          readonly: readonly1,
+          value,
+        } = adapter.convert(from, ...params)
+        const {
+          required: required2,
+          readonly: readonly2,
+        } = annotations(validator, ...params)
+        return {
+          value,
+          required: required1 || required2,
+          readonly: readonly1 || readonly2,
+        }
+      }
+      acc[key] = {
+        ...adapter,
+        convert,
+        revert: adapter.revert && revert,
+      }
+      return acc
+    },
+    {},
+  ) as MergedOfFieldAdaptersWithValidators<FieldAdapters, Validators, Key>
+}