@esportsplus/reactivity 0.33.0 → 0.36.0

package/build/system.js

@@ -1,6 +1,8 @@
-import { PACKAGE_NAME, SIGNAL, 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.js';
+import { PACKAGE_NAME, SIGNAL, 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.js';
 import { isObject, isPromise } from '@esportsplus/utilities';
-let asyncMeta = new WeakMap(), depth = 0, disposeHead = null, draining = false, heap = new Array(64), heap_i = 0, heap_n = 0, linkPoolHead = null, microtask = queueMicrotask, notified = false, observer = null, pendingHead = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0, walkPoolHead = null, writes = 0;
+let asyncMeta = new WeakMap(), depth = 0, disposeHead = null, draining = false, heap = new Array(64), heap_i = 0, heap_n = 0, linkPoolHead = null, microtask = queueMicrotask, notified = false, observer = null, pendingHead = null, pulled = null, puller = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0, walkPoolHead = null, writes = 0;
+function noop() {
+}
 function walkPop(walk) {
     let prev = walk.prev;
     walk.computed = null;
@@ -105,6 +107,9 @@ function insertIntoHeap(computed) {
             heap.length = Math.max(height + 1, Math.ceil(heap.length * 2));
         }
     }
+    else if (height < heap_i) {
+        stabilizer = STABILIZER_RESCHEDULE;
+    }
 }
 function link(dep, sub) {
     if (dep.rv === version) {
@@ -204,12 +209,24 @@ function pull(node) {
     }
     let o = observer;
     observer = null;
+    pulled = node;
+    puller = o;
     update(node);
     observer = o;
+    pulled = null;
+    puller = null;
 }
 function propagate(computed) {
-    for (let c = computed.subs; c; c = c.nextSub) {
+    let c = computed.subs;
+    if (c === null) {
+        return;
+    }
+    let skip = computed === 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;
         }
@@ -217,14 +234,10 @@ function propagate(computed) {
     }
     schedule();
 }
-function recompute(computed, del) {
-    if (del) {
+function recompute(computed) {
+    if (computed.state & STATE_IN_HEAP) {
         deleteFromHeap(computed);
     }
-    else {
-        computed.nextHeap = undefined;
-        computed.prevHeap = computed;
-    }
     if (computed.cleanup) {
         try {
             cleanup(computed);
@@ -251,7 +264,7 @@ function recompute(computed, del) {
     depth--;
     version++;
     observer = o;
-    computed.state = STATE_COMPUTED | flags;
+    computed.state = STATE_COMPUTED | flags | (computed.state & STATE_IN_HEAP);
     computed.gv = w;
     let depsTail = computed.depsTail, remove = depsTail ? depsTail.nextDep : computed.deps;
     if (remove) {
@@ -287,46 +300,44 @@ function recompute(computed, del) {
             propagate(computed);
         }
     }
+    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;
-    }
 }
 function stabilize() {
     let o = observer;
     observer = null;
-    stabilizer = STABILIZER_RUNNING;
-    for (heap_i = 0; heap_i <= heap_n; heap_i++) {
-        if (pendingHead !== null) {
-            drainPending();
+    do {
+        stabilizer = STABILIZER_RUNNING;
+        for (heap_i = 0; heap_i <= heap_n; heap_i++) {
+            if (pendingHead !== null) {
+                drainPending();
+            }
+            let computed;
+            while ((computed = heap[heap_i]) !== undefined) {
+                recompute(computed);
+            }
         }
-        let computed = heap[heap_i];
-        heap[heap_i] = undefined;
-        while (computed !== undefined) {
-            let next = computed.nextHeap;
-            recompute(computed, false);
-            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;
-    }
 }
 function unlink(link) {
     let dep = link.dep, nextDep = link.nextDep, nextSub = link.nextSub, prevSub = link.prevSub;
@@ -369,7 +380,7 @@ function update(root) {
                 resuming = true;
             }
             else if (node.state & STATE_DIRTY) {
-                recompute(node, true);
+                recompute(node);
                 node.state &= ~STATE_NOTIFY_MASK;
             }
             else {
@@ -394,7 +405,7 @@ function update(root) {
                 continue;
             }
             if (node.state & STATE_DIRTY) {
-                recompute(node, true);
+                recompute(node);
             }
             else {
                 node.gv = w;
@@ -414,18 +425,23 @@ function update(root) {
 function makeAsyncComputed(factory) {
     let error = signal(undefined), node = signal(undefined), pending = signal(false), v = 0;
     let stop = effect(() => {
-        let fail = (e) => {
-            if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+        let id = ++v, stale = () => {
+            if (pendingHead !== null) {
+                drainPending();
+            }
+            return id !== v || (factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK)) !== 0;
+        }, fail = (e) => {
+            if (!stale()) {
                 write(error, e === undefined ? new Error('reactivity: async computed rejected with undefined') : e);
                 write(pending, false);
             }
-        }, id = ++v, result = read(factory);
+        }, result = read(factory);
         if (isPromise(result)) {
-            if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+            if (!stale()) {
                 write(pending, true);
             }
             result.then((value) => {
-                if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+                if (!stale()) {
                     write(error, undefined);
                     write(node, value);
                     write(pending, false);
@@ -438,7 +454,7 @@ function makeAsyncComputed(factory) {
                 it.return?.();
             });
             let step = (r) => {
-                if (id !== v || (factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+                if (stale()) {
                     return;
                 }
                 if (!r.done) {
@@ -451,7 +467,7 @@ function makeAsyncComputed(factory) {
                     write(pending, false);
                 }
             };
-            if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+            if (!stale()) {
                 write(pending, true);
             }
             untrack(() => it.next()).then(step, fail);
@@ -475,33 +491,15 @@ function makeAsyncComputed(factory) {
     return wrapper;
 }
 function makeComputed(fn, eager = false) {
-    let self = {
-        cleanup: null,
-        deps: null,
-        depsTail: null,
-        disposal: null,
-        equals: null,
-        error: null,
-        fn: fn,
-        gv: 0,
-        height: 0,
-        nextHeap: undefined,
-        prevHeap: null,
-        rv: 0,
-        state: STATE_COMPUTED,
-        subs: null,
-        subsTail: null,
-        value: undefined,
-    };
-    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) {
             self.height = observer.height + 1;
-            recompute(self, false);
+            recompute(self);
         }
         else {
             self.height = observer.height + 1;
@@ -512,14 +510,36 @@ function makeComputed(fn, eager = false) {
         onCleanup(() => dispose(self));
     }
     else {
-        recompute(self, false);
-        root.disposables++;
+        recompute(self);
         if (scope) {
             onCleanup(() => dispose(self));
         }
     }
     return self;
 }
+function makeNode(fn) {
+    let self = {
+        cleanup: null,
+        deps: null,
+        depsTail: null,
+        disposal: null,
+        equals: null,
+        error: null,
+        fn,
+        gv: 0,
+        height: 0,
+        nextHeap: undefined,
+        pending: null,
+        prevHeap: null,
+        rv: 0,
+        state: STATE_COMPUTED,
+        subs: null,
+        subsTail: null,
+        value: undefined,
+    };
+    self.prevHeap = self;
+    return self;
+}
 const batch = (fn) => {
     depth++;
     try {
@@ -527,8 +547,9 @@ const batch = (fn) => {
     }
     finally {
         depth--;
-        if (!depth) {
-            schedule();
+        if (!depth && stabilizer === STABILIZER_DEFERRED) {
+            stabilizer = STABILIZER_SCHEDULED;
+            microtask(stabilize);
         }
     }
 };
@@ -610,7 +631,7 @@ const effect = (fn, apply) => {
     };
 };
 const flush = () => {
-    while (stabilizer === STABILIZER_SCHEDULED) {
+    if (stabilizer === STABILIZER_SCHEDULED) {
         stabilize();
     }
 };
@@ -671,26 +692,27 @@ const read = (node) => {
     return node.value;
 };
 const root = (fn) => {
-    let c, d = root.disposables, o = observer, s = scope, self = null, tracking = fn.length, value;
+    let c, o = observer, s = scope, self = null, tracking = fn.length, value;
     observer = null;
-    root.disposables = 0;
-    if (tracking) {
-        scope = self = { cleanup: null, state: STATE_COMPUTED };
-        value = fn(c = () => dispose(self));
+    try {
+        if (tracking) {
+            scope = self = makeNode(noop);
+            value = fn(c = () => dispose(self));
+        }
+        else {
+            scope = null;
+            value = fn();
+        }
     }
-    else {
-        scope = null;
-        value = fn();
+    finally {
+        observer = o;
+        scope = s;
     }
-    observer = o;
-    root.disposables = d;
-    scope = s;
     if (c) {
         onCleanup(c);
     }
     return value;
 };
-root.disposables = 0;
 const signal = (value, equals = null) => {
     return {
         equals: equals,

package/build/types.d.ts

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

package/package.json

@@ -4,10 +4,10 @@
     "@esportsplus/utilities": "^0.28.0"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.29.5",
-    "@types/node": "^26.1.1",
-    "vite": "^8.1.5",
-    "vitest": "^4.1.10"
+    "@esportsplus/typescript": "^0.32.0",
+    "@types/node": "^26.4.1",
+    "vite": "^8.2.2",
+    "vitest": "^4.1.11"
   },
   "exports": {
     ".": {
@@ -36,7 +36,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.33.0",
+  "version": "0.36.0",
   "scripts": {
     "agent:bench": "vitest bench --run",
     "agent:test": "tsc --noEmit && vitest run",

package/pnpm-workspace.yaml

@@ -1,2 +1,5 @@
 allowBuilds:
   esbuild: true
+minimumReleaseAgeExclude:
+  - '@esportsplus/typescript@0.31.0 || 0.32.0'
+  - tsc-alias@1.9.4

package/src/compiler/array.ts

@@ -1,34 +1,18 @@
 import { ts } from '@esportsplus/typescript';
-import { ast, imports } from '@esportsplus/typescript/compiler';
+import { ast } from '@esportsplus/typescript/compiler';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME, TYPES } from './constants';
-import type { Bindings } from './types';
+import { COMPOUND_OPERATORS, NAMESPACE, TYPES } from './constants';
+import type { Bindings, IsReactiveCall } from './types';
 
 
 type VisitContext = {
     bindings: Bindings;
-    checker: ts.TypeChecker | undefined;
+    isReactiveCall: IsReactiveCall;
     replacements: ReplacementIntent[];
     sourceFile: ts.SourceFile;
 };
 
 
-function isReactiveCall(checker: ts.TypeChecker | undefined, node: ts.Node): node is ts.CallExpression {
-    if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) {
-        return false;
-    }
-
-    let expr = node.expression;
-
-    // Use checker to verify symbol origin (handles re-exports)
-    if (checker) {
-        return imports.includes(checker, expr, PACKAGE_NAME, ENTRYPOINT);
-    }
-
-    // Fallback without checker: match by name only
-    return expr.text === ENTRYPOINT;
-}
-
 function getElementTypeText(typeNode: ts.TypeNode, sourceFile: ts.SourceFile): string | null {
     if (ts.isArrayTypeNode(typeNode)) {
         return typeNode.elementType.getText(sourceFile);
@@ -47,42 +31,8 @@ function getElementTypeText(typeNode: ts.TypeNode, sourceFile: ts.SourceFile): s
     return null;
 }
 
-function getOperator(kind: ts.SyntaxKind) {
-    switch (kind) {
-        case ts.SyntaxKind.PlusEqualsToken: return '+';
-        case ts.SyntaxKind.MinusEqualsToken: return '-';
-        case ts.SyntaxKind.AsteriskEqualsToken: return '*';
-        case ts.SyntaxKind.SlashEqualsToken: return '/';
-        case ts.SyntaxKind.PercentEqualsToken: return '%';
-        case ts.SyntaxKind.AsteriskAsteriskEqualsToken: return '**';
-        case ts.SyntaxKind.AmpersandEqualsToken: return '&';
-        case ts.SyntaxKind.BarEqualsToken: return '|';
-        case ts.SyntaxKind.CaretEqualsToken: return '^';
-        default: return '+';
-    }
-}
-
-function isAssignmentOperator(kind: ts.SyntaxKind) {
-    return kind === ts.SyntaxKind.EqualsToken ||
-        kind === ts.SyntaxKind.PlusEqualsToken ||
-        kind === ts.SyntaxKind.MinusEqualsToken ||
-        kind === ts.SyntaxKind.AsteriskEqualsToken ||
-        kind === ts.SyntaxKind.SlashEqualsToken ||
-        kind === ts.SyntaxKind.PercentEqualsToken ||
-        kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken ||
-        kind === ts.SyntaxKind.LessThanLessThanEqualsToken ||
-        kind === ts.SyntaxKind.GreaterThanGreaterThanEqualsToken ||
-        kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken ||
-        kind === ts.SyntaxKind.AmpersandEqualsToken ||
-        kind === ts.SyntaxKind.BarEqualsToken ||
-        kind === ts.SyntaxKind.CaretEqualsToken ||
-        kind === ts.SyntaxKind.BarBarEqualsToken ||
-        kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
-        kind === ts.SyntaxKind.QuestionQuestionEqualsToken;
-}
-
 function visit(ctx: VisitContext, node: ts.Node): void {
-    if (isReactiveCall(ctx.checker, node) && node.arguments.length > 0) {
+    if (ctx.isReactiveCall(node) && node.arguments.length > 0) {
         let arg = node.arguments[0],
             expression = ts.isAsExpression(arg) ? arg.expression : arg;
 
@@ -105,7 +55,7 @@ function visit(ctx: VisitContext, node: ts.Node): void {
             ctx.replacements.push({
                 node,
                 generate: (sf) => expression.elements.length > 0
-                    ? ` new ${NAMESPACE}.ReactiveArray${typeParam}(...${expression.getText(sf)})`
+                    ? ` new ${NAMESPACE}.ReactiveArray${typeParam}(${expression.getText(sf)})`
                     : ` new ${NAMESPACE}.ReactiveArray${typeParam}()`
             });
         }
@@ -148,10 +98,10 @@ function visit(ctx: VisitContext, node: ts.Node): void {
                 parent = node.parent;
 
             // arr.length = value OR arr.length += value
-            if (parent && ts.isBinaryExpression(parent) && parent.left === node && isAssignmentOperator(parent.operatorToken.kind)) {
-                let op = parent.operatorToken.kind;
+            if (parent && ts.isBinaryExpression(parent) && parent.left === node && (parent.operatorToken.kind === ts.SyntaxKind.EqualsToken || COMPOUND_OPERATORS.has(parent.operatorToken.kind))) {
+                let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind);
 
-                if (op === ts.SyntaxKind.EqualsToken) {
+                if (op === undefined) {
                     ctx.replacements.push({
                         node: parent,
                         generate: (sf) => `${expr.getText(sf)}.$length = ${parent.right.getText(sf)}`
@@ -160,7 +110,7 @@ function visit(ctx: VisitContext, node: ts.Node): void {
                 else {
                     ctx.replacements.push({
                         node: parent,
-                        generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${getOperator(op)} ${parent.right.getText(sf)}`
+                        generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} ${parent.right.getText(sf)}`
                     });
                 }
             }
@@ -220,7 +170,7 @@ function visit(ctx: VisitContext, node: ts.Node): void {
             right = node.right;
 
         // Unwrap "as" expressions: arr = [] as Type[]
-        while (ts.isAsExpression(right) || ts.isTypeAssertionExpression(right)) {
+        while (ts.isAsExpression(right) || ts.isTypeAssertion(right)) {
             right = right.expression;
         }
 
@@ -234,14 +184,14 @@ function visit(ctx: VisitContext, node: ts.Node): void {
         }
     }
 
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker): ReplacementIntent[] => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): ReplacementIntent[] => {
     let ctx: VisitContext = {
             bindings,
-            checker,
+            isReactiveCall,
             replacements: [],
             sourceFile
         };

package/src/compiler/constants.ts

@@ -1,9 +1,26 @@
+import { ts } from '@esportsplus/typescript';
 import { uid } from '@esportsplus/typescript/compiler';
 
 
-const ENTRYPOINT = 'reactive';
+const COMPOUND_OPERATORS = new Map<ts.SyntaxKind, string>([
+    [ts.SyntaxKind.AmpersandAmpersandEqualsToken, '&&'],
+    [ts.SyntaxKind.AmpersandEqualsToken, '&'],
+    [ts.SyntaxKind.AsteriskAsteriskEqualsToken, '**'],
+    [ts.SyntaxKind.AsteriskEqualsToken, '*'],
+    [ts.SyntaxKind.BarBarEqualsToken, '||'],
+    [ts.SyntaxKind.BarEqualsToken, '|'],
+    [ts.SyntaxKind.CaretEqualsToken, '^'],
+    [ts.SyntaxKind.GreaterThanGreaterThanEqualsToken, '>>'],
+    [ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken, '>>>'],
+    [ts.SyntaxKind.LessThanLessThanEqualsToken, '<<'],
+    [ts.SyntaxKind.MinusEqualsToken, '-'],
+    [ts.SyntaxKind.PercentEqualsToken, '%'],
+    [ts.SyntaxKind.PlusEqualsToken, '+'],
+    [ts.SyntaxKind.QuestionQuestionEqualsToken, '??'],
+    [ts.SyntaxKind.SlashEqualsToken, '/']
+]);
 
-const ENTRYPOINT_REGEX = /\breactive\b/;
+const ENTRYPOINT = 'reactive';
 
 const NAMESPACE = uid('reactivity');
 
@@ -11,12 +28,11 @@ const NAMESPACE = uid('reactivity');
 const TYPES = {
     Array: 0,
     Computed: 1,
-    Object: 2,
-    Signal: 3
+    Signal: 2
 } as const;
 
 type TYPES = typeof TYPES[keyof typeof TYPES];
 
 
-export { ENTRYPOINT, ENTRYPOINT_REGEX, NAMESPACE, TYPES };
+export { COMPOUND_OPERATORS, ENTRYPOINT, NAMESPACE, TYPES };
 export { PACKAGE_NAME } from '../constants';