@eventra_dev/eventra-cli 0.1.34 → 0.2.2

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);
 

package/src/engine/languageService.ts

@@ -21,7 +21,7 @@ export class TSService {
     let compilerOptions: ts.CompilerOptions = {
       allowJs: true,
       allowNonTsExtensions: true,
-      jsx: ts.JsxEmit.React,
+      jsx: ts.JsxEmit.Preserve,
       jsxImportSource: "react",
       moduleResolution: ts.ModuleResolutionKind.Node16,
       target: ts.ScriptTarget.ESNext,
@@ -59,7 +59,15 @@ export class TSService {
 
     const allFiles = ts.sys.readDirectory(
       root,
-      [".ts", ".tsx", ".js", ".jsx"],
+      [
+        ".ts",
+        ".tsx",
+        ".js",
+        ".jsx",
+        ".vue",
+        ".svelte",
+        ".astro"
+      ],
       undefined,
       undefined
     );
@@ -77,34 +85,39 @@ export class TSService {
         file = this.normalize(file);
         return this.files.get(file)?.version.toString() ?? "0";
       },
+      getScriptKind: (fileName) => {
+        fileName = this.normalize(fileName);
+
+        if (
+          fileName.endsWith(".tsx") ||
+          fileName.endsWith(".vue") ||
+          fileName.endsWith(".svelte") ||
+          fileName.endsWith(".astro")
+        ) {
+          return ts.ScriptKind.TSX;
+        }
+
+        if (fileName.endsWith(".ts")) {
+          return ts.ScriptKind.TS;
+        }
+
+        if (fileName.endsWith(".jsx")) {
+          return ts.ScriptKind.JSX;
+        }
+
+        if (fileName.endsWith(".js")) {
+          return ts.ScriptKind.JS;
+        }
 
+        return ts.ScriptKind.Unknown;
+      },
       getScriptSnapshot: (file) => {
         file = this.normalize(file);
-
-        // из памяти
         const f = this.files.get(file);
         if (f) {
           return ts.ScriptSnapshot.fromString(f.content);
         }
 
-        // virtual TSX (vue/svelte/astro)
-        if (file.endsWith(".tsx")) {
-          const original = file.replace(/\.tsx$/, "");
-
-          if (fs.existsSync(original)) {
-            const content = fs.readFileSync(original, "utf-8");
-
-            this.files.set(file, {
-              content,
-              version: 1,
-            });
-
-            this.fileNames.add(file);
-
-            return ts.ScriptSnapshot.fromString(content);
-          }
-        }
-
         try {
           if (fs.existsSync(file)) {
             const content = fs.readFileSync(file, "utf-8");
@@ -148,12 +161,6 @@ export class TSService {
     return path.resolve(file).replace(/\\/g, "/");
   }
 
-  private ensureProgram() {
-    try {
-      this.service.getProgram();
-    } catch {}
-  }
-
   // PUBLIC API
   updateFile(file: string, content: string) {
     file = this.normalize(file);
@@ -166,8 +173,6 @@ export class TSService {
     });
 
     this.fileNames.add(file);
-
-    this.ensureProgram();
   }
 
   removeFile(file: string) {
@@ -175,8 +180,6 @@ export class TSService {
 
     this.files.delete(file);
     this.fileNames.delete(file);
-
-    this.ensureProgram();
   }
 
   getProgram() {

package/src/engine/scanner.ts

@@ -4,6 +4,7 @@ import { resolveFunctionFromCall } from "./callResolver";
 import { resolveExportedSymbol } from "./exportResolver";
 import { EventraConfig, ScanResult } from "../types";
 
+// HELPERS
 function isValidEvent(v: string) {
   return (
     v &&
@@ -32,6 +33,7 @@ function getJsxAttrName(name: ts.JsxAttributeName): string {
   return "";
 }
 
+// MAIN
 export function scanSource(
   source: ts.SourceFile,
   checker: ts.TypeChecker,
@@ -47,35 +49,52 @@ export function scanSource(
   if (visited.has(source.fileName)) {
     return { events, detectedFunctionWrappers, detectedComponentWrappers };
   }
+
   visited.add(source.fileName);
 
-  function extractTrackCall(node: ts.CallExpression, paramMap: Map<string, ts.Expression>) {
-    const expr = node.expression;
+  // TRACK DETECTION
+  function isTrackCall(expr: ts.Expression) {
+    if (ts.isIdentifier(expr)) {
+      return expr.text === "track";
+    }
+
+    if (ts.isPropertyAccessExpression(expr)) {
+      return expr.name.text === "track";
+    }
+
+    return false;
+  }
+
+  function extractTrackCall(
+    node: ts.CallExpression,
+    paramMap: Map<string, ts.Expression>
+  ) {
+    if (!isTrackCall(node.expression)) return;
+
+    const arg = node.arguments[0];
+    if (!arg) return;
 
-    if (ts.isPropertyAccessExpression(expr) && expr.name.text === "track") {
-      const arg = node.arguments[0];
-      if (!arg) return;
+    const res = resolveNodeValue(arg, checker, paramMap);
 
-      const res = resolveNodeValue(arg, checker, paramMap);
-      for (const v of res.values) {
-        if (isValidEvent(v)) events.add(v);
+    for (const v of res.values) {
+      if (isValidEvent(v)) {
+        events.add(v);
       }
     }
   }
 
+  // WRAPPER DETECTION
   function isWrapperFunction(fn: ts.FunctionLikeDeclaration) {
     let found = false;
 
     function walk(n: ts.Node) {
       if (found) return;
 
-      if (ts.isCallExpression(n)) {
-        const expr = n.expression;
-        if (ts.isPropertyAccessExpression(expr) && expr.name.text === "track") {
-          found = true;
-          return;
-        }
+      if (ts.isCallExpression(n) && isTrackCall(n.expression)) {
+        found = true;
+        return;
       }
+
       ts.forEachChild(n, walk);
     }
 
@@ -83,15 +102,20 @@ export function scanSource(
     return found;
   }
 
+  // COMPONENT WRAPPER
   function detectComponentWrapper(tag: ts.JsxTagNameExpression): string | null {
     const tagName = getJsxTagName(tag);
 
-    if (wrapperCache.has(tagName)) return wrapperCache.get(tagName)!;
+    if (wrapperCache.has(tagName)) {
+      return wrapperCache.get(tagName)!;
+    }
 
     let symbol = checker.getSymbolAtLocation(tag);
+
     if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
       symbol = checker.getAliasedSymbol(symbol);
     }
+
     if (!symbol) {
       wrapperCache.set(tagName, null);
       return null;
@@ -120,21 +144,20 @@ export function scanSource(
       function walk(n: ts.Node) {
         if (prop) return;
 
-        if (ts.isCallExpression(n)) {
-          const expr = n.expression;
+        if (ts.isCallExpression(n) && isTrackCall(n.expression)) {
+          const arg = n.arguments[0];
 
-          if (ts.isPropertyAccessExpression(expr) && expr.name.text === "track") {
-            const arg = n.arguments[0];
-            if (ts.isPropertyAccessExpression(arg)) {
-              prop = arg.name.text;
-              return;
-            }
+          if (ts.isPropertyAccessExpression(arg)) {
+            prop = arg.name.text;
+            return;
           }
         }
+
         ts.forEachChild(n, walk);
       }
 
       walk(fn.body);
+
       wrapperCache.set(tagName, prop);
 
       if (prop) {
@@ -147,6 +170,7 @@ export function scanSource(
     return null;
   }
 
+  // VISITOR
   function visit(node: ts.Node) {
     // JSX
     if (ts.isJsxSelfClosingElement(node) || ts.isJsxOpeningElement(node)) {
@@ -205,29 +229,45 @@ export function scanSource(
         resolvedFn.parameters.forEach((p, i) => {
           const arg = node.arguments[i];
           if (!arg) return;
+
           if (ts.isIdentifier(p.name)) {
             paramMap.set(p.name.text, arg);
           }
         });
       }
 
-      // direct track
       extractTrackCall(node, paramMap);
 
-      // wrapper
       if (resolvedFn && isWrapperFunction(resolvedFn)) {
         const name = getCallName(node.expression);
+
         if (name && name !== "track") {
           detectedFunctionWrappers.add(name);
         }
+
         if (resolvedFn.body) {
           visit(resolvedFn.body);
         }
       }
 
-      for (const arg of node.arguments) {
-        visit(arg);
+      if (resolvedFn && resolvedFn.body) {
+        const sf = resolvedFn.getSourceFile();
+
+        if (!visited.has(sf.fileName)) {
+          const res = scanSource(
+            sf,
+            checker,
+            config,
+            visited,
+            paramMap,
+            wrapperCache
+          );
+
+          res.events.forEach(e => events.add(e));
+        }
       }
+
+      node.arguments.forEach(visit);
       visit(node.expression);
 
       return;