@eventra_dev/eventra-cli 0.1.24 → 0.1.26

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";
@@ -19,39 +22,56 @@ export class EventraEngine {
     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
   scanFile(
     file: string,
     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);
@@ -66,33 +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);
+
+      if (isExternalFile(abs)) continue;
 
-      const depContent = this.ts.getFileContent(dep);
-      if (!depContent) 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(dep, h);
-      this.ts.updateFile(dep, depContent);
+      this.fileHash.set(abs, h);
 
-      const source = this.ts.getSourceFile(dep);
+      this.ts.updateFile(abs, depContent);
+
+      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;
@@ -111,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,
@@ -147,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);
 

package/src/engine/languageService.ts

@@ -7,9 +7,12 @@ export class TSService {
   private fileNames = new Set<string>();
   private service: ts.LanguageService;
 
-  private readonly compilerOptions: ts.CompilerOptions = {};
-  private readonly baseUrl: string = "";
-  private readonly paths: Record<string, string[]> = {};
+  private compilerOptions: ts.CompilerOptions;
+  private baseUrl: string;
+  private paths: Record<string, string[]>;
+  private usage = new Map<string, number>();
+  private tick = 0;
+  private MAX_FILES = 2000;
 
   constructor(private root: string) {
     const configPath = ts.findConfigFile(
@@ -20,13 +23,18 @@ export class TSService {
 
     let compilerOptions: ts.CompilerOptions = {
       allowJs: true,
-      jsx: ts.JsxEmit.Preserve,
+      jsx: ts.JsxEmit.React,
+      jsxImportSource: "react",
       moduleResolution: ts.ModuleResolutionKind.Node16,
       target: ts.ScriptTarget.ESNext,
       esModuleInterop: true,
       allowSyntheticDefaultImports: true,
+      skipLibCheck: true,
     };
 
+    let baseUrl = root;
+    let paths: Record<string, string[]> = {};
+
     if (configPath) {
       const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
 
@@ -41,56 +49,108 @@ export class TSService {
         ...parsed.options,
       };
 
-      this.paths = parsed.options.paths || {};
-      this.baseUrl = parsed.options.baseUrl
+      paths = parsed.options.paths || {};
+      baseUrl = parsed.options.baseUrl
         ? path.resolve(root, parsed.options.baseUrl)
         : root;
-    } else {
-      this.baseUrl = root;
     }
 
     this.compilerOptions = compilerOptions;
+    this.baseUrl = baseUrl;
+    this.paths = paths;
 
     const host: ts.LanguageServiceHost = {
-      getScriptFileNames: () => {
-        return [...new Set(this.fileNames)].sort((a, b) =>
-          a.localeCompare(b)
-        );
-      },
+      getScriptFileNames: () => Array.from(this.fileNames),
 
-      getScriptVersion: (file) =>
-        this.files.get(file)?.version.toString() ?? "0",
+      getScriptVersion: (file) => {
+        file = this.normalize(file);
+        return this.files.get(file)?.version.toString() ?? "0";
+      },
 
       getScriptSnapshot: (file) => {
-        const f = this.files.get(file);
+        file = this.normalize(file);
 
+        const f = this.files.get(file);
         if (f) {
+          this.touch(file);
           return ts.ScriptSnapshot.fromString(f.content);
         }
 
-        if (fs.existsSync(file)) {
-          return ts.ScriptSnapshot.fromString(
-            fs.readFileSync(file, "utf-8")
-          );
-        }
+        try {
+          if (fs.existsSync(file)) {
+            const content = fs.readFileSync(file, "utf-8");
+
+            this.files.set(file, {
+              content,
+              version: 1,
+            });
+
+            this.fileNames.add(file);
+            this.touch(file);
+            this.evictIfNeeded();
 
-        return undefined;
+            return ts.ScriptSnapshot.fromString(content);
+          }
+        } catch {}
+
+        // fallback
+        return ts.ScriptSnapshot.fromString("");
       },
 
       getCurrentDirectory: () => this.root,
       getCompilationSettings: () => this.compilerOptions,
       getDefaultLibFileName: (opts) =>
         ts.getDefaultLibFilePath(opts),
-
-      readFile: ts.sys.readFile,
       fileExists: ts.sys.fileExists,
+      readFile: ts.sys.readFile,
       readDirectory: ts.sys.readDirectory,
     };
 
     this.service = ts.createLanguageService(host);
   }
 
+  // INTERNAL
+  private normalize(file: string) {
+    return path.resolve(file).replace(/\\/g, "/");
+  }
+
+  private touch(file: string) {
+    this.tick++;
+    this.usage.set(file, this.tick);
+  }
+
+  private evictIfNeeded() {
+    if (this.fileNames.size <= this.MAX_FILES) return;
+
+    let oldestFile: string | null = null;
+    let oldestTick = Infinity;
+
+    for (const f of this.fileNames) {
+      const t = this.usage.get(f) ?? 0;
+
+      if (t < oldestTick) {
+        oldestTick = t;
+        oldestFile = f;
+      }
+    }
+
+    if (oldestFile) {
+      this.files.delete(oldestFile);
+      this.fileNames.delete(oldestFile);
+      this.usage.delete(oldestFile);
+    }
+  }
+
+  private ensureProgram() {
+    try {
+      this.service.getProgram();
+    } catch {}
+  }
+
+  // PUBLIC API
   updateFile(file: string, content: string) {
+    file = this.normalize(file);
+
     const prev = this.files.get(file);
 
     this.files.set(file, {
@@ -99,6 +159,20 @@ export class TSService {
     });
 
     this.fileNames.add(file);
+    this.touch(file);
+    this.evictIfNeeded();
+
+    this.ensureProgram();
+  }
+
+  removeFile(file: string) {
+    file = this.normalize(file);
+
+    this.files.delete(file);
+    this.fileNames.delete(file);
+    this.usage.delete(file);
+
+    this.ensureProgram();
   }
 
   getProgram() {
@@ -110,18 +184,15 @@ export class TSService {
   }
 
   getSourceFile(file: string) {
+    file = this.normalize(file);
     return this.getProgram()?.getSourceFile(file);
   }
 
   getFileContent(file: string) {
+    file = this.normalize(file);
     return this.files.get(file)?.content;
   }
 
-  removeFile(file: string) {
-    this.files.delete(file);
-    this.fileNames.delete(file);
-  }
-
   getModuleResolutionConfig() {
     return {
       baseUrl: this.baseUrl,