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

form-controller.spec.ts

472 lines13.3 KB

1/// <reference lib="dom" />
2import { LitElement, html } from 'lit'
3import { describe, expect, expectTypeOf, it, vi } from 'vitest'
4import { userEvent } from 'vitest/browser'
5import {
6 TanStackFormController,
7 defineFieldGroup,
8 formOptions,
9 getFormType,
10} from '../src/index.js'
11import { defineOnce, mount } from './utils.js'
12import type { LitFormType } from '../src/index.js'
13​
14const personFormOptions = formOptions({
15 defaultValues: {
16 firstName: 'Ada',
17 lastName: '',
18 items: [{ id: 'one', name: 'First' }],
19 profile: { name: '' },
20 },
21})
22​
23class TestFormElement extends LitElement {
24 submit = vi.fn()
25 formMount = vi.fn()
26 fieldMount = vi.fn()
27 fieldUnmount = vi.fn()
28 updateCount = 0
29​
30 form = new TanStackFormController(this, {
31 ...personFormOptions,
32 onSubmit: ({ value }) => this.submit(value),
33 listeners: [
34 {
35 triggers: ['mount'],
36 run: this.formMount,
37 },
38 ],
39 })
40​
41 updateFirstName(firstName: string) {
42 this.form.update({
43 ...personFormOptions,
44 defaultValues: {
45 ...personFormOptions.defaultValues,
46 firstName,
47 },
48 onSubmit: ({ value }) => this.submit(value),
49 listeners: [
50 {
51 triggers: ['mount'],
52 run: this.formMount,
53 },
54 ],
55 })
56 }
57​
58 protected updated() {
59 this.updateCount++
60 }
61​
62 render() {
63 return html`
64 <form
65 @submit=${(event: SubmitEvent) => {
66 event.preventDefault()
67 void this.form.api.handleSubmit()
68 }}
69 >
70 ${this.form.field(
71 {
72 name: 'firstName',
73 listeners: [
74 { triggers: ['mount'], run: this.fieldMount },
75 { triggers: ['unmount'], run: this.fieldUnmount },
76 ],
77 },
78 (field) => {
79 return html`
80 <label>
81 First name
82 <input
83 id="firstName"
84 .value=${field.value}
85 @blur=${() => field.handleBlur()}
86 @input=${(event: InputEvent) =>
87 field.handleChange(
88 (event.currentTarget as HTMLInputElement).value,
89 )}
90 />
91 </label>
92 `
93 },
94 )}
95 ${this.form.field(
96 {
97 name: 'lastName',
98 validators: [
99 {
100 triggers: ['change'],
101 run: ({ value }) =>
102 value.length >= 3 ? undefined : 'Use at least 3 characters',
103 },
104 ],
105 },
106 (field) => html`
107 <label>
108 Last name
109 <input
110 id="lastName"
111 .value=${field.value}
112 @blur=${() => field.handleBlur()}
113 @input=${(event: InputEvent) =>
114 field.handleChange(
115 (event.currentTarget as HTMLInputElement).value,
116 )}
117 />
118 </label>
119 ${field.errors.map(
120 (error) => html`<span class="last-error">${error.message}</span>`,
121 )}
122 `,
123 )}
124 ${this.form.subscribe(
125 (state) => state.isSubmitting,
126 (isSubmitting) => html`
127 <button id="submit" type="submit" ?disabled=${isSubmitting}>
128 ${isSubmitting ? 'Submitting' : 'Submit'}
129 </button>
130 `,
131 )}
132 <button id="reset" type="button" @click=${() => this.form.api.reset()}>
133 Reset
134 </button>
135 </form>
136 `
137 }
139​
140class ArrayFormElement extends LitElement {
141 form = new TanStackFormController(this, personFormOptions)
142​
143 render() {
144 return html`
145 ${this.form.arrayField({ name: 'items' }, (array) => {
146 return html`
147 <output id="count">${array.value.length}</output>
148 ${array.value.map((_item, index) =>
149 this.form.field(
150 { name: `items[${index}].name` },
151 (field) => html`<input class="item" .value=${field.value} />`,
152 ),
153 )}
154 `
155 })}
156 <button
157 id="add"
158 @click=${() =>
159 this.form.api.pushFieldValue('items', {
160 id: crypto.randomUUID(),
161 name: 'Next',
162 })}
163 >
164 Add
165 </button>
166 `
167 }
169​
170class FormGroupElement extends LitElement {
171 step = 0
172 groupSubmit = vi.fn(() => {
173 this.step++
174 this.requestUpdate()
175 })
176 form = new TanStackFormController(this, personFormOptions)
177​
178 render() {
179 return html`
180 ${this.form.formGroup(
181 {
182 name: 'profile',
183 validators: [
184 {
185 triggers: [],
186 run: ({ value }) =>
187 value.name.length >= 2 ? undefined : 'Enter a name',
188 },
189 ],
190 onSubmit: this.groupSubmit,
191 },
192 (group) => html`
193 <form
194 @submit=${(event: SubmitEvent) => {
195 event.preventDefault()
196 void group.handleSubmit()
197 }}
198 >
199 ${group.field({ name: 'name' }, (field) => {
200 return html`
201 <input
202 id="profileName"
203 .value=${field.value}
204 @input=${(event: InputEvent) =>
205 field.handleChange(
206 (event.currentTarget as HTMLInputElement).value,
207 )}
208 />
209 `
210 })}
211 ${group.state.errors.map(
212 (error) =>
213 html`<span class="group-error">${error.message}</span>`,
214 )}
215 <button id="continue" type="submit">Continue</button>
216 </form>
217 `,
218 )}
219 <output id="step">${this.step}</output>
220 `
221 }
223​
224const reusableNameFieldGroup = defineFieldGroup(({ strict }) => ({
225 value: strict<string>(),
226 items: strict<Array<string>>(),
227}))
228const ReusableNameField = reusableNameFieldGroup.bindComponent(
229 (props: { fields: typeof reusableNameFieldGroup.fields; label: string }) => {
230 const nameField = props.fields.field(
231 { name: 'value' },
232 (field) => html`
233 <label>
234 ${props.label}
235 <input
236 id="reusableName"
237 .value=${field.value}
238 @input=${(event: InputEvent) =>
239 field.handleChange(
240 (event.currentTarget as HTMLInputElement).value,
241 )}
242 />
243 </label>
244 `,
245 )
246​
247 return html`
248 ${nameField}
249 <button
250 id="moveReusableItem"
251 @click=${() => props.fields.moveFieldValue('items', 0, 2)}
252 >
253 Move item
254 </button>
255 `
256 },
257 'fields',
259​
260class ReusableFieldGroupElement extends LitElement {
261 form = new TanStackFormController(this, {
262 defaultValues: {
263 profile: { name: '' },
264 lists: { names: ['a', 'b', 'c'] },
265 count: 0,
266 },
267 })
268​
269 render() {
270 return ReusableNameField({
271 form: this.form,
272 fields: { value: 'profile.name', items: 'lists.names' },
273 label: 'Name',
274 })
275 }
277​
278class IdentityFieldGroupElement extends LitElement {
279 form = new TanStackFormController(this, {
280 defaultValues: {
281 value: '',
282 items: ['a', 'b', 'c'],
283 },
284 })
285​
286 render() {
287 return ReusableNameField({
288 form: this.form,
289 label: 'Name',
290 })
291 }
293​
294defineOnce('test-lit-form', TestFormElement)
295defineOnce('test-lit-array-form', ArrayFormElement)
296defineOnce('test-lit-form-group', FormGroupElement)
297defineOnce('test-lit-reusable-field-group', ReusableFieldGroupElement)
298defineOnce('test-lit-identity-field-group', IdentityFieldGroupElement)
299​
300describe('TanStackFormController', () => {
301 it('owns v2 fields and mirrors user input', async () => {
302 const element = await mount<TestFormElement>('test-lit-form')
303 const firstName =
304 element.shadowRoot!.querySelector<HTMLInputElement>('#firstName')!
305 const lastName =
306 element.shadowRoot!.querySelector<HTMLInputElement>('#lastName')!
307​
308 expect(firstName).toHaveValue('Ada')
309 expect(lastName).toHaveValue('')
310​
311 await userEvent.type(lastName, 'Lovelace')
312​
313 expect(element.form.api.getFieldValue('lastName')).toBe('Lovelace')
314 })
315​
316 it('updates field parts without rerendering the host', async () => {
317 const element = await mount<TestFormElement>('test-lit-form')
318 const updateCount = element.updateCount
319​
320 await userEvent.type(
321 element.shadowRoot!.querySelector<HTMLInputElement>('#lastName')!,
322 'Lovelace',
323 )
324​
325 expect(element.updateCount).toBe(updateCount)
326 expect(element.shadowRoot!.querySelector('.last-error')).toBeNull()
327 })
328​
329 it('renders v2 validation issues and resets fields', async () => {
330 const element = await mount<TestFormElement>('test-lit-form')
331 const firstName =
332 element.shadowRoot!.querySelector<HTMLInputElement>('#firstName')!
333 const lastName =
334 element.shadowRoot!.querySelector<HTMLInputElement>('#lastName')!
335​
336 await userEvent.type(lastName, 'Li')
337 expect(element.shadowRoot!.querySelector('.last-error')).toHaveTextContent(
338 'Use at least 3 characters',
339 )
340 await userEvent.type(firstName, ' Lovelace')
341 await userEvent.click(element.shadowRoot!.querySelector('#reset')!)
342 await element.updateComplete
343 expect(firstName).toHaveValue('Ada')
344 })
345​
346 it('submits through the form API', async () => {
347 const element = await mount<TestFormElement>('test-lit-form')
348 await userEvent.type(
349 element.shadowRoot!.querySelector<HTMLInputElement>('#lastName')!,
350 'Lovelace',
351 )
352 await userEvent.click(element.shadowRoot!.querySelector('#submit')!)
353 await vi.waitFor(() => expect(element.submit).toHaveBeenCalledOnce())
354 })
355​
356 it('updates untouched defaults without replacing the controller', async () => {
357 const element = await mount<TestFormElement>('test-lit-form')
358 const form = element.form
359​
360 element.updateFirstName('Grace')
361 await element.updateComplete
362​
363 expect(element.form).toBe(form)
364 expect(
365 element.shadowRoot!.querySelector<HTMLInputElement>('#firstName'),
366 ).toHaveValue('Grace')
367 })
368​
369 it('mounts and reconnects form and field subscriptions', async () => {
370 const element = await mount<TestFormElement>('test-lit-form')
371 expect(element.formMount).toHaveBeenCalledOnce()
372 expect(element.fieldMount).toHaveBeenCalledOnce()
373​
374 element.remove()
375 await Promise.resolve()
376 expect(element.fieldUnmount).toHaveBeenCalledOnce()
377​
378 document.body.appendChild(element)
379 element.requestUpdate()
380 await element.updateComplete
381 expect(element.formMount).toHaveBeenCalledTimes(2)
382 expect(element.fieldMount).toHaveBeenCalledTimes(2)
383 })
384​
385 it('renders structural array updates through arrayField', async () => {
386 const element = await mount<ArrayFormElement>('test-lit-array-form')
387 expect(element.shadowRoot!.querySelector('#count')).toHaveTextContent('1')
388​
389 await userEvent.click(element.shadowRoot!.querySelector('#add')!)
390​
391 expect(element.shadowRoot!.querySelector('#count')).toHaveTextContent('2')
392 expect(element.shadowRoot!.querySelectorAll('.item')).toHaveLength(2)
393 })
394​
395 it('validates and submits a scoped form group', async () => {
396 const element = await mount<FormGroupElement>('test-lit-form-group')
397​
398 await userEvent.click(element.shadowRoot!.querySelector('#continue')!)
399 expect(element.shadowRoot!.querySelector('.group-error')).toHaveTextContent(
400 'Enter a name',
401 )
402 expect(element.groupSubmit).not.toHaveBeenCalled()
403​
404 await userEvent.type(
405 element.shadowRoot!.querySelector<HTMLInputElement>('#profileName')!,
406 'Ada',
407 )
408 await userEvent.click(element.shadowRoot!.querySelector('#continue')!)
409​
410 await vi.waitFor(() => expect(element.groupSubmit).toHaveBeenCalledOnce())
411 expect(element.shadowRoot!.querySelector('#step')).toHaveTextContent('1')
412 })
413​
414 it('maps reusable virtual fields to concrete form paths', async () => {
415 const element = await mount<ReusableFieldGroupElement>(
416 'test-lit-reusable-field-group',
417 )
418​
419 await userEvent.type(
420 element.shadowRoot!.querySelector<HTMLInputElement>('#reusableName')!,
421 'Ada',
422 )
423​
424 expect(element.form.api.getFieldValue('profile.name')).toBe('Ada')
425​
426 await userEvent.click(
427 element.shadowRoot!.querySelector<HTMLButtonElement>(
428 '#moveReusableItem',
429 )!,
430 )
431 expect(element.form.api.getFieldValue('lists.names')).toEqual([
432 'b',
433 'c',
434 'a',
435 ])
436 })
437​
438 it('defaults omitted bindings to same-named form fields', async () => {
439 const element = await mount<IdentityFieldGroupElement>(
440 'test-lit-identity-field-group',
441 )
442​
443 await userEvent.type(
444 element.shadowRoot!.querySelector<HTMLInputElement>('#reusableName')!,
445 'Ada',
446 )
447​
448 expect(element.form.api.getFieldValue('value')).toBe('Ada')
449​
450 await userEvent.click(
451 element.shadowRoot!.querySelector<HTMLButtonElement>(
452 '#moveReusableItem',
453 )!,
454 )
455 expect(element.form.api.getFieldValue('items')).toEqual(['b', 'c', 'a'])
456 })
457​
458 it('derives reusable controller types from formOptions', () => {
459 type ReusableForm = LitFormType<typeof personFormOptions>
460 const reusableForm = getFormType(personFormOptions)
461 expectTypeOf(reusableForm).toEqualTypeOf<ReusableForm>()
462​
463 class Parent extends LitElement {
464 form = new TanStackFormController(this, {
465 ...personFormOptions,
466 onSubmit: () => undefined,
467 })
468 }
469​
470 expectTypeOf<Parent['form']>().toExtend<ReusableForm>()
471 })
472})