@eventra_dev/eventra-cli 0.1.30 → 0.1.32

package/src/utils/universal.ts

@@ -1,28 +1,77 @@
 import path from "path";
 import { ParseResult } from "../types";
 
-// Remove comments
+/* ---------------------------------- */
+/* COMMENT STRIP (SAFE)               */
+/* ---------------------------------- */
 function stripComments(input: string): string {
   return input
     .replace(/<!--[\s\S]*?-->/g, "")
-    .replace(/\/\*[\s\S]*?\*\//g, "")
-    .replace(/\/\/.*$/gm, "");
+    .replace(/\/\*[\s\S]*?\*\//g, "");
 }
 
-// Basic filter
+/* ---------------------------------- */
+/* TRACK DETECTOR                     */
+/* ---------------------------------- */
 function looksLikeTracking(code: string) {
-  return /track/i.test(code);
+  return /\btrack\s*\(|\.track\s*\(/.test(code);
 }
 
-// HTML inline handlers (onclick="")
+/* ---------------------------------- */
+/* 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++;
+    } else if (char === "}") {
+      depth--;
+      if (depth === 0 && start !== -1) {
+        const expr = input.slice(start, i);
+
+        if (looksLikeTracking(expr)) {
+          result.push(expr);
+        }
+
+        start = -1;
+      }
+    }
+  }
+
+  return result;
+}
+
+/* ---------------------------------- */
+/* HTML HANDLERS                      */
+/* ---------------------------------- */
 function extractHTMLHandlers(input: string): string[] {
   const result: string[] = [];
 
-  const matches = input.matchAll(
-    /\bon\w+\s*=\s*["']([^"']+)["']/g
-  );
+  const regex = /\bon\w+\s*=\s*["']([^"']+)["']/g;
 
-  for (const m of matches) {
+  for (const m of input.matchAll(regex)) {
     if (looksLikeTracking(m[1])) {
       result.push(m[1]);
     }
@@ -31,15 +80,15 @@ function extractHTMLHandlers(input: string): string[] {
   return result;
 }
 
-// Vue handlers (@click / v-on)
+/* ---------------------------------- */
+/* VUE HANDLERS                       */
+/* ---------------------------------- */
 function extractVueHandlers(input: string): string[] {
   const result: string[] = [];
 
-  const matches = input.matchAll(
-    /(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g
-  );
+  const regex = /(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g;
 
-  for (const m of matches) {
+  for (const m of input.matchAll(regex)) {
     if (looksLikeTracking(m[1])) {
       result.push(m[1]);
     }
@@ -48,51 +97,95 @@ function extractVueHandlers(input: string): string[] {
   return result;
 }
 
-// Svelte handlers (on:click)
+/* ---------------------------------- */
+/* SVELTE HANDLERS                    */
+/* ---------------------------------- */
 function extractSvelteHandlers(input: string): string[] {
   const result: string[] = [];
 
-  const matches = input.matchAll(
-    /\bon:[\w]+\s*=\s*{([^}]+)}/g
-  );
+  const regex = /\bon:[\w]+\s*=\s*{([\s\S]*?)}/g;
 
-  for (const m of matches) {
-    if (looksLikeTracking(m[1])) {
-      result.push(m[1]);
-    }
+  for (const m of input.matchAll(regex)) {
+    const expr = m[1];
+
+    const nested = extractBracedExpressions(`{${expr}}`);
+    result.push(...nested);
   }
 
   return result;
 }
 
-// JSX / template { ... }
-function extractJSExpressions(input: string): string[] {
-  const result: string[] = [];
+/* ---------------------------------- */
+/* SCRIPT EXTRACTION                  */
+/* ---------------------------------- */
+function extractScripts(input: string, file: string) {
+  const scripts: string[] = [];
+  const deps: string[] = [];
 
-  const matches = input.matchAll(/\{([^}]+)\}/g);
+  // <script src="">
+  const srcRegex =
+    /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/gi;
 
-  for (const m of matches) {
-    if (looksLikeTracking(m[1])) {
-      result.push(m[1]);
+  for (const m of input.matchAll(srcRegex)) {
+    const src = m[1];
+
+    const resolved = src.startsWith("/")
+      ? path.resolve(process.cwd(), "." + src)
+      : path.resolve(path.dirname(file), src);
+
+    deps.push(resolved);
+  }
+
+  // inline <script>
+  const scriptRegex =
+    /<script\b[^>]*>([\s\S]*?)<\/script>/gi;
+
+  for (const m of input.matchAll(scriptRegex)) {
+    if (m[1]?.trim()) {
+      scripts.push(m[1]);
     }
   }
 
-  return result;
+  const noScripts = input.replace(scriptRegex, "");
+
+  return { scripts, deps, noScripts };
 }
 
-// dynamic import()
-function extractDynamicImports(
-  input: string,
-  file: string
-): { deps: string[]; calls: string[] } {
+/* ---------------------------------- */
+/* 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 matches = input.matchAll(
-    /import\(\s*["'](.+?)["']\s*\)/g
-  );
+  const regex = /import\(\s*["'](.+?)["']\s*\)/g;
 
-  for (const m of matches) {
+  for (const m of input.matchAll(regex)) {
     const mod = m[1];
 
     const resolved = mod.startsWith("/")
@@ -109,7 +202,9 @@ function extractDynamicImports(
   return { deps, calls };
 }
 
-// UNIVERSAL PARSER
+/* ---------------------------------- */
+/* MAIN                               */
+/* ---------------------------------- */
 export function parseUniversal(
   content: string,
   file: string
@@ -119,53 +214,30 @@ export function parseUniversal(
 
   const clean = stripComments(content);
 
-  // ASTRO FRONTMATTER
-  const fm = clean.match(/^---([\s\S]*?)---/);
+  /* ---------- ASTRO FRONTMATTER ---------- */
+  const fm = clean.match(/^\s*---([\s\S]*?)---/);
   if (fm?.[1]) {
     parts.push(fm[1]);
   }
 
-  // <script src="">
-  const scriptSrc = clean.matchAll(
-    /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g
-  );
-
-  for (const s of scriptSrc) {
-    const src = s[1];
+  /* ---------- SCRIPTS ---------- */
+  const { scripts, deps: scriptDeps, noScripts } =
+    extractScripts(clean, file);
 
-    const resolved = src.startsWith("/")
-      ? path.resolve(process.cwd(), "." + src)
-      : path.resolve(path.dirname(file), src);
+  parts.push(...scripts);
+  deps.push(...scriptDeps);
 
-    deps.push(resolved);
-  }
-
-  // INLINE <script>
-  const scripts = clean.matchAll(
-    /<script\b([^>]*)>([\s\S]*?)<\/script>/g
-  );
-
-  for (const m of scripts) {
-    if (m[2].trim()) {
-      parts.push(m[2]);
-    }
-  }
-
-  // TEMPLATE PART
-  const noScripts = clean.replace(
-    /<script[\s\S]*?<\/script>/g,
-    ""
-  );
-
-  // handlers
+  /* ---------- HANDLERS ---------- */
   parts.push(...extractHTMLHandlers(noScripts));
   parts.push(...extractVueHandlers(noScripts));
   parts.push(...extractSvelteHandlers(noScripts));
 
-  // JSX / Astro / Vue expressions
-  parts.push(...extractJSExpressions(clean));
+  /* ---------- JSX / TEMPLATE ---------- */
+  parts.push(...extractBracedExpressions(clean));
+
+  /* ---------- IMPORTS ---------- */
+  deps.push(...extractStaticImports(clean, file));
 
-  // dynamic imports
   const dyn = extractDynamicImports(clean, file);
   deps.push(...dyn.deps);
   parts.push(...dyn.calls);

package/tests/run.ts

@@ -40,7 +40,6 @@ function ensureTestConfig(dir: string) {
     events: [],
     wrappers: [],
     functionWrappers: [],
-    aliases: {},
     sync: {
       include: [
         "**/*.{ts,tsx,js,jsx,vue,svelte,astro}"

package/dist/engine/trackingDetector.js

@@ -1,17 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTrackingCall = isTrackingCall;
-const typescript_1 = __importDefault(require("typescript"));
-function isTrackingCall(node) {
-    const expr = node.expression;
-    if (typescript_1.default.isIdentifier(expr)) {
-        return expr.text === "track";
-    }
-    if (typescript_1.default.isPropertyAccessExpression(expr)) {
-        return expr.name.text === "track";
-    }
-    return false;
-}

package/src/engine/trackingDetector.ts

@@ -1,17 +0,0 @@
-import ts from "typescript";
-
-export function isTrackingCall(
-  node: ts.CallExpression
-): boolean {
-  const expr = node.expression;
-
-  if (ts.isIdentifier(expr)) {
-    return expr.text === "track";
-  }
-
-  if (ts.isPropertyAccessExpression(expr)) {
-    return expr.name.text === "track";
-  }
-
-  return false;
-}