@eventra_dev/eventra-cli 0.1.28 → 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;
@@ -13,25 +11,6 @@ function getCallName(expr: ts.Expression): string {
   return "";
 }
 
-function getJsxAttrName(name: ts.JsxAttributeName): string | null {
-  if (ts.isIdentifier(name)) return name.text;
-  if (ts.isJsxNamespacedName(name)) return name.name.text;
-  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 &&
@@ -42,43 +21,6 @@ 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)) {
-      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(a) && a.text === prop) ||
-          (ts.isPropertyAccessExpression(a) &&
-            a.name.text === prop)
-        ) {
-          found = true;
-        }
-      }
-    }
-
-    ts.forEachChild(node, visit);
-  }
-
-  if (fn.body) {
-    visit(fn.body);
-  }
-
-  return found;
-}
-
 export type ScanResult = {
   events: Set<string>;
   detectedFunctionWrappers: Set<string>;
@@ -90,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>();
@@ -104,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);
 
@@ -112,50 +52,28 @@ export function scanSource(
         w => w.name === name
       );
 
-      const isTrackingByType = isTrackingCall(node, checker);
-
-      let resolvedFn = resolveFunctionFromCall(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 ||
-        isAutoWrapper ||
-        name.startsWith("$");
-
-      // fallback track(...)
-      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;
-        }
-      }
+        (isAutoWrapper &&
+          resolvedFn &&
+          !isExternalFile(resolvedFn.getSourceFile().fileName));
 
       if (!isTracking) {
         ts.forEachChild(node, visit);
         return;
       }
 
-      // DETECT WRAPPERS
-      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)) {
@@ -169,9 +87,7 @@ export function scanSource(
         });
       }
 
-      let handled = false;
-
-      // MAIN RESOLVE
+      // ✅ ТОЛЬКО правильный аргумент
       if (resolvedFn) {
         const idx = findTrackParamIndex(resolvedFn);
 
@@ -182,22 +98,11 @@ export function scanSource(
             paramMap
           );
 
-          res.values.forEach(v => {
-            if (isValidEvent(v)) events.add(v);
-          });
-
-          handled = true;
-        }
-      }
-
-      // fallback
-      if (!handled) {
-        for (const arg of node.arguments) {
-          const res = resolveNodeValue(arg, checker, paramMap);
-
-          res.values.forEach(v => {
-            if (isValidEvent(v)) events.add(v);
-          });
+          for (const v of res.values) {
+            if (isValidEvent(v)) {
+              events.add(v);
+            }
+          }
         }
       }
 
@@ -211,7 +116,6 @@ export function scanSource(
             checker,
             config,
             visited,
-            depth + 1,
             paramMap
           );
 
@@ -220,100 +124,6 @@ export function scanSource(
       }
     }
 
-    // JSX
-    if (
-      ts.isJsxSelfClosingElement(node) ||
-      ts.isJsxOpeningElement(node)
-    ) {
-      const tagNode =
-        ts.isPropertyAccessExpression(node.tagName)
-          ? node.tagName.name
-          : node.tagName;
-
-      let symbol = checker.getSymbolAtLocation(tagNode);
-
-      if (symbol) {
-        symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
-      }
-
-      if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
-        symbol = checker.getAliasedSymbol(symbol);
-      }
-
-      if (!symbol) {
-        ts.forEachChild(node, visit);
-        return;
-      }
-
-      const tagName =
-        ts.isPropertyAccessExpression(node.tagName)
-          ? node.tagName.name.getText()
-          : node.tagName.getText();
-
-      for (const decl of symbol.getDeclarations() ?? []) {
-        let fn: ts.FunctionLikeDeclaration | null = null;
-
-        if (ts.isFunctionDeclaration(decl)) fn = decl;
-
-        if (ts.isVariableDeclaration(decl) && decl.initializer) {
-          const init = decl.initializer;
-
-          if (
-            ts.isArrowFunction(init) ||
-            ts.isFunctionExpression(init)
-          ) {
-            fn = init;
-          }
-        }
-
-        if (!fn) continue;
-
-        const param = fn.parameters[0];
-        if (!param || !ts.isObjectBindingPattern(param.name)) continue;
-
-        for (const el of param.name.elements) {
-          const prop = el.name.getText();
-
-          const isEvent =
-            isPropUsedInTracking(fn, checker, prop) ||
-            config.wrappers.some(
-              w => w.name === tagName && w.prop === prop
-            );
-
-          if (!isEvent) continue;
-
-          const attr = node.attributes.properties.find(p => {
-            if (!ts.isJsxAttribute(p)) return false;
-            return getJsxAttrName(p.name) === prop;
-          }) as ts.JsxAttribute | undefined;
-
-          if (!attr || !attr.initializer) continue;
-
-          const expr = ts.isJsxExpression(attr.initializer)
-            ? attr.initializer.expression
-            : attr.initializer;
-
-          if (!expr) continue;
-
-          const paramMap = new Map<string, ts.Expression>();
-          paramMap.set(prop, expr);
-
-          const res = scanSource(
-            fn.getSourceFile(),
-            checker,
-            config,
-            visited,
-            depth + 1,
-            paramMap
-          );
-
-          res.events.forEach(e => events.add(e));
-
-          detectedComponentWrappers.set(tagName, prop);
-        }
-      }
-    }
-
     ts.forEachChild(node, visit);
   }
 

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
+  );
 
-  let inString: '"' | "'" | "`" | null = null;
-  let escape = false;
+  for (const m of matches) {
+    if (looksLikeTracking(m[1])) {
+      result.push(m[1]);
+    }
+  }
 
-  while (i < len) {
-    const ch = input[i];
+  return result;
+}
 
-    if (inString) {
-      if (escape) escape = false;
-      else if (ch === "\\") escape = true;
-      else if (ch === inString) inString = null;
-      i++;
-      continue;
-    }
+// Vue handlers (@click / v-on)
+function extractVueHandlers(input: string): string[] {
+  const result: string[] = [];
 
-    if (ch === '"' || ch === "'" || ch === "`") {
-      inString = ch;
-      i++;
-      continue;
-    }
+  const matches = input.matchAll(
+    /(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g
+  );
 
-    if (ch === "{") {
-      let depth = 1;
-      let j = i + 1;
+  for (const m of matches) {
+    if (looksLikeTracking(m[1])) {
+      result.push(m[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 handlers (onclick="...")
-function extractInlineHandlers(input: string): string[] {
+// JSX / template { ... }
+function extractJSExpressions(input: string): string[] {
   const result: string[] = [];
 
-  const regex = /\bon\w+\s*=\s*["']([^"']+)["']/g;
+  const matches = input.matchAll(/\{([^}]+)\}/g);
 
-  let match;
-  while ((match = regex.exec(input))) {
-    const code = match[1].trim();
-
-    if (code && /[a-zA-Z0-9_$]\s*\(/.test(code)) {
-      result.push(code);
+  for (const m of matches) {
+    if (looksLikeTracking(m[1])) {
+      result.push(m[1]);
     }
   }
 
   return result;
 }
 
-// Extract dynamic imports
+// dynamic import()
 function extractDynamicImports(
   input: string,
   file: string
@@ -90,47 +88,25 @@ function extractDynamicImports(
   const deps: string[] = [];
   const calls: string[] = [];
 
-  const regex = /import\(\s*["'](.+?)["']\s*\)/g;
+  const matches = input.matchAll(
+    /import\(\s*["'](.+?)["']\s*\)/g
+  );
 
-  let match;
-  while ((match = regex.exec(input))) {
-    const mod = match[1];
+  for (const m of matches) {
+    const mod = m[1];
 
     const resolved = mod.startsWith("/")
       ? path.resolve(process.cwd(), "." + mod)
       : path.resolve(path.dirname(file), mod);
 
     deps.push(resolved);
-  }
-
-  // also extract calls chained after import
-  const callRegex = /import\([^)]+\)\.then\(([^)]+)\)/g;
-
-  while ((match = callRegex.exec(input))) {
-    calls.push(match[1]);
-  }
-
-  return { deps, calls };
-}
-
-// Loose JS extractor
-function extractLooseJS(input: string): string[] {
-  const result: string[] = [];
-
-  const lines = input.split("\n");
 
-  for (const line of lines) {
-    const l = line.trim();
-
-    if (!l) continue;
-    if (l.startsWith("<")) continue;
-
-    if (/[a-zA-Z0-9_$]\s*\(/.test(l)) {
-      result.push(l);
+    if (looksLikeTracking(mod)) {
+      calls.push(`import("${mod}")`);
     }
   }
 
-  return result;
+  return { deps, calls };
 }
 
 // UNIVERSAL PARSER
@@ -170,38 +146,30 @@ 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
   const noScripts = clean.replace(
     /<script[\s\S]*?<\/script>/g,
     ""
   );
 
-  // INLINE HANDLERS
-  parts.push(...extractInlineHandlers(noScripts));
+  // handlers
+  parts.push(...extractHTMLHandlers(noScripts));
+  parts.push(...extractVueHandlers(noScripts));
+  parts.push(...extractSvelteHandlers(noScripts));
+
+  // JSX / Astro / Vue expressions
+  parts.push(...extractJSExpressions(clean));
 
-  // DYNAMIC IMPORTS
+  // dynamic imports
   const dyn = extractDynamicImports(clean, file);
   deps.push(...dyn.deps);
   parts.push(...dyn.calls);
 
-  // LOOSE JS
-  parts.push(...extractLooseJS(noScripts));
-
-  // EXPRESSIONS
-  const extracted = extractJS(clean);
-  for (const e of extracted) {
-    parts.push(e + ";");
-  }
-
   return {
     code: [...new Set(parts)].join("\n"),
     deps: [...new Set(deps.filter(Boolean))],