Open History to see the last commit
1import { createRoot } from 'solid-js'
2import { afterEach, beforeEach, describe, expect, it } from 'vitest'
3import { defaultDevtoolsMountedFieldSummary } from '../src/fieldSummaryMeta'
4import { createFormDevtoolsStore } from '../src/stores/formDevtoolsStore'
5import type { FormDevtoolsStore } from '../src/stores/formDevtoolsStore'
6import type { FieldRowFilterPredicate } from '../src/stores/fieldListStore'
7import type { DevtoolsMountedFieldScaffold } from '../src/eventClientTypes'
8import type { FormId } from '../src/types/branded'
9β
10const formA = 'form-a' as FormId
11const formB = 'form-b' as FormId
12β
13function field(path: string, fieldId: string): DevtoolsMountedFieldScaffold {
14 return { path, fieldId }
15}
16β
17let fieldList!: FormDevtoolsStore['fieldList']
18let fieldMeta!: FormDevtoolsStore['fieldMeta']
19let disposeStore!: () => void
20β
21beforeEach(() => {
22 createRoot((dispose) => {
23 const store = createFormDevtoolsStore()
24 fieldList = store.fieldList
25 fieldMeta = store.fieldMeta
26 disposeStore = dispose
27 })
28})
29β
30afterEach(() => {
31 fieldList.setSubscribedFormId(null)
32 fieldList.setFieldSearchQuery('')
33 fieldList.setFieldFilterPipeline([])
34 fieldList.clearRows()
35 disposeStore()
36})
37β
38describe('field list store', () => {
39 it('applies snapshots for the subscribed form and sorts rows by path', () => {
40 fieldList.setSubscribedFormId(formA)
41β
42 fieldList.applySnapshot({
43 formInstanceId: formA,
44 fields: [
45 field('items[10].name', 'field-10'),
46 field('user.email', 'field-email'),
47 field('items[2].name', 'field-2'),
48 ],
49 })
50β
51 expect(fieldList.fieldRows().map((row) => row.path)).toEqual([
52 'items[2].name',
53 'items[10].name',
54 'user.email',
55 ])
56 expect(fieldList.rowsByPath().get('user.email')?.fieldId).toBe(
57 'field-email',
58 )
59 expect(fieldList.rowsByFieldId().get('field-2')?.path).toBe('items[2].name')
60 })
61β
62 it('ignores snapshots for other forms', () => {
63 fieldList.setSubscribedFormId(formA)
64β
65 fieldList.applySnapshot({
66 formInstanceId: formB,
67 fields: [field('ignored', 'field-ignored')],
68 })
69β
70 expect(fieldList.fieldRows()).toEqual([])
71 })
72β
73 it('keeps field identity through structural and mounted-state changes', () => {
74 fieldList.setSubscribedFormId(formA)
75 fieldList.applySnapshot({
76 formInstanceId: formA,
77 fields: [
78 field('first', 'field-first'),
79 field('second', 'field-second'),
80 field('first.child', 'field-child'),
81 ],
82 })
83β
84 fieldList.applyPatch({
85 formInstanceId: formA,
86 upsert: [
87 {
88 fieldId: 'field-child',
89 path: 'second.child',
90 },
91 ],
92 })
93β
94 expect(fieldList.rowsByFieldId().get('field-child')).toMatchObject({
95 path: 'second.child',
96 fieldId: 'field-child',
97 })
98β
99 fieldList.applyPatch({
100 formInstanceId: formA,
101 upsert: [{ fieldId: 'field-child', isMounted: false }],
102 })
103β
104 expect(fieldList.rowsByFieldId().get('field-child')).toMatchObject({
105 fieldId: 'field-child',
106 path: 'second.child',
107 isMounted: false,
108 })
109 })
110β
111 it('bypasses default inclusion when filtering by mounted state', () => {
112 fieldList.setSubscribedFormId(formA)
113 fieldList.applySnapshot({
114 formInstanceId: formA,
115 fields: [
116 field('z.mounted', 'field-mounted'),
117 {
118 ...field('a.unmounted.valid', 'field-unmounted-valid'),
119 isMounted: false,
120 },
121 {
122 ...field('b.unmounted.invalid', 'field-unmounted-invalid'),
123 isMounted: false,
124 summary: { validity: 'invalidHidden' },
125 },
126 {
127 ...field('c.unmounted.self-invalid', 'field-unmounted-self-invalid'),
128 isMounted: false,
129 summary: { hasSelfErrors: true, validity: 'invalidHidden' },
130 },
131 ],
132 })
133β
134 expect(fieldList.visibleFieldRows().map((row) => row.path)).toEqual([
135 'c.unmounted.self-invalid',
136 'z.mounted',
137 ])
138 expect(fieldList.selectedFieldRow()).toBeNull()
139 expect(fieldList.mainPanelFieldRows()).toEqual([])
140β
141 const unmountedPredicate: FieldRowFilterPredicate = (row) =>
142 row.isMounted === false
143 unmountedPredicate.bypassesDefaultInclusion = true
144 fieldList.setFieldFilterPipeline([unmountedPredicate])
145β
146 expect(fieldList.visibleFieldRows().map((row) => row.path)).toEqual([
147 'a.unmounted.valid',
148 'b.unmounted.invalid',
149 'c.unmounted.self-invalid',
150 ])
151 })
152β
153 it('stores only non-default summaries and hydrates at consumption', () => {
154 fieldList.setSubscribedFormId(formA)
155 fieldList.applySnapshot({
156 formInstanceId: formA,
157 fields: [
158 field('user.name', 'field-name'),
159 {
160 ...field('user.email', 'field-email'),
161 summary: { isDirty: true },
162 },
163 ],
164 })
165β
166 expect(fieldList.fieldSparseMetaById().size).toBe(1)
167 expect(fieldMeta.getFieldSummary('field-name')).toBe(
168 defaultDevtoolsMountedFieldSummary,
169 )
170 expect(fieldMeta.getFieldSummary('field-email')).toEqual({
171 isDirty: true,
172 isTouched: false,
173 isBlurred: false,
174 isLongValidating: false,
175 isDefaultValue: true,
176 hasSelfErrors: false,
177 validity: 'valid',
178 })
179 expect(fieldMeta.getFieldSummary('another-pristine-field')).toBe(
180 fieldMeta.getFieldSummary('field-name'),
181 )
182 })
183β
184 it('applies meta-only patches without replacing scaffold maps', () => {
185 fieldList.setSubscribedFormId(formA)
186 fieldList.applySnapshot({
187 formInstanceId: formA,
188 fields: [field('user.name', 'field-name')],
189 })
190 const pathMap = fieldList.rowsByPath()
191 const idMap = fieldList.rowsByFieldId()
192β
193 fieldList.applyPatch({
194 formInstanceId: formA,
195 upsert: [{ fieldId: 'field-name', setSummary: { isDirty: true } }],
196 })
197β
198 expect(fieldList.rowsByPath()).toBe(pathMap)
199 expect(fieldList.rowsByFieldId()).toBe(idMap)
200 expect(fieldMeta.getFieldSummary('field-name')).toEqual({
201 isDirty: true,
202 isTouched: false,
203 isBlurred: false,
204 isLongValidating: false,
205 isDefaultValue: true,
206 hasSelfErrors: false,
207 validity: 'valid',
208 })
209β
210 fieldList.applyPatch({
211 formInstanceId: formA,
212 upsert: [{ fieldId: 'field-name', clearSummary: ['isDirty'] }],
213 })
214β
215 expect(fieldList.fieldSparseMetaById().size).toBe(0)
216 expect(fieldMeta.getFieldSummary('field-name')).toBe(
217 defaultDevtoolsMountedFieldSummary,
218 )
219 })
220β
221 it('keeps selection and pins by field identity across path patches', () => {
222 fieldList.setSubscribedFormId(formA)
223 fieldList.applySnapshot({
224 formInstanceId: formA,
225 fields: [field('items[0]', 'field-item')],
226 })
227 fieldList.setSelectedFieldPath('items[0]')
228 fieldList.setFieldPinned('field-item', true)
229β
230 fieldList.applyPatch({
231 formInstanceId: formA,
232 upsert: [{ fieldId: 'field-item', path: 'items[1]' }],
233 })
234β
235 expect(fieldList.selectedFieldPath()).toBe('items[1]')
236 expect(fieldList.pinnedFieldIds()).toEqual(['field-item'])
237 expect(fieldList.rowsByPath().has('items[0]')).toBe(false)
238β
239 fieldList.applyPatch({
240 formInstanceId: formA,
241 remove: ['field-item'],
242 })
243β
244 expect(fieldList.selectedFieldPath()).toBeNull()
245 expect(fieldList.pinnedFieldIds()).toEqual([])
246 expect(fieldList.fieldRows()).toEqual([])
247 })
248β
249 it('applies path swaps atomically without dropping sparse meta or pins', () => {
250 fieldList.setSubscribedFormId(formA)
251 fieldList.applySnapshot({
252 formInstanceId: formA,
253 fields: [
254 { ...field('items[0]', 'field-0'), summary: { isDirty: true } },
255 field('items[1]', 'field-1'),
256 ],
257 })
258 fieldList.setSelectedFieldPath('items[0]')
259 fieldList.setFieldPinned('field-0', true)
260 fieldList.setFieldPinned('field-1', true)
261β
262 fieldList.applyPatch({
263 formInstanceId: formA,
264 upsert: [
265 { fieldId: 'field-0', path: 'items[1]' },
266 { fieldId: 'field-1', path: 'items[0]' },
267 ],
268 })
269β
270 expect(fieldList.selectedFieldPath()).toBe('items[1]')
271 expect(fieldList.pinnedFieldIds()).toEqual(['field-0', 'field-1'])
272 expect(fieldMeta.getFieldSummary('field-0')).toEqual({
273 isDirty: true,
274 isTouched: false,
275 isBlurred: false,
276 isLongValidating: false,
277 isDefaultValue: true,
278 hasSelfErrors: false,
279 validity: 'valid',
280 })
281 expect(fieldList.rowsByPath().get('items[0]')?.fieldId).toBe('field-1')
282 expect(fieldList.rowsByPath().get('items[1]')?.fieldId).toBe('field-0')
283 })
284β
285 it('filters visible rows by field path without changing stored rows', () => {
286 fieldList.setSubscribedFormId(formA)
287 fieldList.applySnapshot({
288 formInstanceId: formA,
289 fields: [
290 field('user.name', 'field-name'),
291 field('user.email', 'field-email'),
292 field('settings.theme', 'field-theme'),
293 ],
294 })
295β
296 fieldList.setFieldSearchQuery('email')
297β
298 expect(fieldList.visibleFieldRows().map((row) => row.path)).toEqual([
299 'user.email',
300 ])
301 expect(fieldList.fieldRows()).toHaveLength(3)
302 })
303β
304 it('exposes a path leaf that stays aligned when a field moves', () => {
305 fieldList.setSubscribedFormId(formA)
306 fieldList.applySnapshot({
307 formInstanceId: formA,
308 fields: [
309 field('user.name', 'field-name'),
310 field('items[0]', 'field-item'),
311 ],
312 })
313β
314 expect(
315 fieldList.visibleFieldRows().map(({ path, pathLeaf }) => ({
316 path,
317 pathLeaf,
318 })),
319 ).toEqual([
320 { path: 'items[0]', pathLeaf: '[0]' },
321 { path: 'user.name', pathLeaf: 'name' },
322 ])
323β
324 fieldList.applyPatch({
325 formInstanceId: formA,
326 upsert: [{ fieldId: 'field-name', path: 'user.email' }],
327 })
328β
329 expect(
330 fieldList
331 .visibleFieldRows()
332 .find(({ fieldId }) => fieldId === 'field-name'),
333 ).toMatchObject({ path: 'user.email', pathLeaf: 'email' })
334 expect(fieldList.rowsByPath().get('user.email')?.pathLeaf).toBe('email')
335 expect(fieldList.rowsByPath().has('user.name')).toBe(false)
336 })
337β
338 it('filters visible rows through each predicate before fuzzy search', () => {
339 fieldList.setSubscribedFormId(formA)
340 fieldList.applySnapshot({
341 formInstanceId: formA,
342 fields: [
343 field('user.name', 'field-name'),
344 field('user.email', 'field-email'),
345 field('settings.theme', 'field-theme'),
346 ],
347 })
348 fieldList.setFieldPinned('field-name', true)
349 fieldList.setFieldPinned('field-theme', true)
350 let predicateCalls = 0
351 fieldList.setFieldFilterPipeline([
352 (row) => {
353 predicateCalls++
354 return fieldList.isFieldPinned(row.fieldId)
355 },
356 (row) => row.path.startsWith('user.'),
357 ])
358β
359 expect(fieldList.visibleFieldRows().map((row) => row.path)).toEqual([
360 'user.name',
361 ])
362 const callsAfterFiltering = predicateCalls
363β
364 fieldList.setFieldSearchQuery('email')
365β
366 expect(fieldList.visibleFieldRows()).toEqual([])
367 expect(predicateCalls).toBe(callsAfterFiltering)
368 expect(fieldList.fieldRows()).toHaveLength(3)
369 })
370β
371 it('does not subscribe filtering to sparse meta without a meta filter', () => {
372 fieldList.setSubscribedFormId(formA)
373 fieldList.applySnapshot({
374 formInstanceId: formA,
375 fields: [field('user.name', 'field-name')],
376 })
377 let predicateCalls = 0
378 fieldList.setFieldFilterPipeline([
379 (row) => {
380 predicateCalls++
381 return row.path.startsWith('user.')
382 },
383 ])
384β
385 expect(fieldList.visibleFieldRows()).toHaveLength(1)
386 const callsBeforeMetaPatch = predicateCalls
387β
388 fieldList.applyPatch({
389 formInstanceId: formA,
390 upsert: [{ fieldId: 'field-name', setSummary: { isDirty: true } }],
391 })
392β
393 expect(fieldList.visibleFieldRows()).toHaveLength(1)
394 expect(predicateCalls).toBe(callsBeforeMetaPatch)
395 })
396β
397 it('clears a stale selected path when a replacement snapshot omits it', () => {
398 fieldList.setSubscribedFormId(formA)
399 fieldList.applySnapshot({
400 formInstanceId: formA,
401 fields: [field('user.name', 'field-name'), field('user.email', 'email')],
402 })
403 fieldList.setSelectedFieldPath('user.email')
404β
405 fieldList.applySnapshot({
406 formInstanceId: formA,
407 fields: [field('user.name', 'field-name')],
408 })
409β
410 expect(fieldList.selectedFieldPath()).toBeNull()
411 expect(fieldList.selectedFieldRow()).toBeNull()
412 })
413β
414 it('tracks pinned fields once and preserves the order they were pinned', () => {
415 fieldList.setFieldPinned('field-name', true)
416 fieldList.setFieldPinned('field-email', true)
417 fieldList.setFieldPinned('field-name', true)
418β
419 expect(fieldList.pinnedFieldIds()).toEqual(['field-name', 'field-email'])
420β
421 fieldList.toggleFieldPinned('field-name')
422β
423 expect(fieldList.pinnedFieldIds()).toEqual(['field-email'])
424 })
425β
426 it('puts the selected field before pinned fields without duplicate cards', () => {
427 fieldList.setSubscribedFormId(formA)
428 fieldList.applySnapshot({
429 formInstanceId: formA,
430 fields: [
431 field('user.name', 'field-name'),
432 field('user.email', 'field-email'),
433 field('settings.theme', 'field-theme'),
434 ],
435 })
436 fieldList.setFieldPinned('field-email', true)
437 fieldList.setFieldPinned('field-name', true)
438 fieldList.setFieldPinned('field-theme', true)
439 fieldList.setSelectedFieldPath('user.name')
440β
441 expect(fieldList.mainPanelFieldRows().map((row) => row.fieldId)).toEqual([
442 'field-name',
443 'field-email',
444 'field-theme',
445 ])
446 })
447β
448 it('drops pins for fields omitted by a replacement snapshot', () => {
449 fieldList.setSubscribedFormId(formA)
450 fieldList.applySnapshot({
451 formInstanceId: formA,
452 fields: [
453 field('user.name', 'field-name'),
454 field('user.email', 'field-email'),
455 ],
456 })
457 fieldList.setFieldPinned('field-name', true)
458 fieldList.setFieldPinned('field-email', true)
459β
460 fieldList.applySnapshot({
461 formInstanceId: formA,
462 fields: [field('user.email', 'field-email')],
463 })
464β
465 expect(fieldList.pinnedFieldIds()).toEqual(['field-email'])
466 })
467})