@eventra_dev/eventra-cli 0.1.25 → 0.1.26

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.26",
   "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);
   }

package/src/engine/callResolver.ts

@@ -29,18 +29,48 @@ function resolveFromSymbol(
     return resolveFromSymbol(aliased, checker, visited, depth + 1);
   }
 
+  // re-export support
+  if ((symbol as any).exports) {
+    for (const exp of (symbol as any).exports.values()) {
+      const resolved = resolveFromSymbol(exp, checker, visited, depth + 1);
+      if (resolved) return resolved;
+    }
+  }
+
   const decls = symbol.getDeclarations() ?? [];
 
   for (const decl of decls) {
+    // direct function
     if (isFunctionLike(decl)) {
       return decl;
     }
 
-    // MethodSignature
+    // VARIABLE → FUNCTION
+    if (ts.isVariableDeclaration(decl) && decl.initializer) {
+      if (isFunctionLike(decl.initializer)) {
+        return decl.initializer;
+      }
+
+      const innerSymbol = checker.getSymbolAtLocation(decl.initializer);
+      if (innerSymbol && innerSymbol !== symbol) {
+        const resolved = resolveFromSymbol(
+          innerSymbol,
+          checker,
+          visited,
+          depth + 1
+        );
+        if (resolved) return resolved;
+      }
+    }
+
+    // MethodSignature (interface / type)
     if (ts.isMethodSignature(decl)) {
       const parent = decl.parent;
 
-      if (ts.isInterfaceDeclaration(parent) || ts.isTypeLiteralNode(parent)) {
+      if (
+        ts.isInterfaceDeclaration(parent) ||
+        ts.isTypeLiteralNode(parent)
+      ) {
         const name = decl.name.getText();
 
         const type = checker.getTypeAtLocation(parent);
@@ -49,16 +79,26 @@ function resolveFromSymbol(
         for (const prop of props) {
           if (prop.name !== name) continue;
 
-          const resolved = resolveFromSymbol(prop, checker, visited, depth + 1);
+          const resolved = resolveFromSymbol(
+            prop,
+            checker,
+            visited,
+            depth + 1
+          );
           if (resolved) return resolved;
         }
       }
     }
 
-    // SAFE fallback
+    // fallback recursion
     const s = checker.getSymbolAtLocation(decl);
     if (s && s !== symbol) {
-      const resolved = resolveFromSymbol(s, checker, visited, depth + 1);
+      const resolved = resolveFromSymbol(
+        s,
+        checker,
+        visited,
+        depth + 1
+      );
       if (resolved) return resolved;
     }
   }
@@ -70,6 +110,32 @@ export function resolveFunctionFromCall(
   expr: ts.Expression,
   checker: ts.TypeChecker
 ): ts.FunctionLikeDeclaration | null {
+
+  // tracker.track
+  if (ts.isPropertyAccessExpression(expr)) {
+    let symbol = checker.getSymbolAtLocation(expr.name);
+
+    if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
+      symbol = checker.getAliasedSymbol(symbol);
+    }
+
+    if (symbol) {
+      const resolved = resolveFromSymbol(symbol, checker);
+      if (resolved) return resolved;
+    }
+  }
+
+  // tracker["track"]
+  if (ts.isElementAccessExpression(expr)) {
+    const symbol = checker.getSymbolAtLocation(expr.argumentExpression);
+
+    if (symbol) {
+      const resolved = resolveFromSymbol(symbol, checker);
+      if (resolved) return resolved;
+    }
+  }
+
+  // normal call signatures
   const type = checker.getTypeAtLocation(expr);
   const signatures = type.getCallSignatures();
 
@@ -81,7 +147,6 @@ export function resolveFunctionFromCall(
       return decl;
     }
 
-    // interface method
     if (ts.isMethodSignature(decl)) {
       const symbol = checker.getSymbolAtLocation(decl.name);
 
@@ -92,5 +157,11 @@ export function resolveFunctionFromCall(
     }
   }
 
+  // fallback
+  const symbol = checker.getSymbolAtLocation(expr);
+  if (symbol) {
+    return resolveFromSymbol(symbol, checker);
+  }
+
   return null;
 }

package/src/engine/engine.ts

@@ -1,3 +1,6 @@
+import path from "path";
+import fs from "fs";
+
 import { TSService } from "./languageService";
 import { ScanResult, scanSource } from "./scanner";
 import { DependencyGraph } from "./graph";
@@ -18,8 +21,29 @@ export class EventraEngine {
     const { baseUrl, paths } = this.ts.getModuleResolutionConfig();
     this.graph = new DependencyGraph(baseUrl, paths);
   }
+
+  private normalize(file: string) {
+    return path.resolve(file).replace(/\\/g, "/");
+  }
+
+  private empty(): ScanResult {
+    return {
+      events: new Set(),
+      detectedFunctionWrappers: new Set(),
+      detectedComponentWrappers: new Map(),
+    };
+  }
+
+  // PRELOAD
   preloadFile(file: string, content: string) {
+    file = this.normalize(file);
+
     this.ts.updateFile(file, content);
+
+    const source = this.ts.getSourceFile(file);
+    if (source) {
+      this.graph.update(file, source);
+    }
   }
 
   // SCAN FILE
@@ -28,33 +52,26 @@ export class EventraEngine {
     content: string,
     config: EventraConfig
   ): ScanResult {
+    file = this.normalize(file);
+
     const h = hash(content);
 
-    // skip unchanged
     if (this.fileHash.get(file) === h) {
-      return (
-        this.fileResults.get(file) ?? {
-          events: new Set(),
-          detectedFunctionWrappers: new Set(),
-          detectedComponentWrappers: new Map(),
-        }
-      );
+      return this.fileResults.get(file) ?? this.empty();
     }
 
     this.fileHash.set(file, h);
+
     this.ts.updateFile(file, content);
 
     const source = this.ts.getSourceFile(file);
     const checker = this.ts.getChecker();
 
     if (!source || !checker) {
-      return {
-        events: new Set(),
-        detectedFunctionWrappers: new Set(),
-        detectedComponentWrappers: new Map(),
-      };
+      return this.empty();
     }
 
+    // обновляем graph
     this.graph.update(file, source);
 
     const res = scanSource(source, checker, config);
@@ -69,32 +86,46 @@ export class EventraEngine {
     content: string,
     config: EventraConfig
   ) {
+    file = this.normalize(file);
+
     const res = this.scanFile(file, content, config);
 
     const dependents = this.graph.getAllDependentsDeep(file);
 
     for (const dep of dependents) {
-      if (isExternalFile(dep)) continue;
+      const abs = this.normalize(dep);
 
-      const depContent = this.ts.getFileContent(dep);
-      if (!depContent) continue;
+      if (isExternalFile(abs)) continue;
+
+      let depContent = this.ts.getFileContent(abs);
+
+      if (!depContent) {
+        try {
+          depContent = fs.readFileSync(abs, "utf-8");
+        } catch {
+          continue;
+        }
+      }
 
       const h = hash(depContent);
 
-      if (this.fileHash.get(dep) === h) continue;
+      if (this.fileHash.get(abs) === h) {
+        continue;
+      }
+
+      this.fileHash.set(abs, h);
 
-      this.fileHash.set(dep, h);
-      this.ts.updateFile(dep, depContent);
+      this.ts.updateFile(abs, depContent);
 
-      const source = this.ts.getSourceFile(dep);
+      const source = this.ts.getSourceFile(abs);
       const checker = this.ts.getChecker();
 
       if (!source || !checker) continue;
 
-      this.graph.update(dep, source);
+      this.graph.update(abs, source);
 
       const r = scanSource(source, checker, config);
-      this.fileResults.set(dep, r);
+      this.fileResults.set(abs, r);
     }
 
     return res;
@@ -113,31 +144,45 @@ export class EventraEngine {
 
   // REMOVE FILE
   removeFile(file: string, config?: EventraConfig) {
+    file = this.normalize(file);
+
+    const dependents = this.graph.getAllDependentsDeep(file);
+
     this.ts.removeFile(file);
     this.fileResults.delete(file);
     this.fileHash.delete(file);
     this.graph.remove(file);
 
-    const dependents = this.graph.getAllDependentsDeep(file);
-
     for (const dep of dependents) {
-      if (isExternalFile(dep)) continue;
+      const abs = this.normalize(dep);
 
-      const content = this.ts.getFileContent(dep);
-      if (!content) continue;
+      if (isExternalFile(abs)) continue;
+
+      let content = this.ts.getFileContent(abs);
+
+      if (!content) {
+        try {
+          content = fs.readFileSync(abs, "utf-8");
+        } catch {
+          continue;
+        }
+      }
 
       const h = hash(content);
 
-      if (this.fileHash.get(dep) === h) continue;
+      if (this.fileHash.get(abs) === h) continue;
+
+      this.fileHash.set(abs, h);
 
-      this.fileHash.set(dep, h);
-      this.ts.updateFile(dep, content);
+      this.ts.updateFile(abs, content);
 
-      const source = this.ts.getSourceFile(dep);
+      const source = this.ts.getSourceFile(abs);
       const checker = this.ts.getChecker();
 
       if (!source || !checker) continue;
 
+      this.graph.update(abs, source);
+
       const r = scanSource(
         source,
         checker,
@@ -149,7 +194,7 @@ export class EventraEngine {
         }
       );
 
-      this.fileResults.set(dep, r);
+      this.fileResults.set(abs, r);
     }
   }
 }