@sigil-dev/runtime 0.9.21 → 0.9.23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/index.test.ts DELETED
@@ -1,2089 +0,0 @@
1
- import { describe, expect, test } from "bun:test";
2
- import {
3
- applyDirective,
4
- batch,
5
- claim,
6
- claimComment,
7
- claimText,
8
- collectEffects,
9
- createEffect,
10
- createEffectPre,
11
- createInspectEffect,
12
- createMemo,
13
- createProfilerEffect,
14
- createRawSignal,
15
- createResource,
16
- createRoot,
17
- createSignal,
18
- easeInCubic,
19
- easeInOutCubic,
20
- easeInOutQuad,
21
- easeInOutQuart,
22
- easeInOutQuint,
23
- easeInOutSine,
24
- easeInQuad,
25
- easeInQuart,
26
- easeInQuint,
27
- easeInSine,
28
- easeOutCubic,
29
- easeOutQuad,
30
- easeOutQuart,
31
- easeOutQuint,
32
- easeOutSine,
33
- hydrateKeyedList,
34
- linear,
35
- ReactiveMap,
36
- ReactiveSet,
37
- reconcile,
38
- setProp,
39
- snapshot,
40
- tick,
41
- tracking,
42
- untrack,
43
- withEffectScope,
44
- } from "./index.ts";
45
- import { mountTransition, removeAnimated } from "./transition.ts";
46
-
47
- // Minimal DOM mock for reconcile tests
48
- class MockNode {
49
- parentNode: MockNode | null = null;
50
- children: MockNode[] = [];
51
- name: string;
52
- constructor(name: string) {
53
- this.name = name;
54
- }
55
- before(node: MockNode) {
56
- // Remove from old parent
57
- if (node.parentNode) {
58
- const idx = node.parentNode.children.indexOf(node);
59
- if (idx >= 0) node.parentNode.children.splice(idx, 1);
60
- }
61
- // Insert before this node in parent
62
- if (this.parentNode) {
63
- const idx = this.parentNode.children.indexOf(this);
64
- this.parentNode.children.splice(idx, 0, node);
65
- node.parentNode = this.parentNode;
66
- }
67
- }
68
- removeChild(node: MockNode) {
69
- const idx = this.children.indexOf(node);
70
- if (idx >= 0) this.children.splice(idx, 1);
71
- node.parentNode = null;
72
- }
73
- toString() {
74
- return this.name;
75
- }
76
- }
77
- class MockComment extends MockNode {
78
- constructor() {
79
- super("");
80
- }
81
- }
82
- class MockElement extends MockNode {}
83
-
84
- function nodeNames(parent: MockNode): string[] {
85
- return parent.children.filter((c) => c.name !== "").map((c) => c.name);
86
- }
87
-
88
- describe("Runtime", () => {
89
- describe("Basic reactivity", () => {
90
- describe("createSignal", () => {
91
- test("returns initial value", () => {
92
- const count = createSignal(0);
93
- expect(count()).toBe(0);
94
- });
95
-
96
- test("updates on set", () => {
97
- const count = createSignal(0);
98
- count.set(5);
99
- expect(count()).toBe(5);
100
- });
101
- });
102
-
103
- describe("createEffect", () => {
104
- test("runs immediately", () => {
105
- const count = createSignal(0);
106
- let seen = -1;
107
- createEffect(() => {
108
- seen = count();
109
- });
110
- expect(seen).toBe(0);
111
- });
112
-
113
- test("reruns on signal change", () => {
114
- const count = createSignal(0);
115
- let seen = -1;
116
- createEffect(() => {
117
- seen = count();
118
- });
119
- batch(() => {
120
- count.set(5);
121
- });
122
- expect(seen).toBe(5);
123
- });
124
- });
125
-
126
- describe("createMemo", () => {
127
- test("derives value", () => {
128
- const count = createSignal(2);
129
- const doubled = createMemo(() => count() * 2);
130
- expect(doubled()).toBe(4);
131
- });
132
-
133
- test("updates when dependency changes", () => {
134
- const count = createSignal(2);
135
- const doubled = createMemo(() => count() * 2);
136
- batch(() => {
137
- count.set(5);
138
- });
139
- expect(doubled()).toBe(10);
140
- });
141
- });
142
- });
143
-
144
- describe("reconcile", () => {
145
- function setup() {
146
- const parent = new MockElement("parent");
147
- const anchor = new MockComment();
148
- parent.children.push(anchor);
149
- anchor.parentNode = parent;
150
- const keyMap = new Map<unknown, MockNode>();
151
- return { parent, anchor, keyMap };
152
- }
153
-
154
- /** Cast wrapper — MockNode/MockElement satisfy the DOM APIs reconcile actually uses */
155
- function mockReconcile<T>(
156
- anchor: MockComment,
157
- keyMap: Map<unknown, MockNode>,
158
- newItems: T[],
159
- getKey: (item: T) => unknown,
160
- createNode: (item: T) => MockNode,
161
- ) {
162
- reconcile(
163
- anchor as unknown as Comment,
164
- keyMap as unknown as Map<unknown, Node>,
165
- newItems,
166
- getKey,
167
- createNode as unknown as (item: T) => Node,
168
- );
169
- }
170
-
171
- test("inserts initial items", () => {
172
- const { parent, anchor, keyMap } = setup();
173
- const items = [
174
- { id: 1, text: "a" },
175
- { id: 2, text: "b" },
176
- ];
177
-
178
- mockReconcile(
179
- anchor,
180
- keyMap,
181
- items,
182
- (i) => i.id,
183
- (i) => new MockElement(i.text),
184
- );
185
-
186
- expect(nodeNames(parent)).toEqual(["a", "b"]);
187
- expect(keyMap.size).toBe(2);
188
- });
189
-
190
- test("reuses nodes with same key", () => {
191
- const { parent, anchor, keyMap } = setup();
192
- const items = [
193
- { id: 1, text: "a" },
194
- { id: 2, text: "b" },
195
- ];
196
-
197
- mockReconcile(
198
- anchor,
199
- keyMap,
200
- items,
201
- (i) => i.id,
202
- (i) => new MockElement(i.text),
203
- );
204
- const nodeA = keyMap.get(1);
205
-
206
- mockReconcile(
207
- anchor,
208
- keyMap,
209
- items,
210
- (i) => i.id,
211
- (i) => new MockElement(i.text),
212
- );
213
-
214
- expect(keyMap.get(1)).toBe(nodeA);
215
- expect(nodeNames(parent)).toEqual(["a", "b"]);
216
- });
217
-
218
- test("removes deleted items", () => {
219
- const { parent, anchor, keyMap } = setup();
220
- mockReconcile(
221
- anchor,
222
- keyMap,
223
- [{ id: 1 }, { id: 2 }, { id: 3 }],
224
- (i) => i.id,
225
- (i) => new MockElement(`n${i.id}`),
226
- );
227
- expect(nodeNames(parent)).toEqual(["n1", "n2", "n3"]);
228
-
229
- mockReconcile(
230
- anchor,
231
- keyMap,
232
- [{ id: 1 }, { id: 3 }],
233
- (i) => i.id,
234
- (i) => new MockElement(`n${i.id}`),
235
- );
236
-
237
- expect(nodeNames(parent)).toEqual(["n1", "n3"]);
238
- expect(keyMap.has(2)).toBe(false);
239
- });
240
-
241
- test("moves nodes to new order", () => {
242
- const { parent, anchor, keyMap } = setup();
243
- const i1 = { id: 1 };
244
- const i2 = { id: 2 };
245
- const i3 = { id: 3 };
246
- mockReconcile(
247
- anchor,
248
- keyMap,
249
- [i1, i2, i3],
250
- (i) => i.id,
251
- (i) => new MockElement(`n${i.id}`),
252
- );
253
- const node1 = keyMap.get(1);
254
- const node2 = keyMap.get(2);
255
- const node3 = keyMap.get(3);
256
-
257
- mockReconcile(
258
- anchor,
259
- keyMap,
260
- [i3, i2, i1],
261
- (i) => i.id,
262
- (i) => new MockElement(`n${i.id}`),
263
- );
264
-
265
- expect(keyMap.get(1)).toBe(node1);
266
- expect(keyMap.get(2)).toBe(node2);
267
- expect(keyMap.get(3)).toBe(node3);
268
- expect(nodeNames(parent)).toEqual(["n3", "n2", "n1"]);
269
- });
270
-
271
- test("rebuilds node when item instance changes under same key", () => {
272
- const { parent, anchor, keyMap } = setup();
273
- mockReconcile(
274
- anchor,
275
- keyMap,
276
- [{ id: 1, text: "old" }],
277
- (i) => i.id,
278
- (i) => new MockElement(i.text),
279
- );
280
- const oldNode = keyMap.get(1);
281
-
282
- // immutable-style update: same key, fresh object → node must swap
283
- mockReconcile(
284
- anchor,
285
- keyMap,
286
- [{ id: 1, text: "new" }],
287
- (i) => i.id,
288
- (i) => new MockElement(i.text),
289
- );
290
-
291
- expect(keyMap.get(1)).not.toBe(oldNode);
292
- expect(nodeNames(parent)).toEqual(["new"]);
293
- });
294
-
295
- test("handles mixed add/remove/reorder", () => {
296
- const { parent, anchor, keyMap } = setup();
297
- const i1 = { id: 1 };
298
- const i3 = { id: 3 };
299
- mockReconcile(
300
- anchor,
301
- keyMap,
302
- [i1, { id: 2 }, i3],
303
- (i) => i.id,
304
- (i) => new MockElement(`n${i.id}`),
305
- );
306
- const node1 = keyMap.get(1);
307
- const node3 = keyMap.get(3);
308
-
309
- mockReconcile(
310
- anchor,
311
- keyMap,
312
- [{ id: 4 }, i3, i1],
313
- (i) => i.id,
314
- (i) => new MockElement(`n${i.id}`),
315
- );
316
-
317
- expect(keyMap.has(2)).toBe(false);
318
- expect(keyMap.get(1)).toBe(node1);
319
- expect(keyMap.get(3)).toBe(node3);
320
- expect(keyMap.has(4)).toBe(true);
321
- expect(nodeNames(parent)).toEqual(["n4", "n3", "n1"]);
322
- });
323
-
324
- test("empty list removes all", () => {
325
- const { parent, anchor, keyMap } = setup();
326
- mockReconcile(
327
- anchor,
328
- keyMap,
329
- [{ id: 1 }, { id: 2 }],
330
- (i) => i.id,
331
- (i) => new MockElement(`n${i.id}`),
332
- );
333
- expect(nodeNames(parent)).toEqual(["n1", "n2"]);
334
-
335
- mockReconcile(
336
- anchor,
337
- keyMap,
338
- [] as { id: number }[],
339
- (i) => i.id,
340
- (i) => new MockElement(`n${i.id}`),
341
- );
342
-
343
- expect(nodeNames(parent)).toEqual([]);
344
- expect(keyMap.size).toBe(0);
345
- });
346
-
347
- test("from empty to populated", () => {
348
- const { parent, anchor, keyMap } = setup();
349
- expect(nodeNames(parent)).toEqual([]);
350
-
351
- mockReconcile(
352
- anchor,
353
- keyMap,
354
- [{ id: 1 }, { id: 2 }],
355
- (i) => i.id,
356
- (i) => new MockElement(`n${i.id}`),
357
- );
358
-
359
- expect(nodeNames(parent)).toEqual(["n1", "n2"]);
360
- });
361
-
362
- test("preserves anchor position", () => {
363
- const { parent, anchor, keyMap } = setup();
364
- const header = new MockElement("header");
365
- anchor.before(header);
366
-
367
- mockReconcile(
368
- anchor,
369
- keyMap,
370
- [{ id: 1 }],
371
- (i) => i.id,
372
- () => new MockElement("item"),
373
- );
374
-
375
- expect(nodeNames(parent)).toEqual(["header", "item"]);
376
- });
377
- });
378
-
379
- test("effect cleanup runs before rerun", () => {
380
- const count = createSignal(0);
381
- const log: string[] = [];
382
- createEffect(() => {
383
- count(); // subscribe
384
- return () => log.push("cleanup");
385
- });
386
- count.set(1);
387
- count.set(2);
388
- batch(() => {});
389
- expect(log).toEqual(["cleanup"]);
390
- });
391
-
392
- test("disposer stops effect", () => {
393
- const count = createSignal(0);
394
- let runs = 0;
395
- const stop = createEffect(() => {
396
- count();
397
- runs++;
398
- });
399
- batch(() => {
400
- count.set(1);
401
- });
402
- stop();
403
- batch(() => {
404
- count.set(2);
405
- });
406
- expect(runs).toBe(2); // initial + one update, not three
407
- });
408
-
409
- test("cleanup runs on dispose", () => {
410
- let cleaned = false;
411
- const stop = createEffect(() => () => {
412
- cleaned = true;
413
- });
414
- stop();
415
- expect(cleaned).toBe(true);
416
- });
417
- });
418
-
419
- describe("batch", () => {
420
- test("multiple signals in batch trigger effect once", () => {
421
- const count = createSignal(0);
422
- const name = createSignal("a");
423
- let runs = 0;
424
- createEffect(() => {
425
- count();
426
- name();
427
- runs++;
428
- });
429
- expect(runs).toBe(1); // initial run
430
-
431
- batch(() => {
432
- count.set(1);
433
- name.set("b");
434
- });
435
- expect(runs).toBe(2); // one run, not two
436
- });
437
-
438
- test("nested batches flush on outermost exit", () => {
439
- const count = createSignal(0);
440
- let runs = 0;
441
- createEffect(() => {
442
- count();
443
- runs++;
444
- });
445
-
446
- batch(() => {
447
- batch(() => {
448
- count.set(1);
449
- });
450
- count.set(2); // still inside outer batch
451
- });
452
- expect(runs).toBe(2); // one run after outer exits
453
- });
454
-
455
- test("outside batch auto-batches to microtask", () => {
456
- const count = createSignal(0);
457
- let runs = 0;
458
- createEffect(() => {
459
- count();
460
- runs++;
461
- });
462
-
463
- count.set(1);
464
- count.set(2);
465
- // Without batch, effects are auto-batched — no synchronous run
466
- expect(runs).toBe(1); // initial only
467
-
468
- batch(() => {});
469
- expect(runs).toBe(2); // initial + one batched update (last write wins)
470
- });
471
- });
472
-
473
- describe("createSignal with objects", () => {
474
- test("property read returns value", () => {
475
- const state = createSignal({ name: "Alice" });
476
- expect(state().name).toBe("Alice");
477
- });
478
-
479
- test("property write triggers effect", () => {
480
- const state = createSignal({ name: "Alice" });
481
- let seen = "";
482
- createEffect(() => {
483
- seen = state().name;
484
- });
485
- expect(seen).toBe("Alice");
486
- batch(() => {
487
- state().name = "Bob";
488
- });
489
- expect(seen).toBe("Bob");
490
- });
491
-
492
- test("unrelated property change does not trigger effect", () => {
493
- const state = createSignal({ name: "Alice", age: 30 });
494
- let runs = 0;
495
- createEffect(() => {
496
- state().name;
497
- runs++;
498
- });
499
- expect(runs).toBe(1);
500
- batch(() => {
501
- state().age = 31;
502
- });
503
- expect(runs).toBe(1);
504
- batch(() => {
505
- state().name = "Bob";
506
- });
507
- expect(runs).toBe(2);
508
- });
509
-
510
- test("deeply nested property access is reactive", () => {
511
- const state = createSignal({ user: { address: { city: "NYC" } } });
512
- let seen = "";
513
- createEffect(() => {
514
- seen = state().user.address.city;
515
- });
516
- expect(seen).toBe("NYC");
517
- batch(() => {
518
- state().user.address.city = "LA";
519
- });
520
- expect(seen).toBe("LA");
521
- });
522
-
523
- test("proxyCache deduplication — same proxy for repeated nested access", () => {
524
- const state = createSignal({ address: { city: "Agartha" } });
525
- const a1 = state().address;
526
- const a2 = state().address;
527
- expect(a1).toBe(a2);
528
-
529
- let seen = "";
530
- createEffect(() => {
531
- seen = state().address.city;
532
- });
533
- expect(seen).toBe("Agartha");
534
- batch(() => {
535
- state().address.city = "Hyperborea";
536
- });
537
- expect(seen).toBe("Hyperborea");
538
- });
539
-
540
- test(".set() replaces entire object", () => {
541
- const state = createSignal({ name: "Alice", age: 30 });
542
- let seen = "";
543
- createEffect(() => {
544
- seen = state().name;
545
- });
546
- expect(seen).toBe("Alice");
547
- batch(() => {
548
- state.set({ name: "Charlie", age: 25 });
549
- });
550
- expect(seen).toBe("Charlie");
551
- });
552
-
553
- test(".peek() reads without tracking", () => {
554
- const state = createSignal({ name: "Alice" });
555
- let runs = 0;
556
- createEffect(() => {
557
- state.peek();
558
- runs++;
559
- });
560
- expect(runs).toBe(1);
561
- batch(() => {
562
- state().name = "Bob";
563
- });
564
- expect(runs).toBe(1);
565
- });
566
-
567
- test("JSON.stringify works on proxy", () => {
568
- const state = createSignal({ name: "Alice", age: 30 });
569
- expect(JSON.stringify(state())).toBe('{"name":"Alice","age":30}');
570
- });
571
-
572
- test("Object.keys works on proxy", () => {
573
- const state = createSignal({ name: "Alice", age: 30 });
574
- expect(Object.keys(state())).toEqual(["name", "age"]);
575
- });
576
-
577
- test("spread works on proxy", () => {
578
- const state = createSignal({ name: "Alice" });
579
- const copy = { ...state() };
580
- expect(copy).toEqual({ name: "Alice" });
581
- });
582
- });
583
-
584
- describe("createSignal with arrays", () => {
585
- test("length is reactive", () => {
586
- const items = createSignal([1, 2, 3]);
587
- let len = 0;
588
- createEffect(() => {
589
- len = items().length;
590
- });
591
- expect(len).toBe(3);
592
- batch(() => {
593
- items().push(4);
594
- });
595
- expect(len).toBe(4);
596
- });
597
-
598
- test("index access is reactive", () => {
599
- const items = createSignal([1, 2, 3]);
600
- let first = 0;
601
- createEffect(() => {
602
- //@ts-expect-error the assertion for that is below
603
- first = items()[0];
604
- });
605
- expect(first).toBe(1);
606
- batch(() => {
607
- items()[0] = 99;
608
- });
609
- expect(first).toBe(99);
610
- });
611
-
612
- test("push triggers effects that read length", () => {
613
- const items = createSignal<number[]>([]);
614
- let seen: number[] = [];
615
- createEffect(() => {
616
- seen = [...items()];
617
- });
618
- expect(seen).toEqual([]);
619
- batch(() => {
620
- items().push(1);
621
- });
622
- expect(seen).toEqual([1]);
623
- batch(() => {
624
- items().push(2);
625
- });
626
- expect(seen).toEqual([1, 2]);
627
- });
628
-
629
- test("pop triggers length effect", () => {
630
- const items = createSignal([1, 2, 3]);
631
- let len = 0;
632
- createEffect(() => {
633
- len = items().length;
634
- });
635
- expect(len).toBe(3);
636
- batch(() => {
637
- items().pop();
638
- });
639
- expect(len).toBe(2);
640
- });
641
-
642
- test("splice triggers effects", () => {
643
- const items = createSignal([1, 2, 3, 4]);
644
- let seen: number[] = [];
645
- createEffect(() => {
646
- seen = [...items()];
647
- });
648
- batch(() => {
649
- items().splice(1, 2);
650
- });
651
- expect(seen).toEqual([1, 4]);
652
- });
653
-
654
- test("push + $derived recomputes", () => {
655
- const items = createSignal([1, 2, 3]);
656
- const doubled = createMemo(() => items().map((x) => x * 2));
657
- expect(doubled()).toEqual([2, 4, 6]);
658
- batch(() => {
659
- items().push(4);
660
- });
661
- expect(doubled()).toEqual([2, 4, 6, 8]);
662
- });
663
- });
664
-
665
- describe("proxy edge cases", () => {
666
- test("null is not proxied", () => {
667
- const state = createSignal(null);
668
- expect(typeof state).toBe("function");
669
- expect(state()).toBe(null);
670
- });
671
-
672
- test("nested arrays in objects are reactive", () => {
673
- const state = createSignal({ items: [1, 2, 3] });
674
- let seen: number[] = [];
675
- createEffect(() => {
676
- seen = [...state().items];
677
- });
678
- expect(seen).toEqual([1, 2, 3]);
679
- batch(() => {
680
- state().items.push(4);
681
- });
682
- expect(seen).toEqual([1, 2, 3, 4]);
683
- });
684
-
685
- test("multiple effects on same object, independent keys", () => {
686
- const state = createSignal({ x: 0, y: 0 });
687
- let xSeen = 0,
688
- ySeen = 0,
689
- xRuns = 0,
690
- yRuns = 0;
691
- createEffect(() => {
692
- xSeen = state().x;
693
- xRuns++;
694
- });
695
- createEffect(() => {
696
- ySeen = state().y;
697
- yRuns++;
698
- });
699
- expect(xRuns).toBe(1);
700
- expect(yRuns).toBe(1);
701
-
702
- batch(() => {
703
- state().x = 5;
704
- });
705
- expect(xSeen).toBe(5);
706
- expect(ySeen).toBe(0);
707
- expect(xRuns).toBe(2);
708
- expect(yRuns).toBe(1);
709
-
710
- batch(() => {
711
- state().y = 10;
712
- });
713
- expect(xSeen).toBe(5);
714
- expect(ySeen).toBe(10);
715
- expect(xRuns).toBe(2);
716
- expect(yRuns).toBe(2);
717
- });
718
- });
719
-
720
- describe("claim", () => {
721
- test("claims an element by tag name and removes from pool", () => {
722
- const div = document.createElement("div");
723
- const span = document.createElement("span");
724
- const pool: ChildNode[] = [div, span];
725
- const result = claim(pool, "div");
726
- expect(result).toBe(div);
727
- expect(pool).toEqual([span]);
728
- });
729
-
730
- test("falls back to createElement when no match", () => {
731
- const span = document.createElement("span");
732
- const pool: ChildNode[] = [span];
733
- const result = claim(pool, "div");
734
- expect(result.tagName).toBe("DIV");
735
- expect(pool).toEqual([span]);
736
- });
737
-
738
- test("claims first match only", () => {
739
- const d1 = document.createElement("div");
740
- const d2 = document.createElement("div");
741
- const pool: ChildNode[] = [d1, d2];
742
- const result = claim(pool, "div");
743
- expect(result).toBe(d1);
744
- expect(pool).toEqual([d2]);
745
- });
746
-
747
- test("is case-insensitive on tag comparison", () => {
748
- const svg = document.createElement("SVG");
749
- const pool: ChildNode[] = [svg];
750
- const result = claim(pool, "svg");
751
- expect(result).toBe(svg);
752
- });
753
-
754
- test("returns empty pool after claiming all matches", () => {
755
- const div = document.createElement("div");
756
- const pool: ChildNode[] = [div];
757
- claim(pool, "div");
758
- expect(pool).toEqual([]);
759
- });
760
-
761
- test("handles empty pool", () => {
762
- const pool: ChildNode[] = [];
763
- const result = claim(pool, "div");
764
- expect(result.tagName).toBe("DIV");
765
- expect(pool).toEqual([]);
766
- });
767
-
768
- test("creates svg in the SVG namespace on empty pool", () => {
769
- const result = claim([], "svg");
770
- expect(result.namespaceURI).toBe("http://www.w3.org/2000/svg");
771
- });
772
-
773
- test("creates svg children in the SVG namespace via parent", () => {
774
- const svg = claim([], "svg");
775
- const path = claim([], "path", svg);
776
- expect(path.namespaceURI).toBe("http://www.w3.org/2000/svg");
777
- });
778
-
779
- test("keeps HTML elements in the HTML namespace", () => {
780
- const result = claim([], "div");
781
- expect(result.namespaceURI).toBe("http://www.w3.org/1999/xhtml");
782
- });
783
- });
784
-
785
- describe("setProp", () => {
786
- test("sets svg attributes without throwing", () => {
787
- const svg = claim([], "svg");
788
- expect(() => setProp(svg, "width", 15)).not.toThrow();
789
- expect(svg.getAttribute("width")).toBe("15");
790
- });
791
-
792
- test("maps className to class on svg", () => {
793
- const svg = claim([], "svg");
794
- setProp(svg, "className", "icon");
795
- expect(svg.getAttribute("class")).toBe("icon");
796
- });
797
-
798
- test("removes svg attribute on false/null", () => {
799
- const svg = claim([], "svg");
800
- setProp(svg, "width", 15);
801
- setProp(svg, "width", false);
802
- expect(svg.hasAttribute("width")).toBe(false);
803
- });
804
-
805
- test("keeps property semantics on HTML elements", () => {
806
- const input = claim([], "input") as HTMLInputElement;
807
- setProp(input, "value", "hello");
808
- expect(input.value).toBe("hello");
809
- });
810
-
811
- test("routes getter-only HTML properties through setAttribute", () => {
812
- const input = claim([], "input") as HTMLInputElement;
813
- expect(() => setProp(input, "list", "people")).not.toThrow();
814
- expect(input.getAttribute("list")).toBe("people");
815
- setProp(input, "list", null);
816
- expect(input.hasAttribute("list")).toBe(false);
817
- });
818
-
819
- test("routes unknown HTML props through setAttribute", () => {
820
- const div = claim([], "div");
821
- setProp(div, "popovertarget", "menu");
822
- expect(div.getAttribute("popovertarget")).toBe("menu");
823
- });
824
-
825
- test("keeps IDL semantics for writable props like checked", () => {
826
- const input = claim([], "input") as HTMLInputElement;
827
- input.type = "checkbox";
828
- setProp(input, "checked", true);
829
- expect(input.checked).toBe(true);
830
- expect(input.hasAttribute("checked")).toBe(false);
831
- });
832
- });
833
-
834
- describe("claimText", () => {
835
- test("claims a text node from pool", () => {
836
- const text = document.createTextNode("hello");
837
- const div = document.createElement("div");
838
- const pool: ChildNode[] = [text, div];
839
- const result = claimText(pool);
840
- expect(result).toBe(text);
841
- expect(pool).toEqual([div]);
842
- });
843
-
844
- test("falls back to createTextNode when no text node in pool", () => {
845
- const div = document.createElement("div");
846
- const pool: ChildNode[] = [div];
847
- const result = claimText(pool);
848
- expect(result).toBeInstanceOf(Text);
849
- expect(result.textContent).toBe("");
850
- expect(pool).toEqual([div]);
851
- });
852
-
853
- test("handles empty pool", () => {
854
- const pool: ChildNode[] = [];
855
- const result = claimText(pool);
856
- expect(result).toBeInstanceOf(Text);
857
- expect(pool).toEqual([]);
858
- });
859
-
860
- test("claims first text node only", () => {
861
- const t1 = document.createTextNode("a");
862
- const t2 = document.createTextNode("b");
863
- const pool: ChildNode[] = [t1, t2];
864
- const result = claimText(pool);
865
- expect(result).toBe(t1);
866
- expect(pool).toEqual([t2]);
867
- });
868
- });
869
-
870
- describe("hydration: full element tree claim", () => {
871
- test("simulates SSR → hydration → scoped pools", () => {
872
- // Simulate SSR output: <div><h1>Title</h1><p>Body</p></div>
873
- const root = document.createElement("div");
874
- const h1 = document.createElement("h1");
875
- h1.appendChild(document.createTextNode("Title"));
876
- const p = document.createElement("p");
877
- p.appendChild(document.createTextNode("Body"));
878
- root.appendChild(h1);
879
- root.appendChild(p);
880
-
881
- // Hydration entry: claim root from page-level pool
882
- const pageNodes: ChildNode[] = [root];
883
- const div = claim(pageNodes, "div");
884
- expect(div).toBe(root);
885
-
886
- // Scope: root's children
887
- const childNodes = Array.from(div.childNodes);
888
-
889
- // Claim h1
890
- const claimedH1 = claim(childNodes, "h1");
891
- expect(claimedH1).toBe(h1);
892
- // Claim text inside h1 — removes from pool array, not DOM
893
- const h1Pool = Array.from(claimedH1.childNodes);
894
- const h1Text = claimText(h1Pool);
895
- expect(h1Text.textContent).toBe("Title");
896
- expect(h1Pool.length).toBe(0); // removed from pool
897
-
898
- // Claim p
899
- const claimedP = claim(childNodes, "p");
900
- expect(claimedP).toBe(p);
901
- const pPool = Array.from(claimedP.childNodes);
902
- const pText = claimText(pPool);
903
- expect(pText.textContent).toBe("Body");
904
-
905
- // No leftover nodes in parent pool
906
- expect(childNodes.length).toBe(0);
907
- });
908
-
909
- test("falls back gracefully for SSR/client mismatch", () => {
910
- // SSR rendered <div><span>OK</span></div>
911
- // Client expects <div><p>OK</p></div>
912
- const root = document.createElement("div");
913
- const span = document.createElement("span");
914
- span.appendChild(document.createTextNode("OK"));
915
- root.appendChild(span);
916
-
917
- const nodes = Array.from(root.childNodes);
918
- // Try to claim a <p> — doesn't exist, creates new one
919
- const p = claim(nodes, "p");
920
- expect(p.tagName).toBe("P");
921
- expect(p.childNodes.length).toBe(0); // new element has no children
922
- // Original span still in pool
923
- expect(nodes.length).toBe(1);
924
- expect(nodes[0]).toBe(span);
925
- });
926
- });
927
-
928
- describe("Scary reactivity", () => {
929
- test("effect unsubscribes from stale dependencies", () => {
930
- const condition = createSignal(true);
931
- const a = createSignal(1);
932
- const b = createSignal(1);
933
- let runs = 0;
934
-
935
- createEffect(() => {
936
- runs++;
937
- if (condition()) {
938
- a(); // read a only when condition is true
939
- } else {
940
- b(); // read b only when condition is false
941
- }
942
- });
943
-
944
- expect(runs).toBe(1);
945
-
946
- // flip condition, effect should now track b, not a
947
- batch(() => {
948
- condition.set(false);
949
- });
950
- expect(runs).toBe(2);
951
-
952
- // updating a should NOT trigger the effect anymore
953
- batch(() => {
954
- a.set(99);
955
- });
956
- expect(runs).toBe(2); // ← this will fail with current implementation
957
- });
958
- });
959
-
960
- describe("withEffectScope", () => {
961
- test("collects effects created during fn()", () => {
962
- const count = createSignal(0);
963
- let runs = 0;
964
- withEffectScope(() => {
965
- createEffect(() => {
966
- count();
967
- runs++;
968
- });
969
- });
970
- expect(runs).toBe(1);
971
- batch(() => {
972
- count.set(1);
973
- });
974
- expect(runs).toBe(2);
975
- });
976
-
977
- test("dispose stops all collected effects", () => {
978
- const count = createSignal(0);
979
- let runs = 0;
980
- const dispose = withEffectScope(() => {
981
- createEffect(() => {
982
- count();
983
- runs++;
984
- });
985
- });
986
- expect(runs).toBe(1);
987
- batch(() => {
988
- count.set(1);
989
- });
990
- expect(runs).toBe(2);
991
-
992
- dispose();
993
-
994
- batch(() => {
995
- count.set(2);
996
- });
997
- expect(runs).toBe(2); // stopped — no further runs
998
- });
999
-
1000
- test("dispose stops multiple effects in the same scope", () => {
1001
- const a = createSignal(0);
1002
- const b = createSignal(0);
1003
- let runsA = 0;
1004
- let runsB = 0;
1005
- const dispose = withEffectScope(() => {
1006
- createEffect(() => {
1007
- a();
1008
- runsA++;
1009
- });
1010
- createEffect(() => {
1011
- b();
1012
- runsB++;
1013
- });
1014
- });
1015
- batch(() => {
1016
- a.set(1);
1017
- b.set(1);
1018
- });
1019
- expect(runsA).toBe(2);
1020
- expect(runsB).toBe(2);
1021
-
1022
- dispose();
1023
-
1024
- batch(() => {
1025
- a.set(2);
1026
- b.set(2);
1027
- });
1028
- expect(runsA).toBe(2);
1029
- expect(runsB).toBe(2);
1030
- });
1031
-
1032
- test("effects outside the scope are unaffected by dispose", () => {
1033
- const count = createSignal(0);
1034
- let outsideRuns = 0;
1035
- let insideRuns = 0;
1036
-
1037
- createEffect(() => {
1038
- count();
1039
- outsideRuns++;
1040
- });
1041
-
1042
- const dispose = withEffectScope(() => {
1043
- createEffect(() => {
1044
- count();
1045
- insideRuns++;
1046
- });
1047
- });
1048
-
1049
- batch(() => {
1050
- count.set(1);
1051
- });
1052
- expect(outsideRuns).toBe(2);
1053
- expect(insideRuns).toBe(2);
1054
-
1055
- dispose();
1056
-
1057
- batch(() => {
1058
- count.set(2);
1059
- });
1060
- expect(outsideRuns).toBe(3); // still running
1061
- expect(insideRuns).toBe(2); // stopped
1062
- });
1063
-
1064
- test("nested scopes: inner dispose doesn't affect outer", () => {
1065
- const count = createSignal(0);
1066
- let outerRuns = 0;
1067
- let innerRuns = 0;
1068
-
1069
- const disposeOuter = withEffectScope(() => {
1070
- createEffect(() => {
1071
- count();
1072
- outerRuns++;
1073
- });
1074
- // simulates a child component scope inside a page scope
1075
- const disposeInner = withEffectScope(() => {
1076
- createEffect(() => {
1077
- count();
1078
- innerRuns++;
1079
- });
1080
- });
1081
- disposeInner();
1082
- });
1083
-
1084
- batch(() => {
1085
- count.set(1);
1086
- });
1087
- expect(outerRuns).toBe(2);
1088
- expect(innerRuns).toBe(1); // stopped on inner dispose
1089
-
1090
- disposeOuter();
1091
- batch(() => {
1092
- count.set(2);
1093
- });
1094
- expect(outerRuns).toBe(2); // stopped on outer dispose
1095
- });
1096
-
1097
- test("createMemo effects are collected in scope", () => {
1098
- const count = createSignal(0);
1099
- let memoRuns = 0;
1100
- const dispose = withEffectScope(() => {
1101
- // createMemo internally calls createEffect
1102
- const doubled = createMemo(() => {
1103
- memoRuns++;
1104
- return count() * 2;
1105
- });
1106
- expect(doubled()).toBe(0);
1107
- });
1108
- expect(memoRuns).toBe(1);
1109
- batch(() => {
1110
- count.set(5);
1111
- });
1112
- expect(memoRuns).toBe(2);
1113
-
1114
- dispose();
1115
- batch(() => {
1116
- count.set(10);
1117
- });
1118
- expect(memoRuns).toBe(2); // memo's internal effect stopped
1119
- });
1120
-
1121
- test("dispose is idempotent", () => {
1122
- const count = createSignal(0);
1123
- let runs = 0;
1124
- const dispose = withEffectScope(() => {
1125
- createEffect(() => {
1126
- count();
1127
- runs++;
1128
- });
1129
- });
1130
- dispose();
1131
- dispose(); // second call must not throw or double-fire
1132
- batch(() => {
1133
- count.set(1);
1134
- });
1135
- expect(runs).toBe(1);
1136
- });
1137
- });
1138
-
1139
- describe("claimComment", () => {
1140
- test("claims a comment node from pool matching text", () => {
1141
- const comment = document.createComment("");
1142
- const div = document.createElement("div");
1143
- const pool: ChildNode[] = [comment, div];
1144
- const result = claimComment(pool);
1145
- expect(result).toBe(comment);
1146
- expect(pool).toEqual([div]);
1147
- });
1148
-
1149
- test("skips comments with non-matching data", () => {
1150
- const comment = document.createComment("g");
1151
- const div = document.createElement("div");
1152
- const pool: ChildNode[] = [comment, div];
1153
- const result = claimComment(pool, "");
1154
- expect(result).not.toBe(comment);
1155
- expect(result).toBeInstanceOf(Comment);
1156
- expect(pool).toEqual([comment, div]); // pool unchanged
1157
- });
1158
-
1159
- test("falls back to createComment when no comment in pool", () => {
1160
- const div = document.createElement("div");
1161
- const pool: ChildNode[] = [div];
1162
- const result = claimComment(pool);
1163
- expect(result).toBeInstanceOf(Comment);
1164
- expect(pool).toEqual([div]);
1165
- });
1166
-
1167
- test("handles empty pool", () => {
1168
- const pool: ChildNode[] = [];
1169
- const result = claimComment(pool);
1170
- expect(result).toBeInstanceOf(Comment);
1171
- expect(pool).toEqual([]);
1172
- });
1173
- });
1174
-
1175
- describe("hydrateKeyedList", () => {
1176
- test("claims anchor and sibling elements, builds keyMap", () => {
1177
- // Simulate SSR output: <!--g--> <li>A</li> <li>B</li> <!--/g-->
1178
- const parent = document.createElement("ul");
1179
- const open = document.createComment("g");
1180
- const li1 = document.createElement("li");
1181
- li1.textContent = "A";
1182
- const li2 = document.createElement("li");
1183
- li2.textContent = "B";
1184
- const close = document.createComment("/g");
1185
- parent.appendChild(open);
1186
- parent.appendChild(li1);
1187
- parent.appendChild(li2);
1188
- parent.appendChild(close);
1189
-
1190
- const pool: ChildNode[] = [open, li1, li2, close];
1191
- const items = [{ id: "a" }, { id: "b" }];
1192
-
1193
- // compiled row bodies claim their element from the pool
1194
- const result = hydrateKeyedList(
1195
- pool,
1196
- items,
1197
- (item) => item.id,
1198
- () => claim(pool, "li"),
1199
- );
1200
-
1201
- expect(result.anchor).toBe(open);
1202
- expect(result.keyMap.size).toBe(2);
1203
- expect(result.keyMap.get("a")).toBe(li1);
1204
- expect(result.keyMap.get("b")).toBe(li2);
1205
- // the list's whole segment is consumed: a row created later can never
1206
- // claim a node that is already in use
1207
- expect(pool.length).toBe(0);
1208
- expect(close.parentNode).toBeNull();
1209
- expect(Array.from(parent.children)).toEqual([li1, li2]);
1210
- });
1211
-
1212
- test("handles SSR/client order mismatch by reconciling", () => {
1213
- // SSR rendered: A, B. Client expects: B, A.
1214
- const parent = document.createElement("ul");
1215
- const open = document.createComment("g");
1216
- const liA = document.createElement("li");
1217
- liA.textContent = "A";
1218
- const liB = document.createElement("li");
1219
- liB.textContent = "B";
1220
- const close = document.createComment("/g");
1221
- parent.appendChild(open);
1222
- parent.appendChild(liA);
1223
- parent.appendChild(liB);
1224
- parent.appendChild(close);
1225
-
1226
- // Pool has anchor + items in SSR order
1227
- const pool: ChildNode[] = [open, liA, liB, close];
1228
- // Client order is reversed
1229
- const items = [{ id: "b" }, { id: "a" }];
1230
-
1231
- const result = hydrateKeyedList(
1232
- pool,
1233
- items,
1234
- (item) => item.id,
1235
- () => claim(pool, "li"),
1236
- );
1237
-
1238
- // keyMap should have the claimed nodes (mapped by SSR position)
1239
- expect(result.keyMap.get("b")).toBe(liA); // first sibling → first signal item key
1240
- expect(result.keyMap.get("a")).toBe(liB); // second sibling → second signal item key
1241
- });
1242
-
1243
- test("empty signal items → empty keyMap", () => {
1244
- const parent = document.createElement("ul");
1245
- const open = document.createComment("g");
1246
- const close = document.createComment("/g");
1247
- parent.appendChild(open);
1248
- parent.appendChild(close);
1249
-
1250
- const pool: ChildNode[] = [open, close];
1251
- const result = hydrateKeyedList(
1252
- pool,
1253
- [],
1254
- (item: { id: string }) => item.id,
1255
- () => document.createElement("li"),
1256
- );
1257
-
1258
- expect(result.anchor).toBe(open);
1259
- expect(result.keyMap.size).toBe(0);
1260
- });
1261
- });
1262
-
1263
- describe("A1 createRawSignal", () => {
1264
- test("skips proxy for objects", () => {
1265
- const state = createRawSignal({ name: "Alice" });
1266
- expect(state()).toEqual({ name: "Alice" });
1267
- // Raw signal — direct object, not proxied
1268
- const _obj = state();
1269
- state.set({ name: "Bob" });
1270
- expect(state()).toEqual({ name: "Bob" });
1271
- });
1272
-
1273
- test("works with primitives", () => {
1274
- const count = createRawSignal(0);
1275
- expect(count()).toBe(0);
1276
- count.set(5);
1277
- expect(count()).toBe(5);
1278
- });
1279
-
1280
- test("is reactive", () => {
1281
- const count = createRawSignal(0);
1282
- let runs = 0;
1283
- createEffect(() => {
1284
- count();
1285
- runs++;
1286
- });
1287
- expect(runs).toBe(1);
1288
- batch(() => {
1289
- count.set(1);
1290
- });
1291
- expect(runs).toBe(2);
1292
- });
1293
-
1294
- test(".peek() reads without tracking", () => {
1295
- const count = createRawSignal(0);
1296
- let runs = 0;
1297
- createEffect(() => {
1298
- count.peek();
1299
- runs++;
1300
- });
1301
- expect(runs).toBe(1);
1302
- batch(() => {
1303
- count.set(1);
1304
- });
1305
- expect(runs).toBe(1);
1306
- });
1307
- });
1308
-
1309
- describe("A2 snapshot", () => {
1310
- test("returns primitive values as-is", () => {
1311
- expect(snapshot(42)).toBe(42);
1312
- expect(snapshot("hello")).toBe("hello");
1313
- expect(snapshot(null)).toBe(null);
1314
- expect(snapshot(undefined)).toBe(undefined);
1315
- });
1316
-
1317
- test("unwraps proxy to plain object", () => {
1318
- const state = createSignal({ name: "Alice", age: 30 });
1319
- const snap = snapshot(state());
1320
- expect(snap).toEqual({ name: "Alice", age: 30 });
1321
- expect(snap).not.toBe(state()); // distinct reference
1322
- });
1323
-
1324
- test("unwraps proxy to plain array", () => {
1325
- const items = createSignal([1, 2, 3]);
1326
- const snap = snapshot(items());
1327
- expect(snap).toEqual([1, 2, 3]);
1328
- expect(Array.isArray(snap)).toBe(true);
1329
- expect(snap).not.toBe(items()); // distinct reference
1330
- });
1331
-
1332
- test("non-proxy objects are returned as-is", () => {
1333
- const obj = { plain: true };
1334
- expect(snapshot(obj)).toBe(obj);
1335
- });
1336
-
1337
- test("deeply nested snapshot is fully un-proxied", () => {
1338
- const obj = createSignal({ a: { b: { c: 1 } } });
1339
- const s = snapshot(obj());
1340
- expect(s.a.b.c).toBe(1);
1341
- // s.a.b should NOT be a proxy — it's a plain object from the deep copy
1342
- //biome-ignore lint: shut up
1343
- const proxyTargetCheck = (val: object) =>
1344
- typeof val === "object" &&
1345
- val !== null &&
1346
- !Object.getPrototypeOf(val)?.constructor?.name?.includes("Map");
1347
- // Verify no nested proxy: accessing s.a.b.c should not trigger tracking
1348
- let tracked = false;
1349
- //biome-ignore lint: shut up
1350
- const prev = (globalThis as any).__sigil_tracking_test;
1351
- (globalThis as any).__sigil_tracking_test = () => (tracked = true);
1352
- const raw = s.a.b;
1353
- // No reactive tracking should happen on plain objects
1354
- expect(raw.c).toBe(1);
1355
- // Deep compare confirms it's a full independent copy
1356
- expect(s).toEqual({ a: { b: { c: 1 } } });
1357
- expect(s.a).not.toBe(obj().a);
1358
- expect(s.a.b).not.toBe(obj().a.b);
1359
- });
1360
- });
1361
-
1362
- describe("A3 tracking", () => {
1363
- test("returns false outside effect", () => {
1364
- expect(tracking()).toBe(false);
1365
- });
1366
-
1367
- test("returns true inside effect", () => {
1368
- let inside = false;
1369
- createEffect(() => {
1370
- inside = tracking();
1371
- });
1372
- expect(inside).toBe(true);
1373
- });
1374
-
1375
- test("returns false after effect completes", () => {
1376
- createEffect(() => {
1377
- tracking();
1378
- });
1379
- expect(tracking()).toBe(false);
1380
- });
1381
- });
1382
-
1383
- describe("A4 createInspectEffect", () => {
1384
- test("does not throw", () => {
1385
- const count = createSignal(0);
1386
- expect(() => {
1387
- createInspectEffect(() => [count()]);
1388
- }).not.toThrow();
1389
- });
1390
-
1391
- test("accepts custom callback", () => {
1392
- const count = createSignal(0);
1393
- const logged: unknown[][] = [];
1394
- createInspectEffect(
1395
- () => [count()],
1396
- (vals) => logged.push(vals),
1397
- );
1398
- expect(logged.length).toBe(1);
1399
- expect(logged[0]).toEqual([0]);
1400
- });
1401
- });
1402
-
1403
- describe("A5 createEffectPre", () => {
1404
- test("runs immediately like createEffect", () => {
1405
- const count = createSignal(0);
1406
- let seen = -1;
1407
- createEffectPre(() => {
1408
- seen = count();
1409
- });
1410
- expect(seen).toBe(0);
1411
- });
1412
-
1413
- test("reruns on signal change", () => {
1414
- const count = createSignal(0);
1415
- let seen = -1;
1416
- createEffectPre(() => {
1417
- seen = count();
1418
- });
1419
- batch(() => {
1420
- count.set(5);
1421
- });
1422
- expect(seen).toBe(5);
1423
- });
1424
- });
1425
-
1426
- describe("A7 ReactiveMap", () => {
1427
- test("basic set/get", () => {
1428
- const map = new ReactiveMap<string, number>();
1429
- map.set("a", 1);
1430
- expect(map.get("a")).toBe(1);
1431
- });
1432
-
1433
- test("reactivity: get tracks reads", () => {
1434
- const map = new ReactiveMap<string, number>();
1435
- let size = 0;
1436
- createEffect(() => {
1437
- size = map.size;
1438
- });
1439
- expect(size).toBe(0);
1440
- batch(() => {
1441
- map.set("x", 1);
1442
- });
1443
- expect(size).toBe(1);
1444
- });
1445
-
1446
- test("deleted key triggers reactivity", () => {
1447
- const map = new ReactiveMap<string, number>();
1448
- map.set("a", 1);
1449
- let accessed: number | undefined;
1450
- createEffect(() => {
1451
- accessed = map.get("a");
1452
- });
1453
- expect(accessed).toBe(1);
1454
- batch(() => {
1455
- map.delete("a");
1456
- });
1457
- expect(accessed).toBe(undefined);
1458
- });
1459
-
1460
- test("clear triggers reactivity", () => {
1461
- const map = new ReactiveMap<string, number>();
1462
- map.set("a", 1);
1463
- let size = 0;
1464
- createEffect(() => {
1465
- size = map.size;
1466
- });
1467
- batch(() => {
1468
- map.clear();
1469
- });
1470
- expect(size).toBe(0);
1471
- });
1472
-
1473
- test("forEach tracks reads", () => {
1474
- const map = new ReactiveMap<string, number>();
1475
- map.set("a", 1);
1476
- let count = 0;
1477
- createEffect(() => {
1478
- count = 0;
1479
- //biome-ignore lint: shut up
1480
- map.forEach(() => count++);
1481
- });
1482
- expect(count).toBe(1);
1483
- batch(() => {
1484
- map.set("b", 2);
1485
- });
1486
- expect(count).toBe(2);
1487
- });
1488
-
1489
- test("per-key granularity: setting key X does not re-trigger effect reading key Y", () => {
1490
- const map = new ReactiveMap<string, number>();
1491
- map.set("a", 1);
1492
- map.set("b", 2);
1493
- let aRuns = 0;
1494
- let bRuns = 0;
1495
- createEffect(() => {
1496
- map.get("a");
1497
- aRuns++;
1498
- });
1499
- createEffect(() => {
1500
- map.get("b");
1501
- bRuns++;
1502
- });
1503
- expect(aRuns).toBe(1);
1504
- expect(bRuns).toBe(1);
1505
-
1506
- batch(() => {
1507
- map.set("a", 10); // only a-effect should rerun
1508
- });
1509
- expect(aRuns).toBe(2);
1510
- expect(bRuns).toBe(1);
1511
-
1512
- batch(() => {
1513
- map.set("b", 20); // only b-effect should rerun
1514
- });
1515
- expect(aRuns).toBe(2);
1516
- expect(bRuns).toBe(2);
1517
- });
1518
-
1519
- test("per-key: adding new key triggers struct but not existing key effects", () => {
1520
- const map = new ReactiveMap<string, number>();
1521
- map.set("a", 1);
1522
- let aRuns = 0;
1523
- let sizeRuns = 0;
1524
- createEffect(() => {
1525
- map.get("a");
1526
- aRuns++;
1527
- });
1528
- createEffect(() => {
1529
- map.size;
1530
- sizeRuns++;
1531
- });
1532
- expect(aRuns).toBe(1);
1533
- expect(sizeRuns).toBe(1);
1534
-
1535
- batch(() => {
1536
- map.set("b", 2); // new key — struct changes, a's value doesn't
1537
- });
1538
- expect(aRuns).toBe(1);
1539
- expect(sizeRuns).toBe(2);
1540
- });
1541
- });
1542
-
1543
- describe("A7 ReactiveSet", () => {
1544
- test("basic add/has", () => {
1545
- const set = new ReactiveSet<number>();
1546
- set.add(1);
1547
- expect(set.has(1)).toBe(true);
1548
- });
1549
-
1550
- test("reactivity: has tracks reads", () => {
1551
- const set = new ReactiveSet<number>();
1552
- let hasIt = false;
1553
- createEffect(() => {
1554
- hasIt = set.has(1);
1555
- });
1556
- expect(hasIt).toBe(false);
1557
- batch(() => {
1558
- set.add(1);
1559
- });
1560
- expect(hasIt).toBe(true);
1561
- });
1562
-
1563
- test("delete triggers reactivity", () => {
1564
- const set = new ReactiveSet<number>();
1565
- set.add(1);
1566
- let size = 0;
1567
- createEffect(() => {
1568
- size = set.size;
1569
- });
1570
- expect(size).toBe(1);
1571
- batch(() => {
1572
- set.delete(1);
1573
- });
1574
- expect(size).toBe(0);
1575
- });
1576
-
1577
- test("clear triggers reactivity", () => {
1578
- const set = new ReactiveSet<number>();
1579
- set.add(1);
1580
- let size = 0;
1581
- createEffect(() => {
1582
- size = set.size;
1583
- });
1584
- batch(() => {
1585
- set.clear();
1586
- });
1587
- expect(size).toBe(0);
1588
- });
1589
-
1590
- test("forEach tracks reads", () => {
1591
- const set = new ReactiveSet<string>();
1592
- set.add("a");
1593
- let count = 0;
1594
- createEffect(() => {
1595
- count = 0;
1596
- //biome-ignore lint: shut up
1597
- set.forEach(() => count++);
1598
- });
1599
- expect(count).toBe(1);
1600
- batch(() => {
1601
- set.add("b");
1602
- });
1603
- expect(count).toBe(2);
1604
- });
1605
- });
1606
-
1607
- describe("A8 easing functions", () => {
1608
- test("linear is identity", () => {
1609
- expect(linear(0)).toBe(0);
1610
- expect(linear(0.5)).toBe(0.5);
1611
- expect(linear(1)).toBe(1);
1612
- });
1613
-
1614
- test("easeInQuad is quadratic", () => {
1615
- expect(easeInQuad(0)).toBe(0);
1616
- expect(easeInQuad(0.5)).toBe(0.25);
1617
- expect(easeInQuad(1)).toBe(1);
1618
- });
1619
-
1620
- test("easeOutQuad completes at 1", () => {
1621
- expect(easeOutQuad(0)).toBe(0);
1622
- expect(easeOutQuad(1)).toBe(1);
1623
- });
1624
-
1625
- test("all easing functions return 0 at t=0 and 1 at t=1", () => {
1626
- const fns = [
1627
- easeInQuad,
1628
- easeOutQuad,
1629
- easeInOutQuad,
1630
- easeInCubic,
1631
- easeOutCubic,
1632
- easeInOutCubic,
1633
- easeInQuart,
1634
- easeOutQuart,
1635
- easeInOutQuart,
1636
- easeInQuint,
1637
- easeOutQuint,
1638
- easeInOutQuint,
1639
- easeInSine,
1640
- easeOutSine,
1641
- easeInOutSine,
1642
- ];
1643
- for (const fn of fns) {
1644
- expect(fn(0)).toBeCloseTo(0, 10);
1645
- expect(fn(1)).toBeCloseTo(1, 10);
1646
- }
1647
- });
1648
- });
1649
-
1650
- describe("A9 createProfilerEffect", () => {
1651
- test("runs the effect", () => {
1652
- let ran = false;
1653
- createProfilerEffect("test", () => {
1654
- ran = true;
1655
- });
1656
- expect(ran).toBe(true);
1657
- });
1658
-
1659
- test("reacts to signal changes", () => {
1660
- const count = createSignal(0);
1661
- let seen = -1;
1662
- createProfilerEffect("test", () => {
1663
- seen = count();
1664
- });
1665
- expect(seen).toBe(0);
1666
- batch(() => {
1667
- count.set(5);
1668
- });
1669
- expect(seen).toBe(5);
1670
- });
1671
- });
1672
-
1673
- describe("Array reactivity", () => {
1674
- test("push on $state array triggers reactivity", async () => {
1675
- const items = createSignal([] as string[]);
1676
- let count = 0;
1677
- createEffect(() => {
1678
- items(); // now auto-tracks length
1679
- count++;
1680
- });
1681
- await tick();
1682
- expect(count).toBe(1); // initial run
1683
- items().push("a");
1684
- await tick();
1685
- expect(count).toBe(2); // re-ran after push
1686
- expect(items().length).toBe(1);
1687
- });
1688
-
1689
- test("pop on $state array triggers reactivity", async () => {
1690
- const items = createSignal(["a", "b"] as string[]);
1691
- let len = 0;
1692
- createEffect(() => {
1693
- len = items().length; // reads length, subscribes
1694
- });
1695
- await tick();
1696
- expect(len).toBe(2);
1697
- items().pop();
1698
- await tick();
1699
- expect(len).toBe(1);
1700
- });
1701
-
1702
- test("splice on $state array triggers reactivity", async () => {
1703
- const items = createSignal(["a", "b", "c"] as string[]);
1704
- let len = 0;
1705
- createEffect(() => {
1706
- len = items().length;
1707
- });
1708
- await tick();
1709
- expect(len).toBe(3);
1710
- items().splice(1, 1);
1711
- await tick();
1712
- expect(len).toBe(2);
1713
- });
1714
- });
1715
-
1716
- describe("untrack", () => {
1717
- test("reading a signal inside untrack does not register a dep", async () => {
1718
- const tracked = createSignal(0);
1719
- const untracked = createSignal(0);
1720
- let runs = 0;
1721
- createEffect(() => {
1722
- runs++;
1723
- untrack(() => untracked());
1724
- tracked();
1725
- });
1726
- await tick();
1727
- expect(runs).toBe(1);
1728
- untracked.set(99);
1729
- await tick();
1730
- expect(runs).toBe(1); // no re-run — read was untracked
1731
- tracked.set(1);
1732
- await tick();
1733
- expect(runs).toBe(2); // still reacts to tracked reads
1734
- });
1735
-
1736
- test("returns fn's value", () => {
1737
- const sig = createSignal(7);
1738
- expect(untrack(() => sig())).toBe(7);
1739
- expect(
1740
- untrack(() => {
1741
- expect(tracking()).toBe(false);
1742
- return "direct";
1743
- }),
1744
- ).toBe("direct");
1745
- });
1746
- });
1747
-
1748
- describe("createRoot", () => {
1749
- test("effects inside survive outer scope disposal", async () => {
1750
- const count = createSignal(0);
1751
- let runs = 0;
1752
- let dispose: () => void = () => {};
1753
- const outerDispose = withEffectScope(() => {
1754
- createRoot((d) => {
1755
- dispose = d;
1756
- createEffect(() => {
1757
- count();
1758
- runs++;
1759
- });
1760
- });
1761
- });
1762
- const afterOuter = runs;
1763
- count.set(1);
1764
- await tick();
1765
- expect(runs).toBe(afterOuter + 1); // root effect still alive
1766
- dispose();
1767
- count.set(2);
1768
- await tick();
1769
- expect(runs).toBe(afterOuter + 1); // torn down by dispose()
1770
- });
1771
-
1772
- test("detached from enclosing scope entirely", async () => {
1773
- const count = createSignal(0);
1774
- let runs = 0;
1775
- const outerDispose = withEffectScope(() => {
1776
- createRoot(() => {
1777
- createEffect(() => {
1778
- count();
1779
- runs++;
1780
- });
1781
- });
1782
- // no reference kept — detached root leaks by design
1783
- });
1784
- outerDispose();
1785
- await tick();
1786
- const before = runs;
1787
- count.set(1);
1788
- await tick();
1789
- expect(runs).toBe(before + 1); // invisible to the disposed outer scope
1790
- });
1791
- });
1792
-
1793
- describe("createResource", () => {
1794
- test("resolves data and toggles loading", async () => {
1795
- const res = createResource(async () => "value");
1796
- expect(res.loading()).toBe(true);
1797
- await tick();
1798
- expect(res.data()).toBe("value");
1799
- expect(res.loading()).toBe(false);
1800
- expect(res.error()).toBeUndefined();
1801
- });
1802
-
1803
- test("source change refetches with new source value", async () => {
1804
- const src = createSignal(1);
1805
- const calls: unknown[] = [];
1806
- const res = createResource(
1807
- async (s) => {
1808
- calls.push(s);
1809
- return s;
1810
- },
1811
- () => src(),
1812
- );
1813
- await tick();
1814
- src.set(2);
1815
- await tick();
1816
- expect(calls).toEqual([1, 2]);
1817
- expect(res.data()).toBe(2);
1818
- });
1819
-
1820
- test("stale responses are discarded", async () => {
1821
- const resolvers: Array<(v: number) => void> = [];
1822
- const src = createSignal(0);
1823
- const res = createResource(
1824
- () =>
1825
- new Promise<number>((r) => {
1826
- resolvers.push(r);
1827
- }),
1828
- () => src(),
1829
- );
1830
- await tick(); // request #1 pending
1831
- src.set(1);
1832
- await tick(); // request #2 started
1833
- resolvers[1]!(99); // newer resolves first
1834
- await tick();
1835
- expect(res.data()).toBe(99);
1836
- resolvers[0]!(11); // stale response arrives late
1837
- await tick();
1838
- expect(res.data()).toBe(99); // discarded
1839
- });
1840
-
1841
- test("rejection captured in error()", async () => {
1842
- const res = createResource(async () => {
1843
- throw new Error("boom");
1844
- });
1845
- await tick();
1846
- expect(res.error()?.message).toBe("boom");
1847
- expect(res.loading()).toBe(false);
1848
- });
1849
-
1850
- test("refetch re-runs the fetcher", async () => {
1851
- let calls = 0;
1852
- const res = createResource(async () => {
1853
- calls++;
1854
- return calls;
1855
- });
1856
- await tick();
1857
- res.refetch();
1858
- await tick();
1859
- expect(res.data()).toBe(2);
1860
- });
1861
- });
1862
-
1863
- describe("transition directives (runtime)", () => {
1864
- test("unregistered node is removed synchronously", () => {
1865
- const el = document.createElement("div");
1866
- document.body.appendChild(el);
1867
- removeAnimated(el);
1868
- expect(el.parentNode).toBeNull();
1869
- });
1870
-
1871
- test("out-animation delays removal until finished", async () => {
1872
- const { promise, resolve } = Promise.withResolvers<void>();
1873
- const el = document.createElement("div");
1874
- document.body.appendChild(el);
1875
- const cleanup = mountTransition(
1876
- el,
1877
- ((_el: unknown, _params: unknown, direction: "in" | "out") => {
1878
- expect(direction).toBe("out");
1879
- return { finished: promise.then(() => undefined) };
1880
- }) as unknown as Parameters<typeof mountTransition>[1],
1881
- "out",
1882
- );
1883
- removeAnimated(el);
1884
- expect(el.parentNode).not.toBeNull(); // waiting for the animation
1885
- resolve();
1886
- await promise;
1887
- await tick();
1888
- expect(el.parentNode).toBeNull(); // removed after finish
1889
- cleanup();
1890
- });
1891
-
1892
- test("in kind plays immediately, transition registers and plays", () => {
1893
- const played: string[] = [];
1894
- const fn = ((_el: Element, _p: unknown, d: "in" | "out") => {
1895
- played.push(d);
1896
- }) as never;
1897
- mountTransition(document.createElement("div"), fn, "in");
1898
- expect(played).toEqual(["in"]);
1899
- const el = document.createElement("div");
1900
- mountTransition(el, fn, "transition");
1901
- expect(played).toEqual(["in", "in"]);
1902
- removeAnimated(el); // registered → out plays, then removal
1903
- expect(played).toEqual(["in", "in", "out"]);
1904
- expect(el.parentNode).toBeNull();
1905
- });
1906
- });
1907
-
1908
- // An exported `$store` is a signal getter; files that import it read
1909
- // `store.key` directly because the compiler only rewrites reads in the
1910
- // declaring file.
1911
- describe("object signal read from another module", () => {
1912
- test("property reads and writes reach the reactive object", () => {
1913
- const store = createSignal({ user: "a", n: 1 }) as unknown as {
1914
- user: string;
1915
- n: number;
1916
- };
1917
- expect(store.user).toBe("a");
1918
- store.n = 2;
1919
- expect((store as unknown as () => { n: number })().n).toBe(2);
1920
- expect(Object.keys(store)).toEqual(["user", "n"]);
1921
- expect("user" in store).toBe(true);
1922
- expect({ ...store }).toEqual({ user: "a", n: 2 });
1923
- });
1924
-
1925
- test("reads are tracked inside effects", async () => {
1926
- const store = createSignal({ n: 1 }) as unknown as { n: number };
1927
- const seen: number[] = [];
1928
- createEffect(() => {
1929
- seen.push(store.n);
1930
- });
1931
- store.n = 5;
1932
- await tick();
1933
- expect(seen).toEqual([1, 5]);
1934
- });
1935
-
1936
- test("arrays work through the getter", () => {
1937
- const list = createSignal([1, 2, 3]) as unknown as number[];
1938
- expect(list.length).toBe(3);
1939
- expect(list.map((x) => x * 2)).toEqual([2, 4, 6]);
1940
- expect([...list]).toEqual([1, 2, 3]);
1941
- list.push(4);
1942
- expect(list.length).toBe(4);
1943
- });
1944
-
1945
- test("snapshot unwraps the getter", () => {
1946
- const store = createSignal({ a: { b: 1 } });
1947
- expect(snapshot(store as unknown as object)).toEqual({ a: { b: 1 } });
1948
- });
1949
-
1950
- test("set and peek keep their signal meaning", () => {
1951
- const store = createSignal({ a: 1 });
1952
- store.set({ a: 2 });
1953
- expect(store().a).toBe(2);
1954
- expect(store.peek()).toEqual({ a: 2 });
1955
- });
1956
- });
1957
-
1958
- describe("collectEffects", () => {
1959
- test("holds effects until flush, then runs them once", () => {
1960
- const ran: string[] = [];
1961
- const { value, flush } = collectEffects(() => {
1962
- createEffect(() => {
1963
- ran.push("a");
1964
- });
1965
- return 7;
1966
- });
1967
- expect(value).toBe(7);
1968
- expect(ran).toEqual([]);
1969
- flush();
1970
- expect(ran).toEqual(["a"]);
1971
- flush();
1972
- expect(ran).toEqual(["a"]);
1973
- });
1974
-
1975
- test("an effect disposed before the flush never runs", () => {
1976
- let ran = 0;
1977
- let dispose = () => {};
1978
- const { flush } = collectEffects(() => {
1979
- dispose = withEffectScope(() => {
1980
- createEffect(() => {
1981
- ran++;
1982
- });
1983
- });
1984
- });
1985
- dispose();
1986
- flush();
1987
- expect(ran).toBe(0);
1988
- });
1989
-
1990
- test("two collections keep their own effects", () => {
1991
- const ran: string[] = [];
1992
- const first = collectEffects(() =>
1993
- createEffect(() => void ran.push("first")),
1994
- );
1995
- const second = collectEffects(() =>
1996
- createEffect(() => void ran.push("second")),
1997
- );
1998
- second.flush();
1999
- expect(ran).toEqual(["second"]);
2000
- first.flush();
2001
- expect(ran).toEqual(["second", "first"]);
2002
- });
2003
-
2004
- test("an effect that throws doesn't stop the others", () => {
2005
- const ran: string[] = [];
2006
- const { flush } = collectEffects(() => {
2007
- createEffect(() => {
2008
- throw new Error("boom");
2009
- });
2010
- createEffect(() => void ran.push("after"));
2011
- });
2012
- const original = globalThis.queueMicrotask;
2013
- const reported: unknown[] = [];
2014
- globalThis.queueMicrotask = (fn: () => void) => {
2015
- try {
2016
- fn();
2017
- } catch (e) {
2018
- reported.push(e);
2019
- }
2020
- };
2021
- try {
2022
- flush();
2023
- } finally {
2024
- globalThis.queueMicrotask = original;
2025
- }
2026
- expect(ran).toEqual(["after"]);
2027
- expect(String(reported[0])).toContain("boom");
2028
- });
2029
-
2030
- test("effects outside it run straight away again", () => {
2031
- collectEffects(() => {});
2032
- let ran = 0;
2033
- createEffect(() => {
2034
- ran++;
2035
- });
2036
- expect(ran).toBe(1);
2037
- });
2038
- });
2039
-
2040
- describe("applyDirective", () => {
2041
- test("sees its element in the document when the build is collected", () => {
2042
- const host = document.createElement("div");
2043
- document.body.appendChild(host);
2044
- let connected = null as boolean | null;
2045
- const { value: el, flush } = collectEffects(() => {
2046
- const el = document.createElement("section");
2047
- applyDirective(el, (node) => {
2048
- connected = node.isConnected;
2049
- return undefined;
2050
- });
2051
- return el;
2052
- });
2053
- expect(connected).toBeNull();
2054
- host.appendChild(el);
2055
- flush();
2056
- expect(connected).toBe(true);
2057
- host.remove();
2058
- });
2059
-
2060
- test("passes params, and its cleanup runs with the scope", () => {
2061
- const calls: unknown[] = [];
2062
- const dispose = withEffectScope(() => {
2063
- applyDirective(document.createElement("div"), [
2064
- (_node: Element, params: unknown) => {
2065
- calls.push(params);
2066
- return () => calls.push("cleanup");
2067
- },
2068
- { a: 1 },
2069
- ]);
2070
- });
2071
- expect(calls).toEqual([{ a: 1 }]);
2072
- dispose();
2073
- expect(calls).toEqual([{ a: 1 }, "cleanup"]);
2074
- });
2075
-
2076
- test("is not set up again when a signal it read changes", () => {
2077
- const n = createSignal(0);
2078
- let runs = 0;
2079
- withEffectScope(() => {
2080
- applyDirective(document.createElement("div"), () => {
2081
- n();
2082
- runs++;
2083
- return undefined;
2084
- });
2085
- });
2086
- n.set(1);
2087
- expect(runs).toBe(1);
2088
- });
2089
- });