@esportsplus/reactivity 0.28.0 → 0.28.2

package/build/compiler/array.js

@@ -1,6 +1,19 @@
 import { ts } from '@esportsplus/typescript';
 import { ast } from '@esportsplus/typescript/compiler';
 import { COMPILER_NAMESPACE, COMPILER_TYPES } from '../constants.js';
+function getElementTypeText(typeNode, sourceFile) {
+    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 isReactiveCall(node) {
     return ts.isIdentifier(node.expression) && node.expression.text === 'reactive';
 }
@@ -8,14 +21,22 @@ function visit(ctx, node) {
     if (ts.isCallExpression(node) && 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;
+            if (ts.isAsExpression(arg) && arg.type) {
+                elementType = getElementTypeText(arg.type, ctx.sourceFile);
+            }
+            else if (node.parent && ts.isVariableDeclaration(node.parent) && node.parent.type) {
+                elementType = getElementTypeText(node.parent.type, ctx.sourceFile);
+            }
             if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 ctx.bindings.set(node.parent.name.text, COMPILER_TYPES.Array);
             }
+            let typeParam = elementType ? `<${elementType}>` : '';
             ctx.replacements.push({
                 node,
                 generate: (sf) => expression.elements.length > 0
-                    ? ` new ${COMPILER_NAMESPACE}.ReactiveArray(...${expression.getText(sf)})`
-                    : ` new ${COMPILER_NAMESPACE}.ReactiveArray()`
+                    ? ` new ${COMPILER_NAMESPACE}.ReactiveArray${typeParam}(...${expression.getText(sf)})`
+                    : ` new ${COMPILER_NAMESPACE}.ReactiveArray${typeParam}()`
             });
         }
     }

package/build/compiler/index.js

@@ -1,13 +1,50 @@
 import { ts } from '@esportsplus/typescript';
-import { ast, imports } from '@esportsplus/typescript/compiler';
+import { imports } from '@esportsplus/typescript/compiler';
 import { COMPILER_ENTRYPOINT, COMPILER_NAMESPACE, PACKAGE } from '../constants.js';
 import array from './array.js';
 import object from './object.js';
 function hasReactiveImport(sourceFile) {
     return imports.find(sourceFile, PACKAGE).some(i => i.specifiers.has(COMPILER_ENTRYPOINT));
 }
-function isReactiveCallNode(node) {
-    return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === COMPILER_ENTRYPOINT;
+function isReactiveSymbol(checker, node) {
+    let symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) {
+        return false;
+    }
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+    let declarations = symbol.getDeclarations();
+    if (!declarations || declarations.length === 0) {
+        return false;
+    }
+    for (let i = 0, n = declarations.length; i < n; i++) {
+        let decl = declarations[i], sourceFile = decl.getSourceFile();
+        if (sourceFile.fileName.includes(PACKAGE) || sourceFile.fileName.includes('reactivity')) {
+            if (symbol.name === COMPILER_ENTRYPOINT) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isReactiveCallExpression(checker, node) {
+    if (!ts.isCallExpression(node)) {
+        return false;
+    }
+    let expr = node.expression;
+    if (ts.isIdentifier(expr)) {
+        if (expr.text === COMPILER_ENTRYPOINT) {
+            return true;
+        }
+        if (checker) {
+            return isReactiveSymbol(checker, expr);
+        }
+    }
+    if (ts.isPropertyAccessExpression(expr) && expr.name.text === COMPILER_ENTRYPOINT && checker) {
+        return isReactiveSymbol(checker, expr);
+    }
+    return false;
 }
 const plugin = {
     patterns: ['reactive(', 'reactive<'],
@@ -21,15 +58,23 @@ const plugin = {
         replacements.push(...objectResult.replacements);
         let arrayResult = array(ctx.sourceFile, bindings, ctx.checker);
         replacements.push(...arrayResult);
-        if (replacements.length > 0 || prepend.length > 0) {
-            let remove = [];
-            if (!ast.hasMatch(ctx.sourceFile, isReactiveCallNode) || replacements.length > 0) {
-                remove.push(COMPILER_ENTRYPOINT);
+        let transformedNodes = new Set(replacements.map(r => r.node));
+        function findRemainingReactiveCalls(node) {
+            if (isReactiveCallExpression(ctx.checker, node) && !transformedNodes.has(node)) {
+                let call = node;
+                replacements.push({
+                    generate: () => `${COMPILER_NAMESPACE}.reactive(${call.arguments.map(a => a.getText(ctx.sourceFile)).join(', ')})`,
+                    node: call
+                });
             }
+            ts.forEachChild(node, findRemainingReactiveCalls);
+        }
+        findRemainingReactiveCalls(ctx.sourceFile);
+        if (replacements.length > 0 || prepend.length > 0) {
             importsIntent.push({
                 namespace: COMPILER_NAMESPACE,
                 package: PACKAGE,
-                remove
+                remove: [COMPILER_ENTRYPOINT]
             });
         }
         return {

package/package.json

@@ -31,7 +31,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.28.0",
+  "version": "0.28.2",
   "scripts": {
     "build": "tsc",
     "build:test": "pnpm build && vite build --config test/vite.config.ts",

package/src/compiler/array.ts

@@ -13,6 +13,24 @@ interface 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 isReactiveCall(node: ts.CallExpression): boolean {
     return ts.isIdentifier(node.expression) && node.expression.text === 'reactive';
 }
@@ -23,15 +41,26 @@ function visit(ctx: VisitContext, node: ts.Node): void {
             expression = ts.isAsExpression(arg) ? arg.expression : arg;
 
         if (ts.isArrayLiteralExpression(expression)) {
+            let elementType: string | null = null;
+
+            if (ts.isAsExpression(arg) && arg.type) {
+                elementType = getElementTypeText(arg.type, ctx.sourceFile);
+            }
+            else if (node.parent && ts.isVariableDeclaration(node.parent) && node.parent.type) {
+                elementType = getElementTypeText(node.parent.type, ctx.sourceFile);
+            }
+
             if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 ctx.bindings.set(node.parent.name.text, COMPILER_TYPES.Array);
             }
 
+            let typeParam = elementType ? `<${elementType}>` : '';
+
             ctx.replacements.push({
                 node,
                 generate: (sf) => expression.elements.length > 0
-                    ? ` new ${COMPILER_NAMESPACE}.ReactiveArray(...${expression.getText(sf)})`
-                    : ` new ${COMPILER_NAMESPACE}.ReactiveArray()`
+                    ? ` new ${COMPILER_NAMESPACE}.ReactiveArray${typeParam}(...${expression.getText(sf)})`
+                    : ` new ${COMPILER_NAMESPACE}.ReactiveArray${typeParam}()`
             });
         }
     }

package/src/compiler/index.ts

@@ -1,6 +1,6 @@
 import type { ImportIntent, Plugin, ReplacementIntent, TransformContext } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
-import { ast, imports } from '@esportsplus/typescript/compiler';
+import { imports } from '@esportsplus/typescript/compiler';
 import { COMPILER_ENTRYPOINT, COMPILER_NAMESPACE, PACKAGE } from '~/constants';
 import type { Bindings } from '~/types';
 import array from './array';
@@ -11,8 +11,66 @@ function hasReactiveImport(sourceFile: ts.SourceFile): boolean {
     return imports.find(sourceFile, PACKAGE).some(i => i.specifiers.has(COMPILER_ENTRYPOINT));
 }
 
-function isReactiveCallNode(node: ts.Node): boolean {
-    return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === COMPILER_ENTRYPOINT;
+function isReactiveSymbol(checker: ts.TypeChecker, node: ts.Node): boolean {
+    let symbol = checker.getSymbolAtLocation(node);
+
+    if (!symbol) {
+        return false;
+    }
+
+    // Follow aliases to original symbol
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+
+    let declarations = symbol.getDeclarations();
+
+    if (!declarations || declarations.length === 0) {
+        return false;
+    }
+
+    for (let i = 0, n = declarations.length; i < n; i++) {
+        let decl = declarations[i],
+            sourceFile = decl.getSourceFile();
+
+        // Check if declaration is from our package
+        if (sourceFile.fileName.includes(PACKAGE) || sourceFile.fileName.includes('reactivity')) {
+            // Verify it's the reactive export
+            if (symbol.name === COMPILER_ENTRYPOINT) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+function isReactiveCallExpression(checker: ts.TypeChecker | undefined, node: ts.Node): node is ts.CallExpression {
+    if (!ts.isCallExpression(node)) {
+        return false;
+    }
+
+    let expr = node.expression;
+
+    // Direct call: reactive(...) or aliasedName(...)
+    if (ts.isIdentifier(expr)) {
+        // Fast path: literal "reactive"
+        if (expr.text === COMPILER_ENTRYPOINT) {
+            return true;
+        }
+
+        // Use checker to resolve aliases
+        if (checker) {
+            return isReactiveSymbol(checker, expr);
+        }
+    }
+
+    // Property access: ns.reactive(...)
+    if (ts.isPropertyAccessExpression(expr) && expr.name.text === COMPILER_ENTRYPOINT && checker) {
+        return isReactiveSymbol(checker, expr);
+    }
+
+    return false;
 }
 
 
@@ -40,20 +98,30 @@ const plugin: Plugin = {
 
         replacements.push(...arrayResult);
 
-        // Build import intent
-        if (replacements.length > 0 || prepend.length > 0) {
-            let remove: string[] = [];
+        // Find remaining reactive() calls that weren't transformed and replace with namespace version
+        let transformedNodes = new Set(replacements.map(r => r.node));
 
-            // Check if we still have reactive() calls after transform
-            // This is a heuristic - if we have no replacements for reactive calls, keep the import
-            if (!ast.hasMatch(ctx.sourceFile, isReactiveCallNode) || replacements.length > 0) {
-                remove.push(COMPILER_ENTRYPOINT);
+        function findRemainingReactiveCalls(node: ts.Node): void {
+            if (isReactiveCallExpression(ctx.checker, node) && !transformedNodes.has(node)) {
+                let call = node;
+
+                replacements.push({
+                    generate: () => `${COMPILER_NAMESPACE}.reactive(${call.arguments.map(a => a.getText(ctx.sourceFile)).join(', ')})`,
+                    node: call
+                });
             }
 
+            ts.forEachChild(node, findRemainingReactiveCalls);
+        }
+
+        findRemainingReactiveCalls(ctx.sourceFile);
+
+        // Build import intent
+        if (replacements.length > 0 || prepend.length > 0) {
             importsIntent.push({
                 namespace: COMPILER_NAMESPACE,
                 package: PACKAGE,
-                remove
+                remove: [COMPILER_ENTRYPOINT]
             });
         }