@esportsplus/reactivity 0.31.3 → 0.32.0

package/test/pending-writes.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it } from 'vitest';
+import { computed, effect, read, signal, write } from '~/system';
+
+
+describe('pending-only writes', () => {
+    it('N writes to one signal between settles produce exactly one fan-out', async () => {
+        let runs = 0,
+            s = signal(0);
+
+        let c = computed(() => {
+            runs++;
+
+            return read(s);
+        });
+
+        effect(() => {
+            read(c);
+        });
+
+        runs = 0;
+
+        write(s, 1);
+        write(s, 2);
+        write(s, 3);
+        write(s, 4);
+        write(s, 5);
+
+        await Promise.resolve();
+        await Promise.resolve();
+
+        // One drain, one recompute — not one per write
+        expect(runs).toBe(1);
+        expect(read(c)).toBe(5);
+    });
+
+    it('an unchanged recompute does not cascade to downstream subscribers', async () => {
+        let downstream = 0,
+            s = signal(0);
+
+        // Parity: value only changes on even inputs, so odd writes recompute c but must not re-run d
+        let c = computed(() => read(s) - (read(s) % 2));
+
+        let d = computed(() => {
+            downstream++;
+
+            return read(c);
+        });
+
+        effect(() => {
+            read(d);
+        });
+
+        downstream = 0;
+
+        write(s, 1);
+        await Promise.resolve();
+        await Promise.resolve();
+
+        // c recomputed to the same value (0) → no propagation to d
+        expect(downstream).toBe(0);
+        expect(read(d)).toBe(0);
+
+        write(s, 2);
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(downstream).toBe(1);
+        expect(read(d)).toBe(2);
+    });
+
+    it('tracked reads converge on pending writes at settle (invariant 1, parity with main)', async () => {
+        let observed: number[] = [],
+            s = signal(0),
+            t = signal(10);
+
+        let c = computed(() => read(t));
+
+        // Effect writes t then reads c, and a downstream effect reads c too — at settle every
+        // tracked reader must see the pending write reflected (main's coherence contract, which
+        // the deferred queue must preserve rather than strand a write un-fanned-out)
+        effect(() => {
+            let v = read(s);
+
+            if (v > 0) {
+                write(t, v * 100);
+            }
+
+            observed.push(read(c));
+        });
+
+        let downstream = 0;
+
+        effect(() => {
+            read(c);
+            downstream++;
+        });
+
+        observed.length = 0;
+        downstream = 0;
+
+        write(s, 1);
+        await Promise.resolve();
+        await Promise.resolve();
+
+        // Both readers and the node itself settle on the written value — the queue never drops it
+        expect(read(c)).toBe(100);
+        expect(observed[observed.length - 1]).toBe(100);
+        expect(downstream).toBeGreaterThan(0);
+    });
+
+    it('repeated writes across two signals coalesce, final graph values correct', async () => {
+        let runs = 0,
+            a = signal(1),
+            b = signal(1);
+
+        let sum = computed(() => {
+            runs++;
+
+            return read(a) + read(b);
+        });
+
+        effect(() => {
+            read(sum);
+        });
+
+        runs = 0;
+
+        write(a, 2);
+        write(a, 3);
+        write(b, 4);
+        write(b, 5);
+
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(runs).toBe(1);
+        expect(read(sum)).toBe(8);
+    });
+});

package/{tests/reactive.ts → test/reactive/reactive.test.ts}

@@ -4,6 +4,7 @@ import { SIGNAL } from '~/constants';
 import { ReactiveObject, isReactiveObject } from '~/reactive/object';
 import reactive from '~/reactive/index';
 import { ReactiveArray } from '~/reactive/array';
+import { tick, waitFor } from '../lib/wait-for';
 
 
 describe('ReactiveObject', () => {
@@ -120,7 +121,7 @@ describe('ReactiveObject', () => {
 
             expect(obj.data).toBeUndefined();
 
-            await new Promise((r) => setTimeout(r, 10));
+            await waitFor(() => obj.data === 42, 'obj.data resolves to 42');
 
             expect(obj.data).toBe(42);
         });
@@ -131,12 +132,12 @@ describe('ReactiveObject', () => {
                     data: () => Promise.resolve(read(s))
                 }) as any;
 
-            await new Promise((r) => setTimeout(r, 10));
+            await waitFor(() => obj.data === 'hello', 'obj.data resolves to hello');
 
             expect(obj.data).toBe('hello');
 
             write(s, 'world');
-            await new Promise((r) => setTimeout(r, 10));
+            await waitFor(() => obj.data === 'world', 'obj.data updates to world');
 
             expect(obj.data).toBe('world');
         });
@@ -153,6 +154,9 @@ describe('ReactiveObject', () => {
 
             expect(obj.data).toBeUndefined();
 
+            // Creation dispatches once: the probe is reused as the factory (no separate probe dispatch).
+            expect(resolvers.length).toBe(1);
+
             // Trigger second computation
             write(s, 2);
             await Promise.resolve();
@@ -163,26 +167,24 @@ describe('ReactiveObject', () => {
             await Promise.resolve();
             await Promise.resolve();
 
-            // Resolve first promise (stale — should be ignored)
-            resolvers[0](100);
-            await Promise.resolve();
-
-            expect(obj.data).toBeUndefined();
+            // [0] creation, [1] after write(2), [2] after write(3) — the latest
+            expect(resolvers.length).toBe(3);
 
-            // Resolve second promise (stale — should be ignored)
-            resolvers[1](200);
+            // Resolve the stale computations — all ignored
+            resolvers[0](50);
+            resolvers[1](100);
             await Promise.resolve();
 
             expect(obj.data).toBeUndefined();
 
-            // Resolve latest promise — should write
+            // Resolve latest promise — lands after the stabilize microtask
             resolvers[2](300);
-            await Promise.resolve();
+            await waitFor(() => obj.data === 300, 'obj.data resolves to latest 300');
 
             expect(obj.data).toBe(300);
         });
 
-        it('dispose prevents new computations but in-flight resolves still write', async () => {
+        it('dispose stops in-flight resolves from landing', async () => {
             let s = signal(1),
                 resolver: ((v: number) => void) | null = null,
                 obj = new ReactiveObject({
@@ -200,18 +202,17 @@ describe('ReactiveObject', () => {
             write(s, 2);
             await Promise.resolve();
 
-            // Resolve the original in-flight promise
+            // Resolve the original in-flight promise — teardown is permanent, nothing lands
             resolver!(999);
             await Promise.resolve();
 
-            // In-flight promise still wrote (version matched)
-            expect(obj.data).toBe(999);
+            expect(obj.data).toBeUndefined();
 
-            // But no further computations occur from new dependency changes
+            // And no further computations occur from new dependency changes
             write(s, 3);
-            await new Promise((r) => setTimeout(r, 10));
+            await tick();
 
-            expect(obj.data).toBe(999);
+            expect(obj.data).toBeUndefined();
         });
     });
 

package/test/read-dedup.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest';
+import { computed, effect, read, signal, write } from '~/system';
+import type { Computed } from '~/system';
+
+
+function countDeps(node: Computed<unknown>): number {
+    let n = 0;
+
+    for (let link = node.deps; link; link = link.nextDep) {
+        n++;
+    }
+
+    return n;
+}
+
+
+describe('read-version dedup', () => {
+    it('interleaved repeat reads (x, y, x) hold exactly 2 dep links and re-run once per write', async () => {
+        let runs = 0,
+            x = signal(0),
+            y = signal(0);
+
+        let c = computed(() => {
+            runs++;
+
+            return read(x) + read(y) + read(x);
+        });
+
+        effect(() => {
+            read(c);
+        });
+
+        expect(countDeps(c as Computed<unknown>)).toBe(2);
+        expect(runs).toBe(1);
+
+        write(x, 1);
+        await Promise.resolve();
+
+        // Steady-state re-run exercises the RECOMPUTING reuse paths
+        expect(countDeps(c as Computed<unknown>)).toBe(2);
+        expect(runs).toBe(2);
+        expect(read(c)).toBe(2);
+
+        write(x, 2);
+        await Promise.resolve();
+
+        expect(countDeps(c as Computed<unknown>)).toBe(2);
+        expect(runs).toBe(3);
+        expect(read(c)).toBe(4);
+    });
+
+    it('outer first-read of a dep stamped only by a nested creation still links (no false positive)', async () => {
+        let outerRuns = 0,
+            s = signal(1);
+
+        effect(() => {
+            outerRuns++;
+
+            // Inline creation: depsTail is null, so the inner recompute nests here and stamps s.
+            // Constant value keeps the inner from ever propagating — the outer re-runs on s
+            // writes ONLY through its own direct link.
+            computed(() => (read(s), 0));
+
+            read(s);
+        });
+
+        expect(outerRuns).toBe(1);
+
+        write(s, 2);
+        await Promise.resolve();
+
+        expect(outerRuns).toBe(2);
+
+        write(s, 3);
+        await Promise.resolve();
+
+        expect(outerRuns).toBe(3);
+    });
+
+    it('repeat reads across a nested-recompute boundary re-link or reuse, never drop', async () => {
+        let runs = 0,
+            s = signal(1);
+
+        let c = computed(() => {
+            runs++;
+
+            // Inline nested recompute reads s and stamps it under the inner run's version.
+            // Undefined return keeps the inner from ever propagating back into c.
+            computed(() => {
+                read(s);
+            });
+
+            return read(s) + read(s);
+        });
+
+        effect(() => {
+            read(c);
+        });
+
+        expect(read(c)).toBe(2);
+        expect(runs).toBe(1);
+
+        // inner + one s link — the repeat read fast-exits, the boundary read still links
+        expect(countDeps(c as Computed<unknown>)).toBe(2);
+
+        write(s, 2);
+        await Promise.resolve();
+
+        expect(read(c)).toBe(4);
+        expect(runs).toBe(2);
+        expect(countDeps(c as Computed<unknown>)).toBe(2);
+
+        write(s, 5);
+        await Promise.resolve();
+
+        expect(read(c)).toBe(10);
+        expect(runs).toBe(3);
+        expect(countDeps(c as Computed<unknown>)).toBe(2);
+    });
+});

package/test/signal-selector.test.ts

@@ -0,0 +1,187 @@
+import { describe, expect, it } from 'vitest';
+import { computed, effect, onCleanup, read, signal, write } from '~/system';
+
+// signal.selector(node, key) rides a Map for entry lookup — SameValueZero semantics: NaN keys match
+// themselves and ±0 collapse, slightly wider than the settled === for those two cases. Object keys
+// compare by reference and MUST be stable (a re-allocated key object never matches). The initial
+// node.value === key snapshot uses ===.
+
+const settle = () => Promise.resolve().then(() => Promise.resolve());
+
+
+describe('signal.selector per-key selector', () => {
+    it('re-runs on transitions into/out of the key, not on writes between other keys', async () => {
+        let runs = 0,
+            s = signal('a');
+
+        effect(() => {
+            runs++;
+            signal.selector(s, 'b');
+        });
+
+        runs = 0;
+
+        write(s, 'c');
+        await settle();
+        expect(runs).toBe(0);
+
+        write(s, 'b');
+        await settle();
+        expect(runs).toBe(1);
+
+        write(s, 'd');
+        await settle();
+        expect(runs).toBe(2);
+
+        write(s, 'e');
+        await settle();
+        expect(runs).toBe(2);
+    });
+
+    it('returns the correct boolean at first call, tracked and untracked', () => {
+        let s = signal('x'),
+            tracked: boolean | null = null;
+
+        expect(signal.selector(s, 'x')).toBe(true);
+        expect(signal.selector(s, 'y')).toBe(false);
+
+        effect(() => {
+            tracked = signal.selector(s, 'x');
+        });
+
+        expect(tracked).toBe(true);
+    });
+
+    it('is lazy: keys stays null until a tracked call, one entry per distinct key', () => {
+        let s = signal(0);
+
+        expect(s.keys).toBe(null);
+
+        signal.selector(s, 1);
+        expect(s.keys).toBe(null);
+
+        effect(() => {
+            signal.selector(s, 1);
+            signal.selector(s, 2);
+            signal.selector(s, 1);
+        });
+
+        expect(s.keys).not.toBe(null);
+        expect(s.keys!.size).toBe(2);
+    });
+
+    it('evicts entries on last unsubscribe and nulls keys when the map empties', () => {
+        let s = signal(0),
+            stop1 = effect(() => {
+                signal.selector(s, 1);
+            }),
+            stop2 = effect(() => {
+                signal.selector(s, 2);
+            });
+
+        expect(s.keys!.size).toBe(2);
+
+        stop1();
+        expect(s.keys!.size).toBe(1);
+
+        stop2();
+        expect(s.keys).toBe(null);
+    });
+
+    it('leaves the computed last-unsub auto-dispose behavior unchanged', () => {
+        let cleaned = 0,
+            s = signal(0);
+
+        let stop = effect(() => {
+            let c = computed(() => {
+                onCleanup(() => {
+                    cleaned++;
+                });
+
+                return read(s);
+            });
+
+            read(c);
+        });
+
+        expect(cleaned).toBe(0);
+
+        // Disposing the effect unlinks c's last subscriber → c still auto-disposes and its cleanup fires.
+        stop();
+        expect(cleaned).toBe(1);
+    });
+
+    it('fans out keys independently; a write touches only the prev and next entries', async () => {
+        let s = signal('a'),
+            runs1 = 0,
+            runs2 = 0,
+            runs3 = 0;
+
+        effect(() => {
+            runs1++;
+            signal.selector(s, 'a');
+        });
+        effect(() => {
+            runs2++;
+            signal.selector(s, 'b');
+        });
+        effect(() => {
+            runs3++;
+            signal.selector(s, 'c');
+        });
+
+        runs1 = runs2 = runs3 = 0;
+
+        write(s, 'b');
+        await settle();
+
+        expect(runs1).toBe(1);
+        expect(runs2).toBe(1);
+        expect(runs3).toBe(0);
+    });
+
+    it('NaN key: the Map reuses one stable entry and transitions fan out (SameValueZero caveat)', async () => {
+        let observed: boolean[] = [],
+            runs = 0,
+            s = signal<number>(0);
+
+        effect(() => {
+            runs++;
+            observed.push(signal.selector(s, NaN));
+        });
+
+        runs = 0;
+        observed.length = 0;
+
+        expect(s.keys!.size).toBe(1);
+
+        write(s, NaN);
+        await settle();
+
+        expect(runs).toBe(1);
+        expect(observed[observed.length - 1]).toBe(true);
+        expect(s.keys!.size).toBe(1);
+    });
+
+    it('object key compares by reference: a stable key matches, a re-allocated one does not', async () => {
+        let k = { id: 1 },
+            observed: boolean[] = [],
+            s = signal<object>(k);
+
+        effect(() => {
+            observed.push(signal.selector(s, k));
+        });
+
+        expect(observed[0]).toBe(true);
+
+        observed.length = 0;
+
+        write(s, { id: 1 });
+        await settle();
+        expect(observed[observed.length - 1]).toBe(false);
+
+        write(s, k);
+        await settle();
+        expect(observed[observed.length - 1]).toBe(true);
+    });
+});