Open History to see the last commit
1import { describe, expect, it, vi } from 'vitest'
2import { render } from 'vitest-browser-react'
3import { userEvent } from 'vitest/browser'
4import React, { useEffect, useState } from 'react'
5import { useForm } from '../src'
6import type { AnyInternalFormApi } from '@tanstack/form-core/internals'
7β
8describe('Form fields', () => {
9 it('should mount the field to the dom', async () => {
10 function Component() {
11 const form = useForm({ defaultValues: { name: 'tony-hawk' } })
12 return (
13 <form.Field name="name">
14 {(field) => <span data-testid="name">{field.value}</span>}
15 </form.Field>
16 )
17 }
18β
19 const screen = await render(<Component />)
20 const input = screen.getByTestId('name')
21β
22 expect(input).toHaveTextContent('tony-hawk')
23 })
24β
25 it('does not re-register fields during unrelated parent rerenders', async () => {
26 const onMount = vi.fn()
27 const onUnmount = vi.fn()
28β
29 function Component() {
30 const [count, setCount] = useState(0)
31 const form = useForm({ defaultValues: { name: 'tony-hawk' } })
32β
33 return (
34 <>
35 <button onClick={() => setCount(count + 1)}>Rerender {count}</button>
36 <form.Field
37 name="name"
38 listeners={[
39 { triggers: ['mount'], run: onMount },
40 { triggers: ['unmount'], run: onUnmount },
41 ]}
42 >
43 {(field) => <span data-testid="name">{field.value}</span>}
44 </form.Field>
45 </>
46 )
47 }
48β
49 const screen = await render(<Component />)
50β
51 expect(screen.getByTestId('name')).toHaveTextContent('tony-hawk')
52 expect(onMount.mock.calls.length - onUnmount.mock.calls.length).toBe(1)
53β
54 const initialMountCount = onMount.mock.calls.length
55 const initialUnmountCount = onUnmount.mock.calls.length
56β
57 const rerender = screen.getByRole('button', { name: /Rerender/ })
58 await rerender.click()
59β
60 expect(rerender).toHaveTextContent('Rerender 1')
61 expect(onMount).toHaveBeenCalledTimes(initialMountCount)
62 expect(onUnmount).toHaveBeenCalledTimes(initialUnmountCount)
63β
64 await screen.unmount()
65β
66 expect(onMount.mock.calls.length - onUnmount.mock.calls.length).toBe(0)
67 expect(onUnmount).toHaveBeenCalledTimes(initialUnmountCount + 1)
68 })
69β
70 it('should have the correct name and value', async () => {
71 function Component() {
72 const form = useForm({ defaultValues: { name: 'tony-hawk' } })
73 return (
74 <form.Field name="name">
75 {(field) => (
76 <>
77 <label htmlFor={field.name}>
78 {field.name}
79 <input
80 id={field.name}
81 value={field.value}
82 onChange={(e) => field.handleChange(e.target.value)}
83 />
84 </label>
85 </>
86 )}
87 </form.Field>
88 )
89 }
90β
91 const screen = await render(<Component />)
92 const input = screen.getByLabelText('name')
93 expect(input).toBeInTheDocument()
94 expect(input).toHaveValue('tony-hawk')
95β
96 await input.clear()
97 await userEvent.type(input, 'new-value')
98 expect(input).toHaveValue('new-value')
99 })
100β
101 it('rerenders an ArrayField for a same-length replacement', async () => {
102 let renders = 0
103β
104 function Component() {
105 const form = useForm({
106 defaultValues: { items: [{ label: 'A' }] },
107 })
108β
109 return (
110 <>
111 <button onClick={() => form.setFieldValue('items', [{ label: 'B' }])}>
112 Replace array
113 </button>
114 <button onClick={() => form.setFieldValue('items[0].label', 'C')}>
115 Update child
116 </button>
117 <form.ArrayField name="items">
118 {(field) => {
119 renders++
120 return (
121 <output data-testid="array">{field.value[0]!.label}</output>
122 )
123 }}
124 </form.ArrayField>
125 </>
126 )
127 }
128β
129 const screen = await render(<Component />)
130 const initialRenders = renders
131β
132 await screen.getByRole('button', { name: 'Replace array' }).click()
133β
134 expect(screen.getByTestId('array')).toHaveTextContent('B')
135 expect(renders).toBeGreaterThan(initialRenders)
136β
137 const replacementRenders = renders
138β
139 await screen.getByRole('button', { name: 'Update child' }).click()
140β
141 expect(renders).toBe(replacementRenders)
142 })
143β
144 it('should have the correct meta when changing the field', async () => {
145 function Component() {
146 const form = useForm({ defaultValues: { name: 'tony-hawk' } })
147 return (
148 <form.Field name="name">
149 {(field) => (
150 <>
151 <label htmlFor={field.name}>
152 {field.name}
153 <input
154 id={field.name}
155 value={field.value}
156 onChange={(e) => field.handleChange(e.target.value)}
157 />
158 </label>
159 <input
160 type="checkbox"
161 data-testid="isTouched"
162 readOnly
163 checked={field.meta.isTouched}
164 />
165 <input
166 type="checkbox"
167 data-testid="isDirty"
168 readOnly
169 checked={field.meta.isDirty}
170 />
171 </>
172 )}
173 </form.Field>
174 )
175 }
176β
177 const screen = await render(<Component />)
178 const input = screen.getByLabelText('name')
179 const isTouchedCheckbox = screen.getByTestId('isTouched')
180 const isDirtyCheckbox = screen.getByTestId('isDirty')
181β
182 expect(isTouchedCheckbox).not.toBeChecked()
183 expect(isDirtyCheckbox).not.toBeChecked()
184 await userEvent.type(input, 'foo')
185 expect(isTouchedCheckbox).toBeChecked()
186 expect(isDirtyCheckbox).toBeChecked()
187 })
188β
189 it('should update isDefaultValue when changing back to the default value', async () => {
190 function Component() {
191 const form = useForm({ defaultValues: { name: 'tony-hawk' } })
192 return (
193 <form.Field name="name">
194 {(field) => (
195 <>
196 <label htmlFor={field.name}>
197 {field.name}
198 <input
199 id={field.name}
200 value={field.value}
201 onChange={(e) => field.handleChange(e.target.value)}
202 />
203 </label>
204 <span data-testid="isDefaultValue">
205 {String(field.meta.isDefaultValue)}
206 </span>
207 <span data-testid="isDirty">{String(field.meta.isDirty)}</span>
208 </>
209 )}
210 </form.Field>
211 )
212 }
213β
214 const screen = await render(<Component />)
215 const input = screen.getByLabelText('name')
216β
217 expect(screen.getByTestId('isDefaultValue')).toHaveTextContent('true')
218 await input.clear()
219 await userEvent.type(input, 'rodney-mullen')
220 expect(screen.getByTestId('isDefaultValue')).toHaveTextContent('false')
221β
222 await input.clear()
223 await userEvent.type(input, 'tony-hawk')
224 expect(screen.getByTestId('isDefaultValue')).toHaveTextContent('true')
225 expect(screen.getByTestId('isDirty')).toHaveTextContent('true')
226 })
227β
228 it('does not rerender unchanged field render props when another field changes', async () => {
229 const renderCounts = {
230 first: 0,
231 middle: 0,
232 last: 0,
233 }
234β
235 function Component() {
236 const form = useForm({
237 defaultValues: {
238 first: 'first',
239 middle: 'middle',
240 last: 'last',
241 },
242 })
243β
244 return (
245 <>
246 <form.Field name="first">
247 {(field) => {
248 renderCounts.first++
249 return (
250 <label htmlFor={field.name}>
251 {field.name}
252 <input
253 id={field.name}
254 value={field.value}
255 onChange={(event) => field.handleChange(event.target.value)}
256 />
257 </label>
258 )
259 }}
260 </form.Field>
261 <form.Field name="middle">
262 {(field) => {
263 renderCounts.middle++
264 return (
265 <label htmlFor={field.name}>
266 {field.name}
267 <input
268 id={field.name}
269 value={field.value}
270 onChange={(event) => field.handleChange(event.target.value)}
271 />
272 </label>
273 )
274 }}
275 </form.Field>
276 <form.Field name="last">
277 {(field) => {
278 renderCounts.last++
279 return (
280 <label htmlFor={field.name}>
281 {field.name}
282 <input
283 id={field.name}
284 value={field.value}
285 onChange={(event) => field.handleChange(event.target.value)}
286 />
287 </label>
288 )
289 }}
290 </form.Field>
291 </>
292 )
293 }
294β
295 const screen = await render(<Component />)
296 const initialCounts = { ...renderCounts }
297 const middleInput = screen.getByLabelText('middle')
298β
299 await middleInput.fill('updated')
300β
301 expect(middleInput).toHaveValue('updated')
302 expect(renderCounts.first).toBe(initialCounts.first)
303 expect(renderCounts.last).toBe(initialCounts.last)
304 expect(renderCounts.middle).toBeGreaterThan(initialCounts.middle)
305 })
306β
307 it('rerenders a field when its meta changes without changing its value', async () => {
308 const renderCounts = {
309 first: 0,
310 last: 0,
311 }
312β
313 function Component() {
314 const form = useForm({
315 defaultValues: {
316 first: 'first',
317 last: 'last',
318 },
319 })
320β
321 return (
322 <>
323 <form.Field name="first">
324 {(field) => {
325 renderCounts.first++
326 return (
327 <>
328 <label htmlFor={field.name}>
329 {field.name}
330 <input
331 id={field.name}
332 value={field.value}
333 onBlur={field.handleBlur}
334 onChange={(event) =>
335 field.handleChange(event.target.value)
336 }
337 />
338 </label>
339 <span data-testid="first-blurred">
340 {String(field.meta.isBlurred)}
341 </span>
342 </>
343 )
344 }}
345 </form.Field>
346 <form.Field name="last">
347 {(field) => {
348 renderCounts.last++
349 return (
350 <label htmlFor={field.name}>
351 {field.name}
352 <input
353 id={field.name}
354 value={field.value}
355 onChange={(event) => field.handleChange(event.target.value)}
356 />
357 </label>
358 )
359 }}
360 </form.Field>
361 </>
362 )
363 }
364β
365 const screen = await render(<Component />)
366 const initialCounts = { ...renderCounts }
367β
368 const firstInput = screen.getByLabelText('first')
369 await firstInput.click()
370 firstInput.element().blur()
371β
372 await expect
373 .element(screen.getByTestId('first-blurred'))
374 .toHaveTextContent('true')
375 expect(renderCounts.first).toBeGreaterThan(initialCounts.first)
376 expect(renderCounts.last).toBe(initialCounts.last)
377 })
378β
379 it('should recreate mounted fields after form reset', async () => {
380 function Component() {
381 const form = useForm({ defaultValues: { name: 'tony-hawk' } })
382 return (
383 <>
384 <form.Field name="name">
385 {(field) => (
386 <label htmlFor={field.name}>
387 {field.name}
388 <input
389 id={field.name}
390 value={field.value}
391 onChange={(e) => field.handleChange(e.target.value)}
392 />
393 </label>
394 )}
395 </form.Field>
396 <button onClick={() => form.reset()} data-testid="reset">
397 Reset
398 </button>
399 </>
400 )
401 }
402β
403 const screen = await render(<Component />)
404 const input = screen.getByLabelText('name')
405β
406 await input.clear()
407 await userEvent.type(input, 'before-reset')
408 expect(input).toHaveValue('before-reset')
409β
410 await screen.getByTestId('reset').click()
411 expect(input).toHaveValue('tony-hawk')
412β
413 await input.clear()
414 await userEvent.type(input, 'after-reset')
415 expect(input).toHaveValue('after-reset')
416 })
417β
418 it('should remove unused field nodes', async () => {
419 const formApi = { current: null as AnyInternalFormApi | null }
420β
421 function Component() {
422 const [show, setShow] = useState(true)
423 const form = useForm({ defaultValues: { foo: { bar: 'Value' } } })
424β
425 useEffect(() => {
426 formApi.current = form as never
427 })
428β
429 return (
430 <>
431 {show && (
432 <form.Field name="foo.bar">
433 {({ value }) => <span data-testid="field">{value}</span>}
434 </form.Field>
435 )}
436 <button onClick={() => setShow(false)} data-testid="off">
437 Turn off
438 </button>
439 </>
440 )
441 }
442β
443 const screen = await render(<Component />)
444 const field = screen.getByTestId('field')
445β
446 expect(field).toBeInTheDocument()
447 // Field exists before unmount
448 expect(formApi.current?._tryGetFieldApi('foo.bar')).not.toBeNull()
449β
450 await screen.getByTestId('off').click()
451β
452 await expect.element(field).not.toBeInTheDocument()
453 await vi.waitFor(
454 () => {
455 expect(formApi.current?._tryGetFieldApi('foo.bar')).toBeNull()
456 },
457 { interval: 50, timeout: 500 },
458 )
459 })
460})