@strictly/react-form 0.0.1

package/.out/core/mobx/types.d.ts

@@ -0,0 +1,19 @@
+import { type ToTypeOfFieldAdapter } from './field_adapter';
+import { type FlattenedConvertedFieldsOf, type FormPresenter } from './form_presenter';
+/**
+ * Used to extract the supported value paths from a presenter
+ */
+export type ValuePathsOfPresenter<Presenter extends FormPresenter<any, any, any, any>> = Presenter extends FormPresenter<infer _1, infer _2, infer _3, infer ValuePathsToAdapters> ? keyof ValuePathsToAdapters : never;
+/**
+ * Used to extract the render type (so the value that is passed to the view) of a given value path
+ * from a presenter
+ */
+export type ToTypeOfPresenterValuePath<Presenter extends FormPresenter<any, any, any, any>, K extends ValuePathsOfPresenter<Presenter>> = Presenter extends FormPresenter<infer _1, infer _2, infer _3, infer ValuePathsToAdapters> ? ToTypeOfFieldAdapter<ValuePathsToAdapters[K]> : never;
+/**
+ * Extracts the form fields from the presenter. The recommended way is to
+ * define the form fields explicitly and use that type to enforce the types
+ * of your converters, but generating the FormFields from your presenter
+ * is less typing, albeit at the cost of potentially getting type errors
+ * reported a long way away from the source
+ */
+export type FormFieldsOfPresenter<Presenter extends FormPresenter<any, any, any, any>> = Presenter extends FormPresenter<infer _1, infer _2, infer _3, infer ValuePathsToAdapters> ? FlattenedConvertedFieldsOf<ValuePathsToAdapters> : never;

package/.out/core/mobx/types.js

@@ -0,0 +1 @@
+export {};

package/.out/core/props.d.ts

@@ -0,0 +1,12 @@
+import { type Fields } from 'types/field';
+export type FormProps<F extends Fields> = {
+    fields: F;
+    onFieldValueChange<K extends keyof F>(this: void, key: K, value: F[K]['value']): void;
+    onFieldFocus?(this: void, key: keyof F): void;
+    onFieldBlur?(this: void, key: keyof F): void;
+    onFieldSubmit?(this: void, key: keyof F): boolean | void;
+};
+export type EditorProps<O> = {
+    value: O;
+    onValueChange: (value: O) => void;
+};

package/.out/core/props.js

@@ -0,0 +1 @@
+export {};

package/.out/field_converters/chain_field_converter.d.ts

@@ -0,0 +1,3 @@
+import { type FieldConverter, type SafeFieldConverter } from 'types/field_converters';
+export declare function chainFieldConverter<From, Intermediate, To, E1, E2, ValuePath extends string, Context>(from: FieldConverter<From, Intermediate, E1, ValuePath, Context>, to: FieldConverter<Intermediate, To, E2, ValuePath, Context>): FieldConverter<From, To, E1 | E2, ValuePath, Context>;
+export declare function chainSafeFieldConverter<From, Intermediate, To, ValuePath extends string, Context>(from: SafeFieldConverter<From, Intermediate, ValuePath, Context>, to: SafeFieldConverter<Intermediate, To, ValuePath, Context>): SafeFieldConverter<From, To, ValuePath, Context>;

package/.out/field_converters/chain_field_converter.js

@@ -0,0 +1,46 @@
+import { UnreachableError, } from '@strictly/base';
+import { FieldConversionResult, } from 'types/field_converters';
+export function chainFieldConverter(from, to) {
+    return function (value, valuePath, context) {
+        const fromConversion = from(value, valuePath, context);
+        switch (fromConversion.type) {
+            case FieldConversionResult.Success:
+                return to(fromConversion.value, valuePath, context);
+            case FieldConversionResult.Failure:
+                if (fromConversion.value != null) {
+                    const toConversion = to(fromConversion.value[0], valuePath, context);
+                    switch (toConversion.type) {
+                        case FieldConversionResult.Success:
+                            return {
+                                type: FieldConversionResult.Failure,
+                                error: fromConversion.error,
+                                value: [toConversion.value],
+                            };
+                        case FieldConversionResult.Failure:
+                            return {
+                                type: FieldConversionResult.Failure,
+                                error: fromConversion.error,
+                                value: toConversion.value,
+                            };
+                        default:
+                            throw new UnreachableError(toConversion);
+                    }
+                }
+                else {
+                    return {
+                        type: FieldConversionResult.Failure,
+                        error: fromConversion.error,
+                        value: null,
+                    };
+                }
+            default:
+                throw new UnreachableError(fromConversion);
+        }
+    };
+}
+export function chainSafeFieldConverter(from, to) {
+    return function (value, valuePath, context) {
+        const intermediate = from(value, valuePath, context);
+        return to(intermediate, valuePath, context);
+    };
+}

package/.out/field_converters/identity_converter.d.ts

@@ -0,0 +1,3 @@
+import { type FieldConverter, type SafeFieldConverter } from 'types/field_converters';
+export declare function safeIdentityConverter<V, ValuePath extends string, Context>(): SafeFieldConverter<V, V, ValuePath, Context>;
+export declare function identityConverter<V, ValuePath extends string, Context>(): FieldConverter<V, V, never, ValuePath, Context>;

package/.out/field_converters/identity_converter.js

@@ -0,0 +1,14 @@
+import { FieldConversionResult, } from 'types/field_converters';
+export function safeIdentityConverter() {
+    return function (v) {
+        return v;
+    };
+}
+export function identityConverter() {
+    return function (value) {
+        return {
+            type: FieldConversionResult.Success,
+            value,
+        };
+    };
+}

package/.out/field_converters/integer_to_string_converter.d.ts

@@ -0,0 +1,7 @@
+import { type FieldConversion, type TwoWayFieldConverter } from 'types/field_converters';
+export declare class IntegerToStringConverter<E, ValuePath extends string, Context> implements TwoWayFieldConverter<number, string, E, ValuePath, Context> {
+    private readonly isNanError;
+    constructor(isNanError: E);
+    convert(from: number): string;
+    revert(from: string): FieldConversion<number, E>;
+}

package/.out/field_converters/integer_to_string_converter.js

@@ -0,0 +1,26 @@
+import { FieldConversionResult, } from 'types/field_converters';
+export class IntegerToStringConverter {
+    isNanError;
+    constructor(isNanError) {
+        this.isNanError = isNanError;
+    }
+    convert(from) {
+        return Math.floor(from).toString();
+    }
+    revert(from) {
+        const value = parseInt(from, 10);
+        if (Number.isNaN(value)) {
+            return {
+                type: FieldConversionResult.Failure,
+                error: this.isNanError,
+                value: null,
+            };
+        }
+        else {
+            return {
+                type: FieldConversionResult.Success,
+                value,
+            };
+        }
+    }
+}

package/.out/field_converters/list_converter.d.ts

@@ -0,0 +1,2 @@
+import { type SafeFieldConverter } from 'types/field_converters';
+export declare function listConverter<E, K extends string, ValuePath extends string, Context>(): SafeFieldConverter<readonly E[], K[], ValuePath, Context>;

package/.out/field_converters/list_converter.js

@@ -0,0 +1,8 @@
+export function listConverter() {
+    return function (from, valuePath) {
+        return from.map(function (_v, i) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return `${valuePath}.${i}`;
+        });
+    };
+}

package/.out/field_converters/maybe_identity_converter.d.ts

@@ -0,0 +1,8 @@
+import { type FieldConversion, type TwoWayFieldConverter } from 'types/field_converters';
+export declare class MaybeIdentityConverter<From, To, E, ValuePath extends string, Context> implements TwoWayFieldConverter<From, From | To, E, ValuePath, Context> {
+    private readonly converter;
+    private readonly isFrom;
+    constructor(converter: TwoWayFieldConverter<From, To, E, ValuePath, Context>, isFrom: (to: From | To) => to is From);
+    convert(from: From, valuePath: ValuePath, context: Context): To | From;
+    revert(from: To | From, valuePath: ValuePath, context: Context): FieldConversion<From, E>;
+}

package/.out/field_converters/maybe_identity_converter.js

@@ -0,0 +1,15 @@
+export class MaybeIdentityConverter {
+    converter;
+    isFrom;
+    constructor(converter, isFrom) {
+        this.converter = converter;
+        this.isFrom = isFrom;
+    }
+    convert(from, valuePath, context) {
+        return this.converter.convert(from, valuePath, context);
+    }
+    revert(from, valuePath, context) {
+        const value = this.isFrom(from) ? this.converter.convert(from, valuePath, context) : from;
+        return this.converter.revert(value, valuePath, context);
+    }
+}

package/.out/field_converters/nullable_to_boolean_converter.d.ts

@@ -0,0 +1,11 @@
+import { type ReadonlyTypeDefOf, type Type, type ValueTypeOf } from '@strictly/define';
+import { type FieldConversion, type TwoWayFieldConverterWithValueFactory } from 'types/field_converters';
+export declare class NullableToBooleanConverter<T extends Type, E, ValuePath extends string, Context> implements TwoWayFieldConverterWithValueFactory<ValueTypeOf<ReadonlyTypeDefOf<T>> | null, boolean, E, ValuePath, Context> {
+    private readonly typeDef;
+    private readonly prototype;
+    readonly defaultValue: ValueTypeOf<ReadonlyTypeDefOf<T>> | null;
+    constructor(typeDef: T, prototype: ValueTypeOf<ReadonlyTypeDefOf<T>>, defaultToNull?: boolean);
+    convert(from: ValueTypeOf<ReadonlyTypeDefOf<T>> | null): boolean;
+    revert(from: boolean): FieldConversion<ValueTypeOf<ReadonlyTypeDefOf<T>> | null, E>;
+    create(): ValueTypeOf<ReadonlyTypeDefOf<T>> | null;
+}

package/.out/field_converters/nullable_to_boolean_converter.js

@@ -0,0 +1,31 @@
+import { copy, } from '@strictly/define';
+import { FieldConversionResult, } from 'types/field_converters';
+export class NullableToBooleanConverter {
+    typeDef;
+    prototype;
+    defaultValue;
+    constructor(typeDef, prototype, defaultToNull = true) {
+        this.typeDef = typeDef;
+        this.prototype = prototype;
+        this.defaultValue = defaultToNull ? null : prototype;
+    }
+    convert(from) {
+        return from != null;
+    }
+    revert(from) {
+        if (from) {
+            const value = copy(this.typeDef, this.prototype);
+            return {
+                type: FieldConversionResult.Success,
+                value,
+            };
+        }
+        return {
+            type: FieldConversionResult.Success,
+            value: null,
+        };
+    }
+    create() {
+        return this.defaultValue;
+    }
+}

package/.out/field_converters/select_value_type_converter.d.ts

@@ -0,0 +1,23 @@
+import { type StringKeyOf } from '@strictly/base';
+import { type LiteralTypeDef, type Type, type UnionTypeDef, type ValueTypeOf, type ValueTypesOfDiscriminatedUnion } from '@strictly/define';
+import { type FieldConversion, type TwoWayFieldConverterWithValueFactory } from 'types/field_converters';
+export declare abstract class AbstractSelectValueTypeConverter<T extends Type, To extends string | null, Values extends Readonly<Record<NonNullable<To>, ValueTypeOf<T>>>, NoSuchValueError, ValuePath extends string, Context> implements TwoWayFieldConverterWithValueFactory<ValueTypeOf<T>, keyof Values | null, NoSuchValueError, ValuePath, Context> {
+    protected readonly typeDef: T;
+    protected readonly values: Values;
+    private readonly defaultValueKey;
+    private readonly noSuchValueError;
+    constructor(typeDef: T, values: Values, defaultValueKey: keyof Values | null, noSuchValueError: NoSuchValueError | null);
+    revert(from: keyof Values | null): FieldConversion<ValueTypeOf<T>, NoSuchValueError>;
+    convert(from: ValueTypeOf<T>): To;
+    protected abstract doConvert(from: ValueTypeOf<T>): To;
+    create(): ValueTypeOf<T>;
+}
+export declare class SelectDiscriminatedUnionConverter<U extends UnionTypeDef, To extends StringKeyOf<U['unions']> | null, ValuePath extends string, Context> extends AbstractSelectValueTypeConverter<Type<U>, To, ValueTypesOfDiscriminatedUnion<U>, never, ValuePath, Context> {
+    constructor(typeDef: Type<U>, values: ValueTypesOfDiscriminatedUnion<U>, defaultValueKey: keyof U['unions']);
+    protected doConvert(from: ValueTypeOf<Type<U>>): any;
+}
+export declare class SelectLiteralConverter<L extends string | number | null, To extends string | null, Values extends Record<NonNullable<L>, NonNullable<To>>, NoSuchValueError, ValuePath extends string, Context> extends AbstractSelectValueTypeConverter<Type<LiteralTypeDef<L>>, To, Record<NonNullable<To>, L>, NoSuchValueError, ValuePath, Context> {
+    private readonly valuesToStrings;
+    constructor(typeDef: Type<LiteralTypeDef<L>>, valuesToStrings: Values, defaultValue: L | null, noSuchValueError: NoSuchValueError | null);
+    protected doConvert(from: L): Values[NonNullable<L>];
+}

package/.out/field_converters/select_value_type_converter.js

@@ -0,0 +1,60 @@
+import { reverse, } from '@strictly/base';
+import { copy, } from '@strictly/define';
+import { FieldConversionResult, } from 'types/field_converters';
+export class AbstractSelectValueTypeConverter {
+    typeDef;
+    values;
+    defaultValueKey;
+    noSuchValueError;
+    constructor(typeDef, values, defaultValueKey, noSuchValueError) {
+        this.typeDef = typeDef;
+        this.values = values;
+        this.defaultValueKey = defaultValueKey;
+        this.noSuchValueError = noSuchValueError;
+    }
+    revert(from) {
+        const prototype = from == null ? null : this.values[from];
+        if (prototype == null && this.noSuchValueError != null) {
+            return {
+                type: FieldConversionResult.Failure,
+                error: this.noSuchValueError,
+                value: null,
+            };
+        }
+        const value = prototype == null ? null : copy(this.typeDef, prototype);
+        // TODO given we are dealing with strings, maybe we should have a check to make sure value is in the record
+        // of values?
+        return {
+            type: FieldConversionResult.Success,
+            value: value,
+        };
+    }
+    convert(from) {
+        if (from == null) {
+            return null;
+        }
+        return this.doConvert(from);
+    }
+    create() {
+        return this.defaultValueKey != null ? this.values[this.defaultValueKey] : null;
+    }
+}
+export class SelectDiscriminatedUnionConverter extends AbstractSelectValueTypeConverter {
+    constructor(typeDef, values, defaultValueKey) {
+        super(typeDef, values, defaultValueKey, null);
+    }
+    doConvert(from) {
+        const { definition: { discriminator, }, } = this.typeDef;
+        return from[discriminator];
+    }
+}
+export class SelectLiteralConverter extends AbstractSelectValueTypeConverter {
+    valuesToStrings;
+    constructor(typeDef, valuesToStrings, defaultValue, noSuchValueError) {
+        super(typeDef, reverse(valuesToStrings), defaultValue && valuesToStrings[defaultValue], noSuchValueError);
+        this.valuesToStrings = valuesToStrings;
+    }
+    doConvert(from) {
+        return from && this.valuesToStrings[from];
+    }
+}

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

@@ -0,0 +1,6 @@
+import { type FieldConversion, type TwoWayFieldConverter } 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>;
+}

package/.out/field_converters/trimming_string_converter.js

@@ -0,0 +1,14 @@
+import { FieldConversionResult, } from 'types/field_converters';
+export class TrimmingStringConverter {
+    constructor() {
+    }
+    convert(to) {
+        return to.trim();
+    }
+    revert(from) {
+        return {
+            type: FieldConversionResult.Success,
+            value: from.trim(),
+        };
+    }
+}

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

@@ -0,0 +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>;

package/.out/field_converters/validating_converter.js

@@ -0,0 +1,21 @@
+import { FieldConversionResult, } from 'types/field_converters';
+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 (error != null) {
+                    return {
+                        type: FieldConversionResult.Failure,
+                        error,
+                        value: [value],
+                    };
+                }
+            }
+            return acc;
+        }, {
+            type: FieldConversionResult.Success,
+            value,
+        });
+    };
+}

package/.out/field_validators/minimum_string_length_field_validator.d.ts

@@ -0,0 +1,2 @@
+import { type FieldValidator } from 'types/field_validator';
+export declare function minimumStringLengthFieldValidatorFactory<E, ValuePath extends string, Context>(minimumLength: number, error: E): FieldValidator<string, E, ValuePath, Context>;

package/.out/field_validators/minimum_string_length_field_validator.js

@@ -0,0 +1,8 @@
+export function minimumStringLengthFieldValidatorFactory(minimumLength, error) {
+    return function (value) {
+        if (value.length < minimumLength) {
+            return error;
+        }
+        return null;
+    };
+}

package/.out/field_value_factories/prototyping_field_value_factory.d.ts

@@ -0,0 +1,2 @@
+import { type FieldValueFactory } from 'types/field_converters';
+export declare function prototypingFieldValueFactory<V, ValuePath extends string, Context>(prototype: V): FieldValueFactory<V, ValuePath, Context>;

package/.out/field_value_factories/prototyping_field_value_factory.js

@@ -0,0 +1,5 @@
+export function prototypingFieldValueFactory(prototype) {
+    return function () {
+        return prototype;
+    };
+}

package/.out/index.d.ts

@@ -0,0 +1,16 @@
+export * from './core/mobx/field_adapter_builder';
+export * from './core/mobx/flattened_adapters_of_fields';
+export * from './core/mobx/form_presenter';
+export * from './core/mobx/types';
+export * from './core/props';
+export * from './field_converters/integer_to_string_converter';
+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/hooks';
+export * from './types/field';
+export * from './types/flattened_form_fields_of';
+export * from './util/partial';

package/.out/index.js

@@ -0,0 +1,16 @@
+export * from './core/mobx/field_adapter_builder';
+export * from './core/mobx/flattened_adapters_of_fields';
+export * from './core/mobx/form_presenter';
+export * from './core/mobx/types';
+export * from './core/props';
+export * from './field_converters/integer_to_string_converter';
+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/hooks';
+export * from './types/field';
+export * from './types/flattened_form_fields_of';
+export * from './util/partial';

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

@@ -0,0 +1,9 @@
+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 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>;

package/.out/mantine/create_checkbox.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createUnsafePartialObserverComponent } from 'util/partial';
+export function createCheckbox(valuePath, Checkbox, ErrorRenderer) {
+    const onChange = (e) => {
+        this.onFieldValueChange?.(valuePath, e.target.checked);
+    };
+    const onFocus = () => {
+        this.onFieldFocus?.(valuePath);
+    };
+    const onBlur = () => {
+        this.onFieldBlur?.(valuePath);
+    };
+    const onKeyUp = (e) => {
+        if (e.key === 'Enter') {
+            if (this.onFieldSubmit?.(valuePath)) {
+                e.preventDefault();
+            }
+        }
+    };
+    const propSource = () => {
+        const { disabled, required, value, error,
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+         } = this.fields[valuePath];
+        return {
+            name: valuePath,
+            checked: value,
+            disabled,
+            required,
+            error: error && _jsx(ErrorRenderer, { error: error }),
+            onChange,
+            onFocus,
+            onBlur,
+            onKeyUp,
+        };
+    };
+    return createUnsafePartialObserverComponent(Checkbox, propSource);
+}

package/.out/mantine/create_list.d.ts

@@ -0,0 +1,15 @@
+import { type ElementOfArray } from '@strictly/base';
+import { type ComponentType } from 'react';
+import { type Fields } from 'types/field';
+import { type ListFieldsOfFields } from 'types/list_fields_of_fields';
+import { type ValueTypeOfField } from 'types/value_type_of_field';
+import { type MantineFieldComponent, type MantineForm } from './types';
+export type SuppliedListProps<Value = any> = {
+    values: readonly Value[];
+};
+export declare function createList<F extends Fields, K extends keyof ListFieldsOfFields<F>, Props extends SuppliedListProps<ElementOfArray<ValueTypeOfField<F[K]>>> & {
+    children: (value: ElementOfArray<ValueTypeOfField<F[K]>>, index: number) => React.ReactNode;
+}>(this: MantineForm<F>, valuePath: K, List: ComponentType<Props>): MantineFieldComponent<SuppliedListProps<ElementOfArray<ValueTypeOfField<F[K]>>>, Props>;
+export declare function DefaultList<Value>({ values, children, }: SuppliedListProps<Value> & {
+    children: (value: Value, index: number) => React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/.out/mantine/create_list.js

@@ -0,0 +1,16 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { createUnsafePartialObserverComponent } from 'util/partial';
+export function createList(valuePath, List) {
+    const propSource = () => {
+        const values = [...this.fields[valuePath].value];
+        return {
+            values,
+        };
+    };
+    return createUnsafePartialObserverComponent(List, propSource);
+}
+export function DefaultList({ values, children, }) {
+    return (_jsx(_Fragment, { children: values.map(function (value, index) {
+            return children(value, index);
+        }) }));
+}

package/.out/mantine/create_pill.d.ts

@@ -0,0 +1,7 @@
+import { type PillProps } from '@mantine/core';
+import { type ComponentType } from 'react';
+import { type AllFieldsOfFields } from 'types/all_fields_of_fields';
+import { type Fields } from 'types/field';
+import { type MantineFieldComponent, type MantineForm } from './types';
+export type SuppliedPillProps = Pick<PillProps, 'children' | 'disabled'>;
+export declare function createPill<F extends Fields, K extends keyof AllFieldsOfFields<F>, Props extends SuppliedPillProps>(this: MantineForm<F>, valuePath: K, Pill: ComponentType<Props>): MantineFieldComponent<SuppliedPillProps, Props>;

package/.out/mantine/create_pill.js

@@ -0,0 +1,15 @@
+import { createUnsafePartialObserverComponent } from 'util/partial';
+export function createPill(valuePath, Pill) {
+    const propSource = () => {
+        const { disabled, 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,
+        };
+    };
+    return createUnsafePartialObserverComponent(Pill, propSource);
+}

package/.out/mantine/create_radio.d.ts

@@ -0,0 +1,8 @@
+import { type RadioProps } from '@mantine/core';
+import { type ComponentType } from 'react';
+import { type Fields } from 'types/field';
+import { type StringFieldsOfFields } from 'types/string_fields_of_fields';
+import { type ValueTypeOfField } from 'types/value_type_of_field';
+import { type MantineFieldComponent, type MantineForm } from './types';
+export type SuppliedRadioProps = Pick<RadioProps, 'value' | 'disabled'>;
+export declare function createRadio<F extends Fields, K extends keyof StringFieldsOfFields<F>, Props extends SuppliedRadioProps>(this: MantineForm<F>, valuePath: K, value: ValueTypeOfField<F[K]>, Radio: ComponentType<Props>): MantineFieldComponent<SuppliedRadioProps, Props>;

package/.out/mantine/create_radio.js

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

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

@@ -0,0 +1,9 @@
+import { type RadioGroupProps } from '@mantine/core';
+import { type ComponentType } from 'react';
+import { type ErrorTypeOfField } from 'types/error_type_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>;

package/.out/mantine/create_radio_group.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createUnsafePartialObserverComponent, } from 'util/partial';
+export function createRadioGroup(valuePath, RadioGroup, ErrorRenderer) {
+    const onChange = (value) => {
+        this.onFieldValueChange?.(valuePath, value);
+    };
+    const onFocus = () => {
+        this.onFieldFocus?.(valuePath);
+    };
+    const onBlur = () => {
+        this.onFieldBlur?.(valuePath);
+    };
+    const onKeyUp = (e) => {
+        if (e.key === 'Enter') {
+            if (this.onFieldSubmit?.(valuePath)) {
+                e.preventDefault();
+            }
+        }
+    };
+    const propSource = () => {
+        const { required, value, error, } = this.fields[valuePath];
+        return {
+            name: valuePath,
+            value,
+            required,
+            error: error && _jsx(ErrorRenderer, { error: error }),
+            onChange,
+            onFocus,
+            onBlur,
+            onKeyUp,
+        };
+    };
+    return createUnsafePartialObserverComponent(RadioGroup, propSource);
+}

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

@@ -0,0 +1,19 @@
+import { type ErrorTypeOfField } from 'types/error_type_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;
+};
+export type SuppliedTextInputProps<T extends TextInputTarget = TextInputTarget> = Partial<{
+    name: string;
+    value: string | number | readonly string[] | undefined;
+    disabled: boolean;
+    required: boolean;
+    onChange: (e: React.ChangeEvent<T>) => void;
+    onFocus: (e: React.FocusEvent<T>) => void;
+    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>;