@esportsplus/reactivity 0.31.3 → 0.33.0

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

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

@@ -1,5 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
 import { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, write } from '~/system';
+import { waitFor } from './lib/wait-for';
 
 
 describe('signal', () => {
@@ -424,7 +425,7 @@ describe('onCleanup', () => {
         expect(fn).not.toHaveBeenCalled();
     });
 
-    it('throwing cleanup skips subsequent cleanups in same array', () => {
+    it('throwing cleanup still runs subsequent cleanups and rethrows to the dispose caller', () => {
         let called: number[] = [],
             c = computed((onCleanup) => {
             onCleanup(() => { called.push(1); });
@@ -435,14 +436,89 @@ describe('onCleanup', () => {
 
         expect(called).toEqual([]);
 
-        // dispose() calls cleanup() synchronously — no try/catch wraps it
-        // cleanup iterates the array: index 0 (push 1), index 1 (push 2, throws)
-        // index 2 (push 3) is never reached because no try/catch in cleanup()
         expect(() => dispose(c)).toThrow('cleanup boom');
 
-        expect(called).toContain(1);
-        expect(called).toContain(2);
-        expect(called).not.toContain(3);
+        // Every disposer ran despite the throw
+        expect(called).toEqual([1, 2, 3]);
+        expect(c.cleanup).toBe(null);
+    });
+
+    it('single throwing cleanup rethrows the exact error', () => {
+        let error = new Error('solo boom'),
+            c = computed((onCleanup) => {
+                onCleanup(() => { throw error; });
+                return 1;
+            });
+
+        try {
+            dispose(c);
+            expect.unreachable();
+        }
+        catch (e) {
+            expect(e).toBe(error);
+        }
+    });
+
+    it('multiple throwing cleanups aggregate into AggregateError with all captured', () => {
+        let called: number[] = [],
+            c = computed((onCleanup) => {
+                onCleanup(() => { called.push(1); throw new Error('first'); });
+                onCleanup(() => { called.push(2); throw new Error('second'); });
+                onCleanup(() => { called.push(3); });
+                return 1;
+            });
+
+        try {
+            dispose(c);
+            expect.unreachable();
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(AggregateError);
+            expect((e as AggregateError).errors.map((x) => (x as Error).message)).toEqual(['first', 'second']);
+        }
+
+        expect(called).toEqual([1, 2, 3]);
+        expect(c.cleanup).toBe(null);
+    });
+
+    it('throwing cleanup during recompute does not abort the stabilize pass', async () => {
+        let s = signal(0),
+            captured: unknown[] = [],
+            listeners = process.listeners('uncaughtException'),
+            otherValues: number[] = [],
+            values: number[] = [];
+
+        effect(() => {
+            values.push(read(s));
+            onCleanup(() => { throw new Error('teardown boom'); });
+        });
+
+        effect(() => {
+            otherValues.push(read(s));
+        });
+
+        process.removeAllListeners('uncaughtException');
+        process.on('uncaughtException', (e) => { captured.push(e); });
+
+        try {
+            write(s, 1);
+            await waitFor(() => captured.length === 1, 'teardown error surfaces as uncaught');
+        }
+        finally {
+            process.removeAllListeners('uncaughtException');
+
+            for (let i = 0, n = listeners.length; i < n; i++) {
+                process.on('uncaughtException', listeners[i]);
+            }
+        }
+
+        // Both effects re-ran — the pass survived the teardown failure
+        expect(values).toEqual([0, 1]);
+        expect(otherValues).toEqual([0, 1]);
+
+        // And the teardown error surfaced as an uncaught microtask exception
+        expect(captured.length).toBe(1);
+        expect((captured[0] as Error).message).toBe('teardown boom');
     });
 });
 
@@ -610,10 +686,109 @@ describe('computed object size', () => {
         expect('type' in c).toBe(false);
     });
 
-    it('has fewer own properties than 14 (old size)', () => {
+    it('has no more own properties than 16 (14 slimmed + gv + rv)', () => {
         let c = computed(() => 42);
 
-        expect(Object.keys(c).length).toBeLessThan(14);
+        expect(Object.keys(c).length).toBeLessThanOrEqual(16);
+    });
+});
+
+describe('globalVersion fast path', () => {
+    it('a computed pulled by two tracked readers in one settle runs its fn at most once with correct values', async () => {
+        let cRuns = 0,
+            s = signal(0),
+            seen1: number[] = [],
+            seen2: number[] = [];
+
+        let c = computed(() => {
+                cRuns++;
+
+                return read(s) + 1;
+            });
+
+        effect(() => {
+            if (read(s) > 0) {
+                seen1.push(read(c));
+            }
+        });
+
+        effect(() => {
+            if (read(s) > 0) {
+                seen2.push(read(c));
+            }
+        });
+
+        cRuns = 0;
+
+        write(s, 1);
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(cRuns).toBe(1);
+        expect(seen1[seen1.length - 1]).toBe(2);
+        expect(seen2[seen2.length - 1]).toBe(2);
+    });
+
+    it('write during recompute leaves the racing node validating normally (no stale skip)', async () => {
+        let s = signal(0),
+            t = signal(0);
+
+        let c = computed(() => {
+                let v = read(s);
+
+                if (v > 0) {
+                    write(t, v * 10);
+                }
+
+                return v;
+            });
+
+        let d = computed(() => read(t) + read(c));
+
+        effect(() => {
+            read(d);
+        });
+
+        write(s, 2);
+        await Promise.resolve();
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(read(t)).toBe(20);
+        expect(read(c)).toBe(2);
+        expect(read(d)).toBe(22);
+    });
+
+    it('a fresh signal write invalidates the fast path (no stale skip across a settle boundary)', async () => {
+        let cRuns = 0,
+            s = signal(1),
+            seen: number[] = [];
+
+        let c = computed(() => {
+                cRuns++;
+
+                return read(s) * 2;
+            });
+
+        effect(() => {
+            seen.push(read(c));
+        });
+
+        expect(seen[seen.length - 1]).toBe(2);
+
+        write(s, 5);
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(read(c)).toBe(10);
+        expect(seen[seen.length - 1]).toBe(10);
+
+        write(s, 7);
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(read(c)).toBe(14);
+        expect(seen[seen.length - 1]).toBe(14);
     });
 });
 
@@ -842,8 +1017,9 @@ describe('edge cases', () => {
         expect(cValues).toEqual([0, 30]);
     });
 
-    it('computed that throws on update retains previous value', async () => {
+    it('computed that throws on update caches the error and rethrows at read', async () => {
         let s = signal(0),
+            effectErrors: unknown[] = [],
             effectValues: number[] = [],
             c = computed(() => {
                 let val = read(s);
@@ -856,7 +1032,12 @@ describe('edge cases', () => {
             });
 
         effect(() => {
-            effectValues.push(read(c));
+            try {
+                effectValues.push(read(c));
+            }
+            catch (e) {
+                effectErrors.push(e);
+            }
         });
 
         expect(effectValues).toEqual([0]);
@@ -870,13 +1051,16 @@ describe('edge cases', () => {
         write(s, 2);
         await Promise.resolve();
 
-        // Value should remain 10 since throw prevented update
-        expect(read(c)).toBe(10);
+        // Error propagates to the subscribed effect and rethrows at read
+        expect(() => read(c)).toThrow('boom');
+        expect(effectErrors.length).toBe(1);
+        expect((effectErrors[0] as Error).message).toBe('boom');
         expect(effectValues).toEqual([0, 10]);
     });
 
     it('computed alternates between throwing and succeeding', async () => {
         let s = signal(0),
+            effectErrors: unknown[] = [],
             effectValues: number[] = [],
             c = computed(() => {
                 let val = read(s);
@@ -889,7 +1073,12 @@ describe('edge cases', () => {
             });
 
         effect(() => {
-            effectValues.push(read(c));
+            try {
+                effectValues.push(read(c));
+            }
+            catch (e) {
+                effectErrors.push(e);
+            }
         });
 
         expect(effectValues).toEqual([0]);
@@ -897,22 +1086,24 @@ describe('edge cases', () => {
         write(s, 1);
         await Promise.resolve();
 
-        // Threw on odd, value stays 0
-        expect(read(c)).toBe(0);
+        // Threw on odd, error cached and rethrown at read
+        expect(() => read(c)).toThrow('odd');
+        expect(effectErrors.length).toBe(1);
         expect(effectValues).toEqual([0]);
 
         write(s, 2);
         await Promise.resolve();
 
-        // Succeeds on even, value updates
+        // Succeeds on even, error cleared, value updates
         expect(read(c)).toBe(2);
         expect(effectValues).toEqual([0, 2]);
 
         write(s, 3);
         await Promise.resolve();
 
-        // Threw on odd again, value stays 2
-        expect(read(c)).toBe(2);
+        // Threw on odd again — the error caches on the Nth failure too
+        expect(() => read(c)).toThrow('odd');
+        expect(effectErrors.length).toBe(2);
         expect(effectValues).toEqual([0, 2]);
 
         write(s, 4);

package/test/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "extends": "../tsconfig.json",
+    "compilerOptions": {
+        "noEmit": true,
+        "paths": {
+            "~/*": [
+                "../src/*"
+            ]
+        },
+        "rootDir": ".."
+    },
+    "include": [
+        "./**/*",
+        "../src/**/*"
+    ]
+}

package/test/untrack.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, it } from 'vitest';
+import { computed, effect, peek, read, signal, untrack, write } from '~/system';
+
+
+describe('untrack', () => {
+    it('does not re-run an effect for a signal read only inside untrack, and sees current values', async () => {
+        let a = signal(1),
+            b = signal(10),
+            calls = 0,
+            seenB: number[] = [];
+
+        effect(() => {
+            read(a);
+            seenB.push(untrack(() => read(b)));
+            calls++;
+        });
+
+        expect(calls).toBe(1);
+        expect(seenB).toEqual([10]);
+
+        write(b, 20);
+        await Promise.resolve();
+
+        // b changed but was only ever read inside untrack — the effect must not re-run
+        expect(calls).toBe(1);
+
+        write(a, 2);
+        await Promise.resolve();
+
+        // a re-runs the effect; the untracked read of b picks up its current value
+        expect(calls).toBe(2);
+        expect(seenB).toEqual([10, 20]);
+    });
+
+    it('restores the observer when fn throws, so a later read in the same effect still tracks', async () => {
+        let a = signal(1),
+            b = signal(1),
+            calls = 0;
+
+        effect(() => {
+            calls++;
+
+            try {
+                untrack(() => {
+                    throw new Error('untrack boom');
+                });
+            }
+            catch {
+                // swallow — only the observer-restoration-after-throw behavior is under test
+            }
+
+            read(a);
+            read(b);
+        });
+
+        expect(calls).toBe(1);
+
+        write(a, 2);
+        await Promise.resolve();
+
+        expect(calls).toBe(2);
+
+        write(b, 2);
+        await Promise.resolve();
+
+        expect(calls).toBe(3);
+    });
+
+    it('returns the value fn produces', () => {
+        expect(untrack(() => 42)).toBe(42);
+    });
+});
+
+
+describe('peek', () => {
+    it('returns the current value of a signal', () => {
+        let s = signal(5);
+
+        expect(peek(s)).toBe(5);
+
+        write(s, 6);
+
+        expect(peek(s)).toBe(6);
+    });
+
+    it('returns the up-to-date value of a dirty computed without subscribing', async () => {
+        let s = signal(1),
+            c = computed(() => read(s) * 2),
+            writerRuns = 0;
+
+        effect(() => {
+            read(c);
+        });
+
+        effect(() => {
+            read(s);
+            writerRuns++;
+        });
+
+        expect(writerRuns).toBe(1);
+
+        write(s, 5);
+
+        // No await — c is queued/dirty, stabilize() has not run yet
+        expect(peek(c)).toBe(10);
+
+        // peek must not create a subscription: the writer effect's run count is untouched
+        expect(writerRuns).toBe(1);
+
+        await Promise.resolve();
+        await Promise.resolve();
+    });
+
+    it('does not add a dependency link when called from inside a tracking scope', async () => {
+        let s = signal(1),
+            c = computed(() => read(s) * 2),
+            caller = computed(() => peek(c));
+
+        expect(read(caller)).toBe(2);
+        expect(caller.deps).toBe(null);
+
+        write(s, 5);
+        await Promise.resolve();
+        await Promise.resolve();
+
+        // caller never subscribed to c, so it does not react to s changing
+        expect(read(caller)).toBe(2);
+    });
+
+    it('rethrows the cached error for an errored computed', () => {
+        let s = signal(0),
+            c = computed(() => {
+                if (read(s) > 0) {
+                    throw new Error('peek boom');
+                }
+
+                return read(s);
+            });
+
+        expect(peek(c)).toBe(0);
+
+        write(s, 1);
+
+        expect(() => peek(c)).toThrow('peek boom');
+    });
+});

package/vitest.config.ts

@@ -11,8 +11,8 @@ export default defineConfig({
     },
     test: {
         benchmark: {
-            include: ['tests/bench/**/*.ts']
+            include: ['bench/**/*.bench.ts']
         },
-        include: ['tests/*.ts']
+        include: ['test/**/*.test.ts']
     }
 });