@esportsplus/reactivity 0.34.0 → 0.36.1

package/README.md

@@ -1,7 +1,5 @@
 # @esportsplus/reactivity
 
-Project doc bundle: [docs/index.md](./docs/index.md) — rejected dead-ends, skip reasons, completed-work index.
-
 A fine-grained reactivity system with compile-time transformations. Write reactive code with natural JavaScript syntax while the compiler generates optimized signal-based code.
 
 ## Installation
@@ -223,7 +221,7 @@ let user = new ReactiveObject_1();
 | `reactive(() => expr)` | Creates a computed value (compile-time only) |
 | `reactive({...})` | Creates a reactive object with signals and computeds |
 | `reactive([...])` | Creates a reactive array |
-| `effect(fn, onError?)` | Runs a function that re-executes when dependencies change. Returns a dispose function. Optional `onError` receives thrown or rejected errors |
+| `effect(fn, apply?)` | Runs a function that re-executes when dependencies change. Returns a dispose function. Optional `apply(value, prev)` runs untracked after each run with `fn`'s return value |
 | `root(fn)` | Creates an untracked scope. If `fn` accepts an argument, a dispose function is provided |
 | `onCleanup(fn)` | Registers a cleanup function for the current effect/computed |
 
@@ -259,7 +257,7 @@ For advanced use cases, the underlying classes are exported:
 
 | Class | Description |
 |-------|-------------|
-| `ReactiveArray<T>` | Array subclass with reactivity and event dispatching |
+| `ReactiveArray<T>` | Array subclass with reactivity and event dispatching. `new ReactiveArray(items?: T[])` takes the initial items as one array |
 | `ReactiveObject<T>` | Base class for reactive objects |
 
 ### Constants
@@ -283,7 +281,6 @@ Symbol constants for type identification:
 | `SelectorSignal<T>` | Signal variant backing `signal.selector` per-key subscriptions |
 | `Link` | Dependency graph link between nodes |
 | `Reactive<T>` | Utility type for inferring reactive object/array types |
-| `TransformResult` | Compiler transform output metadata |
 
 ## ReactiveArray
 
@@ -341,8 +338,13 @@ pnpm bench   # vitest bench --run
 `agent:test` (`tsc --noEmit && vitest run`) and `agent:bench` (`vitest bench --run`) are the
 CI-facing aliases of the same build/test/bench commands.
 
+## Changes in 0.35.0
+
+- `new ReactiveArray(items?)` takes an array instead of variadic items. `new ReactiveArray(5)` previously produced a length-5 holey array, and spreading large arrays overflowed the call stack.
+- `root.disposables` is removed. `reactive()` now always registers its disposal with the enclosing effect or root scope.
+- `ReactiveArray` listener errors are still detached but are now rethrown on a microtask instead of swallowed.
+- `TransformResult` is no longer exported.
+
 ## License
 
 MIT
-
-<!-- claude-code:readme-source-hash: 189167a17e9be8c6 -->

package/bench/reactive/array.bench.ts

@@ -9,7 +9,7 @@ describe('ReactiveArray creation', () => {
     });
 
     bench('create with 10 items', () => {
-        new ReactiveArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        new ReactiveArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
     });
 
     bench('create with 100 items', () => {
@@ -19,7 +19,7 @@ describe('ReactiveArray creation', () => {
             items.push(i);
         }
 
-        new ReactiveArray(...items);
+        new ReactiveArray(items);
     });
 });
 
@@ -56,7 +56,7 @@ describe('ReactiveArray push', () => {
 
 describe('ReactiveArray pop', () => {
     bench('pop', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.pop();
     });
@@ -65,19 +65,19 @@ describe('ReactiveArray pop', () => {
 
 describe('ReactiveArray splice', () => {
     bench('splice remove 1', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.splice(2, 1);
     });
 
     bench('splice insert 1', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.splice(2, 0, 99);
     });
 
     bench('splice replace 1', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.splice(2, 1, 99);
     });
@@ -86,7 +86,7 @@ describe('ReactiveArray splice', () => {
 
 describe('ReactiveArray sort', () => {
     bench('sort 10 items', () => {
-        let arr = new ReactiveArray(5, 3, 8, 1, 9, 2, 7, 4, 6, 10);
+        let arr = new ReactiveArray([5, 3, 8, 1, 9, 2, 7, 4, 6, 10]);
 
         arr.sort((a, b) => a - b);
     });
@@ -98,7 +98,7 @@ describe('ReactiveArray sort', () => {
             items.push(i);
         }
 
-        let arr = new ReactiveArray(...items);
+        let arr = new ReactiveArray(items);
 
         arr.sort((a, b) => a - b);
     });
@@ -110,7 +110,7 @@ describe('ReactiveArray sort', () => {
             items.push(i);
         }
 
-        let arr = new ReactiveArray(...items);
+        let arr = new ReactiveArray(items);
 
         arr.sort((a, b) => a - b);
     });
@@ -119,13 +119,13 @@ describe('ReactiveArray sort', () => {
 
 describe('ReactiveArray $set', () => {
     bench('$set', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.$set(2, 99);
     });
 
     bench('$set same value (no-op)', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.$set(2, 3);
     });
@@ -169,7 +169,7 @@ describe('ReactiveArray dispose/clear', () => {
             items.push(i);
         }
 
-        let arr = new ReactiveArray(...items);
+        let arr = new ReactiveArray(items);
 
         arr.dispose();
     });
@@ -181,7 +181,7 @@ describe('ReactiveArray dispose/clear', () => {
             items.push(i);
         }
 
-        let arr = new ReactiveArray(...items);
+        let arr = new ReactiveArray(items);
 
         arr.clear();
     });
@@ -201,13 +201,13 @@ describe('ReactiveArray concat/unshift/shift/reverse', () => {
     });
 
     bench('unshift 10 items', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.unshift(10, 20, 30, 40, 50, 60, 70, 80, 90, 100);
     });
 
     bench('shift', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.shift();
     });
@@ -219,7 +219,7 @@ describe('ReactiveArray concat/unshift/shift/reverse', () => {
             items.push(i);
         }
 
-        let arr = new ReactiveArray(...items);
+        let arr = new ReactiveArray(items);
 
         arr.reverse();
     });
@@ -228,7 +228,7 @@ describe('ReactiveArray concat/unshift/shift/reverse', () => {
 
 describe('ReactiveArray reactive length', () => {
     bench('read $length in effect', () => {
-        let arr = new ReactiveArray(1, 2, 3);
+        let arr = new ReactiveArray([1, 2, 3]);
 
         let stop = effect(() => {
             arr.$length;

package/build/compiler/array.d.ts

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import type { Bindings } from './types.js';
+import type { Bindings, IsReactiveCall } from './types.js';
 export default _default;
-declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.Checker): ReplacementIntent[];
+declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): ReplacementIntent[];

package/build/compiler/array.js

@@ -1,16 +1,6 @@
 import { ts } from '@esportsplus/typescript';
-import { ast, imports } from '@esportsplus/typescript/compiler';
-import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME, TYPES } from './constants.js';
-function isReactiveCall(checker, node) {
-    if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) {
-        return false;
-    }
-    let expr = node.expression;
-    if (checker) {
-        return imports.includes(checker, expr, PACKAGE_NAME, ENTRYPOINT);
-    }
-    return expr.text === ENTRYPOINT;
-}
+import { ast } from '@esportsplus/typescript/compiler';
+import { COMPOUND_OPERATORS, NAMESPACE, TYPES } from './constants.js';
 function getElementTypeText(typeNode, sourceFile) {
     if (ts.isArrayTypeNode(typeNode)) {
         return typeNode.elementType.getText(sourceFile);
@@ -24,40 +14,8 @@ function getElementTypeText(typeNode, sourceFile) {
     }
     return null;
 }
-function getOperator(kind) {
-    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) {
-    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, node) {
-    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;
         if (ts.isArrayLiteralExpression(expression)) {
             let elementType = null;
@@ -74,7 +32,7 @@ function visit(ctx, node) {
             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}()`
             });
         }
@@ -105,9 +63,9 @@ function visit(ctx, node) {
         let name = ast.expression.name(node.expression);
         if (name && ctx.bindings.get(name) === TYPES.Array) {
             let expr = node.expression, parent = node.parent;
-            if (parent && ts.isBinaryExpression(parent) && parent.left === node && isAssignmentOperator(parent.operatorToken.kind)) {
-                let op = parent.operatorToken.kind;
-                if (op === ts.SyntaxKind.EqualsToken) {
+            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 === undefined) {
                     ctx.replacements.push({
                         node: parent,
                         generate: (sf) => `${expr.getText(sf)}.$length = ${parent.right.getText(sf)}`
@@ -116,7 +74,7 @@ function visit(ctx, node) {
                 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)}`
                     });
                 }
             }
@@ -174,10 +132,10 @@ function visit(ctx, node) {
     }
     node.forEachChild(n => visit(ctx, n));
 }
-export default (sourceFile, bindings, checker) => {
+export default (sourceFile, bindings, isReactiveCall) => {
     let ctx = {
         bindings,
-        checker,
+        isReactiveCall,
         replacements: [],
         sourceFile
     };

package/build/compiler/constants.d.ts

@@ -1,12 +1,12 @@
+import { ts } from '@esportsplus/typescript';
+declare const COMPOUND_OPERATORS: Map<ts.SyntaxKind, string>;
 declare const ENTRYPOINT = "reactive";
-declare const ENTRYPOINT_REGEX: RegExp;
 declare const NAMESPACE: string;
 declare const TYPES: {
     readonly Array: 0;
     readonly Computed: 1;
-    readonly Object: 2;
-    readonly Signal: 3;
+    readonly Signal: 2;
 };
 type TYPES = typeof TYPES[keyof typeof TYPES];
-export { ENTRYPOINT, ENTRYPOINT_REGEX, NAMESPACE, TYPES };
+export { COMPOUND_OPERATORS, ENTRYPOINT, NAMESPACE, TYPES };
 export { PACKAGE_NAME } from '../constants.js';

package/build/compiler/constants.js

@@ -1,12 +1,28 @@
+import { ts } from '@esportsplus/typescript';
 import { uid } from '@esportsplus/typescript/compiler';
+const COMPOUND_OPERATORS = new Map([
+    [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 = 'reactive';
-const ENTRYPOINT_REGEX = /\breactive\b/;
 const NAMESPACE = uid('reactivity');
 const TYPES = {
     Array: 0,
     Computed: 1,
-    Object: 2,
-    Signal: 3
+    Signal: 2
 };
-export { ENTRYPOINT, ENTRYPOINT_REGEX, NAMESPACE, TYPES };
+export { COMPOUND_OPERATORS, ENTRYPOINT, NAMESPACE, TYPES };
 export { PACKAGE_NAME } from '../constants.js';

package/build/compiler/index.js

@@ -4,11 +4,6 @@ import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME } from './constants.js';
 import array from './array.js';
 import object from './object.js';
 import primitives from './primitives.js';
-function findRemainingCalls(checker, sourceFile, transformedNodes) {
-    let ctx = { checker, replacements: [], sourceFile, transformedNodes };
-    visit(ctx, sourceFile);
-    return ctx.replacements;
-}
 function isReactiveCallExpression(checker, node) {
     if (!ts.isCallExpression(node)) {
         return false;
@@ -22,51 +17,43 @@ function isReactiveCallExpression(checker, node) {
     }
     return false;
 }
-function hasReactiveCalls(checker, node) {
-    if (isReactiveCallExpression(checker, node)) {
-        return true;
-    }
-    let found = false;
-    node.forEachChild(child => {
-        if (!found && hasReactiveCalls(checker, child)) {
-            found = true;
-        }
-    });
-    return found;
-}
-function visit(ctx, node) {
-    if (isReactiveCallExpression(ctx.checker, node) && !ctx.transformedNodes.has(node) && !ctx.transformedNodes.has(node.expression)) {
-        ctx.replacements.push({
-            generate: () => `${NAMESPACE}.reactive(${node.arguments.map(a => a.getText(ctx.sourceFile)).join(', ')})`,
-            node
-        });
-    }
-    node.forEachChild(n => visit(ctx, n));
-}
 export default {
     patterns: ['reactive(', 'reactive<'],
     transform: (ctx) => {
-        if (!ctx.checker || !hasReactiveCalls(ctx.checker, ctx.sourceFile)) {
+        let checker = ctx.checker;
+        if (!checker) {
             return {};
         }
         let bindings = new Map(), intents = {
             imports: [],
             prepend: [],
             replacements: []
-        };
-        intents.replacements.push(...primitives(ctx.sourceFile, bindings, (node) => isReactiveCallExpression(ctx.checker, node)));
-        let { prepend, replacements } = object(ctx.sourceFile, bindings, ctx.checker);
-        intents.prepend.push(...prepend);
+        }, isReactiveCall = (node) => isReactiveCallExpression(checker, node), sourceFile = ctx.sourceFile;
+        let { calls, replacements } = primitives(sourceFile, bindings, isReactiveCall);
+        if (calls.length === 0) {
+            return {};
+        }
         intents.replacements.push(...replacements);
-        intents.replacements.push(...array(ctx.sourceFile, bindings, ctx.checker));
-        intents.replacements.push(...findRemainingCalls(ctx.checker, ctx.sourceFile, new Set(intents.replacements.map(r => r.node))));
-        if (intents.replacements.length > 0 || intents.prepend.length > 0) {
-            intents.imports.push({
-                namespace: NAMESPACE,
-                package: PACKAGE_NAME,
-                remove: [ENTRYPOINT]
+        let objects = object(sourceFile, bindings, isReactiveCall);
+        intents.prepend.push(...objects.prepend);
+        intents.replacements.push(...objects.replacements);
+        intents.replacements.push(...array(sourceFile, bindings, isReactiveCall));
+        let transformed = new Set(intents.replacements.map(r => r.node));
+        for (let i = 0, n = calls.length; i < n; i++) {
+            let call = calls[i];
+            if (transformed.has(call) || transformed.has(call.expression)) {
+                continue;
+            }
+            intents.replacements.push({
+                generate: () => `${NAMESPACE}.reactive(${call.arguments.map(a => a.getText(sourceFile)).join(', ')})`,
+                node: call
             });
         }
+        intents.imports.push({
+            namespace: NAMESPACE,
+            package: PACKAGE_NAME,
+            remove: [ENTRYPOINT]
+        });
         return intents;
     }
 };

package/build/compiler/object.d.ts

@@ -1,9 +1,9 @@
 import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import type { Bindings } from './types.js';
+import type { Bindings, IsReactiveCall } from './types.js';
 type ObjectTransformResult = {
     prepend: string[];
     replacements: ReplacementIntent[];
 };
 export default _default;
-declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.Checker): ObjectTransformResult;
+declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): ObjectTransformResult;

package/build/compiler/object.js

@@ -1,6 +1,6 @@
 import { ts } from '@esportsplus/typescript';
-import { code, imports, uid } from '@esportsplus/typescript/compiler';
-import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME, TYPES } from './constants.js';
+import { code, uid } from '@esportsplus/typescript/compiler';
+import { NAMESPACE, TYPES } from './constants.js';
 function analyzeProperty(prop, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) {
         return null;
@@ -139,24 +139,13 @@ function isStaticValue(node) {
         node.kind === ts.SyntaxKind.UndefinedKeyword ||
         (ts.isPrefixUnaryExpression(node) && ts.isNumericLiteral(node.operand));
 }
-function isReactiveCall(checker, node) {
-    if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) {
-        return false;
-    }
-    let expr = node.expression;
-    if (checker) {
-        return imports.includes(checker, expr, PACKAGE_NAME, ENTRYPOINT);
-    }
-    return expr.text === ENTRYPOINT;
-}
 function visit(ctx, node) {
-    if (isReactiveCall(ctx.checker, node)) {
+    if (ctx.isReactiveCall(node)) {
         let arg = node.arguments[0];
         if (arg && ts.isObjectLiteralExpression(arg)) {
             let properties = [], props = arg.properties, varname = null;
             if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 varname = node.parent.name.text;
-                ctx.bindings.set(varname, TYPES.Object);
             }
             for (let i = 0, n = props.length; i < n; i++) {
                 let prop = props[i];
@@ -185,11 +174,11 @@ function visit(ctx, node) {
     }
     node.forEachChild(n => visit(ctx, n));
 }
-export default (sourceFile, bindings, checker) => {
+export default (sourceFile, bindings, isReactiveCall) => {
     let ctx = {
         bindings,
         calls: [],
-        checker,
+        isReactiveCall,
         sourceFile
     };
     visit(ctx, sourceFile);

package/build/compiler/primitives.d.ts

@@ -1,5 +1,9 @@
 import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import type { Bindings } from './types.js';
+import type { Bindings, IsReactiveCall } from './types.js';
+type PrimitivesTransformResult = {
+    calls: ts.CallExpression[];
+    replacements: ReplacementIntent[];
+};
 export default _default;
-declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: (node: ts.Node) => boolean): ReplacementIntent[];
+declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): PrimitivesTransformResult;

package/build/compiler/primitives.js

@@ -1,22 +1,5 @@
 import { ts } from '@esportsplus/typescript';
-import { NAMESPACE, TYPES } from './constants.js';
-const COMPOUND_OPERATORS = new Map([
-    [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, '/']
-]);
+import { COMPOUND_OPERATORS, NAMESPACE, TYPES } from './constants.js';
 function inScope(reference, binding) {
     let current = reference;
     while (current) {
@@ -27,9 +10,34 @@ function inScope(reference, binding) {
     }
     return false;
 }
+function isScope(node) {
+    return ts.isArrowFunction(node) ||
+        ts.isBlock(node) ||
+        ts.isCatchClause(node) ||
+        ts.isForInStatement(node) ||
+        ts.isForOfStatement(node) ||
+        ts.isForStatement(node) ||
+        ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isSourceFile(node);
+}
+function scopeOf(node) {
+    let current = node.parent, depth = 0, scope = node.getSourceFile();
+    while (current) {
+        if (isScope(current)) {
+            if (scope === node.getSourceFile() && !ts.isSourceFile(current)) {
+                scope = current;
+            }
+            depth++;
+        }
+        current = current.parent;
+    }
+    return { depth, scope };
+}
 function visit(ctx, node) {
     if (ctx.isReactiveCall(node)) {
         let call = node;
+        ctx.calls.push(call);
         if (call.arguments.length > 0) {
             let arg = call.arguments[0], classification = TYPES.Signal;
             if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
@@ -64,25 +72,9 @@ function visit(ctx, node) {
                     varname = call.parent.left.text;
                 }
                 if (varname) {
-                    let current = call.parent, scope;
-                    while (current) {
-                        if (ts.isArrowFunction(current) ||
-                            ts.isBlock(current) ||
-                            ts.isForInStatement(current) ||
-                            ts.isForOfStatement(current) ||
-                            ts.isForStatement(current) ||
-                            ts.isFunctionDeclaration(current) ||
-                            ts.isFunctionExpression(current) ||
-                            ts.isSourceFile(current)) {
-                            scope = current;
-                        }
-                        current = current.parent;
-                    }
-                    if (!scope) {
-                        scope = call.getSourceFile();
-                    }
+                    let { depth, scope } = scopeOf(call);
                     ctx.bindings.set(varname, classification);
-                    ctx.scopedBindings.push({ name: varname, scope, type: classification });
+                    ctx.scopedBindings.push({ depth, name: varname, scope, type: classification });
                 }
                 ctx.replacements.push({
                     generate: () => classification === TYPES.Computed
@@ -103,7 +95,7 @@ function visit(ctx, node) {
         let bindings = ctx.scopedBindings, binding, name = node.text;
         for (let i = 0, n = bindings.length; i < n; i++) {
             let b = bindings[i];
-            if (b.name === name && inScope(node, b)) {
+            if (b.name === name && (!binding || b.depth >= binding.depth) && inScope(node, b)) {
                 binding = b;
             }
         }
@@ -183,6 +175,7 @@ function visit(ctx, node) {
 export default (sourceFile, bindings, isReactiveCall) => {
     let ctx = {
         bindings,
+        calls: [],
         isReactiveCall,
         replacements: [],
         scopedBindings: [],
@@ -190,5 +183,5 @@ export default (sourceFile, bindings, isReactiveCall) => {
         tmpCounter: 0
     };
     visit(ctx, sourceFile);
-    return ctx.replacements;
+    return { calls: ctx.calls, replacements: ctx.replacements };
 };

package/build/compiler/types.d.ts

@@ -1,3 +1,5 @@
+import type { ts } from '@esportsplus/typescript';
 import { TYPES } from './constants.js';
 type Bindings = Map<string, TYPES>;
-export type { Bindings };
+type IsReactiveCall = (node: ts.Node) => node is ts.CallExpression;
+export type { Bindings, IsReactiveCall };

package/build/constants.d.ts

@@ -3,11 +3,11 @@ declare const PACKAGE_NAME = "@esportsplus/reactivity";
 declare const REACTIVE_ARRAY: unique symbol;
 declare const REACTIVE_OBJECT: unique symbol;
 declare const SIGNAL: unique symbol;
+declare const STABILIZER_DEFERRED = 4;
 declare const STABILIZER_IDLE = 0;
 declare const STABILIZER_RESCHEDULE = 1;
 declare const STABILIZER_RUNNING = 2;
 declare const STABILIZER_SCHEDULED = 3;
-declare const STATE_NONE = 0;
 declare const STATE_CHECK: number;
 declare const STATE_DIRTY: number;
 declare const STATE_RECOMPUTING: number;
@@ -16,4 +16,4 @@ declare const STATE_COMPUTED: number;
 declare const STATE_ERROR: number;
 declare const STATE_EFFECT: number;
 declare const STATE_NOTIFY_MASK: number;
-export { COMPUTED, PACKAGE_NAME, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING };
+export { COMPUTED, PACKAGE_NAME, REACTIVE_ARRAY, REACTIVE_OBJECT, 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 };