@eventra_dev/eventra-cli 0.1.24 → 0.1.26

package/src/engine/resolver.ts

@@ -12,12 +12,13 @@ export function resolveNodeValue(
   paramMap?: Map<string, ts.Expression>,
   seen = new Set<ts.Node>()
 ): ResolveResult {
+
   if (seen.has(node)) {
     return { values: [], dynamic: true };
   }
   seen.add(node);
 
-  // param mapping
+  // PARAM MAPPING
   if (ts.isIdentifier(node) && paramMap?.has(node.text)) {
     return resolveNodeValue(
       paramMap.get(node.text)!,
@@ -43,12 +44,15 @@ export function resolveNodeValue(
       }
     }
 
-    return { values, dynamic: true };
+    return {
+      values: [...new Set(values)],
+      dynamic: true
+    };
   }
 
   // TEMPLATE
   if (ts.isTemplateExpression(node)) {
-    let results = [node.head.text];
+    let results = node.head.text ? [node.head.text] : [""];
 
     for (const span of node.templateSpans) {
       const res = resolveNodeValue(span.expression, checker, paramMap, seen);
@@ -83,14 +87,7 @@ export function resolveNodeValue(
     let symbol = checker.getSymbolAtLocation(node);
     if (!symbol) return { values: [], dynamic: true };
 
-    // unwrap export
-    symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
-
-    if (symbol.flags & ts.SymbolFlags.Alias) {
-      symbol = checker.getAliasedSymbol(symbol);
-    }
-
-    // inline variable
+    // INLINE FIRST
     for (const decl of symbol.getDeclarations() ?? []) {
       if (ts.isVariableDeclaration(decl) && decl.initializer) {
         return resolveNodeValue(
@@ -100,7 +97,16 @@ export function resolveNodeValue(
           seen
         );
       }
+    }
+
+    // unwrap export
+    symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
+
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+      symbol = checker.getAliasedSymbol(symbol);
+    }
 
+    for (const decl of symbol.getDeclarations() ?? []) {
       if (ts.isEnumMember(decl) && decl.initializer) {
         if (ts.isStringLiteral(decl.initializer)) {
           return {
@@ -111,15 +117,15 @@ export function resolveNodeValue(
       }
     }
 
-    // UNION TYPES
     const type = checker.getTypeAtLocation(node);
 
+    // UNION
     if (type.isUnion()) {
       const values: string[] = [];
 
       for (const t of type.types) {
-        if ((t as any).isStringLiteral?.()) {
-          values.push((t as any).value);
+        if (t.flags & ts.TypeFlags.StringLiteral) {
+          values.push((t as ts.StringLiteralType).value);
         }
       }
 
@@ -128,15 +134,18 @@ export function resolveNodeValue(
       }
     }
 
-    // TYPE FALLBACK (as const)
-    if ((type as any).isStringLiteral?.()) {
-      return { values: [(type as any).value], dynamic: false };
+    // STRING LITERAL TYPE
+    if (type.flags & ts.TypeFlags.StringLiteral) {
+      return {
+        values: [(type as ts.StringLiteralType).value],
+        dynamic: false
+      };
     }
 
     return { values: [], dynamic: true };
   }
 
-  // PROPERTY ACCESS (obj.a.b)
+  // PROPERTY ACCESS
   if (ts.isPropertyAccessExpression(node)) {
 
     const symbol = checker.getSymbolAtLocation(node);
@@ -160,18 +169,16 @@ export function resolveNodeValue(
       }
     }
 
-    // constant enum / readonly
     const constantValue = checker.getConstantValue(node as any);
     if (typeof constantValue === "string") {
       return { values: [constantValue], dynamic: false };
     }
 
-    // type fallback
     const type = checker.getTypeAtLocation(node);
 
-    if ((type as any).isStringLiteral?.()) {
+    if (type.flags & ts.TypeFlags.StringLiteral) {
       return {
-        values: [(type as any).value],
+        values: [(type as ts.StringLiteralType).value],
         dynamic: false,
       };
     }
@@ -206,10 +213,11 @@ export function resolveNodeValue(
       }
     }
 
-    return { values: [], dynamic: true };
+    // fallback
+    return resolveNodeValue(node.name, checker, paramMap, seen);
   }
 
-  // ARRAY ACCESS (arr[0])
+  // ARRAY ACCESS
   if (ts.isElementAccessExpression(node)) {
     const obj = resolveNodeValue(node.expression, checker, paramMap, seen);
 
@@ -224,7 +232,6 @@ export function resolveNodeValue(
       seen
     );
 
-    // if index known
     if (index.values.length === 1) {
       const i = Number(index.values[0]);
 
@@ -236,7 +243,6 @@ export function resolveNodeValue(
       }
     }
 
-    // fallback → dynamic
     return obj.values.length
       ? { values: obj.values, dynamic: true }
       : { values: [], dynamic: true };
@@ -257,7 +263,10 @@ export function resolveNodeValue(
       }
     }
 
-    return { values, dynamic: true };
+    return {
+      values: [...new Set(values)],
+      dynamic: true
+    };
   }
 
   // BINARY ("btn_" + name)

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/getVirtualFile.ts

@@ -0,0 +1,5 @@
+export function getVirtualFile(file: string) {
+  return /\.(vue|svelte|astro|html)$/i.test(file)
+    ? file + ".tsx"
+    : file;
+}

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))],
   };
 }