@eventra_dev/eventra-cli 0.1.10 → 0.1.12

package/dist/commands/watch.js

@@ -8,6 +8,7 @@ const chokidar_1 = __importDefault(require("chokidar"));
 const chalk_1 = __importDefault(require("chalk"));
 const promises_1 = __importDefault(require("fs/promises"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
+const path_1 = __importDefault(require("path"));
 const config_1 = require("../utils/config");
 const engine_1 = require("../engine/engine");
 const processFile_1 = require("../utils/processFile");
@@ -20,22 +21,32 @@ async function watch() {
         ignore: config.sync.exclude,
     });
     const engine = new engine_1.EventraEngine(process.cwd());
+    const fileCache = [];
+    // PRELOAD TS
     for (const file of files) {
         try {
-            const raw = await promises_1.default.readFile(file, "utf-8");
-            const { content, virtualFile } = (0, processFile_1.processFile)(file, raw);
-            engine.scanFile(virtualFile, content, config);
+            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 });
+            engine["ts"].updateFile(virtualFile, content);
         }
         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`));
+    // WATCH STATE
     let locked = false;
     let queued = new Set();
     let timer = null;
+    // RUN BATCH
     const run = async () => {
         if (locked)
             return;
@@ -64,12 +75,15 @@ async function watch() {
         }
         locked = false;
     };
+    // SCHEDULER
     const schedule = (file) => {
-        queued.add(file);
+        const abs = path_1.default.resolve(file);
+        queued.add(abs);
         if (timer)
             clearTimeout(timer);
         timer = setTimeout(run, 100);
     };
+    // WATCHER
     const watcher = chokidar_1.default.watch(config.sync.include, {
         ignored: config.sync.exclude,
         ignoreInitial: true,
@@ -78,12 +92,14 @@ async function watch() {
         .on("add", schedule)
         .on("change", schedule)
         .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)(file, "");
-        engine.removeFile(virtualFile);
+        const { virtualFile } = (0, processFile_1.processFile)(abs, "");
+        engine.removeFile(virtualFile, config);
         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`));
     });
     process.on("SIGINT", async () => {
         console.log(chalk_1.default.yellow("\nStopping watcher..."));

package/dist/engine/resolver.js

@@ -70,6 +70,7 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
             if (s.flags & typescript_1.default.SymbolFlags.Alias) {
                 s = checker.getAliasedSymbol(s);
             }
+            // ENUM support
             for (const decl of s.getDeclarations() ?? []) {
                 if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
                     if (typescript_1.default.isStringLiteral(decl.initializer)) {
@@ -81,6 +82,26 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
+        // OBJECT support
+        if (typescript_1.default.isIdentifier(node.expression)) {
+            const objSymbol = checker.getSymbolAtLocation(node.expression);
+            if (objSymbol) {
+                for (const decl of objSymbol.getDeclarations() ?? []) {
+                    if (typescript_1.default.isVariableDeclaration(decl) &&
+                        decl.initializer &&
+                        typescript_1.default.isObjectLiteralExpression(decl.initializer)) {
+                        for (const prop of decl.initializer.properties) {
+                            if (!typescript_1.default.isPropertyAssignment(prop))
+                                continue;
+                            const name = prop.name.getText();
+                            if (name === node.name.text) {
+                                return resolveNodeValue(prop.initializer, checker, paramMap, seen);
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
     if (typescript_1.default.isObjectLiteralExpression(node)) {
         const values = [];

package/package.json

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

package/src/commands/watch.ts

@@ -2,6 +2,7 @@ import chokidar from "chokidar";
 import chalk from "chalk";
 import fs from "fs/promises";
 import fg from "fast-glob";
+import path from "path";
 
 import { loadConfig, saveConfig } from "../utils/config";
 import { EventraEngine } from "../engine/engine";
@@ -19,19 +20,29 @@ export async function watch() {
 
   const engine = new EventraEngine(process.cwd());
 
+  const fileCache: { file: string; content: string }[] = [];
+
+  // PRELOAD TS
   for (const file of files) {
     try {
-      const raw = await fs.readFile(file, "utf-8");
+      const abs = path.resolve(file);
+      const raw = await fs.readFile(abs, "utf-8");
 
-      const { content, virtualFile } = processFile(file, raw);
+      const { content, virtualFile } = processFile(abs, raw);
 
-      engine.scanFile(virtualFile, content, config);
+      fileCache.push({ file: virtualFile, content });
 
+      engine["ts"].updateFile(virtualFile, content);
     } 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);
 
@@ -39,10 +50,12 @@ export async function watch() {
     chalk.gray(`Initial: ${config.events.length} events\n`)
   );
 
+  // WATCH STATE
   let locked = false;
   let queued = new Set<string>();
   let timer: NodeJS.Timeout | null = null;
 
+  // RUN BATCH
   const run = async () => {
     if (locked) return;
     locked = true;
@@ -53,7 +66,6 @@ export async function watch() {
     for (const file of batch) {
       try {
         const raw = await fs.readFile(file, "utf-8");
-
         const { content, virtualFile } = processFile(file, raw);
 
         engine.updateFile(virtualFile, content, config);
@@ -83,14 +95,17 @@ export async function watch() {
     locked = false;
   };
 
+  // SCHEDULER
   const schedule = (file: string) => {
-    queued.add(file);
+    const abs = path.resolve(file);
 
-    if (timer) clearTimeout(timer);
+    queued.add(abs);
 
+    if (timer) clearTimeout(timer);
     timer = setTimeout(run, 100);
   };
 
+  // WATCHER
   const watcher = chokidar.watch(config.sync.include, {
     ignored: config.sync.exclude,
     ignoreInitial: true,
@@ -100,16 +115,22 @@ export async function watch() {
     .on("add", schedule)
     .on("change", schedule)
     .on("unlink", async (file) => {
+      const abs = path.resolve(file);
+
       console.log(chalk.gray(`remove: ${file}`));
 
-      const { virtualFile } = processFile(file, "");
+      const { virtualFile } = processFile(abs, "");
 
-      engine.removeFile(virtualFile);
+      engine.removeFile(virtualFile, config);
 
       const next = engine.getAllEvents();
 
       config.events = next.sort();
       await saveConfig(config);
+
+      console.log(
+        chalk.gray(`Total: ${config.events.length} events\n`)
+      );
     });
 
   process.on("SIGINT", async () => {

package/src/engine/resolver.ts

@@ -107,6 +107,7 @@ export function resolveNodeValue(
         s = checker.getAliasedSymbol(s);
       }
 
+      // ENUM support
       for (const decl of s.getDeclarations() ?? []) {
         if (ts.isEnumMember(decl) && decl.initializer) {
           if (ts.isStringLiteral(decl.initializer)) {
@@ -118,6 +119,36 @@ export function resolveNodeValue(
         }
       }
     }
+
+    // OBJECT support
+    if (ts.isIdentifier(node.expression)) {
+      const objSymbol = checker.getSymbolAtLocation(node.expression);
+
+      if (objSymbol) {
+        for (const decl of objSymbol.getDeclarations() ?? []) {
+          if (
+            ts.isVariableDeclaration(decl) &&
+            decl.initializer &&
+            ts.isObjectLiteralExpression(decl.initializer)
+          ) {
+            for (const prop of decl.initializer.properties) {
+              if (!ts.isPropertyAssignment(prop)) continue;
+
+              const name = prop.name.getText();
+
+              if (name === node.name.text) {
+                return resolveNodeValue(
+                  prop.initializer,
+                  checker,
+                  paramMap,
+                  seen
+                );
+              }
+            }
+          }
+        }
+      }
+    }
   }
 
   if (ts.isObjectLiteralExpression(node)) {