@strictly/react-form 0.0.7 → 0.0.9

package/.out/types/specs/{error_type_of_field.tests.js → error_of_field.tests.js}

@@ -1,4 +1,4 @@
-describe('ErrorTypeOfField', function () {
+describe('ErrorOfField', function () {
     it('equals expected type', function () {
         const e = Symbol();
         expectTypeOf().toEqualTypeOf();

package/.turbo/turbo-build.log

@@ -7,12 +7,12 @@ $ tsup
 CLI Target: esnext
 CJS Build start
 ESM Build start
-CJS dist/index.cjs 50.08 KB
-CJS ⚡️ Build success in 121ms
-ESM dist/index.js 46.21 KB
-ESM ⚡️ Build success in 122ms
+CJS dist/index.cjs 51.55 KB
+CJS ⚡️ Build success in 120ms
+ESM dist/index.js 47.61 KB
+ESM ⚡️ Build success in 121ms
 DTS Build start
-DTS ⚡️ Build success in 9863ms
-DTS dist/index.d.cts 36.28 KB
-DTS dist/index.d.ts  36.28 KB
-Done in 10.98s.
+DTS ⚡️ Build success in 10031ms
+DTS dist/index.d.cts 37.40 KB
+DTS dist/index.d.ts  37.40 KB
+Done in 11.07s.

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

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

package/core/mobx/field_adapter_builder.ts

@@ -7,12 +7,14 @@ import {
   unreliableIdentityConverter,
 } from 'field_converters/identity_converter'
 import { MaybeIdentityConverter } from 'field_converters/maybe_identity_converter'
+import { TrimmingStringConverter } from 'field_converters/trimming_string_converter'
 import { prototypingFieldValueFactory } from 'field_value_factories/prototyping_field_value_factory'
 import {
   type AnnotatedFieldConverter,
   type FieldValueFactory,
   type TwoWayFieldConverter,
   type TwoWayFieldConverterWithValueFactory,
+  UnreliableFieldConversionType,
   type UnreliableFieldConverter,
 } from 'types/field_converters'
 import { type FieldAdapter } from './field_adapter'
@@ -82,6 +84,65 @@ class FieldAdapterBuilder<
     )
   }
 
+  nullable(): FieldAdapterBuilder<
+    From | null,
+    To | null,
+    E,
+    ValuePath,
+    Context
+  > {
+    return this.or(null)
+  }
+
+  optional(): FieldAdapterBuilder<
+    From | undefined,
+    To | undefined,
+    E,
+    ValuePath,
+    Context
+  > {
+    return this.or(undefined)
+  }
+
+  private or<V>(proto: V): FieldAdapterBuilder<
+    From | V,
+    To | V,
+    E,
+    ValuePath,
+    Context
+  > {
+    function isFrom(v: From | V): v is From {
+      return v !== proto
+    }
+    function isTo(v: To | V): v is To {
+      return v !== proto
+    }
+    return new FieldAdapterBuilder<
+      From | V,
+      To | V,
+      E,
+      ValuePath,
+      Context
+    >(
+      (v, valuePath, context) =>
+        isFrom(v)
+          ? this.convert(v, valuePath, context)
+          : {
+            value: v,
+            readonly: false,
+            required: false,
+          },
+      this.create,
+      (v, valuePath, context) =>
+        isTo(v) && this.revert
+          ? this.revert(v, valuePath, context)
+          : {
+            type: UnreliableFieldConversionType.Success,
+            value: proto,
+          },
+    )
+  }
+
   withIdentity(isFrom: (from: To | From) => from is From): FieldAdapterBuilder<
     From,
     To | From,
@@ -263,6 +324,16 @@ export function identityAdapter<
   )
 }
 
+export function trimmingStringAdapter<
+  ValuePath extends string,
+  Context,
+>() {
+  return adapterFromTwoWayConverter<string, string, never, ValuePath, Context>(
+    new TrimmingStringConverter<ValuePath, Context>(),
+    prototypingFieldValueFactory<string, ValuePath, Context>(''),
+  )
+}
+
 export function listAdapter<
   E,
   ValuePath extends string,

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?: () => 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/sub_form_field_adapters.tests.ts

@@ -1,4 +1,5 @@
 import {
+  list,
   numberType,
   object,
   stringType,
@@ -8,16 +9,18 @@ import {
   subFormFieldAdapters,
 } from 'core/mobx/sub_form_field_adapters'
 import { UnreliableFieldConversionType } from 'types/field_converters'
-import { mockDeep } from 'vitest-mock-extended'
+import {
+  mockDeep,
+  mockReset,
+} from 'vitest-mock-extended'
 
 describe('subFormFieldAdapters', () => {
-  const mockedFieldAdapter1 = mockDeep<Required<FieldAdapter<string, boolean>>>()
-  const fieldAdapter1: FieldAdapter<string, boolean> = mockedFieldAdapter1
-  const mockedFieldAdapter2 = mockDeep<FieldAdapter<number, boolean>>()
-  const fieldAdapter2: FieldAdapter<number, boolean> = mockedFieldAdapter2
-
   describe('empty value', () => {
-    const adapters = subFormFieldAdapters({}, '$.a', stringType)
+    const adapters = subFormFieldAdapters(
+      {},
+      '$.a',
+      stringType,
+    )
 
     it('equals expected type', () => {
       expectTypeOf(adapters).toEqualTypeOf<{}>()
@@ -29,15 +32,35 @@ describe('subFormFieldAdapters', () => {
   })
 
   describe('single adapter', () => {
+    const mockedFieldAdapter1 = mockDeep<Required<FieldAdapter<string, boolean, number, '$', string>>>()
+    const fieldAdapter1: FieldAdapter<string, boolean, number, '$', string> = mockedFieldAdapter1
+
     const type = object().field('a', stringType)
-    const adapters = subFormFieldAdapters({
+    const subAdapters = {
       $: fieldAdapter1,
-    }, '$.a', type)
+    } as const
+    const adapters = subFormFieldAdapters<
+      typeof subAdapters,
+      '$.a',
+      { '$.a': '$.a' },
+      typeof type
+    >(
+      subAdapters,
+      '$.a',
+      type,
+    )
+
+    beforeEach(() => {
+      mockReset(mockedFieldAdapter1)
+    })
 
     it('equals expected type', () => {
-      // TODO toEqualTypeOf (seems to be a TS error)
+      // 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>,
+        '$.a': FieldAdapter<string, boolean, number, '$.a', {
+          a: string,
+        }>,
       }>()
     })
 
@@ -81,12 +104,26 @@ describe('subFormFieldAdapters', () => {
   })
 
   describe('multiple adapters', () => {
+    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)
+    const adapters = subFormFieldAdapters(
+      {
+        '$.x': fieldAdapter1,
+        '$.y': fieldAdapter2,
+      },
+      '$.a',
+      type,
+    )
+
+    beforeEach(() => {
+      mockReset(mockedFieldAdapter1)
+      mockReset(mockedFieldAdapter2)
+    })
 
     it('equals expected type', () => {
       // TODO toEqualTypeOf (seems to be a TS error)
@@ -139,4 +176,60 @@ describe('subFormFieldAdapters', () => {
       })
     })
   })
+
+  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

@@ -9,35 +9,51 @@ import {
   type FieldAdapter,
   type FromOfFieldAdapter,
   type ToOfFieldAdapter,
+  type ValuePathOfFieldAdapter,
 } from './field_adapter'
 
-type SubFormFieldAdapter<F extends FieldAdapter, P extends string, Context> = FieldAdapter<
+type SubFormFieldAdapter<F extends FieldAdapter, ValuePath extends string, Context> = FieldAdapter<
   FromOfFieldAdapter<F>,
   ToOfFieldAdapter<F>,
   ErrorOfFieldAdapter<F>,
-  P,
+  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>, 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
+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,
-  ContextType extends Type>(
+export function subFormFieldAdapters<
+  SubAdapters extends Record<string, FieldAdapter>,
+  TypePath extends string,
+  TypePathsToValuePaths extends Record<TypePath, string>,
+  ContextType extends Type,
+>(
   subAdapters: SubAdapters,
-  prefix: P,
+  parentTypePath: TypePath,
   contextType: ContextType,
-): SubFormFieldAdapters<SubAdapters, P, ValueOfType<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 subValuePath = valuePath.replace(prefix, '$')
-    const subContext = flattenValuesOfType(contextType, context)[prefix]
+    const parentValuePath = valuePath.split('.').slice(0, dotCount).join('.')
+    const subValuePath = valuePath.replace(parentValuePath, '$')
+    const subContext = flattenValuesOfType(contextType, context)[parentValuePath]
     return [
       subValuePath,
       subContext,
@@ -46,23 +62,23 @@ export function subFormFieldAdapters<SubAdapters extends Record<string, FieldAda
 
   // 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)
+    const typePath = subTypePath.replace('$', parentTypePath)
     // adapt field adapter with new path and context
     const adaptedAdapter: FieldAdapter = {
       convert: (from, valuePath, context) => {
-        return subValue.convert(from, ...getSubValuePathAndContext(valuePath, context))
+        return subAdapter.convert(from, ...getSubValuePathAndContext(valuePath, context))
       },
       create: (valuePath, context) => {
-        return subValue.create(...getSubValuePathAndContext(valuePath, context))
+        return subAdapter.create(...getSubValuePathAndContext(valuePath, context))
       },
-      revert: subValue.revert && ((from, valuePath, context) => {
-        return subValue.revert!(from, ...getSubValuePathAndContext(valuePath, context))
+      revert: subAdapter.revert && ((from, valuePath, context) => {
+        return subAdapter.revert!(from, ...getSubValuePathAndContext(valuePath, context))
       }),
     }
-    acc[key] = adaptedAdapter
+    acc[typePath] = adaptedAdapter
     return acc
-  }, {}) as SubFormFieldAdapters<SubAdapters, P, ValueOfType<ContextType>>
+  }, {}) as SubFormFieldAdapters<SubAdapters, TypePath, TypePathsToValuePaths[TypePath], ValueOfType<ContextType>>
 }