@strictly/react-form 0.0.13 → 0.0.14

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

@@ -8,3 +8,4 @@ export type FromOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<
 export type ToOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _F, infer To> ? To : never;
 export type ErrorOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _From, infer _To, infer E> ? NonNullable<E> : never;
 export type ValuePathOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _From, infer _To, infer _E, infer ValuePath> ? ValuePath : never;
+export type ContextOfFieldAdapter<F extends FieldAdapter> = F extends FieldAdapter<infer _From, infer _To, infer _E, infer _P, infer Context> ? Context : never;

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

@@ -20,7 +20,7 @@ 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 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>> {
+export declare abstract class FormModel<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<FlattenedValuesOfType<T, '*'>, ContextType>, ContextType = {}, ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths>> {
     readonly type: T;
     protected readonly adapters: TypePathsToAdapters;
     accessor value: MobxValueOfType<T>;
@@ -28,6 +28,8 @@ export declare class FormModel<T extends Type, ValueToTypePaths extends Readonly
     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;
     get fields(): SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>>;
     private get knownFields();
     private maybeSynthesizeFieldByValuePath;

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;
+    var _b, _c, _d, _e;
     let _instanceExtraInitializers = [];
     let _value_decorators;
     let _value_initializers = [];
@@ -60,6 +60,7 @@ 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;
@@ -94,6 +95,7 @@ let FormModel = (() => {
                 });
                 this.value = mobxCopy(type, value);
                 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) => {
@@ -107,13 +109,17 @@ let FormModel = (() => {
                         // no need to store a temporary value if the value cannot be written back
                         return;
                     }
-                    return convert(value, valuePath, this.value);
+                    // cannot call this.context yet as the "this" pointer has not been fully created
+                    return convert(value, 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 fields() {
                 return new Proxy(this.knownFields, {
                     get: (target, prop) => {
@@ -172,12 +178,12 @@ let FormModel = (() => {
                     : fieldTypeDef != null
                         ? mobxCopy(fieldTypeDef, 
                         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                        create(valuePath, this.value))
+                        create(valuePath, this.context))
                         // fake values can't be copied
                         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                        : create(valuePath, this.value), 
+                        : create(valuePath, this.context), 
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                valuePath, this.value);
+                valuePath, this.context);
                 const error = this.errors[valuePath];
                 return {
                     value: fieldOverride != null ? fieldOverride[0] : value,
@@ -229,7 +235,7 @@ let FormModel = (() => {
                     ? elementValue[0]
                     : elementAdapter.create(
                     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    elementTypePath, this.value);
+                    elementTypePath, this.context);
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const originalList = accessor.value;
                 const newList = [
@@ -340,7 +346,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.value);
+                const conversion = revert(value, valuePath, this.context);
                 const accessor = this.getAccessorForValuePath(valuePath);
                 return runInAction(() => {
                     this.fieldOverrides[valuePath] = [value];
@@ -378,8 +384,8 @@ let FormModel = (() => {
                     return;
                 }
                 const { convert, create, } = adapter;
-                const value = create(valuePath, this.value);
-                const { value: displayValue, } = convert(value, valuePath, this.value);
+                const value = create(valuePath, this.context);
+                const { value: displayValue, } = convert(value, valuePath, this.context);
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                 const key = valuePath;
                 runInAction(() => {
@@ -407,22 +413,22 @@ let FormModel = (() => {
                 const { value: storedValue, } = convert(accessor != null
                     ? accessor.value
                     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    : create(valuePath, this.value), 
+                    : create(valuePath, this.context), 
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                valuePath, this.value);
+                valuePath, this.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.value), valuePath, this.value);
+                    const { value: defaultDisplayValue, } = convert(create(valuePath, this.context), valuePath, this.context);
                     if (defaultDisplayValue === value) {
                         return true;
                     }
                 }
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                const conversion = revert(value, valuePath, this.value);
+                const conversion = revert(value, valuePath, this.context);
                 return runInAction(() => {
                     switch (conversion.type) {
                         case UnreliableFieldConversionType.Failure:
@@ -462,13 +468,13 @@ let FormModel = (() => {
                             return success;
                         }
                         const fieldOverride = this.fieldOverrides[adapterPath];
-                        const { value: storedValue, } = convert(accessor.value, valuePath, this.value);
+                        const { value: storedValue, } = convert(accessor.value, valuePath, this.context);
                         const value = fieldOverride != null
                             ? fieldOverride[0]
                             : storedValue;
                         // TODO more nuanced comparison
                         const dirty = fieldOverride != null && fieldOverride[0] !== storedValue;
-                        const conversion = revert(value, valuePath, this.value);
+                        const conversion = revert(value, valuePath, this.context);
                         switch (conversion.type) {
                             case UnreliableFieldConversionType.Failure:
                                 this.errors[adapterPath] = conversion.error;
@@ -497,12 +503,14 @@ 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/hooks.d.ts

@@ -1,8 +1,8 @@
 import { type ReadonlyTypeOfType, type ValueOfType } from '@strictly/define';
 import { type FormModel } from './form_model';
 import { type FormFieldsOfModel, type ValuePathsOfModel } from './types';
-type ValueOfModel<M extends FormModel<any, any, any, any>> = M extends FormModel<infer T, any, any, any> ? ValueOfType<ReadonlyTypeOfType<T>> : never;
-export declare function useDefaultMobxFormHooks<M extends FormModel<any, any, any, any>, F extends FormFieldsOfModel<M> = FormFieldsOfModel<M>>(model: M, { onValidFieldSubmit, onValidFormSubmit, }?: {
+type ValueOfModel<M extends FormModel<any, any, any, any, any>> = M extends FormModel<infer T, any, any, any, any> ? ValueOfType<ReadonlyTypeOfType<T>> : never;
+export declare function useDefaultMobxFormHooks<M extends FormModel<any, any, any, any, any>, F extends FormFieldsOfModel<M> = FormFieldsOfModel<M>>(model: M, { onValidFieldSubmit, onValidFormSubmit, }?: {
     onValidFieldSubmit?: <Path extends ValuePathsOfModel<M>>(valuePath: Path) => void;
     onValidFormSubmit?: (value: ValueOfModel<M>) => void;
 }): {

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

@@ -1,7 +1,7 @@
 import { type TwoWayFieldConverter } from 'types/field_converters';
-import { type ErrorOfFieldAdapter, type FieldAdapter, type FromOfFieldAdapter, type ToOfFieldAdapter, type ValuePathOfFieldAdapter } from './field_adapter';
+import { type ContextOfFieldAdapter, type ErrorOfFieldAdapter, type FieldAdapter, type FromOfFieldAdapter, type ToOfFieldAdapter, type ValuePathOfFieldAdapter } from './field_adapter';
 export type MergedOfFieldAdaptersWithTwoWayConverter<FieldAdapters extends Readonly<Record<string, FieldAdapter>>, E, Context> = {
-    [K in keyof FieldAdapters]: FieldAdapter<FromOfFieldAdapter<FieldAdapters[K]>, ToOfFieldAdapter<FieldAdapters[K]>, ErrorOfFieldAdapter<FieldAdapters[K]> | E, ValuePathOfFieldAdapter<FieldAdapters[K]>, Context>;
+    [K in keyof FieldAdapters]: FieldAdapter<FromOfFieldAdapter<FieldAdapters[K]>, ToOfFieldAdapter<FieldAdapters[K]>, ErrorOfFieldAdapter<FieldAdapters[K]> | E, ValuePathOfFieldAdapter<FieldAdapters[K]>, ContextOfFieldAdapter<FieldAdapters[K]> & Context>;
 };
 type ValuePathsOfFieldAdapters<FieldAdapters extends Readonly<Record<string, FieldAdapter>>> = {
     [K in keyof FieldAdapters]: ValuePathOfFieldAdapter<FieldAdapters[K]>;

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

@@ -11,6 +11,13 @@ import { createMockedAdapter, resetMockAdapter, } from './fixtures';
 const IS_NAN_ERROR = 1;
 const originalIntegerToStringAdapter = adapterFromTwoWayConverter(new IntegerToStringConverter(IS_NAN_ERROR), prototypingFieldValueFactory(0));
 const originalBooleanToBooleanAdapter = identityAdapter(false);
+class TestFormModel extends FormModel {
+    toContext() {
+        return {
+            ctx: true,
+        };
+    }
+}
 describe('all', function () {
     const integerToStringAdapter = createMockedAdapter(originalIntegerToStringAdapter);
     const booleanToBooleanAdapter = createMockedAdapter(originalBooleanToBooleanAdapter);
@@ -64,7 +71,7 @@ describe('all', function () {
                 let model;
                 beforeEach(function () {
                     originalValue = 5;
-                    model = new FormModel(typeDef, originalValue, adapters);
+                    model = new TestFormModel(typeDef, originalValue, adapters);
                 });
                 describe('accessors', function () {
                     it('gets the expected value', function () {
@@ -105,7 +112,7 @@ describe('all', function () {
                         readonly: false,
                     });
                     originalValue = 5;
-                    model = new FormModel(typeDef, originalValue, adapters);
+                    model = new TestFormModel(typeDef, originalValue, adapters);
                 });
                 it('reports required status', function () {
                     expect(model.fields).toEqual(expect.objectContaining({
@@ -130,7 +137,7 @@ describe('all', function () {
                     4,
                     17,
                 ];
-                model = new FormModel(typeDef, value, adapters);
+                model = new TestFormModel(typeDef, value, adapters);
             });
             describe('accessors', function () {
                 it.each([
@@ -192,7 +199,7 @@ describe('all', function () {
                     a: 1,
                     b: 2,
                 };
-                model = new FormModel(typeDef, value, converters);
+                model = new TestFormModel(typeDef, value, converters);
             });
             describe('accessors', function () {
                 it.each([
@@ -243,7 +250,7 @@ describe('all', function () {
                     a: 1,
                     b: true,
                 };
-                model = new FormModel(typeDef, value, converters);
+                model = new TestFormModel(typeDef, value, converters);
             });
             describe('accessors', function () {
                 it.each([
@@ -289,7 +296,7 @@ describe('all', function () {
             const originalValue = 2;
             let model;
             beforeEach(function () {
-                model = new FormModel(typeDef, originalValue, adapters);
+                model = new TestFormModel(typeDef, originalValue, adapters);
             });
             describe('setFieldValueAndValidate', function () {
                 describe('success', function () {
@@ -391,7 +398,7 @@ describe('all', function () {
                     3,
                     7,
                 ];
-                model = new FormModel(typeDef, originalValue, converters);
+                model = new TestFormModel(typeDef, originalValue, converters);
             });
             describe('setFieldValueAndValidate', function () {
                 describe('success', function () {
@@ -486,7 +493,7 @@ describe('all', function () {
                 let contextCopy;
                 beforeEach(function () {
                     integerToStringAdapter.revert.mockImplementationOnce(function (_value, _path, context) {
-                        contextCopy = [...context];
+                        contextCopy = Object.assign({}, context);
                         return {
                             type: UnreliableFieldConversionType.Success,
                             value: 1,
@@ -496,16 +503,14 @@ describe('all', function () {
                 it('supplies the full, previous context when converting', function () {
                     model.setFieldValueAndValidate('$.2', '4');
                     expect(integerToStringAdapter.revert).toHaveBeenCalledOnce();
-                    expect(integerToStringAdapter.revert).toHaveBeenCalledWith('4', '$.2', 
-                    // uses the same pointer
-                    model.value);
+                    expect(integerToStringAdapter.revert).toHaveBeenCalledWith('4', '$.2', {
+                        ctx: true,
+                    });
                 });
-                it('supplies the context as it is at the time call', function () {
-                    expect(contextCopy).toEqual([
-                        1,
-                        3,
-                        7,
-                    ]);
+                it('supplies the context', function () {
+                    expect(contextCopy).toEqual({
+                        ctx: true,
+                    });
                 });
             });
             describe('addListItem', function () {
@@ -682,7 +687,7 @@ describe('all', function () {
                 let model;
                 beforeEach(function () {
                     originalValue = null;
-                    model = new FormModel(type, originalValue, adapters);
+                    model = new TestFormModel(type, originalValue, adapters);
                 });
                 it('has the expected fields', function () {
                     expect(model.fields).toEqual({
@@ -727,7 +732,7 @@ describe('all', function () {
                 };
                 describe('isValuePathActive', function () {
                     describe('discriminator x', function () {
-                        const model = new FormModel(type, {
+                        const model = new TestFormModel(type, {
                             d: 'x',
                             a: 1,
                         }, adapters);
@@ -750,7 +755,7 @@ describe('all', function () {
                         });
                     });
                     describe('discriminator y', function () {
-                        const model = new FormModel(type, {
+                        const model = new TestFormModel(type, {
                             d: 'y',
                             b: false,
                         }, adapters);
@@ -785,7 +790,7 @@ describe('all', function () {
             let model;
             beforeEach(function () {
                 originalValue = 1;
-                model = new FormModel(typeDef, originalValue, converters);
+                model = new TestFormModel(typeDef, originalValue, converters);
             });
             it('returns the default value for the fake field', function () {
                 expect(model.fields['$.fake']).toEqual(expect.objectContaining({

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

@@ -1,10 +1,9 @@
-import { list, numberType, object, stringType, } from '@strictly/define';
 import { subFormFieldAdapters, } from 'core/mobx/sub_form_field_adapters';
 import { UnreliableFieldConversionType } from 'types/field_converters';
 import { mockDeep, mockReset, } from 'vitest-mock-extended';
 describe('subFormFieldAdapters', () => {
     describe('empty value', () => {
-        const adapters = subFormFieldAdapters({}, '$.a', stringType);
+        const adapters = subFormFieldAdapters({}, '$.a');
         it('equals expected type', () => {
             expectTypeOf(adapters).toEqualTypeOf();
         });
@@ -15,11 +14,10 @@ describe('subFormFieldAdapters', () => {
     describe('single adapter', () => {
         const mockedFieldAdapter1 = mockDeep();
         const fieldAdapter1 = mockedFieldAdapter1;
-        const type = object().field('a', stringType);
         const subAdapters = {
             $: fieldAdapter1,
         };
-        const adapters = subFormFieldAdapters(subAdapters, '$.a', type);
+        const adapters = subFormFieldAdapters(subAdapters, '$.a');
         beforeEach(() => {
             mockReset(mockedFieldAdapter1);
         });
@@ -38,7 +36,7 @@ describe('subFormFieldAdapters', () => {
                 readonly: false,
             };
             mockedFieldAdapter1.convert.mockReturnValue(mockedReturnedValue);
-            const returnedValue = adapters['$.a'].convert('x', '$.a', { a: 'y' });
+            const returnedValue = adapters['$.a'].convert('x', '$.a', 'y');
             expect(fieldAdapter1.convert).toHaveBeenCalledWith('x', '$', 'y');
             expect(returnedValue).toEqual(mockedReturnedValue);
         });
@@ -49,14 +47,14 @@ describe('subFormFieldAdapters', () => {
                 value: 'ok',
             };
             mockedFieldAdapter1.revert.mockReturnValue(mockedReturnedValue);
-            const returnedValue = (_b = (_a = adapters['$.a']).revert) === null || _b === void 0 ? void 0 : _b.call(_a, true, '$.a', { a: 'y' });
+            const returnedValue = (_b = (_a = adapters['$.a']).revert) === null || _b === void 0 ? void 0 : _b.call(_a, true, '$.a', 'y');
             expect(fieldAdapter1.revert).toHaveBeenCalledWith(true, '$', 'y');
             expect(returnedValue).toEqual(mockedReturnedValue);
         });
         it('calls create with the correct paths and values', () => {
             const mockedReturnedValue = 'x';
             mockedFieldAdapter1.create.mockReturnValue(mockedReturnedValue);
-            const returnedValue = adapters['$.a'].create('$.a', { a: 'y' });
+            const returnedValue = adapters['$.a'].create('$.a', 'y');
             expect(fieldAdapter1.create).toHaveBeenCalledWith('$', 'y');
             expect(returnedValue).toEqual(mockedReturnedValue);
         });
@@ -66,12 +64,10 @@ describe('subFormFieldAdapters', () => {
         const fieldAdapter1 = mockedFieldAdapter1;
         const mockedFieldAdapter2 = mockDeep();
         const fieldAdapter2 = mockedFieldAdapter2;
-        const type = object()
-            .field('a', object().field('x', stringType).field('y', numberType));
         const adapters = subFormFieldAdapters({
             '$.x': fieldAdapter1,
             '$.y': fieldAdapter2,
-        }, '$.a', type);
+        }, '$.a');
         beforeEach(() => {
             mockReset(mockedFieldAdapter1);
             mockReset(mockedFieldAdapter2);
@@ -87,12 +83,11 @@ describe('subFormFieldAdapters', () => {
             });
         });
         describe('calls convert with correct paths and values', () => {
-            const subContext = {
-                x: 'a',
-                y: 1,
-            };
             const context = {
-                a: subContext,
+                a: {
+                    x: 'a',
+                    y: 1,
+                },
             };
             it('calls $.a.x', () => {
                 const mockedReturnedValue = {
@@ -102,7 +97,7 @@ describe('subFormFieldAdapters', () => {
                 };
                 mockedFieldAdapter1.convert.mockReturnValue(mockedReturnedValue);
                 const returnedValue = adapters['$.a.x'].convert('b', '$.a.x', context);
-                expect(fieldAdapter1.convert).toHaveBeenCalledWith('b', '$.x', subContext);
+                expect(fieldAdapter1.convert).toHaveBeenCalledWith('b', '$.x', context);
                 expect(returnedValue).toEqual(mockedReturnedValue);
             });
             it('calls $.a.y', () => {
@@ -113,7 +108,7 @@ describe('subFormFieldAdapters', () => {
                 };
                 mockedFieldAdapter2.convert.mockReturnValue(mockedReturnedValue);
                 const returnedValue = adapters['$.a.y'].convert(2, '$.a.y', context);
-                expect(fieldAdapter2.convert).toHaveBeenCalledWith(2, '$.y', subContext);
+                expect(fieldAdapter2.convert).toHaveBeenCalledWith(2, '$.y', context);
                 expect(returnedValue).toEqual(mockedReturnedValue);
             });
         });
@@ -121,11 +116,10 @@ describe('subFormFieldAdapters', () => {
     describe('list adapter', () => {
         const mockedFieldAdapter1 = mockDeep();
         const fieldAdapter1 = mockedFieldAdapter1;
-        const type = list(stringType);
         const subAdapters = {
             $: fieldAdapter1,
         };
-        const adapters = subFormFieldAdapters(subAdapters, '$.*', type);
+        const adapters = subFormFieldAdapters(subAdapters, '$.*');
         beforeEach(() => {
             mockReset(mockedFieldAdapter1);
         });
@@ -140,7 +134,6 @@ describe('subFormFieldAdapters', () => {
         });
         describe('calls convert with correct paths and values', () => {
             const subContext = 'a';
-            const context = [subContext];
             it('calls $.*', () => {
                 const mockedReturnedValue = {
                     value: false,
@@ -148,7 +141,7 @@ describe('subFormFieldAdapters', () => {
                     required: false,
                 };
                 mockedFieldAdapter1.convert.mockReturnValue(mockedReturnedValue);
-                const returnedValue = adapters['$.*'].convert('b', '$.0', context);
+                const returnedValue = adapters['$.*'].convert('b', '$.0', subContext);
                 expect(fieldAdapter1.convert).toHaveBeenCalledWith('b', '$', subContext);
                 expect(returnedValue).toEqual(mockedReturnedValue);
             });

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

@@ -1,9 +1,8 @@
 import { type StringConcatOf } from '@strictly/base';
-import { type ReadonlyTypeOfType, type Type, type ValueOfType } from '@strictly/define';
-import { type ErrorOfFieldAdapter, type FieldAdapter, type FromOfFieldAdapter, type ToOfFieldAdapter, type ValuePathOfFieldAdapter } from './field_adapter';
-type SubFormFieldAdapter<F extends FieldAdapter, ValuePath extends string, Context> = FieldAdapter<FromOfFieldAdapter<F>, ToOfFieldAdapter<F>, ErrorOfFieldAdapter<F>, ValuePathOfFieldAdapter<F> extends StringConcatOf<'$', infer ValuePathSuffix> ? `${ValuePath}${ValuePathSuffix}` : string, Context>;
-type SubFormFieldAdapters<SubAdapters extends Record<string, FieldAdapter>, TypePath extends string, ValuePath extends string, Context> = {
-    [K in keyof SubAdapters as K extends StringConcatOf<'$', infer TypePathSuffix> ? `${TypePath}${TypePathSuffix}` : never]: SubFormFieldAdapter<SubAdapters[K], ValuePath, Context>;
+import { type ContextOfFieldAdapter, type ErrorOfFieldAdapter, type FieldAdapter, type FromOfFieldAdapter, type ToOfFieldAdapter, type ValuePathOfFieldAdapter } from './field_adapter';
+type SubFormFieldAdapter<F extends FieldAdapter, ValuePath extends string> = FieldAdapter<FromOfFieldAdapter<F>, ToOfFieldAdapter<F>, ErrorOfFieldAdapter<F>, ValuePathOfFieldAdapter<F> extends StringConcatOf<'$', infer ValuePathSuffix> ? `${ValuePath}${ValuePathSuffix}` : string, ContextOfFieldAdapter<F>>;
+type SubFormFieldAdapters<SubAdapters extends Record<string, FieldAdapter>, TypePath extends string, ValuePath extends string> = {
+    [K in keyof SubAdapters as K extends StringConcatOf<'$', infer TypePathSuffix> ? `${TypePath}${TypePathSuffix}` : never]: SubFormFieldAdapter<SubAdapters[K], ValuePath>;
 };
-export declare function subFormFieldAdapters<SubAdapters extends Record<string, FieldAdapter>, TypePath extends string, TypePathsToValuePaths extends Record<TypePath, string>, ContextType extends Type>(subAdapters: SubAdapters, parentTypePath: TypePath, contextType: ContextType): SubFormFieldAdapters<SubAdapters, TypePath, TypePathsToValuePaths[TypePath], ValueOfType<ReadonlyTypeOfType<ContextType>>>;
+export declare function subFormFieldAdapters<SubAdapters extends Record<string, FieldAdapter>, TypePath extends string, TypePathsToValuePaths extends Record<TypePath, string>>(subAdapters: SubAdapters, parentTypePath: TypePath): SubFormFieldAdapters<SubAdapters, TypePath, TypePathsToValuePaths[TypePath]>;
 export {};

package/.out/core/mobx/sub_form_field_adapters.js

@@ -1,15 +1,10 @@
-import { flattenValuesOfType, } from '@strictly/define';
-export function subFormFieldAdapters(subAdapters, parentTypePath, contextType) {
+export function subFormFieldAdapters(subAdapters, parentTypePath) {
     // assume the number of '.' in the type path will correspond to the number of '.' in the value path
     const dotCount = parentTypePath.split('.').length;
-    function getSubValuePathAndContext(valuePath, context) {
+    function getSubValuePath(valuePath) {
         const parentValuePath = valuePath.split('.').slice(0, dotCount).join('.');
         const subValuePath = valuePath.replace(parentValuePath, '$');
-        const subContext = flattenValuesOfType(contextType, context)[parentValuePath];
-        return [
-            subValuePath,
-            subContext,
-        ];
+        return subValuePath;
     }
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return Object.entries(subAdapters).reduce((acc, [subTypePath, subAdapter,]) => {
@@ -17,13 +12,13 @@ export function subFormFieldAdapters(subAdapters, parentTypePath, contextType) {
         // adapt field adapter with new path and context
         const adaptedAdapter = {
             convert: (from, valuePath, context) => {
-                return subAdapter.convert(from, ...getSubValuePathAndContext(valuePath, context));
+                return subAdapter.convert(from, getSubValuePath(valuePath), context);
             },
             create: (valuePath, context) => {
-                return subAdapter.create(...getSubValuePathAndContext(valuePath, context));
+                return subAdapter.create(getSubValuePath(valuePath), context);
             },
             revert: subAdapter.revert && ((from, valuePath, context) => {
-                return subAdapter.revert(from, ...getSubValuePathAndContext(valuePath, context));
+                return subAdapter.revert(from, getSubValuePath(valuePath), context);
             }),
         };
         acc[typePath] = adaptedAdapter;

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

@@ -3,12 +3,12 @@ import { type FlattenedConvertedFieldsOf, type FormModel } from './form_model';
 /**
  * Used to extract the supported value paths from a presenter
  */
-export type ValuePathsOfModel<Presenter extends FormModel<any, any, any, any>> = Presenter extends FormModel<infer _1, infer _2, infer _3, infer ValuePathsToAdapters> ? keyof ValuePathsToAdapters : never;
+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
  */
-export type ToValueOfModelValuePath<Presenter extends FormModel<any, any, any, any>, K extends ValuePathsOfModel<Presenter>> = Presenter extends FormModel<infer _1, infer _2, infer _3, infer ValuePathsToAdapters> ? ToOfFieldAdapter<ValuePathsToAdapters[K]> : never;
+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
  * define the form fields explicitly and use that type to enforce the types
@@ -16,4 +16,4 @@ export type ToValueOfModelValuePath<Presenter extends FormModel<any, any, any, a
  * is less typing, albeit at the cost of potentially getting type errors
  * reported a long way away from the source
  */
-export type FormFieldsOfModel<Presenter extends FormModel<any, any, any, any>> = Presenter extends FormModel<infer _1, infer _2, infer _3, infer ValuePathsToAdapters> ? FlattenedConvertedFieldsOf<ValuePathsToAdapters> : never;
+export type FormFieldsOfModel<Model extends FormModel<any, any, any, any, any>> = Model extends FormModel<infer _1, infer _2, infer _3, infer _4, infer ValuePathsToAdapters> ? FlattenedConvertedFieldsOf<ValuePathsToAdapters> : never;

package/.out/index.d.ts

@@ -17,9 +17,11 @@ 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';
 export * from './types/field_converters';
 export * from './types/merge_validators';
+export * from './util/empty';
 export * from './util/partial';

package/.out/index.js

@@ -17,9 +17,11 @@ 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';
 export * from './types/field_converters';
 export * from './types/merge_validators';
+export * from './util/empty';
 export * from './util/partial';

package/.out/mantine/field_view.d.ts

@@ -0,0 +1,18 @@
+import { type ComponentType } from 'react';
+import { type ErrorOfField } from 'types/error_of_field';
+import { type Fields } from 'types/field';
+import { type ValueTypeOfField } from 'types/value_type_of_field';
+/**
+ * Displays current value and error of a field
+ */
+export declare function FieldView<F extends Fields, K extends keyof F>({ fields, valuePath, children, }: {
+    fields: F;
+    valuePath: K;
+    children: (props: {
+        value: ValueTypeOfField<F[K]>;
+        error: ErrorOfField<F[K]> | undefined;
+        ErrorSink: ComponentType<{
+            error: ErrorOfField<F[K]>;
+        }>;
+    }) => JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;

package/.out/mantine/field_view.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Observer } from 'mobx-react';
+import { Empty } from 'util/empty';
+/**
+ * Displays current value and error of a field
+ */
+export function FieldView({ fields, valuePath, children, }) {
+    return (_jsx(Observer, { children: () => {
+            const { value, error, } = fields[valuePath];
+            return children({
+                value,
+                error,
+                ErrorSink: Empty,
+            });
+        } }));
+}