@strictly/react-form 0.0.6 → 0.0.7

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

@@ -21,18 +21,16 @@ describe('all', function () {
     describe('FlattenedTypePathsToConvertersOf', function () {
         describe('record', function () {
             const typeDef = record(numberType);
-            let t;
             it('equals expected type', function () {
-                expectTypeOf(t).toEqualTypeOf();
+                expectTypeOf().toEqualTypeOf();
             });
         });
         describe('object', function () {
             const typeDef = object()
                 .field('x', stringType)
                 .field('y', booleanType);
-            let t;
             it('equals expected type', function () {
-                expectTypeOf(t).toEqualTypeOf();
+                expectTypeOf().toEqualTypeOf();
             });
             it('matches representative adapters', function () {
                 expectTypeOf().toMatchTypeOf();
@@ -50,9 +48,8 @@ describe('all', function () {
                 '$.b': '$.y',
                 '$.c': '$.z',
             };
-            let t;
             it('equals expected type', function () {
-                expectTypeOf(t).toEqualTypeOf();
+                expectTypeOf().toEqualTypeOf();
             });
         });
     });

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

@@ -9,9 +9,8 @@ const error3 = Symbol();
 const error4 = Symbol();
 const context = Symbol();
 describe('MergedOfFieldAdapterWithTwoWayConverter', function () {
-    let m;
     it('merges the errors', function () {
-        expectTypeOf().toEqualTypeOf(m);
+        expectTypeOf().toEqualTypeOf();
     });
 });
 const originalIntegerAdapter = identityAdapter(0);
@@ -69,20 +68,20 @@ describe('mergeFieldAdaptersWithTwoWayConverter', function () {
                 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);
+                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/sub_form_field_adapters.tests.js

@@ -1,10 +1,14 @@
+import { numberType, object, stringType, } from '@strictly/define';
 import { subFormFieldAdapters, } from 'core/mobx/sub_form_field_adapters';
+import { UnreliableFieldConversionType } from 'types/field_converters';
 import { mockDeep } from 'vitest-mock-extended';
 describe('subFormFieldAdapters', () => {
-    const fieldAdapter1 = mockDeep();
-    const fieldAdapter2 = mockDeep();
+    const mockedFieldAdapter1 = mockDeep();
+    const fieldAdapter1 = mockedFieldAdapter1;
+    const mockedFieldAdapter2 = mockDeep();
+    const fieldAdapter2 = mockedFieldAdapter2;
     describe('empty value', () => {
-        const adapters = subFormFieldAdapters({}, '$.a');
+        const adapters = subFormFieldAdapters({}, '$.a', stringType);
         it('equals expected type', () => {
             expectTypeOf(adapters).toEqualTypeOf();
         });
@@ -13,28 +17,92 @@ describe('subFormFieldAdapters', () => {
         });
     });
     describe('single adapter', () => {
+        const type = object().field('a', stringType);
         const adapters = subFormFieldAdapters({
             $: fieldAdapter1,
-        }, '$.a');
+        }, '$.a', type);
         it('equals expected type', () => {
-            expectTypeOf(adapters).toEqualTypeOf();
+            // TODO toEqualTypeOf (seems to be a TS error)
+            expectTypeOf(adapters).toMatchTypeOf();
         });
         it('equals expected value', () => {
-            expect(adapters).toEqual({ '$.a': fieldAdapter1 });
+            expect(adapters).toEqual({ '$.a': expect.anything() });
+        });
+        it('calls convert with the correct paths and values', () => {
+            const mockedReturnedValue = {
+                value: false,
+                required: false,
+                readonly: false,
+            };
+            mockedFieldAdapter1.convert.mockReturnValue(mockedReturnedValue);
+            const returnedValue = adapters['$.a'].convert('x', '$.a', { a: 'y' });
+            expect(fieldAdapter1.convert).toHaveBeenCalledWith('x', '$', 'y');
+            expect(returnedValue).toEqual(mockedReturnedValue);
+        });
+        it('calls revert with the correct paths and values', () => {
+            const mockedReturnedValue = {
+                type: UnreliableFieldConversionType.Success,
+                value: 'ok',
+            };
+            mockedFieldAdapter1.revert.mockReturnValue(mockedReturnedValue);
+            const returnedValue = adapters['$.a'].revert?.(true, '$.a', { 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' });
+            expect(fieldAdapter1.create).toHaveBeenCalledWith('$', 'y');
+            expect(returnedValue).toEqual(mockedReturnedValue);
         });
     });
     describe('multiple adapters', () => {
+        const type = object()
+            .field('a', object().field('x', stringType).field('y', numberType));
         const adapters = subFormFieldAdapters({
             '$.x': fieldAdapter1,
             '$.y': fieldAdapter2,
-        }, '$.a');
+        }, '$.a', type);
         it('equals expected type', () => {
-            expectTypeOf(adapters).toEqualTypeOf();
+            // TODO toEqualTypeOf (seems to be a TS error)
+            expectTypeOf(adapters).toMatchTypeOf();
         });
         it('equals expected value', () => {
             expect(adapters).toEqual({
-                '$.a.x': fieldAdapter1,
-                '$.a.y': fieldAdapter2,
+                '$.a.x': expect.anything(),
+                '$.a.y': expect.anything(),
+            });
+        });
+        describe('calls convert with correct paths and values', () => {
+            const subContext = {
+                x: 'a',
+                y: 1,
+            };
+            const context = {
+                a: subContext,
+            };
+            it('calls $.a.x', () => {
+                const mockedReturnedValue = {
+                    value: true,
+                    readonly: true,
+                    required: false,
+                };
+                mockedFieldAdapter1.convert.mockReturnValue(mockedReturnedValue);
+                const returnedValue = adapters['$.a.x'].convert('b', '$.a.x', context);
+                expect(fieldAdapter1.convert).toHaveBeenCalledWith('b', '$.x', subContext);
+                expect(returnedValue).toEqual(mockedReturnedValue);
+            });
+            it('calls $.a.y', () => {
+                const mockedReturnedValue = {
+                    value: false,
+                    readonly: false,
+                    required: false,
+                };
+                mockedFieldAdapter2.convert.mockReturnValue(mockedReturnedValue);
+                const returnedValue = adapters['$.a.y'].convert(2, '$.a.y', context);
+                expect(fieldAdapter2.convert).toHaveBeenCalledWith(2, '$.y', subContext);
+                expect(returnedValue).toEqual(mockedReturnedValue);
             });
         });
     });

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

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

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

@@ -1,8 +1,29 @@
-export function subFormFieldAdapters(subAdapters, prefix) {
+import { flattenValuesOfType, } from '@strictly/define';
+export function subFormFieldAdapters(subAdapters, prefix, contextType) {
+    function getSubValuePathAndContext(valuePath, context) {
+        const subValuePath = valuePath.replace(prefix, '$');
+        const subContext = flattenValuesOfType(contextType, context)[prefix];
+        return [
+            subValuePath,
+            subContext,
+        ];
+    }
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return Object.entries(subAdapters).reduce((acc, [subKey, subValue,]) => {
         const key = subKey.replace('$', prefix);
-        acc[key] = subValue;
+        // adapt field adapter with new path and context
+        const adaptedAdapter = {
+            convert: (from, valuePath, context) => {
+                return subValue.convert(from, ...getSubValuePathAndContext(valuePath, context));
+            },
+            create: (valuePath, context) => {
+                return subValue.create(...getSubValuePathAndContext(valuePath, context));
+            },
+            revert: subValue.revert && ((from, valuePath, context) => {
+                return subValue.revert(from, ...getSubValuePathAndContext(valuePath, context));
+            }),
+        };
+        acc[key] = adaptedAdapter;
         return acc;
     }, {});
 }