@esportsplus/reactivity 0.33.0 → 0.36.0

package/src/system.ts

@@ -1,7 +1,7 @@
 import {
     PACKAGE_NAME,
     SIGNAL,
-    STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
+    STABILIZER_DEFERRED, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
     STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING
 } from './constants';
 import { Computed, ComputedResult, Link, SelectorSignal, Settled, Signal } from './types';
@@ -28,6 +28,8 @@ let asyncMeta = new WeakMap<Computed<unknown>, { factory: Computed<unknown> }>()
     notified = false,
     observer: Computed<unknown> | null = null,
     pendingHead: Signal<unknown> | null = null,
+    pulled: Computed<unknown> | null = null,
+    puller: Computed<unknown> | null = null,
     scope: Computed<unknown> | null = null,
     stabilizer = STABILIZER_IDLE,
     version = 0,
@@ -35,6 +37,9 @@ let asyncMeta = new WeakMap<Computed<unknown>, { factory: Computed<unknown> }>()
     writes = 0;
 
 
+function noop() {
+}
+
 function walkPop(walk: Walk): Walk | null {
     let prev = walk.prev;
 
@@ -129,8 +134,8 @@ function deleteFromHeap<T>(computed: Computed<T>) {
     computed.prevHeap = computed;
 }
 
-// Reconstructs main's eager write() fan-out in one batched pass: N writes to one signal
-// queue it once, so each subscriber is heap-inserted once. Self-linked nextPending marks the tail.
+// N writes to one signal queue it once, so each subscriber is heap-inserted once. A self-linked
+// nextPending marks the tail.
 function drainPending() {
     let node = pendingHead;
 
@@ -180,6 +185,10 @@ function insertIntoHeap<T>(computed: Computed<T>) {
             heap.length = Math.max(height + 1, Math.ceil(heap.length * 2));
         }
     }
+    // heap_i is only non-zero inside a pass: a bucket it already scanned needs another pass
+    else if (height < heap_i) {
+        stabilizer = STABILIZER_RESCHEDULE;
+    }
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
@@ -305,7 +314,8 @@ function notify<T>(computed: Computed<T>, newState: number) {
 }
 
 // Shared by read()'s tracked pull and peek()'s untracked pull. observer is nulled around update()
-// so a recompute triggered here tracks into the node's own scope, never the caller's.
+// so a recompute triggered here tracks into the node's own scope, never the caller's. pulled/puller
+// let propagate() skip re-queueing the caller: it receives the fresh value when this returns.
 function pull<T>(node: Computed<T>): void {
     if (!notified) {
         notified = true;
@@ -319,16 +329,33 @@ function pull<T>(node: Computed<T>): void {
 
     let o = observer;
 
+    // Cleared rather than restored: an outer pull then merely fails to skip, which is only a re-run
     observer = null;
+    pulled = node as Computed<unknown>;
+    puller = o;
     update(node);
     observer = o;
+    pulled = null;
+    puller = null;
 }
 
 function propagate<T>(computed: Computed<T>) {
-    for (let c = computed.subs; c; c = c.nextSub) {
+    let c = computed.subs;
+
+    if (c === null) {
+        return;
+    }
+
+    let skip = (computed as Computed<unknown>) === pulled ? puller : null;
+
+    for (; c; c = c.nextSub) {
         let s = c.sub,
             state = s.state;
 
+        if (s === skip) {
+            continue;
+        }
+
         if (state & STATE_CHECK) {
             s.state = state | STATE_DIRTY;
         }
@@ -339,14 +366,10 @@ function propagate<T>(computed: Computed<T>) {
     schedule();
 }
 
-function recompute<T>(computed: Computed<T>, del: boolean) {
-    if (del) {
+function recompute<T>(computed: Computed<T>) {
+    if (computed.state & STATE_IN_HEAP) {
         deleteFromHeap(computed);
     }
-    else {
-        computed.nextHeap = undefined;
-        computed.prevHeap = computed;
-    }
 
     if (computed.cleanup) {
         // A failing PREVIOUS generation's teardown must not poison this recompute or the stabilize pass
@@ -387,7 +410,8 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
     // Fresh version so rv/link stamps from this run (incl. nested creations) go stale — false negatives only
     version++;
     observer = o;
-    computed.state = STATE_COMPUTED | flags;
+    // fn may have re-queued this node (a tracked read drains pending writes), so heap membership survives
+    computed.state = STATE_COMPUTED | flags | (computed.state & STATE_IN_HEAP);
     // Entry snapshot, not current writes: a node whose fn wrote mid-run must stay gv < writes and validate normally
     computed.gv = w;
 
@@ -437,61 +461,62 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
             propagate(computed);
         }
     }
+
+    // A schedule() requested while depth > 0 is parked as DEFERRED and queued once the outermost
+    // recompute returns
+    if (!depth && stabilizer === STABILIZER_DEFERRED) {
+        stabilizer = STABILIZER_SCHEDULED;
+        microtask(stabilize);
+    }
 }
 
 function schedule() {
-    if (stabilizer === STABILIZER_SCHEDULED) {
+    if (stabilizer !== STABILIZER_IDLE) {
         return;
     }
 
-    if (stabilizer === STABILIZER_IDLE && !depth) {
+    if (depth) {
+        stabilizer = STABILIZER_DEFERRED;
+    }
+    else {
         stabilizer = STABILIZER_SCHEDULED;
         microtask(stabilize);
     }
-    else if (stabilizer === STABILIZER_RUNNING) {
-        stabilizer = STABILIZER_RESCHEDULE;
-    }
 }
 
+// Buckets are popped from the head so a node queued at the current height mid-pass (a write drained
+// by a tracked read) settles in this pass, and the heap stays intact for deleteFromHeap() when a
+// recompute pulls a same-height sibling. A write that lands below heap_i flags RESCHEDULE.
 function stabilize() {
     let o = observer;
 
     observer = null;
-    stabilizer = STABILIZER_RUNNING;
-
-    for (heap_i = 0; heap_i <= heap_n; heap_i++) {
-        // Drain before scanning each height so writes emitted by a lower level's recompute
-        // land their subscribers in this same pass, matching main's eager same-pass pickup
-        if (pendingHead !== null) {
-            drainPending();
-        }
 
-        let computed = heap[heap_i];
+    do {
+        stabilizer = STABILIZER_RUNNING;
 
-        heap[heap_i] = undefined;
+        for (heap_i = 0; heap_i <= heap_n; heap_i++) {
+            if (pendingHead !== null) {
+                drainPending();
+            }
 
-        while (computed !== undefined) {
-            let next = computed.nextHeap;
+            let computed;
 
-            recompute(computed, false);
+            while ((computed = heap[heap_i]) !== undefined) {
+                recompute(computed);
+            }
+        }
 
-            computed = next;
+        while (heap_n > 0 && heap[heap_n] === undefined) {
+            heap_n--;
         }
-    }
 
-    while (heap_n > 0 && heap[heap_n] === undefined) {
-        heap_n--;
+        heap_i = 0;
     }
+    while (pendingHead !== null || stabilizer === STABILIZER_RESCHEDULE);
 
+    stabilizer = STABILIZER_IDLE;
     observer = o;
-
-    if (stabilizer === STABILIZER_RESCHEDULE) {
-        stabilizer = STABILIZER_SCHEDULED;
-        microtask(stabilize);
-    }
-    else {
-        stabilizer = STABILIZER_IDLE;
-    }
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
@@ -555,7 +580,7 @@ function update<T>(root: Computed<T>): void {
                 resuming = true;
             }
             else if (node.state & STATE_DIRTY) {
-                recompute(node, true);
+                recompute(node);
                 node.state &= ~STATE_NOTIFY_MASK;
             }
             else {
@@ -585,7 +610,7 @@ function update<T>(root: Computed<T>): void {
             }
 
             if (node.state & STATE_DIRTY) {
-                recompute(node, true);
+                recompute(node);
             }
             else {
                 node.gv = w;
@@ -617,24 +642,33 @@ function makeAsyncComputed<T>(factory: Computed<Promise<T> | AsyncIterable<T> |
         v = 0;
 
     let stop = effect(() => {
-        let fail = (e: unknown) => {
-                if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+        let id = ++v,
+            // A settle is stale once a newer dispatch exists or the factory has a re-run queued. Pending
+            // writes are drained first so a write that dirtied the factory but has not been settled yet
+            // still counts, whatever the microtask order.
+            stale = () => {
+                if (pendingHead !== null) {
+                    drainPending();
+                }
+
+                return id !== v || (factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK)) !== 0;
+            },
+            fail = (e: unknown) => {
+                if (!stale()) {
                     write(error, e === undefined ? new Error('reactivity: async computed rejected with undefined') : e);
                     write(pending, false);
                 }
             },
-            id = ++v,
-            // Heap membership (a write's eager insert) marks a pending re-run the notify mask alone misses.
             result = read(factory);
 
         if (isPromise(result)) {
-            if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+            if (!stale()) {
                 write(pending, true);
             }
 
             (result as Promise<T>).then(
                 (value) => {
-                    if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+                    if (!stale()) {
                         write(error, undefined);
                         write(node, value);
                         write(pending, false);
@@ -651,7 +685,7 @@ function makeAsyncComputed<T>(factory: Computed<Promise<T> | AsyncIterable<T> |
             });
 
             let step = (r: IteratorResult<T>) => {
-                if (id !== v || (factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+                if (stale()) {
                     return;
                 }
 
@@ -666,7 +700,7 @@ function makeAsyncComputed<T>(factory: Computed<Promise<T> | AsyncIterable<T> |
                 }
             };
 
-            if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+            if (!stale()) {
                 write(pending, true);
             }
 
@@ -689,7 +723,7 @@ function makeAsyncComputed<T>(factory: Computed<Promise<T> | AsyncIterable<T> |
             return read(node);
         });
 
-    (wrapper as Computed<T | undefined> & { pending: Signal<boolean> }).pending = pending;
+    wrapper.pending = pending;
 
     asyncMeta.set(wrapper as Computed<unknown>, { factory: factory as Computed<unknown> });
     wrapper.disposal = stop;
@@ -698,38 +732,19 @@ function makeAsyncComputed<T>(factory: Computed<Promise<T> | AsyncIterable<T> |
 }
 
 function makeComputed<T>(fn: Computed<T>['fn'], eager: boolean = false): Computed<T> {
-    let self: Computed<T> = {
-            cleanup: null,
-            deps: null,
-            depsTail: null,
-            disposal: null,
-            equals: null,
-            error: null,
-            fn: fn,
-            gv: 0,
-            height: 0,
-            nextHeap: undefined,
-            prevHeap: null as unknown as Computed<unknown>,
-            rv: 0,
-            state: STATE_COMPUTED,
-            subs: null,
-            subsTail: null,
-            value: undefined as T,
-        };
-
-    self.prevHeap = self;
+    let self = makeNode(fn);
 
     if (observer) {
         if (observer.depsTail === null) {
             self.height = observer.height;
-            recompute(self, false);
+            recompute(self);
         }
         else if (eager) {
             // computed() must know fn's return type to pick sync vs async. This probe runs BEFORE
             // link() below, so self has no subs yet — recompute's propagate is a no-op and cannot
             // re-run the parent. Deferring here (as effect() still does) would leave value unset.
             self.height = observer.height + 1;
-            recompute(self, false);
+            recompute(self);
         }
         else {
             self.height = observer.height + 1;
@@ -741,8 +756,7 @@ function makeComputed<T>(fn: Computed<T>['fn'], eager: boolean = false): Compute
         onCleanup(() => dispose(self));
     }
     else {
-        recompute(self, false);
-        root.disposables++;
+        recompute(self);
 
         if (scope) {
             onCleanup(() => dispose(self));
@@ -752,6 +766,34 @@ function makeComputed<T>(fn: Computed<T>['fn'], eager: boolean = false): Compute
     return self;
 }
 
+// Every node, including root()'s cleanup-only scope, is built here so dispose() and onCleanup()
+// only ever see one hidden class.
+function makeNode<T>(fn: Computed<T>['fn']): Computed<T> {
+    let self: Computed<T> = {
+            cleanup: null,
+            deps: null,
+            depsTail: null,
+            disposal: null,
+            equals: null,
+            error: null,
+            fn,
+            gv: 0,
+            height: 0,
+            nextHeap: undefined,
+            pending: null,
+            prevHeap: null as unknown as Computed<unknown>,
+            rv: 0,
+            state: STATE_COMPUTED,
+            subs: null,
+            subsTail: null,
+            value: undefined as T,
+        };
+
+    self.prevHeap = self;
+
+    return self;
+}
+
 // Reuses the same recompute-nesting counter schedule() consults, so writes inside fn defer
 // scheduling until fn returns; pair with flush() for a synchronous transaction.
 const batch = <T>(fn: () => T): T => {
@@ -763,8 +805,9 @@ const batch = <T>(fn: () => T): T => {
     finally {
         depth--;
 
-        if (!depth) {
-            schedule();
+        if (!depth && stabilizer === STABILIZER_DEFERRED) {
+            stabilizer = STABILIZER_SCHEDULED;
+            microtask(stabilize);
         }
     }
 };
@@ -896,13 +939,9 @@ const effect = <T>(fn: Computed<T>['fn'], apply?: (value: T, prev: T | undefined
     };
 };
 
-// RUNNING/RESCHEDULE means a pass is already draining (or a flush is already in this call chain);
-// re-entering stabilize here would corrupt heap_i, so this is a deliberate no-op.
-// Loops (not a single call): a write during a pass can target a height stabilize()'s current
-// pass already scanned past, which only flips stabilizer to RESCHEDULE for the *next* microtask
-// rather than draining in-pass — looping here is what actually settles that tail synchronously.
+// A no-op while a pass is running: re-entering stabilize() would corrupt heap_i.
 const flush = (): void => {
-    while (stabilizer === STABILIZER_SCHEDULED) {
+    if (stabilizer === STABILIZER_SCHEDULED) {
         stabilize();
     }
 };
@@ -958,8 +997,8 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
         link(node, observer);
 
         if ((node as Computed<unknown>).state & STATE_COMPUTED) {
-            // Invariant 1: a tracked mid-cycle read must see pending writes — drain so the heap
-            // and this node's notify bits reflect them before the broadcast condition is read
+            // A tracked read must see pending writes: drain so the heap and this node's notify
+            // bits reflect them before the pull gate below is evaluated
             if (pendingHead !== null) {
                 drainPending();
             }
@@ -985,7 +1024,6 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
 
 const root = <T>(fn: ((dispose: VoidFunction) => T) | (() => T)) => {
     let c,
-        d = root.disposables,
         o = observer,
         s = scope,
         self: Computed<unknown> | null = null,
@@ -993,21 +1031,22 @@ const root = <T>(fn: ((dispose: VoidFunction) => T) | (() => T)) => {
         value: T;
 
     observer = null;
-    root.disposables = 0;
 
-    if (tracking) {
-        scope = self = { cleanup: null, state: STATE_COMPUTED } as Computed<unknown>;
-        value = (fn as (dispose: VoidFunction) => T)(c = () => dispose(self!));
+    try {
+        if (tracking) {
+            scope = self = makeNode(noop);
+            value = (fn as (dispose: VoidFunction) => T)(c = () => dispose(self!));
+        }
+        else {
+            scope = null;
+            value = (fn as () => T)();
+        }
     }
-    else {
-        scope = null;
-        value = (fn as () => T)();
+    finally {
+        observer = o;
+        scope = s;
     }
 
-    observer = o;
-    root.disposables = d;
-    scope = s;
-
     if (c) {
         onCleanup(c);
     }
@@ -1015,8 +1054,6 @@ const root = <T>(fn: ((dispose: VoidFunction) => T) | (() => T)) => {
     return value;
 };
 
-root.disposables = 0;
-
 const signal = <T>(value: T, equals: ((a: T, b: T) => boolean) | null = null): Signal<T> => {
     return {
         equals: equals as ((a: unknown, b: unknown) => boolean) | null,

package/src/types.ts

@@ -1,4 +1,3 @@
-import { ts } from '@esportsplus/typescript';
 import { SIGNAL } from './constants';
 import { ReactiveArray } from './reactive';
 
@@ -14,6 +13,7 @@ interface Computed<T> {
     gv: number;
     height: number;
     nextHeap: Computed<unknown> | undefined;
+    pending: Signal<boolean> | null;
     prevHeap: Computed<unknown>;
     rv: number;
     state: number;
@@ -73,12 +73,6 @@ type Signal<T> = {
     value: T;
 };
 
-interface TransformResult {
-    changed: boolean;
-    code: string;
-    sourceFile: ts.SourceFile;
-}
-
 
 export type {
     Computed,
@@ -87,6 +81,5 @@ export type {
     Reactive,
     SelectorSignal,
     Settled,
-    Signal,
-    TransformResult
+    Signal
 };

package/test/async-computed.test.ts

@@ -373,11 +373,11 @@ describe('asyncComputed', () => {
         expect(() => read(node)).toThrow('boom');
     });
 
-    it('sync computed has no pending', () => {
+    it('sync computed has a null pending', () => {
         root(() => {
             let node = computed(() => 42);
 
-            expect((node as { pending?: unknown }).pending).toBeUndefined();
+            expect(node.pending).toBeNull();
         });
     });
 

package/test/compiler/compiler.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, it } from 'vitest';
 import { ts } from '@esportsplus/typescript';
+import { languageService } from '@esportsplus/typescript/compiler';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import { NAMESPACE } from '~/compiler/constants';
+import { NAMESPACE, TYPES } from '~/compiler/constants';
 import type { Bindings } from '~/compiler/types';
 import array from '~/compiler/array';
 import object from '~/compiler/object';
@@ -25,26 +26,26 @@ function applyIntents(code: string, sourceFile: ts.SourceFile, intents: Replacem
     return code;
 }
 
-function isReactiveCall(node: ts.Node): boolean {
+function isReactiveCall(node: ts.Node): node is ts.CallExpression {
     return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'reactive';
 }
 
 function parse(code: string): ts.SourceFile {
-    return ts.createSourceFile('test.ts', code, ts.ScriptTarget.Latest, true);
+    return languageService.parse(process.cwd() + '/test.ts', code);
 }
 
 function transformPrimitives(code: string): { bindings: Bindings; output: string } {
     let bindings: Bindings = new Map(),
         sourceFile = parse(code),
-        intents = primitives(sourceFile, bindings, isReactiveCall);
+        { replacements } = primitives(sourceFile, bindings, isReactiveCall);
 
-    return { bindings, output: applyIntents(code, sourceFile, intents) };
+    return { bindings, output: applyIntents(code, sourceFile, replacements) };
 }
 
 function transformArray(code: string, bindings?: Bindings): { bindings: Bindings; output: string } {
     let b: Bindings = bindings ?? new Map(),
         sourceFile = parse(code),
-        intents = array(sourceFile, b, undefined);
+        intents = array(sourceFile, b, isReactiveCall);
 
     return { bindings: b, output: applyIntents(code, sourceFile, intents) };
 }
@@ -52,7 +53,7 @@ function transformArray(code: string, bindings?: Bindings): { bindings: Bindings
 function transformObject(code: string): { bindings: Bindings; output: string; prepend: string[] } {
     let bindings: Bindings = new Map(),
         sourceFile = parse(code),
-        result = object(sourceFile, bindings, undefined);
+        result = object(sourceFile, bindings, isReactiveCall);
 
     return {
         bindings,
@@ -127,15 +128,28 @@ describe('primitives transform', () => {
     it('tracks bindings for signal type', () => {
         let { bindings } = transformPrimitives('let x = reactive(0);');
 
-        // TYPES.Signal = 3
-        expect(bindings.get('x')).toBe(3);
+        expect(bindings.get('x')).toBe(TYPES.Signal);
     });
 
     it('tracks bindings for computed type', () => {
         let { bindings } = transformPrimitives('let x = reactive(0); let d = reactive(() => x * 2);');
 
-        // TYPES.Computed = 1
-        expect(bindings.get('d')).toBe(1);
+        expect(bindings.get('d')).toBe(TYPES.Computed);
+    });
+
+    it('leaves a same-named plain variable in a sibling function untouched', () => {
+        let { output } = transformPrimitives('function a() { let x = reactive(0); return x; }\nfunction b() { let x = 1; return x; }');
+
+        expect(output).toContain(`function a() { let x = ${NAMESPACE}.signal(0); return ${NAMESPACE}.read(x); }`);
+        expect(output).toContain('function b() { let x = 1; return x; }');
+    });
+
+    it('resolves a shadowing inner binding to the innermost declaration', () => {
+        let { output } = transformPrimitives('let x = reactive(0); function f() { let x = reactive(() => 1); x = 2; }');
+
+        expect(output).toContain(`let x = ${NAMESPACE}.signal(0)`);
+        expect(output).toContain(`let x = ${NAMESPACE}.computed(() => 1)`);
+        expect(output).not.toContain(`${NAMESPACE}.write(x, 2)`);
     });
 
     it('transforms prefix --x in statement', () => {
@@ -205,18 +219,10 @@ describe('object transform', () => {
         expect(output).toContain('<MyType>');
     });
 
-    it('tracks object binding', () => {
-        let { bindings } = transformObject('let obj = reactive({ count: 0 });');
-
-        // TYPES.Object = 2
-        expect(bindings.get('obj')).toBe(2);
-    });
-
     it('tracks nested array bindings', () => {
         let { bindings } = transformObject('let obj = reactive({ items: [1, 2, 3] });');
 
-        // TYPES.Array = 0
-        expect(bindings.get('obj.items')).toBe(0);
+        expect(bindings.get('obj.items')).toBe(TYPES.Array);
     });
 });
 
@@ -226,7 +232,7 @@ describe('array transform', () => {
         let { output } = transformArray('let arr = reactive([1, 2, 3]);');
 
         expect(output).toContain(`new ${NAMESPACE}.ReactiveArray`);
-        expect(output).toContain('...[1, 2, 3]');
+        expect(output).toContain('([1, 2, 3])');
     });
 
     it('transforms reactive([] as Type[]) to typed ReactiveArray', () => {
@@ -262,6 +268,18 @@ describe('array transform', () => {
         expect(output).toContain('arr.$length = arr.length + 3');
     });
 
+    it('transforms every compound operator on arr.length with its own token', () => {
+        let bindings: Bindings = new Map();
+
+        bindings.set('arr', 0);
+
+        for (let op of ['<<', '>>', '>>>', '??', '||', '&&', '-', '*', '/', '%', '**', '&', '|', '^']) {
+            let { output } = transformArray(`arr.length ${op}= 2;`, bindings);
+
+            expect(output).toContain(`arr.$length = arr.length ${op} 2`);
+        }
+    });
+
     it('transforms arr[i] = value to arr.$set(i, value)', () => {
         let bindings: Bindings = new Map();
 
@@ -275,8 +293,7 @@ describe('array transform', () => {
     it('tracks reactive array binding from reactive call', () => {
         let { bindings } = transformArray('let arr = reactive([1, 2, 3]);');
 
-        // TYPES.Array = 0
-        expect(bindings.get('arr')).toBe(0);
+        expect(bindings.get('arr')).toBe(TYPES.Array);
     });
 
     it('tracks alias binding from reactive array', () => {