@eventra_dev/eventra-cli 0.1.32 → 0.1.34

package/src/engine/languageService.ts

@@ -7,13 +7,9 @@ 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 usage = new Map<string, number>();
-  private tick = 0;
-  private MAX_FILES = 2000;
+  private compilerOptions: ts.CompilerOptions;
+  private baseUrl: string;
+  private paths: Record<string, string[]>;
 
   constructor(private root: string) {
     const configPath = ts.findConfigFile(
@@ -61,16 +57,19 @@ export class TSService {
     this.baseUrl = baseUrl;
     this.paths = paths;
 
+    const allFiles = ts.sys.readDirectory(
+      root,
+      [".ts", ".tsx", ".js", ".jsx"],
+      undefined,
+      undefined
+    );
+
+    for (const f of allFiles) {
+      this.fileNames.add(this.normalize(f));
+    }
+
     const host: ts.LanguageServiceHost = {
       getScriptFileNames: () => {
-        if (this.fileNames.size === 0) {
-          return ts.sys.readDirectory(
-            this.root,
-            [".ts", ".tsx", ".js", ".jsx"],
-            undefined,
-            undefined
-          );
-        }
         return Array.from(this.fileNames);
       },
 
@@ -81,11 +80,14 @@ export class TSService {
 
       getScriptSnapshot: (file) => {
         file = this.normalize(file);
+
+        // из памяти
         const f = this.files.get(file);
         if (f) {
-          this.touch(file);
           return ts.ScriptSnapshot.fromString(f.content);
         }
+
+        // virtual TSX (vue/svelte/astro)
         if (file.endsWith(".tsx")) {
           const original = file.replace(/\.tsx$/, "");
 
@@ -98,12 +100,11 @@ export class TSService {
             });
 
             this.fileNames.add(file);
-            this.touch(file);
-            this.evictIfNeeded();
 
             return ts.ScriptSnapshot.fromString(content);
           }
         }
+
         try {
           if (fs.existsSync(file)) {
             const content = fs.readFileSync(file, "utf-8");
@@ -114,8 +115,6 @@ export class TSService {
             });
 
             this.fileNames.add(file);
-            this.touch(file);
-            this.evictIfNeeded();
 
             return ts.ScriptSnapshot.fromString(content);
           }
@@ -123,10 +122,12 @@ export class TSService {
 
         return ts.ScriptSnapshot.fromString("");
       },
+
       getCurrentDirectory: () => this.root,
       getCompilationSettings: () => this.compilerOptions,
       getDefaultLibFileName: (opts) =>
         ts.getDefaultLibFilePath(opts),
+
       fileExists: (file) => {
         file = this.normalize(file);
         return this.files.has(file) || ts.sys.fileExists(file);
@@ -143,41 +144,13 @@ export class TSService {
     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 oldest: string | null = null;
-    let oldestTick = Infinity;
-
-    for (const f of this.fileNames) {
-      const t = this.usage.get(f) ?? 0;
-
-      if (t < oldestTick) {
-        oldestTick = t;
-        oldest = f;
-      }
-    }
-
-    if (oldest) {
-      this.files.delete(oldest);
-      this.fileNames.delete(oldest);
-      this.usage.delete(oldest);
-    }
-  }
-
   private ensureProgram() {
     try {
-      this.service.getProgram()?.getTypeChecker();
+      this.service.getProgram();
     } catch {}
   }
 
@@ -193,8 +166,6 @@ export class TSService {
     });
 
     this.fileNames.add(file);
-    this.touch(file);
-    this.evictIfNeeded();
 
     this.ensureProgram();
   }
@@ -204,7 +175,6 @@ export class TSService {
 
     this.files.delete(file);
     this.fileNames.delete(file);
-    this.usage.delete(file);
 
     this.ensureProgram();
   }

package/src/engine/resolver.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 import { resolveExportedSymbol } from "./exportResolver";
+import { resolveFunctionFromCall } from "./callResolver";
 
 export type ResolveResult = {
   values: string[];
@@ -12,167 +13,139 @@ export function resolveNodeValue(
   paramMap?: Map<string, ts.Expression>,
   seen = new Set<ts.Node>()
 ): ResolveResult {
-  if (seen.has(node)) {
-    return { values: [], dynamic: true };
-  }
+  if (seen.has(node)) return { values: [], dynamic: true };
   seen.add(node);
 
-  // PARAM MAP (wrapper args)
+  // param passthrough
   if (ts.isIdentifier(node) && paramMap?.has(node.text)) {
-    return resolveNodeValue(
-      paramMap.get(node.text)!,
-      checker,
-      paramMap,
-      seen
-    );
+    return resolveNodeValue(paramMap.get(node.text)!, checker, paramMap, seen);
   }
 
-  // STRING
+  // string
   if (ts.isStringLiteral(node)) {
     return { values: [node.text], dynamic: false };
   }
 
-  // TEMPLATE
+  // template
   if (ts.isTemplateExpression(node)) {
     let results = node.head.text ? [node.head.text] : [""];
-
     for (const span of node.templateSpans) {
-      const res = resolveNodeValue(
-        span.expression,
-        checker,
-        paramMap,
-        seen
-      );
-
-      results = results.flatMap(r =>
-        res.values.length
-          ? res.values.map(v => r + v)
-          : [r + "*"]
+      const r = resolveNodeValue(span.expression, checker, paramMap, seen);
+      results = results.flatMap(s =>
+        r.values.length ? r.values.map(v => s + v) : [s + "*"]
       );
-
-      results = results.map(r => r + span.literal.text);
+      results = results.map(s => s + span.literal.text);
     }
-
     return { values: results, dynamic: true };
   }
 
-  // CONDITIONAL (a ? b : c)
+  // ternary
   if (ts.isConditionalExpression(node)) {
     const a = resolveNodeValue(node.whenTrue, checker, paramMap, seen);
     const b = resolveNodeValue(node.whenFalse, checker, paramMap, seen);
-
     return {
       values: [...new Set([...a.values, ...b.values])],
       dynamic: true,
     };
   }
 
-  // OBJECT → берём ВСЕ значения (без привязки к ключам)
+  // object (event/name priority)
   if (ts.isObjectLiteralExpression(node)) {
-    const values: string[] = [];
-
-    for (const prop of node.properties) {
-      if (!ts.isPropertyAssignment(prop)) continue;
-
-      const res = resolveNodeValue(
-        prop.initializer,
-        checker,
-        paramMap,
-        seen
-      );
-
-      values.push(...res.values);
+    for (const p of node.properties) {
+      if (ts.isPropertyAssignment(p)) {
+        const key = p.name.getText();
+        if (key === "event" || key === "name") {
+          return resolveNodeValue(p.initializer, checker, paramMap, seen);
+        }
+      }
     }
-
-    return {
-      values: [...new Set(values)],
-      dynamic: true,
-    };
+    const vals: string[] = [];
+    for (const p of node.properties) {
+      if (!ts.isPropertyAssignment(p)) continue;
+      const r = resolveNodeValue(p.initializer, checker, paramMap, seen);
+      vals.push(...r.values);
+    }
+    return { values: [...new Set(vals)], dynamic: true };
   }
 
-  // ARRAY
+  // array
   if (ts.isArrayLiteralExpression(node)) {
-    const values: string[] = [];
-
+    const vals: string[] = [];
     for (const el of node.elements) {
-      const res = resolveNodeValue(el, checker, paramMap, seen);
-      values.push(...res.values);
+      const r = resolveNodeValue(el, checker, paramMap, seen);
+      vals.push(...r.values);
     }
+    return { values: [...new Set(vals)], dynamic: true };
+  }
 
+  // concat
+  if (ts.isBinaryExpression(node) &&
+    node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+    const l = resolveNodeValue(node.left, checker, paramMap, seen);
+    const r = resolveNodeValue(node.right, checker, paramMap, seen);
     return {
-      values: [...new Set(values)],
+      values: l.values.flatMap(a =>
+        r.values.length ? r.values.map(b => a + b) : [a + "*"]
+      ),
       dynamic: true,
     };
   }
 
-  // BINARY CONCAT
-  if (ts.isBinaryExpression(node)) {
-    if (node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
-      const left = resolveNodeValue(node.left, checker, paramMap, seen);
-      const right = resolveNodeValue(node.right, checker, paramMap, seen);
-
-      return {
-        values: left.values.flatMap(l =>
-          right.values.length
-            ? right.values.map(r => l + r)
-            : [l + "*"]
-        ),
-        dynamic: true,
-      };
-    }
-  }
-
-  // IDENTIFIER
+  // identifier (const / enum)
   if (ts.isIdentifier(node)) {
-    let symbol = checker.getSymbolAtLocation(node);
-    if (!symbol) return { values: [], dynamic: true };
-
-    symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
-
-    // const VAR = "click"
-    for (const decl of symbol.getDeclarations() ?? []) {
-      if (ts.isVariableDeclaration(decl) && decl.initializer) {
-        return resolveNodeValue(
-          decl.initializer,
-          checker,
-          paramMap,
-          seen
-        );
-      }
+    let s = checker.getSymbolAtLocation(node);
+    if (!s) return { values: [], dynamic: true };
 
-      // enum
-      if (ts.isEnumMember(decl) && decl.initializer) {
-        if (ts.isStringLiteral(decl.initializer)) {
-          return {
-            values: [decl.initializer.text],
-            dynamic: false,
-          };
-        }
+    s = resolveExportedSymbol(s, checker) ?? s;
+
+    for (const d of s.getDeclarations() ?? []) {
+      if (ts.isVariableDeclaration(d) && d.initializer) {
+        return resolveNodeValue(d.initializer, checker, paramMap, seen);
+      }
+      if (ts.isEnumMember(d) && d.initializer && ts.isStringLiteral(d.initializer)) {
+        return { values: [d.initializer.text], dynamic: false };
       }
     }
-
     return { values: [], dynamic: true };
   }
 
-  // PROPERTY ACCESS (ENUM / CONST)
+  // PROPERTY ACCESS (OBJECT + ENUM)
   if (ts.isPropertyAccessExpression(node)) {
-    const symbol = checker.getSymbolAtLocation(node);
-
-    if (symbol) {
-      let s = resolveExportedSymbol(symbol, checker) ?? symbol;
-
-      if (s.flags & ts.SymbolFlags.Alias) {
-        s = checker.getAliasedSymbol(s);
+    const obj = node.expression;
+    const prop = node.name.text;
+
+    // object literal lookup
+    if (ts.isIdentifier(obj)) {
+      const sym = checker.getSymbolAtLocation(obj);
+      if (sym) {
+        const s = resolveExportedSymbol(sym, checker) ?? sym;
+        for (const d of s.getDeclarations() ?? []) {
+          if (
+            ts.isVariableDeclaration(d) &&
+            d.initializer &&
+            ts.isObjectLiteralExpression(d.initializer)
+          ) {
+            for (const p of d.initializer.properties) {
+              if (
+                ts.isPropertyAssignment(p) &&
+                p.name.getText() === prop
+              ) {
+                return resolveNodeValue(p.initializer, checker, paramMap, seen);
+              }
+            }
+          }
+        }
       }
+    }
 
-      for (const decl of s.getDeclarations() ?? []) {
-        if (ts.isEnumMember(decl) && decl.initializer) {
-          if (ts.isStringLiteral(decl.initializer)) {
-            return {
-              values: [decl.initializer.text],
-              dynamic: false,
-            };
-          }
+    // enum fallback
+    const sym = checker.getSymbolAtLocation(node);
+    if (sym) {
+      let s = resolveExportedSymbol(sym, checker) ?? sym;
+      if (s.flags & ts.SymbolFlags.Alias) s = checker.getAliasedSymbol(s);
+      for (const d of s.getDeclarations() ?? []) {
+        if (ts.isEnumMember(d) && d.initializer && ts.isStringLiteral(d.initializer)) {
+          return { values: [d.initializer.text], dynamic: false };
         }
       }
     }
@@ -180,18 +153,24 @@ export function resolveNodeValue(
     return { values: [], dynamic: true };
   }
 
-  // CALL → unwrap args
+  // CALL (unwrap + dive into wrapper body)
   if (ts.isCallExpression(node)) {
-    const values: string[] = [];
+    const vals: string[] = [];
+
+    // args
+    for (const a of node.arguments) {
+      const r = resolveNodeValue(a, checker, paramMap, seen);
+      vals.push(...r.values);
+    }
 
-    for (const arg of node.arguments) {
-      const res = resolveNodeValue(arg, checker, paramMap, seen);
-      values.push(...res.values);
+    // dive into called function (wrapper support)
+    const fn = resolveFunctionFromCall(node.expression, checker);
+    if (fn?.body) {
+      const r = resolveNodeValue(fn.body, checker, paramMap, seen);
+      vals.push(...r.values);
     }
 
-    return values.length
-      ? { values, dynamic: true }
-      : { values: [], dynamic: true };
+    return { values: [...new Set(vals)], dynamic: true };
   }
 
   return { values: [], dynamic: true };