Open History to see the last commit
1import { createRenderEffect, createSignal } from 'solid-js'
2import { render } from 'solid-js/web'
3import { describe, expect, it, vi } from 'vitest'
4import {
5 createForm,
6 createFormHook,
7 defineFieldGroup,
8 getFormHookHelpers,
9 useSelector,
10} from '../src'
11import type { Accessor, JSX } from 'solid-js'
12import type { FieldWithValue } from '../src'
13β
14function mount(Component: () => JSX.Element) {
15 const container = document.createElement('div')
16 document.body.append(container)
17 const disposeRoot = render(Component, container)
18 return {
19 container,
20 dispose: () => {
21 disposeRoot()
22 container.remove()
23 },
24 }
25}
26β
27describe('Solid adapter parity', () => {
28 it('prefixes form group fields and keeps group state reactive', () => {
29 let change!: (value: string) => void
30β
31 function Component() {
32 const form = createForm(() => ({
33 defaultValues: { guest: { name: 'Tony' } },
34 }))
35β
36 return (
37 <form.FormGroup name="guest">
38 {(group) => (
39 <>
40 <group.Field name="name">
41 {(field) => {
42 change = field().handleChange
43 return (
44 <span data-testid="field">
45 {field().name}:{field().value}
46 </span>
47 )
48 }}
49 </group.Field>
50 <span data-testid="group-value">{group().state.values.name}</span>
51 </>
52 )}
53 </form.FormGroup>
54 )
55 }
56β
57 const { container, dispose } = mount(() => <Component />)
58 expect(container.querySelector('[data-testid="field"]')?.textContent).toBe(
59 'guest.name:Tony',
60 )
61β
62 change('Rodney')
63β
64 expect(
65 container.querySelector('[data-testid="group-value"]')?.textContent,
66 ).toBe('Rodney')
67 dispose()
68 })
69β
70 it('prefixes watched field names in form group listeners', () => {
71 const listener = vi.fn()
72 let change!: (value: string) => void
73β
74 function Component() {
75 const form = createForm(() => ({
76 defaultValues: { guest: { name: '', confirmation: '' } },
77 }))
78β
79 return (
80 <form.FormGroup name="guest">
81 {(group) => (
82 <>
83 <group.Field name="name">
84 {(field) => {
85 change = field().handleChange
86 return null
87 }}
88 </group.Field>
89 <group.Field
90 name="confirmation"
91 listeners={[
92 {
93 triggers: ['change'],
94 watchFields: ['name'],
95 run: listener,
96 },
97 ]}
98 >
99 {() => null}
100 </group.Field>
101 </>
102 )}
103 </form.FormGroup>
104 )
105 }
106β
107 const { dispose } = mount(() => <Component />)
108 change('A')
109 expect(listener).toHaveBeenCalledOnce()
110 dispose()
111 })
112β
113 it('reactively updates form group field names', () => {
114 let showLastName!: () => void
115β
116 function Component() {
117 const [fieldName, setFieldName] = createSignal<'firstName' | 'lastName'>(
118 'firstName',
119 )
120 showLastName = () => setFieldName('lastName')
121 const form = createForm(() => ({
122 defaultValues: {
123 guest: { firstName: 'Tony', lastName: 'Hawk' },
124 },
125 }))
126β
127 return (
128 <form.FormGroup name="guest">
129 {(group) => (
130 <group.Field name={fieldName()}>
131 {(field) => (
132 <span data-testid="group-field">
133 {field().name}:{field().value}
134 </span>
135 )}
136 </group.Field>
137 )}
138 </form.FormGroup>
139 )
140 }
141β
142 const { container, dispose } = mount(() => <Component />)
143 expect(
144 container.querySelector('[data-testid="group-field"]')?.textContent,
145 ).toBe('guest.firstName:Tony')
146β
147 showLastName()
148β
149 expect(
150 container.querySelector('[data-testid="group-field"]')?.textContent,
151 ).toBe('guest.lastName:Hawk')
152 dispose()
153 })
154β
155 it('reactively updates form group field listeners', () => {
156 const firstListener = vi.fn()
157 const secondListener = vi.fn()
158 let useSecondListener!: () => void
159 let change!: (value: string) => void
160β
161 function Component() {
162 const [usesSecondListener, setUsesSecondListener] = createSignal(false)
163 useSecondListener = () => setUsesSecondListener(true)
164 const form = createForm(() => ({
165 defaultValues: { guest: { name: '' } },
166 }))
167β
168 return (
169 <form.FormGroup name="guest">
170 {(group) => (
171 <group.Field
172 name="name"
173 listeners={[
174 {
175 triggers: ['change'],
176 run: usesSecondListener() ? secondListener : firstListener,
177 },
178 ]}
179 >
180 {(field) => {
181 change = field().handleChange
182 return null
183 }}
184 </group.Field>
185 )}
186 </form.FormGroup>
187 )
188 }
189β
190 const { dispose } = mount(() => <Component />)
191 change('First')
192 expect(firstListener).toHaveBeenCalledOnce()
193β
194 useSecondListener()
195 change('Second')
196β
197 expect(firstListener).toHaveBeenCalledOnce()
198 expect(secondListener).toHaveBeenCalledOnce()
199 dispose()
200 })
201β
202 it('supports app field components through Solid context', () => {
203 function TextField(props: {
204 field: Accessor<FieldWithValue<string>>
205 label: string
206 }) {
207 return (
208 <span data-testid="app-field">
209 {props.label}:{props.field().name}:{props.field().value}
210 </span>
211 )
212 }
213β
214 const { fieldComponent } = getFormHookHelpers()
215 const AppTextField = fieldComponent.strict(TextField, 'field')
216 const { useAppForm } = createFormHook({
217 fieldComponents: { AppTextField },
218 formComponents: {},
219 })
220β
221 function Component() {
222 const form = useAppForm(() => ({
223 defaultValues: { guest: { name: 'Tony' } },
224 }))
225 return (
226 <form.AppForm>
227 <form.FormGroup name="guest">
228 {(group) => (
229 <group.Field name="name">
230 {(field) => <field.AppTextField label="Name" />}
231 </group.Field>
232 )}
233 </form.FormGroup>
234 </form.AppForm>
235 )
236 }
237β
238 const { container, dispose } = mount(() => <Component />)
239 expect(
240 container.querySelector('[data-testid="app-field"]')?.textContent,
241 ).toBe('Name:guest.name:Tony')
242 dispose()
243 })
244β
245 it('provides app form components with their form context', () => {
246 function Summary() {
247 const form = useFormContext()
248 return (
249 <form.Subscribe selector={(state) => state.values.name}>
250 {(name) => <span data-testid="summary">{name()}</span>}
251 </form.Subscribe>
252 )
253 }
254β
255 const { useAppForm, useFormContext } = createFormHook({
256 fieldComponents: {},
257 formComponents: { Summary },
258 })
259β
260 function Component() {
261 const form = useAppForm(() => ({ defaultValues: { name: 'Tony' } }))
262 return (
263 <form.AppForm>
264 <form.Summary />
265 </form.AppForm>
266 )
267 }
268β
269 const { container, dispose } = mount(() => <Component />)
270 expect(
271 container.querySelector('[data-testid="summary"]')?.textContent,
272 ).toBe('Tony')
273 dispose()
274 })
275β
276 it('reactively applies Subscribe when predicates', () => {
277 let setVisible!: (value: boolean) => void
278β
279 function Component() {
280 const form = createForm(() => ({
281 defaultValues: { visible: false },
282 }))
283 setVisible = (value) => form.setFieldValue('visible', value)
284β
285 return (
286 <form.Subscribe
287 selector={(state) => state.values.visible}
288 when={(visible) => visible}
289 >
290 {() => <span data-testid="visible">Visible</span>}
291 </form.Subscribe>
292 )
293 }
294β
295 const { container, dispose } = mount(() => <Component />)
296 expect(container.querySelector('[data-testid="visible"]')).toBeNull()
297 setVisible(true)
298 expect(container.querySelector('[data-testid="visible"]')).not.toBeNull()
299 dispose()
300 })
301β
302 it('updates options without replacing or re-registering a field', () => {
303 const onMount = vi.fn()
304 const onUnmount = vi.fn()
305 let update!: () => void
306β
307 function Component() {
308 const [count, setCount] = createSignal(0)
309 update = () => setCount((value) => value + 1)
310 const form = createForm(() => ({ defaultValues: { name: 'Tony' } }))
311β
312 return (
313 <>
314 <span>{count()}</span>
315 <form.Field
316 name="name"
317 listeners={[
318 { triggers: ['mount'], run: onMount },
319 { triggers: ['unmount'], run: onUnmount },
320 ]}
321 >
322 {(field) => <span>{field().value}</span>}
323 </form.Field>
324 </>
325 )
326 }
327β
328 const { dispose } = mount(() => <Component />)
329 const initialMounts = onMount.mock.calls.length
330 const initialUnmounts = onUnmount.mock.calls.length
331 update()
332 expect(onMount).toHaveBeenCalledTimes(initialMounts)
333 expect(onUnmount).toHaveBeenCalledTimes(initialUnmounts)
334 dispose()
335 expect(onMount.mock.calls.length - onUnmount.mock.calls.length).toBe(0)
336 })
337β
338 it('only invalidates ArrayField accessors for structural array changes', () => {
339 let changeChild!: (value: string) => void
340 let pushItem!: () => void
341 let arrayAccessorRuns = 0
342β
343 function Component() {
344 const form = createForm(() => ({
345 defaultValues: { people: [{ name: 'Tony' }] },
346 }))
347 pushItem = () => form.pushFieldValue('people', { name: 'Rodney' })
348β
349 return (
350 <>
351 <form.ArrayField name="people">
352 {(field) => {
353 createRenderEffect(() => {
354 field()
355 arrayAccessorRuns++
356 })
357 return <span>{field().value.length}</span>
358 }}
359 </form.ArrayField>
360 <form.Field name="people[0].name">
361 {(field) => {
362 changeChild = field().handleChange
363 return null
364 }}
365 </form.Field>
366 </>
367 )
368 }
369β
370 const { dispose } = mount(() => <Component />)
371 const initialRuns = arrayAccessorRuns
372 changeChild('Updated')
373 expect(arrayAccessorRuns).toBe(initialRuns)
374 pushItem()
375 expect(arrayAccessorRuns).toBe(initialRuns + 1)
376 dispose()
377 })
378β
379 it('rebinds mounted fields after a form reset', () => {
380 let reset!: () => void
381β
382 function Component() {
383 const form = createForm(() => ({ defaultValues: { name: 'Tony' } }))
384 reset = () => form.reset({ name: 'Rodney' })
385 return (
386 <form.Field name="name">
387 {(field) => <span data-testid="reset-value">{field().value}</span>}
388 </form.Field>
389 )
390 }
391β
392 const { container, dispose } = mount(() => <Component />)
393 reset()
394 expect(
395 container.querySelector('[data-testid="reset-value"]')?.textContent,
396 ).toBe('Rodney')
397 dispose()
398 })
399})
400β
401const nameFieldGroup = defineFieldGroup(({ strict }) => ({
402 name: strict<string>(),
403}))
404β
405function NameFieldsImpl(props: { fields: typeof nameFieldGroup.fields }) {
406 const values = useSelector(props.fields.atom)
407 return (
408 <>
409 <props.fields.Field name="name">
410 {(field) => (
411 <span data-testid="logical-field">
412 {field().name}:{field().value}
413 </span>
414 )}
415 </props.fields.Field>
416 <span data-testid="logical-value">{values().name}</span>
417 <button
418 type="button"
419 onClick={() => props.fields.setFieldValue('name', 'Updated')}
420 >
421 Update
422 </button>
423 </>
424 )
425}
426β
427const NameFields = nameFieldGroup.bindComponent(NameFieldsImpl, 'fields')
428β
429describe('Solid reusable field groups', () => {
430 it('defaults omitted bindings to same-named form fields', () => {
431 function Component() {
432 const form = createForm(() => ({
433 defaultValues: { name: 'Initial' },
434 }))
435 return <NameFields form={form} />
436 }
437β
438 const { container, dispose } = mount(() => <Component />)
439 expect(
440 container.querySelector('[data-testid="logical-field"]')?.textContent,
441 ).toBe('name:Initial')
442β
443 container.querySelector('button')?.click()
444β
445 expect(
446 container.querySelector('[data-testid="logical-value"]')?.textContent,
447 ).toBe('Updated')
448 dispose()
449 })
450β
451 it('maps logical names and forwards methods and atoms', () => {
452 function Component() {
453 const form = createForm(() => ({
454 defaultValues: { profile: { name: 'Initial' } },
455 }))
456 return <NameFields form={form} fields={{ name: 'profile.name' }} />
457 }
458β
459 const { container, dispose } = mount(() => <Component />)
460 expect(
461 container.querySelector('[data-testid="logical-field"]')?.textContent,
462 ).toBe('profile.name:Initial')
463β
464 container.querySelector('button')?.click()
465β
466 expect(
467 container.querySelector('[data-testid="logical-value"]')?.textContent,
468 ).toBe('Updated')
469 dispose()
470 })
471β
472 it('reactively updates logical field bindings', () => {
473 let showSecond!: () => void
474β
475 function Component() {
476 const [binding, setBinding] = createSignal<'first' | 'second'>('first')
477 showSecond = () => setBinding('second')
478 const form = createForm(() => ({
479 defaultValues: { first: 'One', second: 'Two' },
480 }))
481 return <NameFields form={form} fields={{ name: binding() }} />
482 }
483β
484 const { container, dispose } = mount(() => <Component />)
485 showSecond()
486 expect(
487 container.querySelector('[data-testid="logical-field"]')?.textContent,
488 ).toBe('second:Two')
489 dispose()
490 })
491})