@esportsplus/reactivity 0.36.7 → 0.37.1

package/src/compiler/array.ts

@@ -1,8 +1,8 @@
 import { ts } from '@esportsplus/typescript';
-import { ast } from '@esportsplus/typescript/compiler';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { COMPOUND_OPERATORS, NAMESPACE, TYPES } from './constants';
 import type { Bindings, IsReactiveCall } from './types';
+import scope from './bindings';
 
 
 type VisitContext = {
@@ -13,25 +13,9 @@ type VisitContext = {
 };
 
 
-function getElementTypeText(typeNode: ts.TypeNode, sourceFile: ts.SourceFile): string | null {
-    if (ts.isArrayTypeNode(typeNode)) {
-        return typeNode.elementType.getText(sourceFile);
-    }
-
-    if (
-        ts.isTypeReferenceNode(typeNode) &&
-        ts.isIdentifier(typeNode.typeName) &&
-        typeNode.typeName.text === 'Array' &&
-        typeNode.typeArguments &&
-        typeNode.typeArguments.length > 0
-    ) {
-        return typeNode.typeArguments[0].getText(sourceFile);
-    }
-
-    return null;
-}
-
-function visit(ctx: VisitContext, node: ts.Node): void {
+// Pass 1, in source order so an alias (`let b = a`) sees the array it copies: reactive([...])
+// declarations, `ReactiveArray`-typed parameters, and aliases of an existing array binding
+function declare(ctx: VisitContext, node: ts.Node): void {
     if (ctx.isReactiveCall(node) && node.arguments.length > 0) {
         let arg = node.arguments[0],
             expression = ts.isAsExpression(arg) ? arg.expression : arg;
@@ -47,7 +31,7 @@ function visit(ctx: VisitContext, node: ts.Node): void {
             }
 
             if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
-                ctx.bindings.set(node.parent.name.text, TYPES.Array);
+                scope.declare(ctx.bindings, node.parent.name, TYPES.Array);
             }
 
             let typeParam = elementType ? `<${elementType}>` : '';
@@ -61,18 +45,14 @@ function visit(ctx: VisitContext, node: ts.Node): void {
         }
     }
 
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
-        if (ts.isIdentifier(node.initializer) && ctx.bindings.get(node.initializer.text) === TYPES.Array) {
-            ctx.bindings.set(node.name.text, TYPES.Array);
-        }
-
-        if (ts.isPropertyAccessExpression(node.initializer)) {
-            let path = ast.property.path(node.initializer);
-
-            if (path && ctx.bindings.get(path) === TYPES.Array) {
-                ctx.bindings.set(node.name.text, TYPES.Array);
-            }
-        }
+    if (
+        ts.isVariableDeclaration(node) &&
+        ts.isIdentifier(node.name) &&
+        node.initializer &&
+        (ts.isIdentifier(node.initializer) || ts.isPropertyAccessExpression(node.initializer)) &&
+        scope.isArray(ctx.bindings, node.initializer)
+    ) {
+        scope.declare(ctx.bindings, node.name, TYPES.Array);
     }
 
     if ((ts.isFunctionDeclaration(node) || ts.isArrowFunction(node)) && node.parameters) {
@@ -80,91 +60,105 @@ function visit(ctx: VisitContext, node: ts.Node): void {
             let param = node.parameters[i];
 
             if (
-                (ts.isIdentifier(param.name) && param.type) &&
+                ts.isIdentifier(param.name) &&
+                param.type &&
                 ts.isTypeReferenceNode(param.type) &&
                 ts.isIdentifier(param.type.typeName) &&
                 param.type.typeName.text === 'ReactiveArray'
             ) {
-                ctx.bindings.set(param.name.text, TYPES.Array);
+                scope.declare(ctx.bindings, param.name, TYPES.Array);
             }
         }
     }
 
-    if (ts.isPropertyAccessExpression(node) && node.name.text === 'length') {
-        let name = ast.expression.name(node.expression);
-
-        if (name && ctx.bindings.get(name) === TYPES.Array) {
-            let expr = node.expression,
-                parent = node.parent;
-
-            // arr.length = value OR arr.length += value
-            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)}`
-                    });
-                }
-                else {
-                    ctx.replacements.push({
-                        node: parent,
-                        generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} ${parent.right.getText(sf)}`
-                    });
-                }
-            }
-            // arr.length++ or arr.length--
-            else if (parent && ts.isPostfixUnaryExpression(parent)) {
-                let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
+    node.forEachChild(child => declare(ctx, child));
+}
 
-                ctx.replacements.push({
-                    node: parent,
-                    generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} 1`
-                });
-            }
-            // ++arr.length or --arr.length
-            else if (parent && ts.isPrefixUnaryExpression(parent)) {
-                let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
+function getElementTypeText(typeNode: ts.TypeNode, sourceFile: ts.SourceFile): string | null {
+    if (ts.isArrayTypeNode(typeNode)) {
+        return typeNode.elementType.getText(sourceFile);
+    }
+
+    if (
+        ts.isTypeReferenceNode(typeNode) &&
+        ts.isIdentifier(typeNode.typeName) &&
+        typeNode.typeName.text === 'Array' &&
+        typeNode.typeArguments &&
+        typeNode.typeArguments.length > 0
+    ) {
+        return typeNode.typeArguments[0].getText(sourceFile);
+    }
+
+    return null;
+}
+
+// Pass 2: rewrite `.length`, index writes and whole-array reassignment on array bindings only
+function rewrite(ctx: VisitContext, node: ts.Node): void {
+    if (ts.isTypeNode(node)) {
+        return;
+    }
 
+    if (ts.isPropertyAccessExpression(node) && node.name.text === 'length' && scope.isArray(ctx.bindings, node.expression)) {
+        let expr = node.expression,
+            parent = node.parent;
+
+        // arr.length = value OR arr.length += value
+        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 = ${expr.getText(sf)}.length ${op} 1`
+                    generate: (sf) => `${expr.getText(sf)}.$length = ${parent.right.getText(sf)}`
                 });
             }
-            // Read-only: arr.length → arr.$length
             else {
                 ctx.replacements.push({
-                    node,
-                    generate: (sf) => `${expr.getText(sf)}.$length`
+                    node: parent,
+                    generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} ${parent.right.getText(sf)}`
                 });
             }
         }
+        // arr.length++ / arr.length-- / ++arr.length / --arr.length
+        else if (parent && (ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent))) {
+            let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
+
+            ctx.replacements.push({
+                node: parent,
+                generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} 1`
+            });
+        }
+        // Read-only: arr.length → arr.$length
+        else {
+            ctx.replacements.push({
+                node,
+                generate: (sf) => `${expr.getText(sf)}.$length`
+            });
+        }
     }
 
     if (
         ts.isBinaryExpression(node) &&
         node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-        ts.isElementAccessExpression(node.left)
+        ts.isElementAccessExpression(node.left) &&
+        scope.isArray(ctx.bindings, node.left.expression)
     ) {
-        let element = node.left,
-            name = ast.expression.name(element.expression);
+        let element = node.left;
 
-        if (name && ctx.bindings.get(name) === TYPES.Array) {
-            ctx.replacements.push({
-                node,
-                generate: (sf) => `${element.expression.getText(sf)}.$set(
+        ctx.replacements.push({
+            node,
+            generate: (sf) => `${element.expression.getText(sf)}.$set(
                     ${element.argumentExpression.getText(sf)},
                     ${node.right.getText(sf)}
                 )`
-            });
-        }
+        });
     }
 
     if (
         ts.isBinaryExpression(node) &&
         node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-        ts.isIdentifier(node.left)
+        ts.isIdentifier(node.left) &&
+        scope.isArray(ctx.bindings, node.left)
     ) {
         let name = node.left.text,
             right = node.right;
@@ -174,17 +168,19 @@ function visit(ctx: VisitContext, node: ts.Node): void {
             right = right.expression;
         }
 
-        if (ctx.bindings.get(name) === TYPES.Array && ts.isArrayLiteralExpression(right)) {
+        if (ts.isArrayLiteralExpression(right)) {
+            let elements = right;
+
             ctx.replacements.push({
                 node,
-                generate: (sf) => right.elements.length > 0
-                    ? `${name}.splice(0, ${name}.length, ...${right.getText(sf)})`
+                generate: (sf) => elements.elements.length > 0
+                    ? `${name}.splice(0, ${name}.length, ...${elements.getText(sf)})`
                     : `${name}.splice(0, ${name}.length)`
             });
         }
     }
 
-    node.forEachChild(n => visit(ctx, n));
+    node.forEachChild(child => rewrite(ctx, child));
 }
 
 
@@ -196,7 +192,8 @@ export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: I
             sourceFile
         };
 
-    visit(ctx, sourceFile);
+    declare(ctx, sourceFile);
+    rewrite(ctx, sourceFile);
 
     return ctx.replacements;
 };

package/src/compiler/bindings.ts

@@ -0,0 +1,100 @@
+import { ts } from '@esportsplus/typescript';
+import { TYPES } from './constants';
+import type { Bindings } from './types';
+
+
+function root(expression: ts.Expression): { path: string; root: ts.Identifier } | null {
+    let parts: string[] = [];
+
+    while (ts.isPropertyAccessExpression(expression)) {
+        parts.push(expression.name.text);
+        expression = expression.expression;
+    }
+
+    if (!ts.isIdentifier(expression) || parts.length === 0) {
+        return null;
+    }
+
+    return { path: parts.reverse().join('.'), root: expression };
+}
+
+function symbolOf(bindings: Bindings, identifier: ts.Identifier): ts.Symbol | undefined {
+    let parent = identifier.parent;
+
+    // A shorthand property's own symbol is the object property, not the variable it reads
+    if (parent && ts.isShorthandPropertyAssignment(parent) && parent.name === identifier) {
+        return bindings.checker.getShorthandAssignmentValueSymbol(parent);
+    }
+
+    return bindings.checker.getSymbolAtLocation(identifier);
+}
+
+
+// Bindings are keyed by symbol, so a shadowing local, parameter or property that merely shares a
+// reactive variable's name is never rewritten. `names` keeps resolution cheap: an identifier whose
+// text no reactive declaration uses cannot refer to one, so it never costs a checker round-trip.
+const create = (checker: ts.Checker): Bindings => ({
+    checker,
+    names: new Set(),
+    paths: new Map(),
+    symbols: new Map()
+});
+
+const declare = (bindings: Bindings, identifier: ts.Identifier, type: TYPES): void => {
+    let symbol = bindings.checker.getSymbolAtLocation(identifier);
+
+    if (symbol) {
+        bindings.names.add(identifier.text);
+        bindings.symbols.set(symbol, type);
+    }
+};
+
+// `state.items` where `state` is a reactive object whose `items` property is a ReactiveArray
+const declarePath = (bindings: Bindings, identifier: ts.Identifier, path: string): void => {
+    let symbol = bindings.checker.getSymbolAtLocation(identifier);
+
+    if (!symbol) {
+        return;
+    }
+
+    let paths = bindings.paths.get(symbol);
+
+    if (!paths) {
+        paths = new Set();
+        bindings.paths.set(symbol, paths);
+    }
+
+    bindings.names.add(identifier.text);
+    paths.add(path);
+};
+
+// True for an identifier or property path that denotes a ReactiveArray binding
+const isArray = (bindings: Bindings, expression: ts.Expression): boolean => {
+    if (ts.isIdentifier(expression)) {
+        return resolve(bindings, expression)?.type === TYPES.Array;
+    }
+
+    let access = root(expression);
+
+    if (!access || !bindings.names.has(access.root.text)) {
+        return false;
+    }
+
+    let symbol = symbolOf(bindings, access.root);
+
+    return symbol !== undefined && bindings.paths.get(symbol)?.has(access.path) === true;
+};
+
+const resolve = (bindings: Bindings, identifier: ts.Identifier): { symbol: ts.Symbol; type: TYPES } | null => {
+    if (!bindings.names.has(identifier.text)) {
+        return null;
+    }
+
+    let symbol = symbolOf(bindings, identifier),
+        type = symbol && bindings.symbols.get(symbol);
+
+    return symbol && type !== undefined ? { symbol, type } : null;
+};
+
+
+export default { create, declare, declarePath, isArray, resolve };

package/src/compiler/index.ts

@@ -2,13 +2,22 @@ import { ts } from '@esportsplus/typescript';
 import { imports } from '@esportsplus/typescript/compiler';
 import type { ImportIntent, ReplacementIntent, TransformContext } from '@esportsplus/typescript/compiler';
 import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME } from './constants';
-import type { Bindings } from './types';
 
 import array from './array';
 import object from './object';
 import primitives from './primitives';
+import scope from './bindings';
 
 
+// Resolved once per file: every pass asks the same question of the same nodes
+function collect(checker: ts.Checker, node: ts.Node, calls: Set<ts.Node>): void {
+    if (isReactiveCallExpression(checker, node)) {
+        calls.add(node);
+    }
+
+    node.forEachChild(child => collect(checker, child, calls));
+}
+
 function isReactiveCallExpression(checker: ts.Checker, node: ts.Node): node is ts.CallExpression {
     if (!ts.isCallExpression(node)) {
         return false;
@@ -21,9 +30,9 @@ function isReactiveCallExpression(checker: ts.Checker, node: ts.Node): node is t
         return imports.includes(checker, expr, PACKAGE_NAME, ENTRYPOINT);
     }
 
-    // Property access: ns.reactive(...)
-    if (ts.isPropertyAccessExpression(expr) && expr.name.text === ENTRYPOINT) {
-        return imports.includes(checker, expr, PACKAGE_NAME);
+    // Namespace call: ns.reactive(...) — the namespace identifier carries the import origin
+    if (ts.isPropertyAccessExpression(expr) && expr.name.text === ENTRYPOINT && ts.isIdentifier(expr.expression)) {
+        return imports.includes(checker, expr.expression, PACKAGE_NAME);
     }
 
     return false;
@@ -39,22 +48,26 @@ export default {
             return {};
         }
 
-        let bindings: Bindings = new Map(),
+        let bindings = scope.create(checker),
+            candidates = new Set<ts.Node>(),
             intents = {
                 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, collects every call)
-        let { calls, replacements } = primitives(sourceFile, bindings, isReactiveCall);
+        collect(checker, sourceFile, candidates);
 
-        if (calls.length === 0) {
+        if (candidates.size === 0) {
             return {};
         }
 
+        let isReactiveCall = (node: ts.Node): node is ts.CallExpression => candidates.has(node);
+
+        // Run primitives transform first (tracks bindings for signal/computed, collects every call)
+        let { calls, replacements } = primitives(sourceFile, bindings, isReactiveCall);
+
         intents.replacements.push(...replacements);
 
         // Run object transform

package/src/compiler/object.ts

@@ -3,6 +3,7 @@ import { code, uid } from '@esportsplus/typescript/compiler';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { NAMESPACE, TYPES } from './constants';
 import type { Bindings, IsReactiveCall } from './types';
+import scope from './bindings';
 
 
 interface AnalyzedProperty {
@@ -223,11 +224,10 @@ function visit(ctx: VisitContext, node: ts.Node): void {
         if (arg && ts.isObjectLiteralExpression(arg)) {
             let properties: AnalyzedProperty[] = [],
                 props = arg.properties,
-                varname: string | null = null;
-
-            if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
-                varname = node.parent.name.text;
-            }
+                target = node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)
+                    ? node.parent.name
+                    : null,
+                varname = target?.text ?? null;
 
             for (let i = 0, n = props.length; i < n; i++) {
                 let prop = props[i];
@@ -245,9 +245,14 @@ function visit(ctx: VisitContext, node: ts.Node): void {
                 }
 
                 properties.push(analyzed);
+            }
 
-                if (analyzed.type === TYPES.Array && varname) {
-                    ctx.bindings.set(`${varname}.${analyzed.key}`, TYPES.Array);
+            // Declared only once every property analyzed: a bailed object stays a runtime reactive()
+            if (target) {
+                for (let i = 0, n = properties.length; i < n; i++) {
+                    if (properties[i].type === TYPES.Array) {
+                        scope.declarePath(ctx.bindings, target, properties[i].key);
+                    }
                 }
             }