@eventra_dev/eventra-cli 0.1.25 → 0.1.27

package/src/engine/languageService.ts

@@ -7,9 +7,12 @@ export class TSService {
   private fileNames = new Set<string>();
   private service: ts.LanguageService;
 
-  private readonly compilerOptions: ts.CompilerOptions = {};
-  private readonly baseUrl: string = "";
-  private readonly paths: Record<string, string[]> = {};
+  private compilerOptions: ts.CompilerOptions;
+  private baseUrl: string;
+  private paths: Record<string, string[]>;
+  private usage = new Map<string, number>();
+  private tick = 0;
+  private MAX_FILES = 2000;
 
   constructor(private root: string) {
     const configPath = ts.findConfigFile(
@@ -20,13 +23,18 @@ export class TSService {
 
     let compilerOptions: ts.CompilerOptions = {
       allowJs: true,
-      jsx: ts.JsxEmit.Preserve,
+      jsx: ts.JsxEmit.React,
+      jsxImportSource: "react",
       moduleResolution: ts.ModuleResolutionKind.Node16,
       target: ts.ScriptTarget.ESNext,
       esModuleInterop: true,
       allowSyntheticDefaultImports: true,
+      skipLibCheck: true,
     };
 
+    let baseUrl = root;
+    let paths: Record<string, string[]> = {};
+
     if (configPath) {
       const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
 
@@ -41,56 +49,108 @@ export class TSService {
         ...parsed.options,
       };
 
-      this.paths = parsed.options.paths || {};
-      this.baseUrl = parsed.options.baseUrl
+      paths = parsed.options.paths || {};
+      baseUrl = parsed.options.baseUrl
         ? path.resolve(root, parsed.options.baseUrl)
         : root;
-    } else {
-      this.baseUrl = root;
     }
 
     this.compilerOptions = compilerOptions;
+    this.baseUrl = baseUrl;
+    this.paths = paths;
 
     const host: ts.LanguageServiceHost = {
-      getScriptFileNames: () => {
-        return [...new Set(this.fileNames)].sort((a, b) =>
-          a.localeCompare(b)
-        );
-      },
+      getScriptFileNames: () => Array.from(this.fileNames),
 
-      getScriptVersion: (file) =>
-        this.files.get(file)?.version.toString() ?? "0",
+      getScriptVersion: (file) => {
+        file = this.normalize(file);
+        return this.files.get(file)?.version.toString() ?? "0";
+      },
 
       getScriptSnapshot: (file) => {
-        const f = this.files.get(file);
+        file = this.normalize(file);
 
+        const f = this.files.get(file);
         if (f) {
+          this.touch(file);
           return ts.ScriptSnapshot.fromString(f.content);
         }
 
-        if (fs.existsSync(file)) {
-          return ts.ScriptSnapshot.fromString(
-            fs.readFileSync(file, "utf-8")
-          );
-        }
+        try {
+          if (fs.existsSync(file)) {
+            const content = fs.readFileSync(file, "utf-8");
+
+            this.files.set(file, {
+              content,
+              version: 1,
+            });
+
+            this.fileNames.add(file);
+            this.touch(file);
+            this.evictIfNeeded();
 
-        return undefined;
+            return ts.ScriptSnapshot.fromString(content);
+          }
+        } catch {}
+
+        // fallback
+        return ts.ScriptSnapshot.fromString("");
       },
 
       getCurrentDirectory: () => this.root,
       getCompilationSettings: () => this.compilerOptions,
       getDefaultLibFileName: (opts) =>
         ts.getDefaultLibFilePath(opts),
-
-      readFile: ts.sys.readFile,
       fileExists: ts.sys.fileExists,
+      readFile: ts.sys.readFile,
       readDirectory: ts.sys.readDirectory,
     };
 
     this.service = ts.createLanguageService(host);
   }
 
+  // INTERNAL
+  private normalize(file: string) {
+    return path.resolve(file).replace(/\\/g, "/");
+  }
+
+  private touch(file: string) {
+    this.tick++;
+    this.usage.set(file, this.tick);
+  }
+
+  private evictIfNeeded() {
+    if (this.fileNames.size <= this.MAX_FILES) return;
+
+    let oldestFile: string | null = null;
+    let oldestTick = Infinity;
+
+    for (const f of this.fileNames) {
+      const t = this.usage.get(f) ?? 0;
+
+      if (t < oldestTick) {
+        oldestTick = t;
+        oldestFile = f;
+      }
+    }
+
+    if (oldestFile) {
+      this.files.delete(oldestFile);
+      this.fileNames.delete(oldestFile);
+      this.usage.delete(oldestFile);
+    }
+  }
+
+  private ensureProgram() {
+    try {
+      this.service.getProgram();
+    } catch {}
+  }
+
+  // PUBLIC API
   updateFile(file: string, content: string) {
+    file = this.normalize(file);
+
     const prev = this.files.get(file);
 
     this.files.set(file, {
@@ -99,6 +159,20 @@ export class TSService {
     });
 
     this.fileNames.add(file);
+    this.touch(file);
+    this.evictIfNeeded();
+
+    this.ensureProgram();
+  }
+
+  removeFile(file: string) {
+    file = this.normalize(file);
+
+    this.files.delete(file);
+    this.fileNames.delete(file);
+    this.usage.delete(file);
+
+    this.ensureProgram();
   }
 
   getProgram() {
@@ -110,18 +184,15 @@ export class TSService {
   }
 
   getSourceFile(file: string) {
+    file = this.normalize(file);
     return this.getProgram()?.getSourceFile(file);
   }
 
   getFileContent(file: string) {
+    file = this.normalize(file);
     return this.files.get(file)?.content;
   }
 
-  removeFile(file: string) {
-    this.files.delete(file);
-    this.fileNames.delete(file);
-  }
-
   getModuleResolutionConfig() {
     return {
       baseUrl: this.baseUrl,

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;