@strictly/react-form 0.0.1 → 0.0.3

package/.out/field_converters/specs/chain_field_converter.tests.js

@@ -0,0 +1,251 @@
+import { chainAnnotatedFieldConverter, chainUnreliableFieldConverter, } from 'field_converters/chain_field_converter';
+import { UnreliableFieldConversionType, } from 'types/field_converters';
+const CONTEXT = 'ctx';
+const ERROR1 = 'error 1';
+const ERROR2 = 'error 2';
+describe('chainUnreliableFieldConverter', function () {
+    const from = vi.fn();
+    const to = vi.fn();
+    let chained;
+    let result;
+    beforeEach(function () {
+        from.mockReset();
+        to.mockReset();
+        chained = chainUnreliableFieldConverter(from, to);
+    });
+    describe('from succeeds', function () {
+        beforeEach(function () {
+            from.mockReturnValue({
+                type: UnreliableFieldConversionType.Success,
+                value: true,
+            });
+        });
+        describe('to succeeds', function () {
+            beforeEach(function () {
+                to.mockReturnValue({
+                    type: UnreliableFieldConversionType.Success,
+                    value: 'x',
+                });
+                result = chained(1, 'x', CONTEXT);
+            });
+            it('equals expected type', function () {
+                expect(result).toEqual({
+                    type: UnreliableFieldConversionType.Success,
+                    value: 'x',
+                });
+            });
+            it('has the original value passed to the from converter', function () {
+                expect(from).toHaveBeenCalledOnce();
+                expect(from).toHaveBeenCalledWith(1, 'x', CONTEXT);
+            });
+            it('has passed the from result to the to converter', function () {
+                expect(to).toHaveBeenCalledOnce();
+                expect(to).toHaveBeenCalledWith(true, 'x', CONTEXT);
+            });
+        });
+        describe('to fails with result', function () {
+            beforeEach(function () {
+                to.mockReturnValue({
+                    type: UnreliableFieldConversionType.Failure,
+                    value: ['y'],
+                    error: ERROR2,
+                });
+                result = chained(1, 'x', CONTEXT);
+            });
+            it('equals expected type', function () {
+                expect(result).toEqual({
+                    type: UnreliableFieldConversionType.Failure,
+                    value: ['y'],
+                    error: ERROR2,
+                });
+            });
+        });
+    });
+    describe('from fails with a value', function () {
+        beforeEach(function () {
+            from.mockReturnValue({
+                type: UnreliableFieldConversionType.Failure,
+                value: [true],
+                error: ERROR1,
+            });
+        });
+        describe('to succeeds', function () {
+            beforeEach(function () {
+                to.mockReturnValue({
+                    type: UnreliableFieldConversionType.Success,
+                    value: 'x',
+                });
+                result = chained(1, 'x', CONTEXT);
+            });
+            it('equals expected type', function () {
+                expect(result).toEqual({
+                    type: UnreliableFieldConversionType.Failure,
+                    value: ['x'],
+                    error: ERROR1,
+                });
+            });
+            it('has the original value passed to the from converter', function () {
+                expect(from).toHaveBeenCalledOnce();
+                expect(from).toHaveBeenCalledWith(1, 'x', CONTEXT);
+            });
+            it('passes the failure result to the to converter', function () {
+                expect(to).toHaveBeenCalledOnce();
+                expect(to).toHaveBeenCalledWith(true, 'x', CONTEXT);
+            });
+        });
+        describe('to fails', function () {
+            beforeEach(function () {
+                to.mockReturnValue({
+                    type: UnreliableFieldConversionType.Failure,
+                    value: ['x'],
+                    error: ERROR2,
+                });
+                result = chained(1, 'x', CONTEXT);
+            });
+            it('equals expected type', function () {
+                expect(result).toEqual({
+                    type: UnreliableFieldConversionType.Failure,
+                    value: ['x'],
+                    error: ERROR1,
+                });
+            });
+        });
+    });
+    describe('from fails with no value', function () {
+        beforeEach(function () {
+            from.mockReturnValue({
+                type: UnreliableFieldConversionType.Failure,
+                value: null,
+                error: ERROR1,
+            });
+            result = chained(1, 'x', CONTEXT);
+        });
+        it('equals expected type', function () {
+            expect(result).toEqual({
+                type: UnreliableFieldConversionType.Failure,
+                value: null,
+                error: ERROR1,
+            });
+        });
+        it('does not call to converter', function () {
+            expect(to).not.toHaveBeenCalled();
+        });
+    });
+});
+describe('chainAnnotatedFieldConverter', function () {
+    const from = vi.fn();
+    const to = vi.fn();
+    let chained;
+    let result;
+    beforeEach(function () {
+        from.mockReset();
+        to.mockReset();
+        chained = chainAnnotatedFieldConverter(from, to);
+    });
+    describe('value', function () {
+        beforeEach(function () {
+            from.mockReturnValue({
+                value: true,
+                readonly: false,
+                required: false,
+            });
+            to.mockReturnValue({
+                value: 1,
+                readonly: false,
+                required: false,
+            });
+            result = chained('z', 'x', CONTEXT);
+        });
+        it('returns expected value', function () {
+            expect(result).toEqual(expect.objectContaining({
+                value: 1,
+            }));
+        });
+        it('calls the from converter', function () {
+            expect(from).toHaveBeenCalledOnce();
+            expect(from).toHaveBeenCalledWith('z', 'x', CONTEXT);
+        });
+        it('calls the to converter', function () {
+            expect(to).toHaveBeenCalledOnce();
+            expect(to).toHaveBeenCalledWith(true, 'x', CONTEXT);
+        });
+    });
+    describe.each([
+        [
+            true,
+            true,
+            true,
+        ],
+        [
+            true,
+            false,
+            true,
+        ],
+        [
+            false,
+            true,
+            true,
+        ],
+        [
+            false,
+            false,
+            false,
+        ],
+    ])('from required %s to required %s result %s', function (fromRequired, toRequired, required) {
+        beforeEach(function () {
+            from.mockReturnValue({
+                value: true,
+                readonly: false,
+                required: fromRequired,
+            });
+            to.mockReturnValue({
+                value: 1,
+                readonly: false,
+                required: toRequired,
+            });
+            result = chained('z', 'x', CONTEXT);
+        });
+        it('required matches expected', function () {
+            expect(result.required).toEqual(required);
+        });
+    });
+    describe.each([
+        [
+            true,
+            true,
+            true,
+        ],
+        [
+            true,
+            false,
+            true,
+        ],
+        [
+            false,
+            true,
+            true,
+        ],
+        [
+            false,
+            false,
+            false,
+        ],
+    ])('from disabled %s to disabled %s result %s', function (fromDisabled, toDisabled, disabled) {
+        beforeEach(function () {
+            from.mockReturnValue({
+                value: true,
+                readonly: fromDisabled,
+                required: false,
+            });
+            to.mockReturnValue({
+                value: 1,
+                readonly: toDisabled,
+                required: false,
+            });
+            result = chained('z', 'x', CONTEXT);
+        });
+        it('required matches expected', function () {
+            expect(result.readonly).toEqual(disabled);
+        });
+    });
+});

package/.out/field_converters/trimming_string_converter.d.ts

@@ -1,6 +1,6 @@
-import { type FieldConversion, type TwoWayFieldConverter } from 'types/field_converters';
+import { type AnnotatedFieldConversion, type TwoWayFieldConverter, type UnreliableFieldConversion } from 'types/field_converters';
 export declare class TrimmingStringConverter<ValuePath extends string, Context> implements TwoWayFieldConverter<string, string, never, ValuePath, Context> {
     constructor();
-    convert(to: string): string;
-    revert(from: string): FieldConversion<string, never>;
+    convert(to: string): AnnotatedFieldConversion<string>;
+    revert(from: string): UnreliableFieldConversion<string, never>;
 }

package/.out/field_converters/trimming_string_converter.js

@@ -1,13 +1,17 @@
-import { FieldConversionResult, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/field_converters';
 export class TrimmingStringConverter {
     constructor() {
     }
     convert(to) {
-        return to.trim();
+        return {
+            value: to.trim(),
+            required: false,
+            readonly: false,
+        };
     }
     revert(from) {
         return {
-            type: FieldConversionResult.Success,
+            type: UnreliableFieldConversionType.Success,
             value: from.trim(),
         };
     }

package/.out/field_converters/validating_converter.d.ts

@@ -1,3 +1,3 @@
-import { type FieldConverter } from 'types/field_converters';
-import { type FieldValidator } from 'types/field_validator';
-export declare function validatingConverter<V, E, ValuePath extends string, Context>(validators?: readonly FieldValidator<V, E, ValuePath, Context>[]): FieldConverter<V, V, E, ValuePath, Context>;
+import { type Validator } from '@strictly/define';
+import { type UnreliableFieldConverter } from 'types/field_converters';
+export declare function validatingConverter<V, E, ValuePath extends string, Context>(validators?: readonly Validator<V, E, ValuePath, Context>[]): UnreliableFieldConverter<V, V, E, ValuePath, Context>;

package/.out/field_converters/validating_converter.js

@@ -1,12 +1,14 @@
-import { FieldConversionResult, } from 'types/field_converters';
+import { validate, } from '@strictly/define';
+import { UnreliableFieldConversionType, } from 'types/field_converters';
+// delete this?
 export function validatingConverter(validators = []) {
     return function (value, valuePath, context) {
         return validators.reduce(function (acc, validator) {
-            if (acc.type === FieldConversionResult.Success) {
-                const error = validator(value, valuePath, context);
+            if (acc.type === UnreliableFieldConversionType.Success) {
+                const error = validate(validator, value, valuePath, context);
                 if (error != null) {
                     return {
-                        type: FieldConversionResult.Failure,
+                        type: UnreliableFieldConversionType.Failure,
                         error,
                         value: [value],
                     };
@@ -14,7 +16,7 @@ export function validatingConverter(validators = []) {
             }
             return acc;
         }, {
-            type: FieldConversionResult.Success,
+            type: UnreliableFieldConversionType.Success,
             value,
         });
     };

package/.out/index.d.ts

@@ -1,6 +1,11 @@
+export * from './core/mobx/field_adapter';
 export * from './core/mobx/field_adapter_builder';
+export * from './core/mobx/field_adapters_of_values';
 export * from './core/mobx/flattened_adapters_of_fields';
+export * from './core/mobx/form_fields_of_field_adapters';
 export * from './core/mobx/form_presenter';
+export * from './core/mobx/merge_field_adapters_with_two_way_converter';
+export * from './core/mobx/merge_field_adapters_with_validators';
 export * from './core/mobx/types';
 export * from './core/props';
 export * from './field_converters/integer_to_string_converter';
@@ -8,9 +13,11 @@ export * from './field_converters/nullable_to_boolean_converter';
 export * from './field_converters/select_value_type_converter';
 export * from './field_converters/trimming_string_converter';
 export * from './field_converters/validating_converter';
-export * from './field_validators/minimum_string_length_field_validator';
 export * from './field_value_factories/prototyping_field_value_factory';
+export * from './mantine/error_renderer';
 export * from './mantine/hooks';
+export * from './types/error_of_field';
 export * from './types/field';
-export * from './types/flattened_form_fields_of';
+export * from './types/field_converters';
+export * from './types/merge_validators';
 export * from './util/partial';

package/.out/index.js

@@ -1,6 +1,11 @@
+export * from './core/mobx/field_adapter';
 export * from './core/mobx/field_adapter_builder';
+export * from './core/mobx/field_adapters_of_values';
 export * from './core/mobx/flattened_adapters_of_fields';
+export * from './core/mobx/form_fields_of_field_adapters';
 export * from './core/mobx/form_presenter';
+export * from './core/mobx/merge_field_adapters_with_two_way_converter';
+export * from './core/mobx/merge_field_adapters_with_validators';
 export * from './core/mobx/types';
 export * from './core/props';
 export * from './field_converters/integer_to_string_converter';
@@ -8,9 +13,11 @@ export * from './field_converters/nullable_to_boolean_converter';
 export * from './field_converters/select_value_type_converter';
 export * from './field_converters/trimming_string_converter';
 export * from './field_converters/validating_converter';
-export * from './field_validators/minimum_string_length_field_validator';
 export * from './field_value_factories/prototyping_field_value_factory';
+export * from './mantine/error_renderer';
 export * from './mantine/hooks';
+export * from './types/error_of_field';
 export * from './types/field';
-export * from './types/flattened_form_fields_of';
+export * from './types/field_converters';
+export * from './types/merge_validators';
 export * from './util/partial';

package/.out/mantine/create_checkbox.d.ts

@@ -1,9 +1,8 @@
 import { type CheckboxProps } from '@mantine/core';
 import { type ComponentType } from 'react';
 import { type BooleanFieldsOfFields } from 'types/boolean_fields_of_fields';
-import { type ErrorTypeOfField } from 'types/error_type_of_field';
+import { type ErrorOfField } from 'types/error_of_field';
 import { type Fields } from 'types/field';
-import { type ErrorRenderer } from './hooks';
 import { type MantineFieldComponent, type MantineForm } from './types';
 export type SuppliedCheckboxProps = Pick<CheckboxProps, 'name' | 'checked' | 'disabled' | 'required' | 'error' | 'onChange' | 'onFocus' | 'onBlur' | 'onKeyUp'>;
-export declare function createCheckbox<F extends Fields, K extends keyof BooleanFieldsOfFields<F>, Props extends SuppliedCheckboxProps>(this: MantineForm<F>, valuePath: K, Checkbox: ComponentType<Props>, ErrorRenderer: ErrorRenderer<ErrorTypeOfField<F[K]>>): MantineFieldComponent<SuppliedCheckboxProps, Props>;
+export declare function createCheckbox<F extends Fields, K extends keyof BooleanFieldsOfFields<F>, Props extends SuppliedCheckboxProps>(this: MantineForm<F>, valuePath: K, Checkbox: ComponentType<Props>): MantineFieldComponent<SuppliedCheckboxProps, Props, ErrorOfField<F[K]>>;

package/.out/mantine/create_checkbox.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createUnsafePartialObserverComponent } from 'util/partial';
-export function createCheckbox(valuePath, Checkbox, ErrorRenderer) {
+import { DefaultErrorRenderer, } from './error_renderer';
+export function createCheckbox(valuePath, Checkbox) {
     const onChange = (e) => {
         this.onFieldValueChange?.(valuePath, e.target.checked);
     };
@@ -17,14 +18,14 @@ export function createCheckbox(valuePath, Checkbox, ErrorRenderer) {
             }
         }
     };
-    const propSource = () => {
-        const { disabled, required, value, error,
+    const propSource = ({ ErrorRenderer = DefaultErrorRenderer, }) => {
+        const { readonly, required, value, error,
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
          } = this.fields[valuePath];
         return {
             name: valuePath,
             checked: value,
-            disabled,
+            disabled: readonly,
             required,
             error: error && _jsx(ErrorRenderer, { error: error }),
             onChange,
@@ -33,5 +34,5 @@ export function createCheckbox(valuePath, Checkbox, ErrorRenderer) {
             onKeyUp,
         };
     };
-    return createUnsafePartialObserverComponent(Checkbox, propSource);
+    return createUnsafePartialObserverComponent(Checkbox, propSource, ['ErrorRenderer']);
 }

package/.out/mantine/create_pill.js

@@ -1,14 +1,14 @@
 import { createUnsafePartialObserverComponent } from 'util/partial';
 export function createPill(valuePath, Pill) {
     const propSource = () => {
-        const { disabled, value,
+        const { readonly, value,
         // note: individual pills cannot display an error!
         // error,
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
          } = this.fields[valuePath];
         return {
             children: value,
-            disabled,
+            disabled: readonly,
         };
     };
     return createUnsafePartialObserverComponent(Pill, propSource);

package/.out/mantine/create_radio.js

@@ -2,7 +2,7 @@ import { createUnsafePartialObserverComponent } from 'util/partial';
 export function createRadio(valuePath, value, Radio) {
     const propSource = () => {
         return {
-            disabled: this.fields[valuePath].disabled,
+            disabled: this.fields[valuePath].readonly,
             value,
         };
     };

package/.out/mantine/create_radio_group.d.ts

@@ -1,9 +1,8 @@
 import { type RadioGroupProps } from '@mantine/core';
 import { type ComponentType } from 'react';
-import { type ErrorTypeOfField } from 'types/error_type_of_field';
+import { type ErrorOfField } from 'types/error_of_field';
 import { type Fields } from 'types/field';
 import { type StringFieldsOfFields } from 'types/string_fields_of_fields';
-import { type ErrorRenderer } from './hooks';
 import { type MantineFieldComponent, type MantineForm } from './types';
 export type SuppliedRadioGroupProps = Pick<RadioGroupProps, 'name' | 'value' | 'required' | 'error' | 'onChange' | 'onFocus' | 'onBlur' | 'onKeyUp'>;
-export declare function createRadioGroup<F extends Fields, K extends keyof StringFieldsOfFields<F>, Props extends SuppliedRadioGroupProps>(this: MantineForm<F>, valuePath: K, RadioGroup: ComponentType<Props>, ErrorRenderer: ErrorRenderer<ErrorTypeOfField<F[K]>>): MantineFieldComponent<SuppliedRadioGroupProps, Props>;
+export declare function createRadioGroup<F extends Fields, K extends keyof StringFieldsOfFields<F>, Props extends SuppliedRadioGroupProps>(this: MantineForm<F>, valuePath: K, RadioGroup: ComponentType<Props>): MantineFieldComponent<SuppliedRadioGroupProps, Props, ErrorOfField<F[K]>>;

package/.out/mantine/create_radio_group.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createUnsafePartialObserverComponent, } from 'util/partial';
-export function createRadioGroup(valuePath, RadioGroup, ErrorRenderer) {
+import { DefaultErrorRenderer, } from './error_renderer';
+export function createRadioGroup(valuePath, RadioGroup) {
     const onChange = (value) => {
         this.onFieldValueChange?.(valuePath, value);
     };
@@ -17,7 +18,7 @@ export function createRadioGroup(valuePath, RadioGroup, ErrorRenderer) {
             }
         }
     };
-    const propSource = () => {
+    const propSource = ({ ErrorRenderer = DefaultErrorRenderer }) => {
         const { required, value, error, } = this.fields[valuePath];
         return {
             name: valuePath,
@@ -30,5 +31,5 @@ export function createRadioGroup(valuePath, RadioGroup, ErrorRenderer) {
             onKeyUp,
         };
     };
-    return createUnsafePartialObserverComponent(RadioGroup, propSource);
+    return createUnsafePartialObserverComponent(RadioGroup, propSource, ['ErrorRenderer']);
 }

package/.out/mantine/create_text_input.d.ts

@@ -1,7 +1,6 @@
-import { type ErrorTypeOfField } from 'types/error_type_of_field';
+import { type ErrorOfField } from 'types/error_of_field';
 import { type Fields } from 'types/field';
 import { type StringFieldsOfFields } from 'types/string_fields_of_fields';
-import { type ErrorRenderer } from './hooks';
 import { type MantineFieldComponent, type MantineForm } from './types';
 export type TextInputTarget = Element & {
     value: string;
@@ -16,4 +15,4 @@ export type SuppliedTextInputProps<T extends TextInputTarget = TextInputTarget>
     onBlur: (e: React.FocusEvent<T>) => void;
     onKeyUp: (e: React.KeyboardEvent<T>) => void;
 }>;
-export declare function createTextInput<F extends Fields, K extends keyof StringFieldsOfFields<F>, Props extends SuppliedTextInputProps>(this: MantineForm<F>, valuePath: K, TextInput: React.ComponentType<Props>, ErrorRenderer: ErrorRenderer<ErrorTypeOfField<F[K]>>): MantineFieldComponent<SuppliedTextInputProps, Props>;
+export declare function createTextInput<F extends Fields, K extends keyof StringFieldsOfFields<F>, Props extends SuppliedTextInputProps>(this: MantineForm<F>, valuePath: K, TextInput: React.ComponentType<Props>): MantineFieldComponent<SuppliedTextInputProps, Props, ErrorOfField<F[K]>>;

package/.out/mantine/create_text_input.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createUnsafePartialObserverComponent } from 'util/partial';
-export function createTextInput(valuePath, TextInput, ErrorRenderer) {
+import { DefaultErrorRenderer, } from './error_renderer';
+export function createTextInput(valuePath, TextInput) {
     const onChange = (e) => {
         this.onFieldValueChange?.(valuePath, e.target.value);
     };
@@ -17,15 +18,15 @@ export function createTextInput(valuePath, TextInput, ErrorRenderer) {
             }
         }
     };
-    const propSource = () => {
-        const { disabled, required, value, error,
+    const propSource = ({ ErrorRenderer = DefaultErrorRenderer, }) => {
+        const { readonly, required, value, error,
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
          } = this.fields[valuePath];
         return {
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             name: valuePath,
             value,
-            disabled,
+            disabled: readonly,
             required,
             error: error && _jsx(ErrorRenderer, { error: error }),
             onChange,
@@ -34,5 +35,5 @@ export function createTextInput(valuePath, TextInput, ErrorRenderer) {
             onKeyUp,
         };
     };
-    return createUnsafePartialObserverComponent(TextInput, propSource);
+    return createUnsafePartialObserverComponent(TextInput, propSource, ['ErrorRenderer']);
 }

package/.out/mantine/create_value_input.d.ts

@@ -1,8 +1,7 @@
 import { type AllFieldsOfFields } from 'types/all_fields_of_fields';
-import { type ErrorTypeOfField } from 'types/error_type_of_field';
+import { type ErrorOfField } from 'types/error_of_field';
 import { type Fields } from 'types/field';
 import { type ValueTypeOfField } from 'types/value_type_of_field';
-import { type ErrorRenderer } from './hooks';
 import { type MantineFieldComponent, type MantineForm } from './types';
 export type SuppliedValueInputProps<V, T extends Element = Element> = Partial<{
     name: string;
@@ -14,4 +13,4 @@ export type SuppliedValueInputProps<V, T extends Element = Element> = Partial<{
     onBlur: (e: React.FocusEvent<T>) => void;
     onKeyUp: (e: React.KeyboardEvent<T>) => void;
 }>;
-export declare function createValueInput<F extends Fields, K extends keyof AllFieldsOfFields<F>, Props extends SuppliedValueInputProps<ValueTypeOfField<F[K]>>>(this: MantineForm<F>, valuePath: K, ValueInput: React.ComponentType<Props>, ErrorRenderer: ErrorRenderer<ErrorTypeOfField<F[K]>>): MantineFieldComponent<SuppliedValueInputProps<ValueTypeOfField<F[K]>>, Props>;
+export declare function createValueInput<F extends Fields, K extends keyof AllFieldsOfFields<F>, Props extends SuppliedValueInputProps<ValueTypeOfField<F[K]>>>(this: MantineForm<F>, valuePath: K, ValueInput: React.ComponentType<Props>): MantineFieldComponent<SuppliedValueInputProps<ValueTypeOfField<F[K]>>, Props, ErrorOfField<F[K]>>;

package/.out/mantine/create_value_input.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createUnsafePartialObserverComponent } from 'util/partial';
-export function createValueInput(valuePath, ValueInput, ErrorRenderer) {
+import { DefaultErrorRenderer, } from './error_renderer';
+export function createValueInput(valuePath, ValueInput) {
     const onChange = (value) => {
         this.onFieldValueChange?.(valuePath, value);
     };
@@ -17,15 +18,15 @@ export function createValueInput(valuePath, ValueInput, ErrorRenderer) {
             }
         }
     };
-    const propSource = () => {
-        const { disabled, required, value, error,
+    const propSource = ({ ErrorRenderer = DefaultErrorRenderer, }) => {
+        const { readonly, required, value, error,
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
          } = this.fields[valuePath];
         return {
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             name: valuePath,
             value,
-            disabled,
+            disabled: readonly,
             required,
             error: error && _jsx(ErrorRenderer, { error: error }),
             onChange,
@@ -34,5 +35,5 @@ export function createValueInput(valuePath, ValueInput, ErrorRenderer) {
             onKeyUp,
         };
     };
-    return createUnsafePartialObserverComponent(ValueInput, propSource);
+    return createUnsafePartialObserverComponent(ValueInput, propSource, ['ErrorRenderer']);
 }

package/.out/mantine/error_renderer.d.ts

@@ -0,0 +1,6 @@
+import { type ComponentType } from 'react';
+export type ErrorRendererProps<E> = {
+    error: E;
+};
+export type ErrorRenderer<E = any> = ComponentType<ErrorRendererProps<E>>;
+export declare function DefaultErrorRenderer({ error, }: ErrorRendererProps<any>): any;

package/.out/mantine/error_renderer.js

@@ -0,0 +1,5 @@
+export function DefaultErrorRenderer({ error,
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ }) {
+    return error;
+}