@strictly/react-form 0.0.9 → 0.0.11

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

@@ -5,13 +5,25 @@ import { TrimmingStringConverter } from 'field_converters/trimming_string_conver
 import { prototypingFieldValueFactory } from 'field_value_factories/prototyping_field_value_factory';
 import { UnreliableFieldConversionType, } from 'types/field_converters';
 class FieldAdapterBuilder {
-    convert;
-    create;
-    revert;
     constructor(convert, create, revert) {
-        this.convert = convert;
-        this.create = create;
-        this.revert = revert;
+        Object.defineProperty(this, "convert", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: convert
+        });
+        Object.defineProperty(this, "create", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: create
+        });
+        Object.defineProperty(this, "revert", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: revert
+        });
     }
     chain(converter, reverter) {
         return new FieldAdapterBuilder(chainAnnotatedFieldConverter(this.convert, converter), this.create, this.revert && reverter && chainUnreliableFieldConverter(reverter, this.revert));

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

@@ -20,9 +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 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 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>> {
     readonly type: T;
-    private readonly adapters;
+    protected readonly adapters: TypePathsToAdapters;
     constructor(type: T, adapters: TypePathsToAdapters);
     private maybeGetAdapterForValuePath;
     private getAdapterForValuePath;
@@ -33,12 +33,12 @@ export declare class FormPresenter<T extends Type, ValueToTypePaths extends Read
     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;
+    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): 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;
-    createModel(value: ValueOfType<ReadonlyTypeOfType<T>>): FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>;
+    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;

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

@@ -1,13 +1,66 @@
+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';
 export class FormPresenter {
-    type;
-    adapters;
     constructor(type, adapters) {
-        this.type = type;
-        this.adapters = adapters;
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: type
+        });
+        Object.defineProperty(this, "adapters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: adapters
+        });
     }
     maybeGetAdapterForValuePath(valuePath) {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -34,7 +87,7 @@ export class FormPresenter {
         const listValuePath = valuePath;
         const accessor = model.accessors[valuePath];
         const listTypePath = this.typePath(valuePath);
-        const definedIndex = index ?? accessor.value.length;
+        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);
@@ -165,7 +218,7 @@ export class FormPresenter {
                     return false;
                 case UnreliableFieldConversionType.Success:
                     delete model.errors[valuePath];
-                    accessor?.set(conversion.value);
+                    accessor === null || accessor === void 0 ? void 0 : accessor.set(conversion.value);
                     return true;
                 default:
                     throw new UnreachableError(conversion);
@@ -188,8 +241,7 @@ export class FormPresenter {
             return;
         }
         const { convert, create, } = adapter;
-        const accessor = model.accessors[valuePath];
-        const value = accessor == null ? create(valuePath, model.value) : accessor.value;
+        const value = create(valuePath, model.value);
         const { value: displayValue, } = convert(value, valuePath, model.value);
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const key = valuePath;
@@ -211,7 +263,7 @@ export class FormPresenter {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         return keys.has(valuePath);
     }
-    validateField(model, valuePath) {
+    validateField(model, valuePath, ignoreDefaultValue = false) {
         const { convert, revert, create, } = this.getAdapterForValuePath(valuePath);
         const fieldOverride = model.fieldOverrides[valuePath];
         const accessor = model.getAccessorForValuePath(valuePath);
@@ -226,6 +278,12 @@ export class FormPresenter {
             : storedValue;
         const dirty = storedValue !== value;
         assertExists(revert, 'changing field directly not supported {}', valuePath);
+        if (ignoreDefaultValue) {
+            const { value: defaultDisplayValue, } = convert(create(valuePath, model.value), valuePath, model.value);
+            if (defaultDisplayValue === value) {
+                return true;
+            }
+        }
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const conversion = revert(value, valuePath, model.value);
         return runInAction(function () {
@@ -293,128 +351,175 @@ export class FormPresenter {
             }, true);
         });
     }
-    createModel(value) {
-        return new FormModel(this.type, value, this.adapters);
-    }
 }
-export class FormModel {
-    type;
-    adapters;
-    @observable.ref
-    accessor value;
-    @observable.shallow
-    accessor fieldOverrides;
-    @observable.shallow
-    accessor errors = {};
-    flattenedTypeDefs;
-    constructor(type, value, adapters) {
-        this.type = type;
-        this.adapters = adapters;
-        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;
+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];
+                });
             }
-            const { convert, revert, } = adapter;
-            if (revert == null) {
-                // no need to store a temporary value if the value cannot be written back
-                return;
+            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);
+                        }
+                    },
+                });
             }
-            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
-    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') {
+            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
-                    return this.maybeSynthesizeFieldByValuePath(prop);
+                    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);
                 }
-            },
-        });
-    }
-    @computed
-    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, 
+                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
-                create(valuePath, this.value))
-                // fake values can't be copied
+                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
-                : 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];
-    }
-    @computed
-    // should only be referenced internally, so loosely typed
-    get accessors() {
-        return flattenAccessorsOfType(this.type, this.value, (value) => {
-            this.value = mobxCopy(this.type, value);
-        });
-    }
-}
+                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);
+                });
+            }
+        },
+        _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,14 +1,34 @@
 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 ValuePathsOfPresenter } from './types';
+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>>(presenter: P, value: ValueOfPresenter<P>, { onValidFieldSubmit, onValidFormSubmit, }?: {
+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;
 }): {
     model: ModelOfPresenter<P>;
-    onFormSubmit?: () => void;
-} & Omit<FieldsViewProps<ModelOfPresenter<P>['fields']>, 'fields'>;
+    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;
+    onFieldBlur?(this: void, key: keyof F): void;
+    onFieldSubmit?(this: void, key: keyof F): boolean | void;
+};
 export {};

package/.out/core/mobx/hooks.js

@@ -1,6 +1,6 @@
 import { useCallback, useMemo, } from 'react';
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function useDefaultMobxFormHooks(presenter, value, { onValidFieldSubmit, onValidFormSubmit, } = {}) {
+import { createUnsafePartialObserverComponent, } from 'util/partial';
+export function useDefaultMobxFormHooks(presenter, value, { onValidFieldSubmit, onValidFormSubmit, FormFieldsView, } = {}) {
     const model = useMemo(function () {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         return presenter.createModel(value);
@@ -17,7 +17,7 @@ export function useDefaultMobxFormHooks(presenter, value, { onValidFieldSubmit,
     ]);
     const onFieldSubmit = useCallback(function (valuePath) {
         if (presenter.validateField(model, valuePath)) {
-            onValidFieldSubmit?.(model, valuePath);
+            onValidFieldSubmit === null || onValidFieldSubmit === void 0 ? void 0 : onValidFieldSubmit(model, valuePath);
         }
         return false;
     }, [
@@ -31,7 +31,7 @@ export function useDefaultMobxFormHooks(presenter, value, { onValidFieldSubmit,
         // TODO debounce?
         setTimeout(function () {
             if (presenter.isValuePathActive(model, path)) {
-                presenter.validateField(model, path);
+                presenter.validateField(model, path, true);
             }
         }, 100);
     }, [
@@ -40,18 +40,39 @@ export function useDefaultMobxFormHooks(presenter, value, { onValidFieldSubmit,
     ]);
     const onFormSubmit = useCallback(function () {
         if (presenter.validateAll(model)) {
-            onValidFormSubmit?.(model, model.value);
+            onValidFormSubmit === null || onValidFormSubmit === void 0 ? void 0 : onValidFormSubmit(model, model.value);
         }
     }, [
         presenter,
         model,
         onValidFormSubmit,
     ]);
+    const FormFields = useMemo(() => {
+        if (FormFieldsView == null) {
+            return undefined;
+        }
+        return createUnsafePartialObserverComponent(FormFieldsView, () => {
+            return {
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                fields: model.fields,
+                onFieldBlur,
+                onFieldSubmit,
+                onFieldValueChange,
+            };
+        });
+    }, [
+        model,
+        FormFieldsView,
+        onFieldBlur,
+        onFieldSubmit,
+        onFieldValueChange,
+    ]);
     return {
         model,
         onFieldValueChange,
         onFieldSubmit,
         onFieldBlur,
         onFormSubmit,
+        FormFields,
     };
 }

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

@@ -35,11 +35,7 @@ export function mergeAdaptersWithValidators(adapters, validators) {
                 readonly: readonly1 || readonly2,
             };
         }
-        acc[key] = {
-            ...adapter,
-            convert,
-            revert: adapter.revert && revert,
-        };
+        acc[key] = Object.assign(Object.assign({}, adapter), { convert, revert: adapter.revert && revert });
         return acc;
     }, {});
 }

package/.out/core/mobx/specs/fixtures.js

@@ -3,9 +3,10 @@ export function createMockedAdapter(_original) {
     return mock();
 }
 export function resetMockAdapter({ convert, revert, create, }, mockedAdapter) {
+    var _a;
     mockReset(mockedAdapter);
     if (revert) {
-        mockedAdapter.revert?.mockImplementation(revert);
+        (_a = mockedAdapter.revert) === null || _a === void 0 ? void 0 : _a.mockImplementation(revert);
     }
     mockedAdapter.convert.mockImplementation(convert);
     mockedAdapter.create.mockImplementation(create);