@eventra_dev/eventra-cli 0.1.22 → 0.1.24

package/dist/commands/watch.js

@@ -12,6 +12,12 @@ const path_1 = __importDefault(require("path"));
 const config_1 = require("../utils/config");
 const engine_1 = require("../engine/engine");
 const processFile_1 = require("../utils/processFile");
+// stabile virtual mapping
+function getVirtualFile(file) {
+    return /\.(vue|svelte|astro|html)$/i.test(file)
+        ? file + ".tsx"
+        : file;
+}
 async function watch() {
     const config = await (0, config_1.loadConfig)();
     if (!config)
@@ -21,54 +27,65 @@ async function watch() {
         ignore: config.sync.exclude,
     });
     const engine = new engine_1.EventraEngine(process.cwd());
-    const fileCache = [];
-    // PRELOAD TS
+    const watchedDeps = new Set();
+    // INITIAL LOAD
     for (const file of files) {
         try {
             const abs = path_1.default.resolve(file);
             const raw = await promises_1.default.readFile(abs, "utf-8");
-            const { content, virtualFile } = (0, processFile_1.processFile)(abs, raw);
-            fileCache.push({ file: virtualFile, content });
+            const { content, deps } = (0, processFile_1.processFile)(abs, raw);
+            const virtual = getVirtualFile(abs);
+            engine.scanFile(virtual, content, config);
+            // deps
+            for (const dep of deps) {
+                watchedDeps.add(path_1.default.resolve(dep));
+            }
         }
         catch {
             console.log(chalk_1.default.gray(`skip: ${file}`));
         }
     }
-    // INITIAL SCAN
-    for (const { file, content } of fileCache) {
-        engine.scanFile(file, content, config);
-    }
     config.events = engine.getAllEvents().sort();
     await (0, config_1.saveConfig)(config);
     console.log(chalk_1.default.gray(`Initial: ${config.events.length} events\n`));
+    // QUEUE
     let locked = false;
-    let queued = new Set();
+    let queued = new Map();
     let timer = null;
     const run = async () => {
-        if (locked)
+        if (locked) {
+            timer = setTimeout(run, 100);
             return;
+        }
         locked = true;
-        const batch = [...queued];
+        const batch = [...queued.values()];
         queued.clear();
-        for (const file of batch) {
+        for (const item of batch) {
             try {
-                const raw = await promises_1.default.readFile(file, "utf-8");
-                const { content, virtualFile, deps } = (0, processFile_1.processFile)(file, raw);
-                engine.updateFile(virtualFile, content, config);
-                // deps
+                const raw = await promises_1.default.readFile(item.real, "utf-8");
+                const { content, deps } = (0, processFile_1.processFile)(item.real, raw);
+                engine.updateFile(item.virtual, content, config);
+                // DEPS
                 for (const dep of deps) {
+                    const absDep = path_1.default.resolve(dep);
+                    if (!watchedDeps.has(absDep)) {
+                        watcher.add(absDep);
+                        watchedDeps.add(absDep);
+                    }
                     try {
-                        const depRaw = await promises_1.default.readFile(dep, "utf-8");
-                        const { content: depContent, virtualFile: depVirtual, } = (0, processFile_1.processFile)(dep, depRaw);
+                        const depRaw = await promises_1.default.readFile(absDep, "utf-8");
+                        const { content: depContent } = (0, processFile_1.processFile)(absDep, depRaw);
+                        const depVirtual = getVirtualFile(absDep);
                         engine.updateFile(depVirtual, depContent, config);
                     }
                     catch { }
                 }
             }
             catch {
-                console.log(chalk_1.default.gray(`skip: ${file}`));
+                console.log(chalk_1.default.gray(`skip: ${item.real}`));
             }
         }
+        // EVENTS DIFF
         const next = engine.getAllEvents();
         const added = next.filter(e => !config.events.includes(e));
         const removed = config.events.filter(e => !next.includes(e));
@@ -81,12 +98,16 @@ async function watch() {
         }
         locked = false;
     };
+    // SCHEDULER
     const schedule = (file) => {
-        queued.add(path_1.default.resolve(file));
+        const abs = path_1.default.resolve(file);
+        const virtual = getVirtualFile(abs);
+        queued.set(abs, { real: abs, virtual });
         if (timer)
             clearTimeout(timer);
-        timer = setTimeout(run, 200);
+        timer = setTimeout(run, 300);
     };
+    // WATCHER
     const watcher = chokidar_1.default.watch(config.sync.include, {
         ignored: config.sync.exclude,
         ignoreInitial: true,
@@ -97,13 +118,19 @@ async function watch() {
         .on("unlink", async (file) => {
         const abs = path_1.default.resolve(file);
         console.log(chalk_1.default.gray(`remove: ${file}`));
-        const { virtualFile } = (0, processFile_1.processFile)(abs, "");
-        engine.removeFile(virtualFile, config);
+        const virtual = getVirtualFile(abs);
+        engine.removeFile(virtual, config);
+        watchedDeps.delete(abs);
         const next = engine.getAllEvents();
         config.events = next.sort();
         await (0, config_1.saveConfig)(config);
         console.log(chalk_1.default.gray(`Total: ${config.events.length} events\n`));
     });
+    // WATCH DEPS
+    for (const dep of watchedDeps) {
+        watcher.add(dep);
+    }
+    // EXIT
     process.on("SIGINT", async () => {
         console.log(chalk_1.default.yellow("\nStopping watcher..."));
         await watcher.close();

package/dist/engine/functionAnalyzer.js

@@ -15,8 +15,20 @@ function findTrackParamIndex(fn) {
     let result = null;
     function visit(node) {
         if (typescript_1.default.isCallExpression(node)) {
-            const name = getCallName(node.expression);
-            if (/(track|event|capture|send)/i.test(name)) {
+            let isTrackCall = false;
+            if (typescript_1.default.isPropertyAccessExpression(node.expression)) {
+                const method = node.expression.name.text;
+                if (method === "track") {
+                    isTrackCall = true;
+                }
+            }
+            // fallback
+            if (typescript_1.default.isIdentifier(node.expression)) {
+                if (node.expression.text === "track") {
+                    isTrackCall = true;
+                }
+            }
+            if (isTrackCall) {
                 for (const arg of node.arguments) {
                     if (typescript_1.default.isIdentifier(arg)) {
                         const idx = paramIndex.get(arg.text);
@@ -25,6 +37,10 @@ function findTrackParamIndex(fn) {
                             return;
                         }
                     }
+                    if (typescript_1.default.isStringLiteral(arg)) {
+                        result = 0;
+                        return;
+                    }
                 }
             }
         }
@@ -35,11 +51,3 @@ function findTrackParamIndex(fn) {
     }
     return result;
 }
-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/engine/resolver.js

@@ -11,42 +11,60 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
         return { values: [], dynamic: true };
     }
     seen.add(node);
+    // param mapping
     if (typescript_1.default.isIdentifier(node) && paramMap?.has(node.text)) {
         return resolveNodeValue(paramMap.get(node.text), checker, paramMap, seen);
     }
+    // STRING
     if (typescript_1.default.isStringLiteral(node)) {
         return { values: [node.text], dynamic: false };
     }
+    // ARRAY
+    if (typescript_1.default.isArrayLiteralExpression(node)) {
+        const values = [];
+        for (const el of node.elements) {
+            const res = resolveNodeValue(el, checker, paramMap, seen);
+            if (res.values.length) {
+                values.push(...res.values);
+            }
+        }
+        return { values, dynamic: true };
+    }
+    // TEMPLATE
     if (typescript_1.default.isTemplateExpression(node)) {
-        let result = node.head.text;
+        let results = [node.head.text];
         for (const span of node.templateSpans) {
-            result += "*";
-            result += span.literal.text;
+            const res = resolveNodeValue(span.expression, checker, paramMap, seen);
+            if (res.values.length) {
+                results = results.flatMap(r => res.values.map(v => r + v));
+            }
+            else {
+                results = results.map(r => r + "*");
+            }
+            results = results.map(r => r + span.literal.text);
         }
-        return { values: [result], dynamic: true };
+        return { values: results, dynamic: true };
     }
+    // CONDITIONAL
     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 ?? [])])],
+            values: [...new Set([...a.values, ...b.values])],
             dynamic: true,
         };
     }
+    // IDENTIFIER
     if (typescript_1.default.isIdentifier(node)) {
         let symbol = checker.getSymbolAtLocation(node);
         if (!symbol)
             return { values: [], dynamic: true };
-        for (const decl of symbol.getDeclarations() ?? []) {
-            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
-                return resolveNodeValue(decl.initializer, checker, paramMap, seen);
-            }
-        }
-        const original = symbol;
+        // unwrap export
         symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
-        if (symbol !== original && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
+        if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
             symbol = checker.getAliasedSymbol(symbol);
         }
+        // inline variable
         for (const decl of symbol.getDeclarations() ?? []) {
             if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
                 return resolveNodeValue(decl.initializer, checker, paramMap, seen);
@@ -60,12 +78,30 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
+        // UNION TYPES
+        const type = checker.getTypeAtLocation(node);
+        if (type.isUnion()) {
+            const values = [];
+            for (const t of type.types) {
+                if (t.isStringLiteral?.()) {
+                    values.push(t.value);
+                }
+            }
+            if (values.length) {
+                return { values, dynamic: false };
+            }
+        }
+        // TYPE FALLBACK (as const)
+        if (type.isStringLiteral?.()) {
+            return { values: [type.value], dynamic: false };
+        }
         return { values: [], dynamic: true };
     }
+    // PROPERTY ACCESS (obj.a.b)
     if (typescript_1.default.isPropertyAccessExpression(node)) {
         const symbol = checker.getSymbolAtLocation(node);
         if (symbol) {
-            let s = symbol;
+            let s = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
             if (s.flags & typescript_1.default.SymbolFlags.Alias) {
                 s = checker.getAliasedSymbol(s);
             }
@@ -80,6 +116,20 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
+        // constant enum / readonly
+        const constantValue = checker.getConstantValue(node);
+        if (typeof constantValue === "string") {
+            return { values: [constantValue], dynamic: false };
+        }
+        // type fallback
+        const type = checker.getTypeAtLocation(node);
+        if (type.isStringLiteral?.()) {
+            return {
+                values: [type.value],
+                dynamic: false,
+            };
+        }
+        // object literal resolve
         if (typescript_1.default.isIdentifier(node.expression)) {
             const objSymbol = checker.getSymbolAtLocation(node.expression);
             if (objSymbol) {
@@ -101,33 +151,59 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
         }
         return { values: [], dynamic: true };
     }
+    // ARRAY ACCESS (arr[0])
+    if (typescript_1.default.isElementAccessExpression(node)) {
+        const obj = resolveNodeValue(node.expression, checker, paramMap, seen);
+        if (!node.argumentExpression) {
+            return { values: obj.values, dynamic: true };
+        }
+        const index = resolveNodeValue(node.argumentExpression, checker, paramMap, seen);
+        // if index known
+        if (index.values.length === 1) {
+            const i = Number(index.values[0]);
+            if (!Number.isNaN(i) && obj.values[i] !== undefined) {
+                return {
+                    values: [obj.values[i]],
+                    dynamic: false,
+                };
+            }
+        }
+        // fallback → dynamic
+        return obj.values.length
+            ? { values: obj.values, dynamic: true }
+            : { values: [], dynamic: true };
+    }
+    // OBJECT
     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") {
+            if (["event", "name", "type"].includes(name)) {
                 const res = resolveNodeValue(prop.initializer, checker, paramMap, seen);
                 values.push(...res.values);
             }
         }
         return { values, dynamic: true };
     }
+    // BINARY ("btn_" + name)
     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.length
-                        ? right.values.map(r => l + r)
-                        : [l + "*"]),
-                    dynamic: true,
-                };
+            if (!left.values.length) {
+                return { values: [], dynamic: true };
             }
+            return {
+                values: left.values.flatMap(l => right.values.length
+                    ? right.values.map(r => l + r)
+                    : [l + "*"]),
+                dynamic: true,
+            };
         }
     }
+    // CALL → dynamic
     if (typescript_1.default.isCallExpression(node)) {
         return { values: [], dynamic: true };
     }

package/dist/utils/universal.js

@@ -6,10 +6,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseUniversal = parseUniversal;
 const path_1 = __importDefault(require("path"));
 /**
- * exact JS:
- * - {...}
- * - attr="..."
- * - Vue / Svelte handlers
+ * Strip comments (HTML + JS)
+ */
+function stripComments(input) {
+    return input
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/\/\/.*$/gm, "");
+}
+/**
+ * Extract JS expressions safely
  */
 function extractJS(input) {
     const result = [];
@@ -66,8 +72,13 @@ function extractJS(input) {
             }
             if (depth === 0) {
                 const expr = input.slice(i + 1, j - 1).trim();
-                if (expr)
+                if (expr &&
+                    (expr.includes("(") ||
+                        expr.includes("=") ||
+                        expr.includes(".") ||
+                        expr.includes("track"))) {
                     result.push(expr);
+                }
                 i = j;
                 continue;
             }
@@ -89,8 +100,12 @@ function extractJS(input) {
                 val += c;
                 j++;
             }
-            if (val.trim())
+            if (val.trim() &&
+                (val.includes("(") ||
+                    val.includes("=>") ||
+                    val.includes("track"))) {
                 result.push(val.trim());
+            }
             i = j + 1;
             continue;
         }
@@ -113,6 +128,9 @@ function extractJS(input) {
     }
     return result;
 }
+/**
+ * Extract loose JS but less noisy
+ */
 function extractLooseJS(input) {
     const result = [];
     const lines = input.split("\n");
@@ -122,33 +140,30 @@ function extractLooseJS(input) {
             continue;
         if (l.startsWith("<"))
             continue;
-        if (l.includes("(") ||
-            l.includes("=") ||
+        // strict filter
+        if (l.includes("track") ||
+            l.includes(".track(") ||
             l.includes("=>") ||
-            l.includes("function") ||
-            l.includes("track")) {
+            l.startsWith("function") ||
+            l.includes("(")) {
             result.push(l);
         }
     }
     return result;
 }
 /**
- * Universal:
- * - Astro
- * - Vue
- * - Svelte
- * - React / JSX
- * - Node / backend
+ * Universal parser
  */
 function parseUniversal(content, file) {
     const parts = [];
     const deps = [];
-    //  Astro frontmatter ---
-    const fm = content.match(/^---([\s\S]*?)---/);
+    const clean = stripComments(content);
+    // Astro frontmatter
+    const fm = clean.match(/^---([\s\S]*?)---/);
     if (fm?.[1])
         parts.push(fm[1]);
     // <script src="">
-    const scriptSrc = content.matchAll(/<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g);
+    const scriptSrc = clean.matchAll(/<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g);
     for (const s of scriptSrc) {
         const src = s[1];
         const resolved = src.startsWith("/")
@@ -157,18 +172,23 @@ function parseUniversal(content, file) {
         deps.push(resolved);
     }
     // inline <script>
-    const scripts = content.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script>/g);
+    const scripts = clean.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script>/g);
     for (const m of scripts) {
-        if (m[1].trim())
-            parts.push(m[1]);
+        const attrs = m[1];
+        // skip JSON / data
+        if (/type=["']application\/json/.test(attrs))
+            continue;
+        if (m[2].trim()) {
+            parts.push(m[2]);
+        }
     }
-    const noScripts = content.replace(/<script[\s\S]*?<\/script>/g, "");
+    // remove scripts
+    const noScripts = clean.replace(/<script[\s\S]*?<\/script>/g, "");
+    // loose JS
     const loose = extractLooseJS(noScripts);
-    for (const l of loose) {
-        parts.push(l);
-    }
+    parts.push(...loose);
     // expressions
-    const extracted = extractJS(content);
+    const extracted = extractJS(clean);
     for (const e of extracted) {
         parts.push(e + ";");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {

package/src/commands/watch.ts

@@ -8,6 +8,18 @@ import { loadConfig, saveConfig } from "../utils/config";
 import { EventraEngine } from "../engine/engine";
 import { processFile } from "../utils/processFile";
 
+type QueueItem = {
+  real: string;
+  virtual: string;
+};
+
+// stabile virtual mapping
+function getVirtualFile(file: string) {
+  return /\.(vue|svelte|astro|html)$/i.test(file)
+    ? file + ".tsx"
+    : file;
+}
+
 export async function watch() {
   const config = await loadConfig();
   if (!config) return;
@@ -20,25 +32,29 @@ export async function watch() {
 
   const engine = new EventraEngine(process.cwd());
 
-  const fileCache: { file: string; content: string }[] = [];
+  const watchedDeps = new Set<string>();
 
-  // PRELOAD TS
+  // INITIAL LOAD
   for (const file of files) {
     try {
       const abs = path.resolve(file);
       const raw = await fs.readFile(abs, "utf-8");
-      const { content, virtualFile } = processFile(abs, raw);
-      fileCache.push({ file: virtualFile, content });
+
+      const { content, deps } = processFile(abs, raw);
+      const virtual = getVirtualFile(abs);
+
+      engine.scanFile(virtual, content, config);
+
+      // deps
+      for (const dep of deps) {
+        watchedDeps.add(path.resolve(dep));
+      }
+
     } catch {
       console.log(chalk.gray(`skip: ${file}`));
     }
   }
 
-  // INITIAL SCAN
-  for (const { file, content } of fileCache) {
-    engine.scanFile(file, content, config);
-  }
-
   config.events = engine.getAllEvents().sort();
   await saveConfig(config);
 
@@ -46,45 +62,55 @@ export async function watch() {
     chalk.gray(`Initial: ${config.events.length} events\n`)
   );
 
+  // QUEUE
   let locked = false;
-  let queued = new Set<string>();
+  let queued = new Map<string, QueueItem>();
   let timer: NodeJS.Timeout | null = null;
 
   const run = async () => {
-    if (locked) return;
+    if (locked) {
+      timer = setTimeout(run, 100);
+      return;
+    }
+
     locked = true;
 
-    const batch = [...queued];
+    const batch = [...queued.values()];
     queued.clear();
 
-    for (const file of batch) {
+    for (const item of batch) {
       try {
-        const raw = await fs.readFile(file, "utf-8");
+        const raw = await fs.readFile(item.real, "utf-8");
 
-        const { content, virtualFile, deps } = processFile(file, raw);
+        const { content, deps } = processFile(item.real, raw);
 
-        engine.updateFile(virtualFile, content, config);
+        engine.updateFile(item.virtual, content, config);
 
-        // deps
+        // DEPS
         for (const dep of deps) {
+          const absDep = path.resolve(dep);
+
+          if (!watchedDeps.has(absDep)) {
+            watcher.add(absDep);
+            watchedDeps.add(absDep);
+          }
+
           try {
-            const depRaw = await fs.readFile(dep, "utf-8");
+            const depRaw = await fs.readFile(absDep, "utf-8");
+            const { content: depContent } = processFile(absDep, depRaw);
 
-            const {
-              content: depContent,
-              virtualFile: depVirtual,
-            } = processFile(dep, depRaw);
+            const depVirtual = getVirtualFile(absDep);
 
             engine.updateFile(depVirtual, depContent, config);
-
           } catch {}
         }
 
       } catch {
-        console.log(chalk.gray(`skip: ${file}`));
+        console.log(chalk.gray(`skip: ${item.real}`));
       }
     }
 
+    // EVENTS DIFF
     const next = engine.getAllEvents();
 
     const added = next.filter(e => !config.events.includes(e));
@@ -105,13 +131,18 @@ export async function watch() {
     locked = false;
   };
 
+  // SCHEDULER
   const schedule = (file: string) => {
-    queued.add(path.resolve(file));
+    const abs = path.resolve(file);
+    const virtual = getVirtualFile(abs);
+
+    queued.set(abs, { real: abs, virtual });
 
     if (timer) clearTimeout(timer);
-    timer = setTimeout(run, 200);
+    timer = setTimeout(run, 300);
   };
 
+  // WATCHER
   const watcher = chokidar.watch(config.sync.include, {
     ignored: config.sync.exclude,
     ignoreInitial: true,
@@ -125,9 +156,11 @@ export async function watch() {
 
       console.log(chalk.gray(`remove: ${file}`));
 
-      const { virtualFile } = processFile(abs, "");
+      const virtual = getVirtualFile(abs);
+
+      engine.removeFile(virtual, config);
 
-      engine.removeFile(virtualFile, config);
+      watchedDeps.delete(abs);
 
       const next = engine.getAllEvents();
 
@@ -139,6 +172,12 @@ export async function watch() {
       );
     });
 
+  // WATCH DEPS
+  for (const dep of watchedDeps) {
+    watcher.add(dep);
+  }
+
+  // EXIT
   process.on("SIGINT", async () => {
     console.log(chalk.yellow("\nStopping watcher..."));
     await watcher.close();

package/src/engine/functionAnalyzer.ts

@@ -15,9 +15,24 @@ export function findTrackParamIndex(
 
   function visit(node: ts.Node) {
     if (ts.isCallExpression(node)) {
-      const name = getCallName(node.expression);
+      let isTrackCall = false;
 
-      if (/(track|event|capture|send)/i.test(name)) {
+      if (ts.isPropertyAccessExpression(node.expression)) {
+        const method = node.expression.name.text;
+
+        if (method === "track") {
+          isTrackCall = true;
+        }
+      }
+
+      // fallback
+      if (ts.isIdentifier(node.expression)) {
+        if (node.expression.text === "track") {
+          isTrackCall = true;
+        }
+      }
+
+      if (isTrackCall) {
         for (const arg of node.arguments) {
           if (ts.isIdentifier(arg)) {
             const idx = paramIndex.get(arg.text);
@@ -26,6 +41,11 @@ export function findTrackParamIndex(
               return;
             }
           }
+
+          if (ts.isStringLiteral(arg)) {
+            result = 0;
+            return;
+          }
         }
       }
     }
@@ -39,13 +59,3 @@ export function findTrackParamIndex(
 
   return result;
 }
-
-function getCallName(expr: ts.Expression): string {
-  if (ts.isIdentifier(expr)) return expr.text;
-
-  if (ts.isPropertyAccessExpression(expr)) {
-    return expr.name.text;
-  }
-
-  return "";
-}

package/src/engine/resolver.ts

@@ -12,12 +12,12 @@ export function resolveNodeValue(
   paramMap?: Map<string, ts.Expression>,
   seen = new Set<ts.Node>()
 ): ResolveResult {
-
   if (seen.has(node)) {
     return { values: [], dynamic: true };
   }
   seen.add(node);
 
+  // param mapping
   if (ts.isIdentifier(node) && paramMap?.has(node.text)) {
     return resolveNodeValue(
       paramMap.get(node.text)!,
@@ -27,54 +27,70 @@ export function resolveNodeValue(
     );
   }
 
+  // STRING
   if (ts.isStringLiteral(node)) {
     return { values: [node.text], dynamic: false };
   }
 
+  // ARRAY
+  if (ts.isArrayLiteralExpression(node)) {
+    const values: string[] = [];
+
+    for (const el of node.elements) {
+      const res = resolveNodeValue(el, checker, paramMap, seen);
+      if (res.values.length) {
+        values.push(...res.values);
+      }
+    }
+
+    return { values, dynamic: true };
+  }
+
+  // TEMPLATE
   if (ts.isTemplateExpression(node)) {
-    let result = node.head.text;
+    let results = [node.head.text];
 
     for (const span of node.templateSpans) {
-      result += "*";
-      result += span.literal.text;
+      const res = resolveNodeValue(span.expression, checker, paramMap, seen);
+
+      if (res.values.length) {
+        results = results.flatMap(r =>
+          res.values.map(v => r + v)
+        );
+      } else {
+        results = results.map(r => r + "*");
+      }
+
+      results = results.map(r => r + span.literal.text);
     }
 
-    return { values: [result], dynamic: true };
+    return { values: results, dynamic: true };
   }
 
+  // CONDITIONAL
   if (ts.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 ?? [])])],
+      values: [...new Set([...a.values, ...b.values])],
       dynamic: true,
     };
   }
 
+  // IDENTIFIER
   if (ts.isIdentifier(node)) {
     let symbol = checker.getSymbolAtLocation(node);
     if (!symbol) return { values: [], dynamic: true };
 
-    for (const decl of symbol.getDeclarations() ?? []) {
-      if (ts.isVariableDeclaration(decl) && decl.initializer) {
-        return resolveNodeValue(
-          decl.initializer,
-          checker,
-          paramMap,
-          seen
-        );
-      }
-    }
-
-    const original = symbol;
-
+    // unwrap export
     symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
 
-    if (symbol !== original && (symbol.flags & ts.SymbolFlags.Alias)) {
+    if (symbol.flags & ts.SymbolFlags.Alias) {
       symbol = checker.getAliasedSymbol(symbol);
     }
 
+    // inline variable
     for (const decl of symbol.getDeclarations() ?? []) {
       if (ts.isVariableDeclaration(decl) && decl.initializer) {
         return resolveNodeValue(
@@ -95,14 +111,38 @@ export function resolveNodeValue(
       }
     }
 
+    // UNION TYPES
+    const type = checker.getTypeAtLocation(node);
+
+    if (type.isUnion()) {
+      const values: string[] = [];
+
+      for (const t of type.types) {
+        if ((t as any).isStringLiteral?.()) {
+          values.push((t as any).value);
+        }
+      }
+
+      if (values.length) {
+        return { values, dynamic: false };
+      }
+    }
+
+    // TYPE FALLBACK (as const)
+    if ((type as any).isStringLiteral?.()) {
+      return { values: [(type as any).value], dynamic: false };
+    }
+
     return { values: [], dynamic: true };
   }
 
+  // PROPERTY ACCESS (obj.a.b)
   if (ts.isPropertyAccessExpression(node)) {
+
     const symbol = checker.getSymbolAtLocation(node);
 
     if (symbol) {
-      let s = symbol;
+      let s = resolveExportedSymbol(symbol, checker) ?? symbol;
 
       if (s.flags & ts.SymbolFlags.Alias) {
         s = checker.getAliasedSymbol(s);
@@ -120,6 +160,23 @@ export function resolveNodeValue(
       }
     }
 
+    // constant enum / readonly
+    const constantValue = checker.getConstantValue(node as any);
+    if (typeof constantValue === "string") {
+      return { values: [constantValue], dynamic: false };
+    }
+
+    // type fallback
+    const type = checker.getTypeAtLocation(node);
+
+    if ((type as any).isStringLiteral?.()) {
+      return {
+        values: [(type as any).value],
+        dynamic: false,
+      };
+    }
+
+    // object literal resolve
     if (ts.isIdentifier(node.expression)) {
       const objSymbol = checker.getSymbolAtLocation(node.expression);
 
@@ -152,6 +209,40 @@ export function resolveNodeValue(
     return { values: [], dynamic: true };
   }
 
+  // ARRAY ACCESS (arr[0])
+  if (ts.isElementAccessExpression(node)) {
+    const obj = resolveNodeValue(node.expression, checker, paramMap, seen);
+
+    if (!node.argumentExpression) {
+      return { values: obj.values, dynamic: true };
+    }
+
+    const index = resolveNodeValue(
+      node.argumentExpression,
+      checker,
+      paramMap,
+      seen
+    );
+
+    // if index known
+    if (index.values.length === 1) {
+      const i = Number(index.values[0]);
+
+      if (!Number.isNaN(i) && obj.values[i] !== undefined) {
+        return {
+          values: [obj.values[i]],
+          dynamic: false,
+        };
+      }
+    }
+
+    // fallback → dynamic
+    return obj.values.length
+      ? { values: obj.values, dynamic: true }
+      : { values: [], dynamic: true };
+  }
+
+  // OBJECT
   if (ts.isObjectLiteralExpression(node)) {
     const values: string[] = [];
 
@@ -160,7 +251,7 @@ export function resolveNodeValue(
 
       const name = prop.name.getText();
 
-      if (name === "event") {
+      if (["event", "name", "type"].includes(name)) {
         const res = resolveNodeValue(prop.initializer, checker, paramMap, seen);
         values.push(...res.values);
       }
@@ -169,24 +260,28 @@ export function resolveNodeValue(
     return { values, dynamic: true };
   }
 
+  // BINARY ("btn_" + name)
   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.length
-              ? right.values.map(r => l + r)
-              : [l + "*"]
-          ),
-          dynamic: true,
-        };
+      if (!left.values.length) {
+        return { values: [], dynamic: true };
       }
+
+      return {
+        values: left.values.flatMap(l =>
+          right.values.length
+            ? right.values.map(r => l + r)
+            : [l + "*"]
+        ),
+        dynamic: true,
+      };
     }
   }
 
+  // CALL → dynamic
   if (ts.isCallExpression(node)) {
     return { values: [], dynamic: true };
   }

package/src/utils/universal.ts

@@ -2,10 +2,17 @@ import path from "path";
 import { ParseResult } from "../types";
 
 /**
- * exact JS:
- * - {...}
- * - attr="..."
- * - Vue / Svelte handlers
+ * Strip comments (HTML + JS)
+ */
+function stripComments(input: string): string {
+  return input
+    .replace(/<!--[\s\S]*?-->/g, "")
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/\/\/.*$/gm, "");
+}
+
+/**
+ * Extract JS expressions safely
  */
 function extractJS(input: string): string[] {
   const result: string[] = [];
@@ -24,7 +31,6 @@ function extractJS(input: string): string[] {
       if (escape) escape = false;
       else if (ch === "\\") escape = true;
       else if (ch === inString) inString = null;
-
       i++;
       continue;
     }
@@ -68,7 +74,17 @@ function extractJS(input: string): string[] {
 
       if (depth === 0) {
         const expr = input.slice(i + 1, j - 1).trim();
-        if (expr) result.push(expr);
+
+        if (
+          expr &&
+          (expr.includes("(") ||
+            expr.includes("=") ||
+            expr.includes(".") ||
+            expr.includes("track"))
+        ) {
+          result.push(expr);
+        }
+
         i = j;
         continue;
       }
@@ -95,7 +111,14 @@ function extractJS(input: string): string[] {
         j++;
       }
 
-      if (val.trim()) result.push(val.trim());
+      if (
+        val.trim() &&
+        (val.includes("(") ||
+          val.includes("=>") ||
+          val.includes("track"))
+      ) {
+        result.push(val.trim());
+      }
 
       i = j + 1;
       continue;
@@ -123,6 +146,9 @@ function extractJS(input: string): string[] {
   return result;
 }
 
+/**
+ * Extract loose JS but less noisy
+ */
 function extractLooseJS(input: string): string[] {
   const result: string[] = [];
 
@@ -134,12 +160,13 @@ function extractLooseJS(input: string): string[] {
     if (!l) continue;
     if (l.startsWith("<")) continue;
 
+    // strict filter
     if (
-      l.includes("(") ||
-      l.includes("=") ||
+      l.includes("track") ||
+      l.includes(".track(") ||
       l.includes("=>") ||
-      l.includes("function") ||
-      l.includes("track")
+      l.startsWith("function") ||
+      l.includes("(")
     ) {
       result.push(l);
     }
@@ -149,14 +176,8 @@ function extractLooseJS(input: string): string[] {
 }
 
 /**
- * Universal:
- * - Astro
- * - Vue
- * - Svelte
- * - React / JSX
- * - Node / backend
+ * Universal parser
  */
-
 export function parseUniversal(
   content: string,
   file: string
@@ -164,12 +185,14 @@ export function parseUniversal(
   const parts: string[] = [];
   const deps: string[] = [];
 
-  //  Astro frontmatter ---
-  const fm = content.match(/^---([\s\S]*?)---/);
+  const clean = stripComments(content);
+
+  // Astro frontmatter
+  const fm = clean.match(/^---([\s\S]*?)---/);
   if (fm?.[1]) parts.push(fm[1]);
 
   // <script src="">
-  const scriptSrc = content.matchAll(
+  const scriptSrc = clean.matchAll(
     /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g
   );
 
@@ -184,28 +207,33 @@ export function parseUniversal(
   }
 
   // inline <script>
-  const scripts = content.matchAll(
-    /<script\b[^>]*>([\s\S]*?)<\/script>/g
+  const scripts = clean.matchAll(
+    /<script\b([^>]*)>([\s\S]*?)<\/script>/g
   );
 
   for (const m of scripts) {
-    if (m[1].trim()) parts.push(m[1]);
+    const attrs = m[1];
+
+    // skip JSON / data
+    if (/type=["']application\/json/.test(attrs)) continue;
+
+    if (m[2].trim()) {
+      parts.push(m[2]);
+    }
   }
 
-  const noScripts = content.replace(
+  // remove scripts
+  const noScripts = clean.replace(
     /<script[\s\S]*?<\/script>/g,
     ""
   );
 
+  // loose JS
   const loose = extractLooseJS(noScripts);
-
-  for (const l of loose) {
-    parts.push(l);
-  }
+  parts.push(...loose);
 
   // expressions
-  const extracted = extractJS(content);
-
+  const extracted = extractJS(clean);
   for (const e of extracted) {
     parts.push(e + ";");
   }