@eventra_dev/eventra-cli 0.1.2 → 0.1.3

package/src/engine/resolver.ts

@@ -7,9 +7,23 @@ export type ResolveResult = {
 
 export function resolveNodeValue(
   node: ts.Node,
-  checker: ts.TypeChecker
+  checker: ts.TypeChecker,
+  paramMap?: Map<string, ts.Expression>,
+  seen = new Set<ts.Node>()
 ): ResolveResult | null {
 
+  if (seen.has(node)) return null;
+  seen.add(node);
+
+  // param mapping
+  if (ts.isIdentifier(node) && paramMap?.has(node.text)) {
+    return resolveNodeValue(
+      paramMap.get(node.text)!,
+      checker,
+      paramMap
+    );
+  }
+
   if (ts.isStringLiteral(node)) {
     return { values: [node.text], dynamic: false };
   }
@@ -26,8 +40,8 @@ export function resolveNodeValue(
   }
 
   if (ts.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 ?? [])])],
@@ -45,7 +59,7 @@ export function resolveNodeValue(
 
     for (const decl of symbol.getDeclarations() ?? []) {
       if (ts.isVariableDeclaration(decl) && decl.initializer) {
-        return resolveNodeValue(decl.initializer, checker);
+        return resolveNodeValue(decl.initializer, checker, paramMap, seen);
       }
 
       if (ts.isEnumMember(decl) && decl.initializer) {
@@ -82,5 +96,38 @@ export function resolveNodeValue(
     }
   }
 
+  if (ts.isObjectLiteralExpression(node)) {
+    const values: string[] = [];
+
+    for (const prop of node.properties) {
+      if (!ts.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 (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);
+
+      if (left && right) {
+        return {
+          values: left.values.flatMap(l =>
+            right.values.map(r => l + r)
+          ),
+          dynamic: true,
+        };
+      }
+    }
+  }
+
   return null;
 }

package/src/engine/scanner.ts

@@ -5,8 +5,10 @@ import { resolveFunctionFromCall } from "./callResolver";
 export function scanSource(
   source: ts.SourceFile,
   checker: ts.TypeChecker,
-  visited = new Set<string>()
-) {
+  visited = new Set<string>(),
+  depth = 0
+): Set<string> {
+  if (depth > 5) return new Set();
   const events = new Set<string>();
 
   if (visited.has(source.fileName)) return events;
@@ -17,24 +19,44 @@ export function scanSource(
       const name = getCallName(node.expression);
 
       if (/(track|event|capture|send)/i.test(name)) {
-        let target = node.arguments[0];
 
         const fn = resolveFunctionFromCall(node.expression, checker);
 
-        // 🔥 cross-file
+        // param mapping
+        let paramMap = new Map<string, ts.Expression>();
+
+        if (fn && ts.isFunctionLike(fn)) {
+          fn.parameters.forEach((param, index) => {
+            const arg = node.arguments[index];
+            if (!arg) return;
+
+            if (ts.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 = resolveNodeValue(target, checker);
+        for (const arg of node.arguments) {
+          const res = 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/src/utils/config.ts

@@ -12,8 +12,7 @@ export function normalizeConfig(
     events: config.events ?? [],
     endpoint: config.endpoint ?? "",
     wrappers: config.wrappers ?? [],
-    functionWrappers:
-      config.functionWrappers ?? [],
+    functionWrappers: config.functionWrappers ?? [],
     aliases: config.aliases ?? {},
     sync: config.sync ?? {
       include: [
@@ -30,43 +29,26 @@ export function normalizeConfig(
 }
 
 export async function loadConfig(): Promise<EventraConfig | null> {
-  const configPath = path.join(
-    process.cwd(),
-    CONFIG_NAME
-  );
+  const configPath = path.join(process.cwd(), CONFIG_NAME);
 
-  if (
-    !(await fs.pathExists(
-      configPath
-    ))
-  ) {
+  if (!(await fs.pathExists(configPath))) {
     return null;
   }
 
-  const config =
-    await fs.readJSON(
-      configPath
-    );
-
-  return normalizeConfig(config);
+  try {
+    const config = await fs.readJSON(configPath);
+    return normalizeConfig(config);
+  } catch {
+    return null;
+  }
 }
 
-export async function saveConfig(
-  config: EventraConfig
-) {
-  const configPath = path.join(
-    process.cwd(),
-    CONFIG_NAME
-  );
+export async function saveConfig(config: EventraConfig) {
+  const configPath = path.join(process.cwd(), CONFIG_NAME);
 
-  const normalized =
-    normalizeConfig(config);
+  const normalized = normalizeConfig(config);
 
-  await fs.writeJSON(
-    configPath,
-    normalized,
-    {
-      spaces: 2
-    }
-  );
+  await fs.writeJSON(configPath, normalized, {
+    spaces: 2
+  });
 }

package/src/utils/parsers/astro.ts

@@ -1,5 +1,12 @@
-export function parseAstro(
-  content: string
-) {
-  return content;
+export function parseAstro(content: string) {
+  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/src/utils/parsers/router.ts

@@ -1,14 +1,9 @@
-export function detectParser(
-  file: string
-) {
-  if (file.endsWith(".vue"))
-    return "vue";
+export function detectParser(file: string) {
+  file = file.toLowerCase();
 
-  if (file.endsWith(".svelte"))
-    return "svelte";
-
-  if (file.endsWith(".astro"))
-    return "astro";
+  if (file.endsWith(".vue")) return "vue";
+  if (file.endsWith(".svelte")) return "svelte";
+  if (file.endsWith(".astro")) return "astro";
 
   return "ts";
 }

package/src/utils/parsers/svelte.ts

@@ -1,5 +1,7 @@
-export function parseSvelte(
-  content: string
-) {
-  return content;
+export function parseSvelte(content: string) {
+  const scriptMatches = [
+    ...content.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)
+  ];
+
+  return scriptMatches.map(m => m[1]).join("\n");
 }

package/src/utils/parsers/vue.ts

@@ -1,16 +1,26 @@
 export function parseVue(content: string) {
-  const scriptMatch = content.match(/<script[\s\S]*?>([\s\S]*?)<\/script>/);
-  const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/);
+  const scriptMatches = [
+    ...content.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)
+  ];
+
+  const script = scriptMatches.map(m => m[1]).join("\n");
 
-  const script = scriptMatch?.[1] ?? "";
+  // template
+  const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/);
   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/src/utils/processFile.ts

@@ -10,9 +10,12 @@ export function processFile(file: string, content: string) {
   if (parser === "svelte") content = parseSvelte(content);
   if (parser === "astro") content = parseAstro(content);
 
-  const virtualFile = file.endsWith(".vue")
-    ? file + ".tsx"
-    : file;
+  const virtualFile =
+    file.endsWith(".vue") ||
+    file.endsWith(".svelte") ||
+    file.endsWith(".astro")
+      ? file + ".tsx"
+      : file;
 
   return { content, virtualFile };
 }