@eventra_dev/eventra-cli 0.1.29 → 0.1.30

package/src/engine/scanner.ts

@@ -1,11 +1,9 @@
 import ts from "typescript";
 import { resolveNodeValue } from "./resolver";
 import { resolveFunctionFromCall } from "./callResolver";
-import { resolveExportedSymbol } from "./exportResolver";
 import { findTrackParamIndex } from "./functionAnalyzer";
 import { EventraConfig } from "../types";
 import { isExternalFile } from "./boundary";
-import { isTrackingCall } from "./trackingDetector";
 
 function getCallName(expr: ts.Expression): string {
   if (ts.isIdentifier(expr)) return expr.text;
@@ -23,42 +21,6 @@ function isValidEvent(v: string) {
   );
 }
 
-function resolveFunctionDeep(
-  expr: ts.Expression,
-  checker: ts.TypeChecker
-): ts.FunctionLikeDeclaration | null {
-  let fn = resolveFunctionFromCall(expr, checker);
-  if (fn) return fn;
-
-  let symbol = checker.getSymbolAtLocation(expr);
-
-  if (!symbol) return null;
-
-  if (symbol.flags & ts.SymbolFlags.Alias) {
-    symbol = checker.getAliasedSymbol(symbol);
-  }
-
-  const resolvedSymbol =
-    resolveExportedSymbol(symbol, checker) ?? symbol;
-
-  for (const decl of resolvedSymbol.getDeclarations() ?? []) {
-    if (ts.isFunctionDeclaration(decl)) {
-      return decl;
-    }
-
-    if (
-      ts.isVariableDeclaration(decl) &&
-      decl.initializer &&
-      (ts.isArrowFunction(decl.initializer) ||
-        ts.isFunctionExpression(decl.initializer))
-    ) {
-      return decl.initializer;
-    }
-  }
-
-  return null;
-}
-
 export type ScanResult = {
   events: Set<string>;
   detectedFunctionWrappers: Set<string>;
@@ -70,7 +32,6 @@ export function scanSource(
   checker: ts.TypeChecker,
   config: EventraConfig,
   visited = new Set<string>(),
-  depth = 0,
   inheritedParamMap?: Map<string, ts.Expression>
 ): ScanResult {
   const events = new Set<string>();
@@ -84,7 +45,6 @@ export function scanSource(
   visited.add(source.fileName);
 
   function visit(node: ts.Node) {
-    // CALL EXPRESSIONS
     if (ts.isCallExpression(node)) {
       const name = getCallName(node.expression);
 
@@ -92,55 +52,28 @@ export function scanSource(
         w => w.name === name
       );
 
-      const isTrackingByType = isTrackingCall(node, checker);
-
-      const resolvedFn = resolveFunctionDeep(
-        node.expression,
-        checker
-      );
+      const resolvedFn = resolveFunctionFromCall(node.expression, checker);
 
       const isAutoWrapper =
-        resolvedFn && findTrackParamIndex(resolvedFn) !== null;
+        !!resolvedFn && findTrackParamIndex(resolvedFn) !== null;
 
-      let isTracking =
+      const isTracking =
+        name === "track" ||
         isKnownWrapper ||
-        isTrackingByType ||
-        name.startsWith("$") ||
         (isAutoWrapper &&
           resolvedFn &&
-          resolvedFn.getSourceFile &&
           !isExternalFile(resolvedFn.getSourceFile().fileName));
 
-      if (!isTracking) {
-        if (
-          ts.isPropertyAccessExpression(node.expression) &&
-          node.expression.name.text === "track"
-        ) {
-          isTracking = true;
-        } else if (
-          ts.isIdentifier(node.expression) &&
-          node.expression.text === "track"
-        ) {
-          isTracking = true;
-        }
-      }
-
       if (!isTracking) {
         ts.forEachChild(node, visit);
         return;
       }
 
-      // DETECT WRAPPER
-      if (
-        !isKnownWrapper &&
-        isAutoWrapper &&
-        !isTrackingByType &&
-        !name.startsWith("track")
-      ) {
+      // авто-детект wrapper
+      if (!isKnownWrapper && isAutoWrapper && name !== "track") {
         detectedFunctionWrappers.add(name);
       }
 
-      // PARAM MAP
       const paramMap = new Map(inheritedParamMap ?? []);
 
       if (resolvedFn && ts.isFunctionLike(resolvedFn)) {
@@ -154,7 +87,7 @@ export function scanSource(
         });
       }
 
-      // STRICT EVENT RESOLVE
+      // ✅ ТОЛЬКО правильный аргумент
       if (resolvedFn) {
         const idx = findTrackParamIndex(resolvedFn);
 
@@ -165,23 +98,24 @@ export function scanSource(
             paramMap
           );
 
-          res.values.forEach(v => {
-            if (isValidEvent(v)) events.add(v);
-          });
+          for (const v of res.values) {
+            if (isValidEvent(v)) {
+              events.add(v);
+            }
+          }
         }
       }
 
-      // CROSS-FILE
+      // CROSS FILE
       if (resolvedFn) {
-        const sf = resolvedFn.getSourceFile?.();
+        const sf = resolvedFn.getSourceFile();
 
-        if (sf && !visited.has(sf.fileName)) {
+        if (!visited.has(sf.fileName)) {
           const res = scanSource(
             sf,
             checker,
             config,
             visited,
-            depth + 1,
             paramMap
           );
 

package/src/engine/trackingDetector.ts

@@ -1,93 +1,16 @@
 import ts from "typescript";
 
-function isStringLike(type: ts.Type) {
-  return (
-    (type.flags & ts.TypeFlags.StringLike) !== 0 ||
-    (type.flags & ts.TypeFlags.StringLiteral) !== 0
-  );
-}
-
-function hasTrackLikeSignature(
-  type: ts.Type,
-  checker: ts.TypeChecker
-): boolean {
-  const sigs = type.getCallSignatures();
-
-  for (const sig of sigs) {
-    const params = sig.getParameters();
-    if (!params.length) continue;
-
-    const t = checker.getTypeOfSymbolAtLocation(
-      params[0],
-      params[0].valueDeclaration!
-    );
-
-    if (isStringLike(t)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function isEventraLikeType(
-  type: ts.Type,
-  checker: ts.TypeChecker
-): boolean {
-  const props = type.getProperties();
-
-  for (const prop of props) {
-    const decl = prop.valueDeclaration ?? prop.declarations?.[0];
-    if (!decl) continue;
-
-    const t = checker.getTypeOfSymbolAtLocation(prop, decl);
-
-    if (hasTrackLikeSignature(t, checker)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
 export function isTrackingCall(
-  node: ts.CallExpression,
-  checker: ts.TypeChecker
+  node: ts.CallExpression
 ): boolean {
   const expr = node.expression;
 
-  // fn(...)
   if (ts.isIdentifier(expr)) {
-    const type = checker.getTypeAtLocation(expr);
-    if (hasTrackLikeSignature(type, checker)) {
-      return true;
-    }
+    return expr.text === "track";
   }
 
-  // obj.method(...)
   if (ts.isPropertyAccessExpression(expr)) {
-    const objType = checker.getTypeAtLocation(expr.expression);
-
-    // объект похож на tracker
-    if (isEventraLikeType(objType, checker)) {
-      return true;
-    }
-
-    // fallback
-    const methodType = checker.getTypeAtLocation(expr.name);
-
-    if (hasTrackLikeSignature(methodType, checker)) {
-      return true;
-    }
-  }
-
-  // obj["track"](...)
-  if (ts.isElementAccessExpression(expr)) {
-    const objType = checker.getTypeAtLocation(expr.expression);
-
-    if (isEventraLikeType(objType, checker)) {
-      return true;
-    }
+    return expr.name.text === "track";
   }
 
   return false;

package/src/utils/universal.ts

@@ -1,7 +1,7 @@
 import path from "path";
 import { ParseResult } from "../types";
 
-// Strip comments (HTML + JS)
+// Remove comments
 function stripComments(input: string): string {
   return input
     .replace(/<!--[\s\S]*?-->/g, "")
@@ -9,80 +9,78 @@ function stripComments(input: string): string {
     .replace(/\/\/.*$/gm, "");
 }
 
-// Extract JS expressions inside {}
-function extractJS(input: string): string[] {
+// Basic filter
+function looksLikeTracking(code: string) {
+  return /track/i.test(code);
+}
+
+// HTML inline handlers (onclick="")
+function extractHTMLHandlers(input: string): string[] {
   const result: string[] = [];
 
-  let i = 0;
-  const len = input.length;
+  const matches = input.matchAll(
+    /\bon\w+\s*=\s*["']([^"']+)["']/g
+  );
+
+  for (const m of matches) {
+    if (looksLikeTracking(m[1])) {
+      result.push(m[1]);
+    }
+  }
 
-  let inString: '"' | "'" | "`" | null = null;
-  let escape = false;
+  return result;
+}
 
-  while (i < len) {
-    const ch = input[i];
+// Vue handlers (@click / v-on)
+function extractVueHandlers(input: string): string[] {
+  const result: string[] = [];
 
-    if (inString) {
-      if (escape) escape = false;
-      else if (ch === "\\") escape = true;
-      else if (ch === inString) inString = null;
-      i++;
-      continue;
-    }
+  const matches = input.matchAll(
+    /(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g
+  );
 
-    if (ch === '"' || ch === "'" || ch === "`") {
-      inString = ch;
-      i++;
-      continue;
+  for (const m of matches) {
+    if (looksLikeTracking(m[1])) {
+      result.push(m[1]);
     }
+  }
 
-    if (ch === "{") {
-      let depth = 1;
-      let j = i + 1;
-
-      while (j < len && depth > 0) {
-        if (input[j] === "{") depth++;
-        else if (input[j] === "}") depth--;
-        j++;
-      }
+  return result;
+}
 
-      if (depth === 0) {
-        const expr = input.slice(i + 1, j - 1).trim();
+// Svelte handlers (on:click)
+function extractSvelteHandlers(input: string): string[] {
+  const result: string[] = [];
 
-        if (expr && /[a-zA-Z0-9_$]\s*\(/.test(expr)) {
-          result.push(expr);
-        }
+  const matches = input.matchAll(
+    /\bon:[\w]+\s*=\s*{([^}]+)}/g
+  );
 
-        i = j;
-        continue;
-      }
+  for (const m of matches) {
+    if (looksLikeTracking(m[1])) {
+      result.push(m[1]);
     }
-
-    i++;
   }
 
   return result;
 }
 
-// Extract inline HTML handlers
-function extractInlineHandlers(input: string): string[] {
+// JSX / template { ... }
+function extractJSExpressions(input: string): string[] {
   const result: string[] = [];
 
-  const matches = input.matchAll(
-    /\bon\w+\s*=\s*["']([^"']+)["']/g
-  );
+  const matches = input.matchAll(/\{([^}]+)\}/g);
 
   for (const m of matches) {
-    const code = m[1];
-    if (/[a-zA-Z0-9_$]\s*\(/.test(code)) {
-      result.push(code);
+    if (looksLikeTracking(m[1])) {
+      result.push(m[1]);
     }
   }
 
   return result;
 }
 
-// Extract dynamic imports
+// dynamic import()
 function extractDynamicImports(
   input: string,
   file: string
@@ -102,17 +100,15 @@ function extractDynamicImports(
       : path.resolve(path.dirname(file), mod);
 
     deps.push(resolved);
-    calls.push(`import("${mod}")`);
+
+    if (looksLikeTracking(mod)) {
+      calls.push(`import("${mod}")`);
+    }
   }
 
   return { deps, calls };
 }
 
-// Filter only probable tracking-related code
-function isProbablyTracking(code: string): boolean {
-  return /track|event|analytics/i.test(code);
-}
-
 // UNIVERSAL PARSER
 export function parseUniversal(
   content: string,
@@ -150,39 +146,29 @@ export function parseUniversal(
   );
 
   for (const m of scripts) {
-    const attrs = m[1];
-
-    if (/type=["']application\/json/.test(attrs)) continue;
-
     if (m[2].trim()) {
       parts.push(m[2]);
     }
   }
 
-  // REMOVE SCRIPTS → TEMPLATE PART
+  // TEMPLATE PART
   const noScripts = clean.replace(
     /<script[\s\S]*?<\/script>/g,
     ""
   );
 
-  // INLINE HANDLERS
-  parts.push(
-    ...extractInlineHandlers(noScripts).filter(isProbablyTracking)
-  );
+  // handlers
+  parts.push(...extractHTMLHandlers(noScripts));
+  parts.push(...extractVueHandlers(noScripts));
+  parts.push(...extractSvelteHandlers(noScripts));
 
-  // DYNAMIC IMPORTS
+  // JSX / Astro / Vue expressions
+  parts.push(...extractJSExpressions(clean));
+
+  // dynamic imports
   const dyn = extractDynamicImports(clean, file);
   deps.push(...dyn.deps);
-  parts.push(...dyn.calls.filter(isProbablyTracking));
-
-  // EXPRESSIONS
-  const extracted = extractJS(clean);
-
-  for (const e of extracted) {
-    if (isProbablyTracking(e)) {
-      parts.push(e + ";");
-    }
-  }
+  parts.push(...dyn.calls);
 
   return {
     code: [...new Set(parts)].join("\n"),