@eventra_dev/eventra-cli 0.0.18 → 0.0.19

package/dist/utils/scanners/function-wrappers.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanFunctionWrappers = scanFunctionWrappers;
 const ts_morph_1 = require("ts-morph");
 const extract_1 = require("../extract");
-function scanFunctionWrappers(source, wrappers) {
-    const events = new Set();
+function scanFunctionWrappers(source, wrappers, aliases) {
+    const events = new Map();
     const calls = source.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
     for (const call of calls) {
         const name = getFunctionName(call);
@@ -13,13 +13,16 @@ function scanFunctionWrappers(source, wrappers) {
         for (const wrapper of wrappers) {
             if (wrapper.name !== name)
                 continue;
-            const results = extractEventFromArgs(call, wrapper.event);
+            const results = extractEventFromArgs(call, wrapper.event, aliases);
             if (!results)
                 continue;
-            results.forEach((r) => events.add(r));
+            for (const r of results) {
+                const key = `${r.value}:${r.dynamic}`;
+                events.set(key, r);
+            }
         }
     }
-    return events;
+    return [...events.values()];
 }
 function getFunctionName(call) {
     const expression = call.getExpression();
@@ -35,21 +38,18 @@ function getDeepName(node) {
     let current = node;
     let name = "";
     while (ts_morph_1.Node.isPropertyAccessExpression(current)) {
-        name =
-            current.getName();
-        current =
-            current.getExpression();
+        name = current.getName();
+        current = current.getExpression();
     }
     return name;
 }
-function extractEventFromArgs(call, event) {
+function extractEventFromArgs(call, event, aliases) {
     const args = call.getArguments();
     const events = [];
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
+    for (const arg of args) {
         // track("event")
         if (!event) {
-            const result = (0, extract_1.extractExpression)(arg);
+            const result = (0, extract_1.extractExpression)(arg, aliases);
             if (!result)
                 continue;
             result.values.forEach((value) => events.push({
@@ -57,7 +57,7 @@ function extractEventFromArgs(call, event) {
                 dynamic: result.dynamic
             }));
         }
-        // track({event})
+        // track({ event })
         if (event) {
             const obj = arg.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
             if (!obj)
@@ -69,7 +69,7 @@ function extractEventFromArgs(call, event) {
                 const init = prop.getInitializer();
                 if (!init)
                     continue;
-                const result = (0, extract_1.extractExpression)(init);
+                const result = (0, extract_1.extractExpression)(init, aliases);
                 if (!result)
                     continue;
                 result.values.forEach((value) => events.push({
@@ -79,7 +79,5 @@ function extractEventFromArgs(call, event) {
             }
         }
     }
-    return events.length
-        ? events
-        : null;
+    return events.length ? events : null;
 }

package/dist/utils/scanners/track.js

@@ -1,10 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanTrack = scanTrack;
 const ts_morph_1 = require("ts-morph");
+const path_1 = __importDefault(require("path"));
 const extract_1 = require("../extract");
-function scanTrack(source, config) {
-    const events = new Set();
+function scanTrack(source, config, aliases) {
+    const events = new Map();
     const calls = source.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
     for (const call of calls) {
         const expr = call.getExpression();
@@ -19,6 +23,7 @@ function scanTrack(source, config) {
         }
         if (!isTrack)
             continue;
+        // ❗ skip wrapper functions
         const func = call.getFirstAncestorByKind(ts_morph_1.SyntaxKind.FunctionDeclaration) ||
             call.getFirstAncestorByKind(ts_morph_1.SyntaxKind.ArrowFunction) ||
             call.getFirstAncestorByKind(ts_morph_1.SyntaxKind.FunctionExpression);
@@ -40,13 +45,20 @@ function scanTrack(source, config) {
         const arg = call.getArguments()[0];
         if (!arg)
             continue;
-        const result = (0, extract_1.extractExpression)(arg);
+        const result = (0, extract_1.extractExpression)(arg, aliases);
         if (!result)
             continue;
-        result.values.forEach((value) => events.add({
-            value,
-            dynamic: result.dynamic,
-        }));
+        const line = call.getStartLineNumber();
+        const file = path_1.default.relative(process.cwd(), source.getFilePath());
+        for (const value of result.values) {
+            const key = `${value}:${file}:${line}`;
+            events.set(key, {
+                value,
+                dynamic: result.dynamic,
+                file,
+                line
+            });
+        }
     }
-    return events;
+    return [...events.values()];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {
@@ -20,6 +20,7 @@
   },
   "dependencies": {
     "chalk": "^4.1.2",
+    "chokidar": "^5.0.0",
     "commander": "^11.0.0",
     "fast-glob": "^3.3.3",
     "fs-extra": "^11.2.0",

package/src/commands/check.ts

@@ -2,8 +2,9 @@ import chalk from "chalk";
 import fg from "fast-glob";
 import { Project } from "ts-morph";
 import fs from "fs/promises";
+import inquirer from "inquirer";
 
-import { loadConfig } from "../utils/config";
+import { loadConfig, saveConfig } from "../utils/config";
 
 import { detectParser } from "../utils/parsers/router";
 import { parseVue } from "../utils/parsers/vue";
@@ -16,7 +17,7 @@ import { scanComponentWrappers } from "../utils/scanners/component-wrappers";
 
 import { ExtractedEvent } from "../types";
 
-export async function check() {
+export async function check({ fix = false }: { fix?: boolean }) {
   const config = await loadConfig();
 
   if (!config) {
@@ -29,11 +30,11 @@ export async function check() {
   const project = new Project();
 
   const knownEvents = new Set(config.events ?? []);
-  const aliases = config.aliases ?? {};
+  const aliases = { ...(config.aliases ?? {}) };
 
-  const foundEvents = new Set<string>();
-  const newEvents = new Set<string>();
-  const unresolvedDynamic = new Set<string>();
+  const foundEvents = new Map<string, ExtractedEvent>();
+  const newEvents = new Map<string, ExtractedEvent>();
+  const unresolvedDynamic = new Map<string, ExtractedEvent>();
 
   const files = await fg(config.sync.include, {
     ignore: config.sync.exclude
@@ -41,132 +42,156 @@ export async function check() {
 
   for (const file of files) {
     try {
-      // skip huge files
       const stat = await fs.stat(file);
+
       if (stat.size > 2 * 1024 * 1024) {
-        console.log(chalk.gray(`Skipped large file: ${file}`));
         continue;
       }
 
       const parser = detectParser(file);
-
       let content = await fs.readFile(file, "utf-8");
 
       if (parser === "vue") content = parseVue(content);
       if (parser === "svelte") content = parseSvelte(content);
       if (parser === "astro") content = parseAstro(content);
 
-      const virtualFile =
-        parser === "ts" ? file : file + ".tsx";
-
-      const source = project.createSourceFile(
-        virtualFile,
-        content,
-        { overwrite: true }
-      );
+      const source = project.createSourceFile(file, content, {
+        overwrite: true
+      });
 
       const found: ExtractedEvent[] = [
-        ...scanTrack(source, config),
-        ...scanFunctionWrappers(
-          source,
-          config.functionWrappers ?? []
-        ),
-        ...scanComponentWrappers(
-          source,
-          config.wrappers ?? []
-        )
+        ...scanTrack(source, config, aliases),
+        ...scanFunctionWrappers(source, config.functionWrappers ?? [], aliases),
+        ...scanComponentWrappers(source, config.wrappers ?? [], aliases)
       ];
 
       for (const event of found) {
         const { value, dynamic } = event;
-
         if (!value) continue;
 
-        // alias skip
-        if (aliases[value] === "__skip__") {
-          continue;
-        }
+        // skip
+        if (aliases[value] === "__skip__") continue;
 
         // alias resolve
-        if (aliases[value]) {
-          foundEvents.add(aliases[value]);
+        if (value in aliases) {
+          foundEvents.set(aliases[value], {
+            ...event,
+            value: aliases[value]
+          });
           continue;
         }
 
-        // dynamic without alias
         if (dynamic) {
-          unresolvedDynamic.add(value);
+          unresolvedDynamic.set(value, event);
           continue;
         }
 
-        // static
-        foundEvents.add(value);
+        foundEvents.set(value, event);
       }
 
-      // clear memory
       project.removeSourceFile(source);
 
     } catch {
-      console.log(
-        chalk.gray(`Skipped file (error): ${file}`)
-      );
+      console.log(chalk.gray(`Skipped: ${file}`));
     }
   }
 
-  // find new events
-  for (const event of foundEvents) {
-    if (!knownEvents.has(event)) {
-      newEvents.add(event);
+  // find new
+  for (const [key, event] of foundEvents) {
+    if (!knownEvents.has(key)) {
+      newEvents.set(key, event);
     }
   }
 
-  let hasError = false;
+  // FIX MODE
+  if (fix) {
+    console.log(chalk.yellow("\nFix mode\n"));
 
-  // dynamic
-  if (unresolvedDynamic.size > 0) {
-    hasError = true;
+    // add new events
+    for (const [name] of newEvents) {
+      config.events.push(name);
+      console.log(chalk.green(`+ ${name}`));
+    }
+
+    // resolve dynamic
+    for (const [value] of unresolvedDynamic) {
+      const { action } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "action",
+          message: `Dynamic: ${value}`,
+          choices: [
+            { name: "Alias", value: "alias" },
+            { name: "Skip", value: "skip" }
+          ]
+        }
+      ]);
+
+      if (action === "skip") {
+        aliases[value] = "__skip__";
+        continue;
+      }
+
+      const { name } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "name",
+          message: "Event name:"
+        }
+      ]);
 
-    console.log(
-      chalk.red("\nUnresolved dynamic events:")
+      const normalized = name.trim().toLowerCase();
+      if (!normalized) continue;
+
+      aliases[value] = normalized;
+      config.events.push(normalized);
+
+      console.log(chalk.green(`${value} → ${normalized}`));
+    }
+
+    config.aliases = Object.fromEntries(
+      Object.entries(aliases).sort()
     );
 
-    [...unresolvedDynamic]
-      .sort()
-      .forEach((e) =>
-        console.log(chalk.red(`- ${e}`))
-      );
+    config.events = [...new Set(config.events)].sort();
+
+    await saveConfig(config);
+
+    console.log(chalk.green("\n✔ Fixed"));
+    return;
   }
 
-  // new events
-  if (newEvents.size > 0) {
+  // NORMAL MODE
+  let hasError = false;
+
+  if (unresolvedDynamic.size) {
     hasError = true;
 
-    console.log(
-      chalk.red("\nNew events detected:")
-    );
+    console.log(chalk.red("\nDynamic events:"));
 
-    [...newEvents]
-      .sort()
-      .forEach((e) =>
-        console.log(chalk.red(`+ ${e}`))
-      );
+    unresolvedDynamic.forEach((e) =>
+      console.log(
+        chalk.red(`- ${e.value} (${e.file}:${e.line})`)
+      )
+    );
   }
 
-  if (hasError) {
-    console.log("");
+  if (newEvents.size) {
+    hasError = true;
 
-    console.log(chalk.red("Event check failed"));
+    console.log(chalk.red("\nNew events:"));
 
-    console.log(
-      chalk.red(
-        `dynamic: ${unresolvedDynamic.size}, new: ${newEvents.size}`
+    newEvents.forEach((e) =>
+      console.log(
+        chalk.red(`+ ${e.value} (${e.file}:${e.line})`)
       )
     );
+  }
 
+  if (hasError) {
+    console.log(chalk.red("\nEvent check failed"));
     process.exit(1);
   }
 
-  console.log(
-    chalk.green("\nAll events are valid")
-  );
+  console.log(chalk.green("\nAll good"));
 }