@eventra_dev/eventra-cli 0.1.31 → 0.1.33

package/src/engine/scanner.ts

@@ -173,15 +173,13 @@ export function scanSource(
   config: EventraConfig,
   visited = new Set<string>(),
   inheritedParamMap?: Map<string, ts.Expression>,
-  wrapperCache?: Map<string, string | null>
+  wrapperCache = new Map<string, string | null>()
 ): ScanResult {
-  wrapperCache = wrapperCache ?? new Map();
-
   const events = new Set<string>();
   const detectedFunctionWrappers = new Set<string>();
   const detectedComponentWrappers = new Map<string, string>();
 
-  if (visited.size > 200 || visited.has(source.fileName)) {
+  if (visited.has(source.fileName) || visited.size > 200) {
     return { events, detectedFunctionWrappers, detectedComponentWrappers };
   }
 
@@ -189,76 +187,58 @@ export function scanSource(
 
   function visit(node: ts.Node) {
     // JSX WRAPPERS
-    if (
-      ts.isJsxSelfClosingElement(node) ||
-      ts.isJsxOpeningElement(node)
-    ) {
+    if (ts.isJsxSelfClosingElement(node) || ts.isJsxOpeningElement(node)) {
       const tagName = getJsxTagName(node.tagName);
 
       // skip html
-      if (!tagName || tagName[0] === tagName[0].toLowerCase()) {
+      if (tagName[0] === tagName[0].toLowerCase()) {
         ts.forEachChild(node, visit);
         return;
       }
 
-      let wrapper = config.wrappers.find(
-        (w) => w.name === tagName
-      );
+      let wrapper = config.wrappers.find(w => w.name === tagName);
 
+      // AUTO DETECT
       if (!wrapper) {
-        let symbol = checker.getSymbolAtLocation(node.tagName);
-
-        let cacheKey = tagName;
+        if (wrapperCache.has(tagName)) {
+          const cached = wrapperCache.get(tagName);
+          if (cached) wrapper = { name: tagName, prop: cached };
+        } else {
+          let symbol = checker.getSymbolAtLocation(node.tagName);
 
-        if (symbol) {
-          if (symbol.flags & ts.SymbolFlags.Alias) {
+          if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
             symbol = checker.getAliasedSymbol(symbol);
           }
 
-          symbol =
-            resolveExportedSymbol(symbol, checker) ?? symbol;
-
-          cacheKey = checker.getFullyQualifiedName(symbol);
-        }
-
-        if (wrapperCache?.has(cacheKey)) {
-          const cached = wrapperCache.get(cacheKey);
-          if (cached) {
-            wrapper = { name: tagName, prop: cached };
-          }
-        } else if (symbol) {
-          let detected: string | null = null;
+          if (symbol) {
+            symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
 
-          for (const decl of symbol.getDeclarations() ?? []) {
-            let fn: ts.FunctionLikeDeclaration | null = null;
+            for (const decl of symbol.getDeclarations() ?? []) {
+              let fn: ts.FunctionLikeDeclaration | null = null;
 
-            if (ts.isFunctionDeclaration(decl)) fn = decl;
+              if (ts.isFunctionDeclaration(decl)) fn = decl;
 
-            if (
-              ts.isVariableDeclaration(decl) &&
-              decl.initializer &&
-              (ts.isArrowFunction(decl.initializer) ||
-                ts.isFunctionExpression(decl.initializer))
-            ) {
-              fn = decl.initializer;
-            }
+              if (
+                ts.isVariableDeclaration(decl) &&
+                decl.initializer &&
+                (ts.isArrowFunction(decl.initializer) ||
+                  ts.isFunctionExpression(decl.initializer))
+              ) {
+                fn = decl.initializer;
+              }
 
-            if (!fn) continue;
+              if (!fn) continue;
 
-            const prop = findTrackedPropName(fn, checker);
+              const prop = findTrackedPropName(fn, checker);
+              wrapperCache.set(tagName, prop ?? null);
 
-            if (prop) {
-              detected = prop;
-              break;
+              if (prop) {
+                wrapper = { name: tagName, prop };
+                detectedComponentWrappers.set(tagName, prop);
+                break;
+              }
             }
           }
-
-          wrapperCache?.set(cacheKey, detected);
-
-          if (detected) {
-            wrapper = { name: tagName, prop: detected };
-            detectedComponentWrappers.set(tagName, detected);
-          }
         }
       }
 
@@ -268,25 +248,21 @@ export function scanSource(
 
           const name = getJsxAttrName(attr.name);
           if (name !== wrapper.prop) continue;
+
           if (!attr.initializer) continue;
 
           if (ts.isStringLiteral(attr.initializer)) {
-            if (isValidEvent(attr.initializer.text)) {
-              events.add(attr.initializer.text);
-            }
+            const v = attr.initializer.text;
+            if (isValidEvent(v)) events.add(v);
           }
 
           if (ts.isJsxExpression(attr.initializer)) {
             const expr = attr.initializer.expression;
             if (!expr) continue;
 
-            const res = resolveNodeValue(
-              expr,
-              checker,
-              inheritedParamMap
-            );
+            const res = resolveNodeValue(expr, checker, inheritedParamMap);
 
-            res.values.forEach((v) => {
+            res.values.forEach(v => {
               if (isValidEvent(v)) events.add(v);
             });
           }
@@ -297,40 +273,56 @@ export function scanSource(
       return;
     }
 
-    // FUNCTION TRACKING
+    // FUNCTION CALLS
     if (ts.isCallExpression(node)) {
-      const name = getCallName(node.expression);
+      let trackParamIndex: number | null = null;
+      let isTracking = false;
+
+      const callName = getCallName(node.expression);
+
+      // direct .track()
+      if (
+        ts.isPropertyAccessExpression(node.expression) &&
+        node.expression.name.text === "track"
+      ) {
+        isTracking = true;
+        trackParamIndex = 0;
+      }
 
-      const isKnownWrapper = config.functionWrappers.some(
-        (w) => w.name === name
+      // config wrapper
+      const manualWrapper = config.functionWrappers.find(
+        w => w.name === callName
       );
 
+      if (manualWrapper) {
+        isTracking = true;
+        trackParamIndex = 0;
+      }
+
+      // resolve function → check body
       const resolvedFn = resolveFunctionFromCall(
         node.expression,
         checker
       );
 
-      const isAutoWrapper =
-        !!resolvedFn && findTrackParamIndex(resolvedFn) !== null;
+      if (resolvedFn) {
+        const idx = findTrackParamIndex(resolvedFn);
 
-      const isTracking =
-        name === "track" ||
-        isKnownWrapper ||
-        (isAutoWrapper &&
-          resolvedFn &&
-          !isExternalFile(
-            resolvedFn.getSourceFile().fileName
-          ));
+        if (idx !== null) {
+          isTracking = true;
+          trackParamIndex = idx;
+
+          if (!manualWrapper && callName !== "track") {
+            detectedFunctionWrappers.add(callName);
+          }
+        }
+      }
 
       if (!isTracking) {
         ts.forEachChild(node, visit);
         return;
       }
 
-      if (!isKnownWrapper && isAutoWrapper && name !== "track") {
-        detectedFunctionWrappers.add(name);
-      }
-
       const paramMap = new Map(inheritedParamMap ?? []);
 
       if (resolvedFn && ts.isFunctionLike(resolvedFn)) {
@@ -344,22 +336,19 @@ export function scanSource(
         });
       }
 
-      if (resolvedFn) {
-        const idx = findTrackParamIndex(resolvedFn);
+      if (trackParamIndex !== null && node.arguments[trackParamIndex]) {
+        const res = resolveNodeValue(
+          node.arguments[trackParamIndex],
+          checker,
+          paramMap
+        );
 
-        if (idx !== null && node.arguments[idx]) {
-          const res = resolveNodeValue(
-            node.arguments[idx],
-            checker,
-            paramMap
-          );
-
-          res.values.forEach((v) => {
-            if (isValidEvent(v)) events.add(v);
-          });
-        }
+        res.values.forEach(v => {
+          if (isValidEvent(v)) events.add(v);
+        });
       }
 
+      // CROSS FILE
       if (resolvedFn) {
         const sf = resolvedFn.getSourceFile();
 
@@ -373,7 +362,7 @@ export function scanSource(
             wrapperCache
           );
 
-          res.events.forEach((e) => events.add(e));
+          res.events.forEach(e => events.add(e));
         }
       }
     }

package/src/utils/universal.ts

@@ -1,28 +1,48 @@
 import path from "path";
 import { ParseResult } from "../types";
 
-// SAFE COMMENT STRIP
+/* ---------------------------------- */
+/* COMMENT STRIP (SAFE)               */
+/* ---------------------------------- */
 function stripComments(input: string): string {
   return input
     .replace(/<!--[\s\S]*?-->/g, "")
     .replace(/\/\*[\s\S]*?\*\//g, "");
 }
 
-// TRACK FILTER
+/* ---------------------------------- */
+/* TRACK DETECTOR                     */
+/* ---------------------------------- */
 function looksLikeTracking(code: string) {
-  return /\btrack\w*\s*\(/.test(code);
+  return /\btrack\s*\(|\.track\s*\(/.test(code);
 }
 
-// SAFE {} PARSER
+/* ---------------------------------- */
+/* SAFE {} PARSER (JSX / TEMPLATES)   */
+/* ---------------------------------- */
 function extractBracedExpressions(input: string): string[] {
   const result: string[] = [];
 
   let depth = 0;
   let start = -1;
+  let inString: string | null = null;
 
   for (let i = 0; i < input.length; i++) {
     const char = input[i];
 
+    // handle strings
+    if (inString) {
+      if (char === inString && input[i - 1] !== "\\") {
+        inString = null;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === "'" || char === "`") {
+      inString = char;
+      continue;
+    }
+
     if (char === "{") {
       if (depth === 0) start = i + 1;
       depth++;
@@ -30,9 +50,11 @@ function extractBracedExpressions(input: string): string[] {
       depth--;
       if (depth === 0 && start !== -1) {
         const expr = input.slice(start, i);
+
         if (looksLikeTracking(expr)) {
           result.push(expr);
         }
+
         start = -1;
       }
     }
@@ -41,7 +63,9 @@ function extractBracedExpressions(input: string): string[] {
   return result;
 }
 
-// HTML handlers
+/* ---------------------------------- */
+/* HTML HANDLERS                      */
+/* ---------------------------------- */
 function extractHTMLHandlers(input: string): string[] {
   const result: string[] = [];
 
@@ -56,7 +80,9 @@ function extractHTMLHandlers(input: string): string[] {
   return result;
 }
 
-// VUE handlers
+/* ---------------------------------- */
+/* VUE HANDLERS                       */
+/* ---------------------------------- */
 function extractVueHandlers(input: string): string[] {
   const result: string[] = [];
 
@@ -71,29 +97,34 @@ function extractVueHandlers(input: string): string[] {
   return result;
 }
 
-// SVELTE handlers
+/* ---------------------------------- */
+/* SVELTE HANDLERS                    */
+/* ---------------------------------- */
 function extractSvelteHandlers(input: string): string[] {
   const result: string[] = [];
 
-  const regex = /\bon:[\w]+\s*=\s*{([^}]+)}/g;
+  const regex = /\bon:[\w]+\s*=\s*{([\s\S]*?)}/g;
 
   for (const m of input.matchAll(regex)) {
-    if (looksLikeTracking(m[1])) {
-      result.push(m[1]);
-    }
+    const expr = m[1];
+
+    const nested = extractBracedExpressions(`{${expr}}`);
+    result.push(...nested);
   }
 
   return result;
 }
 
-// SCRIPT EXTRACTION
+/* ---------------------------------- */
+/* SCRIPT EXTRACTION                  */
+/* ---------------------------------- */
 function extractScripts(input: string, file: string) {
   const scripts: string[] = [];
   const deps: string[] = [];
 
-  // src scripts
+  // <script src="">
   const srcRegex =
-    /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g;
+    /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/gi;
 
   for (const m of input.matchAll(srcRegex)) {
     const src = m[1];
@@ -105,9 +136,9 @@ function extractScripts(input: string, file: string) {
     deps.push(resolved);
   }
 
-  // inline scripts
+  // inline <script>
   const scriptRegex =
-    /<script\b[^>]*>([\s\S]*?)<\/script>/g;
+    /<script\b[^>]*>([\s\S]*?)<\/script>/gi;
 
   for (const m of input.matchAll(scriptRegex)) {
     if (m[1]?.trim()) {
@@ -120,9 +151,37 @@ function extractScripts(input: string, file: string) {
   return { scripts, deps, noScripts };
 }
 
-// DYNAMIC IMPORTS
+/* ---------------------------------- */
+/* STATIC IMPORTS                     */
+/* ---------------------------------- */
+function extractStaticImports(input: string, file: string) {
+  const deps: string[] = [];
+
+  const regex =
+    /import\s+(?:.+?\s+from\s+)?["'](.+?)["']/g;
+
+  for (const m of input.matchAll(regex)) {
+    const mod = m[1];
+
+    if (!mod.startsWith(".") && !mod.startsWith("/")) continue;
+
+    const resolved = path.resolve(
+      path.dirname(file),
+      mod
+    );
+
+    deps.push(resolved);
+  }
+
+  return deps;
+}
+
+/* ---------------------------------- */
+/* DYNAMIC IMPORTS                    */
+/* ---------------------------------- */
 function extractDynamicImports(input: string, file: string) {
   const deps: string[] = [];
+  const calls: string[] = [];
 
   const regex = /import\(\s*["'](.+?)["']\s*\)/g;
 
@@ -134,12 +193,18 @@ function extractDynamicImports(input: string, file: string) {
       : path.resolve(path.dirname(file), mod);
 
     deps.push(resolved);
+
+    if (looksLikeTracking(mod)) {
+      calls.push(`import("${mod}")`);
+    }
   }
 
-  return deps;
+  return { deps, calls };
 }
 
-// MAIN
+/* ---------------------------------- */
+/* MAIN                               */
+/* ---------------------------------- */
 export function parseUniversal(
   content: string,
   file: string
@@ -150,7 +215,7 @@ export function parseUniversal(
   const clean = stripComments(content);
 
   /* ---------- ASTRO FRONTMATTER ---------- */
-  const fm = clean.match(/^---([\s\S]*?)---/);
+  const fm = clean.match(/^\s*---([\s\S]*?)---/);
   if (fm?.[1]) {
     parts.push(fm[1]);
   }
@@ -171,7 +236,11 @@ export function parseUniversal(
   parts.push(...extractBracedExpressions(clean));
 
   /* ---------- IMPORTS ---------- */
-  deps.push(...extractDynamicImports(clean, file));
+  deps.push(...extractStaticImports(clean, file));
+
+  const dyn = extractDynamicImports(clean, file);
+  deps.push(...dyn.deps);
+  parts.push(...dyn.calls);
 
   return {
     code: [...new Set(parts)].join("\n"),