@eventra_dev/eventra-cli 0.1.25 → 0.1.26

package/src/engine/scanner.ts

@@ -5,8 +5,7 @@ import { resolveExportedSymbol } from "./exportResolver";
 import { findTrackParamIndex } from "./functionAnalyzer";
 import { EventraConfig } from "../types";
 import { isExternalFile } from "./boundary";
-
-const TRACKING_NAMES = new Set(["track", "event", "capture", "send"]);
+import { isTrackingCall } from "./trackingDetector";
 
 function getCallName(expr: ts.Expression): string {
   if (ts.isIdentifier(expr)) return expr.text;
@@ -20,6 +19,19 @@ function getJsxAttrName(name: ts.JsxAttributeName): string | null {
   return null;
 }
 
+// unwrap
+function unwrap(expr: ts.Expression): ts.Expression {
+  while (
+    ts.isAsExpression(expr) ||
+    ts.isParenthesizedExpression(expr) ||
+    ts.isTypeAssertionExpression(expr) ||
+    ts.isNonNullExpression(expr)
+    ) {
+    expr = expr.expression;
+  }
+  return expr;
+}
+
 function isValidEvent(v: string) {
   return (
     v &&
@@ -32,24 +44,25 @@ function isValidEvent(v: string) {
 
 function isPropUsedInTracking(
   fn: ts.FunctionLikeDeclaration,
+  checker: ts.TypeChecker,
   prop: string
 ) {
   let found = false;
 
   function visit(node: ts.Node) {
     if (ts.isCallExpression(node)) {
-      const name = getCallName(node.expression);
-
-      if (!TRACKING_NAMES.has(name)) {
+      if (!isTrackingCall(node, checker)) {
         ts.forEachChild(node, visit);
         return;
       }
 
       for (const arg of node.arguments) {
+        const a = unwrap(arg as ts.Expression);
+
         if (
-          (ts.isIdentifier(arg) && arg.text === prop) ||
-          (ts.isPropertyAccessExpression(arg) &&
-            arg.name.text === prop)
+          (ts.isIdentifier(a) && a.text === prop) ||
+          (ts.isPropertyAccessExpression(a) &&
+            a.name.text === prop)
         ) {
           found = true;
         }
@@ -59,7 +72,10 @@ function isPropUsedInTracking(
     ts.forEachChild(node, visit);
   }
 
-  visit(fn);
+  if (fn.body) {
+    visit(fn.body);
+  }
+
   return found;
 }
 
@@ -81,7 +97,11 @@ export function scanSource(
   const detectedFunctionWrappers = new Set<string>();
   const detectedComponentWrappers = new Map<string, string>();
 
-  if (depth > 5 || visited.has(source.fileName)) {
+  if (
+    visited.has(source.fileName) ||
+    depth > 10 ||
+    visited.size > 200
+  ) {
     return { events, detectedFunctionWrappers, detectedComponentWrappers };
   }
 
@@ -90,53 +110,55 @@ export function scanSource(
   function visit(node: ts.Node) {
     // CALL EXPRESSIONS
     if (ts.isCallExpression(node)) {
-      const name = getCallName(node.expression);
+      const expr = unwrap(node.expression);
+      const name = getCallName(expr);
 
       const isKnownWrapper = config.functionWrappers.some(
         w => w.name === name
       );
 
-      let resolvedFn = resolveFunctionFromCall(node.expression, checker);
-
-      // fallback: tracker.track(...)
-      if (!resolvedFn && ts.isPropertyAccessExpression(node.expression)) {
-        const symbol = checker.getSymbolAtLocation(node.expression.name);
-
-        if (symbol) {
-          const decls = symbol.getDeclarations();
+      const isTrackingByType = isTrackingCall(node, checker);
 
-          if (decls?.length) {
-            const d = decls[0];
-
-            if (
-              ts.isMethodDeclaration(d) ||
-              ts.isFunctionDeclaration(d) ||
-              ts.isFunctionExpression(d) ||
-              ts.isArrowFunction(d)
-            ) {
-              resolvedFn = d;
-            }
-          }
-        }
-      }
+      let resolvedFn = resolveFunctionFromCall(expr, checker);
 
       const isAutoWrapper =
         resolvedFn && findTrackParamIndex(resolvedFn) !== null;
 
-      const isTracking =
+      let isTracking =
         isKnownWrapper ||
-        TRACKING_NAMES.has(name) ||
-        name.startsWith("$") || // NUXT FIX
+        isTrackingByType ||
+        name.startsWith("$") ||
         (isAutoWrapper &&
           resolvedFn &&
           !isExternalFile(resolvedFn.getSourceFile().fileName));
 
+      // fallback
+      if (!isTracking) {
+        if (
+          ts.isPropertyAccessExpression(expr) &&
+          expr.name.text === "track"
+        ) {
+          isTracking = true;
+        } else if (
+          ts.isIdentifier(expr) &&
+          expr.text === "track"
+        ) {
+          isTracking = true;
+        }
+      }
+
       if (!isTracking) {
         ts.forEachChild(node, visit);
         return;
       }
 
-      if (!isKnownWrapper && isAutoWrapper && !TRACKING_NAMES.has(name)) {
+      // detect wrapper
+      if (
+        !isKnownWrapper &&
+        isAutoWrapper &&
+        !isTrackingByType &&
+        !name.startsWith("track")
+      ) {
         detectedFunctionWrappers.add(name);
       }
 
@@ -161,16 +183,14 @@ export function scanSource(
 
         if (idx !== null && node.arguments[idx]) {
           const res = resolveNodeValue(
-            node.arguments[idx],
+            unwrap(node.arguments[idx]),
             checker,
             paramMap
           );
 
-          if (res && res.values.length) {
-            res.values.forEach(v => {
-              if (isValidEvent(v)) events.add(v);
-            });
-          }
+          res.values.forEach(v => {
+            if (isValidEvent(v)) events.add(v);
+          });
 
           handled = true;
         }
@@ -179,13 +199,15 @@ export function scanSource(
       // FALLBACK
       if (!handled) {
         for (const arg of node.arguments) {
-          const res = resolveNodeValue(arg, checker, paramMap);
+          const res = resolveNodeValue(
+            unwrap(arg),
+            checker,
+            paramMap
+          );
 
-          if (res && res.values.length) {
-            res.values.forEach(v => {
-              if (isValidEvent(v)) events.add(v);
-            });
-          }
+          res.values.forEach(v => {
+            if (isValidEvent(v)) events.add(v);
+          });
         }
       }
 
@@ -263,7 +285,7 @@ export function scanSource(
           const prop = el.name.getText();
 
           const isEvent =
-            isPropUsedInTracking(fn, prop) ||
+            isPropUsedInTracking(fn, checker, prop) ||
             config.wrappers.some(
               w => w.name === tagName && w.prop === prop
             );

package/src/engine/trackingDetector.ts

@@ -0,0 +1,94 @@
+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
+): boolean {
+  const expr = node.expression;
+
+  // fn(...)
+  if (ts.isIdentifier(expr)) {
+    const type = checker.getTypeAtLocation(expr);
+    if (hasTrackLikeSignature(type, checker)) {
+      return true;
+    }
+  }
+
+  // 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 false;
+}

package/src/types.ts

@@ -5,9 +5,6 @@ export type ParseResult = {
   deps: string[];
 };
 
-export type Parser = (content: string, file: string) => ParseResult;
-
-
 export type ComponentWrapper = {
   name: string;
   prop: string;

package/src/utils/processFile.ts

@@ -1,19 +1,10 @@
-import path from "path";
 import { parseUniversal } from "./universal";
 
 export function processFile(file: string, content: string) {
   const { code, deps } = parseUniversal(content, file);
 
-  const ext = path.extname(file);
-
-  const virtualFile =
-    /\.(vue|svelte|astro|html)$/i.test(file)
-      ? file.replace(ext, "") + ".tsx"
-      : file;
-
   return {
     content: code || "",
-    virtualFile,
     deps: [...new Set(deps.filter(Boolean))],
   };
 }

package/src/utils/universal.ts

@@ -12,7 +12,7 @@ function stripComments(input: string): string {
 }
 
 /**
- * Extract JS expressions safely
+ * Extract JS expressions
  */
 function extractJS(input: string): string[] {
   const result: string[] = [];
@@ -26,7 +26,6 @@ function extractJS(input: string): string[] {
   while (i < len) {
     const ch = input[i];
 
-    // STRING
     if (inString) {
       if (escape) escape = false;
       else if (ch === "\\") escape = true;
@@ -41,47 +40,20 @@ function extractJS(input: string): string[] {
       continue;
     }
 
-    // { ... }
     if (ch === "{") {
       let depth = 1;
       let j = i + 1;
 
-      let innerStr: '"' | "'" | "`" | null = null;
-      let innerEsc = false;
-
       while (j < len && depth > 0) {
-        const c = input[j];
-
-        if (innerStr) {
-          if (innerEsc) innerEsc = false;
-          else if (c === "\\") innerEsc = true;
-          else if (c === innerStr) innerStr = null;
-          j++;
-          continue;
-        }
-
-        if (c === '"' || c === "'" || c === "`") {
-          innerStr = c;
-          j++;
-          continue;
-        }
-
-        if (c === "{") depth++;
-        else if (c === "}") depth--;
-
+        if (input[j] === "{") depth++;
+        else if (input[j] === "}") depth--;
         j++;
       }
 
       if (depth === 0) {
         const expr = input.slice(i + 1, j - 1).trim();
 
-        if (
-          expr &&
-          (expr.includes("(") ||
-            expr.includes("=") ||
-            expr.includes(".") ||
-            expr.includes("track"))
-        ) {
+        if (expr && /[a-zA-Z0-9_$]\s*\(/.test(expr)) {
           result.push(expr);
         }
 
@@ -90,64 +62,14 @@ function extractJS(input: string): string[] {
       }
     }
 
-    // attr="..."
-    if (ch === "=" && (input[i + 1] === '"' || input[i + 1] === "'")) {
-      const quote = input[i + 1];
-      let j = i + 2;
-      let val = "";
-
-      while (j < len) {
-        const c = input[j];
-
-        if (c === "\\" && input[j + 1]) {
-          val += c + input[j + 1];
-          j += 2;
-          continue;
-        }
-
-        if (c === quote) break;
-
-        val += c;
-        j++;
-      }
-
-      if (
-        val.trim() &&
-        (val.includes("(") ||
-          val.includes("=>") ||
-          val.includes("track"))
-      ) {
-        result.push(val.trim());
-      }
-
-      i = j + 1;
-      continue;
-    }
-
     i++;
   }
 
-  // Vue / Svelte / JSX handlers
-  const extra = [
-    /@[\w-]+\s*=\s*["']([\s\S]*?)["']/g,
-    /v-on:[\w-]+\s*=\s*["']([\s\S]*?)["']/g,
-    /on:[\w-]+\s*=\s*{([\s\S]*?)}/g,
-    /on\w+\s*=\s*{([\s\S]*?)}/g,
-  ];
-
-  for (const r of extra) {
-    const m = input.matchAll(r);
-    for (const x of m) {
-      const v = x[1]?.trim();
-      if (v) result.push(v);
-    }
-  }
-
   return result;
 }
 
 /**
- * Extract loose JS but less noisy
+ * Loose JS extractor
  */
 function extractLooseJS(input: string): string[] {
   const result: string[] = [];
@@ -160,14 +82,7 @@ function extractLooseJS(input: string): string[] {
     if (!l) continue;
     if (l.startsWith("<")) continue;
 
-    // strict filter
-    if (
-      l.includes("track") ||
-      l.includes(".track(") ||
-      l.includes("=>") ||
-      l.startsWith("function") ||
-      l.includes("(")
-    ) {
+    if (/[a-zA-Z0-9_$]\s*\(/.test(l)) {
       result.push(l);
     }
   }
@@ -176,7 +91,14 @@ function extractLooseJS(input: string): string[] {
 }
 
 /**
- * Universal parser
+ * UNIVERSAL PARSER
+ * Support:
+ * - React / JSX
+ * - Vue
+ * - Svelte
+ * - Astro
+ * - HTML + JS
+ * - SSR
  */
 export function parseUniversal(
   content: string,
@@ -187,9 +109,11 @@ export function parseUniversal(
 
   const clean = stripComments(content);
 
-  // Astro frontmatter
+  // ASTRO FRONTMATTER
   const fm = clean.match(/^---([\s\S]*?)---/);
-  if (fm?.[1]) parts.push(fm[1]);
+  if (fm?.[1]) {
+    parts.push(fm[1]);
+  }
 
   // <script src="">
   const scriptSrc = clean.matchAll(
@@ -206,7 +130,7 @@ export function parseUniversal(
     deps.push(resolved);
   }
 
-  // inline <script>
+  // INLINE <script>
   const scripts = clean.matchAll(
     /<script\b([^>]*)>([\s\S]*?)<\/script>/g
   );
@@ -214,7 +138,7 @@ export function parseUniversal(
   for (const m of scripts) {
     const attrs = m[1];
 
-    // skip JSON / data
+    // skip JSON
     if (/type=["']application\/json/.test(attrs)) continue;
 
     if (m[2].trim()) {
@@ -222,24 +146,24 @@ export function parseUniversal(
     }
   }
 
-  // remove scripts
+  // REMOVE SCRIPTS → TEMPLATE PART
   const noScripts = clean.replace(
     /<script[\s\S]*?<\/script>/g,
     ""
   );
 
-  // loose JS
-  const loose = extractLooseJS(noScripts);
-  parts.push(...loose);
+  // LOOSE JS
+  parts.push(...extractLooseJS(noScripts));
 
-  // expressions
+  // EXPRESSIONS
   const extracted = extractJS(clean);
   for (const e of extracted) {
     parts.push(e + ";");
   }
 
+  // RESULT
   return {
     code: [...new Set(parts)].join("\n"),
-    deps,
+    deps: [...new Set(deps.filter(Boolean))],
   };
 }