@eventra_dev/eventra-cli 0.2.3 → 0.3.1

package/src/engine/engine.ts

@@ -1,227 +0,0 @@
-import path from "path";
-import fs from "fs";
-
-import { TSService } from "./languageService";
-import { scanSource } from "./scanner";
-import { DependencyGraph } from "./graph";
-import { hash } from "./hash";
-import { EventraConfig, ScanResult } from "../types";
-import { isExternalFile } from "./boundary";
-
-export class EventraEngine {
-  private ts: TSService;
-  private graph: DependencyGraph;
-  private wrapperCache = new Map<string, string | null>();
-  private fileResults = new Map<string, ScanResult>();
-  private fileHash = new Map<string, string>();
-
-  constructor(root: string) {
-    this.ts = new TSService(root);
-
-    const { baseUrl, paths } = this.ts.getModuleResolutionConfig();
-    this.graph = new DependencyGraph(baseUrl, paths);
-  }
-
-  private normalize(file: string) {
-    return path.resolve(file).replace(/\\/g, "/");
-  }
-
-  private empty(): ScanResult {
-    return {
-      events: new Set(),
-      detectedFunctionWrappers: new Set(),
-      detectedComponentWrappers: new Map(),
-    };
-  }
-
-  // PRELOAD
-  preloadFile(file: string, content: string) {
-    file = this.normalize(file);
-
-    this.ts.updateFile(file, content);
-
-    const source = this.ts.getSourceFile(file);
-    if (source) {
-      this.graph.update(file, source);
-    }
-  }
-
-  // SCAN FILE (cached)
-  scanFile(
-    file: string,
-    content: string,
-    config: EventraConfig
-  ): ScanResult {
-    file = this.normalize(file);
-
-    const h = hash(content);
-
-    if (this.fileHash.get(file) === h) {
-      return this.fileResults.get(file) ?? this.empty();
-    }
-
-    this.fileHash.set(file, h);
-
-    this.ts.updateFile(file, content);
-
-    const source = this.ts.getSourceFile(file);
-    const checker = this.ts.getChecker();
-
-    if (!source || !checker) {
-      return this.empty();
-    }
-
-    this.graph.update(file, source);
-
-    const res = scanSource(
-      source,
-      checker,
-      config,
-      new Set(),
-      undefined,
-      this.wrapperCache
-    );
-
-    this.fileResults.set(file, res);
-
-    return res;
-  }
-
-  // UPDATE FILE (incremental)
-  updateFile(
-    file: string,
-    content: string,
-    config: EventraConfig
-  ): 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);
-
-    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);
-
-      if (!depContent) {
-        try {
-          depContent = fs.readFileSync(abs, "utf-8");
-        } catch {
-          continue;
-        }
-      }
-
-      const h = hash(depContent);
-
-      if (this.fileHash.get(abs) === h) {
-        continue;
-      }
-
-      this.fileHash.set(abs, h);
-
-      this.ts.updateFile(abs, depContent);
-
-      const source = this.ts.getSourceFile(abs);
-      const checker = this.ts.getChecker();
-
-      if (!source || !checker) continue;
-
-      this.graph.update(abs, source);
-
-      const r = scanSource(
-        source,
-        checker,
-        config,
-        new Set(),
-        undefined,
-        this.wrapperCache
-      );
-
-      this.fileResults.set(abs, r);
-    }
-
-    return res;
-  }
-
-  // GET ALL EVENTS
-  getAllEvents() {
-    const all = new Set<string>();
-
-    for (const r of this.fileResults.values()) {
-      r.events.forEach(e => all.add(e));
-    }
-
-    return [...all];
-  }
-
-  // REMOVE FILE
-  removeFile(file: string, config?: EventraConfig) {
-    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);
-
-    for (const dep of dependents) {
-      const abs = this.normalize(dep);
-
-      if (abs === file) continue;
-      if (isExternalFile(abs)) continue;
-
-      let content = this.ts.getFileContent(abs);
-
-      if (!content) {
-        try {
-          content = fs.readFileSync(abs, "utf-8");
-        } catch {
-          continue;
-        }
-      }
-
-      this.fileHash.delete(abs);
-
-      this.ts.updateFile(abs, content);
-
-      const source = this.ts.getSourceFile(abs);
-      const checker = this.ts.getChecker();
-
-      if (!source || !checker) continue;
-
-      this.graph.update(abs, source);
-
-      const r = scanSource(
-        source,
-        checker,
-        config ?? {
-          events: [],
-          wrappers: [],
-          functionWrappers: [],
-          sync: { include: [], exclude: [] },
-        },
-        new Set(),
-        undefined,
-        this.wrapperCache
-      );
-
-      this.fileResults.set(abs, r);
-    }
-  }
-}

package/src/engine/exportResolver.ts

@@ -1,56 +0,0 @@
-import ts from "typescript";
-
-function isRealDeclaration(node: ts.Node) {
-  return (
-    ts.isFunctionDeclaration(node) ||
-    ts.isVariableDeclaration(node) ||
-    ts.isClassDeclaration(node)
-  );
-}
-
-export function resolveExportedSymbol(
-  symbol: ts.Symbol,
-  checker: ts.TypeChecker,
-  visited = new Set<ts.Symbol>()
-): ts.Symbol | null {
-
-  if (visited.has(symbol)) return null;
-  visited.add(symbol);
-
-  // unwrap alias
-  if (symbol.flags & ts.SymbolFlags.Alias) {
-    const aliased = checker.getAliasedSymbol(symbol);
-    return resolveExportedSymbol(aliased, checker, visited);
-  }
-
-  // export symbol
-  const exportSymbol = checker.getExportSymbolOfSymbol(symbol);
-  if (exportSymbol && exportSymbol !== symbol) {
-    return resolveExportedSymbol(exportSymbol, checker, visited);
-  }
-
-  const decls = symbol.getDeclarations() ?? [];
-
-  if (decls.some(isRealDeclaration)) {
-    return symbol;
-  }
-
-  // exports (re-export)
-  for (const decl of decls) {
-    const source = decl.getSourceFile();
-    const moduleSymbol = (source as any).symbol;
-
-    if (!moduleSymbol) continue;
-
-    const exports = checker.getExportsOfModule(moduleSymbol);
-
-    for (const exp of exports) {
-      const resolved = resolveExportedSymbol(exp, checker, visited);
-      if (resolved?.getDeclarations()?.length) {
-        return resolved;
-      }
-    }
-  }
-
-  return symbol;
-}

package/src/engine/functionAnalyzer.ts

@@ -1,81 +0,0 @@
-import ts from "typescript";
-
-export function findTrackParamIndex(
-  fn: ts.FunctionLikeDeclaration
-): number | null {
-  const paramIndex = new Map<string, number>();
-
-  fn.parameters.forEach((p, i) => {
-    if (ts.isIdentifier(p.name)) {
-      paramIndex.set(p.name.text, i);
-    }
-  });
-
-  let result: number | null = null;
-
-  function check(arg: ts.Expression): boolean {
-    // identifier
-    if (ts.isIdentifier(arg)) {
-      const idx = paramIndex.get(arg.text);
-      if (idx !== undefined) {
-        result = idx;
-        return true;
-      }
-    }
-
-    // template
-    if (ts.isTemplateExpression(arg)) {
-      for (const span of arg.templateSpans) {
-        if (ts.isIdentifier(span.expression)) {
-          const idx = paramIndex.get(span.expression.text);
-          if (idx !== undefined) {
-            result = idx;
-            return true;
-          }
-        }
-      }
-    }
-
-    // object { event: name }
-    if (ts.isObjectLiteralExpression(arg)) {
-      for (const prop of arg.properties) {
-        if (!ts.isPropertyAssignment(prop)) continue;
-
-        const key = prop.name.getText();
-
-        if (["event", "name", "type"].includes(key)) {
-          return check(prop.initializer);
-        }
-      }
-    }
-
-    return false;
-  }
-
-  function visit(node: ts.Node) {
-    if (result !== null) return;
-
-    if (ts.isCallExpression(node)) {
-      const expr = node.expression;
-
-      const isTrack =
-        (ts.isIdentifier(expr) && expr.text === "track") ||
-        (ts.isPropertyAccessExpression(expr) &&
-          expr.name.text === "track");
-
-      if (!isTrack) return;
-
-      for (const arg of node.arguments) {
-        if (check(arg)) return;
-      }
-    }
-
-    ts.forEachChild(node, visit);
-  }
-
-  if (fn.body) {
-    visit(fn.body);
-  }
-
-  return result;
-}

package/src/engine/graph.ts

@@ -1,193 +0,0 @@
-import ts from "typescript";
-import path from "path";
-import fs from "fs";
-
-export class DependencyGraph {
-  private reverse = new Map<string, Set<string>>();
-  private exports = new Map<string, Set<string>>();
-  private fileCache = new Map<string, string | null>();
-
-  constructor(
-    private baseUrl: string,
-    private paths: Record<string, string[]>
-  ) {}
-
-  private normalize(file: string) {
-    return path.resolve(file).replace(/\\/g, "/");
-  }
-
-  // MODULE RESOLVE
-  private resolveModule(module: string, from: string): string | null {
-    // relative import
-    if (module.startsWith(".")) {
-      const abs = path.resolve(path.dirname(from), module);
-      return this.resolveFile(abs);
-    }
-
-    // tsconfig paths
-    for (const key in this.paths) {
-      const pattern = key.replace(/\*/g, "(.*)");
-      const regex = new RegExp("^" + pattern + "$");
-      const match = module.match(regex);
-
-      if (!match) continue;
-
-      const wildcard = match.slice(1);
-
-      for (const target of this.paths[key]) {
-        let replaced = target;
-
-        wildcard.forEach(w => {
-          replaced = replaced.replace("*", w);
-        });
-
-        const abs = path.resolve(this.baseUrl, replaced);
-        const resolved = this.resolveFile(abs);
-        if (resolved) return resolved;
-      }
-    }
-
-    // node resolution (safe)
-    try {
-      const resolved = require.resolve(module, {
-        paths: [path.dirname(from)],
-      });
-
-      return this.normalize(resolved);
-    } catch {}
-
-    // fallback
-    const abs = path.resolve(this.baseUrl, module);
-    return this.resolveFile(abs);
-  }
-
-  // FILE RESOLVE
-  private resolveFile(base: string): string | null {
-    if (this.fileCache.has(base)) {
-      return this.fileCache.get(base)!;
-    }
-
-    const tryFiles = [
-      base,
-      base + ".ts",
-      base + ".tsx",
-      base + ".js",
-      base + ".jsx",
-      base + ".mjs",
-      base + ".cjs",
-      base + ".d.ts",
-      base + ".vue",
-      base + ".svelte",
-      base + ".astro",
-      path.join(base, "index.ts"),
-      path.join(base, "index.tsx"),
-      path.join(base, "index.js"),
-    ];
-
-    for (const f of tryFiles) {
-      if (fs.existsSync(f)) {
-        const normalized = this.normalize(f);
-        this.fileCache.set(base, normalized);
-        return normalized;
-      }
-    }
-
-    this.fileCache.set(base, null);
-    return null;
-  }
-
-  // UPDATE GRAPH
-  update(file: string, source: ts.SourceFile) {
-    const normalizedFile = this.normalize(file);
-
-    for (const deps of this.reverse.values()) {
-      deps.delete(normalizedFile);
-    }
-
-    this.exports.set(normalizedFile, new Set());
-
-    for (const stmt of source.statements) {
-
-      // IMPORT
-      if (ts.isImportDeclaration(stmt)) {
-        // ignore import type
-        if ((stmt.importClause as any)?.importKind === "type") continue;
-
-        const module = stmt.moduleSpecifier
-          .getText()
-          .replace(/['"]/g, "");
-
-        const resolved = this.resolveModule(module, normalizedFile);
-        if (!resolved) continue;
-
-        if (!this.reverse.has(resolved)) {
-          this.reverse.set(resolved, new Set());
-        }
-
-        this.reverse.get(resolved)!.add(normalizedFile);
-      }
-
-      // EXPORT (re-export)
-      if (ts.isExportDeclaration(stmt)) {
-        if (!stmt.moduleSpecifier) continue;
-
-        const module = stmt.moduleSpecifier
-          .getText()
-          .replace(/['"]/g, "");
-
-        const resolved = this.resolveModule(module, normalizedFile);
-        if (!resolved) continue;
-
-        this.exports.get(normalizedFile)?.add(resolved);
-
-        if (!this.reverse.has(resolved)) {
-          this.reverse.set(resolved, new Set());
-        }
-
-        this.reverse.get(resolved)!.add(normalizedFile);
-      }
-    }
-  }
-
-  // DEPENDENTS
-  getAllDependentsDeep(file: string): string[] {
-    const start = this.normalize(file);
-    const visited = new Set<string>();
-    const result = new Set<string>();
-
-    const walk = (f: string) => {
-      if (visited.has(f)) return;
-      visited.add(f);
-
-      const deps = this.reverse.get(f);
-      deps?.forEach(d => {
-        result.add(d);
-        walk(d);
-      });
-
-      const ex = this.exports.get(f);
-      ex?.forEach(e => walk(e));
-    };
-
-    walk(start);
-
-    return [...result];
-  }
-
-  // REMOVE
-  remove(file: string) {
-    const normalized = this.normalize(file);
-
-    this.reverse.delete(normalized);
-    this.exports.delete(normalized);
-    this.fileCache.delete(normalized);
-
-    for (const set of this.reverse.values()) {
-      set.delete(normalized);
-    }
-
-    for (const set of this.exports.values()) {
-      set.delete(normalized);
-    }
-  }
-}

package/src/engine/hash.ts

@@ -1,5 +0,0 @@
-import crypto from "crypto";
-
-export function hash(content: string) {
-  return crypto.createHash("md5").update(content).digest("hex");
-}