Open History to see the last commit
1import React from 'react'
2import { expectTypeOf } from 'vitest'
3import { createFormHook, getFormHookHelpers } from '../src'
4import type {
5 DefaultFieldOptions,
6 DefaultFormGroupOptions,
7 DefaultFormOptions,
8 FieldWithValue,
9 ReactComponentTree,
10} from '../src'
11β
12const { useAppForm } = createFormHook({
13 fieldComponents: {},
14 formComponents: {},
15 defaultFormOptions: {
16 listenersMerge: 'append',
17 errorVisibility: ({ state, fieldState }) => {
18 expectTypeOf(state.values).toBeUnknown()
19 expectTypeOf(fieldState.value).toBeAny()
20 return true
21 },
22 listeners: [
23 {
24 triggers: [],
25 run: ({ value, formApi }) => {
26 expectTypeOf(value).toBeUnknown()
27 expectTypeOf(formApi.state.values).toBeUnknown()
28 },
29 },
30 ],
31 onSubmitInvalid: ({ value, formApi }) => {
32 expectTypeOf(value).toBeUnknown()
33 expectTypeOf(formApi.state.values).toBeUnknown()
34 },
35 },
36 defaultFieldOptions: {
37 listenersMerge: 'prepend',
38 errorVisibility: ({ state, fieldState }) => {
39 expectTypeOf(state.values).toBeUnknown()
40 expectTypeOf(fieldState.value).toBeAny()
41 return true
42 },
43 listeners: [
44 {
45 triggers: [],
46 run: ({ value, fieldApi, formApi }) => {
47 expectTypeOf(value).toBeUnknown()
48 expectTypeOf(fieldApi.value).toBeUnknown()
49 expectTypeOf(formApi.state.values).toBeUnknown()
50 },
51 },
52 ],
53 },
54 defaultFormGroupOptions: {
55 onSubmitInvalid: ({ value, formApi, groupApi }) => {
56 expectTypeOf(value).toBeUnknown()
57 expectTypeOf(formApi.state.values).toBeUnknown()
58 expectTypeOf(groupApi.value).toBeUnknown()
59 },
60 },
61})
62β
63function InferenceRemainsLocal() {
64 const form = useAppForm({
65 defaultValues: {
66 name: '',
67 tags: [''],
68 group: { count: 0 },
69 },
70 serverState: undefined,
71 })
72β
73 expectTypeOf(form.state.values).toEqualTypeOf<{
74 name: string
75 tags: Array<string>
76 group: { count: number }
77 }>()
78β
79 return (
80 <>
81 <form.Field name="name">
82 {(field) => {
83 expectTypeOf(field.value).toEqualTypeOf<string>()
84 return null
85 }}
86 </form.Field>
87 <form.ArrayField name="tags">
88 {(field) => {
89 expectTypeOf(field.value).toEqualTypeOf<Array<string>>()
90 return null
91 }}
92 </form.ArrayField>
93 <form.FormGroup name="group">
94 {(group) => {
95 expectTypeOf(group.value).toEqualTypeOf<{ count: number }>()
96 return null
97 }}
98 </form.FormGroup>
99 </>
100 )
101}
102β
103void InferenceRemainsLocal
104β
105function TextFieldComponent(props: {
106 field: FieldWithValue<string>
107 label: string
108}) {
109 return props.label
110}
111β
112function NumberFieldComponent(props: { field: FieldWithValue<number> }) {
113 return String(props.field.value)
114}
115β
116function FieldInfoComponent(props: { field: FieldWithValue<unknown> }) {
117 return String(props.field.value)
118}
119β
120const { fieldComponent } = getFormHookHelpers()
121const TextField = fieldComponent.strict(TextFieldComponent, 'field')
122const NumberField = fieldComponent.strict(NumberFieldComponent, 'field')
123const FieldInfo = fieldComponent.loose(FieldInfoComponent, 'field')
124const MemoTextField = React.memo(TextField)
125const LazyTextField = React.lazy(() => Promise.resolve({ default: TextField }))
126β
127const reusableFields = {
128 inputs: {
129 text: {
130 TextField,
131 MemoTextField,
132 LazyTextField,
133 },
134 numbers: {
135 NumberField,
136 },
137 },
138 feedback: {
139 FieldInfo,
140 },
141} satisfies ReactComponentTree
142β
143function SubmitButton() {
144 return null
145}
146β
147function FormStatus() {
148 return null
149}
150β
151const {
152 useAppForm: useNestedAppForm,
153 defineAppFieldGroup: defineNestedAppFieldGroup,
154} = createFormHook({
155 fieldComponents: reusableFields,
156 formComponents: {
157 actions: {
158 SubmitButton,
159 },
160 layout: {
161 status: {
162 FormStatus,
163 },
164 },
165 },
166})
167β
168const nestedAppFieldGroup = defineNestedAppFieldGroup(({ strict }) => ({
169 name: strict<string>(),
170 age: strict<number>(),
171}))
172β
173function NestedComponentTrees() {
174 const form = useNestedAppForm({
175 defaultValues: {
176 name: '',
177 age: 0,
178 tags: [''],
179 },
180 })
181β
182 return (
183 <>
184 <form.actions.SubmitButton />
185 <form.layout.status.FormStatus />
186 <form.Field name="name">
187 {(field) => {
188 expectTypeOf<keyof typeof field.inputs.numbers>().toBeNever()
189 return (
190 <>
191 <field.inputs.text.TextField label="Name" />
192 <field.inputs.text.MemoTextField label="Name" />
193 <field.inputs.text.LazyTextField label="Name" />
194 <field.feedback.FieldInfo />
195 {/* @ts-expect-error number-only leaves are filtered from string fields */}
196 <field.inputs.numbers.NumberField />
197 </>
198 )
199 }}
200 </form.Field>
201 <form.Field name="age">
202 {(field) => {
203 expectTypeOf<keyof typeof field.inputs.text>().toBeNever()
204 return (
205 <>
206 <field.inputs.numbers.NumberField />
207 {/* @ts-expect-error string-only leaves are filtered from number fields */}
208 <field.inputs.text.TextField label="Age" />
209 </>
210 )
211 }}
212 </form.Field>
213 <form.ArrayField name="tags">
214 {(field) => {
215 expectTypeOf<keyof typeof field.inputs.text>().toBeNever()
216 return <field.feedback.FieldInfo />
217 }}
218 </form.ArrayField>
219 <nestedAppFieldGroup.fields.Field name="name">
220 {(field) => (
221 <>
222 <field.inputs.text.TextField label="Name" />
223 {/* @ts-expect-error nested filtering is preserved by app field groups */}
224 <field.inputs.numbers.NumberField />
225 </>
226 )}
227 </nestedAppFieldGroup.fields.Field>
228 </>
229 )
230}
231β
232void NestedComponentTrees
233β
234createFormHook({
235 fieldComponents: {
236 invalid: {
237 // @ts-expect-error component-tree leaves must be React components
238 value: 'not a component',
239 },
240 },
241 formComponents: {},
242})
243β
244createFormHook({
245 fieldComponents: {},
246 formComponents: {
247 invalid: {
248 // @ts-expect-error component-tree leaves must be React components
249 value: 123,
250 },
251 },
252})
253β
254expectTypeOf<
255 Extract<
256 keyof DefaultFormOptions,
257 'formId' | 'defaultValues' | 'validators' | 'onSubmit'
258 >
259>().toBeNever()
260β
261expectTypeOf<
262 Extract<
263 keyof DefaultFieldOptions,
264 'name' | 'defaultValues' | 'validators' | 'onSubmit'
265 >
266>().toBeNever()
267β
268expectTypeOf<
269 Extract<
270 keyof DefaultFormGroupOptions,
271 'form' | 'name' | 'defaultValues' | 'validators' | 'onSubmit'
272 >
273>().toBeNever()
274β
275createFormHook({
276 fieldComponents: {},
277 formComponents: {},
278 defaultFormOptions: {
279 // @ts-expect-error formId belongs to an individual form instance
280 formId: 'profile',
281 },
282})
283β
284createFormHook({
285 fieldComponents: {},
286 formComponents: {},
287 defaultFormOptions: {
288 // @ts-expect-error defaultValues must remain an inference source
289 defaultValues: { name: '' },
290 },
291})
292β
293createFormHook({
294 fieldComponents: {},
295 formComponents: {},
296 defaultFormOptions: {
297 // @ts-expect-error serverState must remain local to an individual form
298 serverState: undefined,
299 },
300})
301β
302createFormHook({
303 fieldComponents: {},
304 formComponents: {},
305 defaultFieldOptions: {
306 // @ts-expect-error validators must remain local to a field
307 validators: [],
308 },
309})
310β
311createFormHook({
312 fieldComponents: {},
313 formComponents: {},
314 defaultFormGroupOptions: {
315 // @ts-expect-error onSubmit must remain local to a form group
316 onSubmit: () => {},
317 },
318})