@strictly/react-form 0.0.15 → 0.0.17

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

@@ -21,5 +21,5 @@ export declare function adapterFromPrototype<From, To, ValuePath extends string,
 export declare function adapterFromPrototype<From, To, E, ValuePath extends string, Context>(converter: TwoWayFieldConverter<From, To, E, ValuePath, Context>, prototype: From): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
 export declare function identityAdapter<V, ValuePath extends string, Context>(prototype: V, required?: boolean): FieldAdapterBuilder<V, V, never, ValuePath, Context>;
 export declare function trimmingStringAdapter<ValuePath extends string, Context>(): FieldAdapterBuilder<string, string, never, ValuePath, Context>;
-export declare function listAdapter<E, ValuePath extends string, Context>(): FieldAdapterBuilder<readonly E[], readonly E[], never, ValuePath, Context>;
+export declare function listAdapter<E, ValuePath extends string = string, Context = unknown>(): FieldAdapterBuilder<readonly E[], readonly E[], never, ValuePath, Context>;
 export {};

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

@@ -1,5 +1,6 @@
 import { type ElementOfArray, type Maybe } from '@strictly/base';
 import { type Accessor, type FlattenedValuesOfType, type MobxValueOfType, type ReadonlyTypeOfType, type Type, type ValueOfType } from '@strictly/define';
+import { type FormMode } from 'core/props';
 import { type ReadonlyDeep, type SimplifyDeep, type StringKeyOf, type UnionToIntersection, type ValueOf } from 'type-fest';
 import { type Field } from 'types/field';
 import { type ContextOfFieldAdapter, type ErrorOfFieldAdapter, type FieldAdapter, type ToOfFieldAdapter } from './field_adapter';
@@ -21,18 +22,20 @@ export type ValuePathsToAdaptersOf<TypePathsToAdapters extends Partial<Readonly<
     readonly [K in keyof ValuePathsToTypePaths as unknown extends TypePathsToAdapters[ValuePathsToTypePaths[K]] ? never : K]: NonNullable<TypePathsToAdapters[ValuePathsToTypePaths[K]]>;
 } : never;
 export type ContextOf<TypePathsToAdapters extends Partial<Readonly<Record<string, FieldAdapter>>>> = UnionToIntersection<{
-    readonly [K in keyof TypePathsToAdapters]: TypePathsToAdapters[K] extends undefined ? undefined : ContextOfFieldAdapter<NonNullable<TypePathsToAdapters[K]>>;
-}[keyof TypePathsToAdapters]>;
+    readonly [K in keyof TypePathsToAdapters]: TypePathsToAdapters[K] extends undefined ? undefined : unknown extends ContextOfFieldAdapter<NonNullable<TypePathsToAdapters[K]>> ? never : ContextOfFieldAdapter<NonNullable<TypePathsToAdapters[K]>>;
+}[keyof TypePathsToAdapters] | {}>;
 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>;
     private readonly flattenedTypeDefs;
-    constructor(type: T, value: ValueOfType<ReadonlyTypeOfType<T>>, adapters: TypePathsToAdapters);
-    get context(): ContextType;
-    protected abstract toContext(value: ValueOfType<ReadonlyTypeOfType<T>>): ContextType;
+    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;
     get fields(): SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>>;
     private get knownFields();
     private maybeSynthesizeFieldByValuePath;
@@ -52,6 +55,6 @@ export declare abstract class FormModel<T extends Type, ValueToTypePaths extends
     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;
+    validateAll(force?: boolean): boolean;
 }
 export {};

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

@@ -49,7 +49,7 @@ 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, _e;
+    var _b, _c, _d;
     let _instanceExtraInitializers = [];
     let _value_decorators;
     let _value_initializers = [];
@@ -60,7 +60,6 @@ let FormModel = (() => {
     let _errors_decorators;
     let _errors_initializers = [];
     let _errors_extraInitializers = [];
-    let _get_context_decorators;
     let _get_fields_decorators;
     let _get_knownFields_decorators;
     let _get_accessors_decorators;
@@ -71,19 +70,31 @@ let FormModel = (() => {
             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) {
+            constructor(type, originalValue, adapters, mode) {
                 Object.defineProperty(this, "type", {
                     enumerable: true,
                     configurable: true,
                     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,
                     writable: true,
                     value: adapters
                 });
+                Object.defineProperty(this, "mode", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: mode
+                });
                 _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, {})));
@@ -93,12 +104,13 @@ let FormModel = (() => {
                     writable: true,
                     value: __runInitializers(this, _errors_extraInitializers)
                 });
-                this.value = mobxCopy(type, value);
+                this.value = mobxCopy(type, originalValue);
                 this.flattenedTypeDefs = flattenTypesOfType(type);
-                const contextValue = this.toContext(value);
                 // 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) => {
+                const conversions = flattenValueTo(type, this.value, () => { }, (_t, fieldValue, _setter, typePath, valuePath) => {
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    const contextValue = this.toContext(originalValue, valuePath);
                     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                     const adapter = this.adapters[typePath];
                     if (adapter == null) {
@@ -110,15 +122,22 @@ let FormModel = (() => {
                         return;
                     }
                     // cannot call this.context yet as the "this" pointer has not been fully created
-                    return convert(value, valuePath, contextValue);
+                    return convert(fieldValue, valuePath, contextValue);
                 });
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                 this.fieldOverrides = map(conversions, function (_k, v) {
                     return v && [v.value];
                 });
             }
-            get context() {
-                return this.toContext(this.value);
+            get forceMutableFields() {
+                switch (this.mode) {
+                    case 'create':
+                        return true;
+                    case 'edit':
+                        return false;
+                    default:
+                        return this.mode;
+                }
             }
             get fields() {
                 return new Proxy(this.knownFields, {
@@ -173,22 +192,23 @@ let FormModel = (() => {
                 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);
                 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.context))
+                        create(valuePath, context))
                         // fake values can't be copied
                         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                        : create(valuePath, this.context), 
+                        : create(valuePath, context), 
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                valuePath, this.context);
+                valuePath, context);
                 const error = this.errors[valuePath];
                 return {
                     value: fieldOverride != null ? fieldOverride[0] : value,
                     error,
-                    readonly,
+                    readonly: readonly && !this.forceMutableFields,
                     required,
                 };
             }
@@ -235,7 +255,10 @@ let FormModel = (() => {
                     ? elementValue[0]
                     : elementAdapter.create(
                     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    elementTypePath, this.context);
+                    elementTypePath, 
+                    // TODO what can we use for the value path here?
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    this.toContext(this.value, valuePath));
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const originalList = accessor.value;
                 const newList = [
@@ -346,7 +369,7 @@ let FormModel = (() => {
                 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.context);
+                const conversion = revert(value, valuePath, this.toContext(this.value, valuePath));
                 const accessor = this.getAccessorForValuePath(valuePath);
                 return runInAction(() => {
                     this.fieldOverrides[valuePath] = [value];
@@ -384,8 +407,10 @@ let FormModel = (() => {
                     return;
                 }
                 const { convert, create, } = adapter;
-                const value = create(valuePath, this.context);
-                const { value: displayValue, } = convert(value, valuePath, this.context);
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const context = this.toContext(this.value, valuePath);
+                const value = create(valuePath, context);
+                const { value: displayValue, } = convert(value, valuePath, context);
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                 const key = valuePath;
                 runInAction(() => {
@@ -410,25 +435,26 @@ let FormModel = (() => {
                 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, this.context), 
+                    : create(valuePath, context), 
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                valuePath, this.context);
+                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, this.context), valuePath, this.context);
+                    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, this.context);
+                const conversion = revert(value, valuePath, context);
                 return runInAction(() => {
                     switch (conversion.type) {
                         case UnreliableFieldConversionType.Failure:
@@ -448,11 +474,12 @@ let FormModel = (() => {
                     }
                 });
             }
-            validateAll() {
+            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
@@ -468,29 +495,39 @@ let FormModel = (() => {
                             return success;
                         }
                         const fieldOverride = this.fieldOverrides[adapterPath];
-                        const { value: storedValue, } = convert(accessor.value, valuePath, this.context);
+                        // 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 more nuanced comparison
+                        // TODO customizable comparisons
                         const dirty = fieldOverride != null && fieldOverride[0] !== storedValue;
-                        const conversion = revert(value, valuePath, this.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);
+                        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);
                 });
             }
@@ -503,14 +540,12 @@ let FormModel = (() => {
             _value_decorators = [(_b = observable).ref.bind(_b)];
             _fieldOverrides_decorators = [(_c = observable).shallow.bind(_c)];
             _errors_decorators = [(_d = observable).shallow.bind(_d)];
-            _get_context_decorators = [(_e = computed).struct.bind(_e)];
             _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_context_decorators, { kind: "getter", name: "context", static: false, private: false, access: { has: obj => "context" in obj, get: obj => obj.context }, metadata: _metadata }, null, _instanceExtraInitializers);
             __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/specs/form_model.tests.js

@@ -1,7 +1,8 @@
 import { expectDefinedAndReturn } from '@strictly/base';
-import { booleanType, list, nullType, numberType, object, record, stringType, union, } from '@strictly/define';
+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 { 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';
 import { SelectDiscriminatedUnionConverter } from 'field_converters/select_value_type_converter';
@@ -12,9 +13,10 @@ const IS_NAN_ERROR = 1;
 const originalIntegerToStringAdapter = adapterFromTwoWayConverter(new IntegerToStringConverter(IS_NAN_ERROR), prototypingFieldValueFactory(0));
 const originalBooleanToBooleanAdapter = identityAdapter(false);
 class TestFormModel extends FormModel {
-    toContext() {
+    toContext(value, valuePath) {
         return {
-            ctx: true,
+            value,
+            valuePath,
         };
     }
 }
@@ -71,7 +73,7 @@ describe('all', function () {
                 let model;
                 beforeEach(function () {
                     originalValue = 5;
-                    model = new TestFormModel(typeDef, originalValue, adapters);
+                    model = new TestFormModel(typeDef, originalValue, adapters, 'create');
                 });
                 describe('accessors', function () {
                     it('gets the expected value', function () {
@@ -112,7 +114,7 @@ describe('all', function () {
                         readonly: false,
                     });
                     originalValue = 5;
-                    model = new TestFormModel(typeDef, originalValue, adapters);
+                    model = new TestFormModel(typeDef, originalValue, adapters, 'create');
                 });
                 it('reports required status', function () {
                     expect(model.fields).toEqual(expect.objectContaining({
@@ -137,7 +139,7 @@ describe('all', function () {
                     4,
                     17,
                 ];
-                model = new TestFormModel(typeDef, value, adapters);
+                model = new TestFormModel(typeDef, value, adapters, 'create');
             });
             describe('accessors', function () {
                 it.each([
@@ -199,7 +201,7 @@ describe('all', function () {
                     a: 1,
                     b: 2,
                 };
-                model = new TestFormModel(typeDef, value, converters);
+                model = new TestFormModel(typeDef, value, converters, 'create');
             });
             describe('accessors', function () {
                 it.each([
@@ -250,7 +252,7 @@ describe('all', function () {
                     a: 1,
                     b: true,
                 };
-                model = new TestFormModel(typeDef, value, converters);
+                model = new TestFormModel(typeDef, value, converters, 'create');
             });
             describe('accessors', function () {
                 it.each([
@@ -296,7 +298,7 @@ describe('all', function () {
             const originalValue = 2;
             let model;
             beforeEach(function () {
-                model = new TestFormModel(typeDef, originalValue, adapters);
+                model = new TestFormModel(typeDef, originalValue, adapters, 'create');
             });
             describe('setFieldValueAndValidate', function () {
                 describe('success', function () {
@@ -398,7 +400,7 @@ describe('all', function () {
                     3,
                     7,
                 ];
-                model = new TestFormModel(typeDef, originalValue, converters);
+                model = new TestFormModel(typeDef, originalValue, converters, 'create');
             });
             describe('setFieldValueAndValidate', function () {
                 describe('success', function () {
@@ -493,23 +495,32 @@ describe('all', function () {
                 let contextCopy;
                 beforeEach(function () {
                     integerToStringAdapter.revert.mockImplementationOnce(function (_value, _path, context) {
-                        contextCopy = Object.assign({}, context);
+                        contextCopy = JSON.stringify(context);
                         return {
                             type: UnreliableFieldConversionType.Success,
                             value: 1,
                         };
                     });
                 });
-                it('supplies the full, previous context when converting', function () {
+                it('supplies the context when converting', function () {
                     model.setFieldValueAndValidate('$.2', '4');
                     expect(integerToStringAdapter.revert).toHaveBeenCalledOnce();
                     expect(integerToStringAdapter.revert).toHaveBeenCalledWith('4', '$.2', {
-                        ctx: true,
+                        // the supplied value isn't a copy, so it will be the model value, even
+                        // if the value has since changed
+                        value: model.value,
+                        valuePath: '$.2',
                     });
                 });
-                it('supplies the context', function () {
-                    expect(contextCopy).toEqual({
-                        ctx: true,
+                it('supplies the correct context value at the time it is being checked', function () {
+                    // the copy will show the supplied value however
+                    expect(JSON.parse(contextCopy)).toEqual({
+                        value: [
+                            1,
+                            3,
+                            7,
+                        ],
+                        valuePath: '$.2',
                     });
                 });
             });
@@ -687,7 +698,7 @@ describe('all', function () {
                 let model;
                 beforeEach(function () {
                     originalValue = null;
-                    model = new TestFormModel(type, originalValue, adapters);
+                    model = new TestFormModel(type, originalValue, adapters, 'create');
                 });
                 it('has the expected fields', function () {
                     expect(model.fields).toEqual({
@@ -735,7 +746,7 @@ describe('all', function () {
                         const model = new TestFormModel(type, {
                             d: 'x',
                             a: 1,
-                        }, adapters);
+                        }, adapters, 'create');
                         it.each([
                             [
                                 '$',
@@ -758,7 +769,7 @@ describe('all', function () {
                         const model = new TestFormModel(type, {
                             d: 'y',
                             b: false,
-                        }, adapters);
+                        }, adapters, 'create');
                         it.each([
                             [
                                 '$',
@@ -790,7 +801,7 @@ describe('all', function () {
             let model;
             beforeEach(function () {
                 originalValue = 1;
-                model = new TestFormModel(typeDef, originalValue, converters);
+                model = new TestFormModel(typeDef, originalValue, converters, 'create');
             });
             it('returns the default value for the fake field', function () {
                 expect(model.fields['$.fake']).toEqual(expect.objectContaining({
@@ -811,5 +822,54 @@ describe('all', function () {
                 });
             });
         });
+        describe('interaction with create and edit modes', () => {
+            const typeDef = object().readonlyField('n', numberType.enforce(n => n < 10 ? 'err' : null));
+            const adapters = mergeAdaptersWithValidators({
+                $: identityAdapter({ n: 0 }),
+                '$.n': integerToStringAdapter,
+            }, flattenValidatorsOfValidatingType(typeDef));
+            let originalValue;
+            beforeEach(() => {
+                originalValue = {
+                    n: 1,
+                };
+            });
+            describe('create mode', () => {
+                let model;
+                beforeEach(() => {
+                    model = new TestFormModel(typeDef, originalValue, adapters, 'create');
+                });
+                it('makes the field editable', () => {
+                    expect(model.fields['$.n'].readonly).toBeFalsy();
+                });
+                it('fails validation', () => {
+                    expect(model.validateAll()).toBeFalsy();
+                });
+                it('passes validation with valid data', () => {
+                    model.setFieldValue('$.n', '10');
+                    expect(model.validateAll()).toBeTruthy();
+                });
+            });
+            describe('edit model', () => {
+                let model;
+                beforeEach(function () {
+                    model = new TestFormModel(typeDef, originalValue, adapters, 'edit');
+                });
+                it('respects the field being readonly', () => {
+                    expect(model.fields['$.n'].readonly).toBeTruthy();
+                });
+                it('validates successfully with clean, but invalid data', () => {
+                    expect(model.validateAll()).toBeTruthy();
+                });
+                it('fails validation with invalid, dirty data', () => {
+                    model.setFieldValue('$.n', '2');
+                    expect(model.validateAll()).toBeFalsy();
+                });
+                it('passes validation with valid, dirty data', () => {
+                    model.setFieldValue('$.n', '10');
+                    expect(model.validateAll()).toBeTruthy();
+                });
+            });
+        });
     });
 });

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

@@ -1,18 +1,18 @@
 import { type ToOfFieldAdapter } from './field_adapter';
 import { type FlattenedConvertedFieldsOf, type FormModel } from './form_model';
 /**
- * Used to extract the supported value paths from a presenter
+ * Used to extract the supported value paths from a model
  */
 export type ValuePathsOfModel<Model extends FormModel<any, any, any, any, any>> = Model extends FormModel<infer _1, infer _2, infer _3, infer _4, infer ValuePathsToAdapters> ? keyof ValuePathsToAdapters : never;
 /**
  * Used to extract the render type (so the value that is passed to the view) of a given value path
- * from a presenter
+ * from a model
  */
 export type ToValueOfModelValuePath<Model extends FormModel<any, any, any, any, any>, K extends ValuePathsOfModel<Model>> = Model extends FormModel<infer _1, infer _2, infer _3, infer _4, infer ValuePathsToAdapters> ? ToOfFieldAdapter<ValuePathsToAdapters[K]> : never;
 /**
- * Extracts the form fields from the presenter. The recommended way is to
+ * Extracts the form fields from a form model. The recommended way is to
  * define the form fields explicitly and use that type to enforce the types
- * of your converters, but generating the FormFields from your presenter
+ * of your converters, but generating the FormFields from your model
  * is less typing, albeit at the cost of potentially getting type errors
  * reported a long way away from the source
  */

package/.out/core/props.d.ts

@@ -6,7 +6,9 @@ export type FieldsViewProps<F extends Fields> = {
     onFieldBlur?(this: void, key: keyof F): void;
     onFieldSubmit?(this: void, key: keyof F): boolean | void;
 };
+export type FormMode = 'edit' | 'create';
 export type FormProps<O> = {
     value: O;
     onValueChange: (value: O) => void;
+    mode: FormMode;
 };

package/.out/index.d.ts

@@ -17,7 +17,6 @@ export * from './field_converters/trimming_string_converter';
 export * from './field_converters/validating_converter';
 export * from './field_value_factories/prototyping_field_value_factory';
 export * from './mantine/error_renderer';
-export * from './mantine/field_view';
 export * from './mantine/hooks';
 export * from './types/error_of_field';
 export * from './types/field';

package/.out/index.js

@@ -17,7 +17,6 @@ export * from './field_converters/trimming_string_converter';
 export * from './field_converters/validating_converter';
 export * from './field_value_factories/prototyping_field_value_factory';
 export * from './mantine/error_renderer';
-export * from './mantine/field_view';
 export * from './mantine/hooks';
 export * from './types/error_of_field';
 export * from './types/field';

package/.out/mantine/create_field_view.d.ts

@@ -0,0 +1,20 @@
+import { type ComponentType } from 'react';
+import { type AllFieldsOfFields } from 'types/all_fields_of_fields';
+import { type ErrorOfField } from 'types/error_of_field';
+import { type Fields } from 'types/field';
+import { type ValueTypeOfField } from 'types/value_type_of_field';
+import { type MantineForm } from './types';
+export type FieldViewProps<F extends Fields, K extends keyof F> = {
+    children: (props: {
+        value: ValueTypeOfField<F[K]>;
+        error: ErrorOfField<F[K]> | undefined;
+        ErrorSink: ComponentType<{
+            error: ErrorOfField<F[K]>;
+        }>;
+        onFocus: () => void;
+        onBlur: () => void;
+        onValueChange: (v: ValueTypeOfField<F[K]>) => void;
+        onSubmit: () => void;
+    }) => JSX.Element;
+};
+export declare function createFieldView<F extends Fields, K extends keyof AllFieldsOfFields<F>>(this: MantineForm<F>, valuePath: K): ComponentType<FieldViewProps<F, K>>;