@strictly/react-form 0.0.11 → 0.0.13

package/.out/core/mobx/{form_presenter.d.ts → form_model.d.ts}

@@ -20,29 +20,9 @@ type FlattenedErrors<ValuePathsToAdapters extends Readonly<Record<string, FieldA
 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 abstract 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>> {
+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>> {
     readonly type: T;
     protected readonly 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: 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<ValueToTypePaths>>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K): 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, ignoreDefaultValue?: boolean): boolean;
-    validateAll(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>): boolean;
-    abstract 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<FlattenedValuesOfType<T, '*'>, ValueOfType<ReadonlyTypeOfType<T>>>, ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths>> {
-    private readonly type;
-    private readonly adapters;
     accessor value: MobxValueOfType<T>;
     accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>;
     accessor errors: FlattenedErrors<ValuePathsToAdapters>;
@@ -54,5 +34,19 @@ export declare class FormModel<T extends Type, ValueToTypePaths extends Readonly
     private synthesizeFieldByPaths;
     getAccessorForValuePath(valuePath: keyof ValuePathsToAdapters): Accessor | undefined;
     get accessors(): Readonly<Record<string, Accessor>>;
+    private maybeGetAdapterForValuePath;
+    private getAdapterForValuePath;
+    typePath<K extends keyof ValueToTypePaths>(valuePath: K): ValueToTypePaths[K];
+    setFieldValueAndValidate<K extends keyof ValuePathsToAdapters>(valuePath: K, value: ToOfFieldAdapter<ValuePathsToAdapters[K]>): boolean;
+    setFieldValue<K extends keyof ValuePathsToAdapters>(valuePath: K, value: ToOfFieldAdapter<ValuePathsToAdapters[K]>): boolean;
+    addListItem<K extends keyof FlattenedListTypesOfType<T>>(valuePath: K, elementValue?: Maybe<ElementOfArray<FlattenedValuesOfType<T>[K]>>, index?: number): void;
+    removeListItem<K extends keyof FlattenedListTypesOfType<T>>(...elementValuePaths: readonly `${K}.${number}`[]): void;
+    private internalSetFieldValue;
+    clearFieldError<K extends keyof ValuePathsToAdapters>(valuePath: K): void;
+    clearFieldValue<K extends StringKeyOf<ValueToTypePaths>>(valuePath: K): void;
+    clearAll(value: ValueOfType<T>): void;
+    isValuePathActive<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean;
+    validateField<K extends keyof ValuePathsToAdapters>(valuePath: K, ignoreDefaultValue?: boolean): boolean;
+    validateAll(): boolean;
 }
 export {};

package/.out/core/mobx/form_model.js

@@ -0,0 +1,513 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 { UnreliableFieldConversionType, } from 'types/field_converters';
+let FormModel = (() => {
+    var _a, _FormModel_value_accessor_storage, _FormModel_fieldOverrides_accessor_storage, _FormModel_errors_accessor_storage;
+    var _b, _c, _d;
+    let _instanceExtraInitializers = [];
+    let _value_decorators;
+    let _value_initializers = [];
+    let _value_extraInitializers = [];
+    let _fieldOverrides_decorators;
+    let _fieldOverrides_initializers = [];
+    let _fieldOverrides_extraInitializers = [];
+    let _errors_decorators;
+    let _errors_initializers = [];
+    let _errors_extraInitializers = [];
+    let _get_fields_decorators;
+    let _get_knownFields_decorators;
+    let _get_accessors_decorators;
+    return _a = class FormModel {
+            get value() { return __classPrivateFieldGet(this, _FormModel_value_accessor_storage, "f"); }
+            set value(value) { __classPrivateFieldSet(this, _FormModel_value_accessor_storage, value, "f"); }
+            get fieldOverrides() { return __classPrivateFieldGet(this, _FormModel_fieldOverrides_accessor_storage, "f"); }
+            set fieldOverrides(value) { __classPrivateFieldSet(this, _FormModel_fieldOverrides_accessor_storage, value, "f"); }
+            get errors() { return __classPrivateFieldGet(this, _FormModel_errors_accessor_storage, "f"); }
+            set errors(value) { __classPrivateFieldSet(this, _FormModel_errors_accessor_storage, value, "f"); }
+            constructor(type, value, adapters) {
+                Object.defineProperty(this, "type", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: (__runInitializers(this, _instanceExtraInitializers), type)
+                });
+                Object.defineProperty(this, "adapters", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: adapters
+                });
+                _FormModel_value_accessor_storage.set(this, __runInitializers(this, _value_initializers, void 0));
+                _FormModel_fieldOverrides_accessor_storage.set(this, (__runInitializers(this, _value_extraInitializers), __runInitializers(this, _fieldOverrides_initializers, void 0)));
+                _FormModel_errors_accessor_storage.set(this, (__runInitializers(this, _fieldOverrides_extraInitializers), __runInitializers(this, _errors_initializers, {})));
+                Object.defineProperty(this, "flattenedTypeDefs", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: __runInitializers(this, _errors_extraInitializers)
+                });
+                this.value = mobxCopy(type, value);
+                this.flattenedTypeDefs = flattenTypesOfType(type);
+                // pre-populate field overrides for consistent behavior when default information is overwritten
+                // then returned to
+                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) {
+                        return;
+                    }
+                    const { convert, revert, } = adapter;
+                    if (revert == null) {
+                        // no need to store a temporary value if the value cannot be written back
+                        return;
+                    }
+                    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];
+                });
+            }
+            get fields() {
+                return new Proxy(this.knownFields, {
+                    get: (target, prop) => {
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+                        const field = target[prop];
+                        if (field != null) {
+                            return field;
+                        }
+                        if (typeof prop === 'string') {
+                            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                            return this.maybeSynthesizeFieldByValuePath(prop);
+                        }
+                    },
+                });
+            }
+            get knownFields() {
+                return flattenValueTo(this.type, this.value, () => { }, 
+                // TODO swap these to valuePath, typePath in flatten
+                (_t, _v, _setter, typePath, valuePath) => {
+                    return this.synthesizeFieldByPaths(
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    valuePath, 
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    typePath);
+                });
+            }
+            maybeSynthesizeFieldByValuePath(valuePath) {
+                let typePath;
+                try {
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    typePath = valuePathToTypePath(this.type, 
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    valuePath, true);
+                }
+                catch (e) {
+                    // TODO make jsonValuePathToTypePath return null in the event of an invalid
+                    // value path instead of throwing an exception
+                    // assume that the path was invalid
+                    return;
+                }
+                return this.synthesizeFieldByPaths(valuePath, typePath);
+            }
+            synthesizeFieldByPaths(valuePath, typePath) {
+                const adapter = this.adapters[typePath];
+                if (adapter == null) {
+                    // invalid path, which can happen
+                    return;
+                }
+                const { convert, create, } = adapter;
+                const fieldOverride = this.fieldOverrides[valuePath];
+                const accessor = this.getAccessorForValuePath(valuePath);
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const fieldTypeDef = this.flattenedTypeDefs[typePath];
+                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: fieldOverride != null ? fieldOverride[0] : value,
+                    error,
+                    readonly,
+                    required,
+                };
+            }
+            getAccessorForValuePath(valuePath) {
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                return this.accessors[valuePath];
+            }
+            get accessors() {
+                return flattenAccessorsOfType(this.type, this.value, (value) => {
+                    this.value = mobxCopy(this.type, value);
+                });
+            }
+            maybeGetAdapterForValuePath(valuePath) {
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const typePath = valuePathToTypePath(this.type, valuePath, true);
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                return this.adapters[typePath];
+            }
+            getAdapterForValuePath(valuePath) {
+                return assertExistsAndReturn(this.maybeGetAdapterForValuePath(valuePath), 'expected adapter to be defined {}', valuePath);
+            }
+            typePath(valuePath) {
+                return valuePathToTypePath(this.type, valuePath, true);
+            }
+            setFieldValueAndValidate(valuePath, value) {
+                return this.internalSetFieldValue(valuePath, value, true);
+            }
+            setFieldValue(valuePath, value) {
+                return this.internalSetFieldValue(valuePath, value, false);
+            }
+            addListItem(valuePath, 
+            // TODO can this type be simplified?
+            elementValue = null, index) {
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const listValuePath = valuePath;
+                const accessor = this.accessors[valuePath];
+                const listTypePath = this.typePath(valuePath);
+                const definedIndex = index !== null && index !== void 0 ? index : accessor.value.length;
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const elementTypePath = `${listTypePath}.*`;
+                const elementAdapter = assertExistsAndReturn(this.adapters[elementTypePath], 'no adapter specified for list {} ({})', elementTypePath, valuePath);
+                // TODO validation on new elements
+                const element = elementValue != null
+                    ? elementValue[0]
+                    : elementAdapter.create(
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    elementTypePath, this.value);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const originalList = accessor.value;
+                const newList = [
+                    ...originalList.slice(0, definedIndex),
+                    element,
+                    ...originalList.slice(definedIndex),
+                ];
+                // shuffle the overrides around to account for new indices
+                // to so this we need to sort the array indices in descending order
+                const targetPaths = Object.keys(this.fieldOverrides).filter(function (v) {
+                    return v.startsWith(`${listValuePath}.`);
+                }).map(function (v) {
+                    const parts = v.substring(listValuePath.length + 1).split('.');
+                    const index = parseInt(parts[0]);
+                    return [
+                        index,
+                        parts.slice(1),
+                    ];
+                }).filter(function ([index]) {
+                    return index >= definedIndex;
+                }).sort(function ([a], [b]) {
+                    // descending
+                    return b - a;
+                });
+                runInAction(() => {
+                    targetPaths.forEach(([index, postfix,]) => {
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        const fromJsonPath = [
+                            listValuePath,
+                            `${index}`,
+                            ...postfix,
+                        ].join('.');
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        const toJsonPath = [
+                            listValuePath,
+                            `${index + 1}`,
+                            ...postfix,
+                        ].join('.');
+                        const fieldOverride = this.fieldOverrides[fromJsonPath];
+                        delete this.fieldOverrides[fromJsonPath];
+                        this.fieldOverrides[toJsonPath] = fieldOverride;
+                        const error = this.errors[fromJsonPath];
+                        delete this.errors[fromJsonPath];
+                        this.errors[toJsonPath] = error;
+                    });
+                    accessor.set(newList);
+                    // delete any value overrides so the new list isn't shadowed
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    delete this.fieldOverrides[listValuePath];
+                });
+            }
+            removeListItem(...elementValuePaths) {
+                // sort and reverse so we delete last to first so indices of sequential deletions are preserved
+                const orderedElementValuePaths = elementValuePaths.toSorted().reverse();
+                runInAction(() => {
+                    orderedElementValuePaths.forEach(elementValuePath => {
+                        const [listValuePath, elementIndexString,] = assertExistsAndReturn(jsonPathPop(elementValuePath), 'expected a path with two or more segments {}', elementValuePath);
+                        const accessor = this.accessors[listValuePath];
+                        const elementIndex = checkValidNumber(parseInt(elementIndexString), 'unexpected index {} ({})', elementIndexString, elementValuePath);
+                        const newList = [...accessor.value];
+                        assertState(elementIndex >= 0 && elementIndex < newList.length, 'invalid index from path {} ({})', elementIndex, elementValuePath);
+                        newList.splice(elementIndex, 1);
+                        // shuffle the overrides around to account for new indices
+                        // to so this we need to sort the array indices in descending order
+                        const targetPaths = Object.keys(this.fieldOverrides).filter(function (v) {
+                            return v.startsWith(`${listValuePath}.`);
+                        }).map(function (v) {
+                            const parts = v.substring(listValuePath.length + 1).split('.');
+                            const index = parseInt(parts[0]);
+                            return [
+                                index,
+                                parts.slice(1),
+                            ];
+                        }).filter(function ([index]) {
+                            return index > elementIndex;
+                        }).sort(function ([a], [b]) {
+                            // descending
+                            return a - b;
+                        });
+                        targetPaths.forEach(([index, postfix,]) => {
+                            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                            const fromJsonPath = [
+                                listValuePath,
+                                `${index}`,
+                                ...postfix,
+                            ].join('.');
+                            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                            const toJsonPath = [
+                                listValuePath,
+                                `${index - 1}`,
+                                ...postfix,
+                            ].join('.');
+                            const fieldOverride = this.fieldOverrides[fromJsonPath];
+                            delete this.fieldOverrides[fromJsonPath];
+                            this.fieldOverrides[toJsonPath] = fieldOverride;
+                            const error = this.errors[fromJsonPath];
+                            delete this.errors[fromJsonPath];
+                            this.errors[toJsonPath] = error;
+                        });
+                        accessor.set(newList);
+                        // delete any value overrides so the new list isn't shadowed
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        delete this.fieldOverrides[listValuePath];
+                    });
+                });
+            }
+            internalSetFieldValue(valuePath, value, displayValidation) {
+                const { revert } = this.getAdapterForValuePath(valuePath);
+                assertExists(revert, 'setting value not supported {}', valuePath);
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+                const conversion = revert(value, valuePath, this.value);
+                const accessor = this.getAccessorForValuePath(valuePath);
+                return runInAction(() => {
+                    this.fieldOverrides[valuePath] = [value];
+                    switch (conversion.type) {
+                        case UnreliableFieldConversionType.Failure:
+                            if (displayValidation) {
+                                this.errors[valuePath] = conversion.error;
+                            }
+                            if (conversion.value != null && accessor != null) {
+                                accessor.set(conversion.value[0]);
+                            }
+                            return false;
+                        case UnreliableFieldConversionType.Success:
+                            delete this.errors[valuePath];
+                            accessor === null || accessor === void 0 ? void 0 : accessor.set(conversion.value);
+                            return true;
+                        default:
+                            throw new UnreachableError(conversion);
+                    }
+                });
+            }
+            clearFieldError(valuePath) {
+                const fieldOverride = this.fieldOverrides[valuePath];
+                if (fieldOverride != null) {
+                    runInAction(() => {
+                        delete this.errors[valuePath];
+                    });
+                }
+            }
+            clearFieldValue(valuePath) {
+                const typePath = this.typePath(valuePath);
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const adapter = this.adapters[typePath];
+                if (adapter == null) {
+                    return;
+                }
+                const { convert, create, } = adapter;
+                const value = create(valuePath, this.value);
+                const { value: displayValue, } = convert(value, valuePath, this.value);
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const key = valuePath;
+                runInAction(() => {
+                    this.fieldOverrides[key] = [displayValue];
+                });
+            }
+            clearAll(value) {
+                runInAction(() => {
+                    this.errors = {};
+                    // TODO this isn't correct, should reload from value
+                    this.fieldOverrides = {};
+                    this.value = mobxCopy(this.type, value);
+                });
+            }
+            isValuePathActive(valuePath) {
+                const values = flattenValuesOfType(this.type, this.value);
+                const keys = new Set(Object.keys(values));
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                return keys.has(valuePath);
+            }
+            validateField(valuePath, ignoreDefaultValue = false) {
+                const { convert, revert, create, } = this.getAdapterForValuePath(valuePath);
+                const fieldOverride = this.fieldOverrides[valuePath];
+                const accessor = this.getAccessorForValuePath(valuePath);
+                const { value: storedValue, } = convert(accessor != null
+                    ? accessor.value
+                    // 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 = fieldOverride != null
+                    ? fieldOverride[0]
+                    : storedValue;
+                const dirty = storedValue !== value;
+                assertExists(revert, 'changing field directly not supported {}', valuePath);
+                if (ignoreDefaultValue) {
+                    const { value: defaultDisplayValue, } = convert(create(valuePath, this.value), valuePath, this.value);
+                    if (defaultDisplayValue === value) {
+                        return true;
+                    }
+                }
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const conversion = revert(value, valuePath, this.value);
+                return runInAction(() => {
+                    switch (conversion.type) {
+                        case UnreliableFieldConversionType.Failure:
+                            this.errors[valuePath] = conversion.error;
+                            if (conversion.value != null && accessor != null && dirty) {
+                                accessor.set(conversion.value[0]);
+                            }
+                            return false;
+                        case UnreliableFieldConversionType.Success:
+                            delete this.errors[valuePath];
+                            if (accessor != null && dirty) {
+                                accessor.set(conversion.value);
+                            }
+                            return true;
+                        default:
+                            throw new UnreachableError(conversion);
+                    }
+                });
+            }
+            validateAll() {
+                // sort keys shortest to longest so parent changes don't overwrite child changes
+                const accessors = toArray(this.accessors).toSorted(function ([a], [b]) {
+                    return a.length - b.length;
+                });
+                return runInAction(() => {
+                    return accessors.reduce((success, [valuePath, accessor,]) => {
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        const adapterPath = valuePath;
+                        const adapter = this.maybeGetAdapterForValuePath(adapterPath);
+                        if (adapter == null) {
+                            // no adapter == there should be nothing specified for this field
+                            return success;
+                        }
+                        const { convert, revert, } = adapter;
+                        if (revert == null) {
+                            // no convert method means this field is immutable
+                            return success;
+                        }
+                        const fieldOverride = this.fieldOverrides[adapterPath];
+                        const { value: storedValue, } = convert(accessor.value, valuePath, this.value);
+                        const value = fieldOverride != null
+                            ? fieldOverride[0]
+                            : storedValue;
+                        // TODO more nuanced comparison
+                        const dirty = fieldOverride != null && fieldOverride[0] !== storedValue;
+                        const conversion = revert(value, valuePath, this.value);
+                        switch (conversion.type) {
+                            case UnreliableFieldConversionType.Failure:
+                                this.errors[adapterPath] = conversion.error;
+                                if (conversion.value != null && dirty) {
+                                    accessor.set(conversion.value[0]);
+                                }
+                                return false;
+                            case UnreliableFieldConversionType.Success:
+                                if (dirty) {
+                                    accessor.set(conversion.value);
+                                }
+                                delete this.errors[adapterPath];
+                                return success;
+                            default:
+                                throw new UnreachableError(conversion);
+                        }
+                    }, true);
+                });
+            }
+        },
+        _FormModel_value_accessor_storage = new WeakMap(),
+        _FormModel_fieldOverrides_accessor_storage = new WeakMap(),
+        _FormModel_errors_accessor_storage = new WeakMap(),
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _value_decorators = [(_b = observable).ref.bind(_b)];
+            _fieldOverrides_decorators = [(_c = observable).shallow.bind(_c)];
+            _errors_decorators = [(_d = observable).shallow.bind(_d)];
+            _get_fields_decorators = [computed];
+            _get_knownFields_decorators = [computed];
+            _get_accessors_decorators = [computed];
+            __esDecorate(_a, null, _value_decorators, { kind: "accessor", name: "value", static: false, private: false, access: { has: obj => "value" in obj, get: obj => obj.value, set: (obj, value) => { obj.value = value; } }, metadata: _metadata }, _value_initializers, _value_extraInitializers);
+            __esDecorate(_a, null, _fieldOverrides_decorators, { kind: "accessor", name: "fieldOverrides", static: false, private: false, access: { has: obj => "fieldOverrides" in obj, get: obj => obj.fieldOverrides, set: (obj, value) => { obj.fieldOverrides = value; } }, metadata: _metadata }, _fieldOverrides_initializers, _fieldOverrides_extraInitializers);
+            __esDecorate(_a, null, _errors_decorators, { kind: "accessor", name: "errors", static: false, private: false, access: { has: obj => "errors" in obj, get: obj => obj.errors, set: (obj, value) => { obj.errors = value; } }, metadata: _metadata }, _errors_initializers, _errors_extraInitializers);
+            __esDecorate(_a, null, _get_fields_decorators, { kind: "getter", name: "fields", static: false, private: false, access: { has: obj => "fields" in obj, get: obj => obj.fields }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _get_knownFields_decorators, { kind: "getter", name: "knownFields", static: false, private: false, access: { has: obj => "knownFields" in obj, get: obj => obj.knownFields }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _get_accessors_decorators, { kind: "getter", name: "accessors", static: false, private: false, access: { has: obj => "accessors" in obj, get: obj => obj.accessors }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { FormModel };

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

@@ -1,30 +1,11 @@
 import { type ReadonlyTypeOfType, type ValueOfType } from '@strictly/define';
-import { type FieldsViewProps } from 'core/props';
-import { type ComponentType } from 'react';
-import { type UnsafePartialComponent } from 'util/partial';
-import { type FormPresenter } from './form_presenter';
-import { type FormFieldsOfPresenter, type ValuePathsOfPresenter } from './types';
-type ValueOfPresenter<P extends FormPresenter<any, any, any, any>> = P extends FormPresenter<infer T, any, any, any> ? ValueOfType<ReadonlyTypeOfType<T>> : never;
-type ModelOfPresenter<P extends FormPresenter<any, any, any, any>> = ReturnType<P['createModel']>;
-export declare function useDefaultMobxFormHooks<P extends FormPresenter<any, any, any, any>, C extends ComponentType<FieldsViewProps<F>>, F extends FormFieldsOfPresenter<P> = FormFieldsOfPresenter<P>>(presenter: P, value: ValueOfPresenter<P>, options?: {
-    onValidFieldSubmit?: <Path extends ValuePathsOfPresenter<P>>(model: ModelOfPresenter<P>, valuePath: Path) => void;
-    onValidFormSubmit?: (model: ModelOfPresenter<P>, value: ValueOfPresenter<P>) => void;
+import { type FormModel } from './form_model';
+import { type FormFieldsOfModel, type ValuePathsOfModel } from './types';
+type ValueOfModel<M extends FormModel<any, any, any, any>> = M extends FormModel<infer T, any, any, any> ? ValueOfType<ReadonlyTypeOfType<T>> : never;
+export declare function useDefaultMobxFormHooks<M extends FormModel<any, any, any, any>, F extends FormFieldsOfModel<M> = FormFieldsOfModel<M>>(model: M, { onValidFieldSubmit, onValidFormSubmit, }?: {
+    onValidFieldSubmit?: <Path extends ValuePathsOfModel<M>>(valuePath: Path) => void;
+    onValidFormSubmit?: (value: ValueOfModel<M>) => void;
 }): {
-    model: ModelOfPresenter<P>;
-    FormFields?: UnsafePartialComponent<C, FieldsViewProps<F>>;
-    onFormSubmit: () => void;
-    onFieldValueChange<K extends keyof F>(this: void, key: K, value: F[K]['value']): void;
-    onFieldFocus?(this: void, key: keyof F): void;
-    onFieldBlur?(this: void, key: keyof F): void;
-    onFieldSubmit?(this: void, key: keyof F): boolean | void;
-};
-export declare function useDefaultMobxFormHooks<P extends FormPresenter<any, any, any, any>, C extends ComponentType<FieldsViewProps<F>>, F extends FormFieldsOfPresenter<P> = FormFieldsOfPresenter<P>>(presenter: P, value: ValueOfPresenter<P>, options: {
-    onValidFieldSubmit?: <Path extends ValuePathsOfPresenter<P>>(model: ModelOfPresenter<P>, valuePath: Path) => void;
-    onValidFormSubmit?: (model: ModelOfPresenter<P>, value: ValueOfPresenter<P>) => void;
-    FormFieldsView: C;
-}): {
-    model: ModelOfPresenter<P>;
-    FormFields: UnsafePartialComponent<C, FieldsViewProps<F>>;
     onFormSubmit: () => void;
     onFieldValueChange<K extends keyof F>(this: void, key: K, value: F[K]['value']): void;
     onFieldFocus?(this: void, key: keyof F): void;