@eventra_dev/eventra-cli 0.1.25 → 0.1.26

package/src/engine/exportResolver.ts

@@ -1,5 +1,13 @@
 import ts from "typescript";
 
+function isRealDeclaration(node: ts.Node) {
+  return (
+    ts.isFunctionDeclaration(node) ||
+    ts.isVariableDeclaration(node) ||
+    ts.isClassDeclaration(node)
+  );
+}
+
 export function resolveExportedSymbol(
   symbol: ts.Symbol,
   checker: ts.TypeChecker,
@@ -8,20 +16,29 @@ export function resolveExportedSymbol(
 
   if (visited.has(symbol)) return null;
   visited.add(symbol);
+
+  // unwrap alias
   if (symbol.flags & ts.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     return resolveExportedSymbol(aliased, checker, visited);
   }
 
-  if (symbol.getDeclarations()?.length) {
-    return symbol;
+  // export symbol
+  const exportSymbol = checker.getExportSymbolOfSymbol(symbol);
+  if (exportSymbol && exportSymbol !== symbol) {
+    return resolveExportedSymbol(exportSymbol, checker, visited);
   }
 
-  const declarations = symbol.getDeclarations() ?? [];
+  const decls = symbol.getDeclarations() ?? [];
+
+  if (decls.some(isRealDeclaration)) {
+    return symbol;
+  }
 
-  for (const decl of declarations) {
+  // exports (re-export)
+  for (const decl of decls) {
     const source = decl.getSourceFile();
-    const moduleSymbol = checker.getSymbolAtLocation(source);
+    const moduleSymbol = (source as any).symbol;
 
     if (!moduleSymbol) continue;
 

package/src/engine/functionAnalyzer.ts

@@ -8,24 +8,95 @@ export function findTrackParamIndex(
   fn.parameters.forEach((p, i) => {
     if (ts.isIdentifier(p.name)) {
       paramIndex.set(p.name.text, i);
+
+      // default param: (name = "x")
+      if (p.initializer && ts.isStringLiteral(p.initializer)) {
+        if (i === 0) return 0;
+      }
     }
   });
 
   let result: number | null = null;
 
+  function unwrap(node: ts.Expression): ts.Expression {
+    // as / parentheses
+    while (
+      ts.isAsExpression(node) ||
+      ts.isParenthesizedExpression(node)
+      ) {
+      node = node.expression;
+    }
+    return node;
+  }
+
+  function checkArg(arg: ts.Expression) {
+    arg = unwrap(arg);
+
+    // identifier → param
+    if (ts.isIdentifier(arg)) {
+      const idx = paramIndex.get(arg.text);
+      if (idx !== undefined) {
+        result = idx;
+        return true;
+      }
+    }
+
+    // string literal
+    if (ts.isStringLiteral(arg)) {
+      result = 0;
+      return true;
+    }
+
+    // template `${name}`
+    if (ts.isTemplateExpression(arg)) {
+      for (const span of arg.templateSpans) {
+        if (ts.isIdentifier(span.expression)) {
+          const idx = paramIndex.get(span.expression.text);
+          if (idx !== undefined) {
+            result = idx;
+            return true;
+          }
+        }
+      }
+      result = 0;
+      return true;
+    }
+
+    // object { event: name }
+    if (ts.isObjectLiteralExpression(arg)) {
+      for (const prop of arg.properties) {
+        if (!ts.isPropertyAssignment(prop)) continue;
+
+        const name = prop.name.getText();
+
+        if (["event", "name", "type"].includes(name)) {
+          return checkArg(prop.initializer);
+        }
+      }
+    }
+
+    // call: String(name)
+    if (ts.isCallExpression(arg)) {
+      for (const inner of arg.arguments) {
+        if (checkArg(inner)) return true;
+      }
+    }
+
+    return false;
+  }
+
   function visit(node: ts.Node) {
+    if (result !== null) return;
+
     if (ts.isCallExpression(node)) {
       let isTrackCall = false;
 
       if (ts.isPropertyAccessExpression(node.expression)) {
-        const method = node.expression.name.text;
-
-        if (method === "track") {
+        if (node.expression.name.text === "track") {
           isTrackCall = true;
         }
       }
 
-      // fallback
       if (ts.isIdentifier(node.expression)) {
         if (node.expression.text === "track") {
           isTrackCall = true;
@@ -34,18 +105,7 @@ export function findTrackParamIndex(
 
       if (isTrackCall) {
         for (const arg of node.arguments) {
-          if (ts.isIdentifier(arg)) {
-            const idx = paramIndex.get(arg.text);
-            if (idx !== undefined) {
-              result = idx;
-              return;
-            }
-          }
-
-          if (ts.isStringLiteral(arg)) {
-            result = 0;
-            return;
-          }
+          if (checkArg(arg)) return;
         }
       }
     }

package/src/engine/graph.ts

@@ -13,15 +13,18 @@ export class DependencyGraph {
   ) {}
 
   private normalize(file: string) {
-    return path.resolve(file);
+    return path.resolve(file).replace(/\\/g, "/");
   }
 
+  // MODULE RESOLVE
   private resolveModule(module: string, from: string): string | null {
+    // relative import
     if (module.startsWith(".")) {
       const abs = path.resolve(path.dirname(from), module);
       return this.resolveFile(abs);
     }
 
+    // tsconfig paths
     for (const key in this.paths) {
       const pattern = key.replace(/\*/g, "(.*)");
       const regex = new RegExp("^" + pattern + "$");
@@ -44,10 +47,21 @@ export class DependencyGraph {
       }
     }
 
+    // node resolution (safe)
+    try {
+      const resolved = require.resolve(module, {
+        paths: [path.dirname(from)],
+      });
+
+      return this.normalize(resolved);
+    } catch {}
+
+    // fallback
     const abs = path.resolve(this.baseUrl, module);
     return this.resolveFile(abs);
   }
 
+  // FILE RESOLVE
   private resolveFile(base: string): string | null {
     if (this.fileCache.has(base)) {
       return this.fileCache.get(base)!;
@@ -59,6 +73,12 @@ export class DependencyGraph {
       base + ".tsx",
       base + ".js",
       base + ".jsx",
+      base + ".mjs",
+      base + ".cjs",
+      base + ".d.ts",
+      base + ".vue",
+      base + ".svelte",
+      base + ".astro",
       path.join(base, "index.ts"),
       path.join(base, "index.tsx"),
       path.join(base, "index.js"),
@@ -76,16 +96,28 @@ export class DependencyGraph {
     return null;
   }
 
+  // UPDATE GRAPH
   update(file: string, source: ts.SourceFile) {
     const normalizedFile = this.normalize(file);
 
+    for (const deps of this.reverse.values()) {
+      deps.delete(normalizedFile);
+    }
+
     this.exports.set(normalizedFile, new Set());
 
     for (const stmt of source.statements) {
+
+      // IMPORT
       if (ts.isImportDeclaration(stmt)) {
-        const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
-        const resolved = this.resolveModule(module, normalizedFile);
+        // ignore import type
+        if ((stmt.importClause as any)?.importKind === "type") continue;
+
+        const module = stmt.moduleSpecifier
+          .getText()
+          .replace(/['"]/g, "");
 
+        const resolved = this.resolveModule(module, normalizedFile);
         if (!resolved) continue;
 
         if (!this.reverse.has(resolved)) {
@@ -95,10 +127,15 @@ export class DependencyGraph {
         this.reverse.get(resolved)!.add(normalizedFile);
       }
 
-      if (ts.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
-        const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
-        const resolved = this.resolveModule(module, normalizedFile);
+      // EXPORT (re-export)
+      if (ts.isExportDeclaration(stmt)) {
+        if (!stmt.moduleSpecifier) continue;
+
+        const module = stmt.moduleSpecifier
+          .getText()
+          .replace(/['"]/g, "");
 
+        const resolved = this.resolveModule(module, normalizedFile);
         if (!resolved) continue;
 
         this.exports.get(normalizedFile)?.add(resolved);
@@ -112,6 +149,7 @@ export class DependencyGraph {
     }
   }
 
+  // DEPENDENTS
   getAllDependentsDeep(file: string): string[] {
     const start = this.normalize(file);
     const visited = new Set<string>();
@@ -136,6 +174,7 @@ export class DependencyGraph {
     return [...result];
   }
 
+  // REMOVE
   remove(file: string) {
     const normalized = this.normalize(file);
 

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)