Open History to see the last commit
1import { bench, describe, expect } from 'vitest'
2import {
3 createNull,
4 deepEqual,
5 isPlainObject,
6 nullReplaceEqualDeep,
7 replaceEqualDeep,
8} from '../src/utils'
9β
10// Shapes the router feeds these helpers on every Link build / navigation.
11const empty = {}
12const emptyNull = createNull()
13const search = { tab: 'specs', page: 2, sort: 'newest', filter: 'available' }
14const searchCopy = { ...search }
15const searchChanged = { ...search, page: 3 }
16// parseSearch and path extraction produce null-prototype records. Exercise
17// these separately from ordinary selector objects: their property storage differs.
18const nullSearch = Object.assign(createNull(), search)
19const nullSearchCopy = Object.assign(createNull(), searchCopy)
20const nullSearchChanged = Object.assign(createNull(), searchChanged)
21const decimalRecord = { x: 0.5, y: 1.5, width: 640.5, height: 480.5 }
22const decimalRecordCopy = { ...decimalRecord }
23const decimalRecordChanged = { ...decimalRecord, x: 1.5 }
24// `?constructor=foo` decodes to an own `constructor` key on a null-proto record.
25const searchWithConstructorKey = Object.assign(createNull(), {
26 constructor: 'foo',
27 page: 2,
28})
29const searchWithConstructorKeyCopy = Object.assign(createNull(), {
30 constructor: 'foo',
31 page: 2,
32})
33class Instance {
34 a = 1
35}
36const instance = new Instance()
37const nested = {
38 tab: 'specs',
39 filters: { category: 'hardware', available: true },
40 ids: [1, 2, 3, 4],
41}
42const nestedCopy = {
43 tab: 'specs',
44 filters: { category: 'hardware', available: true },
45 ids: [1, 2, 3, 4],
46}
47const nestedLeafChanged = {
48 tab: 'specs',
49 filters: { category: 'software', available: true },
50 ids: [1, 2, 3, 4],
51}
52const list = Array.from({ length: 16 }, (_, index) => ({ id: index }))
53const listCopy = list.map((item) => ({ ...item }))
54const listChanged = list.map((item, index) =>
55 index === 10 ? { id: -1 } : { ...item },
56)
57const listShared = list.map((item, index) => (index === 10 ? { id: -1 } : item))
58const wide = Object.fromEntries(
59 Array.from({ length: 12 }, (_, index) => [`key${index}`, `value${index}`]),
60)
61const wideChanged = { ...wide, key7: 'changed' }
62const searchAllChanged = {
63 tab: 'other',
64 page: 3,
65 sort: 'oldest',
66 filter: 'sold',
67}
68const searchReordered = {
69 filter: 'available',
70 sort: 'newest',
71 page: 2,
72 tab: 'specs',
73}
74const searchSubset = { tab: 'specs', page: 2, sort: 'newest' }
75const wider = Object.fromEntries(
76 Array.from({ length: 64 }, (_, index) => [`key${index}`, `value${index}`]),
77)
78const widerChangedLast = { ...wider, key63: 'changed' }
79const widerChangedFirst = { ...wider, key0: 'changed' }
80const widerAllChanged = Object.fromEntries(
81 Object.keys(wider).map((key) => [key, 'changed']),
82)
83const widerSubset = Object.fromEntries(Object.entries(wider).slice(0, 8))
84const numbers = Array.from({ length: 1024 }, (_, index) => index)
85const numbersCopy = [...numbers]
86const numbersChangedLast = numbers.map((n, index) => (index === 1023 ? -1 : n))
87const numbersChangedFirst = numbers.map((n, index) => (index === 0 ? -1 : n))
88const numbersChangedMiddle = numbers.map((n, index) => (index === 512 ? -1 : n))
89const numbersAllChanged = numbers.map((n) => -n - 1)
90const numbersShorter = numbers.slice(0, 512)
91const numbersLonger = [...numbers, undefined, undefined]
92const smallNumbers = [1, 2, 3, 4]
93const smallNumbersChanged = [9, 2, 3, 4]
94const consumedNumbers = replaceEqualDeep(numbers, numbersChangedLast)
95const longList = Array.from({ length: 1024 }, (_, id) => ({ id }))
96const longListCopy = [...longList]
97const longListClonedLast = [...longList]
98longListClonedLast[1023] = { id: 1023 }
99const longListChangedLast = [...longList]
100longListChangedLast[1023] = { id: -1 }
101const longListClonedThenChanged = [...longListChangedLast]
102longListClonedThenChanged[1022] = { id: 1022 }
103const numericCases = [
104 ['fractional', Array.from({ length: 1024 }, (_, index) => index + 0.5)],
105 [
106 'large integer',
107 Array.from({ length: 1024 }, (_, index) => 2 ** 40 + index),
108 ],
109] as const
110const numericResults = numericCases.map(([name, prev]) => {
111 const next = [...prev]
112 next[1023] = -1.5
113 const result = replaceEqualDeep(prev, next)
114 expect(result).toStrictEqual(next)
115 return { name, prev, next, result }
116})
117const mixedPairs: Array<[unknown, unknown]> = [
118 [search, search],
119 [search, searchCopy],
120 [search, searchChanged],
121 [search, searchSubset],
122 [searchSubset, search],
123 [nested, nestedCopy],
124 [list, listChanged],
125 [list, listShared],
126 [smallNumbers, smallNumbersChanged],
127 [emptyNull, createNull()],
128 [searchWithConstructorKey, searchWithConstructorKeyCopy],
129]
130β
131expect(replaceEqualDeep(empty, {})).toBe(empty)
132expect(replaceEqualDeep(search, searchCopy)).toBe(search)
133expect(replaceEqualDeep(search, searchChanged)).toStrictEqual(searchChanged)
134expect(nullReplaceEqualDeep(nullSearch, nullSearchCopy)).toBe(nullSearch)
135expect(nullReplaceEqualDeep(nullSearch, searchCopy)).toBe(nullSearch)
136expect(replaceEqualDeep(decimalRecord, decimalRecordCopy)).toBe(decimalRecord)
137expect(replaceEqualDeep(decimalRecord, decimalRecordChanged)).toStrictEqual(
138 decimalRecordChanged,
139)
140expect(nullReplaceEqualDeep(nullSearch, nullSearchChanged)).toStrictEqual(
141 nullSearchChanged,
142)
143expect(replaceEqualDeep(nested, nestedCopy)).toBe(nested)
144expect(replaceEqualDeep(nested, nestedLeafChanged).ids).toBe(nested.ids)
145const nullNestedResult = nullReplaceEqualDeep(nested, nestedLeafChanged)
146expect(nullNestedResult).toEqual(nestedLeafChanged)
147expect(nullNestedResult.ids).toBe(nested.ids)
148expect(Object.getPrototypeOf(nullNestedResult)).toBeNull()
149expect(replaceEqualDeep(list, listCopy)).toBe(list)
150expect(replaceEqualDeep(list, listChanged)[3]).toBe(list[3])
151expect(replaceEqualDeep(wide, wideChanged)).toStrictEqual(wideChanged)
152expect(replaceEqualDeep(list, listShared)[3]).toBe(list[3])
153expect(replaceEqualDeep(search, searchAllChanged)).toStrictEqual(
154 searchAllChanged,
155)
156expect(replaceEqualDeep(search, searchReordered)).toBe(search)
157expect(replaceEqualDeep(search, searchSubset)).toStrictEqual(searchSubset)
158expect(replaceEqualDeep(wider, widerChangedLast)).toStrictEqual(
159 widerChangedLast,
160)
161expect(replaceEqualDeep(numbers, numbersCopy)).toBe(numbers)
162expect(replaceEqualDeep(longList, longListCopy)).toBe(longList)
163expect(replaceEqualDeep(longList, longListClonedLast)).toBe(longList)
164expect(replaceEqualDeep(longList, longListChangedLast)).toStrictEqual(
165 longListChangedLast,
166)
167const sharedLongList = replaceEqualDeep(longList, longListClonedThenChanged)
168expect(sharedLongList).toStrictEqual(longListClonedThenChanged)
169expect(sharedLongList[1022]).toBe(longList[1022])
170expect(replaceEqualDeep(widerSubset, wider)).toStrictEqual(wider)
171expect(replaceEqualDeep(wider, widerChangedFirst)).toStrictEqual(
172 widerChangedFirst,
173)
174expect(replaceEqualDeep(wider, widerAllChanged)).toStrictEqual(widerAllChanged)
175expect(replaceEqualDeep(numbers, numbersChangedLast)[1023]).toBe(-1)
176for (const [prev, next] of mixedPairs) {
177 expect(replaceEqualDeep(prev, next)).toStrictEqual(next)
178}
179for (const next of [
180 numbersChangedFirst,
181 numbersChangedMiddle,
182 numbersAllChanged,
183 numbersShorter,
184 numbersLonger,
185]) {
186 expect(replaceEqualDeep(numbers, next)).toStrictEqual(next)
187}
188expect(nullReplaceEqualDeep(emptyNull, {})).toBe(emptyNull)
189expect(
190 nullReplaceEqualDeep(searchWithConstructorKey, searchWithConstructorKeyCopy),
191).toBe(searchWithConstructorKey)
192expect(deepEqual(search, searchCopy, true)).toBe(true)
193expect(isPlainObject(search)).toBe(true)
194expect(isPlainObject(emptyNull)).toBe(true)
195expect(isPlainObject(searchWithConstructorKey)).toBe(true)
196expect(isPlainObject(instance)).toBe(false)
197β
198const iterations = 1_000
199let sink: unknown
200β
201describe('isPlainObject', () => {
202 bench('literal', () => {
203 for (let i = 0; i < iterations; i++) {
204 sink = isPlainObject(search)
205 }
206 })
207β
208 bench('null-proto record', () => {
209 for (let i = 0; i < iterations; i++) {
210 sink = isPlainObject(emptyNull)
211 }
212 })
213β
214 bench('null-proto record with a constructor key', () => {
215 for (let i = 0; i < iterations; i++) {
216 sink = isPlainObject(searchWithConstructorKey)
217 }
218 })
219β
220 bench('class instance', () => {
221 for (let i = 0; i < iterations; i++) {
222 sink = isPlainObject(instance)
223 }
224 })
225})
226β
227describe('replaceEqualDeep', () => {
228 bench('equal empty objects', () => {
229 for (let i = 0; i < iterations; i++) {
230 sink = replaceEqualDeep(empty, {})
231 }
232 })
233β
234 bench('equal empty null-proto objects', () => {
235 for (let i = 0; i < iterations; i++) {
236 sink = nullReplaceEqualDeep(emptyNull, createNull())
237 }
238 })
239β
240 bench('equal null-proto search with a constructor key', () => {
241 for (let i = 0; i < iterations; i++) {
242 sink = nullReplaceEqualDeep(
243 searchWithConstructorKey,
244 searchWithConstructorKeyCopy,
245 )
246 }
247 })
248β
249 bench('equal flat search', () => {
250 for (let i = 0; i < iterations; i++) {
251 sink = replaceEqualDeep(search, searchCopy)
252 }
253 })
254β
255 bench('flat search with one changed leaf', () => {
256 for (let i = 0; i < iterations; i++) {
257 sink = replaceEqualDeep(search, searchChanged)
258 }
259 })
260β
261 bench('equal parsed null-proto search', () => {
262 for (let i = 0; i < iterations; i++) {
263 sink = nullReplaceEqualDeep(nullSearch, nullSearchCopy)
264 }
265 })
266β
267 bench('equal ordinary search against a null-proto previous value', () => {
268 for (let i = 0; i < iterations; i++) {
269 sink = nullReplaceEqualDeep(nullSearch, searchCopy)
270 }
271 })
272β
273 bench('parsed null-proto search with one changed leaf', () => {
274 for (let i = 0; i < iterations; i++) {
275 sink = nullReplaceEqualDeep(nullSearch, nullSearchChanged)
276 }
277 })
278β
279 bench('ordinary search update in null-proto mode', () => {
280 for (let i = 0; i < iterations; i++) {
281 sink = nullReplaceEqualDeep(nullSearch, searchChanged)
282 }
283 })
284β
285 bench('equal ordinary search in null-proto mode', () => {
286 for (let i = 0; i < iterations; i++) {
287 sink = nullReplaceEqualDeep(search, searchCopy)
288 }
289 })
290β
291 bench('successive ordinary search update in null-proto mode', () => {
292 for (let i = 0; i < iterations; i++) {
293 sink = nullReplaceEqualDeep(search, searchChanged)
294 }
295 })
296β
297 bench('changed selector followed by the same incoming reference', () => {
298 for (let i = 0; i < iterations; i++) {
299 const current = replaceEqualDeep(search, searchChanged)
300 sink = replaceEqualDeep(current, searchChanged)
301 }
302 })
303β
304 bench('equal record with decimal values', () => {
305 for (let i = 0; i < iterations; i++) {
306 sink = replaceEqualDeep(decimalRecord, decimalRecordCopy)
307 }
308 })
309β
310 bench('changed record with decimal values', () => {
311 for (let i = 0; i < iterations; i++) {
312 sink = replaceEqualDeep(decimalRecord, decimalRecordChanged)
313 }
314 })
315β
316 bench('equal nested search', () => {
317 for (let i = 0; i < iterations; i++) {
318 sink = replaceEqualDeep(nested, nestedCopy)
319 }
320 })
321β
322 bench('nested search sharing unchanged subtrees', () => {
323 for (let i = 0; i < iterations; i++) {
324 sink = replaceEqualDeep(nested, nestedLeafChanged)
325 }
326 })
327β
328 bench('nested search sharing unchanged subtrees in null-proto mode', () => {
329 for (let i = 0; i < iterations; i++) {
330 sink = nullReplaceEqualDeep(nested, nestedLeafChanged)
331 }
332 })
333β
334 bench('equal array of objects', () => {
335 for (let i = 0; i < iterations; i++) {
336 sink = replaceEqualDeep(list, listCopy)
337 }
338 })
339β
340 bench('array of objects with one changed item', () => {
341 for (let i = 0; i < iterations; i++) {
342 sink = replaceEqualDeep(list, listChanged)
343 }
344 })
345β
346 bench('wide flat object with one changed leaf', () => {
347 for (let i = 0; i < iterations; i++) {
348 sink = replaceEqualDeep(wide, wideChanged)
349 }
350 })
351β
352 bench('wide flat object with one changed leaf (null-proto)', () => {
353 for (let i = 0; i < iterations; i++) {
354 sink = nullReplaceEqualDeep(wide, wideChanged)
355 }
356 })
357β
358 bench('flat search with all leaves changed', () => {
359 for (let i = 0; i < iterations; i++) {
360 sink = replaceEqualDeep(search, searchAllChanged)
361 }
362 })
363β
364 bench('equal flat search with reordered keys', () => {
365 for (let i = 0; i < iterations; i++) {
366 sink = replaceEqualDeep(search, searchReordered)
367 }
368 })
369β
370 bench('flat search with a key removed', () => {
371 for (let i = 0; i < iterations; i++) {
372 sink = replaceEqualDeep(search, searchSubset)
373 }
374 })
375β
376 bench('array of shared objects with one changed item', () => {
377 for (let i = 0; i < iterations; i++) {
378 sink = replaceEqualDeep(list, listShared)
379 }
380 })
381β
382 bench('wider flat object (64 keys) with the last leaf changed', () => {
383 for (let i = 0; i < iterations; i++) {
384 sink = replaceEqualDeep(wider, widerChangedLast)
385 }
386 })
387β
388 bench('flat object growing from 8 to 64 keys', () => {
389 for (let i = 0; i < iterations; i++) {
390 sink = replaceEqualDeep(widerSubset, wider)
391 }
392 })
393β
394 for (const [name, next] of [
395 ['first leaf changed', widerChangedFirst],
396 ['all leaves changed', widerAllChanged],
397 ] as const) {
398 bench(`wider flat object (64 keys) with ${name}`, () => {
399 for (let i = 0; i < iterations; i++) {
400 sink = replaceEqualDeep(wider, next)
401 }
402 })
403 }
404β
405 bench('equal long array of shared objects', () => {
406 for (let i = 0; i < iterations; i++) {
407 sink = replaceEqualDeep(longList, longListCopy)
408 }
409 })
410β
411 for (const [name, next] of [
412 ['cloned but equal', longListClonedLast],
413 ['changed', longListChangedLast],
414 ['changed after a cloned but equal item', longListClonedThenChanged],
415 ] as const) {
416 bench(`long array of shared objects with the last item ${name}`, () => {
417 for (let i = 0; i < iterations; i++) {
418 sink = replaceEqualDeep(longList, next)
419 }
420 })
421 }
422β
423 for (const length of [0, 1, 4]) {
424 const prev = Array.from({ length }, (_, index) => index)
425 const next = [...prev]
426 expect(replaceEqualDeep(prev, next)).toBe(prev)
427 bench(`equal primitive array of length ${length}`, () => {
428 for (let i = 0; i < iterations; i++) {
429 sink = replaceEqualDeep(prev, next)
430 }
431 })
432 }
433β
434 bench('equal long primitive array', () => {
435 for (let i = 0; i < iterations; i++) {
436 sink = replaceEqualDeep(numbers, numbersCopy)
437 }
438 })
439β
440 bench('long primitive array with the last item changed', () => {
441 for (let i = 0; i < iterations; i++) {
442 sink = replaceEqualDeep(numbers, numbersChangedLast)
443 }
444 })
445β
446 for (const [name, next] of [
447 ['first item changed', numbersChangedFirst],
448 ['middle item changed', numbersChangedMiddle],
449 ['all items changed', numbersAllChanged],
450 ['shortened', numbersShorter],
451 ['appended undefined values', numbersLonger],
452 ] as const) {
453 bench(`long primitive array with ${name}`, () => {
454 for (let i = 0; i < iterations; i++) {
455 sink = replaceEqualDeep(numbers, next)
456 }
457 })
458 }
459β
460 bench('small primitive array with the first item changed', () => {
461 for (let i = 0; i < iterations; i++) {
462 sink = replaceEqualDeep(smallNumbers, smallNumbersChanged)
463 }
464 })
465β
466 bench('mixed search and array updates', () => {
467 for (let i = 0; i < iterations; i++) {
468 const [prev, next] = mixedPairs[i % mixedPairs.length]!
469 sink = replaceEqualDeep(prev, next)
470 }
471 })
472β
473 for (const { name, prev, next } of numericResults) {
474 bench(`long ${name} array with the last item changed`, () => {
475 for (let i = 0; i < iterations; i++) {
476 sink = replaceEqualDeep(prev, next)
477 }
478 })
479 }
480})
481β
482describe('consume structurally shared arrays', () => {
483 bench('sum changed primitive array by index', () => {
484 for (let i = 0; i < iterations; i++) {
485 let sum = 0
486 for (let j = 0; j < consumedNumbers.length; j++) {
487 sum += consumedNumbers[j]!
488 }
489 sink = sum
490 }
491 })
492β
493 bench('reduce changed primitive array', () => {
494 for (let i = 0; i < iterations; i++) {
495 sink = consumedNumbers.reduce((sum, value) => sum + value, 0)
496 }
497 })
498β
499 for (const { name, result } of numericResults) {
500 bench(`sum changed ${name} array by index`, () => {
501 for (let i = 0; i < iterations; i++) {
502 let sum = 0
503 for (let j = 0; j < result.length; j++) {
504 sum += result[j]!
505 }
506 sink = sum
507 }
508 })
509β
510 bench(`reduce changed ${name} array`, () => {
511 for (let i = 0; i < iterations; i++) {
512 sink = result.reduce((sum, value) => sum + value, 0)
513 }
514 })
515 }
516})
517β
518describe('deepEqual', () => {
519 bench('equal empty objects', () => {
520 for (let i = 0; i < iterations; i++) {
521 sink = deepEqual(empty, {})
522 }
523 })
524β
525 bench('equal flat search (partial)', () => {
526 for (let i = 0; i < iterations; i++) {
527 sink = deepEqual(search, searchCopy, true)
528 }
529 })
530β
531 bench('nested search with one changed leaf', () => {
532 for (let i = 0; i < iterations; i++) {
533 sink = deepEqual(nested, nestedLeafChanged)
534 }
535 })
536})
537β
538export { sink }