Skip to content
Source
Sign inSign up
TanStack/form
Open History to see the last commit

createFormHook.spec.tsx

496 lines14.2 KB

1import React from 'react'
2import { render } from 'vitest-browser-react'
3import { describe, expect, it, vi } from 'vitest'
4import { createFormHook, getFormHookHelpers } from '../src'
5import type {
6 AnyInternalFieldApi,
7 AnyInternalFormApi,
8} from '@tanstack/form-core/internals'
9import type { FieldWithValue } from '../src'
10​
11describe('createFormHook', () => {
12 it('provides registered components to fields created during mount validation', async () => {
13 const SharedComponent = () => <span>Shared field component</span>
14 const { useAppForm } = createFormHook({
15 fieldComponents: { SharedComponent },
16 formComponents: {},
17 })
18​
19 function Component() {
20 const form = useAppForm({
21 defaultValues: { name: '' },
22 validators: [
23 {
24 runOnMount: true,
25 triggers: [],
26 run: () => ({ fields: { name: 'Name is required' } }),
27 },
28 ],
29 })
30​
31 return (
32 <form.Field name="name">
33 {(field) => {
34 const { SharedComponent: DestructuredComponent } = field
35 return <DestructuredComponent />
36 }}
37 </form.Field>
38 )
39 }
40​
41 const { getByText } = await render(<Component />)
42​
43 expect(getByText('Shared field component')).toBeInTheDocument()
44 })
45​
46 it('provides field context to field components inside an ArrayField', async () => {
47 let renders = 0
48​
49 function ItemCount({ field }: { field: FieldWithValue<Array<string>> }) {
50 return <span>Items: {field.value.length}</span>
51 }
52​
53 const { fieldComponent } = getFormHookHelpers()
54 const { useAppForm } = createFormHook({
55 fieldComponents: { ItemCount: fieldComponent.strict(ItemCount, 'field') },
56 formComponents: {},
57 })
58​
59 function Component() {
60 const form = useAppForm({
61 defaultValues: { tags: ['a', 'b'], group: { tags: ['c'] } },
62 })
63​
64 return (
65 <>
66 <form.ArrayField name="tags">
67 {(field) => {
68 renders++
69 return (
70 <>
71 <field.ItemCount />
72 <button type="button" onClick={() => field.pushValue('c')}>
73 Add
74 </button>
75 </>
76 )
77 }}
78 </form.ArrayField>
79 <form.FormGroup name="group">
80 {(group) => (
81 <group.ArrayField name="tags">
82 {(field) => {
83 renders++
84 return <field.ItemCount />
85 }}
86 </group.ArrayField>
87 )}
88 </form.FormGroup>
89 <button
90 type="button"
91 onClick={() => {
92 form.setFieldValue('tags[0]', 'z')
93 form.setFieldValue('group.tags[0]', 'z')
94 }}
95 >
96 Update first
97 </button>
98 </>
99 )
100 }
101​
102 const { getByText } = await render(<Component />)
103​
104 expect(getByText('Items: 2')).toBeInTheDocument()
105 expect(getByText('Items: 1')).toBeInTheDocument()
106 await getByText('Add').click()
107 expect(getByText('Items: 3')).toBeInTheDocument()
108​
109 const pushRenders = renders
110 await getByText('Update first').click()
111 expect(renders).toBe(pushRenders)
112 })
113​
114 it('supports nested field and form component trees', async () => {
115 function FieldValue({ field }: { field: FieldWithValue<string> }) {
116 return <span>Field value: {field.value}</span>
117 }
118​
119 function FormHeading() {
120 return <h1>Nested form component</h1>
121 }
122​
123 const { fieldComponent } = getFormHookHelpers()
124 const FieldValueWithContext = fieldComponent.strict(FieldValue, 'field')
125 const { useAppForm } = createFormHook({
126 fieldComponents: {
127 display: {
128 values: {
129 FieldValue: FieldValueWithContext,
130 },
131 },
132 },
133 formComponents: {
134 layout: {
135 headings: {
136 FormHeading,
137 },
138 },
139 },
140 })
141​
142 function Component() {
143 const form = useAppForm({ defaultValues: { name: 'Tony' } })
144​
145 return (
146 <form.AppForm>
147 <form.layout.headings.FormHeading />
148 <form.Field name="name">
149 {(field) => <field.display.values.FieldValue />}
150 </form.Field>
151 </form.AppForm>
152 )
153 }
154​
155 const { getByText } = await render(<Component />)
156​
157 expect(getByText('Nested form component')).toBeInTheDocument()
158 expect(getByText('Field value: Tony')).toBeInTheDocument()
159 })
160​
161 it('supports destructuring registered form components', async () => {
162 const SharedComponent = () => <span>Shared component</span>
163 const { useAppForm } = createFormHook({
164 fieldComponents: {},
165 formComponents: { SharedComponent },
166 })
167​
168 /* eslint-disable @eslint-react/static-components -- False positive, component's created once */
169 function Component() {
170 const form = useAppForm({ defaultValues: { name: '' } })
171 const { SharedComponent: DestructuredComponent } = form
172​
173 return <DestructuredComponent />
174 }
175 /* eslint-enable @eslint-react/static-components */
176​
177 const { getByText } = await render(<Component />)
178​
179 expect(getByText('Shared component')).toBeInTheDocument()
180 })
181​
182 it('renders inherited form components with per-instance AppForm context', async () => {
183 function CurrentName() {
184 const form = useFormContext()
185 return <span data-testid="current-name">{form.state.values.name}</span>
186 }
187​
188 const { useAppForm, useFormContext } = createFormHook({
189 fieldComponents: {},
190 formComponents: { CurrentName },
191 })
192​
193 function Component() {
194 const form = useAppForm({ defaultValues: { name: 'Tony' } })
195​
196 return (
197 <form.AppForm>
198 <form.CurrentName />
199 </form.AppForm>
200 )
201 }
202​
203 const { getByTestId } = await render(<Component />)
204​
205 expect(getByTestId('current-name')).toHaveTextContent('Tony')
206 })
207​
208 it('uses default form options and lets usage options override them', async () => {
209 const defaultErrorVisibility = () => true
210 const overriddenErrorVisibility = () => false
211 const { useAppForm } = createFormHook({
212 fieldComponents: {},
213 formComponents: {},
214 defaultFormOptions: {
215 errorVisibility: defaultErrorVisibility,
216 },
217 })
218​
219 const getErrorVisibility = (form: unknown) =>
220 (form as AnyInternalFormApi)._options.errorVisibility
221​
222 function DefaultForm() {
223 const form = useAppForm({ defaultValues: { name: '' } })
224 return (
225 <span data-testid="default">
226 {String(getErrorVisibility(form) === defaultErrorVisibility)}
227 </span>
228 )
229 }
230​
231 function OverriddenForm() {
232 const form = useAppForm({
233 defaultValues: { name: '' },
234 errorVisibility: overriddenErrorVisibility,
235 })
236 return (
237 <span data-testid="overridden">
238 {String(getErrorVisibility(form) === overriddenErrorVisibility)}
239 </span>
240 )
241 }
242​
243 function UndefinedForm() {
244 const form = useAppForm({
245 defaultValues: { name: '' },
246 errorVisibility: undefined,
247 })
248 return (
249 <span data-testid="undefined">
250 {String(getErrorVisibility(form) === undefined)}
251 </span>
252 )
253 }
254​
255 const { getByTestId } = await render(
256 <>
257 <DefaultForm />
258 <OverriddenForm />
259 <UndefinedForm />
260 </>,
261 )
262​
263 expect(getByTestId('default')).toHaveTextContent('true')
264 expect(getByTestId('overridden')).toHaveTextContent('true')
265 expect(getByTestId('undefined')).toHaveTextContent('true')
266 })
267​
268 it('resolves form and field listener merge modes in core', async () => {
269 const formCalls: Array<string> = []
270 const fieldCalls: Array<string> = []
271 const { useAppForm } = createFormHook({
272 fieldComponents: {},
273 formComponents: {},
274 defaultFormOptions: {
275 listenersMerge: 'append',
276 listeners: [
277 {
278 triggers: ['change'],
279 run: () => formCalls.push('default'),
280 },
281 ],
282 },
283 defaultFieldOptions: {
284 listenersMerge: 'prepend',
285 listeners: [
286 {
287 triggers: ['change'],
288 run: () => fieldCalls.push('default'),
289 },
290 ],
291 },
292 })
293​
294 function Component() {
295 const form = useAppForm({
296 defaultValues: { name: '' },
297 listeners: [
298 {
299 triggers: ['change'],
300 run: () => formCalls.push('local'),
301 },
302 ],
303 })
304​
305 return (
306 <form.Field
307 name="name"
308 listeners={[
309 {
310 triggers: ['change'],
311 run: () => fieldCalls.push('local'),
312 },
313 ]}
314 >
315 {(field) => (
316 <input
317 aria-label="Name"
318 value={field.value}
319 onChange={(event) => field.handleChange(event.target.value)}
320 />
321 )}
322 </form.Field>
323 )
324 }
325​
326 const { getByRole } = await render(<Component />)
327 await getByRole('textbox', { name: 'Name' }).fill('updated')
328​
329 expect(formCalls).toEqual(['default', 'local'])
330 expect(fieldCalls).toEqual(['local', 'default'])
331 })
332​
333 it('applies field defaults to direct and grouped fields', async () => {
334 const { useAppForm } = createFormHook({
335 fieldComponents: {},
336 formComponents: {},
337 defaultFieldOptions: {
338 errorBoundary: true,
339 },
340 })
341​
342 const getErrorBoundary = (field: unknown) =>
343 String((field as AnyInternalFieldApi)._errorBoundary)
344​
345 function Component() {
346 const form = useAppForm({
347 defaultValues: {
348 direct: '',
349 directArray: [''],
350 overridden: '',
351 undefinedOverride: '',
352 group: {
353 field: '',
354 array: [''],
355 },
356 },
357 })
358​
359 return (
360 <>
361 <form.Field name="direct">
362 {(field) => (
363 <span data-testid="direct">{getErrorBoundary(field)}</span>
364 )}
365 </form.Field>
366 <form.ArrayField name="directArray">
367 {(field) => (
368 <span data-testid="direct-array">{getErrorBoundary(field)}</span>
369 )}
370 </form.ArrayField>
371 <form.Field name="overridden" errorBoundary={false}>
372 {(field) => (
373 <span data-testid="overridden">{getErrorBoundary(field)}</span>
374 )}
375 </form.Field>
376 <form.Field name="undefinedOverride" errorBoundary={undefined}>
377 {(field) => (
378 <span data-testid="undefined">{getErrorBoundary(field)}</span>
379 )}
380 </form.Field>
381 <form.FormGroup name="group">
382 {(group) => (
383 <>
384 <group.Field name="field">
385 {(field) => (
386 <span data-testid="group-field">
387 {getErrorBoundary(field)}
388 </span>
389 )}
390 </group.Field>
391 <group.ArrayField name="array">
392 {(field) => (
393 <span data-testid="group-array">
394 {getErrorBoundary(field)}
395 </span>
396 )}
397 </group.ArrayField>
398 </>
399 )}
400 </form.FormGroup>
401 </>
402 )
403 }
404​
405 const { getByTestId } = await render(<Component />)
406​
407 expect(getByTestId('direct')).toHaveTextContent('true')
408 expect(getByTestId('direct-array')).toHaveTextContent('true')
409 expect(getByTestId('overridden')).toHaveTextContent('false')
410 expect(getByTestId('undefined')).toHaveTextContent('false')
411 expect(getByTestId('group-field')).toHaveTextContent('true')
412 expect(getByTestId('group-array')).toHaveTextContent('true')
413 })
414​
415 it('uses default form group options and permits all override forms', async () => {
416 const defaultOnSubmitInvalid = vi.fn()
417 const overriddenOnSubmitInvalid = vi.fn()
418 const defaultValidator = vi.fn(() => 'invalid')
419 const overriddenValidator = vi.fn(() => 'invalid')
420 const undefinedValidator = vi.fn(() => 'invalid')
421 const { useAppForm } = createFormHook({
422 fieldComponents: {},
423 formComponents: {},
424 defaultFormGroupOptions: {
425 onSubmitInvalid: defaultOnSubmitInvalid,
426 },
427 })
428​
429 function Component() {
430 const form = useAppForm({
431 defaultValues: {
432 defaultGroup: { name: '' },
433 overriddenGroup: { name: '' },
434 undefinedGroup: { name: '' },
435 },
436 })
437​
438 return (
439 <>
440 <form.FormGroup
441 name="defaultGroup"
442 validators={[{ triggers: [], run: defaultValidator }]}
443 >
444 {(group) => (
445 <button onClick={() => void group.handleSubmit()}>
446 Submit default group
447 </button>
448 )}
449 </form.FormGroup>
450 <form.FormGroup
451 name="overriddenGroup"
452 validators={[{ triggers: [], run: overriddenValidator }]}
453 onSubmitInvalid={overriddenOnSubmitInvalid}
454 >
455 {(group) => (
456 <button onClick={() => void group.handleSubmit()}>
457 Submit overridden group
458 </button>
459 )}
460 </form.FormGroup>
461 <form.FormGroup
462 name="undefinedGroup"
463 validators={[{ triggers: [], run: undefinedValidator }]}
464 onSubmitInvalid={undefined}
465 >
466 {(group) => (
467 <button onClick={() => void group.handleSubmit()}>
468 Submit undefined group
469 </button>
470 )}
471 </form.FormGroup>
472 </>
473 )
474 }
475​
476 const { getByRole } = await render(<Component />)
477​
478 await getByRole('button', { name: 'Submit default group' }).click()
479 await vi.waitFor(() =>
480 expect(defaultOnSubmitInvalid).toHaveBeenCalledOnce(),
481 )
482​
483 await getByRole('button', { name: 'Submit overridden group' }).click()
484 await vi.waitFor(() =>
485 expect(overriddenOnSubmitInvalid).toHaveBeenCalledOnce(),
486 )
487 expect(defaultOnSubmitInvalid).toHaveBeenCalledOnce()
488​
489 await getByRole('button', { name: 'Submit undefined group' }).click()
490 await vi.waitFor(() => {
491 expect(undefinedValidator).toHaveBeenCalledOnce()
492 expect(defaultOnSubmitInvalid).toHaveBeenCalledOnce()
493 expect(overriddenOnSubmitInvalid).toHaveBeenCalledOnce()
494 })
495 })
496})