@esportsplus/reactivity 0.30.3 → 0.31.1

package/tests/system.ts

@@ -423,6 +423,27 @@ describe('onCleanup', () => {
         expect(returned).toBe(fn);
         expect(fn).not.toHaveBeenCalled();
     });
+
+    it('throwing cleanup skips subsequent cleanups in same array', () => {
+        let called: number[] = [],
+            c = computed((onCleanup) => {
+            onCleanup(() => { called.push(1); });
+            onCleanup(() => { called.push(2); throw new Error('cleanup boom'); });
+            onCleanup(() => { called.push(3); });
+            return 42;
+        });
+
+        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);
+    });
 });
 
 
@@ -478,6 +499,33 @@ describe('root', () => {
         expect(outer).toBe(1);
         expect(inner).toBe(1);
     });
+
+    it('tracks disposables counter for unowned computeds', () => {
+        let before = root.disposables;
+
+        root(() => {
+            computed(() => 1);
+            computed(() => 2);
+            computed(() => 3);
+        });
+
+        // root restores disposables to outer value after execution
+        expect(root.disposables).toBe(before);
+
+        // Nested: inner root creates computeds, outer root creates computeds
+        root(() => {
+            computed(() => 10);
+
+            root(() => {
+                computed(() => 20);
+                computed(() => 30);
+            });
+
+            computed(() => 40);
+        });
+
+        expect(root.disposables).toBe(before);
+    });
 });
 
 
@@ -548,10 +596,93 @@ describe('isComputed', () => {
         expect(isComputed(1)).toBe(false);
         expect(isComputed(null)).toBe(false);
     });
+
+    it('returns false for objects with state field but no STATE_COMPUTED bit', () => {
+        expect(isComputed({ state: 0 })).toBe(false);
+        expect(isComputed({ state: 1 })).toBe(false);
+    });
+});
+
+describe('computed object size', () => {
+    it('does not have a type field', () => {
+        let c = computed(() => 42);
+
+        expect('type' in c).toBe(false);
+    });
+
+    it('has fewer own properties than 14 (old size)', () => {
+        let c = computed(() => 42);
+
+        expect(Object.keys(c).length).toBeLessThan(14);
+    });
 });
 
 
 describe('edge cases', () => {
+    it('diamond graph dedup — notify state mask prevents redundant recomputation', async () => {
+        let s = signal(1),
+            calls = 0,
+            left = computed(() => read(s) + 1),
+            right = computed(() => read(s) * 2),
+            join = computed(() => {
+                calls++;
+                return read(left) + read(right);
+            });
+
+        effect(() => {
+            read(join);
+        });
+
+        expect(read(join)).toBe(4);
+        calls = 0;
+
+        write(s, 2);
+        await Promise.resolve();
+
+        expect(read(join)).toBe(7);
+        expect(calls).toBe(1);
+    });
+
+    it('dynamic height adjustment — correct ordering after switching deps', async () => {
+        let s = signal(1),
+            toggle = signal(true),
+            a = computed(() => read(s) + 1),
+            b = computed(() => read(a) + 1),
+            c = computed(() => read(b) + 1),
+            order: string[] = [],
+            d = computed(() => {
+                order.push('d');
+
+                if (read(toggle)) {
+                    return read(a);
+                }
+
+                return read(c);
+            });
+
+        effect(() => {
+            read(d);
+        });
+
+        expect(read(d)).toBe(2);
+        order.length = 0;
+
+        // Switch to reading `c` (height 3) instead of `a` (height 1)
+        write(toggle, false);
+        await Promise.resolve();
+
+        expect(read(d)).toBe(4);
+
+        order.length = 0;
+
+        // Write to source — d should recompute after c due to height adjustment
+        write(s, 10);
+        await Promise.resolve();
+
+        expect(read(d)).toBe(13);
+        expect(order).toEqual(['d']);
+    });
+
     it('handles circular computed reads without infinite loop', () => {
         let s = signal(0),
             c1 = computed(() => read(s)),
@@ -652,4 +783,382 @@ describe('edge cases', () => {
 
         expect(innerDisposed).toBe(true);
     });
+
+    it('stabilizer re-schedules when effect writes to signal during stabilization', async () => {
+        let a = signal(0),
+            b = signal(0),
+            bValues: number[] = [];
+
+        effect(() => {
+            let val = read(a);
+
+            if (val > 0) {
+                write(b, val * 100);
+            }
+        });
+
+        effect(() => {
+            bValues.push(read(b));
+        });
+
+        write(a, 3);
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(bValues).toEqual([0, 300]);
+    });
+
+    it('stabilizer re-schedules with nested write chain A → B → C', async () => {
+        let a = signal(0),
+            b = signal(0),
+            c = signal(0),
+            cValues: number[] = [];
+
+        effect(() => {
+            let val = read(a);
+
+            if (val > 0) {
+                write(b, val * 2);
+            }
+        });
+
+        effect(() => {
+            let val = read(b);
+
+            if (val > 0) {
+                write(c, val * 3);
+            }
+        });
+
+        effect(() => {
+            cValues.push(read(c));
+        });
+
+        write(a, 5);
+        await Promise.resolve();
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(cValues).toEqual([0, 30]);
+    });
+
+    it('computed that throws on update retains previous value', async () => {
+        let s = signal(0),
+            effectValues: number[] = [],
+            c = computed(() => {
+                let val = read(s);
+
+                if (val === 2) {
+                    throw new Error('boom');
+                }
+
+                return val * 10;
+            });
+
+        effect(() => {
+            effectValues.push(read(c));
+        });
+
+        expect(effectValues).toEqual([0]);
+
+        write(s, 1);
+        await Promise.resolve();
+
+        expect(effectValues).toEqual([0, 10]);
+        expect(read(c)).toBe(10);
+
+        write(s, 2);
+        await Promise.resolve();
+
+        // Value should remain 10 since throw prevented update
+        expect(read(c)).toBe(10);
+        expect(effectValues).toEqual([0, 10]);
+    });
+
+    it('computed alternates between throwing and succeeding', async () => {
+        let s = signal(0),
+            effectValues: number[] = [],
+            c = computed(() => {
+                let val = read(s);
+
+                if (val % 2 !== 0) {
+                    throw new Error('odd');
+                }
+
+                return val;
+            });
+
+        effect(() => {
+            effectValues.push(read(c));
+        });
+
+        expect(effectValues).toEqual([0]);
+
+        write(s, 1);
+        await Promise.resolve();
+
+        // Threw on odd, value stays 0
+        expect(read(c)).toBe(0);
+        expect(effectValues).toEqual([0]);
+
+        write(s, 2);
+        await Promise.resolve();
+
+        // Succeeds on even, 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);
+        expect(effectValues).toEqual([0, 2]);
+
+        write(s, 4);
+        await Promise.resolve();
+
+        // Succeeds again
+        expect(read(c)).toBe(4);
+        expect(effectValues).toEqual([0, 2, 4]);
+    });
+
+    it('heap auto-resizes for computed chain deeper than 64', async () => {
+        let s = signal(0),
+            chain: ReturnType<typeof computed>[] = [computed(() => read(s) + 1)];
+
+        for (let i = 1; i < 80; i++) {
+            let prev = chain[i - 1];
+
+            chain.push(computed(() => read(prev) + 1));
+        }
+
+        let tail = chain[chain.length - 1],
+            result = -1;
+
+        effect(() => {
+            result = read(tail);
+        });
+
+        expect(result).toBe(80);
+
+        write(s, 10);
+        await Promise.resolve();
+
+        expect(result).toBe(90);
+    });
+
+    it('system remains functional under high effect churn', async () => {
+        let s = signal(0),
+            stops: (() => void)[] = [];
+
+        for (let i = 0; i < 200; i++) {
+            stops.push(effect(() => { read(s); }));
+        }
+
+        for (let i = 0, n = stops.length; i < n; i++) {
+            stops[i]();
+        }
+
+        stops.length = 0;
+
+        let result = -1;
+
+        effect(() => {
+            result = read(s);
+        });
+
+        write(s, 42);
+        await Promise.resolve();
+
+        expect(result).toBe(42);
+
+        for (let i = 0; i < 200; i++) {
+            stops.push(effect(() => { read(s); }));
+        }
+
+        for (let i = 0, n = stops.length; i < n; i++) {
+            stops[i]();
+        }
+
+        write(s, 99);
+        await Promise.resolve();
+
+        expect(result).toBe(99);
+    });
+
+    it('write during stabilization triggers reschedule and computed sees updated value', async () => {
+        let s1 = signal(1),
+            s2 = signal(0),
+            c = computed(() => read(s2) * 10),
+            cValues: number[] = [];
+
+        // Effect 1: writes to s2 when s1 changes — triggers during stabilization
+        effect(() => {
+            let val = read(s1);
+
+            if (val > 1) {
+                write(s2, val);
+            }
+        });
+
+        // Effect 2: reads computed c which depends on s2
+        effect(() => {
+            cValues.push(read(c));
+        });
+
+        expect(cValues).toEqual([0]);
+
+        // Write s1 → effect1 runs during stabilization → writes s2=5
+        // → reschedule → c recomputes with s2=5 → effect2 sees 50
+        write(s1, 5);
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(cValues).toEqual([0, 50]);
+    });
+
+    it('diamond with write during stabilization propagates through both branches', async () => {
+        let source = signal(1),
+            trigger = signal(0),
+            left = computed(() => read(source) + 1),
+            right = computed(() => read(source) * 2),
+            join = computed(() => read(left) + read(right)),
+            joinValues: number[] = [];
+
+        // Effect that writes source during stabilization
+        effect(() => {
+            let val = read(trigger);
+
+            if (val > 0) {
+                write(source, val);
+            }
+        });
+
+        // Effect that reads the diamond join
+        effect(() => {
+            joinValues.push(read(join));
+        });
+
+        // Initial: source=1, left=2, right=2, join=4
+        expect(joinValues).toEqual([4]);
+
+        // trigger=10 → effect writes source=10 → reschedule
+        // left=11, right=20, join=31
+        write(trigger, 10);
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(joinValues).toEqual([4, 31]);
+    });
+
+    it('disposed computed does not prevent new computed from reading same signal', async () => {
+        let s = signal(10),
+            c1 = computed(() => read(s) * 2),
+            c2Values: number[] = [];
+
+        expect(read(c1)).toBe(20);
+
+        dispose(c1);
+
+        // After dispose, c1 retains its last computed value
+        expect(c1.value).toBe(20);
+
+        // New computed can read the same signal
+        let c2 = computed(() => read(s) + 5);
+
+        expect(read(c2)).toBe(15);
+
+        // Subscribe with an effect so c2 reacts to changes
+        effect(() => {
+            c2Values.push(read(c2));
+        });
+
+        expect(c2Values).toEqual([15]);
+
+        // Signal still propagates to new computed
+        write(s, 20);
+        await Promise.resolve();
+
+        expect(c2Values).toEqual([15, 25]);
+
+        // Disposed computed value is stale — not updated
+        expect(c1.value).toBe(20);
+    });
+
+    it('disposed computed retains last value and does not recompute', async () => {
+        let s = signal(1),
+            calls = 0,
+            c = computed(() => {
+                calls++;
+                return read(s) * 3;
+            }),
+            result = -1;
+
+        // Subscribe so it's in the heap
+        effect(() => {
+            result = read(c);
+        });
+
+        expect(result).toBe(3);
+        expect(calls).toBe(1);
+
+        dispose(c);
+
+        // After disposal, value is retained
+        expect(c.value).toBe(3);
+
+        write(s, 10);
+        await Promise.resolve();
+
+        // Not recomputed after dispose
+        expect(calls).toBe(1);
+        expect(c.value).toBe(3);
+    });
+
+    it('link pool handles >1000 dependencies with disposal and reuse', async () => {
+        let signals: ReturnType<typeof signal>[] = [],
+            stops: (() => void)[] = [];
+
+        for (let i = 0; i < 1100; i++) {
+            signals.push(signal(i));
+        }
+
+        // Create effect reading all 1100 signals
+        stops.push(effect(() => {
+            for (let i = 0, n = signals.length; i < n; i++) {
+                read(signals[i]);
+            }
+        }));
+
+        // Dispose to return links to pool
+        stops[0]();
+        stops.length = 0;
+
+        // Create new effects reusing pooled links
+        let sum = -1;
+
+        stops.push(effect(() => {
+            let total = 0;
+
+            for (let i = 0; i < 50; i++) {
+                total += read(signals[i]);
+            }
+
+            sum = total;
+        }));
+
+        // sum of 0..49 = 1225
+        expect(sum).toBe(1225);
+
+        write(signals[0], 100);
+        await Promise.resolve();
+
+        // 1225 - 0 + 100 = 1325
+        expect(sum).toBe(1325);
+
+        for (let i = 0, n = stops.length; i < n; i++) {
+            stops[i]();
+        }
+    });
 });

package/tests/tsconfig.json

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