@strictly/react-form 0.0.7 → 0.0.9

package/dist/index.js

@@ -52,18 +52,18 @@ function chainAnnotatedFieldConverter(from, to) {
   return function(value, valuePath, context) {
     const {
       required: intermediateRequired,
-      readonly: intermediateDisabled,
+      readonly: intermediateReadonly,
       value: intermediateValue
     } = from(value, valuePath, context);
     const {
       required: finalRequired,
-      readonly: finalDisabled,
+      readonly: finalReadonly,
       value: finalValue
     } = to(intermediateValue, valuePath, context);
     return {
       value: finalValue,
       required: intermediateRequired || finalRequired,
-      readonly: intermediateDisabled || finalDisabled
+      readonly: intermediateReadonly || finalReadonly
     };
   };
 }
@@ -102,6 +102,25 @@ var MaybeIdentityConverter = class {
   }
 };
 
+// field_converters/trimming_string_converter.ts
+var TrimmingStringConverter = class {
+  constructor() {
+  }
+  convert(to) {
+    return {
+      value: to.trim(),
+      required: false,
+      readonly: false
+    };
+  }
+  revert(from) {
+    return {
+      type: 0 /* Success */,
+      value: from.trim()
+    };
+  }
+};
+
 // field_value_factories/prototyping_field_value_factory.ts
 function prototypingFieldValueFactory(prototype) {
   return function() {
@@ -136,6 +155,32 @@ var FieldAdapterBuilder = class _FieldAdapterBuilder {
       reverter
     );
   }
+  nullable() {
+    return this.or(null);
+  }
+  optional() {
+    return this.or(void 0);
+  }
+  or(proto) {
+    function isFrom(v) {
+      return v !== proto;
+    }
+    function isTo(v) {
+      return v !== proto;
+    }
+    return new _FieldAdapterBuilder(
+      (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: 0 /* Success */,
+        value: proto
+      }
+    );
+  }
   withIdentity(isFrom) {
     const identityConverter = new MaybeIdentityConverter({
       convert: this.convert,
@@ -173,6 +218,12 @@ function identityAdapter(prototype, required) {
     unreliableIdentityConverter()
   );
 }
+function trimmingStringAdapter() {
+  return adapterFromTwoWayConverter(
+    new TrimmingStringConverter(),
+    prototypingFieldValueFactory("")
+  );
+}
 function listAdapter() {
   return new FieldAdapterBuilder(
     annotatedIdentityConverter(false),
@@ -660,7 +711,10 @@ import {
   useCallback,
   useMemo
 } from "react";
-function useDefaultMobxFormHooks(presenter, value, onValidSubmit) {
+function useDefaultMobxFormHooks(presenter, value, {
+  onValidFieldSubmit,
+  onValidFormSubmit
+} = {}) {
   const model = useMemo(function() {
     return presenter.createModel(value);
   }, [
@@ -680,14 +734,14 @@ function useDefaultMobxFormHooks(presenter, value, onValidSubmit) {
   const onFieldSubmit = useCallback(
     function(valuePath) {
       if (presenter.validateField(model, valuePath)) {
-        onValidSubmit?.(model, valuePath);
+        onValidFieldSubmit?.(model, valuePath);
       }
       return false;
     },
     [
       presenter,
       model,
-      onValidSubmit
+      onValidFieldSubmit
     ]
   );
   const onFieldBlur = useCallback(
@@ -703,11 +757,24 @@ function useDefaultMobxFormHooks(presenter, value, onValidSubmit) {
       model
     ]
   );
+  const onFormSubmit = useCallback(
+    function() {
+      if (presenter.validateAll(model)) {
+        onValidFormSubmit?.(model, model.value);
+      }
+    },
+    [
+      presenter,
+      model,
+      onValidFormSubmit
+    ]
+  );
   return {
     model,
     onFieldValueChange,
     onFieldSubmit,
-    onFieldBlur
+    onFieldBlur,
+    onFormSubmit
   };
 }
 
@@ -793,32 +860,34 @@ function mergeAdaptersWithValidators(adapters, validators) {
 import {
   flattenValuesOfType as flattenValuesOfType2
 } from "@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 = flattenValuesOfType2(contextType, context)[prefix];
+    const parentValuePath = valuePath.split(".").slice(0, dotCount).join(".");
+    const subValuePath = valuePath.replace(parentValuePath, "$");
+    const subContext = flattenValuesOfType2(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;
   }, {});
 }
@@ -988,25 +1057,6 @@ var SelectStringConverter = class extends AbstractSelectValueTypeConverter {
   }
 };
 
-// field_converters/trimming_string_converter.ts
-var TrimmingStringConverter = class {
-  constructor() {
-  }
-  convert(to) {
-    return {
-      value: to.trim(),
-      required: false,
-      readonly: false
-    };
-  }
-  revert(from) {
-    return {
-      type: 0 /* Success */,
-      value: from.trim()
-    };
-  }
-};
-
 // field_converters/validating_converter.ts
 import {
   validate as validate2
@@ -1040,7 +1090,7 @@ function DefaultErrorRenderer({
   error
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 }) {
-  return error;
+  return JSON.stringify(error);
 }
 
 // mantine/hooks.tsx
@@ -1288,15 +1338,19 @@ function createFieldsView(valuePath, FieldsView, observableProps) {
     observableProps.onFieldSubmit?.(toKey(subKey));
   }
   return observer2(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__ */ jsx3(
       FieldsView,
       {
@@ -1454,13 +1508,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,
@@ -1762,6 +1819,7 @@ export {
   mergeValidators,
   prototypingFieldValueFactory,
   subFormFieldAdapters,
+  trimmingStringAdapter,
   useDefaultMobxFormHooks,
   useMantineFormFields,
   usePartialComponent,

package/field_converters/chain_field_converter.ts

@@ -71,18 +71,18 @@ export function chainAnnotatedFieldConverter<
   return function (value: From, valuePath: ValuePath, context: Context): AnnotatedFieldConversion {
     const {
       required: intermediateRequired,
-      readonly: intermediateDisabled,
+      readonly: intermediateReadonly,
       value: intermediateValue,
     } = from(value, valuePath, context)
     const {
       required: finalRequired,
-      readonly: finalDisabled,
+      readonly: finalReadonly,
       value: finalValue,
     } = to(intermediateValue, valuePath, context)
     return {
       value: finalValue,
       required: intermediateRequired || finalRequired,
-      readonly: intermediateDisabled || finalDisabled,
+      readonly: intermediateReadonly || finalReadonly,
     }
   }
 }

package/field_converters/nullable_to_boolean_converter.ts

@@ -13,14 +13,13 @@ import {
 
 export class NullableToBooleanConverter<
   T extends Type,
-  E,
   ValuePath extends string,
   Context,
   NullType extends null | undefined,
 > implements TwoWayFieldConverterWithValueFactory<
   ValueOfType<ReadonlyTypeOfType<T>> | NullType,
   boolean,
-  E,
+  never,
   ValuePath,
   Context
 > {
@@ -43,7 +42,7 @@ export class NullableToBooleanConverter<
     }
   }
 
-  revert(from: boolean): UnreliableFieldConversion<ValueOfType<ReadonlyTypeOfType<T>> | NullType, E> {
+  revert(from: boolean): UnreliableFieldConversion<ValueOfType<ReadonlyTypeOfType<T>> | NullType, never> {
     if (from) {
       const value: ValueOfType<T> = copy(this.typeDef, this.prototype)
       return {

package/mantine/create_checkbox.tsx

@@ -78,9 +78,10 @@ export function createCheckbox<
       onKeyUp,
     }
   }
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return createUnsafePartialObserverComponent(
     Checkbox,
     propSource,
     ['ErrorRenderer'],
-  )
+  ) as MantineFieldComponent<SuppliedCheckboxProps, Props, ErrorOfField<F[K]>>
 }

package/mantine/create_fields_view.tsx

@@ -18,7 +18,7 @@ export function createFieldsView<
   valuePath: K,
   FieldsView: ComponentType<P>,
   observableProps: FieldsViewProps<F>,
-): MantineFieldComponent<FieldsViewProps<P['fields']>, P> {
+): MantineFieldComponent<FieldsViewProps<P['fields']>, P, never> {
   function toKey(subKey: string | number | symbol): string {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return (subKey as string).replace('$', valuePath as string)
@@ -49,18 +49,22 @@ export function createFieldsView<
   }
 
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return observer(function (props: ComponentProps<MantineFieldComponent<FieldsViewProps<P['fields']>, P>>) {
+  return observer(function (props: ComponentProps<MantineFieldComponent<FieldsViewProps<P['fields']>, P, never>>) {
     // convert fields to sub-fields
-    const subFields = Object.entries(observableProps.fields).reduce<Record<string, unknown>>((acc, [
-      fieldKey,
-      fieldValue,
-    ]) => {
+    const subFields = Object.entries(observableProps.fields).reduce<Record<string, unknown>>(
+      (acc, [
+        fieldKey,
+        fieldValue,
+      ]) => {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        if (fieldKey.startsWith(valuePath as string)) {
+          acc[toSubKey(fieldKey)] = fieldValue
+        }
+        return acc
+      },
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      if (fieldKey.startsWith(valuePath as string)) {
-        acc[toSubKey(fieldKey)] = fieldValue
-      }
-      return acc
-    }, {})
+      {} as P['fields'],
+    )
 
     return (
       <FieldsView
@@ -69,13 +73,12 @@ export function createFieldsView<
           // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
           ...props as any
         }
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        fields={subFields as P['fields']}
+        fields={subFields}
         onFieldBlur={onFieldBlur}
         onFieldFocus={onFieldFocus}
         onFieldSubmit={onFieldSubmit}
         onFieldValueChange={onFieldValueChange}
       />
     )
-  }) as unknown as MantineFieldComponent<FieldsViewProps<P['fields']>, P>
+  }) as unknown as MantineFieldComponent<FieldsViewProps<P['fields']>, P, never>
 }

package/mantine/create_form.tsx

@@ -21,7 +21,7 @@ export function createForm<
   valuePath: K,
   Form: ComponentType<P>,
   observableProps: FieldsViewProps<F>,
-): MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P> {
+): MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P, never> {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return observer((props: ComponentProps<MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P>>) => {
     const { value } = observableProps.fields[valuePath]
@@ -39,5 +39,5 @@ export function createForm<
         value={value}
       />
     )
-  }) as MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P>
+  }) as MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P, never>
 }

package/mantine/create_list.tsx

@@ -29,7 +29,7 @@ export function createList<
   this: MantineForm<F>,
   valuePath: K,
   List: ComponentType<Props>,
-): MantineFieldComponent<SuppliedListProps<ElementOfArray<ValueTypeOfField<F[K]>>>, Props> {
+): MantineFieldComponent<SuppliedListProps<ElementOfArray<ValueTypeOfField<F[K]>>>, Props, never> {
   const propSource = () => {
     const values = [...this.fields[valuePath].value]
     return {

package/mantine/create_pill.tsx

@@ -25,7 +25,7 @@ export function createPill<
   this: MantineForm<F>,
   valuePath: K,
   Pill: ComponentType<Props>,
-): MantineFieldComponent<SuppliedPillProps, Props> {
+): MantineFieldComponent<SuppliedPillProps, Props, never> {
   const propSource = () => {
     const {
       readonly,

package/mantine/create_radio.tsx

@@ -22,7 +22,7 @@ export function createRadio<
   valuePath: K,
   value: ValueTypeOfField<F[K]>,
   Radio: ComponentType<Props>,
-): MantineFieldComponent<SuppliedRadioProps, Props> {
+): MantineFieldComponent<SuppliedRadioProps, Props, never> {
   const propSource = () => {
     return {
       disabled: this.fields[valuePath].readonly,

package/mantine/create_radio_group.tsx

@@ -68,6 +68,10 @@ export function createRadioGroup<
       onKeyUp,
     }
   }
-
-  return createUnsafePartialObserverComponent(RadioGroup, propSource, ['ErrorRenderer'])
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return createUnsafePartialObserverComponent(RadioGroup, propSource, ['ErrorRenderer']) as MantineFieldComponent<
+    SuppliedRadioGroupProps,
+    Props,
+    ErrorOfField<F[K]>
+  >
 }

package/mantine/create_text_input.tsx

@@ -59,13 +59,18 @@ export function createTextInput<
   }: {
     ErrorRenderer?: ErrorRenderer<ErrorOfField<F[K]>>,
   }) => {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const field = this.fields[valuePath as string]
+    if (field == null) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      throw new Error(`invalid field ${valuePath as string}`)
+    }
     const {
       readonly,
       required,
       value,
       error,
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    } = this.fields[valuePath as string]
+    } = field
     return {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       name: valuePath as string,
@@ -79,6 +84,7 @@ export function createTextInput<
       onKeyUp,
     }
   }
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return createUnsafePartialObserverComponent<
     typeof TextInput,
     SuppliedTextInputProps,
@@ -88,5 +94,5 @@ export function createTextInput<
     TextInput,
     propSource,
     ['ErrorRenderer'],
-  )
+  ) as MantineFieldComponent<SuppliedTextInputProps, Props, ErrorOfField<F[K]>>
 }

package/mantine/create_value_input.tsx

@@ -77,6 +77,7 @@ export function createValueInput<
       onKeyUp,
     }
   }
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return createUnsafePartialObserverComponent<
     typeof ValueInput,
     SuppliedValueInputProps<ValueTypeOfField<F[K]>>,
@@ -86,5 +87,5 @@ export function createValueInput<
     ValueInput,
     propSource,
     ['ErrorRenderer'],
-  )
+  ) as MantineFieldComponent<SuppliedValueInputProps<ValueTypeOfField<F[K]>>, Props, ErrorOfField<F[K]>>
 }

package/mantine/error_renderer.ts

@@ -1,15 +1,24 @@
 import { type ComponentType } from 'react'
+import { type ErrorOfField } from 'types/error_of_field'
+import { type Fields } from 'types/field'
 
-export type ErrorRendererProps<E> = {
+type InternalErrorRendererProps<E> = {
   error: E,
 }
 
+export type ErrorRendererProps<
+  F extends Fields,
+  K extends keyof Fields,
+> = InternalErrorRendererProps<
+  ErrorOfField<F[K]>
+>
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type ErrorRenderer<E = any> = ComponentType<ErrorRendererProps<E>>
+export type ErrorRenderer<E = any> = ComponentType<InternalErrorRendererProps<E>>
 
 export function DefaultErrorRenderer({
   error,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-}: ErrorRendererProps<any>) {
-  return error
+}: InternalErrorRendererProps<any>) {
+  return JSON.stringify(error)
 }

package/mantine/hooks.tsx

@@ -209,7 +209,7 @@ class MantineFormImpl<
 
   textInput<
     K extends keyof StringFieldsOfFields<F>,
-  >(valuePath: K): MantineFieldComponent<SuppliedTextInputProps, TextInputProps>
+  >(valuePath: K): MantineFieldComponent<SuppliedTextInputProps, TextInputProps, ErrorOfField<F[K]>>
   textInput<
     K extends keyof StringFieldsOfFields<F>,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -217,7 +217,7 @@ class MantineFormImpl<
   >(
     valuePath: K,
     TextInput?: ComponentType<P>,
-  ): MantineFieldComponent<SuppliedTextInputProps, P>
+  ): MantineFieldComponent<SuppliedTextInputProps, P, ErrorOfField<F[K]>>
   textInput<
     K extends keyof StringFieldsOfFields<F>,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -264,7 +264,7 @@ class MantineFormImpl<
 
   checkbox<
     K extends keyof BooleanFieldsOfFields<F>,
-  >(valuePath: K): MantineFieldComponent<SuppliedCheckboxProps, CheckboxProps>
+  >(valuePath: K): MantineFieldComponent<SuppliedCheckboxProps, CheckboxProps, ErrorOfField<F[K]>>
   checkbox<
     K extends keyof BooleanFieldsOfFields<F>,
     P extends SuppliedCheckboxProps,
@@ -282,19 +282,21 @@ class MantineFormImpl<
       valuePath,
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       Checkbox as ComponentType<SuppliedCheckboxProps>,
-    ) as MantineFieldComponent<SuppliedCheckboxProps, P>
+    ) as MantineFieldComponent<SuppliedCheckboxProps, P, ErrorOfField<F[K]>>
   }
 
+  // this should work?
   radioGroup<
     K extends keyof StringFieldsOfFields<F>,
-  >(valuePath: K): MantineFieldComponent<SuppliedRadioGroupProps, RadioGroupProps>
+    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>
+  ): MantineFieldComponent<SuppliedRadioGroupProps, P, ErrorOfField<F[K]>>
   radioGroup<
     K extends keyof StringFieldsOfFields<F>,
     P extends SuppliedRadioGroupProps,
@@ -340,7 +342,7 @@ class MantineFormImpl<
       value,
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       Radio as ComponentType<SuppliedRadioProps>,
-    ) as MantineFieldComponent<SuppliedRadioProps, P>
+    ) as MantineFieldComponent<SuppliedRadioProps, P, ErrorOfField<F[K]>>
   }
 
   pill<
@@ -352,7 +354,7 @@ class MantineFormImpl<
   >(
     valuePath: K,
     Pill: ComponentType<P>,
-  ): MantineFieldComponent<SuppliedPillProps, P>
+  ): MantineFieldComponent<SuppliedPillProps, P, ErrorOfField<F[K]>>
   pill<
     K extends keyof AllFieldsOfFields<F>,
     P extends SuppliedPillProps,
@@ -373,7 +375,8 @@ class MantineFormImpl<
     K extends keyof ListFieldsOfFields<F>,
   >(valuePath: K): MantineFieldComponent<
     SuppliedListProps<`${K}.${number}`>,
-    ComponentProps<typeof DefaultList<ElementOfArray<F[K]['value']>, K>>
+    ComponentProps<typeof DefaultList<ElementOfArray<F[K]['value']>, K>>,
+    never
   > {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return this.listCache.retrieveOrCreate(
@@ -382,7 +385,7 @@ class MantineFormImpl<
     ) as MantineFieldComponent<
       SuppliedListProps<`${K}.${number}`>,
       ComponentProps<typeof DefaultList<ElementOfArray<F[K]['value']>, K>>,
-      ErrorOfField<F[K]>
+      never
     >
   }
 
@@ -391,7 +394,8 @@ class MantineFormImpl<
     P extends FieldsViewProps<Fields> = FieldsViewProps<SubFormFields<F, K>>,
   >(valuePath: K, FieldsView: ComponentType<P>): MantineFieldComponent<
     FieldsViewProps<P['fields']>,
-    P
+    P,
+    never
   > {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return this.fieldsViewCache.retrieveOrCreate(
@@ -402,7 +406,8 @@ class MantineFormImpl<
       this,
     ) as unknown as MantineFieldComponent<
       FieldsViewProps<P['fields']>,
-      P
+      P,
+      never
     >
   }
 
@@ -412,7 +417,7 @@ class MantineFormImpl<
   >(
     valuePath: K,
     Form: ComponentType<P>,
-  ): MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P> {
+  ): MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P, never> {
     // strip props from component since we lose information in the cache
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return this.formCache.retrieveOrCreate(
@@ -421,6 +426,6 @@ class MantineFormImpl<
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       Form as ComponentType,
       this,
-    ) as unknown as MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P>
+    ) as unknown as MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P, never>
   }
 }