@strictly/react-form 0.0.7 → 0.0.8

package/dist/index.d.ts

@@ -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<{

package/dist/index.js

@@ -660,7 +660,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 +683,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 +706,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 +809,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;
   }, {});
 }
@@ -1040,7 +1058,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 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 +1476,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/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

@@ -11,5 +11,5 @@ export function DefaultErrorRenderer({
   error,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 }: ErrorRendererProps<any>) {
-  return error
+  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>
   }
 }