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 from 'react'
5import { defineFieldGroup, useForm, useSelector } from '../src'
6β
7const { fields: nestedFields, bindComponent: bindNestedFields } =
8 defineFieldGroup(({ strict }) => ({
9 foo: strict<{ bar: string }>(),
10 }))
11β
12interface NestedFieldsProps {
13 fields: typeof nestedFields
14}
15β
16function NestedFieldsImpl({ fields }: NestedFieldsProps) {
17 return (
18 <>
19 <fields.Field name="foo.bar">
20 {(field) => (
21 <span data-testid="field">
22 {field.name}:{field.value}
23 </span>
24 )}
25 </fields.Field>
26 <button
27 type="button"
28 onClick={() => fields.setFieldValue('foo.bar', 'Updated')}
29 >
30 Update
31 </button>
32 </>
33 )
34}
35β
36const NestedFields = bindNestedFields(NestedFieldsImpl, 'fields')
37β
38const { fields: passwordFields, bindComponent: bindPasswordFields } =
39 defineFieldGroup(({ strict }) => ({
40 password: strict<string>(),
41 confirmPassword: strict<string>(),
42 }))
43β
44interface PasswordFieldsProps {
45 fields: typeof passwordFields
46 listener: () => void
47}
48β
49function PasswordFieldsImpl({ fields, listener }: PasswordFieldsProps) {
50 return (
51 <>
52 <fields.Field name="password">
53 {(field) => (
54 <input
55 aria-label="Password"
56 value={field.value}
57 onChange={(event) => field.handleChange(event.target.value)}
58 />
59 )}
60 </fields.Field>
61 <fields.Field
62 name="confirmPassword"
63 listeners={[
64 {
65 triggers: ['change'],
66 watchFields: ['password'],
67 run: listener,
68 },
69 ]}
70 >
71 {() => null}
72 </fields.Field>
73 </>
74 )
75}
76β
77const PasswordFields = bindPasswordFields(PasswordFieldsImpl, 'fields')
78β
79const { fields: rangeFields, bindComponent: bindRangeFields } =
80 defineFieldGroup(({ strict }) => ({
81 lower: strict<string>(),
82 upper: strict<string>(),
83 }))
84β
85interface RangeFieldsProps {
86 fields: typeof rangeFields
87 onRender: {
88 lower: React.ProfilerOnRenderCallback
89 upper: React.ProfilerOnRenderCallback
90 }
91}
92β
93function RangeFieldsImpl({ fields, onRender }: RangeFieldsProps) {
94 return (
95 <>
96 <fields.Field name="lower">
97 {(field) => (
98 <React.Profiler id="lower" onRender={onRender.lower}>
99 <input
100 aria-label="Lower"
101 value={field.value}
102 onChange={(event) => field.handleChange(event.target.value)}
103 />
104 </React.Profiler>
105 )}
106 </fields.Field>
107 <fields.Field name="upper">
108 {(field) => (
109 <React.Profiler id="upper" onRender={onRender.upper}>
110 <input
111 aria-label="Upper"
112 value={field.value}
113 onChange={(event) => field.handleChange(event.target.value)}
114 />
115 </React.Profiler>
116 )}
117 </fields.Field>
118 </>
119 )
120}
121β
122const RangeFields = bindRangeFields(RangeFieldsImpl, 'fields')
123β
124interface RangeValuesFieldsProps {
125 fields: typeof rangeFields
126}
127β
128function RangeValuesFieldsImpl({ fields }: RangeValuesFieldsProps) {
129 const values = useSelector(fields.atom)
130β
131 return (
132 <>
133 <span data-testid="values">
134 {values.lower}:{values.upper}
135 </span>
136 <fields.Field name="lower">
137 {(field) => (
138 <input
139 aria-label="Lower"
140 value={field.value}
141 onChange={(event) => field.handleChange(event.target.value)}
142 />
143 )}
144 </fields.Field>
145 <fields.Field name="upper">
146 {(field) => (
147 <input
148 aria-label="Upper"
149 value={field.value}
150 onChange={(event) => field.handleChange(event.target.value)}
151 />
152 )}
153 </fields.Field>
154 </>
155 )
156}
157β
158const RangeValuesFields = bindRangeFields(RangeValuesFieldsImpl, 'fields')
159β
160const { fields: memoizedInputFields, bindComponent: bindMemoizedInputFields } =
161 defineFieldGroup(({ strict }) => ({
162 value: strict<string>(),
163 }))
164β
165interface MemoizedInputProps {
166 field: {
167 value: string
168 handleChange: (value: string) => void
169 }
170}
171β
172const MemoizedInput = React.memo(function MemoizedInput({
173 field,
174}: MemoizedInputProps) {
175 return (
176 <input
177 aria-label="Memoized"
178 value={field.value}
179 onChange={(event) => field.handleChange(event.target.value)}
180 />
181 )
182})
183β
184interface MemoizedInputFieldsProps {
185 fields: typeof memoizedInputFields
186 onRender: React.ProfilerOnRenderCallback
187}
188β
189function MemoizedInputFieldsImpl({
190 fields,
191 onRender,
192}: MemoizedInputFieldsProps) {
193 return (
194 <fields.Field name="value">
195 {(field) => (
196 <React.Profiler id="memoized-input" onRender={onRender}>
197 <MemoizedInput field={field} />
198 </React.Profiler>
199 )}
200 </fields.Field>
201 )
202}
203β
204const MemoizedInputFields = bindMemoizedInputFields(
205 MemoizedInputFieldsImpl,
206 'fields',
207)
208β
209describe('FieldGroup', () => {
210 it('defaults omitted bindings to same-named form fields', async () => {
211 function Component() {
212 const form = useForm({
213 defaultValues: {
214 foo: {
215 bar: 'Initial',
216 },
217 },
218 })
219β
220 return <NestedFields form={form} />
221 }
222β
223 const { getByRole, getByTestId } = await render(<Component />)
224β
225 expect(getByTestId('field')).toHaveTextContent('foo.bar:Initial')
226β
227 await getByRole('button', { name: 'Update' }).click()
228β
229 expect(getByTestId('field')).toHaveTextContent('foo.bar:Updated')
230 })
231β
232 it('resolves nested logical field names and forwards field methods', async () => {
233 function Component() {
234 const form = useForm({
235 defaultValues: {
236 foo: {
237 bar: 'Identity',
238 },
239 anything: {
240 bar: 'Initial',
241 },
242 },
243 })
244β
245 return <NestedFields form={form} fields={{ foo: 'anything' }} />
246 }
247β
248 const { getByRole, getByTestId } = await render(<Component />)
249β
250 expect(getByTestId('field')).toHaveTextContent('anything.bar:Initial')
251β
252 await getByRole('button', { name: 'Update' }).click()
253β
254 expect(getByTestId('field')).toHaveTextContent('anything.bar:Updated')
255 })
256β
257 it('updates logical field bindings when props change', async () => {
258 function Component() {
259 const [binding, setBinding] = React.useState<'first' | 'second'>('first')
260 const form = useForm({
261 defaultValues: {
262 first: { bar: 'One' },
263 second: { bar: 'Two' },
264 },
265 })
266β
267 return (
268 <>
269 <NestedFields form={form} fields={{ foo: binding }} />
270 <button type="button" onClick={() => setBinding('second')}>
271 Show second
272 </button>
273 </>
274 )
275 }
276β
277 const { getByRole, getByTestId } = await render(<Component />)
278 expect(getByTestId('field')).toHaveTextContent('first.bar:One')
279β
280 await getByRole('button', { name: 'Show second' }).click()
281β
282 expect(getByTestId('field')).toHaveTextContent('second.bar:Two')
283 })
284β
285 it('exposes subscribed field meta from field group children', async () => {
286 const MetaFields = bindNestedFields(
287 ({ fields }: NestedFieldsProps) => (
288 <fields.Field name="foo.bar">
289 {(field) => (
290 <span data-testid="meta">{String(field.meta.isValidating)}</span>
291 )}
292 </fields.Field>
293 ),
294 'fields',
295 )
296β
297 function Component() {
298 const form = useForm({
299 defaultValues: {
300 anything: {
301 bar: 'Initial',
302 },
303 },
304 })
305β
306 return <MetaFields form={form} fields={{ foo: 'anything' }} />
307 }
308β
309 const { getByTestId } = await render(<Component />)
310β
311 expect(getByTestId('meta')).toHaveTextContent('false')
312 })
313β
314 it('resolves watched field names for listeners', async () => {
315 const listener = vi.fn()
316β
317 function Component() {
318 const form = useForm({
319 defaultValues: {
320 account: {
321 password: '',
322 confirmPassword: '',
323 },
324 },
325 })
326β
327 return (
328 <PasswordFields
329 form={form}
330 fields={{
331 password: 'account.password',
332 confirmPassword: 'account.confirmPassword',
333 }}
334 listener={listener}
335 />
336 )
337 }
338β
339 const { getByLabelText } = await render(<Component />)
340β
341 await userEvent.type(getByLabelText('Password'), 'a')
342β
343 expect(listener).toHaveBeenCalledOnce()
344 })
345β
346 it('updates extracted memoized field components when field values change', async () => {
347 const onRender = vi.fn()
348β
349 function Component() {
350 const form = useForm({
351 defaultValues: {
352 value: '',
353 },
354 })
355β
356 return <MemoizedInputFields form={form} onRender={onRender} />
357 }
358β
359 const { getByLabelText } = await render(<Component />)
360 const input = getByLabelText('Memoized')
361β
362 await userEvent.type(input, 'abc')
363β
364 expect(input).toHaveValue('abc')
365 expect(onRender).toHaveBeenCalledTimes(4)
366 })
367β
368 it('does not rerender unrelated sibling fields when one field changes', async () => {
369 const onRender = {
370 lower: vi.fn(),
371 upper: vi.fn(),
372 }
373β
374 function Component() {
375 const form = useForm({
376 defaultValues: {
377 min: '',
378 max: '',
379 },
380 })
381β
382 return (
383 <RangeFields
384 form={form}
385 fields={{
386 lower: 'min',
387 upper: 'max',
388 }}
389 onRender={onRender}
390 />
391 )
392 }
393β
394 const { getByLabelText } = await render(<Component />)
395 const initialUpperRenderCount = onRender.upper.mock.calls.length
396β
397 await userEvent.type(getByLabelText('Lower'), '12')
398β
399 expect(getByLabelText('Lower')).toHaveValue('12')
400 expect(onRender.lower).toHaveBeenCalledTimes(3)
401 expect(onRender.upper).toHaveBeenCalledTimes(initialUpperRenderCount)
402 })
403β
404 it('exposes bound field values through a group-level atom', async () => {
405 function Component() {
406 const form = useForm({
407 defaultValues: {
408 min: '1',
409 max: '5',
410 },
411 })
412β
413 return (
414 <RangeValuesFields
415 form={form}
416 fields={{
417 lower: 'min',
418 upper: 'max',
419 }}
420 />
421 )
422 }
423β
424 const { getByLabelText, getByTestId } = await render(<Component />)
425β
426 expect(getByTestId('values')).toHaveTextContent('1:5')
427β
428 await userEvent.type(getByLabelText('Lower'), '2')
429β
430 expect(getByTestId('values')).toHaveTextContent('12:5')
431 })
432})