@structuralists/scaffolding 0.10.2 → 0.12.0

package/src/forms/state/useFormState/useFormState.test-d.ts

@@ -2,9 +2,11 @@ import { describe, it, expectTypeOf } from 'vitest';
 import { useFormState } from './useFormState';
 import { errorAt } from './errorAt';
 import { allOf, matches, min, minLength, notEmpty } from '../validators/validators';
-import type { FormErrors } from './types';
+import type { FormErrors, FormFieldProps } from './types';
 import type { Refine, Validations } from '../validations/types';
 import type { Path, ValueAt } from '../path/types';
+import type { TextInputForFormProps } from '../bindings/TextInputForForm';
+import type { SingleSelectForFormProps } from '../bindings/SingleSelectForForm';
 
 // These tests exercise the headline feature end-to-end at the hook boundary:
 // the type `onSubmit` receives must be the *refined* form type. The two
@@ -308,6 +310,12 @@ type InsuranceQuoteForm = {
   referralSource: string | null;
   notes: string | undefined;
   agreedToTerms: boolean | undefined;
+  // Disambiguation probe: an object field owning a key literally named
+  // `each` must still be treated as a nested object spec (directed by T).
+  audit: {
+    each: string | undefined;
+    reviewedBy: string | undefined;
+  };
   paperlessBilling: boolean;
 };
 
@@ -425,6 +433,83 @@ describe('useFormState narrowing at realistic scale', () => {
     errorAt(errors, ['email', 'domain']);
   });
 
+  it('getFormFieldPropsAt infers FormFieldProps<ValueAt> at deep paths, inline at the call site', () => {
+    const form = useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: { email: notEmpty('email') },
+    });
+
+    // Flat and deep paths: value/onChange typed by ValueAt<T, P>.
+    expectTypeOf(form.getFormFieldPropsAt(['email'])).toEqualTypeOf<
+      FormFieldProps<string | undefined>
+    >();
+    expectTypeOf(
+      form.getFormFieldPropsAt(['homeAddress', 'city']),
+    ).toEqualTypeOf<FormFieldProps<string | undefined>>();
+    expectTypeOf(
+      form.getFormFieldPropsAt(['drivers', 0, 'incidents', 1, 'claimAmountUsd']),
+    ).toEqualTypeOf<FormFieldProps<number | null>>();
+    expectTypeOf(
+      form.getFormFieldPropsAt(['vehicles', 0, 'garagingAddress', 'postalCode']),
+    ).toEqualTypeOf<FormFieldProps<string | undefined>>();
+
+    // Nullable-object semantics (PR #17) flow through the binding: stepping
+    // through a dead ancestor adds `| undefined`, stopping AT a nullable
+    // field keeps its exact type.
+    expectTypeOf(
+      form.getFormFieldPropsAt(['coApplicant', 'sharesResidence']),
+    ).toEqualTypeOf<FormFieldProps<boolean | undefined>>();
+    expectTypeOf(
+      form.getFormFieldPropsAt(['pastPolicies', 0, 'activeUntil']),
+    ).toEqualTypeOf<FormFieldProps<string | null | undefined>>();
+    expectTypeOf(form.getFormFieldPropsAt(['employer'])).toEqualTypeOf<
+      FormFieldProps<string | null>
+    >();
+
+    // Only Path<T> is admitted.
+    // @ts-expect-error 'emial' is not a field of the form
+    form.getFormFieldPropsAt(['emial']);
+    // @ts-expect-error no paths exist below a scalar leaf
+    form.getFormFieldPropsAt(['email', 'domain']);
+  });
+
+  it('element wrappers accept only shape-compatible bindings', () => {
+    const form = useFormState({ initialValues: {} as InsuranceQuoteForm });
+
+    type TextBinding = TextInputForFormProps['formFieldProps'];
+
+    // Text-shaped fields bind: V must sit between the wrapper's emit type
+    // (string) and display type (string | null | undefined).
+    expectTypeOf(
+      form.getFormFieldPropsAt(['homeAddress', 'city']),
+    ).toMatchTypeOf<TextBinding>();
+    expectTypeOf(form.getFormFieldPropsAt(['employer'])).toMatchTypeOf<TextBinding>();
+    expectTypeOf(
+      form.getFormFieldPropsAt(['pastPolicies', 0, 'activeUntil']),
+    ).toMatchTypeOf<TextBinding>();
+
+    // Wrong-shaped bindings fail at the formFieldProps prop.
+    // @ts-expect-error a number-typed path cannot bind to a text element
+    const numberIntoText: TextBinding = form.getFormFieldPropsAt(['deductibleUsd']);
+    // @ts-expect-error a boolean-typed path cannot bind to a text element
+    const booleanIntoText: TextBinding = form.getFormFieldPropsAt(['agreedToTerms']);
+
+    // The select wrapper lines its options' literal union up with the field:
+    // emitting a wider type than the field holds is rejected.
+    type CoverageBinding = SingleSelectForFormProps<
+      'liability' | 'comprehensive'
+    >['formFieldProps'];
+    expectTypeOf<
+      FormFieldProps<'liability' | 'comprehensive' | undefined>
+    >().toMatchTypeOf<CoverageBinding>();
+    // @ts-expect-error a plain-string field would accept values outside the options
+    const stringIntoSelect: CoverageBinding = form.getFormFieldPropsAt(['coverageType']);
+
+    void numberIntoText;
+    void booleanIntoText;
+    void stringIntoSelect;
+  });
+
   it('paths through optional sections and nullable lists resolve, at scale', () => {
     // The latent hole this pins: Path admitted these paths all along, but
     // ValueAt resolved them to `never` because `keyof (Obj | undefined)` is
@@ -468,3 +553,433 @@ describe('useFormState narrowing at realistic scale', () => {
     >().toEqualTypeOf<string | null | undefined>();
   });
 });
+
+// ---------------------------------------------------------------------------
+// The recursive grammar (plan phase 2, grammar proven whole by the phase-2
+// type spike): nested object specs, list `each` specs, validator arrays at
+// every level, and the recursive `Refine` — exercised inline at the hook
+// boundary on the chunky form. Ported from the spike's probe suite; the
+// spike's two binding adjustments (value-model-first branch order in
+// `RefineField`, the `Refine` identity gate) are what these probes pin.
+// ---------------------------------------------------------------------------
+
+describe('useFormState — full recursive grammar at InsuranceQuoteForm scale, inline', () => {
+  it('composes leaf/array/nested/each constraints and refines at every depth', () => {
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: {
+        // -- root leaves, same mix as the flat probe above
+        firstName: notEmpty('firstName'),
+        lastName: [notEmpty('lastName')],
+        email: [notEmpty('email'), matches('email', /@/, 'a valid email')],
+        phone: matches('phone', /^[\d\s()+-]+$/, 'a phone number'),
+        dateOfBirth: allOf(
+          notEmpty('dateOfBirth'),
+          matches('dateOfBirth', /^\d{4}-\d{2}-\d{2}$/, 'an ISO date'),
+        ),
+        yearsEmployed: min('yearsEmployed', 0),
+        coverageType: [
+          notEmpty('coverageType'),
+          (val) => {
+            expectTypeOf(val).toEqualTypeOf<string | undefined>();
+            return null;
+          },
+        ],
+        agreedToTerms: notEmpty('agreedToTerms'),
+        // -- nested object spec (depth 2), validators + arrays + bare arrow
+        homeAddress: {
+          city: notEmpty('city'),
+          postalCode: [notEmpty('postalCode'), matches('postalCode', /^\d{5}$/, '5 digits')],
+          state: (val) => {
+            expectTypeOf(val).toEqualTypeOf<string | undefined>();
+            return null;
+          },
+        },
+        // -- nested object spec on a NULLABLE section
+        mailingAddress: {
+          city: notEmpty('mailing city'),
+        },
+        coApplicant: {
+          firstName: notEmpty('coApplicant firstName'),
+        },
+        // -- list `each` spec with a nested list `each` inside (the full
+        //    composition case from the plan), plus arrays and bare arrows at
+        //    both list depths
+        drivers: {
+          each: {
+            name: notEmpty('name'),
+            licenseNumber: [notEmpty('licenseNumber'), minLength('licenseNumber', 5)],
+            licenseState: (val) => {
+              expectTypeOf(val).toEqualTypeOf<string | undefined>();
+              return null;
+            },
+            incidents: {
+              each: {
+                date: notEmpty('date'),
+                kind: (val) => {
+                  expectTypeOf(val).toEqualTypeOf<string | undefined>();
+                  return null;
+                },
+                claimAmountUsd: min('claimAmountUsd', 0),
+              },
+            },
+          },
+        },
+        // -- object-in-list: each spec whose element has a nested object spec
+        vehicles: {
+          each: {
+            vin: [notEmpty('vin')],
+            year: min('year', 1900),
+            garagingAddress: {
+              line1: notEmpty('garaging line1'),
+              postalCode: [notEmpty('garaging postalCode'), matches('postalCode', /^\d{5}$/, '5 digits')],
+            },
+          },
+        },
+        // -- each spec on a NULLABLE list
+        pastPolicies: {
+          each: {
+            insurer: notEmpty('insurer'),
+          },
+        },
+        // -- whole-list leaf validator on a list field (leaf forms stay legal
+        //    for structural fields)
+        discountCodes: (val) => {
+          expectTypeOf(val).toEqualTypeOf<string[]>();
+          return null;
+        },
+        // -- object field owning a key named `each`: interpreted as a nested
+        //    object spec because T directs, not the constraint's shape
+        audit: {
+          each: notEmpty('audit each'),
+        },
+      },
+      onSubmit: (values) => {
+        // Root leaves refine exactly as on the flat grammar.
+        expectTypeOf(values.firstName).toEqualTypeOf<string>();
+        expectTypeOf(values.lastName).toEqualTypeOf<string>();
+        expectTypeOf(values.email).toEqualTypeOf<string>();
+        expectTypeOf(values.dateOfBirth).toEqualTypeOf<string>();
+        expectTypeOf(values.coverageType).toEqualTypeOf<string>();
+        expectTypeOf(values.agreedToTerms).toEqualTypeOf<boolean>();
+        expectTypeOf(values.phone).toEqualTypeOf<string | undefined>();
+        expectTypeOf(values.yearsEmployed).toEqualTypeOf<number | null>();
+
+        // Nested object spec: constrained leaves refine, siblings pass through.
+        expectTypeOf(values.homeAddress.city).toEqualTypeOf<string>();
+        expectTypeOf(values.homeAddress.postalCode).toEqualTypeOf<string>();
+        expectTypeOf(values.homeAddress.state).toEqualTypeOf<string | undefined>();
+        expectTypeOf(values.homeAddress.line1).toEqualTypeOf<string | undefined>();
+
+        // Nullable section: the section stays optional, its constrained leaf
+        // refines inside the present branch.
+        expectTypeOf(values.mailingAddress?.city).toEqualTypeOf<string | undefined>();
+        expectTypeOf(values.mailingAddress?.line1).toEqualTypeOf<string | undefined>();
+        expectTypeOf(values.coApplicant?.firstName).toEqualTypeOf<string | undefined>();
+        expectTypeOf(values.coApplicant?.sharesResidence).toEqualTypeOf<boolean | undefined>();
+
+        // each: refined element type flows through Array<...>.
+        expectTypeOf(values.drivers[0].name).toEqualTypeOf<string>();
+        expectTypeOf(values.drivers[0].licenseNumber).toEqualTypeOf<string>();
+        expectTypeOf(values.drivers[0].licenseState).toEqualTypeOf<string | undefined>();
+
+        // list-in-list: refinement reaches depth 4.
+        expectTypeOf(values.drivers[0].incidents[0].date).toEqualTypeOf<string>();
+        expectTypeOf(values.drivers[0].incidents[0].kind).toEqualTypeOf<string | undefined>();
+        expectTypeOf(values.drivers[0].incidents[0].claimAmountUsd).toEqualTypeOf<number | null>();
+
+        // object-in-list: nested spec inside an each spec.
+        expectTypeOf(values.vehicles[0].vin).toEqualTypeOf<string>();
+        expectTypeOf(values.vehicles[0].garagingAddress.line1).toEqualTypeOf<string>();
+        expectTypeOf(values.vehicles[0].garagingAddress.postalCode).toEqualTypeOf<string>();
+        expectTypeOf(values.vehicles[0].garagingAddress.city).toEqualTypeOf<string | undefined>();
+
+        // Nullable list: `| null` on the list survives, elements refine.
+        expectTypeOf(values.pastPolicies?.[0].insurer).toEqualTypeOf<string | undefined>();
+
+        // Disambiguation: `audit` refined as an object spec despite the
+        // `each` key.
+        expectTypeOf(values.audit.each).toEqualTypeOf<string>();
+        expectTypeOf(values.audit.reviewedBy).toEqualTypeOf<string | undefined>();
+
+        // Unconstrained structure passes through untouched.
+        expectTypeOf(values.paperlessBilling).toEqualTypeOf<boolean>();
+        expectTypeOf(values.discountCodes).toEqualTypeOf<string[]>();
+        expectTypeOf(values.deductibleUsd).toEqualTypeOf<number | undefined>();
+      },
+    });
+  });
+});
+
+describe('useFormState — hook-boundary regimes on the recursive grammar', () => {
+  it('without constraints, onSubmit receives the IDENTICAL form type at every depth', () => {
+    // With the default V = Validations<T>, the identity gate on Refine must
+    // short-circuit to T itself — not a union of structurally-identical
+    // mapped copies of each section (the one genuine bug the type spike
+    // found in the plan's sketch; toEqualTypeOf is the strict-identity pin).
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      onSubmit: (values) => {
+        expectTypeOf(values).toEqualTypeOf<InsuranceQuoteForm>();
+        expectTypeOf(values.homeAddress).toEqualTypeOf<UsAddress>();
+        expectTypeOf(values.drivers).toEqualTypeOf<InsuranceQuoteForm['drivers']>();
+      },
+    });
+  });
+
+  it('infers T from literal initialValues while contextually typing nested constraints', () => {
+    useFormState({
+      initialValues: {
+        name: undefined as string | undefined,
+        home: {
+          city: undefined as string | undefined,
+          zip: undefined as string | undefined,
+        },
+        pets: [] as Array<{ nickname: string | undefined }>,
+      },
+      constraints: {
+        name: notEmpty('name'),
+        home: { city: notEmpty('city') },
+        pets: { each: { nickname: notEmpty('nickname') } },
+      },
+      onSubmit: (values) => {
+        expectTypeOf(values.name).toEqualTypeOf<string>();
+        expectTypeOf(values.home.city).toEqualTypeOf<string>();
+        expectTypeOf(values.home.zip).toEqualTypeOf<string | undefined>();
+        expectTypeOf(values.pets[0].nickname).toEqualTypeOf<string>();
+      },
+    });
+  });
+
+  it('preserves refinement markers through a pre-built `as const satisfies` object at full depth', () => {
+    const prebuilt = {
+      email: [notEmpty('email'), matches('email', /@/, 'a valid email')],
+      homeAddress: {
+        city: notEmpty('city'),
+      },
+      drivers: {
+        each: {
+          name: notEmpty('name'),
+          incidents: {
+            each: { date: notEmpty('date') },
+          },
+        },
+      },
+    } as const satisfies Validations<InsuranceQuoteForm>;
+
+    // Direct Refine application, no hook in between.
+    type Submit = Refine<InsuranceQuoteForm, typeof prebuilt>;
+    expectTypeOf<Submit['email']>().toEqualTypeOf<string>();
+    expectTypeOf<Submit['homeAddress']['city']>().toEqualTypeOf<string>();
+    expectTypeOf<Submit['homeAddress']['line1']>().toEqualTypeOf<string | undefined>();
+    expectTypeOf<Submit['drivers'][number]['name']>().toEqualTypeOf<string>();
+    expectTypeOf<Submit['drivers'][number]['incidents'][number]['date']>().toEqualTypeOf<string>();
+    expectTypeOf<Submit['drivers'][number]['licenseState']>().toEqualTypeOf<string | undefined>();
+
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: prebuilt,
+      onSubmit: (values) => {
+        expectTypeOf(values.email).toEqualTypeOf<string>();
+        expectTypeOf(values.drivers[0].incidents[0].date).toEqualTypeOf<string>();
+      },
+    });
+  });
+});
+
+declare const cond: boolean;
+
+describe('useFormState — leaf forms on structural fields, and phase-1 soundness at depth', () => {
+  it('contextually types whole-section and whole-list leaf validators', () => {
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: {
+        // A bare arrow on an OBJECT field is a whole-value validator, not a
+        // nested spec — the leaf forms stay legal for structural fields.
+        homeAddress: (val) => {
+          expectTypeOf(val).toEqualTypeOf<UsAddress>();
+          return null;
+        },
+        mailingAddress: (val) => {
+          expectTypeOf(val).toEqualTypeOf<UsAddress | undefined>();
+          return null;
+        },
+        // Whole-list validator array on a list field.
+        drivers: [
+          (val) => {
+            expectTypeOf(val).toEqualTypeOf<InsuranceQuoteForm['drivers']>();
+            return val.length > 0 ? null : 'at least one driver';
+          },
+        ],
+      },
+      onSubmit: (values) => {
+        // Whole-value leaf validators narrow nothing (no markers here).
+        expectTypeOf(values.homeAddress).toEqualTypeOf<UsAddress>();
+        expectTypeOf(values.drivers).toEqualTypeOf<InsuranceQuoteForm['drivers']>();
+      },
+    });
+  });
+
+  it('keeps union-typed constraints per-branch sound inside nested and each specs', () => {
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: {
+        homeAddress: {
+          // Only one branch runs: distribution must yield the union of the
+          // per-branch refinements, exactly as at the root (phase 1).
+          city: cond ? notEmpty('city') : minLength('city', 2),
+          // Array with a union-typed MEMBER: the member contributes only the
+          // intersection of its branches' excludes (never here — minLength
+          // narrows nothing), so the field must NOT refine.
+          state: [cond ? notEmpty('state') : minLength('state', 2)],
+        },
+        drivers: {
+          each: {
+            name: cond ? notEmpty('name') : minLength('name', 2),
+          },
+        },
+      },
+      onSubmit: (values) => {
+        // string (notEmpty branch) | string | undefined (minLength branch)
+        expectTypeOf(values.homeAddress.city).toEqualTypeOf<string | undefined>();
+        expectTypeOf(values.homeAddress.state).toEqualTypeOf<string | undefined>();
+        expectTypeOf(values.drivers[0].name).toEqualTypeOf<string | undefined>();
+      },
+    });
+  });
+});
+
+// Negative probes at depth. Anchor gotcha (from the spike): wrong-KEY
+// rejections are TS2353 excess-property errors anchored at the offending
+// leaf line, but wrong-VALIDATOR-INPUT rejections are TS2322 assignability
+// errors anchored at the OUTERMOST constraint key — their `@ts-expect-error`
+// directives must sit on the parent/root key's line.
+
+describe('useFormState — recursive-grammar negative probes', () => {
+  it('rejects a wrong key inside a nested object spec', () => {
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: {
+        homeAddress: {
+          // @ts-expect-error 'cityy' is not a field of UsAddress
+          cityy: notEmpty('cityy'),
+        },
+      },
+    });
+  });
+
+  it('rejects a wrong key inside an each spec', () => {
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: {
+        drivers: {
+          each: {
+            // @ts-expect-error 'nam' is not a field of the driver element
+            nam: notEmpty('nam'),
+          },
+        },
+      },
+    });
+  });
+
+  it('rejects a wrong key inside a list-in-list each spec', () => {
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: {
+        drivers: {
+          each: {
+            incidents: {
+              each: {
+                // @ts-expect-error 'datee' is not a field of the incident element
+                datee: notEmpty('datee'),
+              },
+            },
+          },
+        },
+      },
+    });
+  });
+
+  it('rejects a bare object spec (no `each`) on a list field', () => {
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: {
+        drivers: {
+          // @ts-expect-error a list field takes { each: ... }, not a field
+          // map — EPC anchors at the unknown property
+          name: notEmpty('name'),
+        },
+      },
+    });
+  });
+
+  it('rejects an `each` spec on a plain object field', () => {
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: {
+        homeAddress: {
+          // @ts-expect-error homeAddress is an object, not a list — no `each`
+          each: { city: notEmpty('city') },
+        },
+      },
+    });
+  });
+
+  it('rejects a nested spec on a scalar leaf', () => {
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: {
+        email: {
+          // @ts-expect-error email is a scalar; only validators/arrays apply
+          domain: notEmpty('domain'),
+        },
+      },
+    });
+  });
+
+  it('rejects a wrong-input validator inside a nested spec', () => {
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: {
+        // @ts-expect-error min validates numbers; postalCode is a string —
+        // the TS2322 anchors at the PARENT key, elaboration names postalCode
+        homeAddress: {
+          postalCode: min('postalCode', 0),
+        },
+      },
+    });
+  });
+
+  it('rejects a wrong-input validator in an array at list-in-list depth', () => {
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: {
+        // @ts-expect-error min validates numbers; date is a string — the
+        // TS2322 anchors at the ROOT constraint key, elaboration walks
+        // each.incidents → each.date down to the parameter mismatch
+        drivers: {
+          each: {
+            incidents: {
+              each: {
+                date: [notEmpty('date'), min('date', 0)],
+              },
+            },
+          },
+        },
+      },
+    });
+  });
+
+  it('rejects a bare validator where an each spec map is required', () => {
+    useFormState({
+      initialValues: {} as InsuranceQuoteForm,
+      constraints: {
+        // @ts-expect-error `each` takes a per-field map, not a validator
+        // (rejected by the weak-type check; anchors at the parent key)
+        vehicles: {
+          each: minLength('vehicles', 1),
+        },
+      },
+    });
+  });
+});

package/src/forms/state/useFormState/useFormState.test.tsx

@@ -40,8 +40,8 @@ describe('useFormState', () => {
         constraints: { email: notEmpty('email') },
       }),
     );
-    // The full structured shape: one entry per failing field, addressed by
-    // a typed path (single-key on the flat grammar).
+    // The full structured shape: one entry per failing constrained node,
+    // addressed by a typed path (single-key for a root leaf).
     expect(result.current.errors).toEqual([
       { path: ['email'], error: "'email' cannot be empty" },
     ]);

package/src/forms/state/useFormState/useFormState.ts

@@ -5,6 +5,7 @@ import type {
   FormValuesObject,
   UnionPolicyCheck,
 } from './types';
+import { useFieldBinding } from './useFieldBinding';
 import { useFormDebugger } from './useFormDebugger';
 import { useFormSubmit } from './useFormSubmit';
 import type { Refine, Validations } from '../validations/types';
@@ -30,8 +31,8 @@ type Args<T extends FormValuesObject, V extends Validations<T>> = {
 // Plumbing only: each slice of form state lives in its own pure function or
 // focused hook, and this hook just links them up and recomposes their
 // outputs into the `FormHelpers<T>` surface. Values state is the one slice
-// kept inline — today it is a bare `useState`, and the granular setters that
-// would earn it a module of its own arrive with the path-based grammar.
+// kept inline — a bare `useState`; the granular path writes layer on top of
+// its setter (`useFieldBinding` funnels `write()` results through it).
 export const useFormState = <
   T extends FormValuesObject,
   const V extends Validations<T> = Validations<T>,
@@ -53,8 +54,15 @@ export const useFormState = <
     onSubmit,
   });
 
+  const { touched, getFormFieldPropsAt } = useFieldBinding({
+    values,
+    onValueChanges,
+    errors,
+    submitAttempted,
+  });
+
   const Debugger = useFormDebugger({
-    snapshot: { values, errors, isValid, submitAttempted },
+    snapshot: { values, errors, isValid, submitAttempted, touched },
   });
 
   return {
@@ -64,6 +72,7 @@ export const useFormState = <
     isValid,
     submitAttempted,
     submit,
+    getFormFieldPropsAt,
     Debugger,
   };
 };