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

createFieldListSearch.test.ts

316 lines9.1 KB

1import { createSignal } from 'solid-js'
2import { render } from 'solid-js/web'
3import { afterEach, describe, expect, it } from 'vitest'
4import { createFieldListSearch } from '../src/hooks/createFieldListSearch'
5import { setPinnedFieldIds } from '../src/stores/fieldListStore'
6import type { FieldRowFilterPredicate } from '../src/stores/fieldListStore'
7import type { FieldId } from '../src/types/branded'
8​
9const disposers: Array<() => void> = []
10​
11function field(path: string, fieldId: string) {
12 return { path, pathLeaf: path, fieldId: fieldId as FieldId }
14​
15function meta(isDirty: boolean) {
16 return {
17 isDirty,
18 isTouched: false,
19 isBlurred: false,
20 isLongValidating: false,
21 isDefaultValue: true,
22 hasSelfErrors: false,
23 validity: 'valid' as const,
24 }
26​
27afterEach(() => {
28 for (const dispose of disposers.splice(0)) dispose()
29 setPinnedFieldIds([])
30})
31​
32describe('field list search', () => {
33 it('combines Bookmarked and Dirty predicates in the active pipeline', async () => {
34 let search!: ReturnType<typeof createFieldListSearch>
35 let activePipeline!: () => Array<FieldRowFilterPredicate>
36​
37 const dispose = render(() => {
38 const [query, setQuery] = createSignal('')
39 const [filterPipeline, setFilterPipeline] = createSignal<
40 Array<FieldRowFilterPredicate>
41 >([])
42​
43 activePipeline = filterPipeline
44 search = createFieldListSearch({
45 query,
46 setQuery,
47 setFilterPipeline,
48 })
49​
50 return null
51 }, document.createElement('div'))
52 disposers.push(dispose)
53​
54 search.tagsInputApi().addValue('bookmarked')
55 await Promise.resolve()
56​
57 expect(activePipeline()).toHaveLength(1)
58​
59 setPinnedFieldIds(['field-pinned'])
60 const predicate = activePipeline()[0]!
61​
62 expect(predicate(field('pinned', 'field-pinned'), meta(false))).toBe(true)
63 expect(predicate(field('other', 'field-other'), meta(false))).toBe(false)
64​
65 search.tagsInputApi().addValue('dirty')
66 await Promise.resolve()
67​
68 expect(activePipeline()).toHaveLength(2)
69 expect(
70 activePipeline().every((activePredicate) =>
71 activePredicate(field('pinned', 'field-pinned'), meta(true)),
72 ),
73 ).toBe(true)
74 expect(
75 activePipeline().every((activePredicate) =>
76 activePredicate(field('pristine', 'field-pinned'), meta(false)),
77 ),
78 ).toBe(false)
79​
80 search.tagsInputApi().addValue('unmounted')
81 await Promise.resolve()
82​
83 expect(activePipeline()).toHaveLength(3)
84 expect(activePipeline()[2]?.bypassesDefaultInclusion).toBe(true)
85​
86 expect(
87 search.tagsSuggestions().items.map((filter) => filter.id),
88 ).not.toContain('pristine')
89 expect(
90 search.tagsSuggestions().items.map((filter) => filter.id),
91 ).not.toContain('validating')
92 })
93​
94 it('filters Dirty and Pristine rows from hydrated summaries', async () => {
95 let search!: ReturnType<typeof createFieldListSearch>
96 let activePipeline!: () => Array<FieldRowFilterPredicate>
97​
98 const dispose = render(() => {
99 const [query, setQuery] = createSignal('')
100 const [filterPipeline, setFilterPipeline] = createSignal<
101 Array<FieldRowFilterPredicate>
102 >([])
103​
104 activePipeline = filterPipeline
105 search = createFieldListSearch({
106 query,
107 setQuery,
108 setFilterPipeline,
109 })
110​
111 return null
112 }, document.createElement('div'))
113 disposers.push(dispose)
114​
115 search.tagsInputApi().addValue('dirty')
116 await Promise.resolve()
117​
118 const dirtyPredicate = activePipeline()[0]!
119 expect(dirtyPredicate.usesSummary).toBe(true)
120 expect(dirtyPredicate(field('dirty', 'field-dirty'), meta(true))).toBe(true)
121 expect(
122 dirtyPredicate(field('pristine', 'field-pristine'), meta(false)),
123 ).toBe(false)
124 search.clearSelection()
125 search.tagsInputApi().addValue('pristine')
126 await Promise.resolve()
127​
128 const pristinePredicate = activePipeline()[0]!
129 expect(pristinePredicate(field('dirty', 'field-dirty'), meta(true))).toBe(
130 false,
131 )
132 expect(
133 pristinePredicate(field('pristine', 'field-pristine'), meta(false)),
134 ).toBe(true)
135 })
136​
137 it('filters Invalid and Valid rows from hydrated summaries', async () => {
138 let search!: ReturnType<typeof createFieldListSearch>
139 let activePipeline!: () => Array<FieldRowFilterPredicate>
140​
141 const dispose = render(() => {
142 const [query, setQuery] = createSignal('')
143 const [filterPipeline, setFilterPipeline] = createSignal<
144 Array<FieldRowFilterPredicate>
145 >([])
146​
147 activePipeline = filterPipeline
148 search = createFieldListSearch({
149 query,
150 setQuery,
151 setFilterPipeline,
152 })
153​
154 return null
155 }, document.createElement('div'))
156 disposers.push(dispose)
157​
158 search.tagsInputApi().addValue('invalid')
159 await Promise.resolve()
160​
161 const invalidPredicate = activePipeline()[0]!
162 expect(invalidPredicate.usesSummary).toBe(true)
163 expect(
164 invalidPredicate(field('invalid', 'field-invalid'), {
165 ...meta(false),
166 validity: 'invalid',
167 }),
168 ).toBe(true)
169 expect(
170 invalidPredicate(field('hidden', 'field-hidden'), {
171 ...meta(false),
172 validity: 'invalidHidden',
173 }),
174 ).toBe(true)
175 expect(invalidPredicate(field('valid', 'field-valid'), meta(false))).toBe(
176 false,
177 )
178 expect(
179 search.tagsSuggestions().items.map((filter) => filter.id),
180 ).not.toContain('valid')
181​
182 search.clearSelection()
183 search.tagsInputApi().addValue('valid')
184 await Promise.resolve()
185​
186 const validPredicate = activePipeline()[0]!
187 expect(
188 validPredicate(field('invalid', 'field-invalid'), {
189 ...meta(false),
190 validity: 'invalid',
191 }),
192 ).toBe(false)
193 expect(
194 validPredicate(field('hidden', 'field-hidden'), {
195 ...meta(false),
196 validity: 'invalidHidden',
197 }),
198 ).toBe(false)
199 expect(validPredicate(field('valid', 'field-valid'), meta(false))).toBe(
200 true,
201 )
202 })
203​
204 it('filters Blurred and Not blurred rows from hydrated summaries', async () => {
205 let search!: ReturnType<typeof createFieldListSearch>
206 let activePipeline!: () => Array<FieldRowFilterPredicate>
207​
208 const dispose = render(() => {
209 const [query, setQuery] = createSignal('')
210 const [filterPipeline, setFilterPipeline] = createSignal<
211 Array<FieldRowFilterPredicate>
212 >([])
213​
214 activePipeline = filterPipeline
215 search = createFieldListSearch({
216 query,
217 setQuery,
218 setFilterPipeline,
219 })
220​
221 return null
222 }, document.createElement('div'))
223 disposers.push(dispose)
224​
225 search.tagsInputApi().addValue('blurred')
226 await Promise.resolve()
227​
228 const blurredPredicate = activePipeline()[0]!
229 expect(blurredPredicate.usesSummary).toBe(true)
230 expect(
231 blurredPredicate(field('blurred', 'field-blurred'), {
232 ...meta(false),
233 isBlurred: true,
234 }),
235 ).toBe(true)
236 expect(
237 blurredPredicate(field('not-blurred', 'field-not-blurred'), meta(false)),
238 ).toBe(false)
239 expect(
240 search.tagsSuggestions().items.map((filter) => filter.id),
241 ).not.toContain('not-blurred')
242​
243 search.clearSelection()
244 search.tagsInputApi().addValue('not-blurred')
245 await Promise.resolve()
246​
247 const notBlurredPredicate = activePipeline()[0]!
248 expect(
249 notBlurredPredicate(field('blurred', 'field-blurred'), {
250 ...meta(false),
251 isBlurred: true,
252 }),
253 ).toBe(false)
254 expect(
255 notBlurredPredicate(
256 field('not-blurred', 'field-not-blurred'),
257 meta(false),
258 ),
259 ).toBe(true)
260 })
261​
262 it('filters Default and Non-default value rows from hydrated summaries', async () => {
263 let search!: ReturnType<typeof createFieldListSearch>
264 let activePipeline!: () => Array<FieldRowFilterPredicate>
265​
266 const dispose = render(() => {
267 const [query, setQuery] = createSignal('')
268 const [filterPipeline, setFilterPipeline] = createSignal<
269 Array<FieldRowFilterPredicate>
270 >([])
271​
272 activePipeline = filterPipeline
273 search = createFieldListSearch({
274 query,
275 setQuery,
276 setFilterPipeline,
277 })
278​
279 return null
280 }, document.createElement('div'))
281 disposers.push(dispose)
282​
283 search.tagsInputApi().addValue('non-default-value')
284 await Promise.resolve()
285​
286 const nonDefaultPredicate = activePipeline()[0]!
287 expect(nonDefaultPredicate.usesSummary).toBe(true)
288 expect(
289 nonDefaultPredicate(field('changed', 'field-changed'), {
290 ...meta(false),
291 isDefaultValue: false,
292 }),
293 ).toBe(true)
294 expect(
295 nonDefaultPredicate(field('default', 'field-default'), meta(false)),
296 ).toBe(false)
297 expect(
298 search.tagsSuggestions().items.map((filter) => filter.id),
299 ).not.toContain('default-value')
300​
301 search.clearSelection()
302 search.tagsInputApi().addValue('default-value')
303 await Promise.resolve()
304​
305 const defaultPredicate = activePipeline()[0]!
306 expect(
307 defaultPredicate(field('changed', 'field-changed'), {
308 ...meta(false),
309 isDefaultValue: false,
310 }),
311 ).toBe(false)
312 expect(
313 defaultPredicate(field('default', 'field-default'), meta(false)),
314 ).toBe(true)
315 })
316})