@eventra_dev/eventra-cli 0.1.6 → 0.1.7

package/src/commands/sync.ts

@@ -23,13 +23,24 @@ export async function sync() {
 
   const engine = new EventraEngine(process.cwd());
 
+  const detectedFn = new Set<string>();
+  const detectedCmp = new Map<string, string>();
+
   for (const file of files) {
     try {
       const raw = await fs.readFile(file, "utf-8");
 
       const { content, virtualFile } = processFile(file, raw);
 
-      engine.scanFile(virtualFile, content);
+      const res = engine.scanFile(virtualFile, content, config);
+
+      for (const w of res.detectedFunctionWrappers) {
+        detectedFn.add(w);
+      }
+
+      for (const [k, v] of res.detectedComponentWrappers) {
+        detectedCmp.set(k, v);
+      }
 
     } catch (err) {
       console.log(chalk.yellow(`Skipped: ${file}`));
@@ -40,10 +51,59 @@ export async function sync() {
     }
   }
 
+  // EVENTS
   const events = engine.getAllEvents().sort();
 
-  config.events = events;
+  const mergedEvents = new Set(config.events ?? []);
+  events.forEach(e => mergedEvents.add(e));
+
+  config.events = [...mergedEvents].sort();
+
+  // FUNCTION WRAPPERS
+  config.functionWrappers = mergeUnique(
+    config.functionWrappers ?? [],
+    [...detectedFn].map(name => ({ name })),
+    w => w.name
+  );
+
+  // COMPONENT WRAPPERS
+  config.wrappers = mergeUnique(
+    config.wrappers ?? [],
+    [...detectedCmp.entries()].map(([name, prop]) => ({
+      name,
+      prop,
+    })),
+    w => `${w.name}:${w.prop}`
+  );
+
   await saveConfig(config);
 
   console.log(chalk.green(`Found ${events.length} events`));
+
+  if (detectedFn.size) {
+    console.log(chalk.blue("\nDetected function wrappers:"));
+    detectedFn.forEach(w => console.log(chalk.gray(`• ${w}`)));
+  }
+
+  if (detectedCmp.size) {
+    console.log(chalk.blue("\nDetected component wrappers:"));
+    detectedCmp.forEach((prop, name) =>
+      console.log(chalk.gray(`• ${name} (${prop})`))
+    );
+  }
+}
+
+// HELPERS
+function mergeUnique<T>(
+  a: T[],
+  b: T[],
+  key: (v: T) => string
+): T[] {
+  const map = new Map<string, T>();
+
+  [...b, ...a].forEach(item => {
+    map.set(key(item), item);
+  });
+
+  return [...map.values()];
 }

package/src/commands/watch.ts

@@ -25,7 +25,7 @@ export async function watch() {
 
       const { content, virtualFile } = processFile(file, raw);
 
-      engine.scanFile(virtualFile, content);
+      engine.scanFile(virtualFile, content, config);
 
     } catch {
       console.log(chalk.gray(`skip: ${file}`));
@@ -56,7 +56,7 @@ export async function watch() {
 
         const { content, virtualFile } = processFile(file, raw);
 
-        engine.updateFile(virtualFile, content);
+        engine.updateFile(virtualFile, content, config);
 
       } catch {
         console.log(chalk.gray(`skip: ${file}`));

package/src/engine/callResolver.ts

@@ -1,25 +1,92 @@
 import ts from "typescript";
 
+function isFunctionLike(
+  node: ts.Node
+): node is ts.FunctionLikeDeclaration {
+  return (
+    ts.isFunctionDeclaration(node) ||
+    ts.isMethodDeclaration(node) ||
+    ts.isConstructorDeclaration(node) ||
+    ts.isFunctionExpression(node) ||
+    ts.isArrowFunction(node)
+  );
+}
+
+function resolveFromSymbol(
+  symbol: ts.Symbol,
+  checker: ts.TypeChecker,
+  visited = new Set<ts.Symbol>()
+): ts.FunctionLikeDeclaration | null {
+  if (visited.has(symbol)) return null;
+  visited.add(symbol);
+
+  // alias unwrap
+  if (symbol.flags & ts.SymbolFlags.Alias) {
+    const aliased = checker.getAliasedSymbol(symbol);
+    return resolveFromSymbol(aliased, checker, visited);
+  }
+
+  const decls = symbol.getDeclarations() ?? [];
+
+  for (const decl of decls) {
+    if (isFunctionLike(decl)) {
+      return decl;
+    }
+
+    if (ts.isMethodSignature(decl)) {
+      const parent = decl.parent;
+
+      if (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, visited);
+          if (resolved) return resolved;
+        }
+      }
+    }
+
+    // fallback
+    const s = checker.getSymbolAtLocation(decl);
+    if (s) {
+      const resolved = resolveFromSymbol(s, checker, visited);
+      if (resolved) return resolved;
+    }
+  }
+
+  return null;
+}
+
 export function resolveFunctionFromCall(
   expr: ts.Expression,
   checker: ts.TypeChecker
 ): ts.FunctionLikeDeclaration | null {
-
   const type = checker.getTypeAtLocation(expr);
   const signatures = type.getCallSignatures();
 
   for (const sig of signatures) {
     const decl = sig.getDeclaration();
 
-    if (
-      decl &&
-      (ts.isFunctionDeclaration(decl) ||
-        ts.isMethodDeclaration(decl) ||
-        ts.isFunctionExpression(decl) ||
-        ts.isArrowFunction(decl))
-    ) {
+    if (!decl) continue;
+
+    if (isFunctionLike(decl)) {
       return decl;
     }
+
+    // MethodSignature case
+    if (ts.isMethodSignature(decl)) {
+      const symbol = checker.getSymbolAtLocation(decl.name);
+
+      if (symbol) {
+        const resolved = resolveFromSymbol(symbol, checker);
+        if (resolved) return resolved;
+      }
+    }
   }
 
   return null;

package/src/engine/engine.ts

@@ -1,13 +1,14 @@
 import { TSService } from "./languageService";
-import { scanSource } from "./scanner";
+import { ScanResult, scanSource } from "./scanner";
 import { DependencyGraph } from "./graph";
 import { hash } from "./hash";
+import { EventraConfig } from "../types";
 
 export class EventraEngine {
   private ts: TSService;
   private graph: DependencyGraph;
 
-  private fileEvents = new Map<string, Set<string>>();
+  private fileResults = new Map<string, ScanResult>();
   private fileHash = new Map<string, string>();
 
   constructor(root: string) {
@@ -17,37 +18,46 @@ export class EventraEngine {
     this.graph = new DependencyGraph(baseUrl, paths);
   }
 
-  scanFile(file: string, content: string) {
+  scanFile(file: string, content: string, config: EventraConfig): ScanResult {
     const h = hash(content);
 
-    // cache
     if (this.fileHash.get(file) === h) {
-      return this.fileEvents.get(file) ?? new Set();
+      return (
+        this.fileResults.get(file) ?? {
+          events: new Set(),
+          detectedFunctionWrappers: new Set(),
+          detectedComponentWrappers: new Map(),
+        }
+      );
     }
 
     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 new Set();
+    if (!source || !checker) {
+      return {
+        events: new Set(),
+        detectedFunctionWrappers: new Set(),
+        detectedComponentWrappers: new Map(),
+      };
+    }
 
-    // обновляем graph
     this.graph.update(file, source);
 
-    const events = scanSource(source, checker);
+    const res = scanSource(source, checker, config);
 
-    this.fileEvents.set(file, events);
+    this.fileResults.set(file, res);
 
-    return events;
+    return res;
   }
 
-  updateFile(file: string, content: string) {
-    const events = this.scanFile(file, content);
+  updateFile(file: string, content: string, config: EventraConfig) {
+    const res = this.scanFile(file, content, config);
 
-    const dependents = this.graph.getDependents(file);
+    const dependents = this.graph.getAllDependentsDeep(file);
 
     for (const dep of dependents) {
       const source = this.ts.getSourceFile(dep);
@@ -55,26 +65,25 @@ export class EventraEngine {
 
       if (!source || !checker) continue;
 
-      const ev = scanSource(source, checker);
-
-      this.fileEvents.set(dep, ev);
+      const r = scanSource(source, checker, config);
+      this.fileResults.set(dep, r);
     }
 
-    return events;
+    return res;
   }
 
   getAllEvents() {
     const all = new Set<string>();
 
-    for (const set of this.fileEvents.values()) {
-      set.forEach(e => all.add(e));
+    for (const r of this.fileResults.values()) {
+      r.events.forEach(e => all.add(e));
     }
 
     return [...all];
   }
 
   removeFile(file: string) {
-    this.fileEvents.delete(file);
+    this.fileResults.delete(file);
     this.fileHash.delete(file);
     this.graph.remove(file);
   }

package/src/engine/graph.ts

@@ -5,6 +5,7 @@ import fs from "fs";
 export class DependencyGraph {
   private reverse = new Map<string, Set<string>>();
   private exports = new Map<string, Set<string>>();
+  private fileCache = new Map<string, string | null>();
 
   constructor(
     private baseUrl: string,
@@ -15,42 +16,43 @@ export class DependencyGraph {
     return path.resolve(file);
   }
 
-  // TS-like resolver
   private resolveModule(module: string, from: string): string | null {
-    // relative
     if (module.startsWith(".")) {
       const abs = path.resolve(path.dirname(from), module);
       return this.resolveFile(abs);
     }
 
-    // paths mapping
     for (const key in this.paths) {
-      const pattern = key.replace("*", "(.*)");
+      const pattern = key.replace(/\*/g, "(.*)");
       const regex = new RegExp("^" + pattern + "$");
       const match = module.match(regex);
 
       if (!match) continue;
 
-      const wildcard = match[1] || "";
+      const wildcard = match.slice(1);
 
       for (const target of this.paths[key]) {
-        const replaced = target.replace("*", wildcard);
-        const abs = path.resolve(this.baseUrl, replaced);
+        let replaced = target;
+
+        wildcard.forEach(w => {
+          replaced = replaced.replace("*", w);
+        });
 
+        const abs = path.resolve(this.baseUrl, replaced);
         const resolved = this.resolveFile(abs);
         if (resolved) return resolved;
       }
     }
 
-    // baseUrl fallback
     const abs = path.resolve(this.baseUrl, module);
-    const resolved = this.resolveFile(abs);
-    if (resolved) return resolved;
-
-    return null;
+    return this.resolveFile(abs);
   }
 
   private resolveFile(base: string): string | null {
+    if (this.fileCache.has(base)) {
+      return this.fileCache.get(base)!;
+    }
+
     const tryFiles = [
       base,
       base + ".ts",
@@ -64,10 +66,13 @@ export class DependencyGraph {
 
     for (const f of tryFiles) {
       if (fs.existsSync(f)) {
-        return this.normalize(f);
+        const normalized = this.normalize(f);
+        this.fileCache.set(base, normalized);
+        return normalized;
       }
     }
 
+    this.fileCache.set(base, null);
     return null;
   }
 
@@ -77,11 +82,10 @@ export class DependencyGraph {
     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);
+
         if (!resolved) continue;
 
         if (!this.reverse.has(resolved)) {
@@ -91,18 +95,13 @@ export class DependencyGraph {
         this.reverse.get(resolved)!.add(normalizedFile);
       }
 
-      // EXPORT *
       if (ts.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
         const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
-
         const resolved = this.resolveModule(module, normalizedFile);
-        if (!resolved) continue;
 
-        if (!this.exports.has(normalizedFile)) {
-          this.exports.set(normalizedFile, new Set());
-        }
+        if (!resolved) continue;
 
-        this.exports.get(normalizedFile)!.add(resolved);
+        this.exports.get(normalizedFile)?.add(resolved);
 
         if (!this.reverse.has(resolved)) {
           this.reverse.set(resolved, new Set());
@@ -113,17 +112,43 @@ export class DependencyGraph {
     }
   }
 
-  getDependents(file: string) {
-    return [...(this.reverse.get(this.normalize(file)) ?? [])];
+  getAllDependentsDeep(file: string): string[] {
+    const start = this.normalize(file);
+    const visited = new Set<string>();
+    const result = new Set<string>();
+
+    const walk = (f: string) => {
+      if (visited.has(f)) return;
+      visited.add(f);
+
+      const deps = this.reverse.get(f);
+      deps?.forEach(d => {
+        result.add(d);
+        walk(d);
+      });
+
+      const ex = this.exports.get(f);
+      ex?.forEach(e => walk(e));
+    };
+
+    walk(start);
+
+    return [...result];
   }
 
   remove(file: string) {
     const normalized = this.normalize(file);
 
+    this.reverse.delete(normalized);
     this.exports.delete(normalized);
+    this.fileCache.delete(normalized);
 
     for (const set of this.reverse.values()) {
       set.delete(normalized);
     }
+
+    for (const set of this.exports.values()) {
+      set.delete(normalized);
+    }
   }
 }

package/src/engine/resolver.ts

@@ -53,6 +53,16 @@ export function resolveNodeValue(
   if (ts.isIdentifier(node)) {
     let symbol = checker.getSymbolAtLocation(node);
     if (!symbol) return null;
+    for (const decl of symbol.getDeclarations() ?? []) {
+      if (ts.isVariableDeclaration(decl) && decl.initializer) {
+        return resolveNodeValue(
+          decl.initializer,
+          checker,
+          paramMap,
+          seen
+        );
+      }
+    }
 
     symbol = resolveExportedSymbol(symbol, checker) ?? symbol;