@esportsplus/reactivity 0.31.3 → 0.32.0

package/test/async-iterable.test.ts

@@ -0,0 +1,221 @@
+import { describe, expect, it } from 'vitest';
+import { computed, effect, read, root, signal, write } from '~/system';
+import { tick } from './lib/wait-for';
+import type { Computed } from '~/system';
+
+
+// resolve() settle contract: fn returning undefined means "not ready yet, keep waiting"
+// (asyncComputed nodes hold undefined pre-first-settle, so `() => read(wrapper)` composes
+// naturally); the first non-undefined value resolves the returned promise, a throw rejects it.
+//
+// AsyncIterable tracking pin: an async generator's body runs synchronously up to its first
+// await/yield INSIDE the factory's first next() call, under the polling effect's observer.
+// Dependencies belong in the factory fn body, read synchronously BEFORE the iterable is
+// returned — reads inside the generator body itself never link into the polling effect.
+function gate(): { promise: Promise<void>; resolve: VoidFunction } {
+    let resolveFn!: VoidFunction;
+
+    let promise = new Promise<void>((res) => {
+        resolveFn = res;
+    });
+
+    return { promise, resolve: resolveFn };
+}
+
+
+describe('asyncComputed AsyncIterable support', () => {
+    it('yields land in order; return() fires on re-run', async () => {
+        let allGates: ReturnType<typeof gate>[][] = [],
+            calls = 0,
+            node!: Computed<number | undefined>,
+            returned = 0,
+            s = signal(1);
+
+        let feed = () => {
+            calls++;
+
+            let myGates = [gate(), gate()];
+
+            allGates.push(myGates);
+
+            return (async function* () {
+                try {
+                    await myGates[0].promise;
+                    yield 1;
+
+                    await myGates[1].promise;
+                    yield 2;
+                }
+                finally {
+                    returned++;
+                }
+            })();
+        };
+
+        root(() => {
+            node = computed(() => {
+                read(s);
+
+                return feed();
+            });
+        });
+
+        expect(calls).toBe(1);
+
+        allGates[0][0].resolve();
+        await tick();
+
+        expect(read(node)).toBe(1);
+
+        // Mid-iteration: generation 0's generator is suspended awaiting its second gate.
+        // Re-run the factory before releasing it — the old iterator is abandoned.
+        write(s, 2);
+        await tick();
+
+        expect(calls).toBe(2);
+
+        // The abandoned generation-0 generator only unwinds once its own pending internal
+        // await settles (async generator return() semantics) — release it to observe close.
+        allGates[0][1].resolve();
+        await tick();
+
+        expect(returned).toBe(1);
+    });
+
+    it('return() fires on disposal', async () => {
+        let allGates: ReturnType<typeof gate>[][] = [],
+            node!: Computed<number | undefined>,
+            returned = 0,
+            s = signal(1),
+            stopRoot!: VoidFunction;
+
+        let feed = () => {
+            let myGates = [gate(), gate()];
+
+            allGates.push(myGates);
+
+            return (async function* () {
+                try {
+                    await myGates[0].promise;
+                    yield 1;
+
+                    await myGates[1].promise;
+                    yield 2;
+                }
+                finally {
+                    returned++;
+                }
+            })();
+        };
+
+        root((dispose) => {
+            stopRoot = dispose;
+
+            node = computed(() => {
+                read(s);
+
+                return feed();
+            });
+        });
+
+        let keeper = effect(() => {
+            read(node);
+        });
+
+        allGates[0][0].resolve();
+        await tick();
+
+        expect(read(node)).toBe(1);
+
+        // Mid-iteration: dispose while the generator is suspended awaiting its second gate.
+        keeper();
+        stopRoot();
+
+        allGates[0][1].resolve();
+        await tick();
+
+        expect(returned).toBe(1);
+        expect(read(node)).toBe(1);   // no further value landed
+    });
+
+    it('latest-wins across iterables: a stale yield from an abandoned iterator never lands', async () => {
+        let allGates: ReturnType<typeof gate>[][] = [],
+            calls = 0,
+            node!: Computed<number | undefined>,
+            s = signal(1);
+
+        let feed = () => {
+            calls++;
+
+            let generation = calls,
+                myGates = [gate(), gate()];
+
+            allGates.push(myGates);
+
+            return (async function* () {
+                await myGates[0].promise;
+                yield generation * 100;
+
+                await myGates[1].promise;
+                yield generation * 100 + 1;
+            })();
+        };
+
+        root(() => {
+            node = computed(() => {
+                read(s);
+
+                return feed();
+            });
+        });
+
+        allGates[0][0].resolve();
+        await tick();
+
+        expect(read(node)).toBe(100);
+
+        // Re-run before releasing generation 0's second gate — it becomes abandoned.
+        write(s, 2);
+        await tick();
+
+        expect(calls).toBe(2);
+
+        // Release the abandoned generation's pending gate: its stale second yield (101)
+        // reaches step(), but the id !== v guard drops it before it ever touches node.
+        allGates[0][1].resolve();
+        await tick();
+
+        expect(read(node)).toBe(100);
+
+        // The fresh iterator still works normally.
+        allGates[1][0].resolve();
+        await tick();
+
+        expect(read(node)).toBe(200);
+    });
+
+    it('a rejecting iterator step surfaces via the error contract', async () => {
+        let node!: Computed<number | undefined>,
+            rejectGate = gate();
+
+        let feed = async function* () {
+            yield 1;
+
+            await rejectGate.promise;
+            throw new Error('iterable step boom');
+        };
+
+        root(() => {
+            node = computed(() => feed());
+        });
+
+        await tick();
+
+        expect(read(node)).toBe(1);
+
+        rejectGate.resolve();
+        await tick();
+
+        expect(() => read(node)).toThrow('iterable step boom');
+    });
+});

package/test/async-nested.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { computed, effect, read, root, signal } from '~/system';
+import { waitFor } from './lib/wait-for';
+import type { Computed } from '~/system';
+
+describe('async computed created mid-tracking', () => {
+    it('detects async when it is not the first tracked op', async () => {
+        let captured: Computed<number | undefined> | null = null,
+            s = signal(0);
+        root(() => {
+            effect(() => {
+                read(s);                                        // 1st tracked op
+                captured = computed(() => Promise.resolve(42)); // 2nd op — deferred branch
+            });
+        });
+        await waitFor(() => read(captured!) === 42, 'nested async resolves to 42');
+        expect(read(captured!)).toBe(42);
+    });
+});

package/test/deep-graphs.test.ts

@@ -0,0 +1,215 @@
+import { describe, expect, it } from 'vitest';
+import { computed, effect, flush, peek, read, signal, write } from '~/system';
+
+
+// Depth chosen well past the V8 call-stack frame limit (~10-15k): a recursive notify/update/dispose
+// would RangeError here, an iterative walk does not.
+const DEPTH = 200000;
+
+
+describe('deep graphs', () => {
+    it('a 200k-deep chain settles at the leaf with no overflow (scheduled + pull paths)', () => {
+        let chain: ReturnType<typeof computed<number>>[] = [],
+            s = signal(0),
+            seen = -1;
+
+        chain[0] = computed(() => read(s) + 1);
+
+        for (let i = 1; i < DEPTH; i++) {
+            let prev = chain[i - 1];
+
+            chain[i] = computed(() => read(prev) + 1);
+        }
+
+        let leaf = chain[DEPTH - 1];
+
+        let stop = effect(() => {
+            seen = read(leaf);
+        });
+
+        expect(seen).toBe(DEPTH);
+
+        // Scheduled path: write + flush drains the height buckets.
+        write(s, 1);
+        flush();
+
+        expect(seen).toBe(DEPTH + 1);
+
+        // Pull path: a synchronous peek before flush forces the notify broadcast + the update walk.
+        write(s, 2);
+
+        expect(peek(leaf)).toBe(DEPTH + 2);
+
+        flush();
+
+        expect(seen).toBe(DEPTH + 2);
+
+        stop();
+    }, 30000);
+
+    it('a wide fan-out with deep branches settles (notify sibling traversal)', () => {
+        let leaves: ReturnType<typeof computed<number>>[] = [],
+            observed = -1,
+            s = signal(1),
+            width = 100,
+            branchDepth = 50;
+
+        for (let b = 0; b < width; b++) {
+            let node = computed(() => read(s));
+
+            for (let d = 0; d < branchDepth; d++) {
+                let prev = node;
+
+                node = computed(() => read(prev) + 1);
+            }
+
+            leaves.push(node);
+        }
+
+        let sum = computed(() => {
+            let total = 0;
+
+            for (let i = 0, n = leaves.length; i < n; i++) {
+                total += read(leaves[i]);
+            }
+
+            return total;
+        });
+
+        let stop = effect(() => {
+            observed = read(sum);
+        });
+
+        expect(observed).toBe(width * (1 + branchDepth));
+
+        write(s, 2);
+
+        expect(peek(sum)).toBe(width * (2 + branchDepth));
+
+        flush();
+
+        expect(observed).toBe(width * (2 + branchDepth));
+
+        stop();
+    });
+
+    it('a diamond recomputes the sink once per source change (glitch-free, no redundant checks)', () => {
+        let aRuns = 0,
+            bRuns = 0,
+            cRuns = 0,
+            s = signal(1);
+
+        let a = computed(() => {
+            aRuns++;
+
+            return read(s) + 1;
+        });
+
+        let b = computed(() => {
+            bRuns++;
+
+            return read(s) * 2;
+        });
+
+        let c = computed(() => {
+            cRuns++;
+
+            return read(a) + read(b);
+        });
+
+        let stop = effect(() => {
+            read(c);
+        });
+
+        expect(aRuns).toBe(1);
+        expect(bRuns).toBe(1);
+        expect(cRuns).toBe(1);
+        expect(peek(c)).toBe(4);
+
+        write(s, 2);
+        flush();
+
+        expect(aRuns).toBe(2);
+        expect(bRuns).toBe(2);
+        expect(cRuns).toBe(2);
+        expect(peek(c)).toBe(7);
+
+        stop();
+    });
+
+    it('a dynamic conditional dep does not over-recompute (DIRTY-break)', () => {
+        let a = signal(10),
+            b = signal(20),
+            cRuns = 0,
+            s = signal(true);
+
+        let c = computed(() => {
+            cRuns++;
+
+            return read(s) ? read(a) : read(b);
+        });
+
+        let stop = effect(() => {
+            read(c);
+        });
+
+        expect(cRuns).toBe(1);
+        expect(peek(c)).toBe(10);
+
+        // b is not a dep while s is true.
+        write(b, 99);
+        flush();
+
+        expect(cRuns).toBe(1);
+
+        write(s, false);
+        flush();
+
+        expect(cRuns).toBe(2);
+        expect(peek(c)).toBe(99);
+
+        // a is no longer a dep.
+        write(a, 5);
+        flush();
+
+        expect(cRuns).toBe(2);
+
+        stop();
+    });
+
+    it('teardown of a 200k-deep chain completes without overflow; cleanup fires once per node', () => {
+        let chain: ReturnType<typeof computed<number>>[] = [],
+            cleanups = 0,
+            s = signal(0);
+
+        chain[0] = computed((onCleanup) => {
+            onCleanup(() => cleanups++);
+
+            return read(s) + 1;
+        });
+
+        for (let i = 1; i < DEPTH; i++) {
+            let prev = chain[i - 1];
+
+            chain[i] = computed((onCleanup) => {
+                onCleanup(() => cleanups++);
+
+                return read(prev) + 1;
+            });
+        }
+
+        let stop = effect(() => {
+            read(chain[DEPTH - 1]);
+        });
+
+        stop();
+
+        expect(cleanups).toBe(DEPTH);
+
+        // Nothing survives to re-run.
+        write(s, 1);
+        flush();
+
+        expect(cleanups).toBe(DEPTH);
+    }, 30000);
+});

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

@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest';
 import { computed, effect, onCleanup, read, root, signal, write } from '~/system';
 import { ReactiveArray } from '~/reactive/array';
 import { ReactiveObject } from '~/reactive/object';
+import { waitFor } from './lib/wait-for';
 
 
 // These tests validate effect patterns from the compiler integration tests,
@@ -208,4 +209,63 @@ describe('effect patterns', () => {
             expect(lengths).toEqual([3, 4, 3, 2]);
         });
     });
+
+    describe('writes across an async boundary in a reaction', () => {
+        it('a write before the await propagates in the current flush; a write after the await propagates once settled', async () => {
+            let post = signal(0),
+                postSeen: number[] = [],
+                pre = signal(0),
+                preSeen: number[] = [],
+                trigger = signal(0);
+
+            root(() => {
+                effect(() => {
+                    preSeen.push(read(pre));
+                });
+
+                effect(() => {
+                    postSeen.push(read(post));
+                });
+
+                // Reaction writes `pre` synchronously (before the await) and `post` in the
+                // deferred continuation (after the await) — reactively's before/after-await case
+                effect(() => {
+                    let v = read(trigger);
+
+                    if (v > 0) {
+                        write(pre, v);
+                        setTimeout(() => write(post, v * 10), 10);
+                    }
+                });
+            });
+
+            // Baseline: observers hold the initial 0
+            expect(preSeen).toEqual([0]);
+            expect(postSeen).toEqual([0]);
+
+            write(trigger, 1);
+            await Promise.resolve();
+            await Promise.resolve();
+
+            // Before-await write already landed; after-await write still pending
+            expect(preSeen).toEqual([0, 1]);
+            expect(postSeen).toEqual([0]);
+
+            await waitFor(() => postSeen.length === 2, 'after-await write lands (post=10)');
+
+            // After-await write lands once the boundary settles
+            expect(postSeen).toEqual([0, 10]);
+
+            write(trigger, 2);
+            await Promise.resolve();
+            await Promise.resolve();
+
+            expect(preSeen).toEqual([0, 1, 2]);
+            expect(postSeen).toEqual([0, 10]);
+
+            await waitFor(() => postSeen.length === 3, 'second after-await write lands (post=20)');
+
+            expect(postSeen).toEqual([0, 10, 20]);
+        });
+    });
 });

package/test/equals.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest';
+import { computed, effect, flush, peek, read, signal, write } from '~/system';
+
+
+describe('custom equals', () => {
+    it('a signal with an always-true comparator never propagates (and never stores)', () => {
+        let runs = 0,
+            s = signal(0, () => true);
+
+        effect(() => {
+            runs++;
+            read(s);
+        });
+
+        expect(runs).toBe(1);
+
+        write(s, 1);
+        flush();
+
+        expect(runs).toBe(1);
+        expect(peek(s)).toBe(0);
+    });
+
+    it('Object.is suppresses a NaN re-write; the default === re-triggers on NaN', () => {
+        let defaultRuns = 0,
+            isRuns = 0,
+            sDefault = signal(NaN),
+            sIs = signal(NaN, Object.is);
+
+        effect(() => {
+            isRuns++;
+            read(sIs);
+        });
+
+        effect(() => {
+            defaultRuns++;
+            read(sDefault);
+        });
+
+        write(sIs, NaN);
+        flush();
+
+        expect(isRuns).toBe(1);
+
+        write(sDefault, NaN);
+        flush();
+
+        expect(defaultRuns).toBe(2);
+    });
+
+    it('a computed custom equals suppresses propagation while the cached value still updates', () => {
+        let cRuns = 0,
+            effectRuns = 0,
+            s = signal(1);
+
+        let c = computed(() => {
+            cRuns++;
+
+            return { parity: read(s) % 2, tick: cRuns };
+        }, (a, b) => a.parity === b.parity);
+
+        effect(() => {
+            effectRuns++;
+            read(c);
+        });
+
+        expect(cRuns).toBe(1);
+        expect(effectRuns).toBe(1);
+
+        write(s, 3);
+        flush();
+
+        expect(cRuns).toBe(2);
+        expect(effectRuns).toBe(1);
+        expect(peek(c).tick).toBe(2);
+
+        write(s, 2);
+        flush();
+
+        expect(effectRuns).toBe(2);
+        expect(peek(c).parity).toBe(0);
+    });
+
+    it('error recovery propagates under an always-true comparator (the hadError leg wins)', () => {
+        let log: number[] = [],
+            s = signal(0);
+
+        let c = computed(() => {
+            if (read(s) === 1) {
+                throw new Error('equals boom');
+            }
+
+            return 0;
+        }, () => true);
+
+        let d = computed(() => {
+            try {
+                return read(c);
+            }
+            catch {
+                return -1;
+            }
+        });
+
+        effect(() => {
+            log.push(read(d));
+        });
+
+        expect(log).toEqual([0]);
+
+        write(s, 1);
+        flush();
+
+        expect(log).toEqual([0, -1]);
+        expect(() => read(c)).toThrow('equals boom');
+
+        write(s, 0);
+        flush();
+
+        expect(log).toEqual([0, -1, 0]);
+    });
+
+    it('the default path is byte-identical: no comparator gates with ===', () => {
+        let runs = 0,
+            s = signal(1);
+
+        effect(() => {
+            runs++;
+            read(s);
+        });
+
+        write(s, 1);
+        flush();
+
+        expect(runs).toBe(1);
+
+        write(s, 2);
+        flush();
+
+        expect(runs).toBe(2);
+    });
+});