@strictly/react-form 0.0.1 → 0.0.2

package/core/mobx/specs/form_presenter.tests.ts

@@ -1,7 +1,7 @@
 import { expectDefinedAndReturn } from '@strictly/base'
 import {
   booleanType,
-  type FlattenedValueTypesOf,
+  type FlattenedValuesOfType,
   list,
   nullType,
   numberType,
@@ -9,8 +9,8 @@ import {
   record,
   stringType,
   union,
-  type ValueToTypePathsOf,
-  type ValueTypeOf,
+  type ValueOfType,
+  type ValueToTypePathsOfType,
 } from '@strictly/define'
 import { type FieldAdapter } from 'core/mobx/field_adapter'
 import {
@@ -25,56 +25,38 @@ import {
 } 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 { type Simplify } from 'type-fest'
 import { type Field } from 'types/field'
 import {
-  FieldConversionResult,
+  UnreliableFieldConversionType,
 } from 'types/field_converters'
-import { type Mocked } from 'vitest'
 import {
-  mock,
-  mockClear,
-} from 'vitest-mock-extended'
+  createMockedAdapter,
+  resetMockAdapter,
+} from './fixtures'
 
 const IS_NAN_ERROR = 1
 
-function createMockedAdapter<
-  E,
-  To,
-  From,
-  ValuePath extends string,
->({
-  convert,
-  revert,
-  create,
-}: FieldAdapter<From, To, E, ValuePath>): Mocked<
-  Required<FieldAdapter<From, To, E, ValuePath>>
-> {
-  const mockedAdapter = mock<Required<FieldAdapter<From, To, E, ValuePath>>>()
-  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),
-    ),
+    originalIntegerToStringAdapter,
   )
   const booleanToBooleanAdapter = createMockedAdapter(
-    identityAdapter(false),
+    originalBooleanToBooleanAdapter,
   )
 
   beforeEach(function () {
-    mockClear(integerToStringAdapter)
-    mockClear(booleanToBooleanAdapter)
+    resetMockAdapter(originalIntegerToStringAdapter, integerToStringAdapter)
+    resetMockAdapter(originalBooleanToBooleanAdapter, booleanToBooleanAdapter)
   })
 
   describe('FlattenedTypePathsToConvertersOf', function () {
@@ -99,14 +81,14 @@ describe('all', function () {
       const typeDef = record<typeof numberType, 'a' | 'b'>(numberType)
       type T = Simplify<
         FlattenedTypePathsToAdaptersOf<
-          FlattenedValueTypesOf<typeof typeDef>,
-          ValueTypeOf<typeof typeDef>
+          FlattenedValuesOfType<typeof typeDef>,
+          ValueOfType<typeof typeDef>
         >
       >
       let t: Partial<{
-        readonly $: ConvenientFieldAdapter<Readonly<Record<'a' | 'b', number>>, ValueTypeOf<typeof typeDef>>,
-        readonly ['$.a']: ConvenientFieldAdapter<number, ValueTypeOf<typeof typeDef>>,
-        readonly ['$.b']: ConvenientFieldAdapter<number, ValueTypeOf<typeof typeDef>>,
+        readonly $: ConvenientFieldAdapter<Readonly<Record<'a' | 'b', number>>, ValueOfType<typeof typeDef>>,
+        readonly ['$.a']: ConvenientFieldAdapter<number, ValueOfType<typeof typeDef>>,
+        readonly ['$.b']: ConvenientFieldAdapter<number, ValueOfType<typeof typeDef>>,
       }>
 
       it('equals expected type', function () {
@@ -116,16 +98,16 @@ describe('all', function () {
 
     describe('object', function () {
       const typeDef = object()
-        .set('x', stringType)
-        .set('y', booleanType)
+        .field('x', stringType)
+        .field('y', booleanType)
       type T = FlattenedTypePathsToAdaptersOf<
-        FlattenedValueTypesOf<typeof typeDef>,
-        ValueTypeOf<typeof typeDef>
+        FlattenedValuesOfType<typeof typeDef>,
+        ValueOfType<typeof typeDef>
       >
       let t: Partial<{
-        readonly $: ConvenientFieldAdapter<{ readonly x: string, readonly y: boolean }, ValueTypeOf<typeof typeDef>>,
-        readonly ['$.x']: ConvenientFieldAdapter<string, ValueTypeOf<typeof typeDef>>,
-        readonly ['$.y']: ConvenientFieldAdapter<boolean, ValueTypeOf<typeof typeDef>>,
+        readonly $: ConvenientFieldAdapter<{ readonly x: string, readonly y: boolean }, ValueOfType<typeof typeDef>>,
+        readonly ['$.x']: ConvenientFieldAdapter<string, ValueOfType<typeof typeDef>>,
+        readonly ['$.y']: ConvenientFieldAdapter<boolean, ValueOfType<typeof typeDef>>,
       }>
       it('equals expected type', function () {
         expectTypeOf(t).toEqualTypeOf<T>()
@@ -177,57 +159,100 @@ describe('all', function () {
 
   describe('FormModel', function () {
     describe('literal', function () {
-      const typeDef = numberType
-      const adapters = {
-        $: integerToStringAdapter,
-      } as const
-      let originalValue: ValueTypeOf<typeof typeDef>
-      let model: FormModel<
-        typeof typeDef,
-        ValueToTypePathsOf<typeof typeDef>,
-        typeof adapters
-      >
-      beforeEach(function () {
-        originalValue = 5
-        model = new FormModel<
+      describe('optional', function () {
+        const typeDef = numberType
+        const adapters = {
+          $: integerToStringAdapter,
+        } as const
+        let originalValue: ValueOfType<typeof typeDef>
+        let model: FormModel<
           typeof typeDef,
-          ValueToTypePathsOf<typeof typeDef>,
+          ValueToTypePathsOfType<typeof typeDef>,
           typeof adapters
-        >(
-          typeDef,
-          originalValue,
-          adapters,
-        )
-      })
+        >
+        beforeEach(function () {
+          originalValue = 5
+          model = new FormModel<
+            typeof typeDef,
+            ValueToTypePathsOfType<typeof typeDef>,
+            typeof adapters
+          >(
+            typeDef,
+            originalValue,
+            adapters,
+          )
+        })
 
-      describe('accessors', function () {
-        it('gets the expected value', function () {
-          const accessor = expectDefinedAndReturn(model.accessors.$)
-          expect(accessor.value).toEqual(originalValue)
+        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)
+          })
         })
 
-        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,
+        } as const
+        let originalValue: ValueOfType<typeof typeDef>
+        let model: FormModel<
+          typeof typeDef,
+          ValueToTypePathsOfType<typeof typeDef>,
+          typeof adapters
+        >
+        beforeEach(function () {
+          integerToStringAdapter.convert.mockReturnValue({
+            value: 'x',
+            required: true,
+            readonly: false,
+          })
+          originalValue = 5
+          model = new FormModel<
+            typeof typeDef,
+            ValueToTypePathsOfType<typeof typeDef>,
+            typeof adapters
+          >(
+            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(['$'])
-        })
       })
     })
 
@@ -236,10 +261,10 @@ describe('all', function () {
       const adapters = {
         '$.*': integerToStringAdapter,
       } as const
-      let value: ValueTypeOf<typeof typeDef>
+      let value: ValueOfType<typeof typeDef>
       let model: FormModel<
         typeof typeDef,
-        ValueToTypePathsOf<typeof typeDef>,
+        ValueToTypePathsOfType<typeof typeDef>,
         typeof adapters
       >
       beforeEach(function () {
@@ -250,7 +275,7 @@ describe('all', function () {
         ]
         model = new FormModel<
           typeof typeDef,
-          ValueToTypePathsOf<typeof typeDef>,
+          ValueToTypePathsOfType<typeof typeDef>,
           typeof adapters
         >(
           typeDef,
@@ -288,6 +313,25 @@ 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 () {
@@ -296,10 +340,10 @@ describe('all', function () {
         '$.*': integerToStringAdapter,
         // '$.*': booleanToBooleanConverter,
       } as const
-      let value: ValueTypeOf<typeof typeDef>
+      let value: ValueOfType<typeof typeDef>
       let model: FormModel<
         typeof typeDef,
-        ValueToTypePathsOf<typeof typeDef>,
+        ValueToTypePathsOfType<typeof typeDef>,
         typeof converters
       >
       beforeEach(function () {
@@ -309,7 +353,7 @@ describe('all', function () {
         }
         model = new FormModel<
           typeof typeDef,
-          ValueToTypePathsOf<typeof typeDef>,
+          ValueToTypePathsOfType<typeof typeDef>,
           typeof converters
         >(
           typeDef,
@@ -360,16 +404,16 @@ 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,
       } as const
-      let value: ValueTypeOf<typeof typeDef>
+      let value: ValueOfType<typeof typeDef>
       let model: FormModel<
         typeof typeDef,
-        ValueToTypePathsOf<typeof typeDef>,
+        ValueToTypePathsOfType<typeof typeDef>,
         typeof converters
       >
       beforeEach(function () {
@@ -379,7 +423,7 @@ describe('all', function () {
         }
         model = new FormModel<
           typeof typeDef,
-          ValueToTypePathsOf<typeof typeDef>,
+          ValueToTypePathsOfType<typeof typeDef>,
           typeof converters
         >(
           typeDef,
@@ -437,16 +481,16 @@ describe('all', function () {
       } as const
       const presenter = new FormPresenter<
         typeof typeDef,
-        ValueToTypePathsOf<typeof typeDef>,
+        ValueToTypePathsOfType<typeof typeDef>,
         typeof adapters
       >(
         typeDef,
         adapters,
       )
-      const originalValue: ValueTypeOf<typeof typeDef> = 2
+      const originalValue: ValueOfType<typeof typeDef> = 2
       let model: FormModel<
         typeof typeDef,
-        ValueToTypePathsOf<typeof typeDef>,
+        ValueToTypePathsOfType<typeof typeDef>,
         typeof adapters
       >
       beforeEach(function () {
@@ -467,7 +511,6 @@ describe('all', function () {
             expect(model.fields).toEqual(expect.objectContaining({
               $: expect.objectContaining({
                 value: '1',
-                // eslint-disable-next-line no-undefined
                 error: undefined,
               }),
             }))
@@ -499,7 +542,7 @@ describe('all', function () {
             const errorCode = 65
             beforeEach(function () {
               integerToStringAdapter.revert?.mockReturnValueOnce({
-                type: FieldConversionResult.Failure,
+                type: UnreliableFieldConversionType.Failure,
                 error: errorCode,
                 value: [newValue],
               })
@@ -515,7 +558,7 @@ describe('all', function () {
                 $: expect.objectContaining({
                   value: '-1',
                   error: errorCode,
-                  disabled: false,
+                  readonly: false,
                 }),
               })
             })
@@ -545,7 +588,6 @@ describe('all', function () {
           expect(model.fields).toEqual(expect.objectContaining({
             $: expect.objectContaining({
               value: newValue,
-              // eslint-disable-next-line no-undefined
               error: undefined,
             }),
           }))
@@ -560,16 +602,16 @@ describe('all', function () {
       } as const
       const presenter = new FormPresenter<
         typeof typeDef,
-        ValueToTypePathsOf<typeof typeDef>,
+        ValueToTypePathsOfType<typeof typeDef>,
         typeof converters
       >(
         typeDef,
         converters,
       )
-      let originalValue: ValueTypeOf<typeof typeDef>
+      let originalValue: ValueOfType<typeof typeDef>
       let model: FormModel<
         typeof typeDef,
-        ValueToTypePathsOf<typeof typeDef>,
+        ValueToTypePathsOfType<typeof typeDef>,
         typeof converters
       >
       beforeEach(function () {
@@ -599,7 +641,6 @@ describe('all', function () {
             expect(model.fields).toEqual(expect.objectContaining({
               '$.0': expect.objectContaining({
                 value: '100',
-                // eslint-disable-next-line no-undefined
                 error: undefined,
               }),
             }))
@@ -642,7 +683,6 @@ describe('all', function () {
           expect(model.fields).toEqual(expect.objectContaining({
             '$.0': expect.objectContaining({
               value: newValue,
-              // eslint-disable-next-line no-undefined
               error: undefined,
             }),
           }))
@@ -665,7 +705,6 @@ describe('all', function () {
             }),
             '$.1': expect.objectContaining({
               value: '2',
-              // eslint-disable-next-line no-undefined
               error: undefined,
             }),
             '$.2': expect.objectContaining({
@@ -691,7 +730,7 @@ describe('all', function () {
           integerToStringAdapter.revert.mockImplementationOnce(function (_value, _path, context) {
             contextCopy = [...context]
             return {
-              type: FieldConversionResult.Success,
+              type: UnreliableFieldConversionType.Success,
               value: 1,
             }
           })
@@ -760,7 +799,6 @@ describe('all', function () {
           it.each([
             [
               '$.0',
-              // eslint-disable-next-line no-undefined
               undefined,
             ],
             [
@@ -881,26 +919,26 @@ 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,
         } as const
-        type JsonPaths = ValueToTypePathsOf<typeof typeDef>
+        type ValueToTypePaths = ValueToTypePathsOfType<typeof type>
         const presenter = new FormPresenter<
-          typeof typeDef,
-          JsonPaths,
+          typeof type,
+          ValueToTypePaths,
           typeof adapters
         >(
-          typeDef,
+          type,
           adapters,
         )
-        let originalValue: ValueTypeOf<typeof typeDef>
+        let originalValue: ValueOfType<typeof type>
         let model: FormModel<
-          typeof typeDef,
-          JsonPaths,
+          typeof type,
+          ValueToTypePaths,
           typeof adapters
         >
         beforeEach(function () {
@@ -911,8 +949,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,
@@ -932,6 +969,93 @@ 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)
+        type ValueToTypePaths = ValueToTypePathsOfType<typeof type>
+
+        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,
+        } as const
+        const presenter = new FormPresenter<
+          typeof type,
+          ValueToTypePaths,
+          typeof adapters
+        >(
+          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,
+              ],
+            ] as const)('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,
+              ],
+            ] as const)('value path %s is active %s', function (path, expected) {
+              const isValid = presenter.isValuePathActive(model, path)
+              expect(isValid).toBe(expected)
+            })
+          })
+        })
+      })
     })
 
     describe('fake', function () {
@@ -952,7 +1076,7 @@ describe('all', function () {
         typeDef,
         converters,
       )
-      let originalValue: ValueTypeOf<typeof typeDef>
+      let originalValue: ValueOfType<typeof typeDef>
       let model: FormModel<
         typeof typeDef,
         JsonPaths,