@esportsplus/reactivity 0.33.0 → 0.36.0

package/test/reactive/nested.test.ts

@@ -63,7 +63,7 @@ describe('nested reactive patterns', () => {
             let todo1 = new ReactiveObject({ done: false, text: 'Learn reactivity' }) as any,
                 todo2 = new ReactiveObject({ done: true, text: 'Build app' }) as any,
                 todo3 = new ReactiveObject({ done: false, text: 'Test everything' }) as any,
-                todos = new ReactiveArray(todo1, todo2, todo3),
+                todos = new ReactiveArray([todo1, todo2, todo3]),
                 completedCounts: number[] = [];
 
             effect(() => {
@@ -88,7 +88,7 @@ describe('nested reactive patterns', () => {
 
         it('push new reactive object to array', () => {
             let todo1 = new ReactiveObject({ done: false, text: 'First' }) as any,
-                todos = new ReactiveArray(todo1);
+                todos = new ReactiveArray([todo1]);
 
             expect(todos.length).toBe(1);
 
@@ -104,10 +104,10 @@ describe('nested reactive patterns', () => {
 
     describe('matrix pattern', () => {
         it('array of arrays', () => {
-            let row1 = new ReactiveArray(1, 2, 3),
-                row2 = new ReactiveArray(4, 5, 6),
-                row3 = new ReactiveArray(7, 8, 9),
-                matrix = new ReactiveArray(row1, row2, row3);
+            let row1 = new ReactiveArray([1, 2, 3]),
+                row2 = new ReactiveArray([4, 5, 6]),
+                row3 = new ReactiveArray([7, 8, 9]),
+                matrix = new ReactiveArray([row1, row2, row3]);
 
             expect(matrix.length).toBe(3);
             expect([...matrix[0]]).toEqual([1, 2, 3]);
@@ -116,9 +116,9 @@ describe('nested reactive patterns', () => {
         });
 
         it('modifying inner array', () => {
-            let row1 = new ReactiveArray(1, 2, 3),
-                row2 = new ReactiveArray(4, 5, 6),
-                matrix = new ReactiveArray(row1, row2);
+            let row1 = new ReactiveArray([1, 2, 3]),
+                row2 = new ReactiveArray([4, 5, 6]),
+                matrix = new ReactiveArray([row1, row2]);
 
             row1.$set(0, 100);
             row2.push(60);
@@ -128,10 +128,10 @@ describe('nested reactive patterns', () => {
         });
 
         it('push new row to matrix', () => {
-            let row1 = new ReactiveArray(1, 2, 3),
-                matrix = new ReactiveArray(row1);
+            let row1 = new ReactiveArray([1, 2, 3]),
+                matrix = new ReactiveArray([row1]);
 
-            let row2 = new ReactiveArray(4, 5, 6);
+            let row2 = new ReactiveArray([4, 5, 6]);
 
             matrix.push(row2);
 
@@ -143,7 +143,7 @@ describe('nested reactive patterns', () => {
 
     describe('cross-object array + multiplier', () => {
         it('computed sum reacts to multiplier changes', async () => {
-            let items = new ReactiveArray(10, 20, 30),
+            let items = new ReactiveArray([10, 20, 30]),
                 multiplier = signal(2),
                 sum = computed(() => {
                     let total = 0;
@@ -171,7 +171,7 @@ describe('nested reactive patterns', () => {
         });
 
         it('computed sum reacts to reactive length changes', async () => {
-            let items = new ReactiveArray(10, 20, 30),
+            let items = new ReactiveArray([10, 20, 30]),
                 multiplier = signal(2),
                 sum = computed(() => {
                     let length = items.$length,

package/test/reactive/objects.test.ts

@@ -126,7 +126,7 @@ describe('reactive object patterns', () => {
         });
 
         it('array computed using reduce via external signal', async () => {
-            let items = new ReactiveArray(1, 2, 3),
+            let items = new ReactiveArray([1, 2, 3]),
                 total = computed(() => {
                     let sum = 0;
 

package/test/reactive/reactive.test.ts

@@ -391,6 +391,55 @@ describe('reactive()', () => {
             expect(() => reactive('hello' as any)).toThrow();
         });
     });
+
+
+    describe('auto-dispose', () => {
+        it('disposes an object with a computed property when its owning effect stops', async () => {
+            let s = signal(1),
+                runs = 0,
+                stop = effect(() => {
+                    reactive({
+                        doubled: () => {
+                            runs++;
+                            return read(s) * 2;
+                        }
+                    });
+                });
+
+            expect(runs).toBe(1);
+
+            stop();
+
+            write(s, 2);
+            await Promise.resolve();
+
+            expect(runs).toBe(1);
+        });
+
+        it('disposes nested objects of an array when its owning effect stops', () => {
+            let inner = new ReactiveObject({ x: 1 }),
+                spy = vi.spyOn(inner, 'dispose'),
+                stop = effect(() => {
+                    reactive([inner]);
+                });
+
+            stop();
+
+            expect(spy).toHaveBeenCalledTimes(1);
+        });
+
+        it('top-level reactive() is not auto-disposed', async () => {
+            let s = signal(1),
+                obj = reactive({ doubled: () => read(s) * 2 }) as any;
+
+            expect(obj.doubled).toBe(2);
+
+            write(s, 3);
+            await Promise.resolve();
+
+            expect(obj.doubled).toBe(6);
+        });
+    });
 });
 
 

package/test/system.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
-import { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, write } from '~/system';
+import { computed, dispose, effect, flush, isComputed, isSignal, onCleanup, peek, read, root, signal, write } from '~/system';
 import { waitFor } from './lib/wait-for';
 
 
@@ -576,32 +576,32 @@ describe('root', () => {
         expect(inner).toBe(1);
     });
 
-    it('tracks disposables counter for unowned computeds', () => {
-        let before = root.disposables;
+    it('restores scope when an inner root throws', () => {
+        let spy = vi.fn(),
+            stop: VoidFunction | undefined;
 
-        root(() => {
-            computed(() => 1);
-            computed(() => 2);
-            computed(() => 3);
-        });
+        root((dispose) => {
+            stop = dispose;
 
-        // root restores disposables to outer value after execution
-        expect(root.disposables).toBe(before);
+            try {
+                root((inner) => {
+                    inner;
+                    throw new Error('reactivity: inner boom');
+                });
+            }
+            catch {
+            }
 
-        // Nested: inner root creates computeds, outer root creates computeds
-        root(() => {
-            computed(() => 10);
+            onCleanup(spy);
+        });
 
-            root(() => {
-                computed(() => 20);
-                computed(() => 30);
-            });
+        expect(spy).not.toHaveBeenCalled();
 
-            computed(() => 40);
-        });
+        stop!();
 
-        expect(root.disposables).toBe(before);
+        expect(spy).toHaveBeenCalledTimes(1);
     });
+
 });
 
 
@@ -686,10 +686,19 @@ describe('computed object size', () => {
         expect('type' in c).toBe(false);
     });
 
-    it('has no more own properties than 16 (14 slimmed + gv + rv)', () => {
+    it('has no more own properties than 17 (14 slimmed + gv + rv + pending)', () => {
         let c = computed(() => 42);
 
-        expect(Object.keys(c).length).toBeLessThanOrEqual(16);
+        expect(Object.keys(c).length).toBeLessThanOrEqual(17);
+    });
+
+    it('shares one shape between sync and async computeds', () => {
+        let a = computed(() => 42),
+            b = computed(() => Promise.resolve(42));
+
+        expect(Object.keys(a)).toEqual(Object.keys(b));
+        expect(a.pending).toBeNull();
+        expect(isSignal(b.pending)).toBe(true);
     });
 });
 
@@ -793,6 +802,105 @@ describe('globalVersion fast path', () => {
 });
 
 
+describe('stale reads after a pass', () => {
+    it('an observer created between a write and its flush never sees the stale value', async () => {
+        let s = signal(0),
+            c = computed(() => read(s)),
+            seen: number[] = [];
+
+        write(s, 1);
+        flush();
+
+        write(s, 2);
+
+        effect(() => {
+            seen.push(read(c));
+        });
+
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(seen[0]).toBe(2);
+        expect(seen).not.toContain(1);
+        expect(read(c)).toBe(2);
+    });
+
+    it('a computed created between a write and its flush computes from the new value', async () => {
+        let s = signal(0),
+            seen: number[] = [];
+
+        write(s, 1);
+        flush();
+
+        write(s, 2);
+
+        effect(() => {
+            let c = computed(() => read(s) * 10);
+
+            seen.push(read(c));
+        });
+
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(seen[0]).toBe(20);
+        expect(seen).not.toContain(10);
+    });
+});
+
+
+describe('same-height stabilization', () => {
+    it('settles a sibling pulled from the active heap bucket', () => {
+        let s = signal(0),
+            flag = signal(false),
+            M = computed(() => 0),
+            N = computed(() => read(flag) ? (read(M), read(s), 0) : 0),
+            R = computed(() => read(s) + read(N));
+
+        effect(() => { read(R); });
+        effect(() => { read(N); });
+        effect(() => { read(M); });
+
+        write(flag, true);
+        flush();
+        write(s, 1);
+
+        expect(() => {
+            peek(M);
+            flush();
+        }).not.toThrow();
+        expect(read(R)).toBe(1);
+    });
+
+    it('observes one settled value per write when a sibling grows', () => {
+        let s = signal(0),
+            flag = signal(false),
+            M = computed(() => 0),
+            N = computed(() => read(flag) ? read(M) + read(s) : 0),
+            values: number[] = [],
+            R = computed(() => {
+                let value = read(s) + read(N);
+
+                values.push(value);
+
+                return value;
+            });
+
+        effect(() => { read(R); });
+        effect(() => { read(N); });
+        effect(() => { read(M); });
+
+        write(flag, true);
+        flush();
+        values.length = 0;
+        write(s, 1);
+        flush();
+
+        expect(values).toEqual([2]);
+    });
+});
+
+
 describe('edge cases', () => {
     it('diamond graph dedup — notify state mask prevents redundant recomputation', async () => {
         let s = signal(1),