@eventra_dev/eventra-cli 0.0.19 → 0.1.1

package/dist/engine/graph.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyGraph = void 0;
+class DependencyGraph {
+    reverse = new Map();
+    update(file, source) {
+        const imports = source
+            .getImportDeclarations()
+            .map(i => i.getModuleSpecifierSourceFile()?.getFilePath())
+            .filter(Boolean);
+        for (const dep of imports) {
+            if (!this.reverse.has(dep)) {
+                this.reverse.set(dep, new Set());
+            }
+            this.reverse.get(dep).add(file);
+        }
+    }
+    getDependents(file) {
+        return [...(this.reverse.get(file) ?? [])];
+    }
+}
+exports.DependencyGraph = DependencyGraph;

package/dist/engine/project.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectGraph = void 0;
+const ts_morph_1 = require("ts-morph");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function normalize(file) {
+    return path_1.default.resolve(file);
+}
+function findTsConfig(start) {
+    let dir = path_1.default.dirname(start);
+    while (true) {
+        const file = path_1.default.join(dir, "tsconfig.json");
+        if (fs_1.default.existsSync(file))
+            return file;
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+function getScriptKind(file) {
+    if (file.endsWith(".tsx"))
+        return ts_morph_1.ts.ScriptKind.TSX;
+    if (file.endsWith(".jsx"))
+        return ts_morph_1.ts.ScriptKind.JSX;
+    if (file.endsWith(".js"))
+        return ts_morph_1.ts.ScriptKind.JS;
+    if (file.endsWith(".vue"))
+        return ts_morph_1.ts.ScriptKind.TSX;
+    return ts_morph_1.ts.ScriptKind.TS;
+}
+class ProjectGraph {
+    project;
+    constructor(entry) {
+        const tsconfig = findTsConfig(entry);
+        this.project = tsconfig
+            ? new ts_morph_1.Project({
+                tsConfigFilePath: tsconfig,
+                skipAddingFilesFromTsConfig: false,
+            })
+            : new ts_morph_1.Project({
+                useInMemoryFileSystem: true,
+                compilerOptions: {
+                    allowJs: true,
+                    jsx: ts_morph_1.ts.JsxEmit.Preserve,
+                    moduleResolution: ts_morph_1.ts.ModuleResolutionKind.NodeJs,
+                    target: ts_morph_1.ts.ScriptTarget.ESNext,
+                },
+            });
+    }
+    getSource(file, content) {
+        const filePath = normalize(file);
+        let source = this.project.getSourceFile(filePath);
+        if (!source) {
+            source = this.project.createSourceFile(filePath, content, {
+                overwrite: true,
+                scriptKind: getScriptKind(filePath),
+            });
+        }
+        else {
+            source.replaceWithText(content);
+        }
+        return source;
+    }
+    getChecker() {
+        return this.project.getTypeChecker().compilerObject;
+    }
+}
+exports.ProjectGraph = ProjectGraph;

package/dist/engine/resolver.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNodeValue = resolveNodeValue;
+const ts_morph_1 = require("ts-morph");
+function resolveNodeValue(node, checker) {
+    if (!ts_morph_1.Node.isIdentifier(node))
+        return null;
+    const symbol = checker.getSymbolAtLocation(node.compilerNode);
+    if (!symbol)
+        return null;
+    const decls = symbol.getDeclarations() ?? [];
+    for (const d of decls) {
+        if (ts_morph_1.ts.isVariableDeclaration(d) && d.initializer) {
+            const init = d.initializer;
+            if (ts_morph_1.ts.isStringLiteral(init)) {
+                return { values: [init.text], dynamic: false };
+            }
+            if (ts_morph_1.ts.isNoSubstitutionTemplateLiteral(init)) {
+                return { values: [init.text], dynamic: false };
+            }
+            if (ts_morph_1.ts.isTemplateExpression(init)) {
+                let result = init.head.text;
+                for (const span of init.templateSpans) {
+                    result += "*";
+                    result += span.literal.text;
+                }
+                return { values: [result], dynamic: true };
+            }
+        }
+        if (ts_morph_1.ts.isParameter(d) && d.initializer) {
+            const init = d.initializer;
+            if (ts_morph_1.ts.isStringLiteral(init)) {
+                return { values: [init.text], dynamic: false };
+            }
+        }
+    }
+    return null;
+}

package/dist/engine/scanner.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanSource = scanSource;
+const ts_morph_1 = require("ts-morph");
+const extract_1 = require("./extract");
+const callResolver_1 = require("./callResolver");
+const flow_1 = require("./flow");
+function getCallName(expr) {
+    if (ts_morph_1.Node.isIdentifier(expr))
+        return expr.getText();
+    if (ts_morph_1.Node.isPropertyAccessExpression(expr))
+        return expr.getName();
+    return expr.getText();
+}
+function isTrackLike(name) {
+    return /(track|trackFeature)/i.test(name);
+}
+function pickArg(args) {
+    return (args.find(ts_morph_1.Node.isStringLiteral) ??
+        args.find(ts_morph_1.Node.isTemplateExpression) ??
+        args.find(ts_morph_1.Node.isObjectLiteralExpression) ??
+        args[0]);
+}
+function scanSource(source, checker) {
+    const events = new Set();
+    // CALLS
+    for (const call of source.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)) {
+        const expr = call.getExpression();
+        const name = getCallName(expr);
+        if (!isTrackLike(name))
+            continue;
+        const args = call.getArguments();
+        if (!args.length)
+            continue;
+        let target = pickArg(args);
+        const fn = (0, callResolver_1.resolveFunctionFromCall)(expr);
+        if (fn) {
+            const index = (0, flow_1.getForwardedParamIndex)(fn);
+            if (index !== null && args[index]) {
+                target = args[index];
+            }
+        }
+        (0, extract_1.extractEventsFromArgs)([target], checker).forEach(({ value }) => {
+            if (isValid(value))
+                events.add(value);
+        });
+    }
+    // JSX
+    const jsx = [
+        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxOpeningElement),
+        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxSelfClosingElement),
+    ];
+    for (const el of jsx) {
+        for (const attr of el.getAttributes()) {
+            if (!ts_morph_1.Node.isJsxAttribute(attr))
+                continue;
+            const name = attr.getNameNode().getText();
+            if (!/(event|name|action)/i.test(name))
+                continue;
+            const init = attr.getInitializer();
+            if (!init)
+                continue;
+            const expr = ts_morph_1.Node.isJsxExpression(init)
+                ? init.getExpression()
+                : init;
+            if (!expr)
+                continue;
+            (0, extract_1.extractEventsFromArgs)([expr], checker).forEach(({ value }) => {
+                if (isValid(value))
+                    events.add(value);
+            });
+        }
+    }
+    return events;
+}
+function isValid(v) {
+    return !!v && v.length > 1 && !v.includes(" ");
+}

package/dist/engine/symbol.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNodeValue = resolveNodeValue;
+const ts_morph_1 = require("ts-morph");
+function resolveNodeValue(node, checker) {
+    if (ts_morph_1.Node.isIdentifier(node)) {
+        const symbol = checker.getSymbolAtLocation(node.compilerNode);
+        if (!symbol)
+            return null;
+        const decls = symbol.getDeclarations() ?? [];
+        for (const d of decls) {
+            if (ts_morph_1.ts.isVariableDeclaration(d) && d.initializer) {
+                if (ts_morph_1.Node.isStringLiteral(d.initializer)) {
+                    return {
+                        values: [d.initializer.text],
+                        dynamic: false
+                    };
+                }
+            }
+            if (ts_morph_1.ts.isParameter(d) && d.initializer) {
+                if (ts_morph_1.Node.isStringLiteral(d.initializer)) {
+                    return {
+                        values: [d.initializer.text],
+                        dynamic: false
+                    };
+                }
+            }
+        }
+    }
+    return null;
+}

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.1",
   "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);
   }