@strictly/react-form 0.0.1 → 0.0.3

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

@@ -0,0 +1,20 @@
+import { mock, mockReset, } from 'vitest-mock-extended';
+export function createMockedAdapter(_original) {
+    return mock();
+}
+export function resetMockAdapter({ convert, revert, create, }, mockedAdapter) {
+    mockReset(mockedAdapter);
+    if (revert) {
+        mockedAdapter.revert?.mockImplementation(revert);
+    }
+    mockedAdapter.convert.mockImplementation(convert);
+    mockedAdapter.create.mockImplementation(create);
+}
+export function createMockTwoWayFieldConverter(_original) {
+    return mock();
+}
+export function resetMockTwoWayFieldConverter({ convert, revert, }, mockedConverter) {
+    mockReset(mockedConverter);
+    mockedConverter.convert.mockImplementation(convert);
+    mockedConverter.revert.mockImplementation(revert);
+}

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

@@ -1,12 +1,15 @@
 const error = Symbol();
-describe('FlattenedAdaptersOfFIelds', function () {
+describe('FlattenedAdaptersOfFields', function () {
     it('maps the converter types', function () {
         expectTypeOf().toEqualTypeOf();
     });
     it('ignores extraneous types not listed in the fields', function () {
         expectTypeOf().toEqualTypeOf();
     });
-    it('handles multiple fields fields', function () {
+    it('handles multiple fields', function () {
+        expectTypeOf().toEqualTypeOf();
+    });
+    it('allows synthesized fields', function () {
         expectTypeOf().toEqualTypeOf();
     });
 });

package/.out/core/mobx/specs/{flattened_list_type_defs_of.tests.js → flattened_list_types_of_types.tests.js}

@@ -1,16 +1,16 @@
 import { list, nullType, numberType, object, record, stringType, union, } from '@strictly/define';
-describe('FlattenedListTypeDefsOf', function () {
+describe('FlattenedListTypesOfType', function () {
     it('filters lists types', function () {
         const listTypeDef = list(numberType);
         const recordTypeDef = record(stringType);
         const objectTypeDef = object();
-        const unionTypeDef = union().add('0', numberType).add('1', nullType);
+        const unionTypeDef = union().or('0', numberType).or('1', nullType);
         const typeDef = object()
-            .set('literal', numberType)
-            .set('list', listTypeDef)
-            .set('record', recordTypeDef)
-            .set('object', objectTypeDef)
-            .set('union', unionTypeDef);
+            .field('literal', numberType)
+            .field('list', listTypeDef)
+            .field('record', recordTypeDef)
+            .field('object', objectTypeDef)
+            .field('union', unionTypeDef);
         expectTypeOf().toEqualTypeOf();
     });
 });

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

@@ -4,25 +4,19 @@ import { adapterFromTwoWayConverter, identityAdapter, } from 'core/mobx/field_ad
 import { FormModel, FormPresenter, } from 'core/mobx/form_presenter';
 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';
 import { prototypingFieldValueFactory } from 'field_value_factories/prototyping_field_value_factory';
-import { FieldConversionResult, } from 'types/field_converters';
-import { mock, mockClear, } from 'vitest-mock-extended';
+import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { createMockedAdapter, resetMockAdapter, } from './fixtures';
 const IS_NAN_ERROR = 1;
-function createMockedAdapter({ convert, revert, create, }) {
-    const mockedAdapter = mock();
-    if (revert) {
-        mockedAdapter.revert?.mockImplementation(revert);
-    }
-    mockedAdapter.convert.mockImplementation(convert);
-    mockedAdapter.create.mockImplementation(create);
-    return mockedAdapter;
-}
+const originalIntegerToStringAdapter = adapterFromTwoWayConverter(new IntegerToStringConverter(IS_NAN_ERROR), prototypingFieldValueFactory(0));
+const originalBooleanToBooleanAdapter = identityAdapter(false);
 describe('all', function () {
-    const integerToStringAdapter = createMockedAdapter(adapterFromTwoWayConverter(new IntegerToStringConverter(IS_NAN_ERROR), prototypingFieldValueFactory(0)));
-    const booleanToBooleanAdapter = createMockedAdapter(identityAdapter(false));
+    const integerToStringAdapter = createMockedAdapter(originalIntegerToStringAdapter);
+    const booleanToBooleanAdapter = createMockedAdapter(originalBooleanToBooleanAdapter);
     beforeEach(function () {
-        mockClear(integerToStringAdapter);
-        mockClear(booleanToBooleanAdapter);
+        resetMockAdapter(originalIntegerToStringAdapter, integerToStringAdapter);
+        resetMockAdapter(originalBooleanToBooleanAdapter, booleanToBooleanAdapter);
     });
     describe('FlattenedTypePathsToConvertersOf', function () {
         describe('record', function () {
@@ -34,8 +28,8 @@ describe('all', function () {
         });
         describe('object', function () {
             const typeDef = object()
-                .set('x', stringType)
-                .set('y', booleanType);
+                .field('x', stringType)
+                .field('y', booleanType);
             let t;
             it('equals expected type', function () {
                 expectTypeOf(t).toEqualTypeOf();
@@ -64,39 +58,66 @@ describe('all', function () {
     });
     describe('FormModel', function () {
         describe('literal', function () {
-            const typeDef = numberType;
-            const adapters = {
-                $: integerToStringAdapter,
-            };
-            let originalValue;
-            let model;
-            beforeEach(function () {
-                originalValue = 5;
-                model = new FormModel(typeDef, originalValue, adapters);
-            });
-            describe('accessors', function () {
-                it('gets the expected value', function () {
-                    const accessor = expectDefinedAndReturn(model.accessors.$);
-                    expect(accessor.value).toEqual(originalValue);
+            describe('optional', function () {
+                const typeDef = numberType;
+                const adapters = {
+                    $: integerToStringAdapter,
+                };
+                let originalValue;
+                let model;
+                beforeEach(function () {
+                    originalValue = 5;
+                    model = new FormModel(typeDef, originalValue, adapters);
                 });
-                it('sets the underlying value', function () {
-                    const newValue = 1;
-                    const accessor = expectDefinedAndReturn(model.accessors.$);
-                    accessor.set(newValue);
-                    expect(model.value).toEqual(newValue);
+                describe('accessors', function () {
+                    it('gets the expected value', function () {
+                        const accessor = expectDefinedAndReturn(model.accessors.$);
+                        expect(accessor.value).toEqual(originalValue);
+                    });
+                    it('sets the underlying value', function () {
+                        const newValue = 1;
+                        const accessor = expectDefinedAndReturn(model.accessors.$);
+                        accessor.set(newValue);
+                        expect(model.value).toEqual(newValue);
+                    });
+                });
+                describe('fields', function () {
+                    it('equals expected value', function () {
+                        expect(model.fields).toEqual(expect.objectContaining({
+                            $: expect.objectContaining({
+                                value: '5',
+                            }),
+                        }));
+                    });
+                    it('has the expected keys', function () {
+                        expect(Object.keys(model.fields)).toEqual(['$']);
+                    });
                 });
             });
-            describe('fields', function () {
-                it('equals expected value', function () {
+            describe('required', function () {
+                const typeDef = numberType;
+                const adapters = {
+                    $: integerToStringAdapter,
+                };
+                let originalValue;
+                let model;
+                beforeEach(function () {
+                    integerToStringAdapter.convert.mockReturnValue({
+                        value: 'x',
+                        required: true,
+                        readonly: false,
+                    });
+                    originalValue = 5;
+                    model = new FormModel(typeDef, originalValue, adapters);
+                });
+                it('reports required status', function () {
                     expect(model.fields).toEqual(expect.objectContaining({
                         $: expect.objectContaining({
-                            value: '5',
+                            value: 'x',
+                            required: true,
                         }),
                     }));
                 });
-                it('has the expected keys', function () {
-                    expect(Object.keys(model.fields)).toEqual(['$']);
-                });
             });
         });
         describe('list', function () {
@@ -142,6 +163,24 @@ describe('all', function () {
                     ]);
                 });
             });
+            describe('fields', function () {
+                it('equals the expected value', function () {
+                    expect(model.fields).toEqual(expect.objectContaining({
+                        '$.0': expect.objectContaining({
+                            value: '1',
+                            required: false,
+                        }),
+                        '$.1': expect.objectContaining({
+                            value: '4',
+                            required: false,
+                        }),
+                        '$.2': expect.objectContaining({
+                            value: '17',
+                            required: false,
+                        }),
+                    }));
+                });
+            });
         });
         describe('record', function () {
             const typeDef = record(numberType);
@@ -194,8 +233,8 @@ describe('all', function () {
         });
         describe('object', function () {
             const typeDef = object()
-                .set('a', numberType)
-                .set('b', booleanType);
+                .field('a', numberType)
+                .field('b', booleanType);
             const converters = {
                 '$.a': integerToStringAdapter,
                 '$.b': booleanToBooleanAdapter,
@@ -268,7 +307,6 @@ describe('all', function () {
                         expect(model.fields).toEqual(expect.objectContaining({
                             $: expect.objectContaining({
                                 value: '1',
-                                // eslint-disable-next-line no-undefined
                                 error: undefined,
                             }),
                         }));
@@ -296,7 +334,7 @@ describe('all', function () {
                         const errorCode = 65;
                         beforeEach(function () {
                             integerToStringAdapter.revert?.mockReturnValueOnce({
-                                type: FieldConversionResult.Failure,
+                                type: UnreliableFieldConversionType.Failure,
                                 error: errorCode,
                                 value: [newValue],
                             });
@@ -310,7 +348,7 @@ describe('all', function () {
                                 $: expect.objectContaining({
                                     value: '-1',
                                     error: errorCode,
-                                    disabled: false,
+                                    readonly: false,
                                 }),
                             });
                         });
@@ -337,7 +375,6 @@ describe('all', function () {
                     expect(model.fields).toEqual(expect.objectContaining({
                         $: expect.objectContaining({
                             value: newValue,
-                            // eslint-disable-next-line no-undefined
                             error: undefined,
                         }),
                     }));
@@ -376,7 +413,6 @@ describe('all', function () {
                         expect(model.fields).toEqual(expect.objectContaining({
                             '$.0': expect.objectContaining({
                                 value: '100',
-                                // eslint-disable-next-line no-undefined
                                 error: undefined,
                             }),
                         }));
@@ -413,7 +449,6 @@ describe('all', function () {
                     expect(model.fields).toEqual(expect.objectContaining({
                         '$.0': expect.objectContaining({
                             value: newValue,
-                            // eslint-disable-next-line no-undefined
                             error: undefined,
                         }),
                     }));
@@ -434,7 +469,6 @@ describe('all', function () {
                         }),
                         '$.1': expect.objectContaining({
                             value: '2',
-                            // eslint-disable-next-line no-undefined
                             error: undefined,
                         }),
                         '$.2': expect.objectContaining({
@@ -458,7 +492,7 @@ describe('all', function () {
                     integerToStringAdapter.revert.mockImplementationOnce(function (_value, _path, context) {
                         contextCopy = [...context];
                         return {
-                            type: FieldConversionResult.Success,
+                            type: UnreliableFieldConversionType.Success,
                             value: 1,
                         };
                     });
@@ -517,7 +551,6 @@ describe('all', function () {
                     it.each([
                         [
                             '$.0',
-                            // eslint-disable-next-line no-undefined
                             undefined,
                         ],
                         [
@@ -624,14 +657,14 @@ describe('all', function () {
         describe('union', function () {
             describe('non-discriminated', function () {
                 const listOfNumbersTypeDef = list(numberType);
-                const typeDef = union()
-                    .add('null', nullType)
-                    .add('0', listOfNumbersTypeDef);
+                const type = union()
+                    .or('null', nullType)
+                    .or('0', listOfNumbersTypeDef);
                 const adapters = {
-                    $: adapterFromTwoWayConverter(new NullableToBooleanConverter(typeDef, [1])),
+                    $: adapterFromTwoWayConverter(new NullableToBooleanConverter(type, [1], null)),
                     '$.*': integerToStringAdapter,
                 };
-                const presenter = new FormPresenter(typeDef, adapters);
+                const presenter = new FormPresenter(type, adapters);
                 let originalValue;
                 let model;
                 beforeEach(function () {
@@ -641,8 +674,7 @@ describe('all', function () {
                 it('has the expected fields', function () {
                     expect(model.fields).toEqual({
                         $: {
-                            disabled: false,
-                            // eslint-disable-next-line no-undefined
+                            readonly: false,
                             error: undefined,
                             value: false,
                             required: false,
@@ -660,6 +692,76 @@ describe('all', function () {
                     });
                 });
             });
+            describe('discriminated', function () {
+                const struct1 = object().field('a', numberType);
+                const struct2 = object().field('b', booleanType);
+                const type = union('d')
+                    .or('x', struct1)
+                    .or('y', struct2);
+                const adapters = {
+                    $: adapterFromTwoWayConverter(new SelectDiscriminatedUnionConverter(type, {
+                        x: {
+                            d: 'x',
+                            a: 0,
+                        },
+                        y: {
+                            d: 'y',
+                            b: false,
+                        },
+                    }, 'x', true)).narrow,
+                    '$.x:a': identityAdapter(0).narrow,
+                    '$.y:b': identityAdapter(false).narrow,
+                };
+                const presenter = new FormPresenter(type, adapters);
+                describe('isValuePathActive', function () {
+                    describe('discriminator x', function () {
+                        const model = presenter.createModel({
+                            d: 'x',
+                            a: 1,
+                        });
+                        it.each([
+                            [
+                                '$',
+                                true,
+                            ],
+                            [
+                                '$.x:a',
+                                true,
+                            ],
+                            [
+                                '$.y:b',
+                                false,
+                            ],
+                        ])('value path %s is active %s', function (path, expected) {
+                            const isValid = presenter.isValuePathActive(model, path);
+                            expect(isValid).toBe(expected);
+                        });
+                    });
+                    describe('discriminator y', function () {
+                        const model = presenter.createModel({
+                            d: 'y',
+                            b: false,
+                        });
+                        it.each([
+                            [
+                                '$',
+                                true,
+                            ],
+                            [
+                                '$.x:a',
+                                false,
+                            ],
+                            [
+                                '$.y:b',
+                                true,
+                            ],
+                        ])('value path %s is active %s', function (path, expected) {
+                            const isValid = presenter.isValuePathActive(model, path);
+                            expect(isValid).toBe(expected);
+                        });
+                    });
+                });
+            });
         });
         describe('fake', function () {
             const typeDef = numberType;

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

@@ -0,0 +1,89 @@
+import { identityAdapter } from 'core/mobx/field_adapter_builder';
+import { mergeFieldAdaptersWithTwoWayConverter, } from 'core/mobx/merge_field_adapters_with_two_way_converter';
+import { annotatedIdentityConverter, unreliableIdentityConverter, } from 'field_converters/identity_converter';
+import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { createMockedAdapter, createMockTwoWayFieldConverter, resetMockAdapter, resetMockTwoWayFieldConverter, } from './fixtures';
+const error1 = Symbol();
+const error2 = Symbol();
+const error3 = Symbol();
+const error4 = Symbol();
+const context = Symbol();
+describe('MergedOfFieldAdapterWithTwoWayConverter', function () {
+    let m;
+    it('merges the errors', function () {
+        expectTypeOf().toEqualTypeOf(m);
+    });
+});
+const originalIntegerAdapter = identityAdapter(0);
+const originalBooleanAdapter = identityAdapter(false, true);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const originalConverter = {
+    convert: annotatedIdentityConverter(),
+    revert: unreliableIdentityConverter(),
+};
+describe('mergeFieldAdaptersWithTwoWayConverter', function () {
+    const integerAdapter = createMockedAdapter(originalIntegerAdapter);
+    const booleanAdapter = createMockedAdapter(originalBooleanAdapter);
+    beforeEach(function () {
+        resetMockAdapter(originalIntegerAdapter, integerAdapter);
+        resetMockAdapter(originalBooleanAdapter, booleanAdapter);
+    });
+    describe('two entries', function () {
+        const fieldAdapters = {
+            integerAdapter,
+            booleanAdapter,
+        };
+        const converter = createMockTwoWayFieldConverter(originalConverter);
+        beforeEach(function () {
+            resetMockTwoWayFieldConverter(originalConverter, converter);
+        });
+        const merged = mergeFieldAdaptersWithTwoWayConverter(fieldAdapters, converter);
+        describe('convert', function () {
+            let result;
+            describe('success', function () {
+                // note don't really need to exercise this too extensively since most of
+                // the work is done in chainXFieldAdapter
+                beforeEach(function () {
+                    result = merged.booleanAdapter.convert(true, 'booleanAdapter', context);
+                });
+                it('returns the same value on convert', function () {
+                    expect(result).toEqual(expect.objectContaining({
+                        value: true,
+                    }));
+                });
+                it('calls the mocked converter', function () {
+                    expect(converter.convert).toHaveBeenCalledOnce();
+                    expect(converter.convert).toHaveBeenCalledWith(true, 'booleanAdapter', context);
+                });
+                it('calls the mocked adapter', function () {
+                    expect(booleanAdapter.convert).toHaveBeenCalledOnce();
+                    expect(booleanAdapter.convert).toHaveBeenCalledWith(true, 'booleanAdapter', context);
+                });
+            });
+        });
+        describe('revert', function () {
+            let result;
+            describe('success', function () {
+                // note don't really need to exercise this too extensively since most of
+                // the work is done in chainXFieldAdapter
+                beforeEach(function () {
+                    result = merged.booleanAdapter.revert(true, 'booleanAdapter', context);
+                });
+            });
+            it('returns the same value on revert', function () {
+                expect(result).toEqual(expect.objectContaining({
+                    value: true,
+                    type: UnreliableFieldConversionType.Success,
+                }));
+            });
+            it('calls the mocked converter', function () {
+                expect(converter.revert).toHaveBeenCalledOnce();
+                expect(converter.revert).toHaveBeenCalledWith(true, 'booleanAdapter', context);
+            });
+            it('calls the mocked adapter', function () {
+                expect(booleanAdapter.revert).toHaveBeenCalledOnce();
+                expect(booleanAdapter.revert).toHaveBeenCalledWith(true, 'booleanAdapter', context);
+            });
+        });
+    });
+});

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

@@ -0,0 +1,172 @@
+import { expectDefined, expectEquals, } from '@strictly/base';
+import { identityAdapter, } from 'core/mobx/field_adapter_builder';
+import { mergeAdaptersWithValidators, } from 'core/mobx/merge_field_adapters_with_validators';
+import { UnreliableFieldConversionType } from 'types/field_converters';
+import { createMockedAdapter, resetMockAdapter, } from './fixtures';
+const error1 = 'error 1';
+const error2 = 'error 2';
+const context = 'context 1';
+describe('MergedOfFieldAdaptersWithValidators', function () {
+    describe('empty validators', function () {
+        it('does not change the adapters', function () {
+            expectTypeOf().toEqualTypeOf();
+        });
+    });
+    describe('different errors', function () {
+        it('merges the error types', function () {
+            expectTypeOf().toEqualTypeOf();
+        });
+    });
+    describe('different paths', function () {
+        it('merges the error types', function () {
+            expectTypeOf().toEqualTypeOf();
+        });
+    });
+    describe('different values', function () {
+        it('removes mismatched values', function () {
+            expectTypeOf().toEqualTypeOf();
+        });
+    });
+});
+const originalIntegerToIntegerAdapter = identityAdapter(0);
+const originalBooleanToBooleanAdapter = identityAdapter(false, true);
+describe('mergeFieldAdaptersWithValidators', function () {
+    const integerToIntegerAdapter = createMockedAdapter(originalIntegerToIntegerAdapter);
+    const booleanToBooleanAdapter = createMockedAdapter(originalBooleanToBooleanAdapter);
+    const failingValidator1 = vi.fn(function () {
+        return 'fail 1';
+    });
+    const failingValidator2 = vi.fn(function () {
+        return 'fail 2';
+    });
+    const requiredValidator = {
+        validate: () => null,
+        annotations: () => ({
+            required: true,
+            readonly: false,
+        }),
+    };
+    const readonlyValidator = {
+        validate: () => null,
+        annotations: () => ({
+            required: false,
+            readonly: true,
+        }),
+    };
+    beforeEach(function () {
+        resetMockAdapter(originalIntegerToIntegerAdapter, integerToIntegerAdapter);
+        resetMockAdapter(originalBooleanToBooleanAdapter, booleanToBooleanAdapter);
+        failingValidator1.mockClear();
+        failingValidator2.mockClear();
+    });
+    describe('record contents', function () {
+        describe('empty validators', function () {
+            const adapters = {
+                a: integerToIntegerAdapter,
+                b: booleanToBooleanAdapter,
+            };
+            const validators = {};
+            const merged = mergeAdaptersWithValidators(adapters, validators);
+            it('does not change the adapters', function () {
+                expect(merged).toEqual(adapters);
+            });
+        });
+        describe('populated validators', function () {
+            const adapters = {
+                a: integerToIntegerAdapter,
+                b: booleanToBooleanAdapter,
+                c: integerToIntegerAdapter,
+                d: integerToIntegerAdapter,
+            };
+            const validators = {
+                a: failingValidator1,
+                b: failingValidator2,
+                c: requiredValidator,
+                d: readonlyValidator,
+            };
+            const merged = mergeAdaptersWithValidators(adapters, validators);
+            describe('matching validators', function () {
+                it('has the same keys', function () {
+                    expect([...Object.keys(adapters)]).toEqual([
+                        'a',
+                        'b',
+                        'c',
+                        'd',
+                    ]);
+                });
+            });
+            describe('revert', function () {
+                it.each([
+                    [
+                        'a',
+                        'fail 1',
+                        1,
+                    ],
+                    [
+                        'b',
+                        'fail 2',
+                        true,
+                    ],
+                ])('field %s fails with validation %s', function (key, error, value) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const mergedAdapter = merged[key];
+                    expectDefined(mergedAdapter.revert);
+                    const result = mergedAdapter.revert(value, key, null);
+                    expectEquals(result.type, UnreliableFieldConversionType.Failure);
+                    expect(result.error).toEqual(error);
+                });
+                it.each([
+                    [
+                        'c',
+                        1,
+                    ],
+                    [
+                        'd',
+                        true,
+                    ],
+                ])('field %s succeeds with value %s', function (key, value) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const mergedAdapter = merged[key];
+                    expectDefined(mergedAdapter.revert);
+                    const result = mergedAdapter.revert(value, key, null);
+                    expectEquals(result.type, UnreliableFieldConversionType.Success);
+                    expect(result.value).toEqual(value);
+                });
+            });
+            describe('convert', function () {
+                it.each([
+                    [
+                        'a',
+                        false,
+                        false,
+                        1,
+                    ],
+                    [
+                        'b',
+                        true,
+                        false,
+                        true,
+                    ],
+                    [
+                        'c',
+                        true,
+                        false,
+                        2,
+                    ],
+                    [
+                        'd',
+                        false,
+                        true,
+                        3,
+                    ],
+                ])('field %s is required %s and readonly %s', function (key, expectedRequired, expectedReadonly, value) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const adapter = merged[key];
+                    const { required, readonly, } = adapter.convert(value, key, null);
+                    expect(required).toEqual(expectedRequired);
+                    expect(readonly).toEqual(expectedReadonly);
+                });
+            });
+        });
+    });
+});