@eventra_dev/eventra-cli 0.0.19 → 0.1.2

package/dist/engine/languageService.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSService = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const fs_1 = __importDefault(require("fs"));
+class TSService {
+    root;
+    files = new Map();
+    service;
+    constructor(root) {
+        this.root = root;
+        const host = {
+            getScriptFileNames: () => [...this.files.keys()],
+            getScriptVersion: (file) => this.files.get(file)?.version.toString() ?? "0",
+            getScriptSnapshot: (file) => {
+                const f = this.files.get(file);
+                if (f) {
+                    return typescript_1.default.ScriptSnapshot.fromString(f.content);
+                }
+                if (fs_1.default.existsSync(file)) {
+                    return typescript_1.default.ScriptSnapshot.fromString(fs_1.default.readFileSync(file, "utf-8"));
+                }
+                return undefined;
+            },
+            getCurrentDirectory: () => this.root,
+            getCompilationSettings: () => ({
+                allowJs: true,
+                jsx: typescript_1.default.JsxEmit.Preserve,
+                moduleResolution: typescript_1.default.ModuleResolutionKind.Node16,
+                target: typescript_1.default.ScriptTarget.ESNext,
+                esModuleInterop: true,
+                allowSyntheticDefaultImports: true,
+            }),
+            getDefaultLibFileName: (opts) => typescript_1.default.getDefaultLibFilePath(opts),
+            readFile: (fileName, encoding) => {
+                try {
+                    return fs_1.default.readFileSync(fileName, encoding);
+                }
+                catch (err) {
+                    return undefined;
+                }
+            },
+            fileExists: fs_1.default.existsSync,
+        };
+        this.service = typescript_1.default.createLanguageService(host);
+    }
+    updateFile(file, content) {
+        const prev = this.files.get(file);
+        this.files.set(file, {
+            content,
+            version: prev ? prev.version + 1 : 1,
+        });
+    }
+    getProgram() {
+        return this.service.getProgram();
+    }
+    getChecker() {
+        return this.getProgram()?.getTypeChecker();
+    }
+    getSourceFile(file) {
+        return this.getProgram()?.getSourceFile(file);
+    }
+}
+exports.TSService = TSService;

package/dist/engine/resolver.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNodeValue = resolveNodeValue;
+const typescript_1 = __importDefault(require("typescript"));
+function resolveNodeValue(node, checker) {
+    if (typescript_1.default.isStringLiteral(node)) {
+        return { values: [node.text], dynamic: false };
+    }
+    if (typescript_1.default.isTemplateExpression(node)) {
+        let result = node.head.text;
+        for (const span of node.templateSpans) {
+            result += "*";
+            result += span.literal.text;
+        }
+        return { values: [result], dynamic: true };
+    }
+    if (typescript_1.default.isConditionalExpression(node)) {
+        const a = resolveNodeValue(node.whenTrue, checker);
+        const b = resolveNodeValue(node.whenFalse, checker);
+        return {
+            values: [...new Set([...(a?.values ?? []), ...(b?.values ?? [])])],
+            dynamic: true,
+        };
+    }
+    if (typescript_1.default.isIdentifier(node)) {
+        let symbol = checker.getSymbolAtLocation(node);
+        if (!symbol)
+            return null;
+        if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+            symbol = checker.getAliasedSymbol(symbol);
+        }
+        for (const decl of symbol.getDeclarations() ?? []) {
+            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+                return resolveNodeValue(decl.initializer, checker);
+            }
+            if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
+                if (typescript_1.default.isStringLiteral(decl.initializer)) {
+                    return {
+                        values: [decl.initializer.text],
+                        dynamic: false,
+                    };
+                }
+            }
+        }
+    }
+    if (typescript_1.default.isPropertyAccessExpression(node)) {
+        const symbol = checker.getSymbolAtLocation(node);
+        if (symbol) {
+            let s = symbol;
+            if (s.flags & typescript_1.default.SymbolFlags.Alias) {
+                s = checker.getAliasedSymbol(s);
+            }
+            for (const decl of s.getDeclarations() ?? []) {
+                if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
+                    if (typescript_1.default.isStringLiteral(decl.initializer)) {
+                        return {
+                            values: [decl.initializer.text],
+                            dynamic: false,
+                        };
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}

package/dist/engine/scanner.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanSource = scanSource;
+const typescript_1 = __importDefault(require("typescript"));
+const resolver_1 = require("./resolver");
+const callResolver_1 = require("./callResolver");
+function scanSource(source, checker, visited = new Set()) {
+    const events = new Set();
+    if (visited.has(source.fileName))
+        return events;
+    visited.add(source.fileName);
+    function visit(node) {
+        if (typescript_1.default.isCallExpression(node)) {
+            const name = getCallName(node.expression);
+            if (/(track|event|capture|send)/i.test(name)) {
+                let target = node.arguments[0];
+                const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
+                // 🔥 cross-file
+                if (fn) {
+                    const sf = fn.getSourceFile();
+                    if (!visited.has(sf.fileName)) {
+                        scanSource(sf, checker, visited).forEach(e => events.add(e));
+                    }
+                }
+                if (target) {
+                    const res = (0, resolver_1.resolveNodeValue)(target, checker);
+                    res?.values.forEach(v => {
+                        if (v && v.length > 1 && !v.includes(" ")) {
+                            events.add(v);
+                        }
+                    });
+                }
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    visit(source);
+    return events;
+}
+function getCallName(expr) {
+    if (typescript_1.default.isIdentifier(expr))
+        return expr.text;
+    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+        return expr.name.text;
+    }
+    return "";
+}

package/dist/utils/parsers/vue.js

@@ -2,17 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVue = parseVue;
 function parseVue(content) {
-    const template = content.match(/<template[\s\S]*?>([\s\S]*?)<\/template>/);
-    const script = content.match(/<script[\s\S]*?>([\s\S]*?)<\/script>/);
-    return `
-${script?.[1] ?? ""}
-
-function __vue_template__() {
-  return (
-    <>
-      ${template?.[1] ?? ""}
-    </>
-  );
-}
+    const scriptMatch = content.match(/<script[\s\S]*?>([\s\S]*?)<\/script>/);
+    const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/);
+    const script = scriptMatch?.[1] ?? "";
+    let template = templateMatch?.[1] ?? "";
+    template = template.replace(/<!--[\s\S]*?-->/g, "");
+    template = template
+        .replace(/v-if="[^"]+"/g, "")
+        .replace(/v-for="[^"]+"/g, "")
+        .replace(/@click=/g, "onClick=");
+    const jsx = `
+const __VUE_JSX__ = (
+  <>
+    ${template}
+  </>
+);
 `;
+    return script + "\n" + jsx;
 }

package/dist/utils/processFile.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFile = processFile;
+const router_1 = require("./parsers/router");
+const vue_1 = require("./parsers/vue");
+const svelte_1 = require("./parsers/svelte");
+const astro_1 = require("./parsers/astro");
+function processFile(file, content) {
+    const parser = (0, router_1.detectParser)(file);
+    if (parser === "vue")
+        content = (0, vue_1.parseVue)(content);
+    if (parser === "svelte")
+        content = (0, svelte_1.parseSvelte)(content);
+    if (parser === "astro")
+        content = (0, astro_1.parseAstro)(content);
+    const virtualFile = file.endsWith(".vue")
+        ? file + ".tsx"
+        : file;
+    return { content, virtualFile };
+}

package/package.json

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

package/src/commands/check.ts

@@ -1,21 +1,10 @@
 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, saveConfig } from "../utils/config";
-
-import { detectParser } from "../utils/parsers/router";
-import { parseVue } from "../utils/parsers/vue";
-import { parseSvelte } from "../utils/parsers/svelte";
-import { parseAstro } from "../utils/parsers/astro";
-
-import { scanTrack } from "../utils/scanners/track";
-import { scanFunctionWrappers } from "../utils/scanners/function-wrappers";
-import { scanComponentWrappers } from "../utils/scanners/component-wrappers";
-
-import { ExtractedEvent } from "../types";
+import { EventraEngine } from "../engine/engine";
+import { processFile } from "../utils/processFile";
 
 export async function check({ fix = false }: { fix?: boolean }) {
   const config = await loadConfig();
@@ -27,169 +16,48 @@ export async function check({ fix = false }: { fix?: boolean }) {
 
   console.log(chalk.blue("Checking events..."));
 
-  const project = new Project();
-
-  const knownEvents = new Set(config.events ?? []);
-  const aliases = { ...(config.aliases ?? {}) };
-
-  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
+    ignore: config.sync.exclude,
   });
 
+  const engine = new EventraEngine(process.cwd());
+
   for (const file of files) {
     try {
-      const stat = await fs.stat(file);
-
-      if (stat.size > 2 * 1024 * 1024) {
-        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 source = project.createSourceFile(file, content, {
-        overwrite: true
-      });
-
-      const found: ExtractedEvent[] = [
-        ...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;
-
-        // skip
-        if (aliases[value] === "__skip__") continue;
-
-        // alias resolve
-        if (value in aliases) {
-          foundEvents.set(aliases[value], {
-            ...event,
-            value: aliases[value]
-          });
-          continue;
-        }
-
-        if (dynamic) {
-          unresolvedDynamic.set(value, event);
-          continue;
-        }
+      const raw = await fs.readFile(file, "utf-8");
 
-        foundEvents.set(value, event);
-      }
+      const { content, virtualFile } = processFile(file, raw);
 
-      project.removeSourceFile(source);
+      engine.scanFile(virtualFile, content);
 
     } catch {
       console.log(chalk.gray(`Skipped: ${file}`));
     }
   }
 
-  // find new
-  for (const [key, event] of foundEvents) {
-    if (!knownEvents.has(key)) {
-      newEvents.set(key, event);
-    }
-  }
-
-  // FIX MODE
-  if (fix) {
-    console.log(chalk.yellow("\nFix mode\n"));
+  const found = new Set(engine.getAllEvents());
+  const known = new Set(config.events ?? []);
 
-    // 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:"
-        }
-      ]);
-
-      const normalized = name.trim().toLowerCase();
-      if (!normalized) continue;
-
-      aliases[value] = normalized;
-      config.events.push(normalized);
-
-      console.log(chalk.green(`${value} → ${normalized}`));
-    }
+  const newEvents = [...found].filter(e => !known.has(e));
 
-    config.aliases = Object.fromEntries(
-      Object.entries(aliases).sort()
-    );
+  if (fix) {
+    newEvents.forEach(e => {
+      config.events.push(e);
+      console.log(chalk.green(`+ ${e}`));
+    });
 
     config.events = [...new Set(config.events)].sort();
 
     await saveConfig(config);
 
-    console.log(chalk.green("\n✔ Fixed"));
+    console.log(chalk.green("\nFixed"));
     return;
   }
 
-  // NORMAL MODE
-  let hasError = false;
-
-  if (unresolvedDynamic.size) {
-    hasError = true;
-
-    console.log(chalk.red("\nDynamic events:"));
-
-    unresolvedDynamic.forEach((e) =>
-      console.log(
-        chalk.red(`- ${e.value} (${e.file}:${e.line})`)
-      )
-    );
-  }
-
-  if (newEvents.size) {
-    hasError = true;
-
+  if (newEvents.length) {
     console.log(chalk.red("\nNew events:"));
+    newEvents.forEach(e => console.log(chalk.red(`+ ${e}`)));
 
-    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);
   }