@strictly/react-form 0.0.1 → 0.0.2

package/.out/core/mobx/field_adapter.d.ts

@@ -1,9 +1,10 @@
-import { type FieldConverter, type FieldValueFactory, type SafeFieldConverter } from 'types/field_converters';
+import { type AnnotatedFieldConverter, type FieldValueFactory, type UnreliableFieldConverter } from 'types/field_converters';
 export type FieldAdapter<From = any, To = any, E = any, ValuePath extends string = any, Context = any> = {
-    readonly convert: SafeFieldConverter<From, To, ValuePath, Context>;
+    readonly convert: AnnotatedFieldConverter<From, To, ValuePath, Context>;
     readonly create: FieldValueFactory<From, ValuePath, Context>;
-    readonly revert?: FieldConverter<To, From, E, ValuePath, Context>;
+    readonly revert?: UnreliableFieldConverter<To, From, E, ValuePath, Context>;
 };
-export type FromTypeOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer From> ? From : never;
-export type ToTypeOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _F, infer To> ? To : never;
-export type ErrorTypeOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _From, infer _To, infer E> ? NonNullable<E> : never;
+export type FromOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer From> ? From : never;
+export type ToOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _F, infer To> ? To : never;
+export type ErrorOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _From, infer _To, infer E> ? NonNullable<E> : never;
+export type ValuePathOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _From, infer _To, infer _E, infer ValuePath> ? ValuePath : never;

package/.out/core/mobx/field_adapter_builder.d.ts

@@ -1,22 +1,21 @@
-import { type FieldConverter, type FieldValueFactory, type SafeFieldConverter, type TwoWayFieldConverter, type TwoWayFieldConverterWithValueFactory } from 'types/field_converters';
-import { type FieldValidator } from 'types/field_validator';
+import { type AnnotatedFieldConverter, type FieldValueFactory, type TwoWayFieldConverter, type TwoWayFieldConverterWithValueFactory, type UnreliableFieldConverter } from 'types/field_converters';
+import { type FieldAdapter } from './field_adapter';
 declare class FieldAdapterBuilder<From, To, E, ValuePath extends string, Context> {
-    readonly convert: SafeFieldConverter<From, To, ValuePath, Context>;
+    readonly convert: AnnotatedFieldConverter<From, To, ValuePath, Context>;
     readonly create: FieldValueFactory<From, ValuePath, Context>;
-    readonly revert?: FieldConverter<To, From, E, ValuePath, Context> | undefined;
-    constructor(convert: SafeFieldConverter<From, To, ValuePath, Context>, create: FieldValueFactory<From, ValuePath, Context>, revert?: FieldConverter<To, From, E, ValuePath, Context> | undefined);
-    validateFrom<E2>(...validators: readonly FieldValidator<From, E2, ValuePath, Context>[]): FieldAdapterBuilder<From, To, E | E2, ValuePath, Context>;
-    validateTo<E2>(...validators: readonly FieldValidator<To, E2, ValuePath, Context>[]): FieldAdapterBuilder<From, To, E | E2, ValuePath, Context>;
-    chain<To2, E2 = E>(converter: SafeFieldConverter<To, To2, ValuePath, Context>, reverter?: FieldConverter<To2, To, E2, ValuePath, Context>): FieldAdapterBuilder<From, To2, E | E2, ValuePath, Context>;
-    withReverter(reverter: FieldConverter<To, From, E, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+    readonly revert?: UnreliableFieldConverter<To, From, E, ValuePath, Context> | undefined;
+    constructor(convert: AnnotatedFieldConverter<From, To, ValuePath, Context>, create: FieldValueFactory<From, ValuePath, Context>, revert?: UnreliableFieldConverter<To, From, E, ValuePath, Context> | undefined);
+    chain<To2, E2 = E>(converter: AnnotatedFieldConverter<To, To2, ValuePath, Context>, reverter?: UnreliableFieldConverter<To2, To, E2, ValuePath, Context>): FieldAdapterBuilder<From, To2, E | E2, ValuePath, Context>;
+    withReverter(reverter: UnreliableFieldConverter<To, From, E, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
     withIdentity(isFrom: (from: To | From) => from is From): FieldAdapterBuilder<From, To | From, E, ValuePath, Context>;
+    get narrow(): FieldAdapter<From, To, E, ValuePath, Context>;
 }
-export declare function adapter<From, To, ValuePath extends string, Context>(converter: SafeFieldConverter<From, To, ValuePath, Context>, valueFactory: FieldValueFactory<From, ValuePath, Context>): FieldAdapterBuilder<From, To, never, ValuePath, Context>;
-export declare function adapter<From, To, E, ValuePath extends string, Context>(converter: SafeFieldConverter<From, To, ValuePath, Context>, valueFactory: FieldValueFactory<From, ValuePath, Context>, reverter: FieldConverter<To, From, E, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+export declare function adapter<From, To, ValuePath extends string, Context>(converter: AnnotatedFieldConverter<From, To, ValuePath, Context>, valueFactory: FieldValueFactory<From, ValuePath, Context>): FieldAdapterBuilder<From, To, never, ValuePath, Context>;
+export declare function adapter<From, To, E, ValuePath extends string, Context>(converter: AnnotatedFieldConverter<From, To, ValuePath, Context>, valueFactory: FieldValueFactory<From, ValuePath, Context>, reverter: UnreliableFieldConverter<To, From, E, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
 export declare function adapterFromTwoWayConverter<From, To, E, ValuePath extends string, Context>(converter: TwoWayFieldConverter<From, To, E, ValuePath, Context>, valueFactory: FieldValueFactory<From, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
 export declare function adapterFromTwoWayConverter<From, To, E, ValuePath extends string, Context>(converter: TwoWayFieldConverterWithValueFactory<From, To, E, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
-export declare function adapterFromPrototype<From, To, ValuePath extends string, Context>(converter: SafeFieldConverter<From, To, ValuePath, Context>, prototype: From): FieldAdapterBuilder<From, To, never, ValuePath, Context>;
+export declare function adapterFromPrototype<From, To, ValuePath extends string, Context>(converter: AnnotatedFieldConverter<From, To, ValuePath, Context>, prototype: From): FieldAdapterBuilder<From, To, never, ValuePath, Context>;
 export declare function adapterFromPrototype<From, To, E, ValuePath extends string, Context>(converter: TwoWayFieldConverter<From, To, E, ValuePath, Context>, prototype: From): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
-export declare function identityAdapter<V, ValuePath extends string, Context>(prototype: V): FieldAdapterBuilder<V, V, never, ValuePath, Context>;
+export declare function identityAdapter<V, ValuePath extends string, Context>(prototype: V, required?: boolean): FieldAdapterBuilder<V, V, never, ValuePath, Context>;
 export declare function listAdapter<E, K extends string, ValuePath extends string, Context>(): FieldAdapterBuilder<readonly E[], readonly K[], never, ValuePath, Context>;
 export {};

package/.out/core/mobx/field_adapter_builder.js

@@ -1,8 +1,7 @@
-import { chainFieldConverter, chainSafeFieldConverter, } from 'field_converters/chain_field_converter';
-import { identityConverter, safeIdentityConverter, } from 'field_converters/identity_converter';
+import { chainAnnotatedFieldConverter, chainUnreliableFieldConverter, } from 'field_converters/chain_field_converter';
+import { annotatedIdentityConverter, unreliableIdentityConverter, } from 'field_converters/identity_converter';
 import { listConverter } from 'field_converters/list_converter';
 import { MaybeIdentityConverter } from 'field_converters/maybe_identity_converter';
-import { validatingConverter, } from 'field_converters/validating_converter';
 import { prototypingFieldValueFactory } from 'field_value_factories/prototyping_field_value_factory';
 class FieldAdapterBuilder {
     convert;
@@ -13,14 +12,8 @@ class FieldAdapterBuilder {
         this.create = create;
         this.revert = revert;
     }
-    validateFrom(...validators) {
-        return new FieldAdapterBuilder(this.convert, this.create, this.revert && chainFieldConverter(this.revert, validatingConverter(validators)));
-    }
-    validateTo(...validators) {
-        return new FieldAdapterBuilder(this.convert, this.create, this.revert && chainFieldConverter(validatingConverter(validators), this.revert));
-    }
     chain(converter, reverter) {
-        return new FieldAdapterBuilder(chainSafeFieldConverter(this.convert, converter), this.create, this.revert && reverter && chainFieldConverter(reverter, this.revert));
+        return new FieldAdapterBuilder(chainAnnotatedFieldConverter(this.convert, converter), this.create, this.revert && reverter && chainUnreliableFieldConverter(reverter, this.revert));
     }
     withReverter(reverter) {
         return new FieldAdapterBuilder(this.convert, this.create, reverter);
@@ -33,6 +26,9 @@ class FieldAdapterBuilder {
         }, isFrom);
         return new FieldAdapterBuilder(identityConverter.convert.bind(identityConverter), this.create, this.revert && identityConverter.revert.bind(identityConverter));
     }
+    get narrow() {
+        return this;
+    }
 }
 export function adapter(converter, valueFactory, reverter) {
     return new FieldAdapterBuilder(converter, valueFactory, reverter);
@@ -48,8 +44,8 @@ export function adapterFromPrototype(converter, prototype) {
         ? new FieldAdapterBuilder(converter, factory)
         : new FieldAdapterBuilder(converter.convert.bind(converter), factory, converter.revert.bind(converter));
 }
-export function identityAdapter(prototype) {
-    return new FieldAdapterBuilder(safeIdentityConverter(), prototypingFieldValueFactory(prototype), identityConverter());
+export function identityAdapter(prototype, required) {
+    return new FieldAdapterBuilder(annotatedIdentityConverter(required), prototypingFieldValueFactory(prototype), unreliableIdentityConverter());
 }
 export function listAdapter() {
     return new FieldAdapterBuilder(listConverter(), prototypingFieldValueFactory([]));

package/.out/core/mobx/field_adapters_of_values.d.ts

@@ -0,0 +1,4 @@
+import { type FieldAdapter } from './field_adapter';
+export type FieldAdaptersOfValues<FlattenedValues extends Readonly<Record<string, any>>, TypePathsToValuePaths extends Readonly<Record<keyof FlattenedValues, string>> = Readonly<Record<keyof FlattenedValues, any>>, Context = any> = {
+    readonly [K in keyof FlattenedValues]: FieldAdapter<FlattenedValues[K], any, any, TypePathsToValuePaths[K], Context>;
+};

package/.out/core/mobx/flattened_adapters_of_fields.d.ts

@@ -1,9 +1,9 @@
-import { type ReadonlyTypeDefOf, type Type, type ValueTypeOf } from '@strictly/define';
+import { type ReadonlyTypeOfType, type Type, type ValueOfType } from '@strictly/define';
 import { type FieldAdapter } from 'core/mobx/field_adapter';
 import { type SimplifyDeep, type ValueOf } from 'type-fest';
 import { type Field } from 'types/field';
 export type FlattenedAdaptersOfFields<ValuePathsToTypePaths extends Readonly<Record<string, string>>, FlattenedTypeDefs extends Partial<Readonly<Record<ValueOf<ValuePathsToTypePaths>, Type>>>, FormFields extends Partial<Readonly<Record<keyof ValuePathsToTypePaths, Field>>>> = SimplifyDeep<{
     readonly [K in keyof ValuePathsToTypePaths as FormFields[K] extends Field ? ValuePathsToTypePaths[K] : never]: AdapterOfField<NonNullable<FormFields[K]>, FlattenedTypeDefs[ValuePathsToTypePaths[K]], K>;
 }>;
-type AdapterOfField<F extends Field, T extends Type | undefined, ValuePath extends string | number | symbol> = ValuePath extends string ? F extends Field<infer V, infer E> ? undefined extends T ? FieldAdapter<V, V, E, ValuePath> : FieldAdapter<ValueTypeOf<ReadonlyTypeDefOf<NonNullable<T>>>, V, E, ValuePath> : never : never;
+type AdapterOfField<F extends Field, T extends Type | undefined, ValuePath extends string | number | symbol> = ValuePath extends string ? F extends Field<infer V, infer E> ? undefined extends T ? FieldAdapter<V, V, E, ValuePath> : FieldAdapter<ValueOfType<ReadonlyTypeOfType<NonNullable<T>>>, V, E, ValuePath> : never : never;
 export {};

package/.out/core/mobx/flattened_list_types_of_type.d.ts

@@ -0,0 +1,8 @@
+import { type FlattenedTypesOfType, type ListTypeDef, type Type } from '@strictly/define';
+import { type SimplifyDeep } from 'type-fest';
+export type ListValuePathsOfType<T extends Type> = keyof FlattenedListTypesOfType<T>;
+export type FlattenedListTypesOfType<T extends Type> = FlattenedListTypesOfTypes<SimplifyDeep<FlattenedTypesOfType<T, null>>>;
+type FlattenedListTypesOfTypes<T extends Readonly<Record<string, Type>>> = {
+    [K in keyof T as T[K]['definition'] extends ListTypeDef ? K : never]: T[K];
+};
+export {};

package/.out/core/mobx/form_fields_of_field_adapters.d.ts

@@ -0,0 +1,8 @@
+import { type ValueOf } from 'type-fest';
+import { type Field } from 'types/field';
+import { type FieldAdapter } from './field_adapter';
+export type FormFieldsOfFieldAdapters<ValuePathsToTypePaths extends Readonly<Record<string, string>>, FieldAdapters extends Partial<Readonly<Record<ValueOf<ValuePathsToTypePaths>, FieldAdapter>>>> = {
+    [K in keyof ValuePathsToTypePaths as undefined extends FieldAdapters[ValuePathsToTypePaths[K]] ? never : K]: FormFieldOfFieldAdapter<FieldAdapters[ValuePathsToTypePaths[K]]>;
+};
+type FormFieldOfFieldAdapter<F extends FieldAdapter | undefined> = F extends FieldAdapter<infer _From, infer To, infer E> ? Field<To, E> : never;
+export {};

package/.out/core/mobx/form_presenter.d.ts

@@ -1,61 +1,58 @@
 import { type ElementOfArray, type Maybe } from '@strictly/base';
-import { type Accessor, type FlattenedValueTypesOf, type MobxValueTypeOf, type ReadonlyTypeDefOf, type Type, type ValueTypeOf } from '@strictly/define';
+import { type Accessor, type FlattenedValuesOfType, type MobxValueOfType, type ReadonlyTypeOfType, type Type, type ValueOfType } from '@strictly/define';
 import { type ReadonlyDeep, type SimplifyDeep, type StringKeyOf, type ValueOf } from 'type-fest';
 import { type Field } from 'types/field';
-import { type ErrorTypeOfFieldAdapter, type FieldAdapter, type ToTypeOfFieldAdapter } from './field_adapter';
-import { type FlattenedListTypeDefsOf } from './flattened_list_type_defs_of';
+import { type ErrorOfFieldAdapter, type FieldAdapter, type ToOfFieldAdapter } from './field_adapter';
+import { 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]>>;
+    readonly [K in keyof ValuePathsToAdapters]: Field<ToOfFieldAdapter<ValuePathsToAdapters[K]>, ErrorOfFieldAdapter<ValuePathsToAdapters[K]>>;
 };
 export type FlattenedTypePathsToAdaptersOf<FlattenedValues extends Readonly<Record<string, any>>, Context> = {
     readonly [K in keyof FlattenedValues]?: FieldAdapter<ReadonlyDeep<FlattenedValues[K]>, any, any, any, Context>;
 };
-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]>>;
+    -readonly [K in keyof ValuePathsToAdapters]?: FieldOverride<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<TypePathsToAdapters extends Partial<Readonly<Record<string, FieldAdapter>>>, ValuePathsToTypePaths extends Readonly<Record<string, string>>> = keyof TypePathsToAdapters extends ValueOf<ValuePathsToTypePaths> ? {
     readonly [K in keyof ValuePathsToTypePaths as unknown extends TypePathsToAdapters[ValuePathsToTypePaths[K]] ? never : K]: NonNullable<TypePathsToAdapters[ValuePathsToTypePaths[K]]>;
 } : never;
-export declare class FormPresenter<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<FlattenedValueTypesOf<T, '*'>, ValueTypeOf<ReadonlyTypeDefOf<T>>>, ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths>> {
-    readonly typeDef: T;
+export declare class FormPresenter<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<FlattenedValuesOfType<T, '*'>, ValueOfType<ReadonlyTypeOfType<T>>>, ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths>> {
+    readonly type: T;
     private readonly adapters;
-    constructor(typeDef: T, adapters: TypePathsToAdapters);
+    constructor(type: T, adapters: TypePathsToAdapters);
     private maybeGetAdapterForValuePath;
     private getAdapterForValuePath;
     typePath<K extends keyof ValueToTypePaths>(valuePath: K): ValueToTypePaths[K];
-    setFieldValueAndValidate<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K, value: ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>): boolean;
-    setFieldValue<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K, value: ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>): boolean;
-    addListItem<K extends keyof FlattenedListTypeDefsOf<T>>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K, elementValue: Maybe<ElementOfArray<FlattenedValueTypesOf<T>[K]>>, index?: number): void;
-    removeListItem<K extends keyof FlattenedListTypeDefsOf<T>>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, elementValuePath: `${K}.${number}`): void;
+    setFieldValueAndValidate<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K, value: ToOfFieldAdapter<ValuePathsToAdapters[K]>): boolean;
+    setFieldValue<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K, value: ToOfFieldAdapter<ValuePathsToAdapters[K]>): boolean;
+    addListItem<K extends keyof FlattenedListTypesOfType<T>>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K, elementValue?: Maybe<ElementOfArray<FlattenedValuesOfType<T>[K]>>, index?: number): void;
+    removeListItem<K extends keyof FlattenedListTypesOfType<T>>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, elementValuePath: `${K}.${number}`): void;
     private internalSetFieldValue;
     clearFieldError<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K): void;
     clearFieldValue<K extends StringKeyOf<ValuePathsToAdapters>>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K): void;
-    clearAll(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, value: ValueTypeOf<T>): void;
+    clearAll(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, value: ValueOfType<T>): void;
+    isValuePathActive<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K): boolean;
     validateField<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K): boolean;
     validateAll(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>): boolean;
-    createModel(value: ValueTypeOf<ReadonlyTypeDefOf<T>>): FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>;
+    createModel(value: ValueOfType<ReadonlyTypeOfType<T>>): FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>;
 }
-export declare class FormModel<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<FlattenedValueTypesOf<T, '*'>, ValueTypeOf<ReadonlyTypeDefOf<T>>>, ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths>> {
-    private readonly typeDef;
+export declare class FormModel<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<FlattenedValuesOfType<T, '*'>, ValueOfType<ReadonlyTypeOfType<T>>>, ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths>> {
+    private readonly type;
     private readonly adapters;
-    accessor value: MobxValueTypeOf<T>;
+    accessor value: MobxValueOfType<T>;
     accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>;
     accessor errors: FlattenedErrors<ValuePathsToAdapters>;
     private readonly flattenedTypeDefs;
-    constructor(typeDef: T, value: ValueTypeOf<ReadonlyTypeDefOf<T>>, adapters: TypePathsToAdapters);
+    constructor(type: T, value: ValueOfType<ReadonlyTypeOfType<T>>, adapters: TypePathsToAdapters);
     get fields(): SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>>;
     private get knownFields();
     private maybeSynthesizeFieldByValuePath;
     private synthesizeFieldByPaths;
     getAccessorForValuePath(valuePath: keyof ValuePathsToAdapters): Accessor | undefined;
     get accessors(): Readonly<Record<string, Accessor>>;
-    protected isDisabled(_valuePath: keyof ValuePathsToAdapters): boolean;
-    protected isRequired(_valuePath: keyof ValuePathsToAdapters): boolean;
 }
 export {};

package/.out/core/mobx/form_presenter.js

@@ -1,17 +1,17 @@
-import { assertExists, assertExistsAndReturn, assertState, checkValidNumber, toArray, UnreachableError, } from '@strictly/base';
-import { flattenAccessorsOf, flattenTypeDefsOf, flattenValueTypeTo, jsonPathPop, mobxCopy, valuePathToTypePath, } from '@strictly/define';
+import { assertExists, assertExistsAndReturn, assertState, checkValidNumber, map, toArray, UnreachableError, } from '@strictly/base';
+import { flattenAccessorsOfType, flattenTypesOfType, flattenValuesOfType, flattenValueTo, jsonPathPop, mobxCopy, valuePathToTypePath, } from '@strictly/define';
 import { computed, observable, runInAction, } from 'mobx';
-import { FieldConversionResult, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/field_converters';
 export class FormPresenter {
-    typeDef;
+    type;
     adapters;
-    constructor(typeDef, adapters) {
-        this.typeDef = typeDef;
+    constructor(type, adapters) {
+        this.type = type;
         this.adapters = adapters;
     }
     maybeGetAdapterForValuePath(valuePath) {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const typePath = valuePathToTypePath(this.typeDef, valuePath, true);
+        const typePath = valuePathToTypePath(this.type, valuePath, true);
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         return this.adapters[typePath];
     }
@@ -19,7 +19,7 @@ export class FormPresenter {
         return assertExistsAndReturn(this.maybeGetAdapterForValuePath(valuePath), 'expected adapter to be defined {}', valuePath);
     }
     typePath(valuePath) {
-        return valuePathToTypePath(this.typeDef, valuePath, true);
+        return valuePathToTypePath(this.type, valuePath, true);
     }
     setFieldValueAndValidate(model, valuePath, value) {
         return this.internalSetFieldValue(model, valuePath, value, true);
@@ -27,7 +27,9 @@ export class FormPresenter {
     setFieldValue(model, valuePath, value) {
         return this.internalSetFieldValue(model, valuePath, value, false);
     }
-    addListItem(model, valuePath, elementValue, index) {
+    addListItem(model, valuePath, 
+    // TODO can this type be simplified?
+    elementValue = null, index) {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const listValuePath = valuePath;
         const accessor = model.accessors[valuePath];
@@ -151,11 +153,9 @@ export class FormPresenter {
         const conversion = revert(value, valuePath, 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;
                     }
@@ -163,7 +163,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;
@@ -190,12 +190,11 @@ export class FormPresenter {
         const { convert, create, } = 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;
         runInAction(function () {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            model.fieldOverrides[valuePath] = {
-                value: displayValue,
-            };
+            model.fieldOverrides[key] = [displayValue];
         });
     }
     clearAll(model, value) {
@@ -203,21 +202,27 @@ export class FormPresenter {
             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(model, valuePath) {
+        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);
+    }
     validateField(model, valuePath) {
         const { convert, revert, create, } = this.getAdapterForValuePath(valuePath);
         const fieldOverride = model.fieldOverrides[valuePath];
         const accessor = model.getAccessorForValuePath(valuePath);
-        const storedValue = convert(accessor != null
+        const { value: storedValue, } = convert(accessor != null
             ? accessor.value
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             : create(valuePath, model.value), 
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         valuePath, model.value);
         const value = fieldOverride != null
-            ? fieldOverride.value
+            ? fieldOverride[0]
             : storedValue;
         const dirty = storedValue !== value;
         assertExists(revert, 'changing field directly not supported {}', valuePath);
@@ -225,13 +230,13 @@ export class FormPresenter {
         const conversion = revert(value, valuePath, 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);
@@ -262,21 +267,21 @@ 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);
                         }
@@ -289,11 +294,11 @@ export class FormPresenter {
         });
     }
     createModel(value) {
-        return new FormModel(this.typeDef, value, this.adapters);
+        return new FormModel(this.type, value, this.adapters);
     }
 }
 export class FormModel {
-    typeDef;
+    type;
     adapters;
     @observable.ref
     accessor value;
@@ -302,14 +307,14 @@ export class FormModel {
     @observable.shallow
     accessor errors = {};
     flattenedTypeDefs;
-    constructor(typeDef, value, adapters) {
-        this.typeDef = typeDef;
+    constructor(type, value, adapters) {
+        this.type = type;
         this.adapters = adapters;
-        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, this.value, () => { }, (_t, value, _setter, typePath, valuePath) => {
+        const conversions = flattenValueTo(type, this.value, () => { }, (_t, value, _setter, typePath, valuePath) => {
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             const adapter = this.adapters[typePath];
             if (adapter == null) {
@@ -320,10 +325,11 @@ 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];
         });
     }
     @computed
@@ -344,7 +350,7 @@ export class FormModel {
     }
     @computed
     get knownFields() {
-        return flattenValueTypeTo(this.typeDef, this.value, () => { }, 
+        return flattenValueTo(this.type, this.value, () => { }, 
         // TODO swap these to valuePath, typePath in flatten
         (_t, _v, _setter, typePath, valuePath) => {
             return this.synthesizeFieldByPaths(
@@ -358,7 +364,7 @@ export class FormModel {
         let typePath;
         try {
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            typePath = valuePathToTypePath(this.typeDef, 
+            typePath = valuePathToTypePath(this.type, 
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             valuePath, true);
         }
@@ -381,26 +387,23 @@ export class FormModel {
         const accessor = this.getAccessorForValuePath(valuePath);
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const fieldTypeDef = this.flattenedTypeDefs[typePath];
-        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, this.value))
-                    // fake values can't be copied
-                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    : create(valuePath, this.value), 
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            valuePath, this.value);
+        const { value, required, readonly, } = convert(accessor != null
+            ? accessor.value
+            : fieldTypeDef != null
+                ? mobxCopy(fieldTypeDef, 
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                create(valuePath, this.value))
+                // fake values can't be copied
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                : create(valuePath, this.value), 
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        valuePath, 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,
         };
     }
     getAccessorForValuePath(valuePath) {
@@ -410,16 +413,8 @@ export class FormModel {
     @computed
     // should only be referenced internally, so loosely typed
     get accessors() {
-        return flattenAccessorsOf(this.typeDef, this.value, (value) => {
-            this.value = mobxCopy(this.typeDef, value);
+        return flattenAccessorsOfType(this.type, this.value, (value) => {
+            this.value = mobxCopy(this.type, value);
         });
     }
-    isDisabled(_valuePath) {
-        // TODO infer from types
-        return false;
-    }
-    isRequired(_valuePath) {
-        // TODO infer from types
-        return false;
-    }
 }

package/.out/core/mobx/merge_field_adapters_with_two_way_converter.d.ts

@@ -0,0 +1,13 @@
+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 declare function mergeFieldAdaptersWithTwoWayConverter<FieldAdapters extends Readonly<Record<string, FieldAdapter>>, E, Context>(fieldAdapters: FieldAdapters, converter: TwoWayFieldConverter<TosOfFieldAdapters<FieldAdapters>, TosOfFieldAdapters<FieldAdapters>, E, ValuePathsOfFieldAdapters<FieldAdapters>, Context>): MergedOfFieldAdaptersWithTwoWayConverter<FieldAdapters, E, Context>;
+export {};

package/.out/core/mobx/merge_field_adapters_with_two_way_converter.js

@@ -0,0 +1,11 @@
+import { map } from '@strictly/base';
+import { chainAnnotatedFieldConverter, chainUnreliableFieldConverter, } from 'field_converters/chain_field_converter';
+export function mergeFieldAdaptersWithTwoWayConverter(fieldAdapters, converter) {
+    return map(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/.out/core/mobx/merge_field_adapters_with_validators.d.ts

@@ -0,0 +1,11 @@
+import { type Validator } from '@strictly/define';
+import { type Simplify } from 'type-fest';
+import { type FieldAdapter } from './field_adapter';
+export type MergedOfFieldAdaptersWithValidators<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 declare function mergeAdaptersWithValidators<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>;
+export {};

package/.out/core/mobx/merge_field_adapters_with_validators.js

@@ -0,0 +1,45 @@
+import { reduce } from '@strictly/base';
+import { annotations, validate, } from '@strictly/define';
+import { UnreliableFieldConversionType, } from 'types/field_converters';
+export function mergeAdaptersWithValidators(adapters, validators) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return reduce(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, ...params) {
+            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],
+                error: validationError,
+            };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function convert(from, ...params) {
+            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;
+    }, {});
+}

package/.out/core/mobx/specs/fixtures.d.ts

@@ -0,0 +1,7 @@
+import { type FieldAdapter } from 'core/mobx/field_adapter';
+import { type TwoWayFieldConverter } from 'types/field_converters';
+import { type Mocked } from 'vitest';
+export declare function createMockedAdapter<E, To, From, ValuePath extends string>(_original: FieldAdapter<From, To, E, ValuePath>): Mocked<Required<FieldAdapter<From, To, E, ValuePath>>>;
+export declare function resetMockAdapter<E, To, From, ValuePath extends string>({ convert, revert, create, }: FieldAdapter<From, To, E, ValuePath>, mockedAdapter: Mocked<Required<FieldAdapter<From, To, E, ValuePath>>>): void;
+export declare function createMockTwoWayFieldConverter<From, To, E, ValuePath extends string, Context>(_original: TwoWayFieldConverter<From, To, E, ValuePath, Context>): Mocked<TwoWayFieldConverter<From, To, E, ValuePath, Context>>;
+export declare function resetMockTwoWayFieldConverter<From, To, E, ValuePath extends string, Context>({ convert, revert, }: TwoWayFieldConverter<From, To, E, ValuePath, Context>, mockedConverter: Mocked<TwoWayFieldConverter<From, To, E, ValuePath, Context>>): void;