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

createFormHook.spec.tsx

428 lines12.3 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('supports nested field and form component trees', async () => {
47 function FieldValue({ field }: { field: FieldWithValue<string> }) {
48 return <span>Field value: {field.value}</span>
49 }
50​
51 function FormHeading() {
52 return <h1>Nested form component</h1>
53 }
54​
55 const { fieldComponent } = getFormHookHelpers()
56 const FieldValueWithContext = fieldComponent.strict(FieldValue, 'field')
57 const { useAppForm } = createFormHook({
58 fieldComponents: {
59 display: {
60 values: {
61 FieldValue: FieldValueWithContext,
62 },
63 },
64 },
65 formComponents: {
66 layout: {
67 headings: {
68 FormHeading,
69 },
70 },
71 },
72 })
73​
74 function Component() {
75 const form = useAppForm({ defaultValues: { name: 'Tony' } })
76​
77 return (
78 <form.AppForm>
79 <form.layout.headings.FormHeading />
80 <form.Field name="name">
81 {(field) => <field.display.values.FieldValue />}
82 </form.Field>
83 </form.AppForm>
84 )
85 }
86​
87 const { getByText } = await render(<Component />)
88​
89 expect(getByText('Nested form component')).toBeInTheDocument()
90 expect(getByText('Field value: Tony')).toBeInTheDocument()
91 })
92​
93 it('supports destructuring registered form components', async () => {
94 const SharedComponent = () => <span>Shared component</span>
95 const { useAppForm } = createFormHook({
96 fieldComponents: {},
97 formComponents: { SharedComponent },
98 })
99​
100 /* eslint-disable @eslint-react/static-components -- False positive, component's created once */
101 function Component() {
102 const form = useAppForm({ defaultValues: { name: '' } })
103 const { SharedComponent: DestructuredComponent } = form
104​
105 return <DestructuredComponent />
106 }
107 /* eslint-enable @eslint-react/static-components */
108​
109 const { getByText } = await render(<Component />)
110​
111 expect(getByText('Shared component')).toBeInTheDocument()
112 })
113​
114 it('renders inherited form components with per-instance AppForm context', async () => {
115 function CurrentName() {
116 const form = useFormContext()
117 return <span data-testid="current-name">{form.state.values.name}</span>
118 }
119​
120 const { useAppForm, useFormContext } = createFormHook({
121 fieldComponents: {},
122 formComponents: { CurrentName },
123 })
124​
125 function Component() {
126 const form = useAppForm({ defaultValues: { name: 'Tony' } })
127​
128 return (
129 <form.AppForm>
130 <form.CurrentName />
131 </form.AppForm>
132 )
133 }
134​
135 const { getByTestId } = await render(<Component />)
136​
137 expect(getByTestId('current-name')).toHaveTextContent('Tony')
138 })
139​
140 it('uses default form options and lets usage options override them', async () => {
141 const defaultErrorVisibility = () => true
142 const overriddenErrorVisibility = () => false
143 const { useAppForm } = createFormHook({
144 fieldComponents: {},
145 formComponents: {},
146 defaultFormOptions: {
147 errorVisibility: defaultErrorVisibility,
148 },
149 })
150​
151 const getErrorVisibility = (form: unknown) =>
152 (form as AnyInternalFormApi)._options.errorVisibility
153​
154 function DefaultForm() {
155 const form = useAppForm({ defaultValues: { name: '' } })
156 return (
157 <span data-testid="default">
158 {String(getErrorVisibility(form) === defaultErrorVisibility)}
159 </span>
160 )
161 }
162​
163 function OverriddenForm() {
164 const form = useAppForm({
165 defaultValues: { name: '' },
166 errorVisibility: overriddenErrorVisibility,
167 })
168 return (
169 <span data-testid="overridden">
170 {String(getErrorVisibility(form) === overriddenErrorVisibility)}
171 </span>
172 )
173 }
174​
175 function UndefinedForm() {
176 const form = useAppForm({
177 defaultValues: { name: '' },
178 errorVisibility: undefined,
179 })
180 return (
181 <span data-testid="undefined">
182 {String(getErrorVisibility(form) === undefined)}
183 </span>
184 )
185 }
186​
187 const { getByTestId } = await render(
188 <>
189 <DefaultForm />
190 <OverriddenForm />
191 <UndefinedForm />
192 </>,
193 )
194​
195 expect(getByTestId('default')).toHaveTextContent('true')
196 expect(getByTestId('overridden')).toHaveTextContent('true')
197 expect(getByTestId('undefined')).toHaveTextContent('true')
198 })
199​
200 it('resolves form and field listener merge modes in core', async () => {
201 const formCalls: Array<string> = []
202 const fieldCalls: Array<string> = []
203 const { useAppForm } = createFormHook({
204 fieldComponents: {},
205 formComponents: {},
206 defaultFormOptions: {
207 listenersMerge: 'append',
208 listeners: [
209 {
210 triggers: ['change'],
211 run: () => formCalls.push('default'),
212 },
213 ],
214 },
215 defaultFieldOptions: {
216 listenersMerge: 'prepend',
217 listeners: [
218 {
219 triggers: ['change'],
220 run: () => fieldCalls.push('default'),
221 },
222 ],
223 },
224 })
225​
226 function Component() {
227 const form = useAppForm({
228 defaultValues: { name: '' },
229 listeners: [
230 {
231 triggers: ['change'],
232 run: () => formCalls.push('local'),
233 },
234 ],
235 })
236​
237 return (
238 <form.Field
239 name="name"
240 listeners={[
241 {
242 triggers: ['change'],
243 run: () => fieldCalls.push('local'),
244 },
245 ]}
246 >
247 {(field) => (
248 <input
249 aria-label="Name"
250 value={field.value}
251 onChange={(event) => field.handleChange(event.target.value)}
252 />
253 )}
254 </form.Field>
255 )
256 }
257​
258 const { getByRole } = await render(<Component />)
259 await getByRole('textbox', { name: 'Name' }).fill('updated')
260​
261 expect(formCalls).toEqual(['default', 'local'])
262 expect(fieldCalls).toEqual(['local', 'default'])
263 })
264​
265 it('applies field defaults to direct and grouped fields', async () => {
266 const { useAppForm } = createFormHook({
267 fieldComponents: {},
268 formComponents: {},
269 defaultFieldOptions: {
270 errorBoundary: true,
271 },
272 })
273​
274 const getErrorBoundary = (field: unknown) =>
275 String((field as AnyInternalFieldApi)._errorBoundary)
276​
277 function Component() {
278 const form = useAppForm({
279 defaultValues: {
280 direct: '',
281 directArray: [''],
282 overridden: '',
283 undefinedOverride: '',
284 group: {
285 field: '',
286 array: [''],
287 },
288 },
289 })
290​
291 return (
292 <>
293 <form.Field name="direct">
294 {(field) => (
295 <span data-testid="direct">{getErrorBoundary(field)}</span>
296 )}
297 </form.Field>
298 <form.ArrayField name="directArray">
299 {(field) => (
300 <span data-testid="direct-array">{getErrorBoundary(field)}</span>
301 )}
302 </form.ArrayField>
303 <form.Field name="overridden" errorBoundary={false}>
304 {(field) => (
305 <span data-testid="overridden">{getErrorBoundary(field)}</span>
306 )}
307 </form.Field>
308 <form.Field name="undefinedOverride" errorBoundary={undefined}>
309 {(field) => (
310 <span data-testid="undefined">{getErrorBoundary(field)}</span>
311 )}
312 </form.Field>
313 <form.FormGroup name="group">
314 {(group) => (
315 <>
316 <group.Field name="field">
317 {(field) => (
318 <span data-testid="group-field">
319 {getErrorBoundary(field)}
320 </span>
321 )}
322 </group.Field>
323 <group.ArrayField name="array">
324 {(field) => (
325 <span data-testid="group-array">
326 {getErrorBoundary(field)}
327 </span>
328 )}
329 </group.ArrayField>
330 </>
331 )}
332 </form.FormGroup>
333 </>
334 )
335 }
336​
337 const { getByTestId } = await render(<Component />)
338​
339 expect(getByTestId('direct')).toHaveTextContent('true')
340 expect(getByTestId('direct-array')).toHaveTextContent('true')
341 expect(getByTestId('overridden')).toHaveTextContent('false')
342 expect(getByTestId('undefined')).toHaveTextContent('false')
343 expect(getByTestId('group-field')).toHaveTextContent('true')
344 expect(getByTestId('group-array')).toHaveTextContent('true')
345 })
346​
347 it('uses default form group options and permits all override forms', async () => {
348 const defaultOnSubmitInvalid = vi.fn()
349 const overriddenOnSubmitInvalid = vi.fn()
350 const defaultValidator = vi.fn(() => 'invalid')
351 const overriddenValidator = vi.fn(() => 'invalid')
352 const undefinedValidator = vi.fn(() => 'invalid')
353 const { useAppForm } = createFormHook({
354 fieldComponents: {},
355 formComponents: {},
356 defaultFormGroupOptions: {
357 onSubmitInvalid: defaultOnSubmitInvalid,
358 },
359 })
360​
361 function Component() {
362 const form = useAppForm({
363 defaultValues: {
364 defaultGroup: { name: '' },
365 overriddenGroup: { name: '' },
366 undefinedGroup: { name: '' },
367 },
368 })
369​
370 return (
371 <>
372 <form.FormGroup
373 name="defaultGroup"
374 validators={[{ triggers: [], run: defaultValidator }]}
375 >
376 {(group) => (
377 <button onClick={() => void group.handleSubmit()}>
378 Submit default group
379 </button>
380 )}
381 </form.FormGroup>
382 <form.FormGroup
383 name="overriddenGroup"
384 validators={[{ triggers: [], run: overriddenValidator }]}
385 onSubmitInvalid={overriddenOnSubmitInvalid}
386 >
387 {(group) => (
388 <button onClick={() => void group.handleSubmit()}>
389 Submit overridden group
390 </button>
391 )}
392 </form.FormGroup>
393 <form.FormGroup
394 name="undefinedGroup"
395 validators={[{ triggers: [], run: undefinedValidator }]}
396 onSubmitInvalid={undefined}
397 >
398 {(group) => (
399 <button onClick={() => void group.handleSubmit()}>
400 Submit undefined group
401 </button>
402 )}
403 </form.FormGroup>
404 </>
405 )
406 }
407​
408 const { getByRole } = await render(<Component />)
409​
410 await getByRole('button', { name: 'Submit default group' }).click()
411 await vi.waitFor(() =>
412 expect(defaultOnSubmitInvalid).toHaveBeenCalledOnce(),
413 )
414​
415 await getByRole('button', { name: 'Submit overridden group' }).click()
416 await vi.waitFor(() =>
417 expect(overriddenOnSubmitInvalid).toHaveBeenCalledOnce(),
418 )
419 expect(defaultOnSubmitInvalid).toHaveBeenCalledOnce()
420​
421 await getByRole('button', { name: 'Submit undefined group' }).click()
422 await vi.waitFor(() => {
423 expect(undefinedValidator).toHaveBeenCalledOnce()
424 expect(defaultOnSubmitInvalid).toHaveBeenCalledOnce()
425 expect(overriddenOnSubmitInvalid).toHaveBeenCalledOnce()
426 })
427 })
428})