@esportsplus/reactivity 0.34.0 → 0.36.1

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.Checker | undefined;
+    isReactiveCall: IsReactiveCall;
     replacements: ReplacementIntent[];
     sourceFile: ts.SourceFile;
 };
 
 
-function isReactiveCall(checker: ts.Checker | 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)}`
                     });
                 }
             }
@@ -238,10 +188,10 @@ function visit(ctx: VisitContext, node: ts.Node): void {
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.Checker): 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';

package/src/compiler/index.ts

@@ -9,26 +9,6 @@ import object from './object';
 import primitives from './primitives';
 
 
-type FindRemainingContext = {
-    checker: ts.Checker;
-    replacements: ReplacementIntent[];
-    sourceFile: ts.SourceFile;
-    transformedNodes: Set<ts.Node>;
-};
-
-
-function findRemainingCalls(
-    checker: ts.Checker,
-    sourceFile: ts.SourceFile,
-    transformedNodes: Set<ts.Node>
-): ReplacementIntent[] {
-    let ctx: FindRemainingContext = { checker, replacements: [], sourceFile, transformedNodes };
-
-    visit(ctx, sourceFile);
-
-    return ctx.replacements;
-}
-
 function isReactiveCallExpression(checker: ts.Checker, node: ts.Node): node is ts.CallExpression {
     if (!ts.isCallExpression(node)) {
         return false;
@@ -49,38 +29,13 @@ function isReactiveCallExpression(checker: ts.Checker, node: ts.Node): node is t
     return false;
 }
 
-function hasReactiveCalls(checker: ts.Checker, node: ts.Node): boolean {
-    if (isReactiveCallExpression(checker, node)) {
-        return true;
-    }
-
-    let found = false;
-
-    node.forEachChild(child => {
-        if (!found && hasReactiveCalls(checker, child)) {
-            found = true;
-        }
-    });
-
-    return found;
-}
-
-function visit(ctx: FindRemainingContext, node: ts.Node): void {
-    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: TransformContext) => {
-        if (!ctx.checker || !hasReactiveCalls(ctx.checker, ctx.sourceFile)) {
+        let checker = ctx.checker;
+
+        if (!checker) {
             return {};
         }
 
@@ -89,36 +44,50 @@ export default {
                 imports: [] as ImportIntent[],
                 prepend: [] as string[],
                 replacements: [] as ReplacementIntent[]
-            };
+            },
+            isReactiveCall = (node: ts.Node): node is ts.CallExpression => isReactiveCallExpression(checker, node),
+            sourceFile = ctx.sourceFile;
 
-        // Run primitives transform first (tracks bindings for signal/computed)
-        intents.replacements.push(
-            ...primitives(ctx.sourceFile, bindings, (node: ts.Node) => isReactiveCallExpression(ctx.checker!, node))
-        );
+        // Run primitives transform first (tracks bindings for signal/computed, collects every call)
+        let { calls, replacements } = primitives(sourceFile, bindings, isReactiveCall);
 
-        // Run object transform
-        let { prepend, replacements } = object(ctx.sourceFile, bindings, ctx.checker);
+        if (calls.length === 0) {
+            return {};
+        }
 
-        intents.prepend.push(...prepend);
         intents.replacements.push(...replacements);
 
+        // Run object transform
+        let objects = object(sourceFile, bindings, isReactiveCall);
+
+        intents.prepend.push(...objects.prepend);
+        intents.replacements.push(...objects.replacements);
+
         // Run array transform separately ( avoid race conditions )
-        intents.replacements.push(...array(ctx.sourceFile, bindings, ctx.checker));
-
-        // Find remaining reactive() calls that weren't transformed and replace with namespace version
-        intents.replacements.push(
-            ...findRemainingCalls(ctx.checker, ctx.sourceFile, new Set(intents.replacements.map(r => r.node)))
-        );
-
-        // Build import intent
-        if (intents.replacements.length > 0 || intents.prepend.length > 0) {
-            intents.imports.push({
-                namespace: NAMESPACE,
-                package: PACKAGE_NAME,
-                remove: [ENTRYPOINT]
+        intents.replacements.push(...array(sourceFile, bindings, isReactiveCall));
+
+        // Calls no transform claimed fall through to the runtime reactive()
+        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/src/compiler/object.ts

@@ -1,8 +1,8 @@
 import { ts } from '@esportsplus/typescript';
-import { code, imports, uid } from '@esportsplus/typescript/compiler';
+import { code, uid } 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 { NAMESPACE, TYPES } from './constants';
+import type { Bindings, IsReactiveCall } from './types';
 
 
 interface AnalyzedProperty {
@@ -28,7 +28,7 @@ interface ReactiveObjectCall {
 interface VisitContext {
     bindings: Bindings;
     calls: ReactiveObjectCall[];
-    checker: ts.Checker | undefined;
+    isReactiveCall: IsReactiveCall;
     sourceFile: ts.SourceFile;
 }
 
@@ -216,24 +216,8 @@ function isStaticValue(node: ts.Node): boolean {
         (ts.isPrefixUnaryExpression(node) && ts.isNumericLiteral(node.operand));
 }
 
-function isReactiveCall(checker: ts.Checker | 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 visit(ctx: VisitContext, node: ts.Node): void {
-    if (isReactiveCall(ctx.checker, node)) {
+    if (ctx.isReactiveCall(node)) {
         let arg = node.arguments[0];
 
         if (arg && ts.isObjectLiteralExpression(arg)) {
@@ -243,7 +227,6 @@ function visit(ctx: VisitContext, node: ts.Node): void {
 
             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++) {
@@ -282,11 +265,11 @@ function visit(ctx: VisitContext, node: ts.Node): void {
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.Checker): ObjectTransformResult => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): ObjectTransformResult => {
     let ctx: VisitContext = {
             bindings,
             calls: [],
-            checker,
+            isReactiveCall,
             sourceFile
         };
 

package/src/compiler/primitives.ts

@@ -1,10 +1,11 @@
 import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import { NAMESPACE, TYPES } from './constants';
-import type { Bindings } from './types';
+import { COMPOUND_OPERATORS, NAMESPACE, TYPES } from './constants';
+import type { Bindings, IsReactiveCall } from './types';
 
 
 interface ScopeBinding {
+    depth: number;
     name: string;
     scope: ts.Node;
     type: TYPES;
@@ -12,31 +13,18 @@ interface ScopeBinding {
 
 interface TransformContext {
     bindings: Bindings;
-    isReactiveCall: (node: ts.Node) => boolean;
+    calls: ts.CallExpression[];
+    isReactiveCall: IsReactiveCall;
     replacements: ReplacementIntent[];
     scopedBindings: ScopeBinding[];
     sourceFile: ts.SourceFile;
     tmpCounter: number;
 }
 
-
-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, '/']
-]);
+type PrimitivesTransformResult = {
+    calls: ts.CallExpression[];
+    replacements: ReplacementIntent[];
+};
 
 
 function inScope(reference: ts.Node, binding: ScopeBinding): boolean {
@@ -53,9 +41,44 @@ function inScope(reference: ts.Node, binding: ScopeBinding): boolean {
     return false;
 }
 
+function isScope(node: ts.Node): boolean {
+    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);
+}
+
+// Innermost enclosing scope plus its nesting depth, so shadowed names resolve to the closest binding
+function scopeOf(node: ts.Node): { depth: number; scope: ts.Node } {
+    let current: ts.Node | undefined = node.parent,
+        depth = 0,
+        scope: ts.Node = 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: TransformContext, node: ts.Node): void {
     if (ctx.isReactiveCall(node)) {
-        let call = node as ts.CallExpression;
+        let call = node;
+
+        ctx.calls.push(call);
 
         if (call.arguments.length > 0) {
             let arg = call.arguments[0],
@@ -101,32 +124,10 @@ function visit(ctx: TransformContext, node: ts.Node): void {
                 }
 
                 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 });
                 }
 
                 // Replace just the 'reactive' identifier with the appropriate namespace function
@@ -159,7 +160,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
         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;
             }
         }
@@ -255,9 +256,10 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: (node: ts.Node) => boolean) => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): PrimitivesTransformResult => {
     let ctx: TransformContext = {
             bindings,
+            calls: [],
             isReactiveCall,
             replacements: [],
             scopedBindings: [],
@@ -267,5 +269,5 @@ export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: (
 
     visit(ctx, sourceFile);
 
-    return ctx.replacements;
+    return { calls: ctx.calls, replacements: ctx.replacements };
 };

package/src/compiler/types.ts

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

package/src/constants.ts

@@ -8,6 +8,8 @@ const REACTIVE_OBJECT = Symbol('reactivity.reactive.object');
 
 const SIGNAL = Symbol('reactivity.signal');
 
+const STABILIZER_DEFERRED = 4;
+
 const STABILIZER_IDLE = 0;
 
 const STABILIZER_RESCHEDULE = 1;
@@ -16,8 +18,6 @@ const STABILIZER_RUNNING = 2;
 
 const STABILIZER_SCHEDULED = 3;
 
-const STATE_NONE = 0;
-
 const STATE_CHECK = 1 << 0;
 
 const STATE_DIRTY = 1 << 1;
@@ -40,6 +40,6 @@ export {
     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
+    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
 };