@eventra_dev/eventra-cli 0.1.25 → 0.1.27

package/dist/engine/scanner.js

@@ -10,7 +10,7 @@ const callResolver_1 = require("./callResolver");
 const exportResolver_1 = require("./exportResolver");
 const functionAnalyzer_1 = require("./functionAnalyzer");
 const boundary_1 = require("./boundary");
-const TRACKING_NAMES = new Set(["track", "event", "capture", "send"]);
+const trackingDetector_1 = require("./trackingDetector");
 function getCallName(expr) {
     if (typescript_1.default.isIdentifier(expr))
         return expr.text;
@@ -25,6 +25,16 @@ function getJsxAttrName(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 &&
@@ -32,70 +42,75 @@ function isValidEvent(v) {
         !v.includes(" ") &&
         /^[a-zA-Z0-9._:-]+$/.test(v));
 }
-function isPropUsedInTracking(fn, prop) {
+function isPropUsedInTracking(fn, checker, prop) {
     let found = false;
     function visit(node) {
         if (typescript_1.default.isCallExpression(node)) {
-            const name = getCallName(node.expression);
-            if (!TRACKING_NAMES.has(name)) {
+            if (!(0, trackingDetector_1.isTrackingCall)(node, checker)) {
                 typescript_1.default.forEachChild(node, visit);
                 return;
             }
             for (const arg of node.arguments) {
-                if ((typescript_1.default.isIdentifier(arg) && arg.text === prop) ||
-                    (typescript_1.default.isPropertyAccessExpression(arg) &&
-                        arg.name.text === prop)) {
+                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);
     }
-    visit(fn);
+    if (fn.body) {
+        visit(fn.body);
+    }
     return found;
 }
 function scanSource(source, checker, config, visited = new Set(), depth = 0, inheritedParamMap) {
     const events = new Set();
     const detectedFunctionWrappers = new Set();
     const detectedComponentWrappers = new Map();
-    if (depth > 5 || visited.has(source.fileName)) {
+    if (visited.has(source.fileName) ||
+        depth > 10 ||
+        visited.size > 200) {
         return { events, detectedFunctionWrappers, detectedComponentWrappers };
     }
     visited.add(source.fileName);
     function visit(node) {
         // CALL EXPRESSIONS
         if (typescript_1.default.isCallExpression(node)) {
-            const name = getCallName(node.expression);
+            const expr = unwrap(node.expression);
+            const name = getCallName(expr);
             const isKnownWrapper = config.functionWrappers.some(w => w.name === name);
-            let resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-            // fallback: tracker.track(...)
-            if (!resolvedFn && typescript_1.default.isPropertyAccessExpression(node.expression)) {
-                const symbol = checker.getSymbolAtLocation(node.expression.name);
-                if (symbol) {
-                    const decls = symbol.getDeclarations();
-                    if (decls?.length) {
-                        const d = decls[0];
-                        if (typescript_1.default.isMethodDeclaration(d) ||
-                            typescript_1.default.isFunctionDeclaration(d) ||
-                            typescript_1.default.isFunctionExpression(d) ||
-                            typescript_1.default.isArrowFunction(d)) {
-                            resolvedFn = d;
-                        }
-                    }
-                }
-            }
+            const isTrackingByType = (0, trackingDetector_1.isTrackingCall)(node, checker);
+            let resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(expr, checker);
             const isAutoWrapper = resolvedFn && (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn) !== null;
-            const isTracking = isKnownWrapper ||
-                TRACKING_NAMES.has(name) ||
-                name.startsWith("$") || // NUXT FIX
+            let isTracking = isKnownWrapper ||
+                isTrackingByType ||
+                name.startsWith("$") ||
                 (isAutoWrapper &&
                     resolvedFn &&
                     !(0, boundary_1.isExternalFile)(resolvedFn.getSourceFile().fileName));
+            // fallback
+            if (!isTracking) {
+                if (typescript_1.default.isPropertyAccessExpression(expr) &&
+                    expr.name.text === "track") {
+                    isTracking = true;
+                }
+                else if (typescript_1.default.isIdentifier(expr) &&
+                    expr.text === "track") {
+                    isTracking = true;
+                }
+            }
             if (!isTracking) {
                 typescript_1.default.forEachChild(node, visit);
                 return;
             }
-            if (!isKnownWrapper && isAutoWrapper && !TRACKING_NAMES.has(name)) {
+            // detect wrapper
+            if (!isKnownWrapper &&
+                isAutoWrapper &&
+                !isTrackingByType &&
+                !name.startsWith("track")) {
                 detectedFunctionWrappers.add(name);
             }
             const paramMap = new Map(inheritedParamMap ?? []);
@@ -114,26 +129,22 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
             if (resolvedFn) {
                 const idx = (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn);
                 if (idx !== null && node.arguments[idx]) {
-                    const res = (0, resolver_1.resolveNodeValue)(node.arguments[idx], checker, paramMap);
-                    if (res && res.values.length) {
-                        res.values.forEach(v => {
-                            if (isValidEvent(v))
-                                events.add(v);
-                        });
-                    }
+                    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)(arg, checker, paramMap);
-                    if (res && res.values.length) {
-                        res.values.forEach(v => {
-                            if (isValidEvent(v))
-                                events.add(v);
-                        });
-                    }
+                    const res = (0, resolver_1.resolveNodeValue)(unwrap(arg), checker, paramMap);
+                    res.values.forEach(v => {
+                        if (isValidEvent(v))
+                            events.add(v);
+                    });
                 }
             }
             // CROSS FILE
@@ -183,7 +194,7 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
                     continue;
                 for (const el of param.name.elements) {
                     const prop = el.name.getText();
-                    const isEvent = isPropUsedInTracking(fn, prop) ||
+                    const isEvent = isPropUsedInTracking(fn, checker, prop) ||
                         config.wrappers.some(w => w.name === tagName && w.prop === prop);
                     if (!isEvent)
                         continue;

package/dist/engine/trackingDetector.js

@@ -0,0 +1,68 @@
+"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 isStringLike(type) {
+    return ((type.flags & typescript_1.default.TypeFlags.StringLike) !== 0 ||
+        (type.flags & typescript_1.default.TypeFlags.StringLiteral) !== 0);
+}
+function hasTrackLikeSignature(type, checker) {
+    const sigs = type.getCallSignatures();
+    for (const sig of sigs) {
+        const params = sig.getParameters();
+        if (!params.length)
+            continue;
+        const t = checker.getTypeOfSymbolAtLocation(params[0], params[0].valueDeclaration);
+        if (isStringLike(t)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isEventraLikeType(type, checker) {
+    const props = type.getProperties();
+    for (const prop of props) {
+        const decl = prop.valueDeclaration ?? prop.declarations?.[0];
+        if (!decl)
+            continue;
+        const t = checker.getTypeOfSymbolAtLocation(prop, decl);
+        if (hasTrackLikeSignature(t, checker)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isTrackingCall(node, checker) {
+    const expr = node.expression;
+    // fn(...)
+    if (typescript_1.default.isIdentifier(expr)) {
+        const type = checker.getTypeAtLocation(expr);
+        if (hasTrackLikeSignature(type, checker)) {
+            return true;
+        }
+    }
+    // obj.method(...)
+    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+        const objType = checker.getTypeAtLocation(expr.expression);
+        // объект похож на tracker
+        if (isEventraLikeType(objType, checker)) {
+            return true;
+        }
+        // fallback
+        const methodType = checker.getTypeAtLocation(expr.name);
+        if (hasTrackLikeSignature(methodType, checker)) {
+            return true;
+        }
+    }
+    // obj["track"](...)
+    if (typescript_1.default.isElementAccessExpression(expr)) {
+        const objType = checker.getTypeAtLocation(expr.expression);
+        if (isEventraLikeType(objType, checker)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/utils/processFile.js

@@ -1,20 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processFile = processFile;
-const path_1 = __importDefault(require("path"));
 const universal_1 = require("./universal");
 function processFile(file, content) {
     const { code, deps } = (0, universal_1.parseUniversal)(content, file);
-    const ext = path_1.default.extname(file);
-    const virtualFile = /\.(vue|svelte|astro|html)$/i.test(file)
-        ? file.replace(ext, "") + ".tsx"
-        : file;
     return {
         content: code || "",
-        virtualFile,
         deps: [...new Set(deps.filter(Boolean))],
     };
 }

package/dist/utils/universal.js

@@ -15,7 +15,7 @@ function stripComments(input) {
         .replace(/\/\/.*$/gm, "");
 }
 /**
- * Extract JS expressions safely
+ * Extract JS expressions
  */
 function extractJS(input) {
     const result = [];
@@ -25,7 +25,6 @@ function extractJS(input) {
     let escape = false;
     while (i < len) {
         const ch = input[i];
-        // STRING
         if (inString) {
             if (escape)
                 escape = false;
@@ -41,95 +40,31 @@ function extractJS(input) {
             i++;
             continue;
         }
-        // { ... }
         if (ch === "{") {
             let depth = 1;
             let j = i + 1;
-            let innerStr = null;
-            let innerEsc = false;
             while (j < len && depth > 0) {
-                const c = input[j];
-                if (innerStr) {
-                    if (innerEsc)
-                        innerEsc = false;
-                    else if (c === "\\")
-                        innerEsc = true;
-                    else if (c === innerStr)
-                        innerStr = null;
-                    j++;
-                    continue;
-                }
-                if (c === '"' || c === "'" || c === "`") {
-                    innerStr = c;
-                    j++;
-                    continue;
-                }
-                if (c === "{")
+                if (input[j] === "{")
                     depth++;
-                else if (c === "}")
+                else if (input[j] === "}")
                     depth--;
                 j++;
             }
             if (depth === 0) {
                 const expr = input.slice(i + 1, j - 1).trim();
-                if (expr &&
-                    (expr.includes("(") ||
-                        expr.includes("=") ||
-                        expr.includes(".") ||
-                        expr.includes("track"))) {
+                if (expr && /[a-zA-Z0-9_$]\s*\(/.test(expr)) {
                     result.push(expr);
                 }
                 i = j;
                 continue;
             }
         }
-        // attr="..."
-        if (ch === "=" && (input[i + 1] === '"' || input[i + 1] === "'")) {
-            const quote = input[i + 1];
-            let j = i + 2;
-            let val = "";
-            while (j < len) {
-                const c = input[j];
-                if (c === "\\" && input[j + 1]) {
-                    val += c + input[j + 1];
-                    j += 2;
-                    continue;
-                }
-                if (c === quote)
-                    break;
-                val += c;
-                j++;
-            }
-            if (val.trim() &&
-                (val.includes("(") ||
-                    val.includes("=>") ||
-                    val.includes("track"))) {
-                result.push(val.trim());
-            }
-            i = j + 1;
-            continue;
-        }
         i++;
     }
-    // Vue / Svelte / JSX handlers
-    const extra = [
-        /@[\w-]+\s*=\s*["']([\s\S]*?)["']/g,
-        /v-on:[\w-]+\s*=\s*["']([\s\S]*?)["']/g,
-        /on:[\w-]+\s*=\s*{([\s\S]*?)}/g,
-        /on\w+\s*=\s*{([\s\S]*?)}/g,
-    ];
-    for (const r of extra) {
-        const m = input.matchAll(r);
-        for (const x of m) {
-            const v = x[1]?.trim();
-            if (v)
-                result.push(v);
-        }
-    }
     return result;
 }
 /**
- * Extract loose JS but less noisy
+ * Loose JS extractor
  */
 function extractLooseJS(input) {
     const result = [];
@@ -140,28 +75,31 @@ function extractLooseJS(input) {
             continue;
         if (l.startsWith("<"))
             continue;
-        // strict filter
-        if (l.includes("track") ||
-            l.includes(".track(") ||
-            l.includes("=>") ||
-            l.startsWith("function") ||
-            l.includes("(")) {
+        if (/[a-zA-Z0-9_$]\s*\(/.test(l)) {
             result.push(l);
         }
     }
     return result;
 }
 /**
- * Universal parser
+ * UNIVERSAL PARSER
+ * Support:
+ * - React / JSX
+ * - Vue
+ * - Svelte
+ * - Astro
+ * - HTML + JS
+ * - SSR
  */
 function parseUniversal(content, file) {
     const parts = [];
     const deps = [];
     const clean = stripComments(content);
-    // Astro frontmatter
+    // ASTRO FRONTMATTER
     const fm = clean.match(/^---([\s\S]*?)---/);
-    if (fm?.[1])
+    if (fm?.[1]) {
         parts.push(fm[1]);
+    }
     // <script src="">
     const scriptSrc = clean.matchAll(/<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g);
     for (const s of scriptSrc) {
@@ -171,29 +109,29 @@ function parseUniversal(content, file) {
             : path_1.default.resolve(path_1.default.dirname(file), src);
         deps.push(resolved);
     }
-    // inline <script>
+    // INLINE <script>
     const scripts = clean.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script>/g);
     for (const m of scripts) {
         const attrs = m[1];
-        // skip JSON / data
+        // skip JSON
         if (/type=["']application\/json/.test(attrs))
             continue;
         if (m[2].trim()) {
             parts.push(m[2]);
         }
     }
-    // remove scripts
+    // REMOVE SCRIPTS → TEMPLATE PART
     const noScripts = clean.replace(/<script[\s\S]*?<\/script>/g, "");
-    // loose JS
-    const loose = extractLooseJS(noScripts);
-    parts.push(...loose);
-    // expressions
+    // LOOSE JS
+    parts.push(...extractLooseJS(noScripts));
+    // EXPRESSIONS
     const extracted = extractJS(clean);
     for (const e of extracted) {
         parts.push(e + ";");
     }
+    // RESULT
     return {
         code: [...new Set(parts)].join("\n"),
-        deps,
+        deps: [...new Set(deps.filter(Boolean))],
     };
 }

package/package.json

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

package/src/commands/watch.ts

@@ -14,6 +14,10 @@ type QueueItem = {
   virtual: string;
 };
 
+function normalize(file: string) {
+  return path.resolve(file).replace(/\\/g, "/");
+}
+
 export async function watch() {
   const config = await loadConfig();
   if (!config) return;
@@ -27,6 +31,7 @@ export async function watch() {
 
   const engine = new EventraEngine(process.cwd());
   const watchedDeps = new Set<string>();
+
   const cache = new Map<
     string,
     { content: string; deps: string[] }
@@ -37,18 +42,18 @@ export async function watch() {
   // COLLECT + CACHE
   for (const file of files) {
     try {
-      const raw = await fs.readFile(file, "utf-8");
+      const abs = normalize(file);
+      const raw = await fs.readFile(abs, "utf-8");
 
-      if (raw.length > 2_000_000) continue; // safeguard
+      if (raw.length > 2_000_000) continue;
 
-      const parsed = processFile(file, raw);
+      const parsed = processFile(abs, raw);
 
-      cache.set(file, parsed);
-      toScan.add(file);
+      cache.set(abs, parsed);
+      toScan.add(abs);
 
       for (const dep of parsed.deps) {
-        const absDep = path.resolve(dep);
-        toScan.add(absDep);
+        toScan.add(normalize(dep));
       }
 
     } catch {
@@ -56,7 +61,7 @@ export async function watch() {
     }
   }
 
-  // PRELOAD (TS PROGRAM)
+  // PRELOAD
   for (const file of toScan) {
     try {
       let parsed = cache.get(file);
@@ -64,10 +69,10 @@ export async function watch() {
       if (!parsed) {
         const raw = await fs.readFile(file, "utf-8");
         parsed = processFile(file, raw);
+        cache.set(file, parsed);
       }
 
       const virtual = getVirtualFile(file);
-
       engine.preloadFile?.(virtual, parsed.content);
 
     } catch {}
@@ -88,7 +93,7 @@ export async function watch() {
       engine.scanFile(virtual, parsed.content, config);
 
       for (const dep of parsed.deps) {
-        watchedDeps.add(path.resolve(dep));
+        watchedDeps.add(normalize(dep));
       }
 
     } catch {}
@@ -120,29 +125,44 @@ export async function watch() {
         if (raw.length > 2_000_000) continue;
 
         const parsed = processFile(item.real, raw);
-
         cache.set(item.real, parsed);
 
         engine.updateFile(item.virtual, parsed.content, config);
 
-        // DEPS
+        // DEPENDENCY DIFF
+        const nextDeps = new Set<string>();
+
         for (const dep of parsed.deps) {
-          const absDep = path.resolve(dep);
+          nextDeps.add(normalize(dep));
+        }
 
-          if (!watchedDeps.has(absDep)) {
-            watcher.add(absDep);
-            watchedDeps.add(absDep);
+        // add new deps
+        for (const dep of nextDeps) {
+          if (!watchedDeps.has(dep)) {
+            watcher.add(dep);
+            watchedDeps.add(dep);
           }
+        }
+
+        // remove old deps
+        for (const dep of [...watchedDeps]) {
+          if (!nextDeps.has(dep)) {
+            watcher.unwatch(dep);
+            watchedDeps.delete(dep);
+          }
+        }
 
+        // preload deps
+        for (const dep of nextDeps) {
           try {
-            const depRaw = await fs.readFile(absDep, "utf-8");
-            const depParsed = processFile(absDep, depRaw);
+            const raw = await fs.readFile(dep, "utf-8");
+            const parsedDep = processFile(dep, raw);
 
-            cache.set(absDep, depParsed);
+            cache.set(dep, parsedDep);
 
-            const depVirtual = getVirtualFile(absDep);
+            const virtual = getVirtualFile(dep);
 
-            engine.updateFile(depVirtual, depParsed.content, config);
+            engine.updateFile(virtual, parsedDep.content, config);
           } catch {}
         }
 
@@ -174,7 +194,7 @@ export async function watch() {
 
   // SCHEDULER
   const schedule = (file: string) => {
-    const abs = path.resolve(file);
+    const abs = normalize(file);
     const virtual = getVirtualFile(abs);
 
     console.log(chalk.gray(`change: ${file}`));
@@ -182,7 +202,7 @@ export async function watch() {
     queued.set(abs, { real: abs, virtual });
 
     if (timer) clearTimeout(timer);
-    timer = setTimeout(run, 250);
+    timer = setTimeout(run, 200);
   };
 
   // WATCHER
@@ -196,7 +216,7 @@ export async function watch() {
     .on("add", schedule)
     .on("change", schedule)
     .on("unlink", async (file) => {
-      const abs = path.resolve(file);
+      const abs = normalize(file);
 
       console.log(chalk.gray(`remove: ${file}`));
 
@@ -220,7 +240,7 @@ export async function watch() {
       console.error(chalk.red("Watcher error:"), err);
     });
 
-  // WATCH DEPS
+  // WATCH DEPS INIT
   for (const dep of watchedDeps) {
     watcher.add(dep);
   }