@strictly/react-form 0.0.6 → 0.0.8

package/.turbo/turbo-build.log

@@ -7,12 +7,12 @@ $ tsup
 CLI Target: esnext
 CJS Build start
 ESM Build start
-CJS dist/index.cjs 49.29 KB
-CJS ⚡️ Build success in 106ms
-ESM dist/index.js 45.41 KB
-ESM ⚡️ Build success in 106ms
+CJS dist/index.cjs 50.73 KB
+CJS ⚡️ Build success in 112ms
+ESM dist/index.js 46.84 KB
+ESM ⚡️ Build success in 113ms
 DTS Build start
-DTS ⚡️ Build success in 10312ms
-DTS dist/index.d.cts 35.93 KB
-DTS dist/index.d.ts  35.93 KB
-Done in 11.43s.
+DTS ⚡️ Build success in 9662ms
+DTS dist/index.d.cts 36.94 KB
+DTS dist/index.d.ts  36.94 KB
+Done in 10.73s.

package/.turbo/turbo-check-types.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ tsc
-Done in 8.11s.
+Done in 7.38s.

package/.turbo/turbo-release$colon$exports.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ json -f package.json -f package.exports.json --merge > package.release.json
-Done in 0.11s.
+Done in 0.13s.

package/core/mobx/hooks.ts

@@ -25,12 +25,16 @@ type ModelOfPresenter<P extends FormPresenter<any, any, any, any>> = ReturnType<
 export function useDefaultMobxFormHooks<P extends FormPresenter<any, any, any, any>>(
   presenter: P,
   value: ValueOfPresenter<P>,
-  onValidSubmit?: <Path extends ValuePathsOfPresenter<P>>(
-    model: ModelOfPresenter<P>,
-    valuePath: Path,
-  ) => void,
+  {
+    onValidFieldSubmit,
+    onValidFormSubmit,
+  }: {
+    onValidFieldSubmit?: <Path extends ValuePathsOfPresenter<P>>(model: ModelOfPresenter<P>, valuePath: Path) => void,
+    onValidFormSubmit?: (model: ModelOfPresenter<P>, value: ValueOfPresenter<P>) => void,
+  },
 ): {
   model: ModelOfPresenter<P>,
+  onFormSubmit?: (value: ValueOfPresenter<P>) => void,
 } & Omit<FieldsViewProps<ModelOfPresenter<P>['fields']>, 'fields'> {
   const model = useMemo(function () {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -57,14 +61,14 @@ export function useDefaultMobxFormHooks<P extends FormPresenter<any, any, any, a
   const onFieldSubmit = useCallback(
     function<Path extends ValuePathsOfPresenter<P>> (valuePath: Path) {
       if (presenter.validateField(model, valuePath)) {
-        onValidSubmit?.(model, valuePath)
+        onValidFieldSubmit?.(model, valuePath)
       }
       return false
     },
     [
       presenter,
       model,
-      onValidSubmit,
+      onValidFieldSubmit,
     ],
   )
 
@@ -85,10 +89,24 @@ export function useDefaultMobxFormHooks<P extends FormPresenter<any, any, any, a
     ],
   )
 
+  const onFormSubmit = useCallback(
+    function () {
+      if (presenter.validateAll(model)) {
+        onValidFormSubmit?.(model, model.value)
+      }
+    },
+    [
+      presenter,
+      model,
+      onValidFormSubmit,
+    ],
+  )
+
   return {
     model,
     onFieldValueChange,
     onFieldSubmit,
     onFieldBlur,
+    onFormSubmit,
   }
 }

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

@@ -85,14 +85,14 @@ describe('all', function () {
           ValueOfType<typeof typeDef>
         >
       >
-      let t: Partial<{
+      type C = Partial<{
         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 () {
-        expectTypeOf(t).toEqualTypeOf<T>()
+        expectTypeOf<C>().toEqualTypeOf<T>()
       })
     })
 
@@ -104,13 +104,13 @@ describe('all', function () {
         FlattenedValuesOfType<typeof typeDef>,
         ValueOfType<typeof typeDef>
       >
-      let t: Partial<{
+      type C = Partial<{
         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>()
+        expectTypeOf<C>().toEqualTypeOf<T>()
       })
 
       it('matches representative adapters', function () {
@@ -147,12 +147,12 @@ describe('all', function () {
         A,
         typeof valuePathsToTypePaths
       >
-      let t: {
+      type C = {
         readonly '$.a': A['$.x'],
         readonly '$.b': A['$.y'],
       }
       it('equals expected type', function () {
-        expectTypeOf(t).toEqualTypeOf<T>()
+        expectTypeOf<C>().toEqualTypeOf<T>()
       })
     })
   })

package/core/mobx/specs/{merge_field_adapters_with_two_way_converter.ts → merge_field_adapters_with_two_way_converter.tests.ts}

@@ -33,14 +33,14 @@ describe('MergedOfFieldAdapterWithTwoWayConverter', function () {
   }
   type M = MergedOfFieldAdaptersWithTwoWayConverter<T, typeof error4, typeof context>
 
-  let m: {
+  type C = {
     readonly x: FieldAdapter<boolean, string, typeof error1 | typeof error4, 'x', typeof context>,
     readonly y: FieldAdapter<number, boolean, typeof error2 | typeof error4, 'y', typeof context>,
     readonly z: FieldAdapter<string, number, typeof error3 | typeof error4, 'z', typeof context>,
   }
 
   it('merges the errors', function () {
-    expectTypeOf<M>().toEqualTypeOf(m)
+    expectTypeOf<M>().toEqualTypeOf<C>()
   })
 })
 
@@ -117,23 +117,23 @@ 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('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 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('calls the mocked adapter', function () {
+          expect(booleanAdapter.revert).toHaveBeenCalledOnce()
+          expect(booleanAdapter.revert).toHaveBeenCalledWith(true, 'booleanAdapter', context)
+        })
       })
     })
   })

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

@@ -1,15 +1,26 @@
+import {
+  list,
+  numberType,
+  object,
+  stringType,
+} from '@strictly/define'
 import { type FieldAdapter } from 'core/mobx/field_adapter'
 import {
   subFormFieldAdapters,
 } from 'core/mobx/sub_form_field_adapters'
-import { mockDeep } from 'vitest-mock-extended'
+import { UnreliableFieldConversionType } from 'types/field_converters'
+import {
+  mockDeep,
+  mockReset,
+} from 'vitest-mock-extended'
 
 describe('subFormFieldAdapters', () => {
-  const fieldAdapter1: FieldAdapter<string, boolean> = mockDeep()
-  const fieldAdapter2: FieldAdapter<number, boolean> = mockDeep()
-
   describe('empty value', () => {
-    const adapters = subFormFieldAdapters({}, '$.a')
+    const adapters = subFormFieldAdapters(
+      {},
+      '$.a',
+      stringType,
+    )
 
     it('equals expected type', () => {
       expectTypeOf(adapters).toEqualTypeOf<{}>()
@@ -21,29 +32,102 @@ describe('subFormFieldAdapters', () => {
   })
 
   describe('single adapter', () => {
-    const adapters = subFormFieldAdapters({
+    const mockedFieldAdapter1 = mockDeep<Required<FieldAdapter<string, boolean, number, '$', string>>>()
+    const fieldAdapter1: FieldAdapter<string, boolean, number, '$', string> = mockedFieldAdapter1
+
+    const type = object().field('a', stringType)
+    const subAdapters = {
       $: fieldAdapter1,
-    }, '$.a')
+    } as const
+    const adapters = subFormFieldAdapters<
+      typeof subAdapters,
+      '$.a',
+      { '$.a': '$.a' },
+      typeof type
+    >(
+      subAdapters,
+      '$.a',
+      type,
+    )
+
+    beforeEach(() => {
+      mockReset(mockedFieldAdapter1)
+    })
 
     it('equals expected type', () => {
-      expectTypeOf(adapters).toEqualTypeOf<{
-        '$.a': FieldAdapter<string, boolean>,
+      // TODO toEqualTypeOf (cannot reason about revert optionality, seems to be a TS issue as they
+      // are both optional AFAICT)
+      expectTypeOf(adapters).toMatchTypeOf<{
+        '$.a': FieldAdapter<string, boolean, number, '$.a', {
+          a: string,
+        }>,
       }>()
     })
 
     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',
+      } as const
+      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 adapters = subFormFieldAdapters({
-      '$.x': fieldAdapter1,
-      '$.y': fieldAdapter2,
-    }, '$.a')
+    const mockedFieldAdapter1 = mockDeep<Required<FieldAdapter<string, boolean>>>()
+    const fieldAdapter1: FieldAdapter<string, boolean, number> = mockedFieldAdapter1
+    const mockedFieldAdapter2 = mockDeep<FieldAdapter<number, boolean>>()
+    const fieldAdapter2: FieldAdapter<number, boolean> = mockedFieldAdapter2
+
+    const type = object()
+      .field('a', object().field('x', stringType).field('y', numberType))
+    const adapters = subFormFieldAdapters(
+      {
+        '$.x': fieldAdapter1,
+        '$.y': fieldAdapter2,
+      },
+      '$.a',
+      type,
+    )
+
+    beforeEach(() => {
+      mockReset(mockedFieldAdapter1)
+      mockReset(mockedFieldAdapter2)
+    })
 
     it('equals expected type', () => {
-      expectTypeOf(adapters).toEqualTypeOf<{
+      // TODO toEqualTypeOf (seems to be a TS error)
+      expectTypeOf(adapters).toMatchTypeOf<{
         '$.a.x': FieldAdapter<string, boolean>,
         '$.a.y': FieldAdapter<number, boolean>,
       }>()
@@ -51,8 +135,100 @@ describe('subFormFieldAdapters', () => {
 
     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,
+      } as const
+      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)
+      })
+    })
+  })
+
+  describe('list adapter', () => {
+    const mockedFieldAdapter1 = mockDeep<Required<FieldAdapter<string, boolean, number, '$', string>>>()
+    const fieldAdapter1: FieldAdapter<string, boolean, number, '$', string> = mockedFieldAdapter1
+    const type = list(stringType)
+    const subAdapters = {
+      $: fieldAdapter1,
+    }
+    const adapters = subFormFieldAdapters<
+      typeof subAdapters,
+      '$.*',
+      {
+        '$.*': `$.${number}`,
+      },
+      typeof type
+    >(
+      subAdapters,
+      '$.*',
+      type,
+    )
+
+    beforeEach(() => {
+      mockReset(mockedFieldAdapter1)
+    })
+
+    it('equals expected type', () => {
+      // TODO toEqualTypeOf (seems to be a TS error)
+      expectTypeOf(adapters).toMatchTypeOf<{
+        '$.*': FieldAdapter<string, boolean, number, `$.${number}`, string[]>,
+      }>()
+    })
+
+    it('equals expected value', () => {
+      expect(adapters).toEqual({
+        '$.*': expect.anything(),
+      })
+    })
+
+    describe('calls convert with correct paths and values', () => {
+      const subContext = 'a'
+      const context = [subContext]
+
+      it('calls $.*', () => {
+        const mockedReturnedValue = {
+          value: false,
+          readonly: false,
+          required: false,
+        }
+        mockedFieldAdapter1.convert.mockReturnValue(mockedReturnedValue)
+
+        const returnedValue = adapters['$.*'].convert('b', '$.0', context)
+        expect(fieldAdapter1.convert).toHaveBeenCalledWith('b', '$', subContext)
+        expect(returnedValue).toEqual(mockedReturnedValue)
       })
     })
   })

package/core/mobx/sub_form_field_adapters.ts

@@ -1,21 +1,84 @@
 import { type StringConcatOf } from '@strictly/base'
-import { type FieldAdapter } from './field_adapter'
+import {
+  flattenValuesOfType,
+  type Type,
+  type ValueOfType,
+} from '@strictly/define'
+import {
+  type ErrorOfFieldAdapter,
+  type FieldAdapter,
+  type FromOfFieldAdapter,
+  type ToOfFieldAdapter,
+  type ValuePathOfFieldAdapter,
+} 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]
+type SubFormFieldAdapter<F extends FieldAdapter, ValuePath extends string, Context> = FieldAdapter<
+  FromOfFieldAdapter<F>,
+  ToOfFieldAdapter<F>,
+  ErrorOfFieldAdapter<F>,
+  ValuePathOfFieldAdapter<F> extends StringConcatOf<'$', infer ValuePathSuffix> ? `${ValuePath}${ValuePathSuffix}`
+    // assume string (they don't care about the value path as a type) if there the path doesn't have a $ prefix
+    : 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
+  >
 }
 
-export function subFormFieldAdapters<SubAdapters extends Record<string, FieldAdapter>, P extends string>(
+export function subFormFieldAdapters<
+  SubAdapters extends Record<string, FieldAdapter>,
+  TypePath extends string,
+  TypePathsToValuePaths extends Record<TypePath, string>,
+  ContextType extends Type,
+>(
   subAdapters: SubAdapters,
-  prefix: P,
-): SubFormFieldAdapters<SubAdapters, P> {
+  parentTypePath: TypePath,
+  contextType: ContextType,
+): SubFormFieldAdapters<SubAdapters, TypePath, TypePathsToValuePaths[TypePath], ValueOfType<ContextType>> {
+  // 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: string, context: ValueOfType<ContextType>) {
+    const parentValuePath = valuePath.split('.').slice(0, dotCount).join('.')
+    const subValuePath = valuePath.replace(parentValuePath, '$')
+    const subContext = flattenValuesOfType(contextType, context)[parentValuePath]
+    return [
+      subValuePath,
+      subContext,
+    ] as const
+  }
+
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return Object.entries(subAdapters).reduce<Record<string, FieldAdapter>>((acc, [
-    subKey,
-    subValue,
+    subTypePath,
+    subAdapter,
   ]) => {
-    const key = subKey.replace('$', prefix)
-    acc[key] = subValue
+    const typePath = subTypePath.replace('$', parentTypePath)
+    // adapt field adapter with new path and context
+    const adaptedAdapter: FieldAdapter = {
+      convert: (from, valuePath, context) => {
+        return subAdapter.convert(from, ...getSubValuePathAndContext(valuePath, context))
+      },
+      create: (valuePath, context) => {
+        return subAdapter.create(...getSubValuePathAndContext(valuePath, context))
+      },
+      revert: subAdapter.revert && ((from, valuePath, context) => {
+        return subAdapter.revert!(from, ...getSubValuePathAndContext(valuePath, context))
+      }),
+    }
+    acc[typePath] = adaptedAdapter
     return acc
-  }, {}) as SubFormFieldAdapters<SubAdapters, P>
+  }, {}) as SubFormFieldAdapters<SubAdapters, TypePath, TypePathsToValuePaths[TypePath], ValueOfType<ContextType>>
 }