@eventra_dev/eventra-cli 0.1.2 → 0.1.4

package/dist/engine/resolver.js

@@ -5,7 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveNodeValue = resolveNodeValue;
 const typescript_1 = __importDefault(require("typescript"));
-function resolveNodeValue(node, checker) {
+function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
+    if (seen.has(node))
+        return null;
+    seen.add(node);
+    // param mapping
+    if (typescript_1.default.isIdentifier(node) && paramMap?.has(node.text)) {
+        return resolveNodeValue(paramMap.get(node.text), checker, paramMap);
+    }
     if (typescript_1.default.isStringLiteral(node)) {
         return { values: [node.text], dynamic: false };
     }
@@ -18,8 +25,8 @@ function resolveNodeValue(node, checker) {
         return { values: [result], dynamic: true };
     }
     if (typescript_1.default.isConditionalExpression(node)) {
-        const a = resolveNodeValue(node.whenTrue, checker);
-        const b = resolveNodeValue(node.whenFalse, checker);
+        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,
@@ -34,7 +41,7 @@ function resolveNodeValue(node, checker) {
         }
         for (const decl of symbol.getDeclarations() ?? []) {
             if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
-                return resolveNodeValue(decl.initializer, checker);
+                return resolveNodeValue(decl.initializer, checker, paramMap, seen);
             }
             if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
                 if (typescript_1.default.isStringLiteral(decl.initializer)) {
@@ -65,5 +72,31 @@ function resolveNodeValue(node, checker) {
             }
         }
     }
+    if (typescript_1.default.isObjectLiteralExpression(node)) {
+        const values = [];
+        for (const prop of node.properties) {
+            if (!typescript_1.default.isPropertyAssignment(prop))
+                continue;
+            const name = prop.name.getText();
+            if (name === "event") {
+                const res = resolveNodeValue(prop.initializer, checker, paramMap, seen);
+                if (res)
+                    values.push(...res.values);
+            }
+        }
+        return { values, dynamic: true };
+    }
+    if (typescript_1.default.isBinaryExpression(node)) {
+        if (node.operatorToken.kind === typescript_1.default.SyntaxKind.PlusToken) {
+            const left = resolveNodeValue(node.left, checker, paramMap, seen);
+            const right = resolveNodeValue(node.right, checker, paramMap, seen);
+            if (left && right) {
+                return {
+                    values: left.values.flatMap(l => right.values.map(r => l + r)),
+                    dynamic: true,
+                };
+            }
+        }
+    }
     return null;
 }

package/dist/engine/scanner.js

@@ -7,7 +7,37 @@ 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()) {
+const functionAnalyzer_1 = require("./functionAnalyzer");
+function getCallName(expr) {
+    if (typescript_1.default.isIdentifier(expr))
+        return expr.text;
+    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+        return expr.name.text;
+    }
+    return "";
+}
+function pickBestArg(args, checker, paramMap) {
+    let best = null;
+    for (const arg of args) {
+        const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
+        if (!res?.values?.length)
+            continue;
+        let score = 0;
+        if (!res.dynamic)
+            score += 3;
+        if (res.values.every(v => v.length < 50))
+            score += 2;
+        if (res.values.some(v => v.includes("*")))
+            score -= 2;
+        if (!best || score > best.score) {
+            best = { score, node: arg };
+        }
+    }
+    return best?.node;
+}
+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 +46,47 @@ 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
-                if (fn) {
-                    const sf = fn.getSourceFile();
-                    if (!visited.has(sf.fileName)) {
-                        scanSource(sf, checker, visited).forEach(e => events.add(e));
+                const 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);
+                        }
+                    });
+                }
+                if (fn && typescript_1.default.isFunctionLike(fn)) {
+                    const idx = (0, functionAnalyzer_1.findTrackParamIndex)(fn);
+                    if (idx !== null) {
+                        const realArg = node.arguments[idx];
+                        if (realArg) {
+                            const res = (0, resolver_1.resolveNodeValue)(realArg, checker, paramMap);
+                            res?.values.forEach(v => {
+                                if (v &&
+                                    v.length > 1 &&
+                                    v.length < 100 &&
+                                    !v.includes(" ") &&
+                                    /^[a-zA-Z0-9._:-]+$/.test(v)) {
+                                    events.add(v);
+                                }
+                            });
+                            return;
+                        }
                     }
                 }
+                // fallback (heuristic)
+                const target = pickBestArg(node.arguments, checker, paramMap);
                 if (target) {
-                    const res = (0, resolver_1.resolveNodeValue)(target, checker);
+                    const res = (0, resolver_1.resolveNodeValue)(target, 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);
                         }
                     });
@@ -40,11 +98,3 @@ function scanSource(source, checker, visited = new Set()) {
     visit(source);
     return events;
 }
-function getCallName(expr) {
-    if (typescript_1.default.isIdentifier(expr))
-        return expr.text;
-    if (typescript_1.default.isPropertyAccessExpression(expr)) {
-        return expr.name.text;
-    }
-    return "";
-}

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.4",
   "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/functionAnalyzer.ts

@@ -0,0 +1,51 @@
+import ts from "typescript";
+
+export function findTrackParamIndex(
+  fn: ts.FunctionLikeDeclaration
+): number | null {
+  const paramIndex = new Map<string, number>();
+
+  fn.parameters.forEach((p, i) => {
+    if (ts.isIdentifier(p.name)) {
+      paramIndex.set(p.name.text, i);
+    }
+  });
+
+  let result: number | null = null;
+
+  function visit(node: ts.Node) {
+    if (ts.isCallExpression(node)) {
+      const name = getCallName(node.expression);
+
+      if (/(track|event|capture|send)/i.test(name)) {
+        for (const arg of node.arguments) {
+          if (ts.isIdentifier(arg)) {
+            const idx = paramIndex.get(arg.text);
+            if (idx !== undefined) {
+              result = idx;
+              return;
+            }
+          }
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  if (fn.body) {
+    visit(fn.body);
+  }
+
+  return result;
+}
+
+function getCallName(expr: ts.Expression): string {
+  if (ts.isIdentifier(expr)) return expr.text;
+
+  if (ts.isPropertyAccessExpression(expr)) {
+    return expr.name.text;
+  }
+
+  return "";
+}