@strictly/react-form 0.0.7 → 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 50.08 KB
-CJS ⚡️ Build success in 121ms
-ESM dist/index.js 46.21 KB
-ESM ⚡️ Build success in 122ms
+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 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 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 7.67s.
+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.12s.
+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/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>>
 }

package/dist/index.cjs

@@ -690,7 +690,10 @@ var FormModel = class {
 
 // core/mobx/hooks.ts
 var import_react = require("react");
-function useDefaultMobxFormHooks(presenter, value, onValidSubmit) {
+function useDefaultMobxFormHooks(presenter, value, {
+  onValidFieldSubmit,
+  onValidFormSubmit
+}) {
   const model = (0, import_react.useMemo)(function() {
     return presenter.createModel(value);
   }, [
@@ -710,14 +713,14 @@ function useDefaultMobxFormHooks(presenter, value, onValidSubmit) {
   const onFieldSubmit = (0, import_react.useCallback)(
     function(valuePath) {
       if (presenter.validateField(model, valuePath)) {
-        onValidSubmit?.(model, valuePath);
+        onValidFieldSubmit?.(model, valuePath);
       }
       return false;
     },
     [
       presenter,
       model,
-      onValidSubmit
+      onValidFieldSubmit
     ]
   );
   const onFieldBlur = (0, import_react.useCallback)(
@@ -733,11 +736,24 @@ function useDefaultMobxFormHooks(presenter, value, onValidSubmit) {
       model
     ]
   );
+  const onFormSubmit = (0, import_react.useCallback)(
+    function() {
+      if (presenter.validateAll(model)) {
+        onValidFormSubmit?.(model, model.value);
+      }
+    },
+    [
+      presenter,
+      model,
+      onValidFormSubmit
+    ]
+  );
   return {
     model,
     onFieldValueChange,
     onFieldSubmit,
-    onFieldBlur
+    onFieldBlur,
+    onFormSubmit
   };
 }
 
@@ -818,32 +834,34 @@ function mergeAdaptersWithValidators(adapters, validators) {
 
 // core/mobx/sub_form_field_adapters.ts
 var import_define3 = require("@strictly/define");
-function subFormFieldAdapters(subAdapters, prefix, contextType) {
+function subFormFieldAdapters(subAdapters, parentTypePath, contextType) {
+  const dotCount = parentTypePath.split(".").length;
   function getSubValuePathAndContext(valuePath, context) {
-    const subValuePath = valuePath.replace(prefix, "$");
-    const subContext = (0, import_define3.flattenValuesOfType)(contextType, context)[prefix];
+    const parentValuePath = valuePath.split(".").slice(0, dotCount).join(".");
+    const subValuePath = valuePath.replace(parentValuePath, "$");
+    const subContext = (0, import_define3.flattenValuesOfType)(contextType, context)[parentValuePath];
     return [
       subValuePath,
       subContext
     ];
   }
   return Object.entries(subAdapters).reduce((acc, [
-    subKey,
-    subValue
+    subTypePath,
+    subAdapter
   ]) => {
-    const key = subKey.replace("$", prefix);
+    const typePath = subTypePath.replace("$", parentTypePath);
     const adaptedAdapter = {
       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;
   }, {});
 }
@@ -1057,7 +1075,7 @@ function DefaultErrorRenderer({
   error
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 }) {
-  return error;
+  return JSON.stringify(error);
 }
 
 // mantine/hooks.tsx
@@ -1288,15 +1306,19 @@ function createFieldsView(valuePath, FieldsView, observableProps) {
     observableProps.onFieldSubmit?.(toKey(subKey));
   }
   return (0, import_mobx_react2.observer)(function(props) {
-    const subFields = Object.entries(observableProps.fields).reduce((acc, [
-      fieldKey,
-      fieldValue
-    ]) => {
-      if (fieldKey.startsWith(valuePath)) {
-        acc[toSubKey(fieldKey)] = fieldValue;
-      }
-      return acc;
-    }, {});
+    const subFields = Object.entries(observableProps.fields).reduce(
+      (acc, [
+        fieldKey,
+        fieldValue
+      ]) => {
+        if (fieldKey.startsWith(valuePath)) {
+          acc[toSubKey(fieldKey)] = fieldValue;
+        }
+        return acc;
+      },
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      {}
+    );
     return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
       FieldsView,
       {
@@ -1452,13 +1474,16 @@ function createTextInput(valuePath, TextInput) {
   const propSource = ({
     ErrorRenderer = DefaultErrorRenderer
   }) => {
+    const field = this.fields[valuePath];
+    if (field == null) {
+      throw new Error(`invalid field ${valuePath}`);
+    }
     const {
       readonly,
       required,
       value,
       error
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    } = this.fields[valuePath];
+    } = field;
     return {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       name: valuePath,

package/dist/index.d.cts

@@ -181,8 +181,12 @@ type FormFieldsOfPresenter<Presenter extends FormPresenter<any, any, any, any>>
 
 type ValueOfPresenter<P extends FormPresenter<any, any, any, any>> = P extends FormPresenter<infer T, any, any, any> ? ValueOfType<ReadonlyTypeOfType<T>> : never;
 type ModelOfPresenter<P extends FormPresenter<any, any, any, any>> = ReturnType<P['createModel']>;
-declare 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): {
+declare function useDefaultMobxFormHooks<P extends FormPresenter<any, any, any, any>>(presenter: P, value: ValueOfPresenter<P>, { 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'>;
 
 type MergedOfFieldAdaptersWithTwoWayConverter<FieldAdapters extends Readonly<Record<string, FieldAdapter>>, E, Context> = {
@@ -204,11 +208,11 @@ type MergedOfFieldAdaptersWithValidators<FieldAdapters extends Readonly<Record<K
 type MergedOfFieldAdapterWithValidator<A extends FieldAdapter, V extends Validator | undefined> = undefined extends V ? A : A extends FieldAdapter<infer From, infer To, infer E1, infer P1, infer C1> ? V extends Validator<From, infer E2, infer P2, infer C2> ? FieldAdapter<From, To, E1 | E2, P1 | P2, C1 | C2> : never : never;
 declare function mergeAdaptersWithValidators<FieldAdapters extends Readonly<Record<Key, FieldAdapter>>, Validators extends Readonly<Record<string, Validator>>, Key extends keyof Validators = keyof Validators>(adapters: FieldAdapters, validators: Validators): MergedOfFieldAdaptersWithValidators<FieldAdapters, Validators, Key>;
 
-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;
+type SubFormFieldAdapter<F extends FieldAdapter, ValuePath extends string, Context> = FieldAdapter<FromOfFieldAdapter<F>, ToOfFieldAdapter<F>, ErrorOfFieldAdapter<F>, ValuePathOfFieldAdapter<F> extends StringConcatOf<'$', infer ValuePathSuffix> ? `${ValuePath}${ValuePathSuffix}` : 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>;
 };
-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>>;
+declare function subFormFieldAdapters<SubAdapters extends Record<string, FieldAdapter>, TypePath extends string, TypePathsToValuePaths extends Record<TypePath, string>, ContextType extends Type>(subAdapters: SubAdapters, parentTypePath: TypePath, contextType: ContextType): SubFormFieldAdapters<SubAdapters, TypePath, TypePathsToValuePaths[TypePath], ValueOfType<ContextType>>;
 
 declare class IntegerToStringConverter<E, ValuePath extends string, Context> implements TwoWayFieldConverter<number, string, E, ValuePath, Context> {
     private readonly isNanError;
@@ -218,14 +222,14 @@ declare class IntegerToStringConverter<E, ValuePath extends string, Context> imp
     revert(from: string): UnreliableFieldConversion<number, E>;
 }
 
-declare class NullableToBooleanConverter<T extends Type, E, ValuePath extends string, Context, NullType extends null | undefined> implements TwoWayFieldConverterWithValueFactory<ValueOfType<ReadonlyTypeOfType<T>> | NullType, boolean, E, ValuePath, Context> {
+declare class NullableToBooleanConverter<T extends Type, ValuePath extends string, Context, NullType extends null | undefined> implements TwoWayFieldConverterWithValueFactory<ValueOfType<ReadonlyTypeOfType<T>> | NullType, boolean, never, ValuePath, Context> {
     private readonly typeDef;
     private readonly prototype;
     private readonly nullType;
     readonly defaultValue: ValueOfType<ReadonlyTypeOfType<T>> | NullType;
     constructor(typeDef: T, prototype: ValueOfType<ReadonlyTypeOfType<T>>, nullType: NullType, defaultToNull?: boolean);
     convert(from: ValueOfType<ReadonlyTypeOfType<T>> | NullType): AnnotatedFieldConversion<boolean>;
-    revert(from: boolean): UnreliableFieldConversion<ValueOfType<ReadonlyTypeOfType<T>> | NullType, E>;
+    revert(from: boolean): UnreliableFieldConversion<ValueOfType<ReadonlyTypeOfType<T>> | NullType, never>;
     create(): ValueOfType<ReadonlyTypeOfType<T>> | NullType;
 }
 
@@ -269,7 +273,7 @@ type ErrorRendererProps<E> = {
     error: E;
 };
 type ErrorRenderer<E = any> = ComponentType<ErrorRendererProps<E>>;
-declare function DefaultErrorRenderer({ error, }: ErrorRendererProps<any>): any;
+declare function DefaultErrorRenderer({ error, }: ErrorRendererProps<any>): string;
 
 type ValueTypeOfField<F extends Field> = F extends Field<infer V> ? V : never;
 
@@ -319,8 +323,10 @@ type MantineForm<F extends Fields> = {
     onFieldBlur: ((this: void, key: keyof F) => void) | undefined;
     onFieldSubmit: ((this: void, key: keyof F) => boolean | void) | undefined;
 };
-type MantineFieldComponent<T, P = T, E = any> = UnsafePartialComponent<ComponentType<P>, T, {
-    ErrorRenderer?: ErrorRenderer<E>;
+type MantineFieldComponent<T, P = T, E = any> = UnsafePartialComponent<ComponentType<P>, T, [
+    E
+] extends [never] ? {} : {
+    ErrorRenderer: ErrorRenderer<E>;
 }>;
 
 type SuppliedCheckboxProps = Pick<CheckboxProps, 'name' | 'checked' | 'disabled' | 'required' | 'error' | 'onChange' | 'onFocus' | 'onBlur' | 'onKeyUp'>;
@@ -384,21 +390,21 @@ declare class MantineFormImpl<F extends Fields> implements MantineForm<F> {
     onFieldBlur: ((this: void, key: keyof F) => void) | undefined;
     onFieldSubmit: ((this: void, key: keyof F) => boolean | void) | undefined;
     constructor(fields: F);
-    textInput<K extends keyof StringFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedTextInputProps, TextInputProps>;
-    textInput<K extends keyof StringFieldsOfFields<F>, P extends SuppliedTextInputProps<any>>(valuePath: K, TextInput?: ComponentType<P>): MantineFieldComponent<SuppliedTextInputProps, P>;
+    textInput<K extends keyof StringFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedTextInputProps, TextInputProps, ErrorOfField<F[K]>>;
+    textInput<K extends keyof StringFieldsOfFields<F>, P extends SuppliedTextInputProps<any>>(valuePath: K, TextInput?: ComponentType<P>): MantineFieldComponent<SuppliedTextInputProps, P, ErrorOfField<F[K]>>;
     valueInput<K extends keyof AllFieldsOfFields<F>, P extends SuppliedValueInputProps<ValueTypeOfField<F[K]>, any>>(valuePath: K, ValueInput: ComponentType<P>): MantineFieldComponent<SuppliedValueInputProps<ValueTypeOfField<F[K]>>, P, ErrorOfField<F[K]>>;
     select<K extends keyof StringFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedTextInputProps, ComponentProps<typeof SimpleSelect>, ErrorOfField<F[K]>>;
-    checkbox<K extends keyof BooleanFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedCheckboxProps, CheckboxProps>;
+    checkbox<K extends keyof BooleanFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedCheckboxProps, CheckboxProps, ErrorOfField<F[K]>>;
     checkbox<K extends keyof BooleanFieldsOfFields<F>, P extends SuppliedCheckboxProps>(valuePath: K, Checkbox: ComponentType<P>): MantineFieldComponent<SuppliedCheckboxProps, P, ErrorOfField<F[K]>>;
-    radioGroup<K extends keyof StringFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedRadioGroupProps, RadioGroupProps>;
-    radioGroup<K extends keyof StringFieldsOfFields<F>, P extends SuppliedRadioGroupProps>(valuePath: K, RadioGroup: ComponentType<P>): MantineFieldComponent<SuppliedRadioGroupProps, P>;
+    radioGroup<K extends keyof StringFieldsOfFields<F>, P extends RadioGroupProps = RadioGroupProps>(valuePath: K): MantineFieldComponent<SuppliedRadioGroupProps, P, ErrorOfField<F[K]>>;
+    radioGroup<K extends keyof StringFieldsOfFields<F>, P extends SuppliedRadioGroupProps>(valuePath: K, RadioGroup: ComponentType<P>): MantineFieldComponent<SuppliedRadioGroupProps, P, ErrorOfField<F[K]>>;
     radio<K extends keyof StringFieldsOfFields<F>>(valuePath: K, value: ValueTypeOfField<F[K]>): MantineFieldComponent<SuppliedRadioProps, RadioProps, ErrorOfField<F[K]>>;
     radio<K extends keyof StringFieldsOfFields<F>, P extends SuppliedRadioProps>(valuePath: K, value: ValueTypeOfField<F[K]>, Radio: ComponentType<P>): MantineFieldComponent<SuppliedRadioProps, P, ErrorOfField<F[K]>>;
     pill<K extends keyof AllFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedPillProps, PillProps, ErrorOfField<F[K]>>;
-    pill<K extends keyof AllFieldsOfFields<F>, P extends SuppliedPillProps>(valuePath: K, Pill: ComponentType<P>): MantineFieldComponent<SuppliedPillProps, P>;
-    list<K extends keyof ListFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedListProps<`${K}.${number}`>, ComponentProps<typeof DefaultList<ElementOfArray<F[K]['value']>, K>>>;
-    fieldsView<K extends keyof AllFieldsOfFields<F>, P extends FieldsViewProps<Fields> = FieldsViewProps<SubFormFields<F, K>>>(valuePath: K, FieldsView: ComponentType<P>): MantineFieldComponent<FieldsViewProps<P['fields']>, P>;
-    form<K extends keyof AllFieldsOfFields<F>, P extends FormProps<ValueTypeOfField<F[K]>> = FormProps<ValueTypeOfField<F[K]>>>(valuePath: K, Form: ComponentType<P>): MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P>;
+    pill<K extends keyof AllFieldsOfFields<F>, P extends SuppliedPillProps>(valuePath: K, Pill: ComponentType<P>): MantineFieldComponent<SuppliedPillProps, P, ErrorOfField<F[K]>>;
+    list<K extends keyof ListFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedListProps<`${K}.${number}`>, ComponentProps<typeof DefaultList<ElementOfArray<F[K]['value']>, K>>, never>;
+    fieldsView<K extends keyof AllFieldsOfFields<F>, P extends FieldsViewProps<Fields> = FieldsViewProps<SubFormFields<F, K>>>(valuePath: K, FieldsView: ComponentType<P>): MantineFieldComponent<FieldsViewProps<P['fields']>, P, never>;
+    form<K extends keyof AllFieldsOfFields<F>, P extends FormProps<ValueTypeOfField<F[K]>> = FormProps<ValueTypeOfField<F[K]>>>(valuePath: K, Form: ComponentType<P>): MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P, never>;
 }
 
 type MergedOfValidators<Validators1 extends Partial<Readonly<Record<Keys, Validator>>>, Validators2 extends Partial<Readonly<Record<Keys, Validator>>>, Keys extends string = Extract<keyof Validators1 | keyof Validators2, string>> = Simplify<{