@strictly/react-form 0.0.18 → 0.0.20

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

@@ -14,8 +14,12 @@ type FieldOverride<V = any> = Maybe<V>;
 type FlattenedFieldOverrides<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
     -readonly [K in keyof ValuePathsToAdapters]?: FieldOverride<ToOfFieldAdapter<ValuePathsToAdapters[K]>>;
 };
-type FlattenedErrors<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
-    -readonly [K in keyof ValuePathsToAdapters]?: ErrorOfFieldAdapter<ValuePathsToAdapters[K]>;
+export declare enum Validation {
+    Changed = 1,
+    Always = 2
+}
+type FlattenedValidation<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
+    -readonly [K in keyof ValuePathsToAdapters]?: Validation;
 };
 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]]>;
@@ -26,13 +30,13 @@ export type ContextOf<TypePathsToAdapters extends Partial<Readonly<Record<string
 export type FormMode = 'edit' | 'create';
 export declare abstract class FormModel<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<FlattenedValuesOfType<T, '*'>, ContextType>, ContextType = ContextOf<TypePathsToAdapters>, ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths>> {
     readonly type: T;
-    private readonly originalValue;
     protected readonly adapters: TypePathsToAdapters;
     protected readonly mode: FormMode;
     accessor value: MobxValueOfType<T>;
     accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>;
-    accessor errors: FlattenedErrors<ValuePathsToAdapters>;
+    accessor validation: FlattenedValidation<ValuePathsToAdapters>;
     private readonly flattenedTypeDefs;
+    private readonly originalValues;
     constructor(type: T, originalValue: ValueOfType<ReadonlyTypeOfType<T>>, adapters: TypePathsToAdapters, mode: FormMode);
     protected abstract toContext(value: ValueOfType<ReadonlyTypeOfType<T>>, valuePath: keyof ValuePathsToAdapters): ContextType;
     get forceMutableFields(): boolean;
@@ -45,16 +49,15 @@ export declare abstract class FormModel<T extends Type, ValueToTypePaths extends
     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;
+    setFieldValue<K extends keyof ValuePathsToAdapters>(valuePath: K, value: ToOfFieldAdapter<ValuePathsToAdapters[K]>, validation?: Validation | undefined | null): 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;
+    clearFieldValue<K extends StringKeyOf<ValuePathsToAdapters>>(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(force?: boolean): boolean;
+    validateField<K extends keyof ValuePathsToAdapters>(valuePath: K, validation?: Validation): boolean;
+    validateAll(validation?: Validation): boolean;
 }
 export {};

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

@@ -47,8 +47,13 @@ import { assertExists, assertExistsAndReturn, assertState, checkValidNumber, map
 import { flattenAccessorsOfType, flattenTypesOfType, flattenValuesOfType, flattenValueTo, jsonPathPop, mobxCopy, valuePathToTypePath, } from '@strictly/define';
 import { computed, observable, runInAction, } from 'mobx';
 import { UnreliableFieldConversionType, } from 'types/field_converters';
+export var Validation;
+(function (Validation) {
+    Validation[Validation["Changed"] = 1] = "Changed";
+    Validation[Validation["Always"] = 2] = "Always";
+})(Validation || (Validation = {}));
 let FormModel = (() => {
-    var _a, _FormModel_value_accessor_storage, _FormModel_fieldOverrides_accessor_storage, _FormModel_errors_accessor_storage;
+    var _a, _FormModel_value_accessor_storage, _FormModel_fieldOverrides_accessor_storage, _FormModel_validation_accessor_storage;
     var _b, _c, _d;
     let _instanceExtraInitializers = [];
     let _value_decorators;
@@ -57,9 +62,9 @@ let FormModel = (() => {
     let _fieldOverrides_decorators;
     let _fieldOverrides_initializers = [];
     let _fieldOverrides_extraInitializers = [];
-    let _errors_decorators;
-    let _errors_initializers = [];
-    let _errors_extraInitializers = [];
+    let _validation_decorators;
+    let _validation_initializers = [];
+    let _validation_extraInitializers = [];
     let _get_fields_decorators;
     let _get_knownFields_decorators;
     let _get_accessors_decorators;
@@ -68,8 +73,8 @@ let FormModel = (() => {
             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"); }
+            get validation() { return __classPrivateFieldGet(this, _FormModel_validation_accessor_storage, "f"); }
+            set validation(value) { __classPrivateFieldSet(this, _FormModel_validation_accessor_storage, value, "f"); }
             constructor(type, originalValue, adapters, mode) {
                 Object.defineProperty(this, "type", {
                     enumerable: true,
@@ -77,12 +82,6 @@ let FormModel = (() => {
                     writable: true,
                     value: (__runInitializers(this, _instanceExtraInitializers), type)
                 });
-                Object.defineProperty(this, "originalValue", {
-                    enumerable: true,
-                    configurable: true,
-                    writable: true,
-                    value: originalValue
-                });
                 Object.defineProperty(this, "adapters", {
                     enumerable: true,
                     configurable: true,
@@ -97,13 +96,22 @@ let FormModel = (() => {
                 });
                 _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, {})));
+                _FormModel_validation_accessor_storage.set(this, (__runInitializers(this, _fieldOverrides_extraInitializers), __runInitializers(this, _validation_initializers, {})));
                 Object.defineProperty(this, "flattenedTypeDefs", {
                     enumerable: true,
                     configurable: true,
                     writable: true,
-                    value: __runInitializers(this, _errors_extraInitializers)
+                    value: __runInitializers(this, _validation_extraInitializers)
                 });
+                // cannot be type safe
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                Object.defineProperty(this, "originalValues", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: void 0
+                });
+                this.originalValues = flattenValuesOfType(type, originalValue);
                 this.value = mobxCopy(type, originalValue);
                 this.flattenedTypeDefs = flattenTypesOfType(type);
                 // pre-populate field overrides for consistent behavior when default information is overwritten
@@ -187,24 +195,60 @@ let FormModel = (() => {
                     // invalid path, which can happen
                     return;
                 }
-                const { convert, create, } = adapter;
+                const { convert, create, revert, } = 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 context = this.toContext(this.value, valuePath);
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const defaultValue = create(valuePath, context);
                 const { value, required, readonly, } = convert(accessor != null
                     ? accessor.value
                     : fieldTypeDef != null
-                        ? mobxCopy(fieldTypeDef, 
-                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                        create(valuePath, context))
+                        ? mobxCopy(fieldTypeDef, defaultValue)
                         // fake values can't be copied
-                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                        : create(valuePath, context), 
+                        : defaultValue, 
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                 valuePath, context);
-                const error = this.errors[valuePath];
+                // const error = this.errors[valuePath]
+                let error = undefined;
+                const displayedValue = fieldOverride != null ? fieldOverride[0] : value;
+                const validation = this.validation[valuePath];
+                switch (validation) {
+                    case undefined:
+                        // skip validation
+                        break;
+                    case Validation.Changed:
+                        if (revert != null) {
+                            const originalValue = valuePath in this.originalValues
+                                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                                ? this.originalValues[valuePath]
+                                : defaultValue;
+                            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                            const { value: originalDisplayedValue } = convert(originalValue, valuePath, context);
+                            // TODO better comparisons, displayed values can still be complex
+                            if (displayedValue !== originalDisplayedValue) {
+                                const revertResult = revert(displayedValue, valuePath, context);
+                                if ((revertResult === null || revertResult === void 0 ? void 0 : revertResult.type) === UnreliableFieldConversionType.Failure) {
+                                    ;
+                                    ({ error } = revertResult);
+                                }
+                            }
+                        }
+                        break;
+                    case Validation.Always:
+                        {
+                            const revertResult = revert === null || revert === void 0 ? void 0 : revert(displayedValue, valuePath, context);
+                            if ((revertResult === null || revertResult === void 0 ? void 0 : revertResult.type) === UnreliableFieldConversionType.Failure) {
+                                ;
+                                ({ error } = revertResult);
+                            }
+                        }
+                        break;
+                    default:
+                        throw new UnreachableError(validation);
+                }
                 return {
                     value: fieldOverride != null ? fieldOverride[0] : value,
                     error,
@@ -233,11 +277,8 @@ let FormModel = (() => {
             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);
+            setFieldValue(valuePath, value, validation = this.validation[valuePath]) {
+                return this.internalSetFieldValue(valuePath, value, validation);
             }
             addListItem(valuePath, 
             // TODO can this type be simplified?
@@ -300,9 +341,9 @@ let FormModel = (() => {
                         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;
+                        const validation = this.validation[fromJsonPath];
+                        delete this.validation[fromJsonPath];
+                        this.validation[toJsonPath] = validation;
                     });
                     accessor.set(newList);
                     // delete any value overrides so the new list isn't shadowed
@@ -354,9 +395,9 @@ let FormModel = (() => {
                             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;
+                            const validation = this.validation[fromJsonPath];
+                            delete this.validation[fromJsonPath];
+                            this.validation[toJsonPath] = validation;
                         });
                         accessor.set(newList);
                         // delete any value overrides so the new list isn't shadowed
@@ -365,7 +406,7 @@ let FormModel = (() => {
                     });
                 });
             }
-            internalSetFieldValue(valuePath, value, displayValidation) {
+            internalSetFieldValue(valuePath, value, validation) {
                 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
@@ -373,17 +414,19 @@ let FormModel = (() => {
                 const accessor = this.getAccessorForValuePath(valuePath);
                 return runInAction(() => {
                     this.fieldOverrides[valuePath] = [value];
+                    if (validation != null) {
+                        this.validation[valuePath] = validation;
+                    }
+                    else {
+                        delete this.validation[valuePath];
+                    }
                     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:
@@ -395,7 +438,7 @@ let FormModel = (() => {
                 const fieldOverride = this.fieldOverrides[valuePath];
                 if (fieldOverride != null) {
                     runInAction(() => {
-                        delete this.errors[valuePath];
+                        delete this.validation[valuePath];
                     });
                 }
             }
@@ -415,11 +458,12 @@ let FormModel = (() => {
                 const key = valuePath;
                 runInAction(() => {
                     this.fieldOverrides[key] = [displayValue];
+                    delete this.validation[key];
                 });
             }
             clearAll(value) {
                 runInAction(() => {
-                    this.errors = {};
+                    this.validation = {};
                     // TODO this isn't correct, should reload from value
                     this.fieldOverrides = {};
                     this.value = mobxCopy(this.type, value);
@@ -431,121 +475,43 @@ let FormModel = (() => {
                 // 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 context = this.toContext(this.value, valuePath);
-                const { value: storedValue, } = convert(accessor != null
-                    ? accessor.value
-                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    : create(valuePath, context), 
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                valuePath, context);
-                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, context), valuePath, context);
-                    if (defaultDisplayValue === value) {
-                        return true;
-                    }
-                }
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                const conversion = revert(value, valuePath, context);
-                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);
-                    }
+            validateField(valuePath, validation) {
+                var _b;
+                if (validation === void 0) { validation = Math.max(this.mode === 'create' ? Validation.Always : Validation.Changed, (_b = this.validation[valuePath]) !== null && _b !== void 0 ? _b : Validation.Changed); }
+                runInAction(() => {
+                    this.validation[valuePath] = validation;
                 });
+                return this.fields[valuePath].error == null;
             }
-            validateAll(force = this.mode === 'create') {
-                // 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;
-                });
-                const flattenedOriginalValues = flattenValuesOfType(this.type, this.originalValue);
-                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];
+            validateAll(validation = this.mode === 'create' ? Validation.Always : Validation.Changed) {
+                const accessors = toArray(this.accessors);
+                runInAction(() => {
+                    accessors.forEach(([valuePath]) => {
                         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                        const context = this.toContext(this.value, valuePath);
-                        const { value: storedValue, } = convert(accessor.value, valuePath, context);
-                        const value = fieldOverride != null
-                            ? fieldOverride[0]
-                            : storedValue;
-                        // TODO customizable comparisons
-                        const dirty = fieldOverride != null && fieldOverride[0] !== storedValue;
-                        const needsValidation = force
-                            || !(valuePath in flattenedOriginalValues)
-                            || storedValue !== convert(flattenedOriginalValues[valuePath], valuePath, 
-                            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                            this.toContext(this.originalValue, valuePath)).value;
-                        if (needsValidation) {
-                            const conversion = revert(value, valuePath, context);
-                            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);
-                            }
-                        }
-                        return success;
-                    }, true);
+                        this.validation[valuePath] = validation;
+                    });
+                });
+                return accessors.every(([valuePath]) => {
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    const field = this.fields[valuePath];
+                    return (field === null || field === void 0 ? void 0 : field.error) == null;
                 });
             }
         },
         _FormModel_value_accessor_storage = new WeakMap(),
         _FormModel_fieldOverrides_accessor_storage = new WeakMap(),
-        _FormModel_errors_accessor_storage = new WeakMap(),
+        _FormModel_validation_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)];
+            _validation_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, _validation_decorators, { kind: "accessor", name: "validation", static: false, private: false, access: { has: obj => "validation" in obj, get: obj => obj.validation, set: (obj, value) => { obj.validation = value; } }, metadata: _metadata }, _validation_initializers, _validation_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);

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

@@ -1,9 +1,8 @@
 import { useCallback, } from 'react';
 export function useDefaultMobxFormHooks(model, { onValidFieldSubmit, onValidFormSubmit, } = {}) {
     const onFieldValueChange = useCallback(function (path, value) {
-        // TODO do in one action
-        model.clearFieldError(path);
-        model.setFieldValue(path, value);
+        // clear any validation
+        model.setFieldValue(path, value, null);
     }, [model]);
     const onFieldSubmit = useCallback(function (valuePath) {
         if (model.validateField(valuePath)) {
@@ -20,7 +19,7 @@ export function useDefaultMobxFormHooks(model, { onValidFieldSubmit, onValidForm
         // TODO debounce?
         setTimeout(function () {
             if (model.isValuePathActive(path)) {
-                model.validateField(path, true);
+                model.validateField(path);
             }
         }, 100);
     }, [model]);

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

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

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

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

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

@@ -1,7 +1,7 @@
 import { expectDefinedAndReturn } from '@strictly/base';
 import { booleanType, flattenValidatorsOfValidatingType, list, nullType, numberType, object, record, stringType, union, } from '@strictly/define';
 import { adapterFromTwoWayConverter, identityAdapter, } from 'core/mobx/field_adapter_builder';
-import { FormModel, } from 'core/mobx/form_model';
+import { FormModel, Validation, } from 'core/mobx/form_model';
 import { mergeAdaptersWithValidators } from 'core/mobx/merge_field_adapters_with_validators';
 import { IntegerToStringConverter } from 'field_converters/integer_to_string_converter';
 import { NullableToBooleanConverter } from 'field_converters/nullable_to_boolean_converter';
@@ -19,6 +19,9 @@ class TestFormModel extends FormModel {
             valuePath,
         };
     }
+    setFieldValueAndValidate(valuePath, value) {
+        this.setFieldValue(valuePath, value, Validation.Always);
+    }
 }
 describe('all', function () {
     const integerToStringAdapter = createMockedAdapter(originalIntegerToStringAdapter);
@@ -336,10 +339,10 @@ describe('all', function () {
                     });
                     describe('conversion succeeds, but validation fails', function () {
                         const newValue = -1;
-                        const errorCode = 65;
+                        const errorCode = IS_NAN_ERROR;
                         beforeEach(function () {
                             var _a;
-                            (_a = integerToStringAdapter.revert) === null || _a === void 0 ? void 0 : _a.mockReturnValueOnce({
+                            (_a = integerToStringAdapter.revert) === null || _a === void 0 ? void 0 : _a.mockReturnValue({
                                 type: UnreliableFieldConversionType.Failure,
                                 error: errorCode,
                                 value: [newValue],
@@ -527,9 +530,10 @@ describe('all', function () {
             describe('addListItem', function () {
                 describe('adds default to start of the list', function () {
                     beforeEach(function () {
-                        model.errors['$.0'] = 0;
-                        model.errors['$.1'] = 1;
-                        model.errors['$.2'] = 2;
+                        model.setFieldValue('$.0', 'x');
+                        model.setFieldValue('$.1', '3');
+                        model.setFieldValue('$.2', 'z');
+                        model.validateAll();
                         model.addListItem('$', null, 0);
                     });
                     it('adds the list item to the underlying value', function () {
@@ -547,7 +551,7 @@ describe('all', function () {
                         ],
                         [
                             '$.1',
-                            '1',
+                            'x',
                         ],
                         [
                             '$.2',
@@ -555,7 +559,7 @@ describe('all', function () {
                         ],
                         [
                             '$.3',
-                            '7',
+                            'z',
                         ],
                     ])('it reports the value of field %s as %s', function (path, fieldValue) {
                         var _a;
@@ -568,15 +572,15 @@ describe('all', function () {
                         ],
                         [
                             '$.1',
-                            0,
+                            IS_NAN_ERROR,
                         ],
                         [
                             '$.2',
-                            1,
+                            undefined,
                         ],
                         [
                             '$.3',
-                            2,
+                            IS_NAN_ERROR,
                         ],
                     ])('it reports the error of field %s', function (path, error) {
                         var _a;
@@ -615,9 +619,10 @@ describe('all', function () {
             });
             describe('removeListItem', function () {
                 beforeEach(function () {
-                    model.errors['$.0'] = 0;
-                    model.errors['$.1'] = 1;
-                    model.errors['$.2'] = 2;
+                    model.setFieldValue('$.0', 'x');
+                    model.setFieldValue('$.1', '3');
+                    model.setFieldValue('$.2', 'z');
+                    model.validateAll();
                 });
                 describe('remove first item', function () {
                     beforeEach(function () {
@@ -633,11 +638,11 @@ describe('all', function () {
                         expect(model.fields).toEqual({
                             '$.0': expect.objectContaining({
                                 value: '3',
-                                error: 1,
+                                error: undefined,
                             }),
                             '$.1': expect.objectContaining({
-                                value: '7',
-                                error: 2,
+                                value: 'z',
+                                error: IS_NAN_ERROR,
                             }),
                         });
                     });
@@ -655,12 +660,12 @@ describe('all', function () {
                     it('updates the field values and errors', function () {
                         expect(model.fields).toEqual({
                             '$.0': expect.objectContaining({
-                                value: '1',
-                                error: 0,
+                                value: 'x',
+                                error: IS_NAN_ERROR,
                             }),
                             '$.1': expect.objectContaining({
-                                value: '7',
-                                error: 2,
+                                value: 'z',
+                                error: IS_NAN_ERROR,
                             }),
                         });
                     });
@@ -675,8 +680,8 @@ describe('all', function () {
                     it('updates the field values and errors', function () {
                         expect(model.fields).toEqual({
                             '$.0': expect.objectContaining({
-                                value: '7',
-                                error: 2,
+                                value: 'z',
+                                error: IS_NAN_ERROR,
                             }),
                         });
                     });

package/.out/mantine/create_fields_view.d.ts

@@ -5,8 +5,9 @@ import type { AllFieldsOfFields } from 'types/all_fields_of_fields';
 import type { Fields } from 'types/field';
 import type { SubFormFields } from 'types/sub_form_fields';
 import type { MantineFieldComponent } from './types';
+export type SubPathsOf<ValuePath extends string, SubFormValuePath extends string> = SubFormValuePath extends StringConcatOf<ValuePath, infer Postfix> ? `$${Postfix}` : never;
 export type CallbackMapper<ValuePath extends string> = {
-    <Cb extends (...args: any[]) => any>(cb: Cb): Parameters<Cb> extends [infer SubFormValuePath extends string, ...(infer Rest)] ? SubFormValuePath extends StringConcatOf<ValuePath, infer Postfix> ? (valuePath: `$${Postfix}`, ...rest: Rest) => ReturnType<Cb> : never : never;
+    <Cb extends (...args: any[]) => any>(cb: Cb): Parameters<Cb> extends [infer SubFormValuePath extends string, ...(infer Rest)] ? (valuePath: SubPathsOf<ValuePath, SubFormValuePath>, ...rest: Rest) => ReturnType<Cb> : never;
 };
 export type FieldsView<ValuePath extends string = string, C extends ComponentType<any> = ComponentType<any>> = {
     Component: C;