@eventra_dev/eventra-cli 0.1.1 → 0.1.3

package/dist/engine/resolver.js

@@ -1,36 +1,100 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveNodeValue = resolveNodeValue;
-const ts_morph_1 = require("ts-morph");
-function resolveNodeValue(node, checker) {
-    if (!ts_morph_1.Node.isIdentifier(node))
+const typescript_1 = __importDefault(require("typescript"));
+function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
+    if (seen.has(node))
         return null;
-    const symbol = checker.getSymbolAtLocation(node.compilerNode);
-    if (!symbol)
-        return null;
-    const decls = symbol.getDeclarations() ?? [];
-    for (const d of decls) {
-        if (ts_morph_1.ts.isVariableDeclaration(d) && d.initializer) {
-            const init = d.initializer;
-            if (ts_morph_1.ts.isStringLiteral(init)) {
-                return { values: [init.text], dynamic: false };
+    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 };
+    }
+    if (typescript_1.default.isTemplateExpression(node)) {
+        let result = node.head.text;
+        for (const span of node.templateSpans) {
+            result += "*";
+            result += span.literal.text;
+        }
+        return { values: [result], dynamic: true };
+    }
+    if (typescript_1.default.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,
+        };
+    }
+    if (typescript_1.default.isIdentifier(node)) {
+        let symbol = checker.getSymbolAtLocation(node);
+        if (!symbol)
+            return null;
+        if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+            symbol = checker.getAliasedSymbol(symbol);
+        }
+        for (const decl of symbol.getDeclarations() ?? []) {
+            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+                return resolveNodeValue(decl.initializer, checker, paramMap, seen);
             }
-            if (ts_morph_1.ts.isNoSubstitutionTemplateLiteral(init)) {
-                return { values: [init.text], dynamic: false };
+            if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
+                if (typescript_1.default.isStringLiteral(decl.initializer)) {
+                    return {
+                        values: [decl.initializer.text],
+                        dynamic: false,
+                    };
+                }
             }
-            if (ts_morph_1.ts.isTemplateExpression(init)) {
-                let result = init.head.text;
-                for (const span of init.templateSpans) {
-                    result += "*";
-                    result += span.literal.text;
+        }
+    }
+    if (typescript_1.default.isPropertyAccessExpression(node)) {
+        const symbol = checker.getSymbolAtLocation(node);
+        if (symbol) {
+            let s = symbol;
+            if (s.flags & typescript_1.default.SymbolFlags.Alias) {
+                s = checker.getAliasedSymbol(s);
+            }
+            for (const decl of s.getDeclarations() ?? []) {
+                if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
+                    if (typescript_1.default.isStringLiteral(decl.initializer)) {
+                        return {
+                            values: [decl.initializer.text],
+                            dynamic: false,
+                        };
+                    }
                 }
-                return { values: [result], dynamic: true };
             }
         }
-        if (ts_morph_1.ts.isParameter(d) && d.initializer) {
-            const init = d.initializer;
-            if (ts_morph_1.ts.isStringLiteral(init)) {
-                return { values: [init.text], dynamic: false };
+    }
+    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,
+                };
             }
         }
     }

package/dist/engine/scanner.js

@@ -1,78 +1,68 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanSource = scanSource;
-const ts_morph_1 = require("ts-morph");
-const extract_1 = require("./extract");
+const typescript_1 = __importDefault(require("typescript"));
+const resolver_1 = require("./resolver");
 const callResolver_1 = require("./callResolver");
-const flow_1 = require("./flow");
-function getCallName(expr) {
-    if (ts_morph_1.Node.isIdentifier(expr))
-        return expr.getText();
-    if (ts_morph_1.Node.isPropertyAccessExpression(expr))
-        return expr.getName();
-    return expr.getText();
-}
-function isTrackLike(name) {
-    return /(track|trackFeature)/i.test(name);
-}
-function pickArg(args) {
-    return (args.find(ts_morph_1.Node.isStringLiteral) ??
-        args.find(ts_morph_1.Node.isTemplateExpression) ??
-        args.find(ts_morph_1.Node.isObjectLiteralExpression) ??
-        args[0]);
-}
-function scanSource(source, checker) {
+function scanSource(source, checker, visited = new Set(), depth = 0) {
+    if (depth > 5)
+        return new Set();
     const events = new Set();
-    // CALLS
-    for (const call of source.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)) {
-        const expr = call.getExpression();
-        const name = getCallName(expr);
-        if (!isTrackLike(name))
-            continue;
-        const args = call.getArguments();
-        if (!args.length)
-            continue;
-        let target = pickArg(args);
-        const fn = (0, callResolver_1.resolveFunctionFromCall)(expr);
-        if (fn) {
-            const index = (0, flow_1.getForwardedParamIndex)(fn);
-            if (index !== null && args[index]) {
-                target = args[index];
+    if (visited.has(source.fileName))
+        return events;
+    visited.add(source.fileName);
+    function visit(node) {
+        if (typescript_1.default.isCallExpression(node)) {
+            const name = getCallName(node.expression);
+            if (/(track|event|capture|send)/i.test(name)) {
+                const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
+                // 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, depth + 1)
+                            .forEach(e => events.add(e));
+                    }
+                }
+                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.length < 100 &&
+                            !v.includes(" ") &&
+                            /^[a-zA-Z0-9._:-]+$/.test(v)) {
+                            events.add(v);
+                        }
+                    });
+                }
             }
         }
-        (0, extract_1.extractEventsFromArgs)([target], checker).forEach(({ value }) => {
-            if (isValid(value))
-                events.add(value);
-        });
-    }
-    // JSX
-    const jsx = [
-        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxOpeningElement),
-        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxSelfClosingElement),
-    ];
-    for (const el of jsx) {
-        for (const attr of el.getAttributes()) {
-            if (!ts_morph_1.Node.isJsxAttribute(attr))
-                continue;
-            const name = attr.getNameNode().getText();
-            if (!/(event|name|action)/i.test(name))
-                continue;
-            const init = attr.getInitializer();
-            if (!init)
-                continue;
-            const expr = ts_morph_1.Node.isJsxExpression(init)
-                ? init.getExpression()
-                : init;
-            if (!expr)
-                continue;
-            (0, extract_1.extractEventsFromArgs)([expr], checker).forEach(({ value }) => {
-                if (isValid(value))
-                    events.add(value);
-            });
-        }
+        typescript_1.default.forEachChild(node, visit);
     }
+    visit(source);
     return events;
 }
-function isValid(v) {
-    return !!v && v.length > 1 && !v.includes(" ");
+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.1",
+  "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

@@ -1,35 +1,24 @@
-import { Node } from "ts-morph";
-
-export function resolveFunctionFromCall(expr: Node) {
-  let symbol = expr.getSymbol();
-
-  if (!symbol && Node.isPropertyAccessExpression(expr)) {
-    symbol = expr.getNameNode().getSymbol();
-  }
-
-  if (!symbol) return null;
-
-  const decls = symbol.getDeclarations() ?? [];
-
-  for (const d of decls) {
-    if (Node.isFunctionDeclaration(d)) return d;
-
-    if (Node.isVariableDeclaration(d)) {
-      const init = d.getInitializer();
-
-      if (
-        init &&
-        (Node.isArrowFunction(init) ||
-          Node.isFunctionExpression(init))
-      ) {
-        return init;
-      }
-    }
-
-    if (Node.isMethodDeclaration(d)) return d;
-
-    if (Node.isFunctionExpression(d) || Node.isArrowFunction(d)) {
-      return d;
+import ts from "typescript";
+
+export function resolveFunctionFromCall(
+  expr: ts.Expression,
+  checker: ts.TypeChecker
+): ts.FunctionLikeDeclaration | null {
+
+  const type = checker.getTypeAtLocation(expr);
+  const signatures = type.getCallSignatures();
+
+  for (const sig of signatures) {
+    const decl = sig.getDeclaration();
+
+    if (
+      decl &&
+      (ts.isFunctionDeclaration(decl) ||
+        ts.isMethodDeclaration(decl) ||
+        ts.isFunctionExpression(decl) ||
+        ts.isArrowFunction(decl))
+    ) {
+      return decl;
     }
   }