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