@eventra_dev/eventra-cli 0.1.34 → 0.2.1

package/src/commands/check.ts

@@ -25,28 +25,20 @@ export async function check({ fix = false }: { fix?: boolean }) {
 
   const engine = new EventraEngine(process.cwd());
 
+  const cache = new Map<string, { content: string; deps: string[] }>();
   const toScan = new Set<string>();
 
-  const cache = new Map<
-    string,
-    { content: string; deps: string[] }
-  >();
-
-  // COLLECT + CACHE
+  // COLLECT
   for (const file of files) {
     try {
       const raw = await fs.readFile(file, "utf-8");
-
       if (raw.length > 2_000_000) continue;
 
       const parsed = processFile(file, raw);
 
       cache.set(file, parsed);
       toScan.add(file);
-
-      for (const dep of parsed.deps) {
-        toScan.add(path.resolve(dep));
-      }
+      parsed.deps.forEach(dep => toScan.add(path.resolve(dep)));
 
     } catch {}
   }
@@ -54,17 +46,9 @@ export async function check({ fix = false }: { fix?: boolean }) {
   // 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);
-
+      const parsed = cache.get(file);
+      if (!parsed) continue;
+      engine.preloadFile(getVirtualFile(file), parsed.content);
     } catch {}
   }
 
@@ -74,49 +58,34 @@ export async function check({ fix = false }: { fix?: boolean }) {
       const parsed = cache.get(file);
       if (!parsed) continue;
 
-      const virtual = getVirtualFile(file);
-
-      engine.scanFile(virtual, parsed.content, config);
+      engine.scanFile(
+        getVirtualFile(file),
+        parsed.content,
+        config
+      );
 
     } catch {}
   }
 
-  // DIFF
   const found = new Set(engine.getAllEvents());
   const known = new Set(config.events ?? []);
 
-  const newEvents = [...found].filter(e => !known.has(e));
+  const added = [...found].filter(e => !known.has(e));
   const removed = [...known].filter(e => !found.has(e));
 
-  // FIX MODE
   if (fix) {
     config.events = [...found].sort();
     await saveConfig(config);
-
-    console.log(
-      chalk.green(`\nSynced (${config.events.length} events)`)
-    );
+    console.log(chalk.green("Synced"));
     return;
   }
 
-  // CHECK MODE
-  if (newEvents.length || removed.length) {
-    if (newEvents.length) {
-      console.log(chalk.red("\nNew events:"));
-      newEvents.forEach(e =>
-        console.log(chalk.red(`+ ${e}`))
-      );
-    }
-
-    if (removed.length) {
-      console.log(chalk.yellow("\nRemoved events:"));
-      removed.forEach(e =>
-        console.log(chalk.yellow(`- ${e}`))
-      );
-    }
+  if (added.length || removed.length) {
+    added.forEach(e => console.log(chalk.red(`+ ${e}`)));
+    removed.forEach(e => console.log(chalk.yellow(`- ${e}`)));
 
     process.exit(1);
   }
 
-  console.log(chalk.green("\nAll good"));
+  console.log(chalk.green("All good"));
 }

package/src/commands/sync.ts

@@ -19,25 +19,15 @@ export async function sync() {
     absolute: true,
   });
 
-  if (!files.length) {
-    console.log(chalk.yellow("No files found"));
-    return;
-  }
-
   const engine = new EventraEngine(process.cwd());
 
+  const cache = new Map<string, { content: string; deps: string[] }>();
   const toScan = new Set<string>();
 
-  const cache = new Map<
-    string,
-    { content: string; deps: string[] }
-  >();
-
-  // COLLECT + CACHE
+  // COLLECT
   for (const file of files) {
     try {
       const raw = await fs.readFile(file, "utf-8");
-
       if (raw.length > 2_000_000) continue;
 
       const parsed = processFile(file, raw);
@@ -45,9 +35,7 @@ export async function sync() {
       cache.set(file, parsed);
       toScan.add(file);
 
-      for (const dep of parsed.deps) {
-        toScan.add(path.resolve(dep));
-      }
+      parsed.deps.forEach(dep => toScan.add(path.resolve(dep)));
 
     } catch {}
   }
@@ -63,8 +51,7 @@ export async function sync() {
         cache.set(file, parsed);
       }
 
-      const virtual = getVirtualFile(file);
-      engine.preloadFile(virtual, parsed.content);
+      engine.preloadFile(getVirtualFile(file), parsed.content);
 
     } catch {}
   }
@@ -78,21 +65,16 @@ export async function sync() {
       const parsed = cache.get(file);
       if (!parsed) continue;
 
-      const virtual = getVirtualFile(file);
-
-      const res = engine.scanFile(virtual, parsed.content, config);
-
-      res.detectedFunctionWrappers.forEach(w =>
-        detectedFn.add(w)
+      const res = engine.updateFile(
+        getVirtualFile(file),
+        parsed.content,
+        config
       );
 
-      for (const [k, v] of res.detectedComponentWrappers) {
-        detectedCmp.set(k, v);
-      }
+      res.detectedFunctionWrappers.forEach(w => detectedFn.add(w));
+      res.detectedComponentWrappers.forEach((v, k) => detectedCmp.set(k, v));
 
-    } catch {
-      console.log(chalk.gray(`skip: ${file}`));
-    }
+    } catch {}
   }
 
   // RESULT
@@ -108,10 +90,7 @@ export async function sync() {
 
   config.wrappers = mergeUnique(
     config.wrappers ?? [],
-    [...detectedCmp.entries()].map(([name, prop]) => ({
-      name,
-      prop,
-    })),
+    [...detectedCmp.entries()].map(([name, prop]) => ({ name, prop })),
     w => `${w.name}:${w.prop}`
   );
 
@@ -120,17 +99,8 @@ export async function sync() {
   console.log(chalk.green(`Found ${events.length} events`));
 }
 
-// HELPERS
-function mergeUnique<T>(
-  a: T[],
-  b: T[],
-  key: (v: T) => string
-): T[] {
+function mergeUnique<T>(a: T[], b: T[], key: (v: T) => string): T[] {
   const map = new Map<string, T>();
-
-  [...b, ...a].forEach(item => {
-    map.set(key(item), item);
-  });
-
+  [...b, ...a].forEach(item => map.set(key(item), item));
   return [...map.values()];
 }

package/src/commands/watch.ts

@@ -9,92 +9,39 @@ import { EventraEngine } from "../engine/engine";
 import { processFile } from "../utils/processFile";
 import { getVirtualFile } from "../utils/getVirtualFile";
 
-type QueueItem = {
-  real: string;
-  virtual: string;
-};
-
-function normalize(file: string) {
-  return path.resolve(file).replace(/\\/g, "/");
-}
-
 export async function watch() {
   const config = await loadConfig();
   if (!config) return;
 
   console.log(chalk.blue("Watching...\n"));
 
-  const files = await fg(config.sync.include, {
-    ignore: config.sync.exclude,
-    absolute: true,
-  });
-
   const engine = new EventraEngine(process.cwd());
+  const fileDeps = new Map<string, Set<string>>();
+  const cache = new Map<string, { content: string; deps: string[] }>();
   const watchedDeps = new Set<string>();
 
-  const cache = new Map<
-    string,
-    { content: string; deps: string[] }
-  >();
+  const normalize = (f: string) =>
+    path.resolve(f).replace(/\\/g, "/");
 
-  const toScan = new Set<string>();
+  // INITIAL LOAD
+  const files = await fg(config.sync.include, {
+    ignore: config.sync.exclude,
+    absolute: true,
+  });
 
-  // COLLECT + CACHE
   for (const file of files) {
     try {
       const abs = normalize(file);
       const raw = await fs.readFile(abs, "utf-8");
 
-      if (raw.length > 2_000_000) continue;
-
       const parsed = processFile(abs, raw);
 
       cache.set(abs, parsed);
-      toScan.add(abs);
 
-      for (const dep of parsed.deps) {
-        toScan.add(normalize(dep));
-      }
+      engine.preloadFile(getVirtualFile(abs), parsed.content);
+      engine.updateFile(getVirtualFile(abs), parsed.content, config);
 
-    } catch {
-      console.log(chalk.gray(`skip: ${file}`));
-    }
-  }
-
-  // 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));
-      }
+      fileDeps.set(abs, new Set(parsed.deps.map(d => normalize(d))));
 
     } catch {}
   }
@@ -102,152 +49,95 @@ export async function watch() {
   config.events = engine.getAllEvents().sort();
   await saveConfig(config);
 
-  console.log(
-    chalk.gray(`Initial: ${config.events.length} events\n`)
+  console.log(chalk.gray(`Initial: ${config.events.length}\n`));
+
+  // WATCHER
+  const watcher = chokidar.watch(
+    [...files.map(normalize), ...watchedDeps],
+    { ignoreInitial: true }
   );
 
-  // QUEUE
-  let locked = false;
-  const queued = new Map<string, QueueItem>();
+  const queue = new Map<string, boolean>();
   let timer: NodeJS.Timeout | null = null;
 
   const run = async () => {
-    if (locked) return;
-    locked = true;
+    const batch = [...queue.keys()];
+    queue.clear();
 
-    const batch = [...queued.values()];
-    queued.clear();
-
-    for (const item of batch) {
+    for (const file of batch) {
       try {
-        const raw = await fs.readFile(item.real, "utf-8");
-
-        if (raw.length > 2_000_000) continue;
+        const raw = await fs.readFile(file, "utf-8");
+        const parsed = processFile(file, raw);
 
-        const parsed = processFile(item.real, raw);
-        cache.set(item.real, parsed);
+        cache.set(file, parsed);
 
-        engine.updateFile(item.virtual, parsed.content, config);
+        engine.updateFile(
+          getVirtualFile(file),
+          parsed.content,
+          config
+        );
 
-        // DEPENDENCY DIFF
-        const nextDeps = new Set<string>();
+        //dependency diff
+        const abs = normalize(file);
 
-        for (const dep of parsed.deps) {
-          nextDeps.add(normalize(dep));
-        }
+        const prevDeps = fileDeps.get(abs) ?? new Set();
+        const nextDeps = new Set(parsed.deps.map(d => normalize(d)));
 
         // add new deps
         for (const dep of nextDeps) {
-          if (!watchedDeps.has(dep)) {
+          if (!prevDeps.has(dep)) {
             watcher.add(dep);
             watchedDeps.add(dep);
           }
         }
 
         // remove old deps
-        for (const dep of [...watchedDeps]) {
+        for (const dep of prevDeps) {
           if (!nextDeps.has(dep)) {
             watcher.unwatch(dep);
             watchedDeps.delete(dep);
           }
         }
 
-        // preload deps
-        for (const dep of nextDeps) {
-          try {
-            const raw = await fs.readFile(dep, "utf-8");
-            const parsedDep = processFile(dep, raw);
-
-            cache.set(dep, parsedDep);
-
-            const virtual = getVirtualFile(dep);
-
-            engine.updateFile(virtual, parsedDep.content, config);
-          } catch {}
-        }
+        fileDeps.set(abs, nextDeps);
 
       } catch {
-        console.log(chalk.gray(`skip: ${item.real}`));
+        console.log(chalk.gray(`skip: ${file}`));
       }
     }
 
-    // DIFF EVENTS
-    const next = engine.getAllEvents();
-
-    const added = next.filter(e => !config.events.includes(e));
-    const removed = config.events.filter(e => !next.includes(e));
-
-    if (added.length || removed.length) {
-      added.forEach(e => console.log(chalk.green(`+ ${e}`)));
-      removed.forEach(e => console.log(chalk.red(`- ${e}`)));
+    const next = engine.getAllEvents().sort();
+    config.events = next;
 
-      config.events = next.sort();
-      await saveConfig(config);
-
-      console.log(
-        chalk.gray(`Total: ${config.events.length} events\n`)
-      );
-    }
+    await saveConfig(config);
 
-    locked = false;
+    console.log(chalk.green(`Updated: ${next.length}`));
   };
 
-  // SCHEDULER
   const schedule = (file: string) => {
     const abs = normalize(file);
-    const virtual = getVirtualFile(abs);
-
-    console.log(chalk.gray(`change: ${file}`));
-
-    queued.set(abs, { real: abs, virtual });
+    queue.set(abs, true);
 
     if (timer) clearTimeout(timer);
     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("add", schedule)
     .on("unlink", async (file) => {
       const abs = normalize(file);
 
-      console.log(chalk.gray(`remove: ${file}`));
-
-      const virtual = getVirtualFile(abs);
-
-      engine.removeFile(virtual, config);
+      engine.removeFile(getVirtualFile(abs), config);
 
-      watcher.unwatch(abs);
-      watchedDeps.delete(abs);
-
-      const next = engine.getAllEvents();
-
-      config.events = next.sort();
+      const next = engine.getAllEvents().sort();
+      config.events = next;
       await saveConfig(config);
 
-      console.log(
-        chalk.gray(`Total: ${config.events.length} events\n`)
-      );
-    })
-    .on("error", (err) => {
-      console.error(chalk.red("Watcher error:"), err);
+      console.log(chalk.red(`Removed → ${next.length}`));
     });
 
-  // WATCH DEPS INIT
-  for (const dep of watchedDeps) {
-    watcher.add(dep);
-  }
-
-  // EXIT
   process.on("SIGINT", async () => {
-    console.log(chalk.yellow("\nStopping watcher..."));
     await watcher.close();
     process.exit(0);
   });

package/src/engine/engine.ts

@@ -5,7 +5,7 @@ import { TSService } from "./languageService";
 import { scanSource } from "./scanner";
 import { DependencyGraph } from "./graph";
 import { hash } from "./hash";
-import {EventraConfig, ScanResult} from "../types";
+import { EventraConfig, ScanResult } from "../types";
 import { isExternalFile } from "./boundary";
 
 export class EventraEngine {
@@ -46,7 +46,7 @@ export class EventraEngine {
     }
   }
 
-  // SCAN FILE
+  // SCAN FILE (cached)
   scanFile(
     file: string,
     content: string,
@@ -71,7 +71,6 @@ export class EventraEngine {
       return this.empty();
     }
 
-    // update graph
     this.graph.update(file, source);
 
     const res = scanSource(
@@ -82,6 +81,7 @@ export class EventraEngine {
       undefined,
       this.wrapperCache
     );
+
     this.fileResults.set(file, res);
 
     return res;
@@ -92,10 +92,17 @@ export class EventraEngine {
     file: string,
     content: string,
     config: EventraConfig
-  ) {
-    this.wrapperCache.clear();
+  ): ScanResult {
     file = this.normalize(file);
 
+    // EARLY EXIT
+    if (this.fileHash.get(file) === hash(content)) {
+      return this.fileResults.get(file) ?? this.empty();
+    }
+
+    // invalidate wrapper cache
+    this.wrapperCache.clear();
+
     const res = this.scanFile(file, content, config);
 
     const dependents = this.graph.getAllDependentsDeep(file);
@@ -103,6 +110,7 @@ export class EventraEngine {
     for (const dep of dependents) {
       const abs = this.normalize(dep);
 
+      if (abs === file) continue; // self-skip
       if (isExternalFile(abs)) continue;
 
       let depContent = this.ts.getFileContent(abs);
@@ -140,6 +148,7 @@ export class EventraEngine {
         undefined,
         this.wrapperCache
       );
+
       this.fileResults.set(abs, r);
     }
 
@@ -159,19 +168,22 @@ export class EventraEngine {
 
   // REMOVE FILE
   removeFile(file: string, config?: EventraConfig) {
-    this.wrapperCache.clear();
     file = this.normalize(file);
 
+    this.wrapperCache.clear();
+
     const dependents = this.graph.getAllDependentsDeep(file);
 
+    this.graph.remove(file);
+
     this.ts.removeFile(file);
     this.fileResults.delete(file);
     this.fileHash.delete(file);
-    this.graph.remove(file);
 
     for (const dep of dependents) {
       const abs = this.normalize(dep);
 
+      if (abs === file) continue;
       if (isExternalFile(abs)) continue;
 
       let content = this.ts.getFileContent(abs);
@@ -184,11 +196,7 @@ export class EventraEngine {
         }
       }
 
-      const h = hash(content);
-
-      if (this.fileHash.get(abs) === h) continue;
-
-      this.fileHash.set(abs, h);
+      this.fileHash.delete(abs);
 
       this.ts.updateFile(abs, content);