@eventra_dev/eventra-cli 0.1.24 → 0.1.26

package/src/commands/sync.ts

@@ -1,10 +1,12 @@
 import fg from "fast-glob";
 import fs from "fs/promises";
 import chalk from "chalk";
+import path from "path";
 
 import { loadConfig, saveConfig } from "../utils/config";
 import { EventraEngine } from "../engine/engine";
 import { processFile } from "../utils/processFile";
+import { getVirtualFile } from "../utils/getVirtualFile";
 
 export async function sync() {
   const config = await loadConfig();
@@ -14,6 +16,7 @@ export async function sync() {
 
   const files = await fg(config.sync.include, {
     ignore: config.sync.exclude,
+    absolute: true,
   });
 
   if (!files.length) {
@@ -23,76 +26,86 @@ export async function sync() {
 
   const engine = new EventraEngine(process.cwd());
 
-  const detectedFn = new Set<string>();
-  const detectedCmp = new Map<string, string>();
+  const toScan = new Set<string>();
 
-  const fileCache: { file: string; content: string }[] = [];
+  const cache = new Map<
+    string,
+    { content: string; deps: string[] }
+  >();
 
+  // COLLECT + CACHE
   for (const file of files) {
     try {
       const raw = await fs.readFile(file, "utf-8");
 
-      const { content, virtualFile, deps } = processFile(file, raw);
+      if (raw.length > 2_000_000) continue;
 
-      engine["ts"].updateFile(virtualFile, content);
-      fileCache.push({ file: virtualFile, content });
+      const parsed = processFile(file, raw);
 
-      // deps
-      for (const dep of deps) {
-        try {
-          const depRaw = await fs.readFile(dep, "utf-8");
+      cache.set(file, parsed);
+      toScan.add(file);
 
-          const {
-            content: depContent,
-            virtualFile: depVirtual,
-          } = processFile(dep, depRaw);
+      for (const dep of parsed.deps) {
+        toScan.add(path.resolve(dep));
+      }
 
-          engine["ts"].updateFile(depVirtual, depContent);
-          fileCache.push({ file: depVirtual, content: depContent });
+    } catch {}
+  }
 
-        } catch {}
+  // PRELOAD
+  for (const file of toScan) {
+    try {
+      let parsed = cache.get(file);
+
+      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 {}
   }
 
-  for (const { file, content } of fileCache) {
+  // SCAN
+  const detectedFn = new Set<string>();
+  const detectedCmp = new Map<string, string>();
+
+  for (const file of toScan) {
     try {
-      const res = engine.scanFile(file, content, config);
+      const parsed = cache.get(file);
+      if (!parsed) continue;
 
-      for (const w of res.detectedFunctionWrappers) {
-        detectedFn.add(w);
-      }
+      const virtual = getVirtualFile(file);
+
+      const res = engine.scanFile(virtual, parsed.content, config);
+
+      res.detectedFunctionWrappers.forEach(w =>
+        detectedFn.add(w)
+      );
 
       for (const [k, v] of res.detectedComponentWrappers) {
         detectedCmp.set(k, v);
       }
 
-    } catch (err) {
-      console.log(chalk.yellow(`Skipped: ${file}`));
-
-      if (err instanceof Error) {
-        console.log(chalk.gray(err.message));
-      }
+    } catch {
+      console.log(chalk.gray(`skip: ${file}`));
     }
   }
 
-  // EVENTS
+  // RESULT
   const events = engine.getAllEvents().sort();
 
-  const mergedEvents = new Set(config.events ?? []);
-  events.forEach(e => mergedEvents.add(e));
+  config.events = events;
 
-  config.events = [...mergedEvents].sort();
-
-  // FUNCTION WRAPPERS
   config.functionWrappers = mergeUnique(
     config.functionWrappers ?? [],
     [...detectedFn].map(name => ({ name })),
     w => w.name
   );
 
-  // COMPONENT WRAPPERS
   config.wrappers = mergeUnique(
     config.wrappers ?? [],
     [...detectedCmp.entries()].map(([name, prop]) => ({
@@ -105,18 +118,6 @@ export async function sync() {
   await saveConfig(config);
 
   console.log(chalk.green(`Found ${events.length} events`));
-
-  if (detectedFn.size) {
-    console.log(chalk.blue("\nDetected function wrappers:"));
-    detectedFn.forEach(w => console.log(chalk.gray(`• ${w}`)));
-  }
-
-  if (detectedCmp.size) {
-    console.log(chalk.blue("\nDetected component wrappers:"));
-    detectedCmp.forEach((prop, name) =>
-      console.log(chalk.gray(`• ${name} (${prop})`))
-    );
-  }
 }
 
 // HELPERS

package/src/commands/watch.ts

@@ -7,17 +7,15 @@ import path from "path";
 import { loadConfig, saveConfig } from "../utils/config";
 import { EventraEngine } from "../engine/engine";
 import { processFile } from "../utils/processFile";
+import { getVirtualFile } from "../utils/getVirtualFile";
 
 type QueueItem = {
   real: string;
   virtual: string;
 };
 
-// stabile virtual mapping
-function getVirtualFile(file: string) {
-  return /\.(vue|svelte|astro|html)$/i.test(file)
-    ? file + ".tsx"
-    : file;
+function normalize(file: string) {
+  return path.resolve(file).replace(/\\/g, "/");
 }
 
 export async function watch() {
@@ -28,26 +26,34 @@ export async function watch() {
 
   const files = await fg(config.sync.include, {
     ignore: config.sync.exclude,
+    absolute: true,
   });
 
   const engine = new EventraEngine(process.cwd());
-
   const watchedDeps = new Set<string>();
 
-  // INITIAL LOAD
+  const cache = new Map<
+    string,
+    { content: string; deps: string[] }
+  >();
+
+  const toScan = new Set<string>();
+
+  // COLLECT + CACHE
   for (const file of files) {
     try {
-      const abs = path.resolve(file);
+      const abs = normalize(file);
       const raw = await fs.readFile(abs, "utf-8");
 
-      const { content, deps } = processFile(abs, raw);
-      const virtual = getVirtualFile(abs);
+      if (raw.length > 2_000_000) continue;
+
+      const parsed = processFile(abs, raw);
 
-      engine.scanFile(virtual, content, config);
+      cache.set(abs, parsed);
+      toScan.add(abs);
 
-      // deps
-      for (const dep of deps) {
-        watchedDeps.add(path.resolve(dep));
+      for (const dep of parsed.deps) {
+        toScan.add(normalize(dep));
       }
 
     } catch {
@@ -55,6 +61,44 @@ export async function watch() {
     }
   }
 
+  // PRELOAD
+  for (const file of toScan) {
+    try {
+      let parsed = cache.get(file);
+
+      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 {}
+  }
+
+  // INITIAL SCAN
+  for (const file of toScan) {
+    try {
+      let parsed = cache.get(file);
+
+      if (!parsed) {
+        const raw = await fs.readFile(file, "utf-8");
+        parsed = processFile(file, raw);
+      }
+
+      const virtual = getVirtualFile(file);
+
+      engine.scanFile(virtual, parsed.content, config);
+
+      for (const dep of parsed.deps) {
+        watchedDeps.add(normalize(dep));
+      }
+
+    } catch {}
+  }
+
   config.events = engine.getAllEvents().sort();
   await saveConfig(config);
 
@@ -64,15 +108,11 @@ export async function watch() {
 
   // QUEUE
   let locked = false;
-  let queued = new Map<string, QueueItem>();
+  const queued = new Map<string, QueueItem>();
   let timer: NodeJS.Timeout | null = null;
 
   const run = async () => {
-    if (locked) {
-      timer = setTimeout(run, 100);
-      return;
-    }
-
+    if (locked) return;
     locked = true;
 
     const batch = [...queued.values()];
@@ -82,26 +122,47 @@ export async function watch() {
       try {
         const raw = await fs.readFile(item.real, "utf-8");
 
-        const { content, deps } = processFile(item.real, raw);
+        if (raw.length > 2_000_000) continue;
+
+        const parsed = processFile(item.real, raw);
+        cache.set(item.real, parsed);
 
-        engine.updateFile(item.virtual, content, config);
+        engine.updateFile(item.virtual, parsed.content, config);
 
-        // DEPS
-        for (const dep of deps) {
-          const absDep = path.resolve(dep);
+        // DEPENDENCY DIFF
+        const nextDeps = new Set<string>();
 
-          if (!watchedDeps.has(absDep)) {
-            watcher.add(absDep);
-            watchedDeps.add(absDep);
+        for (const dep of parsed.deps) {
+          nextDeps.add(normalize(dep));
+        }
+
+        // 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 { content: depContent } = processFile(absDep, depRaw);
+            const raw = await fs.readFile(dep, "utf-8");
+            const parsedDep = processFile(dep, raw);
 
-            const depVirtual = getVirtualFile(absDep);
+            cache.set(dep, parsedDep);
 
-            engine.updateFile(depVirtual, depContent, config);
+            const virtual = getVirtualFile(dep);
+
+            engine.updateFile(virtual, parsedDep.content, config);
           } catch {}
         }
 
@@ -110,7 +171,7 @@ export async function watch() {
       }
     }
 
-    // EVENTS DIFF
+    // DIFF EVENTS
     const next = engine.getAllEvents();
 
     const added = next.filter(e => !config.events.includes(e));
@@ -133,26 +194,29 @@ 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}`));
+
     queued.set(abs, { real: abs, virtual });
 
     if (timer) clearTimeout(timer);
-    timer = setTimeout(run, 300);
+    timer = setTimeout(run, 200);
   };
 
   // WATCHER
   const watcher = chokidar.watch(config.sync.include, {
     ignored: config.sync.exclude,
     ignoreInitial: true,
+    persistent: true,
   });
 
   watcher
     .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}`));
 
@@ -160,6 +224,7 @@ export async function watch() {
 
       engine.removeFile(virtual, config);
 
+      watcher.unwatch(abs);
       watchedDeps.delete(abs);
 
       const next = engine.getAllEvents();
@@ -170,9 +235,12 @@ export async function watch() {
       console.log(
         chalk.gray(`Total: ${config.events.length} events\n`)
       );
+    })
+    .on("error", (err) => {
+      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;
 }