@esportsplus/reactivity 0.31.3 → 0.33.0

package/test/invalidate.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it } from 'vitest';
+import { computed, effect, flush, peek, read, signal, write } from '~/system';
+import { waitFor } from './lib/wait-for';
+
+
+describe('invalidate()', () => {
+    it('re-runs the computed fn with no dependency change', () => {
+        let runs = 0,
+            s = signal(1);
+
+        let c = computed(() => {
+            runs++;
+
+            return read(s);
+        });
+
+        effect(() => {
+            read(c);
+        });
+
+        expect(runs).toBe(1);
+
+        computed.invalidate(c);
+        flush();
+
+        expect(runs).toBe(2);
+    });
+
+    it('dependents re-run only when the forced re-run changes the value', () => {
+        let changingRuns = 0,
+            s = signal(1),
+            stableRuns = 0,
+            ticks = 0;
+
+        let changing = computed(() => {
+            read(s);
+
+            return ++ticks;
+        });
+
+        let stable = computed(() => read(s));
+
+        effect(() => {
+            stableRuns++;
+            read(stable);
+        });
+
+        effect(() => {
+            changingRuns++;
+            read(changing);
+        });
+
+        computed.invalidate(stable);
+        flush();
+
+        expect(stableRuns).toBe(1);
+
+        computed.invalidate(changing);
+        flush();
+
+        expect(changingRuns).toBe(2);
+    });
+
+    it('re-dispatches an asyncComputed factory (refetch via the asyncMeta redirect)', async () => {
+        let fetches = 0;
+
+        let node = computed(() => {
+            fetches++;
+
+            return Promise.resolve(fetches);
+        });
+
+        let stop = effect(() => {
+            read(node);
+        });
+
+        await waitFor(() => read(node) === 1, 'node resolves to 1');
+
+        expect(fetches).toBe(1);
+        expect(read(node)).toBe(1);
+
+        computed.invalidate(node);
+        await waitFor(() => read(node) === 2, 'node refetches to 2');
+
+        expect(fetches).toBe(2);
+        expect(read(node)).toBe(2);
+
+        stop();
+    });
+
+    it('forces a side-effecting computed (the public effect encoding) to re-run without propagating', () => {
+        let keeperRuns = 0,
+            s = signal(1),
+            sideRuns = 0;
+
+        let c = computed<void>(() => {
+            read(s);
+            sideRuns++;
+        });
+
+        effect(() => {
+            keeperRuns++;
+            read(c);
+        });
+
+        expect(sideRuns).toBe(1);
+        expect(keeperRuns).toBe(1);
+
+        computed.invalidate(c);
+        flush();
+
+        expect(sideRuns).toBe(2);
+        expect(keeperRuns).toBe(1);
+    });
+
+    it('the global-version fast path does not swallow a forced re-run', () => {
+        let runs = 0,
+            s = signal(1);
+
+        let c = computed(() => {
+            runs++;
+
+            return read(s);
+        });
+
+        effect(() => {
+            read(c);
+        });
+
+        write(s, 2);
+        flush();
+
+        expect(runs).toBe(2);
+
+        // Fully settled: c carries the current gv stamp. Without writes++ inside invalidate,
+        // this synchronous pull would exit through the fast path and skip the re-run. peek()
+        // forces the pull unconditionally (read() outside an observer returns the cached value).
+        computed.invalidate(c);
+
+        expect(peek(c)).toBe(2);
+        expect(runs).toBe(3);
+
+        flush();
+
+        expect(runs).toBe(3);
+    });
+});

package/test/lib/wait-for.ts

@@ -0,0 +1,28 @@
+const tick = (times = 1): Promise<void> => {
+    let p = Promise.resolve();
+
+    for (let i = 0; i < times; i++) {
+        p = p.then(() => new Promise<void>((resolve) => setTimeout(resolve, 0)));
+    }
+
+    return p;
+};
+
+const waitFor = (condition: () => boolean, description: string, timeoutMs = 1000): Promise<void> => {
+    return new Promise<void>((resolve, reject) => {
+        let deadline = Date.now() + timeoutMs,
+            timer = setInterval(() => {
+                if (condition()) {
+                    clearInterval(timer);
+                    resolve();
+                }
+                else if (Date.now() >= deadline) {
+                    clearInterval(timer);
+                    reject(new Error('wait-for: timed out waiting for ' + description));
+                }
+            }, 10);
+    });
+};
+
+
+export { tick, waitFor };

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);
+    });
+});