@eventra_dev/eventra-cli 0.1.2 → 0.1.3

package/dist/engine/scanner.js

@@ -7,7 +7,9 @@ exports.scanSource = scanSource;
 const typescript_1 = __importDefault(require("typescript"));
 const resolver_1 = require("./resolver");
 const callResolver_1 = require("./callResolver");
-function scanSource(source, checker, visited = new Set()) {
+function scanSource(source, checker, visited = new Set(), depth = 0) {
+    if (depth > 5)
+        return new Set();
     const events = new Set();
     if (visited.has(source.fileName))
         return events;
@@ -16,19 +18,35 @@ function scanSource(source, checker, visited = new Set()) {
         if (typescript_1.default.isCallExpression(node)) {
             const name = getCallName(node.expression);
             if (/(track|event|capture|send)/i.test(name)) {
-                let target = node.arguments[0];
                 const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-                // 🔥 cross-file
+                // param mapping
+                let paramMap = new Map();
+                if (fn && typescript_1.default.isFunctionLike(fn)) {
+                    fn.parameters.forEach((param, index) => {
+                        const arg = node.arguments[index];
+                        if (!arg)
+                            return;
+                        if (typescript_1.default.isIdentifier(param.name)) {
+                            paramMap.set(param.name.text, arg);
+                        }
+                    });
+                }
+                // cross-file traversal
                 if (fn) {
                     const sf = fn.getSourceFile();
                     if (!visited.has(sf.fileName)) {
-                        scanSource(sf, checker, visited).forEach(e => events.add(e));
+                        scanSource(sf, checker, visited, depth + 1)
+                            .forEach(e => events.add(e));
                     }
                 }
-                if (target) {
-                    const res = (0, resolver_1.resolveNodeValue)(target, checker);
+                for (const arg of node.arguments) {
+                    const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
                     res?.values.forEach(v => {
-                        if (v && v.length > 1 && !v.includes(" ")) {
+                        if (v &&
+                            v.length > 1 &&
+                            v.length < 100 &&
+                            !v.includes(" ") &&
+                            /^[a-zA-Z0-9._:-]+$/.test(v)) {
                             events.add(v);
                         }
                     });

package/dist/utils/config.js

@@ -36,8 +36,13 @@ async function loadConfig() {
     if (!(await fs_extra_1.default.pathExists(configPath))) {
         return null;
     }
-    const config = await fs_extra_1.default.readJSON(configPath);
-    return normalizeConfig(config);
+    try {
+        const config = await fs_extra_1.default.readJSON(configPath);
+        return normalizeConfig(config);
+    }
+    catch {
+        return null;
+    }
 }
 async function saveConfig(config) {
     const configPath = path_1.default.join(process.cwd(), exports.CONFIG_NAME);

package/dist/utils/parsers/astro.js

@@ -2,5 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAstro = parseAstro;
 function parseAstro(content) {
-    return content;
+    const frontmatter = content.match(/---([\s\S]*?)---/);
+    const scripts = [
+        ...content.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)
+    ];
+    return [
+        frontmatter?.[1] ?? "",
+        ...scripts.map(s => s[1])
+    ].join("\n");
 }

package/dist/utils/parsers/router.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectParser = detectParser;
 function detectParser(file) {
+    file = file.toLowerCase();
     if (file.endsWith(".vue"))
         return "vue";
     if (file.endsWith(".svelte"))

package/dist/utils/parsers/svelte.js

@@ -2,5 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSvelte = parseSvelte;
 function parseSvelte(content) {
-    return content;
+    const scriptMatches = [
+        ...content.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)
+    ];
+    return scriptMatches.map(m => m[1]).join("\n");
 }

package/dist/utils/parsers/vue.js

@@ -2,15 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVue = parseVue;
 function parseVue(content) {
-    const scriptMatch = content.match(/<script[\s\S]*?>([\s\S]*?)<\/script>/);
+    const scriptMatches = [
+        ...content.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)
+    ];
+    const script = scriptMatches.map(m => m[1]).join("\n");
+    // template
     const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/);
-    const script = scriptMatch?.[1] ?? "";
     let template = templateMatch?.[1] ?? "";
     template = template.replace(/<!--[\s\S]*?-->/g, "");
+    // Vue → JSX
     template = template
+        .replace(/\bclass=/g, "className=")
+        .replace(/\bfor=/g, "htmlFor=")
+        .replace(/@(\w+)=/g, (_, e) => {
+        const name = e.charAt(0).toUpperCase() + e.slice(1);
+        return `on${name}=`;
+    })
         .replace(/v-if="[^"]+"/g, "")
-        .replace(/v-for="[^"]+"/g, "")
-        .replace(/@click=/g, "onClick=");
+        .replace(/v-for="[^"]+"/g, "");
     const jsx = `
 const __VUE_JSX__ = (
   <>

package/dist/utils/processFile.js

@@ -13,7 +13,9 @@ function processFile(file, content) {
         content = (0, svelte_1.parseSvelte)(content);
     if (parser === "astro")
         content = (0, astro_1.parseAstro)(content);
-    const virtualFile = file.endsWith(".vue")
+    const virtualFile = file.endsWith(".vue") ||
+        file.endsWith(".svelte") ||
+        file.endsWith(".astro")
         ? file + ".tsx"
         : file;
     return { content, virtualFile };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {

package/src/commands/check.ts

@@ -30,8 +30,12 @@ export async function check({ fix = false }: { fix?: boolean }) {
 
       engine.scanFile(virtualFile, content);
 
-    } catch {
-      console.log(chalk.gray(`Skipped: ${file}`));
+    } catch (err) {
+      console.log(chalk.yellow(`Skipped: ${file}`));
+
+      if (err instanceof Error) {
+        console.log(chalk.gray(err.message));
+      }
     }
   }
 
@@ -39,14 +43,17 @@ export async function check({ fix = false }: { fix?: boolean }) {
   const known = new Set(config.events ?? []);
 
   const newEvents = [...found].filter(e => !known.has(e));
+  const removed = [...known].filter(e => !found.has(e));
 
   if (fix) {
+    const merged = new Set(config.events ?? []);
+
     newEvents.forEach(e => {
-      config.events.push(e);
+      merged.add(e);
       console.log(chalk.green(`+ ${e}`));
     });
 
-    config.events = [...new Set(config.events)].sort();
+    config.events = [...merged].sort();
 
     await saveConfig(config);
 
@@ -54,9 +61,16 @@ export async function check({ fix = false }: { fix?: boolean }) {
     return;
   }
 
-  if (newEvents.length) {
-    console.log(chalk.red("\nNew events:"));
-    newEvents.forEach(e => console.log(chalk.red(`+ ${e}`)));
+  if (newEvents.length || removed.length) {
+    if (newEvents.length) {
+      console.log(chalk.red("\nNew events:"));
+      newEvents.forEach(e => console.log(chalk.red(`+ ${e}`)));
+    }
+
+    if (removed.length) {
+      console.log(chalk.yellow("\nRemoved events:"));
+      removed.forEach(e => console.log(chalk.yellow(`- ${e}`)));
+    }
 
     process.exit(1);
   }

package/src/commands/send.ts

@@ -81,6 +81,9 @@ export async function send() {
     )
   );
 
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 10000);
+
   try {
     const res = await fetch(
       endpoint,
@@ -99,8 +102,9 @@ export async function send() {
             version: CLI_VERSION,
             runtime: "node"
           }
-        })
-      }
+        }),
+        signal: controller.signal
+      },
     );
 
     if (!res.ok) {
@@ -203,5 +207,7 @@ export async function send() {
         )
       );
     }
+  } finally {
+    clearTimeout(timeout);
   }
 }

package/src/commands/sync.ts

@@ -31,9 +31,12 @@ export async function sync() {
 
       engine.scanFile(virtualFile, content);
 
-    } catch (e) {
-      console.log(chalk.red(`ERROR: ${file}`));
-      console.error(e);
+    } catch (err) {
+      console.log(chalk.yellow(`Skipped: ${file}`));
+
+      if (err instanceof Error) {
+        console.log(chalk.gray(err.message));
+      }
     }
   }
 

package/src/commands/watch.ts

@@ -5,31 +5,8 @@ import fg from "fast-glob";
 
 import { loadConfig, saveConfig } from "../utils/config";
 import { EventraEngine } from "../engine/engine";
+import { processFile } from "../utils/processFile";
 
-import { detectParser } from "../utils/parsers/router";
-import { parseVue } from "../utils/parsers/vue";
-import { parseSvelte } from "../utils/parsers/svelte";
-import { parseAstro } from "../utils/parsers/astro";
-
-// PREPROCESS (CONTENT)
-function preprocess(file: string, content: string) {
-  const parser = detectParser(file);
-
-  if (parser === "vue") return parseVue(content);
-  if (parser === "svelte") return parseSvelte(content);
-  if (parser === "astro") return parseAstro(content);
-
-  return content;
-}
-
-// VIRTUAL FILE (PATH)
-function toVirtualFile(file: string) {
-  return file.endsWith(".vue")
-    ? file + ".tsx"
-    : file;
-}
-
-// WATCH
 export async function watch() {
   const config = await loadConfig();
   if (!config) return;
@@ -40,20 +17,13 @@ export async function watch() {
     ignore: config.sync.exclude,
   });
 
-  if (!files.length) {
-    console.log(chalk.yellow("No files found"));
-    return;
-  }
-
   const engine = new EventraEngine(process.cwd());
 
-  // INITIAL SCAN
   for (const file of files) {
     try {
       const raw = await fs.readFile(file, "utf-8");
 
-      const content = preprocess(file, raw);
-      const virtualFile = toVirtualFile(file);
+      const { content, virtualFile } = processFile(file, raw);
 
       engine.scanFile(virtualFile, content);
 
@@ -69,9 +39,9 @@ export async function watch() {
     chalk.gray(`Initial: ${config.events.length} events\n`)
   );
 
-  // STATE
   let locked = false;
   let queued = new Set<string>();
+  let timer: NodeJS.Timeout | null = null;
 
   const run = async () => {
     if (locked) return;
@@ -84,8 +54,7 @@ export async function watch() {
       try {
         const raw = await fs.readFile(file, "utf-8");
 
-        const content = preprocess(file, raw);
-        const virtualFile = toVirtualFile(file);
+        const { content, virtualFile } = processFile(file, raw);
 
         engine.updateFile(virtualFile, content);
 
@@ -116,48 +85,33 @@ export async function watch() {
 
   const schedule = (file: string) => {
     queued.add(file);
-    setTimeout(run, 50);
+
+    if (timer) clearTimeout(timer);
+
+    timer = setTimeout(run, 100);
   };
 
-  // WATCHER
   const watcher = chokidar.watch(config.sync.include, {
     ignored: config.sync.exclude,
     ignoreInitial: true,
-    awaitWriteFinish: {
-      stabilityThreshold: 50,
-      pollInterval: 10,
-    },
   });
 
   watcher
-    .on("add", (file) => {
-      console.log(chalk.gray(`add: ${file}`));
-      schedule(file);
-    })
-    .on("change", (file) => {
-      console.log(chalk.gray(`change: ${file}`));
-      schedule(file);
-    })
+    .on("add", schedule)
+    .on("change", schedule)
     .on("unlink", async (file) => {
       console.log(chalk.gray(`remove: ${file}`));
 
-      const virtualFile = toVirtualFile(file);
+      const { virtualFile } = processFile(file, "");
 
-      engine.removeFile?.(virtualFile);
+      engine.removeFile(virtualFile);
 
       const next = engine.getAllEvents();
 
-      const removed = config.events.filter(e => !next.includes(e));
-
-      if (removed.length) {
-        removed.forEach(e => console.log(chalk.red(`- ${e}`)));
-
-        config.events = next.sort();
-        await saveConfig(config);
-      }
+      config.events = next.sort();
+      await saveConfig(config);
     });
 
-  // EXIT
   process.on("SIGINT", async () => {
     console.log(chalk.yellow("\nStopping watcher..."));
     await watcher.close();

package/src/engine/callResolver.ts

@@ -5,38 +5,21 @@ export function resolveFunctionFromCall(
   checker: ts.TypeChecker
 ): ts.FunctionLikeDeclaration | null {
 
-  let symbol = checker.getSymbolAtLocation(expr);
+  const type = checker.getTypeAtLocation(expr);
+  const signatures = type.getCallSignatures();
 
-  if (!symbol && ts.isPropertyAccessExpression(expr)) {
-    symbol = checker.getSymbolAtLocation(expr.name);
-  }
-
-  if (!symbol) return null;
-
-  if (symbol.flags & ts.SymbolFlags.Alias) {
-    symbol = checker.getAliasedSymbol(symbol);
-  }
+  for (const sig of signatures) {
+    const decl = sig.getDeclaration();
 
-  for (const decl of symbol.getDeclarations() ?? []) {
     if (
-      ts.isFunctionDeclaration(decl) ||
-      ts.isMethodDeclaration(decl) ||
-      ts.isFunctionExpression(decl) ||
-      ts.isArrowFunction(decl)
+      decl &&
+      (ts.isFunctionDeclaration(decl) ||
+        ts.isMethodDeclaration(decl) ||
+        ts.isFunctionExpression(decl) ||
+        ts.isArrowFunction(decl))
     ) {
       return decl;
     }
-
-    if (ts.isVariableDeclaration(decl) && decl.initializer) {
-      const init = decl.initializer;
-
-      if (
-        ts.isArrowFunction(init) ||
-        ts.isFunctionExpression(init)
-      ) {
-        return init;
-      }
-    }
   }
 
   return null;

package/src/engine/engine.ts

@@ -22,7 +22,6 @@ export class EventraEngine {
     }
 
     this.fileHash.set(file, h);
-
     this.ts.updateFile(file, content);
 
     const source = this.ts.getSourceFile(file);
@@ -31,7 +30,6 @@ export class EventraEngine {
     if (!source || !checker) return new Set();
 
     this.graph.update(file, source);
-
     const events = scanSource(source, checker);
 
     this.fileEvents.set(file, events);
@@ -40,7 +38,20 @@ export class EventraEngine {
   }
 
   updateFile(file: string, content: string) {
-    return this.scanFile(file, content);
+    const events = this.scanFile(file, content);
+    const dependents = this.graph.getDependents(file);
+
+    for (const dep of dependents) {
+      const source = this.ts.getSourceFile(dep);
+      const checker = this.ts.getChecker();
+
+      if (!source || !checker) continue;
+
+      const ev = scanSource(source, checker);
+      this.fileEvents.set(dep, ev);
+    }
+
+    return events;
   }
 
   getAllEvents() {
@@ -56,5 +67,6 @@ export class EventraEngine {
   removeFile(file: string) {
     this.fileEvents.delete(file);
     this.fileHash.delete(file);
+    this.graph.remove(file);
   }
 }

package/src/engine/graph.ts

@@ -1,23 +1,70 @@
 import ts from "typescript";
+import path from "path";
+import fs from "fs";
 
 export class DependencyGraph {
   private reverse = new Map<string, Set<string>>();
 
+  private normalize(file: string) {
+    return path.resolve(file);
+  }
+
+  private resolveImport(from: string, module: string): string | null {
+    if (!module.startsWith(".")) return null;
+
+    const base = path.resolve(path.dirname(from), module);
+
+    const tryFiles = [
+      base,
+      base + ".ts",
+      base + ".tsx",
+      base + ".js",
+      base + ".jsx",
+      path.join(base, "index.ts"),
+      path.join(base, "index.tsx"),
+      path.join(base, "index.js"),
+    ];
+
+    for (const f of tryFiles) {
+      if (fs.existsSync(f)) {
+        return this.normalize(f);
+      }
+    }
+
+    return this.normalize(base);
+  }
+
   update(file: string, source: ts.SourceFile) {
+    const normalizedFile = this.normalize(file);
+
     for (const stmt of source.statements) {
       if (!ts.isImportDeclaration(stmt)) continue;
 
-      const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+      const module = stmt.moduleSpecifier
+        .getText()
+        .replace(/['"]/g, "");
+
+      const resolved = this.resolveImport(normalizedFile, module);
+
+      if (!resolved) continue;
 
-      if (!this.reverse.has(module)) {
-        this.reverse.set(module, new Set());
+      if (!this.reverse.has(resolved)) {
+        this.reverse.set(resolved, new Set());
       }
 
-      this.reverse.get(module)!.add(file);
+      this.reverse.get(resolved)!.add(normalizedFile);
     }
   }
 
   getDependents(file: string) {
-    return [...(this.reverse.get(file) ?? [])];
+    return [...(this.reverse.get(this.normalize(file)) ?? [])];
+  }
+
+  remove(file: string) {
+    const normalized = this.normalize(file);
+
+    for (const set of this.reverse.values()) {
+      set.delete(normalized);
+    }
   }
 }

package/src/engine/languageService.ts

@@ -6,10 +6,51 @@ export class TSService {
   private service: ts.LanguageService;
 
   constructor(private root: string) {
+    const configPath = ts.findConfigFile(
+      root,
+      ts.sys.fileExists,
+      "tsconfig.json"
+    );
+
+    let compilerOptions: ts.CompilerOptions = {
+      allowJs: true,
+      jsx: ts.JsxEmit.Preserve,
+      moduleResolution: ts.ModuleResolutionKind.Node16,
+      target: ts.ScriptTarget.ESNext,
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+    };
+
+    if (configPath) {
+      const configFile = ts.readConfigFile(
+        configPath,
+        ts.sys.readFile
+      );
+
+      const parsed = ts.parseJsonConfigFileContent(
+        configFile.config,
+        ts.sys,
+        root
+      );
+
+      compilerOptions = {
+        ...compilerOptions,
+        ...parsed.options,
+      };
+    }
+
     const host: ts.LanguageServiceHost = {
-      getScriptFileNames: () => [...this.files.keys()],
+      getScriptFileNames: () => [
+        ...this.files.keys(),
+        ...ts.sys.readDirectory(
+          this.root,
+          [".ts", ".tsx"],
+          ["node_modules", "dist", ".git"]
+        )
+      ],
       getScriptVersion: (file) =>
         this.files.get(file)?.version.toString() ?? "0",
+
       getScriptSnapshot: (file) => {
         const f = this.files.get(file);
 
@@ -19,32 +60,21 @@ export class TSService {
 
         if (fs.existsSync(file)) {
           return ts.ScriptSnapshot.fromString(
-            fs.readFileSync(file, "utf-8" as BufferEncoding)
+            fs.readFileSync(file, "utf-8")
           );
         }
 
         return undefined;
       },
+
       getCurrentDirectory: () => this.root,
-      getCompilationSettings: () => ({
-        allowJs: true,
-        jsx: ts.JsxEmit.Preserve,
-        moduleResolution: ts.ModuleResolutionKind.Node16,
-        target: ts.ScriptTarget.ESNext,
-        esModuleInterop: true,
-        allowSyntheticDefaultImports: true,
-      }),
-      getDefaultLibFileName: (opts) => ts.getDefaultLibFilePath(opts),
-
-      readFile: (fileName: string, encoding?: string) => {
-        try {
-          return fs.readFileSync(fileName, encoding as BufferEncoding);
-        } catch (err) {
-          return undefined;
-        }
-      },
+      getCompilationSettings: () => compilerOptions,
+      getDefaultLibFileName: (opts) =>
+        ts.getDefaultLibFilePath(opts),
 
-      fileExists: fs.existsSync,
+      readFile: ts.sys.readFile,
+      fileExists: ts.sys.fileExists,
+      readDirectory: ts.sys.readDirectory,
     };
 
     this.service = ts.createLanguageService(host);