@eventra_dev/eventra-cli 0.1.31 → 0.1.32

package/src/engine/callResolver.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 
+// HELPERS
 function isFunctionLike(
   node: ts.Node
 ): node is ts.FunctionLikeDeclaration {
@@ -12,40 +13,39 @@ function isFunctionLike(
   );
 }
 
+// symbol → function
 function resolveFromSymbol(
   symbol: ts.Symbol,
   checker: ts.TypeChecker,
   visited = new Set<ts.Symbol>(),
   depth = 0
 ): ts.FunctionLikeDeclaration | null {
+  if (!symbol) return null;
   if (visited.has(symbol)) return null;
-  if (depth > 5) return null;
+  if (depth > 10) return null;
 
   visited.add(symbol);
 
-  // unwrap alias
+  // Alias unwrap (import/export)
   if (symbol.flags & ts.SymbolFlags.Alias) {
-    const aliased = checker.getAliasedSymbol(symbol);
-    return resolveFromSymbol(aliased, checker, visited, depth + 1);
-  }
-
-  // re-export support
-  if ((symbol as any).exports) {
-    for (const exp of (symbol as any).exports.values()) {
-      const resolved = resolveFromSymbol(exp, checker, visited, depth + 1);
-      if (resolved) return resolved;
-    }
+    try {
+      const aliased = checker.getAliasedSymbol(symbol);
+      return resolveFromSymbol(aliased, checker, visited, depth + 1);
+    } catch {}
   }
 
+  // Declarations
   const decls = symbol.getDeclarations() ?? [];
 
   for (const decl of decls) {
-    // direct function
+    /**
+     * direct function
+     */
     if (isFunctionLike(decl)) {
       return decl;
     }
 
-    // VARIABLE → FUNCTION
+    // VARIABLE → FUNCTION const fn = () => {}
     if (ts.isVariableDeclaration(decl) && decl.initializer) {
       if (isFunctionLike(decl.initializer)) {
         return decl.initializer;
@@ -63,7 +63,12 @@ function resolveFromSymbol(
       }
     }
 
-    // MethodSignature (interface / type)
+    // CLASS METHOD
+    if (ts.isMethodDeclaration(decl)) {
+      return decl;
+    }
+
+    // interface / type method
     if (ts.isMethodSignature(decl)) {
       const parent = decl.parent;
 
@@ -71,14 +76,10 @@ function resolveFromSymbol(
         ts.isInterfaceDeclaration(parent) ||
         ts.isTypeLiteralNode(parent)
       ) {
-        const name = decl.name.getText();
-
         const type = checker.getTypeAtLocation(parent);
         const props = type.getProperties();
 
         for (const prop of props) {
-          if (prop.name !== name) continue;
-
           const resolved = resolveFromSymbol(
             prop,
             checker,
@@ -91,10 +92,24 @@ function resolveFromSymbol(
     }
 
     // fallback recursion
-    const s = checker.getSymbolAtLocation(decl);
-    if (s && s !== symbol) {
+    const inner = checker.getSymbolAtLocation(decl);
+    if (inner && inner !== symbol) {
       const resolved = resolveFromSymbol(
-        s,
+        inner,
+        checker,
+        visited,
+        depth + 1
+      );
+      if (resolved) return resolved;
+    }
+  }
+
+  // Exports (re-export)
+  const exports = (symbol as any).exports;
+  if (exports) {
+    for (const exp of exports.values()) {
+      const resolved = resolveFromSymbol(
+        exp,
         checker,
         visited,
         depth + 1
@@ -106,17 +121,19 @@ function resolveFromSymbol(
   return null;
 }
 
+// MAIN FUNCTION
 export function resolveFunctionFromCall(
   expr: ts.Expression,
   checker: ts.TypeChecker
 ): ts.FunctionLikeDeclaration | null {
-
-  // tracker.track
+  // obj.method()
   if (ts.isPropertyAccessExpression(expr)) {
     let symbol = checker.getSymbolAtLocation(expr.name);
 
     if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
-      symbol = checker.getAliasedSymbol(symbol);
+      try {
+        symbol = checker.getAliasedSymbol(symbol);
+      } catch {}
     }
 
     if (symbol) {
@@ -125,7 +142,7 @@ export function resolveFunctionFromCall(
     }
   }
 
-  // tracker["track"]
+  // obj["method"]()
   if (ts.isElementAccessExpression(expr)) {
     const symbol = checker.getSymbolAtLocation(expr.argumentExpression);
 
@@ -135,7 +152,7 @@ export function resolveFunctionFromCall(
     }
   }
 
-  // normal call signatures
+  // Call signatures
   const type = checker.getTypeAtLocation(expr);
   const signatures = type.getCallSignatures();
 
@@ -157,7 +174,23 @@ export function resolveFunctionFromCall(
     }
   }
 
-  // fallback
+  // Identifier fallback
+  if (ts.isIdentifier(expr)) {
+    let symbol = checker.getSymbolAtLocation(expr);
+
+    if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
+      try {
+        symbol = checker.getAliasedSymbol(symbol);
+      } catch {}
+    }
+
+    if (symbol) {
+      const resolved = resolveFromSymbol(symbol, checker);
+      if (resolved) return resolved;
+    }
+  }
+
+  // LAST fallback
   const symbol = checker.getSymbolAtLocation(expr);
   if (symbol) {
     return resolveFromSymbol(symbol, checker);

package/src/engine/languageService.ts

@@ -7,9 +7,10 @@ export class TSService {
   private fileNames = new Set<string>();
   private service: ts.LanguageService;
 
-  private compilerOptions: ts.CompilerOptions;
-  private baseUrl: string;
-  private paths: Record<string, string[]>;
+  private readonly compilerOptions: ts.CompilerOptions;
+  private readonly baseUrl: string;
+  private readonly paths: Record<string, string[]>;
+
   private usage = new Map<string, number>();
   private tick = 0;
   private MAX_FILES = 2000;
@@ -23,6 +24,7 @@ export class TSService {
 
     let compilerOptions: ts.CompilerOptions = {
       allowJs: true,
+      allowNonTsExtensions: true,
       jsx: ts.JsxEmit.React,
       jsxImportSource: "react",
       moduleResolution: ts.ModuleResolutionKind.Node16,
@@ -60,7 +62,17 @@ export class TSService {
     this.paths = paths;
 
     const host: ts.LanguageServiceHost = {
-      getScriptFileNames: () => Array.from(this.fileNames),
+      getScriptFileNames: () => {
+        if (this.fileNames.size === 0) {
+          return ts.sys.readDirectory(
+            this.root,
+            [".ts", ".tsx", ".js", ".jsx"],
+            undefined,
+            undefined
+          );
+        }
+        return Array.from(this.fileNames);
+      },
 
       getScriptVersion: (file) => {
         file = this.normalize(file);
@@ -69,13 +81,29 @@ export class TSService {
 
       getScriptSnapshot: (file) => {
         file = this.normalize(file);
-
         const f = this.files.get(file);
         if (f) {
           this.touch(file);
           return ts.ScriptSnapshot.fromString(f.content);
         }
+        if (file.endsWith(".tsx")) {
+          const original = file.replace(/\.tsx$/, "");
+
+          if (fs.existsSync(original)) {
+            const content = fs.readFileSync(original, "utf-8");
+
+            this.files.set(file, {
+              content,
+              version: 1,
+            });
+
+            this.fileNames.add(file);
+            this.touch(file);
+            this.evictIfNeeded();
 
+            return ts.ScriptSnapshot.fromString(content);
+          }
+        }
         try {
           if (fs.existsSync(file)) {
             const content = fs.readFileSync(file, "utf-8");
@@ -93,16 +121,22 @@ export class TSService {
           }
         } catch {}
 
-        // fallback
         return ts.ScriptSnapshot.fromString("");
       },
-
       getCurrentDirectory: () => this.root,
       getCompilationSettings: () => this.compilerOptions,
       getDefaultLibFileName: (opts) =>
         ts.getDefaultLibFilePath(opts),
-      fileExists: ts.sys.fileExists,
-      readFile: ts.sys.readFile,
+      fileExists: (file) => {
+        file = this.normalize(file);
+        return this.files.has(file) || ts.sys.fileExists(file);
+      },
+
+      readFile: (file) => {
+        file = this.normalize(file);
+        return this.files.get(file)?.content ?? ts.sys.readFile(file);
+      },
+
       readDirectory: ts.sys.readDirectory,
     };
 
@@ -122,7 +156,7 @@ export class TSService {
   private evictIfNeeded() {
     if (this.fileNames.size <= this.MAX_FILES) return;
 
-    let oldestFile: string | null = null;
+    let oldest: string | null = null;
     let oldestTick = Infinity;
 
     for (const f of this.fileNames) {
@@ -130,20 +164,20 @@ export class TSService {
 
       if (t < oldestTick) {
         oldestTick = t;
-        oldestFile = f;
+        oldest = f;
       }
     }
 
-    if (oldestFile) {
-      this.files.delete(oldestFile);
-      this.fileNames.delete(oldestFile);
-      this.usage.delete(oldestFile);
+    if (oldest) {
+      this.files.delete(oldest);
+      this.fileNames.delete(oldest);
+      this.usage.delete(oldest);
     }
   }
 
   private ensureProgram() {
     try {
-      this.service.getProgram();
+      this.service.getProgram()?.getTypeChecker();
     } catch {}
   }
 

package/src/engine/scanner.ts

@@ -173,15 +173,13 @@ export function scanSource(
   config: EventraConfig,
   visited = new Set<string>(),
   inheritedParamMap?: Map<string, ts.Expression>,
-  wrapperCache?: Map<string, string | null>
+  wrapperCache = new Map<string, string | null>()
 ): ScanResult {
-  wrapperCache = wrapperCache ?? new Map();
-
   const events = new Set<string>();
   const detectedFunctionWrappers = new Set<string>();
   const detectedComponentWrappers = new Map<string, string>();
 
-  if (visited.size > 200 || visited.has(source.fileName)) {
+  if (visited.has(source.fileName) || visited.size > 200) {
     return { events, detectedFunctionWrappers, detectedComponentWrappers };
   }
 
@@ -189,76 +187,58 @@ export function scanSource(
 
   function visit(node: ts.Node) {
     // JSX WRAPPERS
-    if (
-      ts.isJsxSelfClosingElement(node) ||
-      ts.isJsxOpeningElement(node)
-    ) {
+    if (ts.isJsxSelfClosingElement(node) || ts.isJsxOpeningElement(node)) {
       const tagName = getJsxTagName(node.tagName);
 
       // skip html
-      if (!tagName || tagName[0] === tagName[0].toLowerCase()) {
+      if (tagName[0] === tagName[0].toLowerCase()) {
         ts.forEachChild(node, visit);
         return;
       }
 
-      let wrapper = config.wrappers.find(
-        (w) => w.name === tagName
-      );
+      let wrapper = config.wrappers.find(w => w.name === tagName);
 
+      // AUTO DETECT
       if (!wrapper) {
-        let symbol = checker.getSymbolAtLocation(node.tagName);
-
-        let cacheKey = tagName;
+        if (wrapperCache.has(tagName)) {
+          const cached = wrapperCache.get(tagName);
+          if (cached) wrapper = { name: tagName, prop: cached };
+        } else {
+          let symbol = checker.getSymbolAtLocation(node.tagName);
 
-        if (symbol) {
-          if (symbol.flags & ts.SymbolFlags.Alias) {
+          if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
             symbol = checker.getAliasedSymbol(symbol);
           }
 
-          symbol =
-            resolveExportedSymbol(symbol, checker) ?? symbol;
-
-          cacheKey = checker.getFullyQualifiedName(symbol);
-        }
-
-        if (wrapperCache?.has(cacheKey)) {
-          const cached = wrapperCache.get(cacheKey);
-          if (cached) {
-            wrapper = { name: tagName, prop: cached };
-          }
-        } else if (symbol) {
-          let detected: string | null = null;
+          if (symbol) {
+            symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
 
-          for (const decl of symbol.getDeclarations() ?? []) {
-            let fn: ts.FunctionLikeDeclaration | null = null;
+            for (const decl of symbol.getDeclarations() ?? []) {
+              let fn: ts.FunctionLikeDeclaration | null = null;
 
-            if (ts.isFunctionDeclaration(decl)) fn = decl;
+              if (ts.isFunctionDeclaration(decl)) fn = decl;
 
-            if (
-              ts.isVariableDeclaration(decl) &&
-              decl.initializer &&
-              (ts.isArrowFunction(decl.initializer) ||
-                ts.isFunctionExpression(decl.initializer))
-            ) {
-              fn = decl.initializer;
-            }
+              if (
+                ts.isVariableDeclaration(decl) &&
+                decl.initializer &&
+                (ts.isArrowFunction(decl.initializer) ||
+                  ts.isFunctionExpression(decl.initializer))
+              ) {
+                fn = decl.initializer;
+              }
 
-            if (!fn) continue;
+              if (!fn) continue;
 
-            const prop = findTrackedPropName(fn, checker);
+              const prop = findTrackedPropName(fn, checker);
+              wrapperCache.set(tagName, prop ?? null);
 
-            if (prop) {
-              detected = prop;
-              break;
+              if (prop) {
+                wrapper = { name: tagName, prop };
+                detectedComponentWrappers.set(tagName, prop);
+                break;
+              }
             }
           }
-
-          wrapperCache?.set(cacheKey, detected);
-
-          if (detected) {
-            wrapper = { name: tagName, prop: detected };
-            detectedComponentWrappers.set(tagName, detected);
-          }
         }
       }
 
@@ -268,25 +248,21 @@ export function scanSource(
 
           const name = getJsxAttrName(attr.name);
           if (name !== wrapper.prop) continue;
+
           if (!attr.initializer) continue;
 
           if (ts.isStringLiteral(attr.initializer)) {
-            if (isValidEvent(attr.initializer.text)) {
-              events.add(attr.initializer.text);
-            }
+            const v = attr.initializer.text;
+            if (isValidEvent(v)) events.add(v);
           }
 
           if (ts.isJsxExpression(attr.initializer)) {
             const expr = attr.initializer.expression;
             if (!expr) continue;
 
-            const res = resolveNodeValue(
-              expr,
-              checker,
-              inheritedParamMap
-            );
+            const res = resolveNodeValue(expr, checker, inheritedParamMap);
 
-            res.values.forEach((v) => {
+            res.values.forEach(v => {
               if (isValidEvent(v)) events.add(v);
             });
           }
@@ -297,40 +273,56 @@ export function scanSource(
       return;
     }
 
-    // FUNCTION TRACKING
+    // FUNCTION CALLS
     if (ts.isCallExpression(node)) {
-      const name = getCallName(node.expression);
+      let trackParamIndex: number | null = null;
+      let isTracking = false;
+
+      const callName = getCallName(node.expression);
+
+      // direct .track()
+      if (
+        ts.isPropertyAccessExpression(node.expression) &&
+        node.expression.name.text === "track"
+      ) {
+        isTracking = true;
+        trackParamIndex = 0;
+      }
 
-      const isKnownWrapper = config.functionWrappers.some(
-        (w) => w.name === name
+      // config wrapper
+      const manualWrapper = config.functionWrappers.find(
+        w => w.name === callName
       );
 
+      if (manualWrapper) {
+        isTracking = true;
+        trackParamIndex = 0;
+      }
+
+      // resolve function → check body
       const resolvedFn = resolveFunctionFromCall(
         node.expression,
         checker
       );
 
-      const isAutoWrapper =
-        !!resolvedFn && findTrackParamIndex(resolvedFn) !== null;
+      if (resolvedFn) {
+        const idx = findTrackParamIndex(resolvedFn);
 
-      const isTracking =
-        name === "track" ||
-        isKnownWrapper ||
-        (isAutoWrapper &&
-          resolvedFn &&
-          !isExternalFile(
-            resolvedFn.getSourceFile().fileName
-          ));
+        if (idx !== null) {
+          isTracking = true;
+          trackParamIndex = idx;
+
+          if (!manualWrapper && callName !== "track") {
+            detectedFunctionWrappers.add(callName);
+          }
+        }
+      }
 
       if (!isTracking) {
         ts.forEachChild(node, visit);
         return;
       }
 
-      if (!isKnownWrapper && isAutoWrapper && name !== "track") {
-        detectedFunctionWrappers.add(name);
-      }
-
       const paramMap = new Map(inheritedParamMap ?? []);
 
       if (resolvedFn && ts.isFunctionLike(resolvedFn)) {
@@ -344,22 +336,19 @@ export function scanSource(
         });
       }
 
-      if (resolvedFn) {
-        const idx = findTrackParamIndex(resolvedFn);
+      if (trackParamIndex !== null && node.arguments[trackParamIndex]) {
+        const res = resolveNodeValue(
+          node.arguments[trackParamIndex],
+          checker,
+          paramMap
+        );
 
-        if (idx !== null && node.arguments[idx]) {
-          const res = resolveNodeValue(
-            node.arguments[idx],
-            checker,
-            paramMap
-          );
-
-          res.values.forEach((v) => {
-            if (isValidEvent(v)) events.add(v);
-          });
-        }
+        res.values.forEach(v => {
+          if (isValidEvent(v)) events.add(v);
+        });
       }
 
+      // CROSS FILE
       if (resolvedFn) {
         const sf = resolvedFn.getSourceFile();
 
@@ -373,7 +362,7 @@ export function scanSource(
             wrapperCache
           );
 
-          res.events.forEach((e) => events.add(e));
+          res.events.forEach(e => events.add(e));
         }
       }
     }