@esportsplus/reactivity 0.26.0 → 0.27.0

package/build/compiler/array.d.ts

@@ -1,4 +1,4 @@
 import { ts } from '@esportsplus/typescript';
 import type { Bindings } from '../types.js';
-declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, _ns: string) => string;
+declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, _ns: string, _checker?: ts.TypeChecker) => string;
 export default _default;

package/build/compiler/array.js

@@ -54,7 +54,7 @@ function visit(ctx, node) {
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
-export default (sourceFile, bindings, _ns) => {
+export default (sourceFile, bindings, _ns, _checker) => {
     let code = sourceFile.getFullText(), ctx = {
         bindings,
         replacements: [],

package/build/compiler/index.d.ts

@@ -1,4 +1,4 @@
 import { ts } from '@esportsplus/typescript';
 import type { TransformResult } from '../types.js';
-declare const transform: (sourceFile: ts.SourceFile) => TransformResult;
+declare const transform: (sourceFile: ts.SourceFile, program: ts.Program) => TransformResult;
 export { transform };

package/build/compiler/index.js

@@ -1,51 +1,46 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c } from '@esportsplus/typescript/compiler';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE } from '../constants.js';
+import { code as c, imports } from '@esportsplus/typescript/compiler';
+import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE, PACKAGE } from '../constants.js';
 import array from './array.js';
 import object from './object.js';
 import primitives from './primitives.js';
 let transforms = [object, array, primitives];
-function contains(code) {
-    if (!c.contains(code, { regex: COMPILER_ENTRYPOINT_REGEX })) {
-        return false;
+function hasReactiveImport(sourceFile) {
+    let found = imports.find(sourceFile, PACKAGE);
+    for (let i = 0, n = found.length; i < n; i++) {
+        if (found[i].specifiers.has(COMPILER_ENTRYPOINT)) {
+            return true;
+        }
     }
-    let ctx = {
-        imported: false,
-        used: false
-    };
-    visit(ctx, ts.createSourceFile('detect.ts', code, ts.ScriptTarget.Latest, false));
-    return ctx.imported && ctx.used;
+    return false;
 }
-function visit(ctx, node) {
-    if (ctx.imported && ctx.used) {
-        return;
+function hasReactiveUsage(code) {
+    if (!c.contains(code, { regex: COMPILER_ENTRYPOINT_REGEX })) {
+        return false;
     }
-    if (ts.isImportDeclaration(node) &&
-        node.importClause?.namedBindings &&
-        ts.isNamedImports(node.importClause.namedBindings)) {
-        let elements = node.importClause.namedBindings.elements;
-        for (let i = 0, n = elements.length; i < n; i++) {
-            let element = elements[i];
-            if ((element.propertyName?.text ?? element.name.text) === COMPILER_ENTRYPOINT) {
-                ctx.imported = true;
-                break;
-            }
+    let sourceFile = ts.createSourceFile('detect.ts', code, ts.ScriptTarget.Latest, false), used = false;
+    function visit(node) {
+        if (used) {
+            return;
         }
+        if (ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === COMPILER_ENTRYPOINT) {
+            used = true;
+            return;
+        }
+        ts.forEachChild(node, visit);
     }
-    if (ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === COMPILER_ENTRYPOINT) {
-        ctx.used = true;
-    }
-    ts.forEachChild(node, n => visit(ctx, n));
+    visit(sourceFile);
+    return used;
 }
-const transform = (sourceFile) => {
-    let bindings = new Map(), changed = false, code = sourceFile.getFullText(), current = sourceFile, result;
-    if (!contains(code)) {
+const transform = (sourceFile, program) => {
+    let bindings = new Map(), changed = false, checker = program.getTypeChecker(), code = sourceFile.getFullText(), current = sourceFile, result;
+    if (!hasReactiveImport(sourceFile) || !hasReactiveUsage(code)) {
         return { changed: false, code, sourceFile };
     }
     for (let i = 0, n = transforms.length; i < n; i++) {
-        result = transforms[i](current, bindings, COMPILER_NAMESPACE);
+        result = transforms[i](current, bindings, COMPILER_NAMESPACE, checker);
         if (result !== code) {
             current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
             code = result;
@@ -53,6 +48,7 @@ const transform = (sourceFile) => {
         }
     }
     if (changed) {
+        code = imports.modify(code, current, PACKAGE, { remove: [COMPILER_ENTRYPOINT] });
         code = `import * as ${COMPILER_NAMESPACE} from '@esportsplus/reactivity';\n` + code;
         sourceFile = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
     }

package/build/compiler/object.d.ts

@@ -1,4 +1,4 @@
 import { ts } from '@esportsplus/typescript';
 import type { Bindings } from '../types.js';
-declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, ns: string) => string;
+declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, ns: string, checker?: ts.TypeChecker) => string;
 export default _default;

package/build/compiler/object.js

@@ -1,6 +1,6 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c } from '@esportsplus/typescript/compiler';
-import { COMPILER_TYPES, PACKAGE } from '../constants.js';
+import { code as c, imports } from '@esportsplus/typescript/compiler';
+import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '../constants.js';
 function analyzeProperty(prop, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) {
         return null;
@@ -60,27 +60,21 @@ function buildClassCode(className, properties, ns) {
         }
     `;
 }
+function isReactiveCall(node, checker) {
+    if (!ts.isIdentifier(node.expression)) {
+        return false;
+    }
+    if (node.expression.text !== COMPILER_ENTRYPOINT) {
+        return false;
+    }
+    return imports.isFromPackage(node.expression, PACKAGE, checker);
+}
 function visit(ctx, node) {
     if (ts.isImportDeclaration(node)) {
         ctx.lastImportEnd = node.end;
-        if (ts.isStringLiteral(node.moduleSpecifier) &&
-            node.moduleSpecifier.text.includes(PACKAGE)) {
-            let clause = node.importClause;
-            if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
-                let elements = clause.namedBindings.elements;
-                for (let i = 0, n = elements.length; i < n; i++) {
-                    if (elements[i].name.text === 'reactive') {
-                        ctx.hasReactiveImport = true;
-                        break;
-                    }
-                }
-            }
-        }
     }
-    if (ctx.hasReactiveImport &&
-        ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === 'reactive') {
+    if (ts.isCallExpression(node) &&
+        isReactiveCall(node, ctx.checker)) {
         let arg = node.arguments[0];
         if (arg && ts.isObjectLiteralExpression(arg)) {
             let properties = [], props = arg.properties, varName = null;
@@ -115,12 +109,12 @@ function visit(ctx, node) {
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
-export default (sourceFile, bindings, ns) => {
+export default (sourceFile, bindings, ns, checker) => {
     let code = sourceFile.getFullText(), ctx = {
         bindings,
         calls: [],
+        checker,
         classCounter: 0,
-        hasReactiveImport: false,
         lastImportEnd: 0,
         ns,
         sourceFile

package/build/compiler/primitives.d.ts

@@ -1,4 +1,4 @@
 import { ts } from '@esportsplus/typescript';
 import type { Bindings } from '../types.js';
-declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, ns: string) => string;
+declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, ns: string, checker?: ts.TypeChecker) => string;
 export default _default;

package/build/compiler/primitives.js

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
-import { ast, code as c } from '@esportsplus/typescript/compiler';
+import { ast, code as c, imports } from '@esportsplus/typescript/compiler';
 import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '../constants.js';
 const COMPOUND_OPERATORS = new Map([
     [ts.SyntaxKind.AmpersandAmpersandEqualsToken, '&&'],
@@ -58,15 +58,22 @@ function isInScope(reference, binding) {
     }
     return false;
 }
-function isReactiveReassignment(node) {
+function isReactiveCall(node, checker) {
+    if (!ts.isIdentifier(node.expression)) {
+        return false;
+    }
+    if (node.expression.text !== COMPILER_ENTRYPOINT) {
+        return false;
+    }
+    return imports.isFromPackage(node.expression, PACKAGE, checker);
+}
+function isReactiveReassignment(node, checker) {
     let parent = node.parent;
     if (ts.isBinaryExpression(parent) &&
         parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
         parent.right === node &&
-        ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === COMPILER_ENTRYPOINT) {
-        return true;
+        ts.isCallExpression(node)) {
+        return isReactiveCall(node, checker);
     }
     return false;
 }
@@ -90,24 +97,9 @@ function isWriteContext(node) {
     return false;
 }
 function visit(ctx, node) {
-    if (ts.isImportDeclaration(node) &&
-        ts.isStringLiteral(node.moduleSpecifier) &&
-        node.moduleSpecifier.text.includes(PACKAGE)) {
-        let clause = node.importClause;
-        if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
-            for (let i = 0, n = clause.namedBindings.elements.length; i < n; i++) {
-                if (clause.namedBindings.elements[i].name.text === COMPILER_ENTRYPOINT) {
-                    ctx.hasReactiveImport = true;
-                    break;
-                }
-            }
-        }
-    }
-    if (ctx.hasReactiveImport &&
-        ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === COMPILER_ENTRYPOINT &&
-        node.arguments.length > 0) {
+    if (ts.isCallExpression(node) &&
+        node.arguments.length > 0 &&
+        isReactiveCall(node, ctx.checker)) {
         let arg = node.arguments[0], classification = COMPILER_TYPES.Signal;
         if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
             classification = COMPILER_TYPES.Computed;
@@ -170,7 +162,7 @@ function visit(ctx, node) {
         }
         let binding = findBinding(ctx.scopedBindings, node.text, node), name = node.text;
         if (binding && node.parent) {
-            if (!isReactiveReassignment(node.parent) &&
+            if (!isReactiveReassignment(node.parent, ctx.checker) &&
                 !(ts.isTypeOfExpression(node.parent) && node.parent.expression === node)) {
                 let writeCtx = isWriteContext(node);
                 if (writeCtx) {
@@ -247,11 +239,11 @@ function visitArg(ctx, node) {
     }
     ts.forEachChild(node, n => visitArg(ctx, n));
 }
-export default (sourceFile, bindings, ns) => {
+export default (sourceFile, bindings, ns, checker) => {
     let code = sourceFile.getFullText(), ctx = {
         bindings,
+        checker,
         computedArgRanges: [],
-        hasReactiveImport: false,
         ns,
         replacements: [],
         scopedBindings: [],

package/package.json

@@ -4,23 +4,22 @@
     "@esportsplus/utilities": "^0.27.2"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.21.0",
+    "@esportsplus/typescript": "^0.22.0",
     "@types/node": "^25.0.3",
     "vite": "^7.3.0"
   },
   "exports": {
     ".": {
-      "import": "./build/index.js",
-      "types": "./build/index.d.ts"
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
     },
     "./compiler/tsc": {
       "types": "./build/compiler/plugins/tsc.d.ts",
-      "import": "./build/compiler/plugins/tsc.js",
-      "require": "./build/compiler/plugins/tsc.js"
+      "default": "./build/compiler/plugins/tsc.js"
     },
     "./compiler/vite": {
       "types": "./build/compiler/plugins/vite.d.ts",
-      "import": "./build/compiler/plugins/vite.js"
+      "default": "./build/compiler/plugins/vite.js"
     }
   },
   "main": "build/index.js",
@@ -32,7 +31,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "scripts": {
     "build": "tsc",
     "build:test": "pnpm build && vite build --config test/vite.config.ts",

package/src/compiler/array.ts

@@ -81,7 +81,7 @@ function visit(ctx: { bindings: Bindings, replacements: Replacement[], sourceFil
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, _ns: string): string => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, _ns: string, _checker?: ts.TypeChecker): string => {
     let code = sourceFile.getFullText(),
         ctx = {
             bindings,

package/src/compiler/index.ts

@@ -1,6 +1,6 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c } from '@esportsplus/typescript/compiler';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE } from '~/constants';
+import { code as c, imports } from '@esportsplus/typescript/compiler';
+import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE, PACKAGE } from '~/constants';
 import type { Bindings, TransformResult } from '~/types';
 import array from './array';
 import object from './object';
@@ -10,68 +10,63 @@ import primitives from './primitives';
 let transforms = [object, array, primitives];
 
 
-function contains(code: string): boolean {
-    if (!c.contains(code, { regex: COMPILER_ENTRYPOINT_REGEX })) {
-        return false;
-    }
+function hasReactiveImport(sourceFile: ts.SourceFile): boolean {
+    let found = imports.find(sourceFile, PACKAGE);
 
-    let ctx = {
-            imported: false,
-            used: false
-        };
-
-    visit(ctx, ts.createSourceFile('detect.ts', code, ts.ScriptTarget.Latest, false));
+    for (let i = 0, n = found.length; i < n; i++) {
+        if (found[i].specifiers.has(COMPILER_ENTRYPOINT)) {
+            return true;
+        }
+    }
 
-    return ctx.imported && ctx.used;
+    return false;
 }
 
-function visit(ctx: { imported: boolean; used: boolean; }, node: ts.Node): void {
-    if (ctx.imported && ctx.used) {
-        return;
+function hasReactiveUsage(code: string): boolean {
+    if (!c.contains(code, { regex: COMPILER_ENTRYPOINT_REGEX })) {
+        return false;
     }
 
-    if (
-        ts.isImportDeclaration(node) &&
-        node.importClause?.namedBindings &&
-        ts.isNamedImports(node.importClause.namedBindings)
-    ) {
-        let elements = node.importClause.namedBindings.elements;
+    let sourceFile = ts.createSourceFile('detect.ts', code, ts.ScriptTarget.Latest, false),
+        used = false;
 
-        for (let i = 0, n = elements.length; i < n; i++) {
-            let element = elements[i];
+    function visit(node: ts.Node): void {
+        if (used) {
+            return;
+        }
 
-            if ((element.propertyName?.text ?? element.name.text) === COMPILER_ENTRYPOINT) {
-                ctx.imported = true;
-                break;
-            }
+        if (
+            ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === COMPILER_ENTRYPOINT
+        ) {
+            used = true;
+            return;
         }
-    }
 
-    if (
-        ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === COMPILER_ENTRYPOINT
-    ) {
-        ctx.used = true;
+        ts.forEachChild(node, visit);
     }
 
-    ts.forEachChild(node, n => visit(ctx, n));
+    visit(sourceFile);
+
+    return used;
 }
 
 
-const transform = (sourceFile: ts.SourceFile): TransformResult => {
+const transform = (sourceFile: ts.SourceFile, program: ts.Program): TransformResult => {
     let bindings: Bindings = new Map(),
         changed = false,
+        checker = program.getTypeChecker(),
         code = sourceFile.getFullText(),
         current = sourceFile,
         result: string;
 
-    if (!contains(code)) {
+    if (!hasReactiveImport(sourceFile) || !hasReactiveUsage(code)) {
         return { changed: false, code, sourceFile };
     }
 
     for (let i = 0, n = transforms.length; i < n; i++) {
-        result = transforms[i](current, bindings, COMPILER_NAMESPACE);
+        result = transforms[i](current, bindings, COMPILER_NAMESPACE, checker);
 
         if (result !== code) {
             current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
@@ -81,6 +76,7 @@ const transform = (sourceFile: ts.SourceFile): TransformResult => {
     }
 
     if (changed) {
+        code = imports.modify(code, current, PACKAGE, { remove: [COMPILER_ENTRYPOINT] });
         code = `import * as ${COMPILER_NAMESPACE} from '@esportsplus/reactivity';\n` + code;
         sourceFile = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
     }

package/src/compiler/object.ts

@@ -1,6 +1,6 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c, type Replacement } from '@esportsplus/typescript/compiler';
-import { COMPILER_TYPES, PACKAGE } from '~/constants';
+import { code as c, imports, type Replacement } from '@esportsplus/typescript/compiler';
+import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '~/constants';
 import type { Bindings } from '~/types';
 
 
@@ -21,8 +21,8 @@ interface ReactiveObjectCall {
 interface TransformContext {
     bindings: Bindings;
     calls: ReactiveObjectCall[];
+    checker?: ts.TypeChecker;
     classCounter: number;
-    hasReactiveImport: boolean;
     lastImportEnd: number;
     ns: string;
     sourceFile: ts.SourceFile;
@@ -109,34 +109,26 @@ function buildClassCode(className: string, properties: AnalyzedProperty[], ns: s
     `;
 }
 
-function visit(ctx: TransformContext, node: ts.Node): void {
-    if (ts.isImportDeclaration(node)) {
-        ctx.lastImportEnd = node.end;
+function isReactiveCall(node: ts.CallExpression, checker?: ts.TypeChecker): boolean {
+    if (!ts.isIdentifier(node.expression)) {
+        return false;
+    }
 
-        if (
-            ts.isStringLiteral(node.moduleSpecifier) &&
-            node.moduleSpecifier.text.includes(PACKAGE)
-        ) {
-            let clause = node.importClause;
+    if (node.expression.text !== COMPILER_ENTRYPOINT) {
+        return false;
+    }
 
-            if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
-                let elements = clause.namedBindings.elements;
+    return imports.isFromPackage(node.expression, PACKAGE, checker);
+}
 
-                for (let i = 0, n = elements.length; i < n; i++) {
-                    if (elements[i].name.text === 'reactive') {
-                        ctx.hasReactiveImport = true;
-                        break;
-                    }
-                }
-            }
-        }
+function visit(ctx: TransformContext, node: ts.Node): void {
+    if (ts.isImportDeclaration(node)) {
+        ctx.lastImportEnd = node.end;
     }
 
     if (
-        ctx.hasReactiveImport &&
         ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === 'reactive'
+        isReactiveCall(node, ctx.checker)
     ) {
         let arg = node.arguments[0];
 
@@ -186,13 +178,13 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, ns: string): string => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, ns: string, checker?: ts.TypeChecker): string => {
     let code = sourceFile.getFullText(),
         ctx: TransformContext = {
             bindings,
             calls: [],
+            checker,
             classCounter: 0,
-            hasReactiveImport: false,
             lastImportEnd: 0,
             ns,
             sourceFile
@@ -224,4 +216,5 @@ export default (sourceFile: ts.SourceFile, bindings: Bindings, ns: string): stri
     }
 
     return c.replace(code, replacements);
-};
+};
+

package/src/compiler/primitives.ts

@@ -1,7 +1,7 @@
 import { ts } from '@esportsplus/typescript';
-import { ast, code as c, type Range, type Replacement } from '@esportsplus/typescript/compiler';
-import type { Bindings } from '~/types';
+import { ast, code as c, imports, type Range, type Replacement } from '@esportsplus/typescript/compiler';
 import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '~/constants';
+import type { Bindings } from '~/types';
 
 
 interface ArgContext {
@@ -20,8 +20,8 @@ interface ScopeBinding {
 
 interface TransformContext {
     bindings: Bindings;
+    checker?: ts.TypeChecker;
     computedArgRanges: Range[];
-    hasReactiveImport: boolean;
     ns: string;
     replacements: Replacement[];
     scopedBindings: ScopeBinding[];
@@ -104,18 +104,28 @@ function isInScope(reference: ts.Node, binding: ScopeBinding): boolean {
     return false;
 }
 
-function isReactiveReassignment(node: ts.Node): boolean {
+function isReactiveCall(node: ts.CallExpression, checker?: ts.TypeChecker): boolean {
+    if (!ts.isIdentifier(node.expression)) {
+        return false;
+    }
+
+    if (node.expression.text !== COMPILER_ENTRYPOINT) {
+        return false;
+    }
+
+    return imports.isFromPackage(node.expression, PACKAGE, checker);
+}
+
+function isReactiveReassignment(node: ts.Node, checker?: ts.TypeChecker): boolean {
     let parent = node.parent;
 
     if (
         ts.isBinaryExpression(parent) &&
         parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
         parent.right === node &&
-        ts.isCallExpression(node) &&
-        ts.isIdentifier((node as ts.CallExpression).expression) &&
-        ((node as ts.CallExpression).expression as ts.Identifier).text === COMPILER_ENTRYPOINT
+        ts.isCallExpression(node)
     ) {
-        return true;
+        return isReactiveCall(node as ts.CallExpression, checker);
     }
 
     return false;
@@ -149,28 +159,9 @@ function isWriteContext(node: ts.Identifier): 'simple' | 'compound' | 'increment
 
 function visit(ctx: TransformContext, node: ts.Node): void {
     if (
-        ts.isImportDeclaration(node) &&
-        ts.isStringLiteral(node.moduleSpecifier) &&
-        node.moduleSpecifier.text.includes(PACKAGE)
-    ) {
-        let clause = node.importClause;
-
-        if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
-            for (let i = 0, n = clause.namedBindings.elements.length; i < n; i++) {
-                if (clause.namedBindings.elements[i].name.text === COMPILER_ENTRYPOINT) {
-                    ctx.hasReactiveImport = true;
-                    break;
-                }
-            }
-        }
-    }
-
-    if (
-        ctx.hasReactiveImport &&
         ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === COMPILER_ENTRYPOINT &&
-        node.arguments.length > 0
+        node.arguments.length > 0 &&
+        isReactiveCall(node, ctx.checker)
     ) {
         let arg = node.arguments[0],
             classification: COMPILER_TYPES | null = COMPILER_TYPES.Signal;
@@ -237,6 +228,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
         }
     }
 
+
     if (ts.isIdentifier(node) && node.parent && !isInDeclarationInit(node.parent)) {
         if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
             ts.forEachChild(node, n => visit(ctx, n));
@@ -255,7 +247,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 
         if (binding && node.parent) {
             if (
-                !isReactiveReassignment(node.parent) &&
+                !isReactiveReassignment(node.parent, ctx.checker) &&
                 !(ts.isTypeOfExpression(node.parent) && node.parent.expression === node)
             ) {
                 let writeCtx = isWriteContext(node);
@@ -272,7 +264,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
                             });
                         }
                         else if (writeCtx === 'compound' && ts.isBinaryExpression(parent)) {
-                            let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind) ?? '+';
+                            let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind) ?? '+'
 
                             ctx.replacements.push({
                                 end: parent.end,
@@ -324,6 +316,7 @@ function visit(ctx: TransformContext, node: ts.Node): void {
     ts.forEachChild(node, n => visit(ctx, n));
 }
 
+
 function visitArg(ctx: ArgContext, node: ts.Node): void {
     if (ts.isIdentifier(node) && node.parent) {
         if (
@@ -347,12 +340,12 @@ function visitArg(ctx: ArgContext, node: ts.Node): void {
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, ns: string): string => {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, ns: string, checker?: ts.TypeChecker): string => {
     let code = sourceFile.getFullText(),
         ctx: TransformContext = {
             bindings,
+            checker,
             computedArgRanges: [],
-            hasReactiveImport: false,
             ns,
             replacements: [],
             scopedBindings: [],
@@ -367,4 +360,5 @@ export default (sourceFile: ts.SourceFile, bindings: Bindings, ns: string): stri
     }
 
     return c.replace(code, ctx.replacements);
-};
+};
+