@eventra_dev/eventra-cli 0.1.23 → 0.1.24

package/dist/commands/watch.js

@@ -12,6 +12,12 @@ const path_1 = __importDefault(require("path"));
 const config_1 = require("../utils/config");
 const engine_1 = require("../engine/engine");
 const processFile_1 = require("../utils/processFile");
+// stabile virtual mapping
+function getVirtualFile(file) {
+    return /\.(vue|svelte|astro|html)$/i.test(file)
+        ? file + ".tsx"
+        : file;
+}
 async function watch() {
     const config = await (0, config_1.loadConfig)();
     if (!config)
@@ -21,54 +27,65 @@ async function watch() {
         ignore: config.sync.exclude,
     });
     const engine = new engine_1.EventraEngine(process.cwd());
-    const fileCache = [];
-    // PRELOAD TS
+    const watchedDeps = new Set();
+    // INITIAL LOAD
     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 { content, deps } = (0, processFile_1.processFile)(abs, raw);
+            const virtual = getVirtualFile(abs);
+            engine.scanFile(virtual, content, config);
+            // deps
+            for (const dep of deps) {
+                watchedDeps.add(path_1.default.resolve(dep));
+            }
         }
         catch {
             console.log(chalk_1.default.gray(`skip: ${file}`));
         }
     }
-    // INITIAL SCAN
-    for (const { file, content } of fileCache) {
-        engine.scanFile(file, content, config);
-    }
     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();
+    let queued = new Map();
     let timer = null;
     const run = async () => {
-        if (locked)
+        if (locked) {
+            timer = setTimeout(run, 100);
             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
+                const raw = await promises_1.default.readFile(item.real, "utf-8");
+                const { content, deps } = (0, processFile_1.processFile)(item.real, raw);
+                engine.updateFile(item.virtual, content, config);
+                // DEPS
                 for (const dep of 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);
+                        const depRaw = await promises_1.default.readFile(absDep, "utf-8");
+                        const { content: depContent } = (0, processFile_1.processFile)(absDep, depRaw);
+                        const depVirtual = getVirtualFile(absDep);
                         engine.updateFile(depVirtual, depContent, config);
                     }
                     catch { }
                 }
             }
             catch {
-                console.log(chalk_1.default.gray(`skip: ${file}`));
+                console.log(chalk_1.default.gray(`skip: ${item.real}`));
             }
         }
+        // EVENTS DIFF
         const next = engine.getAllEvents();
         const added = next.filter(e => !config.events.includes(e));
         const removed = config.events.filter(e => !next.includes(e));
@@ -81,12 +98,16 @@ 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 = getVirtualFile(abs);
+        queued.set(abs, { real: abs, virtual });
         if (timer)
             clearTimeout(timer);
-        timer = setTimeout(run, 200);
+        timer = setTimeout(run, 300);
     };
+    // WATCHER
     const watcher = chokidar_1.default.watch(config.sync.include, {
         ignored: config.sync.exclude,
         ignoreInitial: true,
@@ -97,13 +118,19 @@ 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 = getVirtualFile(abs);
+        engine.removeFile(virtual, config);
+        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`));
     });
+    // 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/package.json

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

package/src/commands/watch.ts

@@ -8,6 +8,18 @@ import { loadConfig, saveConfig } from "../utils/config";
 import { EventraEngine } from "../engine/engine";
 import { processFile } from "../utils/processFile";
 
+type QueueItem = {
+  real: string;
+  virtual: string;
+};
+
+// stabile virtual mapping
+function getVirtualFile(file: string) {
+  return /\.(vue|svelte|astro|html)$/i.test(file)
+    ? file + ".tsx"
+    : file;
+}
+
 export async function watch() {
   const config = await loadConfig();
   if (!config) return;
@@ -20,25 +32,29 @@ export async function watch() {
 
   const engine = new EventraEngine(process.cwd());
 
-  const fileCache: { file: string; content: string }[] = [];
+  const watchedDeps = new Set<string>();
 
-  // PRELOAD TS
+  // INITIAL LOAD
   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 { content, deps } = processFile(abs, raw);
+      const virtual = getVirtualFile(abs);
+
+      engine.scanFile(virtual, content, config);
+
+      // deps
+      for (const dep of deps) {
+        watchedDeps.add(path.resolve(dep));
+      }
+
     } catch {
       console.log(chalk.gray(`skip: ${file}`));
     }
   }
 
-  // INITIAL SCAN
-  for (const { file, content } of fileCache) {
-    engine.scanFile(file, content, config);
-  }
-
   config.events = engine.getAllEvents().sort();
   await saveConfig(config);
 
@@ -46,45 +62,55 @@ export async function watch() {
     chalk.gray(`Initial: ${config.events.length} events\n`)
   );
 
+  // QUEUE
   let locked = false;
-  let queued = new Set<string>();
+  let queued = new Map<string, QueueItem>();
   let timer: NodeJS.Timeout | null = null;
 
   const run = async () => {
-    if (locked) return;
+    if (locked) {
+      timer = setTimeout(run, 100);
+      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);
+        const { content, deps } = processFile(item.real, raw);
 
-        engine.updateFile(virtualFile, content, config);
+        engine.updateFile(item.virtual, content, config);
 
-        // deps
+        // DEPS
         for (const dep of deps) {
+          const absDep = path.resolve(dep);
+
+          if (!watchedDeps.has(absDep)) {
+            watcher.add(absDep);
+            watchedDeps.add(absDep);
+          }
+
           try {
-            const depRaw = await fs.readFile(dep, "utf-8");
+            const depRaw = await fs.readFile(absDep, "utf-8");
+            const { content: depContent } = processFile(absDep, depRaw);
 
-            const {
-              content: depContent,
-              virtualFile: depVirtual,
-            } = processFile(dep, depRaw);
+            const depVirtual = getVirtualFile(absDep);
 
             engine.updateFile(depVirtual, depContent, config);
-
           } catch {}
         }
 
       } catch {
-        console.log(chalk.gray(`skip: ${file}`));
+        console.log(chalk.gray(`skip: ${item.real}`));
       }
     }
 
+    // EVENTS DIFF
     const next = engine.getAllEvents();
 
     const added = next.filter(e => !config.events.includes(e));
@@ -105,13 +131,18 @@ 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);
+
+    queued.set(abs, { real: abs, virtual });
 
     if (timer) clearTimeout(timer);
-    timer = setTimeout(run, 200);
+    timer = setTimeout(run, 300);
   };
 
+  // WATCHER
   const watcher = chokidar.watch(config.sync.include, {
     ignored: config.sync.exclude,
     ignoreInitial: true,
@@ -125,9 +156,11 @@ 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);
+      watchedDeps.delete(abs);
 
       const next = engine.getAllEvents();
 
@@ -139,6 +172,12 @@ export async function watch() {
       );
     });
 
+  // WATCH DEPS
+  for (const dep of watchedDeps) {
+    watcher.add(dep);
+  }
+
+  // EXIT
   process.on("SIGINT", async () => {
     console.log(chalk.yellow("\nStopping watcher..."));
     await watcher.close();