@strictly/react-form 0.0.1 → 0.0.2

package/.out/types/error_of_field.d.ts

@@ -0,0 +1,2 @@
+import { type Field } from './field';
+export type ErrorOfField<F extends Field> = F extends Field<infer _V, infer E> ? E : never;

package/.out/types/error_of_field.js

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

package/.out/types/field.d.ts

@@ -1,7 +1,7 @@
 export type Field<V = any, E = any> = {
     readonly value: V;
     readonly error?: E | undefined;
-    readonly disabled: boolean;
+    readonly readonly: boolean;
     readonly required: boolean;
 };
 export type Fields = Readonly<Record<string, Field>>;

package/.out/types/field_converters.d.ts

@@ -1,25 +1,32 @@
 import { type Maybe } from '@strictly/base';
-export declare enum FieldConversionResult {
+export declare enum UnreliableFieldConversionType {
     Success = 0,
     Failure = 1
 }
-export type FieldConversion<V, E> = {
-    type: FieldConversionResult.Success;
+export type UnreliableFieldConversion<V = any, E = any> = {
+    type: UnreliableFieldConversionType.Success;
     value: V;
 } | {
-    type: FieldConversionResult.Failure;
+    type: UnreliableFieldConversionType.Failure;
     error: E;
     value: Maybe<V>;
 };
-export type FieldConverter<From, To, E, ValuePath extends string, Context> = {
-    (from: From, valuePath: ValuePath, context: Context): FieldConversion<To, E>;
+export type UnreliableFieldConverter<From, To, E, ValuePath extends string, Context> = {
+    (from: From, valuePath: ValuePath, context: Context): UnreliableFieldConversion<To, E>;
 };
-export type SafeFieldConverter<From, To, ValuePath extends string, Context> = {
-    (from: From, valuePath: ValuePath, context: Context): To;
+export type Annotation = {
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
+export type AnnotatedFieldConversion<V = any> = {
+    value: V;
+} & Annotation;
+export type AnnotatedFieldConverter<From, To, ValuePath extends string, Context> = {
+    (from: From, valuePath: ValuePath, context: Context): AnnotatedFieldConversion<To>;
 };
 export type TwoWayFieldConverter<From, To, E, ValuePath extends string, Context> = {
-    convert: SafeFieldConverter<From, To, ValuePath, Context>;
-    revert: FieldConverter<To, From, E, ValuePath, Context>;
+    convert: AnnotatedFieldConverter<From, To, ValuePath, Context>;
+    revert: UnreliableFieldConverter<To, From, E, ValuePath, Context>;
 };
 export type FieldValueFactory<V, ValuePath extends string, Context> = {
     (valuePath: ValuePath, context: Context): V;

package/.out/types/field_converters.js

@@ -1,5 +1,5 @@
-export var FieldConversionResult;
-(function (FieldConversionResult) {
-    FieldConversionResult[FieldConversionResult["Success"] = 0] = "Success";
-    FieldConversionResult[FieldConversionResult["Failure"] = 1] = "Failure";
-})(FieldConversionResult || (FieldConversionResult = {}));
+export var UnreliableFieldConversionType;
+(function (UnreliableFieldConversionType) {
+    UnreliableFieldConversionType[UnreliableFieldConversionType["Success"] = 0] = "Success";
+    UnreliableFieldConversionType[UnreliableFieldConversionType["Failure"] = 1] = "Failure";
+})(UnreliableFieldConversionType || (UnreliableFieldConversionType = {}));

package/.out/types/flattened_validators_of_fields.d.ts

@@ -0,0 +1,8 @@
+import { type ReadonlyTypeOfType, type Type, type Validator, type ValueOfType } from '@strictly/define';
+import { type SimplifyDeep, type ValueOf } from 'type-fest';
+import { type Field } from 'types/field';
+export type FlattenedValidatorsOfFields<ValuePathsToTypePaths extends Readonly<Record<string, string>>, FlattenedTypeDefs extends Partial<Readonly<Record<ValueOf<ValuePathsToTypePaths>, Type>>>, FormFields extends Partial<Readonly<Record<keyof ValuePathsToTypePaths, Field>>>> = SimplifyDeep<{
+    readonly [K in keyof ValuePathsToTypePaths as FormFields[K] extends Field ? ValuePathsToTypePaths[K] : never]: ValidatorOfField<NonNullable<FormFields[K]>, FlattenedTypeDefs[ValuePathsToTypePaths[K]], K>;
+}>;
+type ValidatorOfField<F extends Field, T extends Type | undefined, ValuePath extends string | number | symbol> = ValuePath extends string ? F extends Field<infer V, infer E> ? undefined extends T ? Validator<V, E, ValuePath> : Validator<ValueOfType<ReadonlyTypeOfType<NonNullable<T>>>, E, ValuePath> : never : never;
+export {};

package/.out/types/flattened_validators_of_fields.js

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

package/.out/types/merge_validators.d.ts

@@ -0,0 +1,7 @@
+import { type Validator } from '@strictly/define';
+import { type Simplify } from 'type-fest';
+export 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<{
+    readonly [K in Keys]: undefined extends Validators1[K] ? undefined extends Validators2[K] ? never : Validators2[K] : undefined extends Validators2[K] ? Validators1[K] : MergedOfValidator<NonNullable<Validators1[K]>, NonNullable<Validators2[K]>>;
+}>;
+export type MergedOfValidator<Validator1 extends Validator, Validator2 extends Validator> = Validator1 extends Validator<infer V, infer E1, infer P, infer C> ? Validator2 extends Validator<V, infer E2, P, C> ? Validator<V, E1 | E2, P, C> : never : never;
+export declare function mergeValidators<Validators1 extends Partial<Readonly<Record<Keys, Validator>>>, Validators2 extends Partial<Readonly<Record<Keys, Validator>>>, Keys extends string = Extract<keyof Validators1 | keyof Validators2, string>>(validators1: Validators1, validators2: Validators2): MergedOfValidators<Validators1, Validators2, Keys>;

package/.out/types/merge_validators.js

@@ -0,0 +1,38 @@
+import { annotations, validate, } from '@strictly/define';
+export function mergeValidators(validators1, validators2) {
+    const validators = {
+        ...validators1,
+        ...validators2,
+    };
+    const keys1 = new Set(Object.keys(validators1));
+    const keys2 = new Set(Object.keys(validators2));
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return Array.from(keys1.intersection(keys2)).reduce(function (validators, key) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const validator1 = validators1[key];
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const validator2 = validators2[key];
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        validators[key] = {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            validate: function (value, valuePath, context) {
+                const error = validate(validator1, value, valuePath, context);
+                if (error != null) {
+                    return error;
+                }
+                return validate(validator2, value, valuePath, context);
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            annotations: function (valuePath, context) {
+                const annotations1 = annotations(validator1, valuePath, context);
+                const annotations2 = annotations(validator2, valuePath, context);
+                return {
+                    readonly: annotations1.readonly || annotations2.readonly,
+                    required: annotations1.required || annotations2.required,
+                };
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        };
+        return validators;
+    }, validators);
+}

package/.out/types/specs/flattened_validators_of_fields.tests.d.ts

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

package/.out/types/specs/flattened_validators_of_fields.tests.js

@@ -0,0 +1,16 @@
+const error = Symbol();
+describe('FlattenedValidatorsOfFields', function () {
+    it('maps the converter types', function () {
+        expectTypeOf().toEqualTypeOf();
+    });
+    it('ignores extraneous types not listed in the fields', function () {
+        expectTypeOf().toEqualTypeOf();
+    });
+    it('handles multiple fields', function () {
+        expectTypeOf().toEqualTypeOf();
+    });
+    it('allows synthesized fields', function () {
+        expectTypeOf().toEqualTypeOf();
+    });
+});
+export {};

package/.out/types/specs/merge_validators.tests.d.ts

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

package/.out/types/specs/merge_validators.tests.js

@@ -0,0 +1,192 @@
+import { annotations, validate, } from '@strictly/define';
+import { mergeValidators, } from 'types/merge_validators';
+import { mock, mockReset, } from 'vitest-mock-extended';
+describe('MergedOfValidators', function () {
+    describe('empty validators 1', function () {
+        it('equals the expected type', function () {
+            expectTypeOf().toEqualTypeOf();
+        });
+    });
+    describe('empty validators 2', function () {
+        it('equals the expected type', function () {
+            expectTypeOf().toEqualTypeOf();
+        });
+    });
+    describe('merged validators with different keys', function () {
+        it('equals the expected type', function () {
+            expectTypeOf().toEqualTypeOf();
+        });
+    });
+    describe('merged validators with same key', function () {
+        it('equals the expected type', function () {
+            expectTypeOf().toEqualTypeOf();
+        });
+    });
+});
+describe('mergeValidators', function () {
+    describe('functional validators', function () {
+        const validatorA1 = vi.fn();
+        const validatorA2 = vi.fn();
+        const validatorB = vi.fn();
+        describe('produces expected type', function () {
+            describe('empty validators 1', function () {
+                const validators1 = {
+                    a: validatorA1,
+                    b: validatorB,
+                };
+                const validators2 = {};
+                const validators = mergeValidators(validators1, validators2);
+                it('equals expected value', function () {
+                    expect(validators).toEqual(validators1);
+                });
+            });
+            describe('empty validators 2', function () {
+                const validators1 = {};
+                const validators2 = {
+                    a: validatorA1,
+                    b: validatorB,
+                };
+                const validators = mergeValidators(validators1, validators2);
+                it('equals expected value', function () {
+                    expect(validators).toEqual(validators2);
+                });
+            });
+            describe('merged validators with different keys', function () {
+                const validators1 = {
+                    a: validatorA1,
+                };
+                const validators2 = {
+                    b: validatorB,
+                };
+                const validators = mergeValidators(validators1, validators2);
+                it('equals expected value', function () {
+                    expect(validators).toEqual({
+                        a: validatorA1,
+                        b: validatorB,
+                    });
+                });
+            });
+            describe('merged validators with same key', function () {
+                const validators1 = {
+                    a: validatorA1,
+                };
+                const validators2 = {
+                    a: validatorA2,
+                };
+                const validators = mergeValidators(validators1, validators2);
+                it('has the expected keys', function () {
+                    expect(Array.from(Object.keys(validators))).toEqual(['a']);
+                });
+                it('reports no error when validators report no error', function () {
+                    const result = validate(validators.a, 'x', 'a', null);
+                    expect(result).toBeUndefined();
+                });
+                it('reports an error from first validator', function () {
+                    validatorA1.mockReturnValueOnce('error a1');
+                    const result = validate(validators.a, 'x', 'a', null);
+                    expect(result).toEqual('error a1');
+                });
+                it('reports an error from second validator', function () {
+                    validatorA2.mockReturnValueOnce('error a2');
+                    const result = validate(validators.a, 'x', 'a', null);
+                    expect(result).toEqual('error a2');
+                });
+            });
+        });
+    });
+    describe('annotated validators', function () {
+        const validatorA1 = mock();
+        const validatorA2 = mock();
+        beforeEach(function () {
+            mockReset(validatorA1);
+            mockReset(validatorA2);
+        });
+        const validators1 = {
+            a: validatorA1,
+        };
+        const validators2 = {
+            a: validatorA2,
+        };
+        const validators = mergeValidators(validators1, validators2);
+        describe.each([
+            [
+                false,
+                false,
+                false,
+            ],
+            [
+                false,
+                true,
+                true,
+            ],
+            [
+                true,
+                false,
+                true,
+            ],
+            [
+                true,
+                true,
+                true,
+            ],
+        ])('required', function (required1, required2, required) {
+            beforeEach(function () {
+                validatorA1.validate.mockReturnValue('error a1');
+                validatorA1.annotations.mockReturnValue({
+                    required: required1,
+                    readonly: false,
+                });
+                validatorA2.annotations.mockReturnValue({
+                    required: required2,
+                    readonly: false,
+                });
+            });
+            it('has the expected required value', function () {
+                expect(annotations(validators.a, 'a', null)).toEqual({
+                    required,
+                    readonly: false,
+                });
+            });
+        });
+        describe.each([
+            [
+                false,
+                false,
+                false,
+            ],
+            [
+                false,
+                true,
+                true,
+            ],
+            [
+                true,
+                false,
+                true,
+            ],
+            [
+                true,
+                true,
+                true,
+            ],
+        ])('required', function (readonly1, readonly2, readonly) {
+            beforeEach(function () {
+                validatorA1.validate.mockReturnValue('error a1');
+                validatorA1.annotations.mockReturnValue({
+                    required: false,
+                    readonly: readonly1,
+                });
+                validatorA2.annotations.mockReturnValue({
+                    required: false,
+                    readonly: readonly2,
+                });
+            });
+            it('has the expected required value', function () {
+                expect(annotations(validators.a, 'a', null)).toEqual({
+                    required: false,
+                    readonly,
+                });
+            });
+        });
+    });
+});

package/.out/util/partial.d.ts

@@ -1,11 +1,17 @@
+import { type FriendlyExhaustiveArrayOfUnion } from '@strictly/base';
 import { type ComponentProps, type ComponentType, type DependencyList, type ForwardRefExoticComponent, type PropsWithoutRef } from 'react';
 export type PartialComponent<Component extends ComponentType<any>, CurriedProps, AdditionalProps = {}> = Exclude<keyof CurriedProps, keyof ComponentProps<Component>> extends never ? UnsafePartialComponent<Component, CurriedProps, AdditionalProps> : keyof CurriedProps extends (string | number) ? `unmatched prop: ${Exclude<keyof CurriedProps, keyof ComponentProps<Component>>}` : Exclude<keyof CurriedProps, keyof ComponentProps<Component>>;
 export type UnsafePartialComponent<Component extends ComponentType<any>, CurriedProps, AdditionalProps = {}> = ForwardRefExoticComponent<PropsWithoutRef<RemainingComponentProps<Component, CurriedProps> & AdditionalProps>>;
 export declare function createSimplePartialComponent<Component extends ComponentType<any>, CurriedProps extends Partial<ComponentProps<Component>>>(Component: Component, curriedProps: CurriedProps): PartialComponent<Component, CurriedProps>;
-export declare function createPartialComponent<Component extends ComponentType<any>, CurriedProps extends Partial<ComponentProps<Component>>, AdditionalProps = {}>(Component: Component, curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps): PartialComponent<Component, CurriedProps, AdditionalProps>;
-export declare function usePartialComponent<Component extends ComponentType<any>, CurriedProps extends Partial<ComponentProps<Component>>, AdditionalProps = {}>(createCurriedProps: (additionalProps: AdditionalProps) => CurriedProps, deps: DependencyList, Component: Component): PartialComponent<Component, CurriedProps, AdditionalProps>;
-export declare function createPartialObserverComponent<Component extends ComponentType<any>, CurriedProps extends Partial<ComponentProps<Component>>, AdditionalProps = {}>(Component: Component, curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps): PartialComponent<Component, CurriedProps, AdditionalProps>;
-export declare function createUnsafePartialObserverComponent<Component extends ComponentType<any>, CurriedProps, AdditionalProps = {}>(Component: Component, curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps): UnsafePartialComponent<Component, CurriedProps, AdditionalProps>;
-export declare function usePartialObserverComponent<Component extends ComponentType<any>, CurriedProps extends Partial<ComponentProps<Component>>, AdditionalProps = {}>(curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps, deps: DependencyList, Component: Component): PartialComponent<Component, CurriedProps, AdditionalProps>;
+export declare function createPartialComponent<Component extends ComponentType<any>, CurriedProps>(Component: Component, curriedPropsSource: () => CurriedProps): PartialComponent<Component, CurriedProps, {}>;
+export declare function createPartialComponent<Component extends ComponentType<any>, CurriedProps, AdditionalProps, AllAdditionalPropKeys extends readonly (keyof AdditionalProps)[]>(Component: Component, curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps, additionalPropKeys: FriendlyExhaustiveArrayOfUnion<keyof AdditionalProps, AllAdditionalPropKeys>): PartialComponent<Component, CurriedProps, AdditionalProps>;
+export declare function usePartialComponent<Component extends ComponentType<any>, CurriedProps>(curriedPropsSource: () => CurriedProps, deps: DependencyList, Component: Component): PartialComponent<Component, CurriedProps, {}>;
+export declare function usePartialComponent<Component extends ComponentType<any>, CurriedProps, AdditionalProps, AllAdditionalPropKeys extends readonly (keyof AdditionalProps)[]>(curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps, deps: DependencyList, Component: Component, additionalPropKeys: FriendlyExhaustiveArrayOfUnion<keyof AdditionalProps, AllAdditionalPropKeys>): PartialComponent<Component, CurriedProps, AdditionalProps>;
+export declare function createPartialObserverComponent<Component extends ComponentType<any>, CurriedProps>(Component: Component, curriedPropsSource: () => CurriedProps): PartialComponent<Component, CurriedProps, {}>;
+export declare function createPartialObserverComponent<Component extends ComponentType<any>, CurriedProps, AdditionalProps, AllAdditionalPropKeys extends readonly (keyof AdditionalProps)[]>(Component: Component, curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps, additionalPropKeys: FriendlyExhaustiveArrayOfUnion<keyof AdditionalProps, AllAdditionalPropKeys>): PartialComponent<Component, CurriedProps, AdditionalProps>;
+export declare function createUnsafePartialObserverComponent<Component extends ComponentType<any>, CurriedProps>(Component: Component, curriedPropsSource: () => CurriedProps): UnsafePartialComponent<Component, CurriedProps, {}>;
+export declare function createUnsafePartialObserverComponent<Component extends ComponentType<any>, CurriedProps, AdditionalProps, AllAdditionalPropKeys extends readonly (keyof AdditionalProps)[]>(Component: Component, curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps, additionalPropKeys: FriendlyExhaustiveArrayOfUnion<keyof AdditionalProps, AllAdditionalPropKeys>): UnsafePartialComponent<Component, CurriedProps, AdditionalProps>;
+export declare function usePartialObserverComponent<Component extends ComponentType<any>, CurriedProps>(curriedPropsSource: () => CurriedProps, deps: DependencyList, Component: Component): PartialComponent<Component, CurriedProps, {}>;
+export declare function usePartialObserverComponent<Component extends ComponentType<any>, CurriedProps, AdditionalProps, AllAdditionalPropKeys extends readonly (keyof AdditionalProps)[]>(curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps, deps: DependencyList, Component: Component, additionalPropKeys: FriendlyExhaustiveArrayOfUnion<keyof AdditionalProps, AllAdditionalPropKeys>): PartialComponent<Component, CurriedProps, AdditionalProps>;
 type RemainingComponentProps<Component extends ComponentType, CurriedProps> = Omit<ComponentProps<Component>, keyof CurriedProps> & JSX.IntrinsicAttributes;
 export {};

package/.out/util/partial.js

@@ -11,49 +11,87 @@ export function createSimplePartialComponent(Component, curriedProps) {
         return (_jsx(C, { ref: ref, ...curriedProps, ...exposedProps }));
     });
 }
-export function createPartialComponent(Component, curriedPropsSource) {
+export function createPartialComponent(Component, curriedPropsSource, additionalPropKeys = []) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return forwardRef(function (exposedProps, ref) {
+    return forwardRef(function (props, ref) {
         // forward ref types are really difficult to work with
         // still needs a cast as `extends ComponentType<any>` != `ComponentType<any>`
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unnecessary-type-assertion
         const C = Component;
+        const [additionalProps, exposedProps,] = additionalPropKeys.reduce(function ([additionalProps, exposedProps,], key) {
+            const value = props[
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            key];
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            delete exposedProps[key];
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+            additionalProps[key] = value;
+            return [
+                additionalProps,
+                exposedProps,
+            ];
+        }, [
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            {},
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            { ...props },
+        ]);
         // TODO is there any way we can memoize this transformation?
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const curriedProps = curriedPropsSource(exposedProps);
+        const curriedProps = curriedPropsSource(additionalProps);
         return (_jsx(C, { ref: ref, ...curriedProps, ...exposedProps }));
     });
 }
 export function usePartialComponent(
 // has to be first so eslint react-hooks/exhaustive-deps can find the callback
 // has to be a function so eslint react-hooks/exhaustive-deps can reason about it :(
-createCurriedProps, 
+curriedPropsSource, 
 // has to be next so eslint react-hooks/exhaustive-deps can find the deps
-deps, Component) {
+deps, Component, additionalPropKeys = []) {
     return useMemo(function () {
-        return createPartialComponent(Component, createCurriedProps);
+        return createPartialComponent(Component, curriedPropsSource, additionalPropKeys);
     }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [
         // eslint-disable-next-line react-hooks/exhaustive-deps
         ...deps,
         Component,
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        ...additionalPropKeys,
     ]);
 }
-export function createPartialObserverComponent(Component, curriedPropsSource) {
+export function createPartialObserverComponent(Component, curriedPropsSource, additionalPropKeys = []) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return createUnsafePartialObserverComponent(Component, curriedPropsSource);
+    return createUnsafePartialObserverComponent(Component, curriedPropsSource, additionalPropKeys);
 }
-export function createUnsafePartialObserverComponent(Component, curriedPropsSource) {
+export function createUnsafePartialObserverComponent(Component, curriedPropsSource, additionalPropKeys = []) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return observer(forwardRef(function (exposedProps, ref) {
+    return observer(forwardRef(function (props, ref) {
         // forward ref types are really difficult to work with
         // still needs a cast as `extends ComponentType<any>` != `ComponentType<any>`
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unnecessary-type-assertion
         const C = Component;
+        // remove the additional props from the exposed props that get passed in to the component
+        // as this generates react warnings
+        const [additionalProps, exposedProps,] = additionalPropKeys.reduce(function ([additionalProps, exposedProps,], key) {
+            const value = props[
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            key];
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            delete exposedProps[key];
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+            additionalProps[key] = value;
+            return [
+                additionalProps,
+                exposedProps,
+            ];
+        }, [
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            {},
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            { ...props },
+        ]);
         // TODO is there any way we can memoize this transformation?
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const curriedProps = curriedPropsSource(exposedProps);
+        const curriedProps = curriedPropsSource(additionalProps);
         return (_jsx(C, { ref: ref, ...curriedProps, ...exposedProps }));
     }));
 }
@@ -61,14 +99,16 @@ export function usePartialObserverComponent(
 // has to be first so eslint react-hooks/exhaustive-deps can find the callback
 curriedPropsSource, 
 // has to be next so eslint react-hooks/exhaustive-deps can find the deps
-deps, Component) {
+deps, Component, additionalPropKeys = []) {
     return useMemo(function () {
-        return createPartialObserverComponent(Component, curriedPropsSource);
+        return createPartialObserverComponent(Component, curriedPropsSource, additionalPropKeys);
     }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [
         // eslint-disable-next-line react-hooks/exhaustive-deps
         ...deps,
         Component,
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        ...additionalPropKeys,
     ]);
 }

package/.turbo/turbo-build.log

@@ -3,16 +3,16 @@ $ tsup
 CLI Building entry: index.ts
 CLI Using tsconfig: tsconfig.build.json
 CLI tsup v8.3.5
-CLI Using tsup config: /home/runner/work/de/de/packages/react-form/tsup.config.ts
+CLI Using tsup config: /home/runner/work/strictly/strictly/packages/react-form/tsup.config.ts
 CLI Target: esnext
 CJS Build start
 ESM Build start
 DTS Build start
-ESM dist/index.js 356.07 KB
-ESM ⚡️ Build success in 1306ms
-CJS dist/index.cjs 365.80 KB
-CJS ⚡️ Build success in 1307ms
-DTS ⚡️ Build success in 10156ms
-DTS dist/index.d.cts 26.90 KB
-DTS dist/index.d.ts  26.90 KB
-Done in 11.09s.
+CJS dist/index.cjs 373.16 KB
+CJS ⚡️ Build success in 1665ms
+ESM dist/index.js 363.03 KB
+ESM ⚡️ Build success in 1708ms
+DTS ⚡️ Build success in 10720ms
+DTS dist/index.d.cts 34.05 KB
+DTS dist/index.d.ts  34.05 KB
+Done in 12.03s.

package/.turbo/turbo-check-types.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ tsc
-Done in 6.90s.
+Done in 7.83s.

package/.turbo/turbo-release$colon$exports.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ json -f package.json -f package.exports.json --merge > package.release.json
-Done in 0.09s.
+Done in 0.10s.

package/README.md

@@ -1,2 +1,6 @@
-# Form (React and Mobx)
+React form types and tools
 
+# TODO
+
+* Move Mobx handling to separate package
+* Move Mantine hooks to separate package

package/core/mobx/field_adapter.ts

@@ -1,7 +1,7 @@
 import {
-  type FieldConverter,
+  type AnnotatedFieldConverter,
   type FieldValueFactory,
-  type SafeFieldConverter,
+  type UnreliableFieldConverter,
 } from 'types/field_converters'
 
 export type FieldAdapter<
@@ -16,17 +16,25 @@ export type FieldAdapter<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   Context = any,
 > = {
-  readonly convert: SafeFieldConverter<From, To, ValuePath, Context>,
+  readonly convert: AnnotatedFieldConverter<From, To, ValuePath, Context>,
   readonly create: FieldValueFactory<From, ValuePath, Context>,
-  readonly revert?: FieldConverter<To, From, E, ValuePath, Context>,
+  readonly revert?: UnreliableFieldConverter<To, From, E, ValuePath, Context>,
 }
 
-export type FromTypeOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer From> ? From
+export type FromOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer From> ? From
   : never
 
-export type ToTypeOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _F, infer To> ? To
+export type ToOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _F, infer To> ? To
   : never
 
-export type ErrorTypeOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _From, infer _To, infer E>
+export type ErrorOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _From, infer _To, infer E>
   ? NonNullable<E>
   : never
+
+export type ValuePathOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<
+  infer _From,
+  infer _To,
+  infer _E,
+  infer ValuePath
+> ? ValuePath
+  : never