@eventra_dev/eventra-cli 0.1.23 → 0.1.25

package/dist/commands/check.js

@@ -7,9 +7,11 @@ exports.check = check;
 const chalk_1 = __importDefault(require("chalk"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
 const config_1 = require("../utils/config");
 const engine_1 = require("../engine/engine");
 const processFile_1 = require("../utils/processFile");
+const getVirtualFile_1 = require("../utils/getVirtualFile");
 async function check({ fix = false }) {
     const config = await (0, config_1.loadConfig)();
     if (!config) {
@@ -19,37 +21,59 @@ async function check({ fix = false }) {
     console.log(chalk_1.default.blue("Checking events..."));
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude,
+        absolute: true,
     });
     const engine = new engine_1.EventraEngine(process.cwd());
+    const toScan = new Set();
+    const cache = new Map();
+    // COLLECT + CACHE
     for (const file of files) {
         try {
             const raw = await promises_1.default.readFile(file, "utf-8");
-            const { content, virtualFile, deps } = (0, processFile_1.processFile)(file, raw);
-            engine.scanFile(virtualFile, content, config);
-            for (const dep of deps) {
-                try {
-                    const depRaw = await promises_1.default.readFile(dep, "utf-8");
-                    const { content: depContent, virtualFile: depVirtual, } = (0, processFile_1.processFile)(dep, depRaw);
-                    engine.scanFile(depVirtual, depContent, config);
-                }
-                catch { }
+            if (raw.length > 2_000_000)
+                continue;
+            const parsed = (0, processFile_1.processFile)(file, raw);
+            cache.set(file, parsed);
+            toScan.add(file);
+            for (const dep of parsed.deps) {
+                toScan.add(path_1.default.resolve(dep));
             }
         }
-        catch (err) {
-            console.log(chalk_1.default.yellow(`Skipped: ${file}`));
+        catch { }
+    }
+    // PRELOAD
+    for (const file of toScan) {
+        try {
+            let parsed = cache.get(file);
+            if (!parsed) {
+                const raw = await promises_1.default.readFile(file, "utf-8");
+                parsed = (0, processFile_1.processFile)(file, raw);
+                cache.set(file, parsed);
+            }
+            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
+            engine.preloadFile(virtual, parsed.content);
+        }
+        catch { }
+    }
+    // SCAN
+    for (const file of toScan) {
+        try {
+            const parsed = cache.get(file);
+            if (!parsed)
+                continue;
+            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
+            engine.scanFile(virtual, 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 removed = [...known].filter(e => !found.has(e));
     // FIX MODE
     if (fix) {
-        const next = new Set();
-        found.forEach(e => next.add(e));
-        newEvents.forEach(e => console.log(chalk_1.default.green(`+ ${e}`)));
-        removed.forEach(e => console.log(chalk_1.default.red(`- ${e}`)));
-        config.events = [...next].sort();
+        config.events = [...found].sort();
         await (0, config_1.saveConfig)(config);
         console.log(chalk_1.default.green(`\nSynced (${config.events.length} events)`));
         return;

package/dist/commands/sync.js

@@ -7,9 +7,11 @@ exports.sync = sync;
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const promises_1 = __importDefault(require("fs/promises"));
 const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
 const config_1 = require("../utils/config");
 const engine_1 = require("../engine/engine");
 const processFile_1 = require("../utils/processFile");
+const getVirtualFile_1 = require("../utils/getVirtualFile");
 async function sync() {
     const config = await (0, config_1.loadConfig)();
     if (!config)
@@ -17,73 +19,73 @@ async function sync() {
     console.log(chalk_1.default.blue("Scanning..."));
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude,
+        absolute: true,
     });
     if (!files.length) {
         console.log(chalk_1.default.yellow("No files found"));
         return;
     }
     const engine = new engine_1.EventraEngine(process.cwd());
-    const detectedFn = new Set();
-    const detectedCmp = new Map();
-    const fileCache = [];
+    const toScan = new Set();
+    const cache = new Map();
+    // COLLECT + CACHE
     for (const file of files) {
         try {
             const raw = await promises_1.default.readFile(file, "utf-8");
-            const { content, virtualFile, deps } = (0, processFile_1.processFile)(file, raw);
-            engine["ts"].updateFile(virtualFile, content);
-            fileCache.push({ file: virtualFile, content });
-            // deps
-            for (const dep of deps) {
-                try {
-                    const depRaw = await promises_1.default.readFile(dep, "utf-8");
-                    const { content: depContent, virtualFile: depVirtual, } = (0, processFile_1.processFile)(dep, depRaw);
-                    engine["ts"].updateFile(depVirtual, depContent);
-                    fileCache.push({ file: depVirtual, content: depContent });
-                }
-                catch { }
+            if (raw.length > 2_000_000)
+                continue;
+            const parsed = (0, processFile_1.processFile)(file, raw);
+            cache.set(file, parsed);
+            toScan.add(file);
+            for (const dep of parsed.deps) {
+                toScan.add(path_1.default.resolve(dep));
             }
         }
         catch { }
     }
-    for (const { file, content } of fileCache) {
+    // PRELOAD
+    for (const file of toScan) {
         try {
-            const res = engine.scanFile(file, content, config);
-            for (const w of res.detectedFunctionWrappers) {
-                detectedFn.add(w);
+            let parsed = cache.get(file);
+            if (!parsed) {
+                const raw = await promises_1.default.readFile(file, "utf-8");
+                parsed = (0, processFile_1.processFile)(file, raw);
+                cache.set(file, parsed);
             }
+            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
+            engine.preloadFile(virtual, parsed.content);
+        }
+        catch { }
+    }
+    // SCAN
+    const detectedFn = new Set();
+    const detectedCmp = new Map();
+    for (const file of toScan) {
+        try {
+            const parsed = cache.get(file);
+            if (!parsed)
+                continue;
+            const virtual = (0, getVirtualFile_1.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_1.default.yellow(`Skipped: ${file}`));
-            if (err instanceof Error) {
-                console.log(chalk_1.default.gray(err.message));
-            }
+        catch {
+            console.log(chalk_1.default.gray(`skip: ${file}`));
         }
     }
-    // EVENTS
+    // RESULT
     const events = engine.getAllEvents().sort();
-    const mergedEvents = new Set(config.events ?? []);
-    events.forEach(e => mergedEvents.add(e));
-    config.events = [...mergedEvents].sort();
-    // FUNCTION WRAPPERS
+    config.events = events;
     config.functionWrappers = mergeUnique(config.functionWrappers ?? [], [...detectedFn].map(name => ({ name })), w => w.name);
-    // COMPONENT WRAPPERS
     config.wrappers = mergeUnique(config.wrappers ?? [], [...detectedCmp.entries()].map(([name, prop]) => ({
         name,
         prop,
     })), w => `${w.name}:${w.prop}`);
     await (0, config_1.saveConfig)(config);
     console.log(chalk_1.default.green(`Found ${events.length} events`));
-    if (detectedFn.size) {
-        console.log(chalk_1.default.blue("\nDetected function wrappers:"));
-        detectedFn.forEach(w => console.log(chalk_1.default.gray(`• ${w}`)));
-    }
-    if (detectedCmp.size) {
-        console.log(chalk_1.default.blue("\nDetected component wrappers:"));
-        detectedCmp.forEach((prop, name) => console.log(chalk_1.default.gray(`• ${name} (${prop})`)));
-    }
 }
 // HELPERS
 function mergeUnique(a, b, key) {

package/dist/commands/watch.js

@@ -12,6 +12,7 @@ const path_1 = __importDefault(require("path"));
 const config_1 = require("../utils/config");
 const engine_1 = require("../engine/engine");
 const processFile_1 = require("../utils/processFile");
+const getVirtualFile_1 = require("../utils/getVirtualFile");
 async function watch() {
     const config = await (0, config_1.loadConfig)();
     if (!config)
@@ -19,56 +20,102 @@ async function watch() {
     console.log(chalk_1.default.blue("Watching...\n"));
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude,
+        absolute: true,
     });
     const engine = new engine_1.EventraEngine(process.cwd());
-    const fileCache = [];
-    // PRELOAD TS
+    const watchedDeps = new Set();
+    const cache = new Map();
+    const toScan = new Set();
+    // COLLECT + CACHE
     for (const file of files) {
         try {
-            const abs = path_1.default.resolve(file);
-            const raw = await promises_1.default.readFile(abs, "utf-8");
-            const { content, virtualFile } = (0, processFile_1.processFile)(abs, raw);
-            fileCache.push({ file: virtualFile, content });
+            const raw = await promises_1.default.readFile(file, "utf-8");
+            if (raw.length > 2_000_000)
+                continue; // safeguard
+            const parsed = (0, processFile_1.processFile)(file, raw);
+            cache.set(file, parsed);
+            toScan.add(file);
+            for (const dep of parsed.deps) {
+                const absDep = path_1.default.resolve(dep);
+                toScan.add(absDep);
+            }
         }
         catch {
             console.log(chalk_1.default.gray(`skip: ${file}`));
         }
     }
+    // PRELOAD (TS PROGRAM)
+    for (const file of toScan) {
+        try {
+            let parsed = cache.get(file);
+            if (!parsed) {
+                const raw = await promises_1.default.readFile(file, "utf-8");
+                parsed = (0, processFile_1.processFile)(file, raw);
+            }
+            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
+            engine.preloadFile?.(virtual, parsed.content);
+        }
+        catch { }
+    }
     // INITIAL SCAN
-    for (const { file, content } of fileCache) {
-        engine.scanFile(file, content, config);
+    for (const file of toScan) {
+        try {
+            let parsed = cache.get(file);
+            if (!parsed) {
+                const raw = await promises_1.default.readFile(file, "utf-8");
+                parsed = (0, processFile_1.processFile)(file, raw);
+            }
+            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
+            engine.scanFile(virtual, parsed.content, config);
+            for (const dep of parsed.deps) {
+                watchedDeps.add(path_1.default.resolve(dep));
+            }
+        }
+        catch { }
     }
     config.events = engine.getAllEvents().sort();
     await (0, config_1.saveConfig)(config);
     console.log(chalk_1.default.gray(`Initial: ${config.events.length} events\n`));
+    // QUEUE
     let locked = false;
-    let queued = new Set();
+    const queued = new Map();
     let timer = null;
     const run = async () => {
         if (locked)
             return;
         locked = true;
-        const batch = [...queued];
+        const batch = [...queued.values()];
         queued.clear();
-        for (const file of batch) {
+        for (const item of batch) {
             try {
-                const raw = await promises_1.default.readFile(file, "utf-8");
-                const { content, virtualFile, deps } = (0, processFile_1.processFile)(file, raw);
-                engine.updateFile(virtualFile, content, config);
-                // deps
-                for (const dep of deps) {
+                const raw = await promises_1.default.readFile(item.real, "utf-8");
+                if (raw.length > 2_000_000)
+                    continue;
+                const parsed = (0, processFile_1.processFile)(item.real, raw);
+                cache.set(item.real, parsed);
+                engine.updateFile(item.virtual, parsed.content, config);
+                // DEPS
+                for (const dep of parsed.deps) {
+                    const absDep = path_1.default.resolve(dep);
+                    if (!watchedDeps.has(absDep)) {
+                        watcher.add(absDep);
+                        watchedDeps.add(absDep);
+                    }
                     try {
-                        const depRaw = await promises_1.default.readFile(dep, "utf-8");
-                        const { content: depContent, virtualFile: depVirtual, } = (0, processFile_1.processFile)(dep, depRaw);
-                        engine.updateFile(depVirtual, depContent, config);
+                        const depRaw = await promises_1.default.readFile(absDep, "utf-8");
+                        const depParsed = (0, processFile_1.processFile)(absDep, depRaw);
+                        cache.set(absDep, depParsed);
+                        const depVirtual = (0, getVirtualFile_1.getVirtualFile)(absDep);
+                        engine.updateFile(depVirtual, depParsed.content, config);
                     }
                     catch { }
                 }
             }
             catch {
-                console.log(chalk_1.default.gray(`skip: ${file}`));
+                console.log(chalk_1.default.gray(`skip: ${item.real}`));
             }
         }
+        // DIFF EVENTS
         const next = engine.getAllEvents();
         const added = next.filter(e => !config.events.includes(e));
         const removed = config.events.filter(e => !next.includes(e));
@@ -81,15 +128,21 @@ async function watch() {
         }
         locked = false;
     };
+    // SCHEDULER
     const schedule = (file) => {
-        queued.add(path_1.default.resolve(file));
+        const abs = path_1.default.resolve(file);
+        const virtual = (0, getVirtualFile_1.getVirtualFile)(abs);
+        console.log(chalk_1.default.gray(`change: ${file}`));
+        queued.set(abs, { real: abs, virtual });
         if (timer)
             clearTimeout(timer);
-        timer = setTimeout(run, 200);
+        timer = setTimeout(run, 250);
     };
+    // WATCHER
     const watcher = chokidar_1.default.watch(config.sync.include, {
         ignored: config.sync.exclude,
         ignoreInitial: true,
+        persistent: true,
     });
     watcher
         .on("add", schedule)
@@ -97,13 +150,23 @@ async function watch() {
         .on("unlink", async (file) => {
         const abs = path_1.default.resolve(file);
         console.log(chalk_1.default.gray(`remove: ${file}`));
-        const { virtualFile } = (0, processFile_1.processFile)(abs, "");
-        engine.removeFile(virtualFile, config);
+        const virtual = (0, getVirtualFile_1.getVirtualFile)(abs);
+        engine.removeFile(virtual, config);
+        watcher.unwatch(abs);
+        watchedDeps.delete(abs);
         const next = engine.getAllEvents();
         config.events = next.sort();
         await (0, config_1.saveConfig)(config);
         console.log(chalk_1.default.gray(`Total: ${config.events.length} events\n`));
+    })
+        .on("error", (err) => {
+        console.error(chalk_1.default.red("Watcher error:"), err);
     });
+    // WATCH DEPS
+    for (const dep of watchedDeps) {
+        watcher.add(dep);
+    }
+    // EXIT
     process.on("SIGINT", async () => {
         console.log(chalk_1.default.yellow("\nStopping watcher..."));
         await watcher.close();

package/dist/engine/engine.js

@@ -16,6 +16,9 @@ class EventraEngine {
         const { baseUrl, paths } = this.ts.getModuleResolutionConfig();
         this.graph = new graph_1.DependencyGraph(baseUrl, paths);
     }
+    preloadFile(file, content) {
+        this.ts.updateFile(file, content);
+    }
     // SCAN FILE
     scanFile(file, content, config) {
         const h = (0, hash_1.hash)(content);
@@ -45,7 +48,6 @@ class EventraEngine {
     }
     // UPDATE FILE (incremental)
     updateFile(file, content, config) {
-        // сначала обновляем текущий файл
         const res = this.scanFile(file, content, config);
         const dependents = this.graph.getAllDependentsDeep(file);
         for (const dep of dependents) {

package/dist/utils/getVirtualFile.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVirtualFile = getVirtualFile;
+function getVirtualFile(file) {
+    return /\.(vue|svelte|astro|html)$/i.test(file)
+        ? file + ".tsx"
+        : file;
+}

package/package.json

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

package/src/commands/check.ts

@@ -1,10 +1,12 @@
 import chalk from "chalk";
 import fg from "fast-glob";
 import fs from "fs/promises";
+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 check({ fix = false }: { fix?: boolean }) {
   const config = await loadConfig();
@@ -18,36 +20,68 @@ export async function check({ fix = false }: { fix?: boolean }) {
 
   const files = await fg(config.sync.include, {
     ignore: config.sync.exclude,
+    absolute: true,
   });
 
   const engine = new EventraEngine(process.cwd());
 
+  const toScan = new Set<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;
+
+      const parsed = processFile(file, raw);
 
-      engine.scanFile(virtualFile, content, config);
+      cache.set(file, parsed);
+      toScan.add(file);
 
-      for (const dep of deps) {
-        try {
-          const depRaw = await fs.readFile(dep, "utf-8");
+      for (const dep of parsed.deps) {
+        toScan.add(path.resolve(dep));
+      }
+
+    } catch {}
+  }
 
-          const {
-            content: depContent,
-            virtualFile: depVirtual,
-          } = processFile(dep, depRaw);
+  // PRELOAD
+  for (const file of toScan) {
+    try {
+      let parsed = cache.get(file);
 
-          engine.scanFile(depVirtual, depContent, config);
-        } catch {}
+      if (!parsed) {
+        const raw = await fs.readFile(file, "utf-8");
+        parsed = processFile(file, raw);
+        cache.set(file, parsed);
       }
 
-    } catch (err) {
-      console.log(chalk.yellow(`Skipped: ${file}`));
-    }
+      const virtual = getVirtualFile(file);
+      engine.preloadFile(virtual, parsed.content);
+
+    } catch {}
   }
 
+  // SCAN
+  for (const file of toScan) {
+    try {
+      const parsed = cache.get(file);
+      if (!parsed) continue;
+
+      const virtual = getVirtualFile(file);
+
+      engine.scanFile(virtual, parsed.content, config);
+
+    } catch {}
+  }
+
+  // DIFF
   const found = new Set(engine.getAllEvents());
   const known = new Set(config.events ?? []);
 
@@ -56,26 +90,12 @@ export async function check({ fix = false }: { fix?: boolean }) {
 
   // FIX MODE
   if (fix) {
-    const next = new Set<string>();
-
-    found.forEach(e => next.add(e));
-
-    newEvents.forEach(e =>
-      console.log(chalk.green(`+ ${e}`))
-    );
-
-    removed.forEach(e =>
-      console.log(chalk.red(`- ${e}`))
-    );
-
-    config.events = [...next].sort();
-
+    config.events = [...found].sort();
     await saveConfig(config);
 
     console.log(
       chalk.green(`\nSynced (${config.events.length} events)`)
     );
-
     return;
   }
 

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,6 +7,12 @@ 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;
+};
 
 export async function watch() {
   const config = await loadConfig();
@@ -16,27 +22,76 @@ 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>();
+  const cache = new Map<
+    string,
+    { content: string; deps: string[] }
+  >();
 
-  const fileCache: { file: string; content: string }[] = [];
+  const toScan = new Set<string>();
 
-  // PRELOAD TS
+  // COLLECT + CACHE
   for (const file of files) {
     try {
-      const abs = path.resolve(file);
-      const raw = await fs.readFile(abs, "utf-8");
-      const { content, virtualFile } = processFile(abs, raw);
-      fileCache.push({ file: virtualFile, content });
+      const raw = await fs.readFile(file, "utf-8");
+
+      if (raw.length > 2_000_000) continue; // safeguard
+
+      const parsed = processFile(file, raw);
+
+      cache.set(file, parsed);
+      toScan.add(file);
+
+      for (const dep of parsed.deps) {
+        const absDep = path.resolve(dep);
+        toScan.add(absDep);
+      }
+
     } catch {
       console.log(chalk.gray(`skip: ${file}`));
     }
   }
 
+  // PRELOAD (TS PROGRAM)
+  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.preloadFile?.(virtual, parsed.content);
+
+    } catch {}
+  }
+
   // INITIAL SCAN
-  for (const { file, content } of fileCache) {
-    engine.scanFile(file, content, config);
+  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(path.resolve(dep));
+      }
+
+    } catch {}
   }
 
   config.events = engine.getAllEvents().sort();
@@ -46,45 +101,57 @@ export async function watch() {
     chalk.gray(`Initial: ${config.events.length} events\n`)
   );
 
+  // QUEUE
   let locked = false;
-  let queued = new Set<string>();
+  const queued = new Map<string, QueueItem>();
   let timer: NodeJS.Timeout | null = null;
 
   const run = async () => {
     if (locked) return;
     locked = true;
 
-    const batch = [...queued];
+    const batch = [...queued.values()];
     queued.clear();
 
-    for (const file of batch) {
+    for (const item of batch) {
       try {
-        const raw = await fs.readFile(file, "utf-8");
+        const raw = await fs.readFile(item.real, "utf-8");
 
-        const { content, virtualFile, deps } = processFile(file, raw);
+        if (raw.length > 2_000_000) continue;
 
-        engine.updateFile(virtualFile, content, config);
+        const parsed = processFile(item.real, raw);
+
+        cache.set(item.real, parsed);
+
+        engine.updateFile(item.virtual, parsed.content, config);
+
+        // DEPS
+        for (const dep of parsed.deps) {
+          const absDep = path.resolve(dep);
+
+          if (!watchedDeps.has(absDep)) {
+            watcher.add(absDep);
+            watchedDeps.add(absDep);
+          }
 
-        // deps
-        for (const dep of deps) {
           try {
-            const depRaw = await fs.readFile(dep, "utf-8");
+            const depRaw = await fs.readFile(absDep, "utf-8");
+            const depParsed = processFile(absDep, depRaw);
 
-            const {
-              content: depContent,
-              virtualFile: depVirtual,
-            } = processFile(dep, depRaw);
+            cache.set(absDep, depParsed);
 
-            engine.updateFile(depVirtual, depContent, config);
+            const depVirtual = getVirtualFile(absDep);
 
+            engine.updateFile(depVirtual, depParsed.content, config);
           } catch {}
         }
 
       } catch {
-        console.log(chalk.gray(`skip: ${file}`));
+        console.log(chalk.gray(`skip: ${item.real}`));
       }
     }
 
+    // DIFF EVENTS
     const next = engine.getAllEvents();
 
     const added = next.filter(e => !config.events.includes(e));
@@ -105,16 +172,24 @@ export async function watch() {
     locked = false;
   };
 
+  // SCHEDULER
   const schedule = (file: string) => {
-    queued.add(path.resolve(file));
+    const abs = path.resolve(file);
+    const virtual = getVirtualFile(abs);
+
+    console.log(chalk.gray(`change: ${file}`));
+
+    queued.set(abs, { real: abs, virtual });
 
     if (timer) clearTimeout(timer);
-    timer = setTimeout(run, 200);
+    timer = setTimeout(run, 250);
   };
 
+  // WATCHER
   const watcher = chokidar.watch(config.sync.include, {
     ignored: config.sync.exclude,
     ignoreInitial: true,
+    persistent: true,
   });
 
   watcher
@@ -125,9 +200,12 @@ export async function watch() {
 
       console.log(chalk.gray(`remove: ${file}`));
 
-      const { virtualFile } = processFile(abs, "");
+      const virtual = getVirtualFile(abs);
+
+      engine.removeFile(virtual, config);
 
-      engine.removeFile(virtualFile, config);
+      watcher.unwatch(abs);
+      watchedDeps.delete(abs);
 
       const next = engine.getAllEvents();
 
@@ -137,8 +215,17 @@ 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
+  for (const dep of watchedDeps) {
+    watcher.add(dep);
+  }
+
+  // EXIT
   process.on("SIGINT", async () => {
     console.log(chalk.yellow("\nStopping watcher..."));
     await watcher.close();

package/src/engine/engine.ts

@@ -18,6 +18,9 @@ export class EventraEngine {
     const { baseUrl, paths } = this.ts.getModuleResolutionConfig();
     this.graph = new DependencyGraph(baseUrl, paths);
   }
+  preloadFile(file: string, content: string) {
+    this.ts.updateFile(file, content);
+  }
 
   // SCAN FILE
   scanFile(
@@ -66,7 +69,6 @@ export class EventraEngine {
     content: string,
     config: EventraConfig
   ) {
-    // сначала обновляем текущий файл
     const res = this.scanFile(file, content, config);
 
     const dependents = this.graph.getAllDependentsDeep(file);

package/src/utils/getVirtualFile.ts

@@ -0,0 +1,5 @@
+export function getVirtualFile(file: string) {
+  return /\.(vue|svelte|astro|html)$/i.test(file)
+    ? file + ".tsx"
+    : file;
+}