@eventra_dev/eventra-cli 0.1.25 → 0.1.27

package/src/engine/callResolver.ts

@@ -29,18 +29,48 @@ function resolveFromSymbol(
     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;
+    }
+  }
+
   const decls = symbol.getDeclarations() ?? [];
 
   for (const decl of decls) {
+    // direct function
     if (isFunctionLike(decl)) {
       return decl;
     }
 
-    // MethodSignature
+    // VARIABLE → FUNCTION
+    if (ts.isVariableDeclaration(decl) && decl.initializer) {
+      if (isFunctionLike(decl.initializer)) {
+        return decl.initializer;
+      }
+
+      const innerSymbol = checker.getSymbolAtLocation(decl.initializer);
+      if (innerSymbol && innerSymbol !== symbol) {
+        const resolved = resolveFromSymbol(
+          innerSymbol,
+          checker,
+          visited,
+          depth + 1
+        );
+        if (resolved) return resolved;
+      }
+    }
+
+    // MethodSignature (interface / type)
     if (ts.isMethodSignature(decl)) {
       const parent = decl.parent;
 
-      if (ts.isInterfaceDeclaration(parent) || ts.isTypeLiteralNode(parent)) {
+      if (
+        ts.isInterfaceDeclaration(parent) ||
+        ts.isTypeLiteralNode(parent)
+      ) {
         const name = decl.name.getText();
 
         const type = checker.getTypeAtLocation(parent);
@@ -49,16 +79,26 @@ function resolveFromSymbol(
         for (const prop of props) {
           if (prop.name !== name) continue;
 
-          const resolved = resolveFromSymbol(prop, checker, visited, depth + 1);
+          const resolved = resolveFromSymbol(
+            prop,
+            checker,
+            visited,
+            depth + 1
+          );
           if (resolved) return resolved;
         }
       }
     }
 
-    // SAFE fallback
+    // fallback recursion
     const s = checker.getSymbolAtLocation(decl);
     if (s && s !== symbol) {
-      const resolved = resolveFromSymbol(s, checker, visited, depth + 1);
+      const resolved = resolveFromSymbol(
+        s,
+        checker,
+        visited,
+        depth + 1
+      );
       if (resolved) return resolved;
     }
   }
@@ -70,6 +110,32 @@ export function resolveFunctionFromCall(
   expr: ts.Expression,
   checker: ts.TypeChecker
 ): ts.FunctionLikeDeclaration | null {
+
+  // tracker.track
+  if (ts.isPropertyAccessExpression(expr)) {
+    let symbol = checker.getSymbolAtLocation(expr.name);
+
+    if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
+      symbol = checker.getAliasedSymbol(symbol);
+    }
+
+    if (symbol) {
+      const resolved = resolveFromSymbol(symbol, checker);
+      if (resolved) return resolved;
+    }
+  }
+
+  // tracker["track"]
+  if (ts.isElementAccessExpression(expr)) {
+    const symbol = checker.getSymbolAtLocation(expr.argumentExpression);
+
+    if (symbol) {
+      const resolved = resolveFromSymbol(symbol, checker);
+      if (resolved) return resolved;
+    }
+  }
+
+  // normal call signatures
   const type = checker.getTypeAtLocation(expr);
   const signatures = type.getCallSignatures();
 
@@ -81,7 +147,6 @@ export function resolveFunctionFromCall(
       return decl;
     }
 
-    // interface method
     if (ts.isMethodSignature(decl)) {
       const symbol = checker.getSymbolAtLocation(decl.name);
 
@@ -92,5 +157,11 @@ export function resolveFunctionFromCall(
     }
   }
 
+  // fallback
+  const symbol = checker.getSymbolAtLocation(expr);
+  if (symbol) {
+    return resolveFromSymbol(symbol, checker);
+  }
+
   return null;
 }

package/src/engine/engine.ts

@@ -1,3 +1,6 @@
+import path from "path";
+import fs from "fs";
+
 import { TSService } from "./languageService";
 import { ScanResult, scanSource } from "./scanner";
 import { DependencyGraph } from "./graph";
@@ -18,8 +21,29 @@ export class EventraEngine {
     const { baseUrl, paths } = this.ts.getModuleResolutionConfig();
     this.graph = new DependencyGraph(baseUrl, paths);
   }
+
+  private normalize(file: string) {
+    return path.resolve(file).replace(/\\/g, "/");
+  }
+
+  private empty(): ScanResult {
+    return {
+      events: new Set(),
+      detectedFunctionWrappers: new Set(),
+      detectedComponentWrappers: new Map(),
+    };
+  }
+
+  // PRELOAD
   preloadFile(file: string, content: string) {
+    file = this.normalize(file);
+
     this.ts.updateFile(file, content);
+
+    const source = this.ts.getSourceFile(file);
+    if (source) {
+      this.graph.update(file, source);
+    }
   }
 
   // SCAN FILE
@@ -28,33 +52,26 @@ export class EventraEngine {
     content: string,
     config: EventraConfig
   ): ScanResult {
+    file = this.normalize(file);
+
     const h = hash(content);
 
-    // skip unchanged
     if (this.fileHash.get(file) === h) {
-      return (
-        this.fileResults.get(file) ?? {
-          events: new Set(),
-          detectedFunctionWrappers: new Set(),
-          detectedComponentWrappers: new Map(),
-        }
-      );
+      return this.fileResults.get(file) ?? this.empty();
     }
 
     this.fileHash.set(file, h);
+
     this.ts.updateFile(file, content);
 
     const source = this.ts.getSourceFile(file);
     const checker = this.ts.getChecker();
 
     if (!source || !checker) {
-      return {
-        events: new Set(),
-        detectedFunctionWrappers: new Set(),
-        detectedComponentWrappers: new Map(),
-      };
+      return this.empty();
     }
 
+    // обновляем graph
     this.graph.update(file, source);
 
     const res = scanSource(source, checker, config);
@@ -69,32 +86,46 @@ export class EventraEngine {
     content: string,
     config: EventraConfig
   ) {
+    file = this.normalize(file);
+
     const res = this.scanFile(file, content, config);
 
     const dependents = this.graph.getAllDependentsDeep(file);
 
     for (const dep of dependents) {
-      if (isExternalFile(dep)) continue;
+      const abs = this.normalize(dep);
 
-      const depContent = this.ts.getFileContent(dep);
-      if (!depContent) continue;
+      if (isExternalFile(abs)) continue;
+
+      let depContent = this.ts.getFileContent(abs);
+
+      if (!depContent) {
+        try {
+          depContent = fs.readFileSync(abs, "utf-8");
+        } catch {
+          continue;
+        }
+      }
 
       const h = hash(depContent);
 
-      if (this.fileHash.get(dep) === h) continue;
+      if (this.fileHash.get(abs) === h) {
+        continue;
+      }
+
+      this.fileHash.set(abs, h);
 
-      this.fileHash.set(dep, h);
-      this.ts.updateFile(dep, depContent);
+      this.ts.updateFile(abs, depContent);
 
-      const source = this.ts.getSourceFile(dep);
+      const source = this.ts.getSourceFile(abs);
       const checker = this.ts.getChecker();
 
       if (!source || !checker) continue;
 
-      this.graph.update(dep, source);
+      this.graph.update(abs, source);
 
       const r = scanSource(source, checker, config);
-      this.fileResults.set(dep, r);
+      this.fileResults.set(abs, r);
     }
 
     return res;
@@ -113,31 +144,45 @@ export class EventraEngine {
 
   // REMOVE FILE
   removeFile(file: string, config?: EventraConfig) {
+    file = this.normalize(file);
+
+    const dependents = this.graph.getAllDependentsDeep(file);
+
     this.ts.removeFile(file);
     this.fileResults.delete(file);
     this.fileHash.delete(file);
     this.graph.remove(file);
 
-    const dependents = this.graph.getAllDependentsDeep(file);
-
     for (const dep of dependents) {
-      if (isExternalFile(dep)) continue;
+      const abs = this.normalize(dep);
 
-      const content = this.ts.getFileContent(dep);
-      if (!content) continue;
+      if (isExternalFile(abs)) continue;
+
+      let content = this.ts.getFileContent(abs);
+
+      if (!content) {
+        try {
+          content = fs.readFileSync(abs, "utf-8");
+        } catch {
+          continue;
+        }
+      }
 
       const h = hash(content);
 
-      if (this.fileHash.get(dep) === h) continue;
+      if (this.fileHash.get(abs) === h) continue;
+
+      this.fileHash.set(abs, h);
 
-      this.fileHash.set(dep, h);
-      this.ts.updateFile(dep, content);
+      this.ts.updateFile(abs, content);
 
-      const source = this.ts.getSourceFile(dep);
+      const source = this.ts.getSourceFile(abs);
       const checker = this.ts.getChecker();
 
       if (!source || !checker) continue;
 
+      this.graph.update(abs, source);
+
       const r = scanSource(
         source,
         checker,
@@ -149,7 +194,7 @@ export class EventraEngine {
         }
       );
 
-      this.fileResults.set(dep, r);
+      this.fileResults.set(abs, r);
     }
   }
 }

package/src/engine/exportResolver.ts

@@ -1,5 +1,13 @@
 import ts from "typescript";
 
+function isRealDeclaration(node: ts.Node) {
+  return (
+    ts.isFunctionDeclaration(node) ||
+    ts.isVariableDeclaration(node) ||
+    ts.isClassDeclaration(node)
+  );
+}
+
 export function resolveExportedSymbol(
   symbol: ts.Symbol,
   checker: ts.TypeChecker,
@@ -8,20 +16,29 @@ export function resolveExportedSymbol(
 
   if (visited.has(symbol)) return null;
   visited.add(symbol);
+
+  // unwrap alias
   if (symbol.flags & ts.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     return resolveExportedSymbol(aliased, checker, visited);
   }
 
-  if (symbol.getDeclarations()?.length) {
-    return symbol;
+  // export symbol
+  const exportSymbol = checker.getExportSymbolOfSymbol(symbol);
+  if (exportSymbol && exportSymbol !== symbol) {
+    return resolveExportedSymbol(exportSymbol, checker, visited);
   }
 
-  const declarations = symbol.getDeclarations() ?? [];
+  const decls = symbol.getDeclarations() ?? [];
+
+  if (decls.some(isRealDeclaration)) {
+    return symbol;
+  }
 
-  for (const decl of declarations) {
+  // exports (re-export)
+  for (const decl of decls) {
     const source = decl.getSourceFile();
-    const moduleSymbol = checker.getSymbolAtLocation(source);
+    const moduleSymbol = (source as any).symbol;
 
     if (!moduleSymbol) continue;
 

package/src/engine/functionAnalyzer.ts

@@ -8,24 +8,95 @@ export function findTrackParamIndex(
   fn.parameters.forEach((p, i) => {
     if (ts.isIdentifier(p.name)) {
       paramIndex.set(p.name.text, i);
+
+      // default param: (name = "x")
+      if (p.initializer && ts.isStringLiteral(p.initializer)) {
+        if (i === 0) return 0;
+      }
     }
   });
 
   let result: number | null = null;
 
+  function unwrap(node: ts.Expression): ts.Expression {
+    // as / parentheses
+    while (
+      ts.isAsExpression(node) ||
+      ts.isParenthesizedExpression(node)
+      ) {
+      node = node.expression;
+    }
+    return node;
+  }
+
+  function checkArg(arg: ts.Expression) {
+    arg = unwrap(arg);
+
+    // identifier → param
+    if (ts.isIdentifier(arg)) {
+      const idx = paramIndex.get(arg.text);
+      if (idx !== undefined) {
+        result = idx;
+        return true;
+      }
+    }
+
+    // string literal
+    if (ts.isStringLiteral(arg)) {
+      result = 0;
+      return true;
+    }
+
+    // template `${name}`
+    if (ts.isTemplateExpression(arg)) {
+      for (const span of arg.templateSpans) {
+        if (ts.isIdentifier(span.expression)) {
+          const idx = paramIndex.get(span.expression.text);
+          if (idx !== undefined) {
+            result = idx;
+            return true;
+          }
+        }
+      }
+      result = 0;
+      return true;
+    }
+
+    // object { event: name }
+    if (ts.isObjectLiteralExpression(arg)) {
+      for (const prop of arg.properties) {
+        if (!ts.isPropertyAssignment(prop)) continue;
+
+        const name = prop.name.getText();
+
+        if (["event", "name", "type"].includes(name)) {
+          return checkArg(prop.initializer);
+        }
+      }
+    }
+
+    // call: String(name)
+    if (ts.isCallExpression(arg)) {
+      for (const inner of arg.arguments) {
+        if (checkArg(inner)) return true;
+      }
+    }
+
+    return false;
+  }
+
   function visit(node: ts.Node) {
+    if (result !== null) return;
+
     if (ts.isCallExpression(node)) {
       let isTrackCall = false;
 
       if (ts.isPropertyAccessExpression(node.expression)) {
-        const method = node.expression.name.text;
-
-        if (method === "track") {
+        if (node.expression.name.text === "track") {
           isTrackCall = true;
         }
       }
 
-      // fallback
       if (ts.isIdentifier(node.expression)) {
         if (node.expression.text === "track") {
           isTrackCall = true;
@@ -34,18 +105,7 @@ export function findTrackParamIndex(
 
       if (isTrackCall) {
         for (const arg of node.arguments) {
-          if (ts.isIdentifier(arg)) {
-            const idx = paramIndex.get(arg.text);
-            if (idx !== undefined) {
-              result = idx;
-              return;
-            }
-          }
-
-          if (ts.isStringLiteral(arg)) {
-            result = 0;
-            return;
-          }
+          if (checkArg(arg)) return;
         }
       }
     }

package/src/engine/graph.ts

@@ -13,15 +13,18 @@ export class DependencyGraph {
   ) {}
 
   private normalize(file: string) {
-    return path.resolve(file);
+    return path.resolve(file).replace(/\\/g, "/");
   }
 
+  // MODULE RESOLVE
   private resolveModule(module: string, from: string): string | null {
+    // relative import
     if (module.startsWith(".")) {
       const abs = path.resolve(path.dirname(from), module);
       return this.resolveFile(abs);
     }
 
+    // tsconfig paths
     for (const key in this.paths) {
       const pattern = key.replace(/\*/g, "(.*)");
       const regex = new RegExp("^" + pattern + "$");
@@ -44,10 +47,21 @@ export class DependencyGraph {
       }
     }
 
+    // node resolution (safe)
+    try {
+      const resolved = require.resolve(module, {
+        paths: [path.dirname(from)],
+      });
+
+      return this.normalize(resolved);
+    } catch {}
+
+    // fallback
     const abs = path.resolve(this.baseUrl, module);
     return this.resolveFile(abs);
   }
 
+  // FILE RESOLVE
   private resolveFile(base: string): string | null {
     if (this.fileCache.has(base)) {
       return this.fileCache.get(base)!;
@@ -59,6 +73,12 @@ export class DependencyGraph {
       base + ".tsx",
       base + ".js",
       base + ".jsx",
+      base + ".mjs",
+      base + ".cjs",
+      base + ".d.ts",
+      base + ".vue",
+      base + ".svelte",
+      base + ".astro",
       path.join(base, "index.ts"),
       path.join(base, "index.tsx"),
       path.join(base, "index.js"),
@@ -76,16 +96,28 @@ export class DependencyGraph {
     return null;
   }
 
+  // UPDATE GRAPH
   update(file: string, source: ts.SourceFile) {
     const normalizedFile = this.normalize(file);
 
+    for (const deps of this.reverse.values()) {
+      deps.delete(normalizedFile);
+    }
+
     this.exports.set(normalizedFile, new Set());
 
     for (const stmt of source.statements) {
+
+      // IMPORT
       if (ts.isImportDeclaration(stmt)) {
-        const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
-        const resolved = this.resolveModule(module, normalizedFile);
+        // ignore import type
+        if ((stmt.importClause as any)?.importKind === "type") continue;
+
+        const module = stmt.moduleSpecifier
+          .getText()
+          .replace(/['"]/g, "");
 
+        const resolved = this.resolveModule(module, normalizedFile);
         if (!resolved) continue;
 
         if (!this.reverse.has(resolved)) {
@@ -95,10 +127,15 @@ export class DependencyGraph {
         this.reverse.get(resolved)!.add(normalizedFile);
       }
 
-      if (ts.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
-        const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
-        const resolved = this.resolveModule(module, normalizedFile);
+      // EXPORT (re-export)
+      if (ts.isExportDeclaration(stmt)) {
+        if (!stmt.moduleSpecifier) continue;
+
+        const module = stmt.moduleSpecifier
+          .getText()
+          .replace(/['"]/g, "");
 
+        const resolved = this.resolveModule(module, normalizedFile);
         if (!resolved) continue;
 
         this.exports.get(normalizedFile)?.add(resolved);
@@ -112,6 +149,7 @@ export class DependencyGraph {
     }
   }
 
+  // DEPENDENTS
   getAllDependentsDeep(file: string): string[] {
     const start = this.normalize(file);
     const visited = new Set<string>();
@@ -136,6 +174,7 @@ export class DependencyGraph {
     return [...result];
   }
 
+  // REMOVE
   remove(file: string) {
     const normalized = this.normalize(file);