@eventra_dev/eventra-cli 0.1.27 → 0.1.29

package/dist/engine/scanner.js

@@ -18,23 +18,6 @@ function getCallName(expr) {
         return expr.name.text;
     return "";
 }
-function getJsxAttrName(name) {
-    if (typescript_1.default.isIdentifier(name))
-        return name.text;
-    if (typescript_1.default.isJsxNamespacedName(name))
-        return name.name.text;
-    return null;
-}
-// unwrap
-function unwrap(expr) {
-    while (typescript_1.default.isAsExpression(expr) ||
-        typescript_1.default.isParenthesizedExpression(expr) ||
-        typescript_1.default.isTypeAssertionExpression(expr) ||
-        typescript_1.default.isNonNullExpression(expr)) {
-        expr = expr.expression;
-    }
-    return expr;
-}
 function isValidEvent(v) {
     return (v &&
         v.length > 1 &&
@@ -42,63 +25,60 @@ function isValidEvent(v) {
         !v.includes(" ") &&
         /^[a-zA-Z0-9._:-]+$/.test(v));
 }
-function isPropUsedInTracking(fn, checker, prop) {
-    let found = false;
-    function visit(node) {
-        if (typescript_1.default.isCallExpression(node)) {
-            if (!(0, trackingDetector_1.isTrackingCall)(node, checker)) {
-                typescript_1.default.forEachChild(node, visit);
-                return;
-            }
-            for (const arg of node.arguments) {
-                const a = unwrap(arg);
-                if ((typescript_1.default.isIdentifier(a) && a.text === prop) ||
-                    (typescript_1.default.isPropertyAccessExpression(a) &&
-                        a.name.text === prop)) {
-                    found = true;
-                }
-            }
-        }
-        typescript_1.default.forEachChild(node, visit);
+function resolveFunctionDeep(expr, checker) {
+    let fn = (0, callResolver_1.resolveFunctionFromCall)(expr, checker);
+    if (fn)
+        return fn;
+    let symbol = checker.getSymbolAtLocation(expr);
+    if (!symbol)
+        return null;
+    if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
     }
-    if (fn.body) {
-        visit(fn.body);
+    const resolvedSymbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
+    for (const decl of resolvedSymbol.getDeclarations() ?? []) {
+        if (typescript_1.default.isFunctionDeclaration(decl)) {
+            return decl;
+        }
+        if (typescript_1.default.isVariableDeclaration(decl) &&
+            decl.initializer &&
+            (typescript_1.default.isArrowFunction(decl.initializer) ||
+                typescript_1.default.isFunctionExpression(decl.initializer))) {
+            return decl.initializer;
+        }
     }
-    return found;
+    return null;
 }
 function scanSource(source, checker, config, visited = new Set(), depth = 0, inheritedParamMap) {
     const events = new Set();
     const detectedFunctionWrappers = new Set();
     const detectedComponentWrappers = new Map();
-    if (visited.has(source.fileName) ||
-        depth > 10 ||
-        visited.size > 200) {
+    if (visited.size > 200 || visited.has(source.fileName)) {
         return { events, detectedFunctionWrappers, detectedComponentWrappers };
     }
     visited.add(source.fileName);
     function visit(node) {
         // CALL EXPRESSIONS
         if (typescript_1.default.isCallExpression(node)) {
-            const expr = unwrap(node.expression);
-            const name = getCallName(expr);
+            const name = getCallName(node.expression);
             const isKnownWrapper = config.functionWrappers.some(w => w.name === name);
             const isTrackingByType = (0, trackingDetector_1.isTrackingCall)(node, checker);
-            let resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(expr, checker);
+            const resolvedFn = resolveFunctionDeep(node.expression, checker);
             const isAutoWrapper = resolvedFn && (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn) !== null;
             let isTracking = isKnownWrapper ||
                 isTrackingByType ||
                 name.startsWith("$") ||
                 (isAutoWrapper &&
                     resolvedFn &&
+                    resolvedFn.getSourceFile &&
                     !(0, boundary_1.isExternalFile)(resolvedFn.getSourceFile().fileName));
-            // fallback
             if (!isTracking) {
-                if (typescript_1.default.isPropertyAccessExpression(expr) &&
-                    expr.name.text === "track") {
+                if (typescript_1.default.isPropertyAccessExpression(node.expression) &&
+                    node.expression.name.text === "track") {
                     isTracking = true;
                 }
-                else if (typescript_1.default.isIdentifier(expr) &&
-                    expr.text === "track") {
+                else if (typescript_1.default.isIdentifier(node.expression) &&
+                    node.expression.text === "track") {
                     isTracking = true;
                 }
             }
@@ -106,13 +86,14 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
                 typescript_1.default.forEachChild(node, visit);
                 return;
             }
-            // detect wrapper
+            // DETECT WRAPPER
             if (!isKnownWrapper &&
                 isAutoWrapper &&
                 !isTrackingByType &&
                 !name.startsWith("track")) {
                 detectedFunctionWrappers.add(name);
             }
+            // PARAM MAP
             const paramMap = new Map(inheritedParamMap ?? []);
             if (resolvedFn && typescript_1.default.isFunctionLike(resolvedFn)) {
                 resolvedFn.parameters.forEach((param, i) => {
@@ -124,100 +105,26 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
                     }
                 });
             }
-            let handled = false;
-            // MAIN RESOLVE
+            // STRICT EVENT RESOLVE
             if (resolvedFn) {
                 const idx = (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn);
                 if (idx !== null && node.arguments[idx]) {
-                    const res = (0, resolver_1.resolveNodeValue)(unwrap(node.arguments[idx]), checker, paramMap);
-                    res.values.forEach(v => {
-                        if (isValidEvent(v))
-                            events.add(v);
-                    });
-                    handled = true;
-                }
-            }
-            // FALLBACK
-            if (!handled) {
-                for (const arg of node.arguments) {
-                    const res = (0, resolver_1.resolveNodeValue)(unwrap(arg), checker, paramMap);
+                    const res = (0, resolver_1.resolveNodeValue)(node.arguments[idx], checker, paramMap);
                     res.values.forEach(v => {
                         if (isValidEvent(v))
                             events.add(v);
                     });
                 }
             }
-            // CROSS FILE
+            // CROSS-FILE
             if (resolvedFn) {
-                const sf = resolvedFn.getSourceFile();
-                if (!visited.has(sf.fileName)) {
+                const sf = resolvedFn.getSourceFile?.();
+                if (sf && !visited.has(sf.fileName)) {
                     const res = scanSource(sf, checker, config, visited, depth + 1, paramMap);
                     res.events.forEach(e => events.add(e));
                 }
             }
         }
-        // JSX COMPONENTS
-        if (typescript_1.default.isJsxSelfClosingElement(node) ||
-            typescript_1.default.isJsxOpeningElement(node)) {
-            const tagNode = typescript_1.default.isPropertyAccessExpression(node.tagName)
-                ? node.tagName.name
-                : node.tagName;
-            let symbol = checker.getSymbolAtLocation(tagNode);
-            if (symbol) {
-                symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
-            }
-            if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
-                symbol = checker.getAliasedSymbol(symbol);
-            }
-            if (!symbol) {
-                typescript_1.default.forEachChild(node, visit);
-                return;
-            }
-            const tagName = typescript_1.default.isPropertyAccessExpression(node.tagName)
-                ? node.tagName.name.getText()
-                : node.tagName.getText();
-            for (const decl of symbol.getDeclarations() ?? []) {
-                let fn = null;
-                if (typescript_1.default.isFunctionDeclaration(decl))
-                    fn = decl;
-                if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
-                    const init = decl.initializer;
-                    if (typescript_1.default.isArrowFunction(init) ||
-                        typescript_1.default.isFunctionExpression(init)) {
-                        fn = init;
-                    }
-                }
-                if (!fn)
-                    continue;
-                const param = fn.parameters[0];
-                if (!param || !typescript_1.default.isObjectBindingPattern(param.name))
-                    continue;
-                for (const el of param.name.elements) {
-                    const prop = el.name.getText();
-                    const isEvent = isPropUsedInTracking(fn, checker, prop) ||
-                        config.wrappers.some(w => w.name === tagName && w.prop === prop);
-                    if (!isEvent)
-                        continue;
-                    const attr = node.attributes.properties.find(p => {
-                        if (!typescript_1.default.isJsxAttribute(p))
-                            return false;
-                        return getJsxAttrName(p.name) === prop;
-                    });
-                    if (!attr || !attr.initializer)
-                        continue;
-                    const expr = typescript_1.default.isJsxExpression(attr.initializer)
-                        ? attr.initializer.expression
-                        : attr.initializer;
-                    if (!expr)
-                        continue;
-                    const paramMap = new Map();
-                    paramMap.set(prop, expr);
-                    const res = scanSource(fn.getSourceFile(), checker, config, visited, depth + 1, paramMap);
-                    res.events.forEach(e => events.add(e));
-                    detectedComponentWrappers.set(tagName, prop);
-                }
-            }
-        }
         typescript_1.default.forEachChild(node, visit);
     }
     visit(source);

package/dist/utils/universal.js

@@ -5,18 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseUniversal = parseUniversal;
 const path_1 = __importDefault(require("path"));
-/**
- * Strip comments (HTML + JS)
- */
+// Strip comments (HTML + JS)
 function stripComments(input) {
     return input
         .replace(/<!--[\s\S]*?-->/g, "")
         .replace(/\/\*[\s\S]*?\*\//g, "")
         .replace(/\/\/.*$/gm, "");
 }
-/**
- * Extract JS expressions
- */
+// Extract JS expressions inside {}
 function extractJS(input) {
     const result = [];
     let i = 0;
@@ -63,34 +59,38 @@ function extractJS(input) {
     }
     return result;
 }
-/**
- * Loose JS extractor
- */
-function extractLooseJS(input) {
+// Extract inline HTML handlers
+function extractInlineHandlers(input) {
     const result = [];
-    const lines = input.split("\n");
-    for (const line of lines) {
-        const l = line.trim();
-        if (!l)
-            continue;
-        if (l.startsWith("<"))
-            continue;
-        if (/[a-zA-Z0-9_$]\s*\(/.test(l)) {
-            result.push(l);
+    const matches = input.matchAll(/\bon\w+\s*=\s*["']([^"']+)["']/g);
+    for (const m of matches) {
+        const code = m[1];
+        if (/[a-zA-Z0-9_$]\s*\(/.test(code)) {
+            result.push(code);
         }
     }
     return result;
 }
-/**
- * UNIVERSAL PARSER
- * Support:
- * - React / JSX
- * - Vue
- * - Svelte
- * - Astro
- * - HTML + JS
- * - SSR
- */
+// Extract dynamic imports
+function extractDynamicImports(input, file) {
+    const deps = [];
+    const calls = [];
+    const matches = input.matchAll(/import\(\s*["'](.+?)["']\s*\)/g);
+    for (const m of matches) {
+        const mod = m[1];
+        const resolved = mod.startsWith("/")
+            ? path_1.default.resolve(process.cwd(), "." + mod)
+            : path_1.default.resolve(path_1.default.dirname(file), mod);
+        deps.push(resolved);
+        calls.push(`import("${mod}")`);
+    }
+    return { deps, calls };
+}
+// Filter only probable tracking-related code
+function isProbablyTracking(code) {
+    return /track|event|analytics/i.test(code);
+}
+// UNIVERSAL PARSER
 function parseUniversal(content, file) {
     const parts = [];
     const deps = [];
@@ -113,7 +113,6 @@ function parseUniversal(content, file) {
     const scripts = clean.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script>/g);
     for (const m of scripts) {
         const attrs = m[1];
-        // skip JSON
         if (/type=["']application\/json/.test(attrs))
             continue;
         if (m[2].trim()) {
@@ -122,14 +121,19 @@ function parseUniversal(content, file) {
     }
     // REMOVE SCRIPTS → TEMPLATE PART
     const noScripts = clean.replace(/<script[\s\S]*?<\/script>/g, "");
-    // LOOSE JS
-    parts.push(...extractLooseJS(noScripts));
+    // INLINE HANDLERS
+    parts.push(...extractInlineHandlers(noScripts).filter(isProbablyTracking));
+    // DYNAMIC IMPORTS
+    const dyn = extractDynamicImports(clean, file);
+    deps.push(...dyn.deps);
+    parts.push(...dyn.calls.filter(isProbablyTracking));
     // EXPRESSIONS
     const extracted = extractJS(clean);
     for (const e of extracted) {
-        parts.push(e + ";");
+        if (isProbablyTracking(e)) {
+            parts.push(e + ";");
+        }
     }
-    // RESULT
     return {
         code: [...new Set(parts)].join("\n"),
         deps: [...new Set(deps.filter(Boolean))],

package/package.json

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

package/src/engine/scanner.ts

@@ -13,25 +13,6 @@ function getCallName(expr: ts.Expression): string {
   return "";
 }
 
-function getJsxAttrName(name: ts.JsxAttributeName): string | null {
-  if (ts.isIdentifier(name)) return name.text;
-  if (ts.isJsxNamespacedName(name)) return name.name.text;
-  return null;
-}
-
-// unwrap
-function unwrap(expr: ts.Expression): ts.Expression {
-  while (
-    ts.isAsExpression(expr) ||
-    ts.isParenthesizedExpression(expr) ||
-    ts.isTypeAssertionExpression(expr) ||
-    ts.isNonNullExpression(expr)
-    ) {
-    expr = expr.expression;
-  }
-  return expr;
-}
-
 function isValidEvent(v: string) {
   return (
     v &&
@@ -42,41 +23,40 @@ function isValidEvent(v: string) {
   );
 }
 
-function isPropUsedInTracking(
-  fn: ts.FunctionLikeDeclaration,
-  checker: ts.TypeChecker,
-  prop: string
-) {
-  let found = false;
+function resolveFunctionDeep(
+  expr: ts.Expression,
+  checker: ts.TypeChecker
+): ts.FunctionLikeDeclaration | null {
+  let fn = resolveFunctionFromCall(expr, checker);
+  if (fn) return fn;
 
-  function visit(node: ts.Node) {
-    if (ts.isCallExpression(node)) {
-      if (!isTrackingCall(node, checker)) {
-        ts.forEachChild(node, visit);
-        return;
-      }
-
-      for (const arg of node.arguments) {
-        const a = unwrap(arg as ts.Expression);
+  let symbol = checker.getSymbolAtLocation(expr);
 
-        if (
-          (ts.isIdentifier(a) && a.text === prop) ||
-          (ts.isPropertyAccessExpression(a) &&
-            a.name.text === prop)
-        ) {
-          found = true;
-        }
-      }
-    }
+  if (!symbol) return null;
 
-    ts.forEachChild(node, visit);
+  if (symbol.flags & ts.SymbolFlags.Alias) {
+    symbol = checker.getAliasedSymbol(symbol);
   }
 
-  if (fn.body) {
-    visit(fn.body);
+  const resolvedSymbol =
+    resolveExportedSymbol(symbol, checker) ?? symbol;
+
+  for (const decl of resolvedSymbol.getDeclarations() ?? []) {
+    if (ts.isFunctionDeclaration(decl)) {
+      return decl;
+    }
+
+    if (
+      ts.isVariableDeclaration(decl) &&
+      decl.initializer &&
+      (ts.isArrowFunction(decl.initializer) ||
+        ts.isFunctionExpression(decl.initializer))
+    ) {
+      return decl.initializer;
+    }
   }
 
-  return found;
+  return null;
 }
 
 export type ScanResult = {
@@ -97,11 +77,7 @@ export function scanSource(
   const detectedFunctionWrappers = new Set<string>();
   const detectedComponentWrappers = new Map<string, string>();
 
-  if (
-    visited.has(source.fileName) ||
-    depth > 10 ||
-    visited.size > 200
-  ) {
+  if (visited.size > 200 || visited.has(source.fileName)) {
     return { events, detectedFunctionWrappers, detectedComponentWrappers };
   }
 
@@ -110,8 +86,7 @@ export function scanSource(
   function visit(node: ts.Node) {
     // CALL EXPRESSIONS
     if (ts.isCallExpression(node)) {
-      const expr = unwrap(node.expression);
-      const name = getCallName(expr);
+      const name = getCallName(node.expression);
 
       const isKnownWrapper = config.functionWrappers.some(
         w => w.name === name
@@ -119,7 +94,10 @@ export function scanSource(
 
       const isTrackingByType = isTrackingCall(node, checker);
 
-      let resolvedFn = resolveFunctionFromCall(expr, checker);
+      const resolvedFn = resolveFunctionDeep(
+        node.expression,
+        checker
+      );
 
       const isAutoWrapper =
         resolvedFn && findTrackParamIndex(resolvedFn) !== null;
@@ -130,18 +108,18 @@ export function scanSource(
         name.startsWith("$") ||
         (isAutoWrapper &&
           resolvedFn &&
+          resolvedFn.getSourceFile &&
           !isExternalFile(resolvedFn.getSourceFile().fileName));
 
-      // fallback
       if (!isTracking) {
         if (
-          ts.isPropertyAccessExpression(expr) &&
-          expr.name.text === "track"
+          ts.isPropertyAccessExpression(node.expression) &&
+          node.expression.name.text === "track"
         ) {
           isTracking = true;
         } else if (
-          ts.isIdentifier(expr) &&
-          expr.text === "track"
+          ts.isIdentifier(node.expression) &&
+          node.expression.text === "track"
         ) {
           isTracking = true;
         }
@@ -152,7 +130,7 @@ export function scanSource(
         return;
       }
 
-      // detect wrapper
+      // DETECT WRAPPER
       if (
         !isKnownWrapper &&
         isAutoWrapper &&
@@ -162,6 +140,7 @@ export function scanSource(
         detectedFunctionWrappers.add(name);
       }
 
+      // PARAM MAP
       const paramMap = new Map(inheritedParamMap ?? []);
 
       if (resolvedFn && ts.isFunctionLike(resolvedFn)) {
@@ -175,15 +154,13 @@ export function scanSource(
         });
       }
 
-      let handled = false;
-
-      // MAIN RESOLVE
+      // STRICT EVENT RESOLVE
       if (resolvedFn) {
         const idx = findTrackParamIndex(resolvedFn);
 
         if (idx !== null && node.arguments[idx]) {
           const res = resolveNodeValue(
-            unwrap(node.arguments[idx]),
+            node.arguments[idx],
             checker,
             paramMap
           );
@@ -191,31 +168,14 @@ export function scanSource(
           res.values.forEach(v => {
             if (isValidEvent(v)) events.add(v);
           });
-
-          handled = true;
         }
       }
 
-      // FALLBACK
-      if (!handled) {
-        for (const arg of node.arguments) {
-          const res = resolveNodeValue(
-            unwrap(arg),
-            checker,
-            paramMap
-          );
-
-          res.values.forEach(v => {
-            if (isValidEvent(v)) events.add(v);
-          });
-        }
-      }
-
-      // CROSS FILE
+      // CROSS-FILE
       if (resolvedFn) {
-        const sf = resolvedFn.getSourceFile();
+        const sf = resolvedFn.getSourceFile?.();
 
-        if (!visited.has(sf.fileName)) {
+        if (sf && !visited.has(sf.fileName)) {
           const res = scanSource(
             sf,
             checker,
@@ -230,100 +190,6 @@ export function scanSource(
       }
     }
 
-    // JSX COMPONENTS
-    if (
-      ts.isJsxSelfClosingElement(node) ||
-      ts.isJsxOpeningElement(node)
-    ) {
-      const tagNode =
-        ts.isPropertyAccessExpression(node.tagName)
-          ? node.tagName.name
-          : node.tagName;
-
-      let symbol = checker.getSymbolAtLocation(tagNode);
-
-      if (symbol) {
-        symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
-      }
-
-      if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
-        symbol = checker.getAliasedSymbol(symbol);
-      }
-
-      if (!symbol) {
-        ts.forEachChild(node, visit);
-        return;
-      }
-
-      const tagName =
-        ts.isPropertyAccessExpression(node.tagName)
-          ? node.tagName.name.getText()
-          : node.tagName.getText();
-
-      for (const decl of symbol.getDeclarations() ?? []) {
-        let fn: ts.FunctionLikeDeclaration | null = null;
-
-        if (ts.isFunctionDeclaration(decl)) fn = decl;
-
-        if (ts.isVariableDeclaration(decl) && decl.initializer) {
-          const init = decl.initializer;
-
-          if (
-            ts.isArrowFunction(init) ||
-            ts.isFunctionExpression(init)
-          ) {
-            fn = init;
-          }
-        }
-
-        if (!fn) continue;
-
-        const param = fn.parameters[0];
-        if (!param || !ts.isObjectBindingPattern(param.name)) continue;
-
-        for (const el of param.name.elements) {
-          const prop = el.name.getText();
-
-          const isEvent =
-            isPropUsedInTracking(fn, checker, prop) ||
-            config.wrappers.some(
-              w => w.name === tagName && w.prop === prop
-            );
-
-          if (!isEvent) continue;
-
-          const attr = node.attributes.properties.find(p => {
-            if (!ts.isJsxAttribute(p)) return false;
-            return getJsxAttrName(p.name) === prop;
-          }) as ts.JsxAttribute | undefined;
-
-          if (!attr || !attr.initializer) continue;
-
-          const expr = ts.isJsxExpression(attr.initializer)
-            ? attr.initializer.expression
-            : attr.initializer;
-
-          if (!expr) continue;
-
-          const paramMap = new Map<string, ts.Expression>();
-          paramMap.set(prop, expr);
-
-          const res = scanSource(
-            fn.getSourceFile(),
-            checker,
-            config,
-            visited,
-            depth + 1,
-            paramMap
-          );
-
-          res.events.forEach(e => events.add(e));
-
-          detectedComponentWrappers.set(tagName, prop);
-        }
-      }
-    }
-
     ts.forEachChild(node, visit);
   }
 

package/src/utils/universal.ts

@@ -1,9 +1,7 @@
 import path from "path";
 import { ParseResult } from "../types";
 
-/**
- * Strip comments (HTML + JS)
- */
+// Strip comments (HTML + JS)
 function stripComments(input: string): string {
   return input
     .replace(/<!--[\s\S]*?-->/g, "")
@@ -11,9 +9,7 @@ function stripComments(input: string): string {
     .replace(/\/\/.*$/gm, "");
 }
 
-/**
- * Extract JS expressions
- */
+// Extract JS expressions inside {}
 function extractJS(input: string): string[] {
   const result: string[] = [];
 
@@ -68,38 +64,56 @@ function extractJS(input: string): string[] {
   return result;
 }
 
-/**
- * Loose JS extractor
- */
-function extractLooseJS(input: string): string[] {
+// Extract inline HTML handlers
+function extractInlineHandlers(input: string): string[] {
   const result: string[] = [];
 
-  const lines = input.split("\n");
-
-  for (const line of lines) {
-    const l = line.trim();
-
-    if (!l) continue;
-    if (l.startsWith("<")) continue;
+  const matches = input.matchAll(
+    /\bon\w+\s*=\s*["']([^"']+)["']/g
+  );
 
-    if (/[a-zA-Z0-9_$]\s*\(/.test(l)) {
-      result.push(l);
+  for (const m of matches) {
+    const code = m[1];
+    if (/[a-zA-Z0-9_$]\s*\(/.test(code)) {
+      result.push(code);
     }
   }
 
   return result;
 }
 
-/**
- * UNIVERSAL PARSER
- * Support:
- * - React / JSX
- * - Vue
- * - Svelte
- * - Astro
- * - HTML + JS
- * - SSR
- */
+// Extract dynamic imports
+function extractDynamicImports(
+  input: string,
+  file: string
+): { deps: string[]; calls: string[] } {
+  const deps: string[] = [];
+  const calls: string[] = [];
+
+  const matches = input.matchAll(
+    /import\(\s*["'](.+?)["']\s*\)/g
+  );
+
+  for (const m of matches) {
+    const mod = m[1];
+
+    const resolved = mod.startsWith("/")
+      ? path.resolve(process.cwd(), "." + mod)
+      : path.resolve(path.dirname(file), mod);
+
+    deps.push(resolved);
+    calls.push(`import("${mod}")`);
+  }
+
+  return { deps, calls };
+}
+
+// Filter only probable tracking-related code
+function isProbablyTracking(code: string): boolean {
+  return /track|event|analytics/i.test(code);
+}
+
+// UNIVERSAL PARSER
 export function parseUniversal(
   content: string,
   file: string
@@ -138,7 +152,6 @@ export function parseUniversal(
   for (const m of scripts) {
     const attrs = m[1];
 
-    // skip JSON
     if (/type=["']application\/json/.test(attrs)) continue;
 
     if (m[2].trim()) {
@@ -152,16 +165,25 @@ export function parseUniversal(
     ""
   );
 
-  // LOOSE JS
-  parts.push(...extractLooseJS(noScripts));
+  // INLINE HANDLERS
+  parts.push(
+    ...extractInlineHandlers(noScripts).filter(isProbablyTracking)
+  );
+
+  // DYNAMIC IMPORTS
+  const dyn = extractDynamicImports(clean, file);
+  deps.push(...dyn.deps);
+  parts.push(...dyn.calls.filter(isProbablyTracking));
 
   // EXPRESSIONS
   const extracted = extractJS(clean);
+
   for (const e of extracted) {
-    parts.push(e + ";");
+    if (isProbablyTracking(e)) {
+      parts.push(e + ";");
+    }
   }
 
-  // RESULT
   return {
     code: [...new Set(parts)].join("\n"),
     deps: [...new Set(deps.filter(Boolean))],