@eventra_dev/eventra-cli 0.1.3 → 0.1.5

package/dist/engine/engine.js

@@ -7,14 +7,17 @@ const graph_1 = require("./graph");
 const hash_1 = require("./hash");
 class EventraEngine {
     ts;
-    graph = new graph_1.DependencyGraph();
+    graph;
     fileEvents = new Map();
     fileHash = new Map();
     constructor(root) {
         this.ts = new languageService_1.TSService(root);
+        const { baseUrl, paths } = this.ts.getModuleResolutionConfig();
+        this.graph = new graph_1.DependencyGraph(baseUrl, paths);
     }
     scanFile(file, content) {
         const h = (0, hash_1.hash)(content);
+        // cache
         if (this.fileHash.get(file) === h) {
             return this.fileEvents.get(file) ?? new Set();
         }
@@ -24,6 +27,7 @@ class EventraEngine {
         const checker = this.ts.getChecker();
         if (!source || !checker)
             return new Set();
+        // обновляем graph
         this.graph.update(file, source);
         const events = (0, scanner_1.scanSource)(source, checker);
         this.fileEvents.set(file, events);

package/dist/engine/functionAnalyzer.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTrackParamIndex = findTrackParamIndex;
+const typescript_1 = __importDefault(require("typescript"));
+function findTrackParamIndex(fn) {
+    const paramIndex = new Map();
+    fn.parameters.forEach((p, i) => {
+        if (typescript_1.default.isIdentifier(p.name)) {
+            paramIndex.set(p.name.text, i);
+        }
+    });
+    let result = null;
+    function visit(node) {
+        if (typescript_1.default.isCallExpression(node)) {
+            const name = getCallName(node.expression);
+            if (/(track|event|capture|send)/i.test(name)) {
+                for (const arg of node.arguments) {
+                    if (typescript_1.default.isIdentifier(arg)) {
+                        const idx = paramIndex.get(arg.text);
+                        if (idx !== undefined) {
+                            result = idx;
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    if (fn.body) {
+        visit(fn.body);
+    }
+    return result;
+}
+function getCallName(expr) {
+    if (typescript_1.default.isIdentifier(expr))
+        return expr.text;
+    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+        return expr.name.text;
+    }
+    return "";
+}

package/dist/engine/graph.js

@@ -8,14 +8,48 @@ const typescript_1 = __importDefault(require("typescript"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 class DependencyGraph {
+    baseUrl;
+    paths;
     reverse = new Map();
+    exports = new Map();
+    constructor(baseUrl, paths) {
+        this.baseUrl = baseUrl;
+        this.paths = paths;
+    }
     normalize(file) {
         return path_1.default.resolve(file);
     }
-    resolveImport(from, module) {
-        if (!module.startsWith("."))
-            return null;
-        const base = path_1.default.resolve(path_1.default.dirname(from), module);
+    // TS-like resolver
+    resolveModule(module, from) {
+        // relative
+        if (module.startsWith(".")) {
+            const abs = path_1.default.resolve(path_1.default.dirname(from), module);
+            return this.resolveFile(abs);
+        }
+        // paths mapping
+        for (const key in this.paths) {
+            const pattern = key.replace("*", "(.*)");
+            const regex = new RegExp("^" + pattern + "$");
+            const match = module.match(regex);
+            if (!match)
+                continue;
+            const wildcard = match[1] || "";
+            for (const target of this.paths[key]) {
+                const replaced = target.replace("*", wildcard);
+                const abs = path_1.default.resolve(this.baseUrl, replaced);
+                const resolved = this.resolveFile(abs);
+                if (resolved)
+                    return resolved;
+            }
+        }
+        // baseUrl fallback
+        const abs = path_1.default.resolve(this.baseUrl, module);
+        const resolved = this.resolveFile(abs);
+        if (resolved)
+            return resolved;
+        return null;
+    }
+    resolveFile(base) {
         const tryFiles = [
             base,
             base + ".ts",
@@ -31,23 +65,38 @@ class DependencyGraph {
                 return this.normalize(f);
             }
         }
-        return this.normalize(base);
+        return null;
     }
     update(file, source) {
         const normalizedFile = this.normalize(file);
+        this.exports.set(normalizedFile, new Set());
         for (const stmt of source.statements) {
-            if (!typescript_1.default.isImportDeclaration(stmt))
-                continue;
-            const module = stmt.moduleSpecifier
-                .getText()
-                .replace(/['"]/g, "");
-            const resolved = this.resolveImport(normalizedFile, module);
-            if (!resolved)
-                continue;
-            if (!this.reverse.has(resolved)) {
-                this.reverse.set(resolved, new Set());
+            // IMPORT
+            if (typescript_1.default.isImportDeclaration(stmt)) {
+                const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+                const resolved = this.resolveModule(module, normalizedFile);
+                if (!resolved)
+                    continue;
+                if (!this.reverse.has(resolved)) {
+                    this.reverse.set(resolved, new Set());
+                }
+                this.reverse.get(resolved).add(normalizedFile);
+            }
+            // EXPORT *
+            if (typescript_1.default.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());
+                }
+                this.exports.get(normalizedFile).add(resolved);
+                if (!this.reverse.has(resolved)) {
+                    this.reverse.set(resolved, new Set());
+                }
+                this.reverse.get(resolved).add(normalizedFile);
             }
-            this.reverse.get(resolved).add(normalizedFile);
         }
     }
     getDependents(file) {
@@ -55,6 +104,7 @@ class DependencyGraph {
     }
     remove(file) {
         const normalized = this.normalize(file);
+        this.exports.delete(normalized);
         for (const set of this.reverse.values()) {
             set.delete(normalized);
         }

package/dist/engine/languageService.js

@@ -6,10 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TSService = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 class TSService {
     root;
     files = new Map();
+    fileNames = new Set();
     service;
+    compilerOptions = {};
+    baseUrl = "";
+    paths = {};
     constructor(root) {
         this.root = root;
         const configPath = typescript_1.default.findConfigFile(root, typescript_1.default.sys.fileExists, "tsconfig.json");
@@ -28,12 +33,17 @@ class TSService {
                 ...compilerOptions,
                 ...parsed.options,
             };
+            this.paths = parsed.options.paths || {};
+            this.baseUrl = parsed.options.baseUrl
+                ? path_1.default.resolve(root, parsed.options.baseUrl)
+                : root;
         }
+        else {
+            this.baseUrl = root;
+        }
+        this.compilerOptions = compilerOptions;
         const host = {
-            getScriptFileNames: () => [
-                ...this.files.keys(),
-                ...typescript_1.default.sys.readDirectory(this.root, [".ts", ".tsx"], ["node_modules", "dist", ".git"])
-            ],
+            getScriptFileNames: () => [...this.fileNames],
             getScriptVersion: (file) => this.files.get(file)?.version.toString() ?? "0",
             getScriptSnapshot: (file) => {
                 const f = this.files.get(file);
@@ -46,7 +56,7 @@ class TSService {
                 return undefined;
             },
             getCurrentDirectory: () => this.root,
-            getCompilationSettings: () => compilerOptions,
+            getCompilationSettings: () => this.compilerOptions,
             getDefaultLibFileName: (opts) => typescript_1.default.getDefaultLibFilePath(opts),
             readFile: typescript_1.default.sys.readFile,
             fileExists: typescript_1.default.sys.fileExists,
@@ -60,6 +70,7 @@ class TSService {
             content,
             version: prev ? prev.version + 1 : 1,
         });
+        this.fileNames.add(file);
     }
     getProgram() {
         return this.service.getProgram();
@@ -70,5 +81,11 @@ class TSService {
     getSourceFile(file) {
         return this.getProgram()?.getSourceFile(file);
     }
+    getModuleResolutionConfig() {
+        return {
+            baseUrl: this.baseUrl,
+            paths: this.paths,
+        };
+    }
 }
 exports.TSService = TSService;

package/dist/engine/scanner.js

@@ -7,6 +7,34 @@ exports.scanSource = scanSource;
 const typescript_1 = __importDefault(require("typescript"));
 const resolver_1 = require("./resolver");
 const callResolver_1 = require("./callResolver");
+const functionAnalyzer_1 = require("./functionAnalyzer");
+function getCallName(expr) {
+    if (typescript_1.default.isIdentifier(expr))
+        return expr.text;
+    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+        return expr.name.text;
+    }
+    return "";
+}
+function pickBestArg(args, checker, paramMap) {
+    let best = null;
+    for (const arg of args) {
+        const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
+        if (!res?.values?.length)
+            continue;
+        let score = 0;
+        if (!res.dynamic)
+            score += 3;
+        if (res.values.every(v => v.length < 50))
+            score += 2;
+        if (res.values.some(v => v.includes("*")))
+            score -= 2;
+        if (!best || score > best.score) {
+            best = { score, node: arg };
+        }
+    }
+    return best?.node;
+}
 function scanSource(source, checker, visited = new Set(), depth = 0) {
     if (depth > 5)
         return new Set();
@@ -19,8 +47,7 @@ function scanSource(source, checker, visited = new Set(), depth = 0) {
             const name = getCallName(node.expression);
             if (/(track|event|capture|send)/i.test(name)) {
                 const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-                // param mapping
-                let paramMap = new Map();
+                const paramMap = new Map();
                 if (fn && typescript_1.default.isFunctionLike(fn)) {
                     fn.parameters.forEach((param, index) => {
                         const arg = node.arguments[index];
@@ -31,16 +58,29 @@ function scanSource(source, checker, visited = new Set(), depth = 0) {
                         }
                     });
                 }
-                // cross-file traversal
-                if (fn) {
-                    const sf = fn.getSourceFile();
-                    if (!visited.has(sf.fileName)) {
-                        scanSource(sf, checker, visited, depth + 1)
-                            .forEach(e => events.add(e));
+                if (fn && typescript_1.default.isFunctionLike(fn)) {
+                    const idx = (0, functionAnalyzer_1.findTrackParamIndex)(fn);
+                    if (idx !== null) {
+                        const realArg = node.arguments[idx];
+                        if (realArg) {
+                            const res = (0, resolver_1.resolveNodeValue)(realArg, checker, paramMap);
+                            res?.values.forEach(v => {
+                                if (v &&
+                                    v.length > 1 &&
+                                    v.length < 100 &&
+                                    !v.includes(" ") &&
+                                    /^[a-zA-Z0-9._:-]+$/.test(v)) {
+                                    events.add(v);
+                                }
+                            });
+                            return;
+                        }
                     }
                 }
-                for (const arg of node.arguments) {
-                    const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
+                // fallback (heuristic)
+                const target = pickBestArg(node.arguments, checker, paramMap);
+                if (target) {
+                    const res = (0, resolver_1.resolveNodeValue)(target, checker, paramMap);
                     res?.values.forEach(v => {
                         if (v &&
                             v.length > 1 &&
@@ -58,11 +98,3 @@ function scanSource(source, checker, visited = new Set(), depth = 0) {
     visit(source);
     return events;
 }
-function getCallName(expr) {
-    if (typescript_1.default.isIdentifier(expr))
-        return expr.text;
-    if (typescript_1.default.isPropertyAccessExpression(expr)) {
-        return expr.name.text;
-    }
-    return "";
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {

package/src/engine/engine.ts

@@ -5,23 +5,28 @@ import { hash } from "./hash";
 
 export class EventraEngine {
   private ts: TSService;
-  private graph = new DependencyGraph();
+  private graph: DependencyGraph;
 
   private fileEvents = new Map<string, Set<string>>();
   private fileHash = new Map<string, string>();
 
   constructor(root: string) {
     this.ts = new TSService(root);
+
+    const { baseUrl, paths } = this.ts.getModuleResolutionConfig();
+    this.graph = new DependencyGraph(baseUrl, paths);
   }
 
   scanFile(file: string, content: string) {
     const h = hash(content);
 
+    // cache
     if (this.fileHash.get(file) === h) {
       return this.fileEvents.get(file) ?? new Set();
     }
 
     this.fileHash.set(file, h);
+
     this.ts.updateFile(file, content);
 
     const source = this.ts.getSourceFile(file);
@@ -29,7 +34,9 @@ export class EventraEngine {
 
     if (!source || !checker) return new Set();
 
+    // обновляем graph
     this.graph.update(file, source);
+
     const events = scanSource(source, checker);
 
     this.fileEvents.set(file, events);
@@ -39,6 +46,7 @@ export class EventraEngine {
 
   updateFile(file: string, content: string) {
     const events = this.scanFile(file, content);
+
     const dependents = this.graph.getDependents(file);
 
     for (const dep of dependents) {
@@ -48,6 +56,7 @@ export class EventraEngine {
       if (!source || !checker) continue;
 
       const ev = scanSource(source, checker);
+
       this.fileEvents.set(dep, ev);
     }
 

package/src/engine/functionAnalyzer.ts

@@ -0,0 +1,51 @@
+import ts from "typescript";
+
+export function findTrackParamIndex(
+  fn: ts.FunctionLikeDeclaration
+): number | null {
+  const paramIndex = new Map<string, number>();
+
+  fn.parameters.forEach((p, i) => {
+    if (ts.isIdentifier(p.name)) {
+      paramIndex.set(p.name.text, i);
+    }
+  });
+
+  let result: number | null = null;
+
+  function visit(node: ts.Node) {
+    if (ts.isCallExpression(node)) {
+      const name = getCallName(node.expression);
+
+      if (/(track|event|capture|send)/i.test(name)) {
+        for (const arg of node.arguments) {
+          if (ts.isIdentifier(arg)) {
+            const idx = paramIndex.get(arg.text);
+            if (idx !== undefined) {
+              result = idx;
+              return;
+            }
+          }
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  if (fn.body) {
+    visit(fn.body);
+  }
+
+  return result;
+}
+
+function getCallName(expr: ts.Expression): string {
+  if (ts.isIdentifier(expr)) return expr.text;
+
+  if (ts.isPropertyAccessExpression(expr)) {
+    return expr.name.text;
+  }
+
+  return "";
+}

package/src/engine/graph.ts

@@ -4,16 +4,53 @@ import fs from "fs";
 
 export class DependencyGraph {
   private reverse = new Map<string, Set<string>>();
+  private exports = new Map<string, Set<string>>();
+
+  constructor(
+    private baseUrl: string,
+    private paths: Record<string, string[]>
+  ) {}
 
   private normalize(file: string) {
     return path.resolve(file);
   }
 
-  private resolveImport(from: string, module: string): string | null {
-    if (!module.startsWith(".")) return null;
+  // 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 regex = new RegExp("^" + pattern + "$");
+      const match = module.match(regex);
+
+      if (!match) continue;
+
+      const wildcard = match[1] || "";
+
+      for (const target of this.paths[key]) {
+        const replaced = target.replace("*", wildcard);
+        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;
 
-    const base = path.resolve(path.dirname(from), module);
+    return null;
+  }
 
+  private resolveFile(base: string): string | null {
     const tryFiles = [
       base,
       base + ".ts",
@@ -31,28 +68,48 @@ export class DependencyGraph {
       }
     }
 
-    return this.normalize(base);
+    return null;
   }
 
   update(file: string, source: ts.SourceFile) {
     const normalizedFile = this.normalize(file);
 
-    for (const stmt of source.statements) {
-      if (!ts.isImportDeclaration(stmt)) continue;
+    this.exports.set(normalizedFile, new Set());
 
-      const module = stmt.moduleSpecifier
-        .getText()
-        .replace(/['"]/g, "");
+    for (const stmt of source.statements) {
+      // IMPORT
+      if (ts.isImportDeclaration(stmt)) {
+        const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
 
-      const resolved = this.resolveImport(normalizedFile, module);
+        const resolved = this.resolveModule(module, normalizedFile);
+        if (!resolved) continue;
 
-      if (!resolved) continue;
+        if (!this.reverse.has(resolved)) {
+          this.reverse.set(resolved, new Set());
+        }
 
-      if (!this.reverse.has(resolved)) {
-        this.reverse.set(resolved, new Set());
+        this.reverse.get(resolved)!.add(normalizedFile);
       }
 
-      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());
+        }
+
+        this.exports.get(normalizedFile)!.add(resolved);
+
+        if (!this.reverse.has(resolved)) {
+          this.reverse.set(resolved, new Set());
+        }
+
+        this.reverse.get(resolved)!.add(normalizedFile);
+      }
     }
   }
 
@@ -63,6 +120,8 @@ export class DependencyGraph {
   remove(file: string) {
     const normalized = this.normalize(file);
 
+    this.exports.delete(normalized);
+
     for (const set of this.reverse.values()) {
       set.delete(normalized);
     }

package/src/engine/languageService.ts

@@ -1,10 +1,16 @@
 import ts from "typescript";
 import fs from "fs";
+import path from "path";
 
 export class TSService {
   private files = new Map<string, { version: number; content: string }>();
+  private fileNames = new Set<string>();
   private service: ts.LanguageService;
 
+  private readonly compilerOptions: ts.CompilerOptions = {};
+  private readonly baseUrl: string = "";
+  private readonly paths: Record<string, string[]> = {};
+
   constructor(private root: string) {
     const configPath = ts.findConfigFile(
       root,
@@ -22,10 +28,7 @@ export class TSService {
     };
 
     if (configPath) {
-      const configFile = ts.readConfigFile(
-        configPath,
-        ts.sys.readFile
-      );
+      const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
 
       const parsed = ts.parseJsonConfigFileContent(
         configFile.config,
@@ -37,17 +40,20 @@ export class TSService {
         ...compilerOptions,
         ...parsed.options,
       };
+
+      this.paths = parsed.options.paths || {};
+      this.baseUrl = parsed.options.baseUrl
+        ? path.resolve(root, parsed.options.baseUrl)
+        : root;
+    } else {
+      this.baseUrl = root;
     }
 
+    this.compilerOptions = compilerOptions;
+
     const host: ts.LanguageServiceHost = {
-      getScriptFileNames: () => [
-        ...this.files.keys(),
-        ...ts.sys.readDirectory(
-          this.root,
-          [".ts", ".tsx"],
-          ["node_modules", "dist", ".git"]
-        )
-      ],
+      getScriptFileNames: () => [...this.fileNames],
+
       getScriptVersion: (file) =>
         this.files.get(file)?.version.toString() ?? "0",
 
@@ -68,7 +74,7 @@ export class TSService {
       },
 
       getCurrentDirectory: () => this.root,
-      getCompilationSettings: () => compilerOptions,
+      getCompilationSettings: () => this.compilerOptions,
       getDefaultLibFileName: (opts) =>
         ts.getDefaultLibFilePath(opts),
 
@@ -87,6 +93,8 @@ export class TSService {
       content,
       version: prev ? prev.version + 1 : 1,
     });
+
+    this.fileNames.add(file);
   }
 
   getProgram() {
@@ -100,4 +108,11 @@ export class TSService {
   getSourceFile(file: string) {
     return this.getProgram()?.getSourceFile(file);
   }
+
+  getModuleResolutionConfig() {
+    return {
+      baseUrl: this.baseUrl,
+      paths: this.paths,
+    };
+  }
 }

package/src/engine/scanner.ts

@@ -1,6 +1,43 @@
 import ts from "typescript";
 import { resolveNodeValue } from "./resolver";
 import { resolveFunctionFromCall } from "./callResolver";
+import { findTrackParamIndex } from "./functionAnalyzer";
+
+function getCallName(expr: ts.Expression): string {
+  if (ts.isIdentifier(expr)) return expr.text;
+
+  if (ts.isPropertyAccessExpression(expr)) {
+    return expr.name.text;
+  }
+
+  return "";
+}
+
+function pickBestArg(
+  args: readonly ts.Expression[],
+  checker: ts.TypeChecker,
+  paramMap: Map<string, ts.Expression>
+) {
+  let best: { score: number; node: ts.Expression } | null = null;
+
+  for (const arg of args) {
+    const res = resolveNodeValue(arg, checker, paramMap);
+
+    if (!res?.values?.length) continue;
+
+    let score = 0;
+
+    if (!res.dynamic) score += 3;
+    if (res.values.every(v => v.length < 50)) score += 2;
+    if (res.values.some(v => v.includes("*"))) score -= 2;
+
+    if (!best || score > best.score) {
+      best = { score, node: arg };
+    }
+  }
+
+  return best?.node;
+}
 
 export function scanSource(
   source: ts.SourceFile,
@@ -9,6 +46,7 @@ export function scanSource(
   depth = 0
 ): Set<string> {
   if (depth > 5) return new Set();
+
   const events = new Set<string>();
 
   if (visited.has(source.fileName)) return events;
@@ -19,11 +57,9 @@ export function scanSource(
       const name = getCallName(node.expression);
 
       if (/(track|event|capture|send)/i.test(name)) {
-
         const fn = resolveFunctionFromCall(node.expression, checker);
 
-        // param mapping
-        let paramMap = new Map<string, ts.Expression>();
+        const paramMap = new Map<string, ts.Expression>();
 
         if (fn && ts.isFunctionLike(fn)) {
           fn.parameters.forEach((param, index) => {
@@ -36,18 +72,37 @@ export function scanSource(
           });
         }
 
-        // cross-file traversal
-        if (fn) {
-          const sf = fn.getSourceFile();
-
-          if (!visited.has(sf.fileName)) {
-            scanSource(sf, checker, visited, depth + 1)
-              .forEach(e => events.add(e));
+        if (fn && ts.isFunctionLike(fn)) {
+          const idx = findTrackParamIndex(fn);
+
+          if (idx !== null) {
+            const realArg = node.arguments[idx];
+
+            if (realArg) {
+              const res = resolveNodeValue(realArg, checker, paramMap);
+
+              res?.values.forEach(v => {
+                if (
+                  v &&
+                  v.length > 1 &&
+                  v.length < 100 &&
+                  !v.includes(" ") &&
+                  /^[a-zA-Z0-9._:-]+$/.test(v)
+                ) {
+                  events.add(v);
+                }
+              });
+
+              return;
+            }
           }
         }
 
-        for (const arg of node.arguments) {
-          const res = resolveNodeValue(arg, checker, paramMap);
+        // fallback (heuristic)
+        const target = pickBestArg(node.arguments, checker, paramMap);
+
+        if (target) {
+          const res = resolveNodeValue(target, checker, paramMap);
 
           res?.values.forEach(v => {
             if (
@@ -71,13 +126,3 @@ export function scanSource(
 
   return events;
 }
-
-function getCallName(expr: ts.Expression): string {
-  if (ts.isIdentifier(expr)) return expr.text;
-
-  if (ts.isPropertyAccessExpression(expr)) {
-    return expr.name.text;
-  }
-
-  return "";
-}