@eventra_dev/eventra-cli 0.1.30 → 0.1.32

package/dist/utils/universal.js

@@ -5,67 +5,146 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseUniversal = parseUniversal;
 const path_1 = __importDefault(require("path"));
-// Remove comments
+/* ---------------------------------- */
+/* COMMENT STRIP (SAFE)               */
+/* ---------------------------------- */
 function stripComments(input) {
     return input
         .replace(/<!--[\s\S]*?-->/g, "")
-        .replace(/\/\*[\s\S]*?\*\//g, "")
-        .replace(/\/\/.*$/gm, "");
+        .replace(/\/\*[\s\S]*?\*\//g, "");
 }
-// Basic filter
+/* ---------------------------------- */
+/* TRACK DETECTOR                     */
+/* ---------------------------------- */
 function looksLikeTracking(code) {
-    return /track/i.test(code);
+    return /\btrack\s*\(|\.track\s*\(/.test(code);
 }
-// HTML inline handlers (onclick="")
+/* ---------------------------------- */
+/* SAFE {} PARSER (JSX / TEMPLATES)   */
+/* ---------------------------------- */
+function extractBracedExpressions(input) {
+    const result = [];
+    let depth = 0;
+    let start = -1;
+    let inString = null;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        // handle strings
+        if (inString) {
+            if (char === inString && input[i - 1] !== "\\") {
+                inString = null;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            inString = char;
+            continue;
+        }
+        if (char === "{") {
+            if (depth === 0)
+                start = i + 1;
+            depth++;
+        }
+        else if (char === "}") {
+            depth--;
+            if (depth === 0 && start !== -1) {
+                const expr = input.slice(start, i);
+                if (looksLikeTracking(expr)) {
+                    result.push(expr);
+                }
+                start = -1;
+            }
+        }
+    }
+    return result;
+}
+/* ---------------------------------- */
+/* HTML HANDLERS                      */
+/* ---------------------------------- */
 function extractHTMLHandlers(input) {
     const result = [];
-    const matches = input.matchAll(/\bon\w+\s*=\s*["']([^"']+)["']/g);
-    for (const m of matches) {
+    const regex = /\bon\w+\s*=\s*["']([^"']+)["']/g;
+    for (const m of input.matchAll(regex)) {
         if (looksLikeTracking(m[1])) {
             result.push(m[1]);
         }
     }
     return result;
 }
-// Vue handlers (@click / v-on)
+/* ---------------------------------- */
+/* VUE HANDLERS                       */
+/* ---------------------------------- */
 function extractVueHandlers(input) {
     const result = [];
-    const matches = input.matchAll(/(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g);
-    for (const m of matches) {
+    const regex = /(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g;
+    for (const m of input.matchAll(regex)) {
         if (looksLikeTracking(m[1])) {
             result.push(m[1]);
         }
     }
     return result;
 }
-// Svelte handlers (on:click)
+/* ---------------------------------- */
+/* SVELTE HANDLERS                    */
+/* ---------------------------------- */
 function extractSvelteHandlers(input) {
     const result = [];
-    const matches = input.matchAll(/\bon:[\w]+\s*=\s*{([^}]+)}/g);
-    for (const m of matches) {
-        if (looksLikeTracking(m[1])) {
-            result.push(m[1]);
-        }
+    const regex = /\bon:[\w]+\s*=\s*{([\s\S]*?)}/g;
+    for (const m of input.matchAll(regex)) {
+        const expr = m[1];
+        const nested = extractBracedExpressions(`{${expr}}`);
+        result.push(...nested);
     }
     return result;
 }
-// JSX / template { ... }
-function extractJSExpressions(input) {
-    const result = [];
-    const matches = input.matchAll(/\{([^}]+)\}/g);
-    for (const m of matches) {
-        if (looksLikeTracking(m[1])) {
-            result.push(m[1]);
+/* ---------------------------------- */
+/* SCRIPT EXTRACTION                  */
+/* ---------------------------------- */
+function extractScripts(input, file) {
+    const scripts = [];
+    const deps = [];
+    // <script src="">
+    const srcRegex = /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/gi;
+    for (const m of input.matchAll(srcRegex)) {
+        const src = m[1];
+        const resolved = src.startsWith("/")
+            ? path_1.default.resolve(process.cwd(), "." + src)
+            : path_1.default.resolve(path_1.default.dirname(file), src);
+        deps.push(resolved);
+    }
+    // inline <script>
+    const scriptRegex = /<script\b[^>]*>([\s\S]*?)<\/script>/gi;
+    for (const m of input.matchAll(scriptRegex)) {
+        if (m[1]?.trim()) {
+            scripts.push(m[1]);
         }
     }
-    return result;
+    const noScripts = input.replace(scriptRegex, "");
+    return { scripts, deps, noScripts };
+}
+/* ---------------------------------- */
+/* STATIC IMPORTS                     */
+/* ---------------------------------- */
+function extractStaticImports(input, file) {
+    const deps = [];
+    const regex = /import\s+(?:.+?\s+from\s+)?["'](.+?)["']/g;
+    for (const m of input.matchAll(regex)) {
+        const mod = m[1];
+        if (!mod.startsWith(".") && !mod.startsWith("/"))
+            continue;
+        const resolved = path_1.default.resolve(path_1.default.dirname(file), mod);
+        deps.push(resolved);
+    }
+    return deps;
 }
-// dynamic import()
+/* ---------------------------------- */
+/* DYNAMIC IMPORTS                    */
+/* ---------------------------------- */
 function extractDynamicImports(input, file) {
     const deps = [];
     const calls = [];
-    const matches = input.matchAll(/import\(\s*["'](.+?)["']\s*\)/g);
-    for (const m of matches) {
+    const regex = /import\(\s*["'](.+?)["']\s*\)/g;
+    for (const m of input.matchAll(regex)) {
         const mod = m[1];
         const resolved = mod.startsWith("/")
             ? path_1.default.resolve(process.cwd(), "." + mod)
@@ -77,41 +156,30 @@ function extractDynamicImports(input, file) {
     }
     return { deps, calls };
 }
-// UNIVERSAL PARSER
+/* ---------------------------------- */
+/* MAIN                               */
+/* ---------------------------------- */
 function parseUniversal(content, file) {
     const parts = [];
     const deps = [];
     const clean = stripComments(content);
-    // ASTRO FRONTMATTER
-    const fm = clean.match(/^---([\s\S]*?)---/);
+    /* ---------- ASTRO FRONTMATTER ---------- */
+    const fm = clean.match(/^\s*---([\s\S]*?)---/);
     if (fm?.[1]) {
         parts.push(fm[1]);
     }
-    // <script src="">
-    const scriptSrc = clean.matchAll(/<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g);
-    for (const s of scriptSrc) {
-        const src = s[1];
-        const resolved = src.startsWith("/")
-            ? path_1.default.resolve(process.cwd(), "." + src)
-            : path_1.default.resolve(path_1.default.dirname(file), src);
-        deps.push(resolved);
-    }
-    // INLINE <script>
-    const scripts = clean.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script>/g);
-    for (const m of scripts) {
-        if (m[2].trim()) {
-            parts.push(m[2]);
-        }
-    }
-    // TEMPLATE PART
-    const noScripts = clean.replace(/<script[\s\S]*?<\/script>/g, "");
-    // handlers
+    /* ---------- SCRIPTS ---------- */
+    const { scripts, deps: scriptDeps, noScripts } = extractScripts(clean, file);
+    parts.push(...scripts);
+    deps.push(...scriptDeps);
+    /* ---------- HANDLERS ---------- */
     parts.push(...extractHTMLHandlers(noScripts));
     parts.push(...extractVueHandlers(noScripts));
     parts.push(...extractSvelteHandlers(noScripts));
-    // JSX / Astro / Vue expressions
-    parts.push(...extractJSExpressions(clean));
-    // dynamic imports
+    /* ---------- JSX / TEMPLATE ---------- */
+    parts.push(...extractBracedExpressions(clean));
+    /* ---------- IMPORTS ---------- */
+    deps.push(...extractStaticImports(clean, file));
     const dyn = extractDynamicImports(clean, file);
     deps.push(...dyn.deps);
     parts.push(...dyn.calls);

package/package.json

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

package/src/engine/callResolver.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 
+// HELPERS
 function isFunctionLike(
   node: ts.Node
 ): node is ts.FunctionLikeDeclaration {
@@ -12,40 +13,39 @@ function isFunctionLike(
   );
 }
 
+// symbol → function
 function resolveFromSymbol(
   symbol: ts.Symbol,
   checker: ts.TypeChecker,
   visited = new Set<ts.Symbol>(),
   depth = 0
 ): ts.FunctionLikeDeclaration | null {
+  if (!symbol) return null;
   if (visited.has(symbol)) return null;
-  if (depth > 5) return null;
+  if (depth > 10) return null;
 
   visited.add(symbol);
 
-  // unwrap alias
+  // Alias unwrap (import/export)
   if (symbol.flags & ts.SymbolFlags.Alias) {
-    const aliased = checker.getAliasedSymbol(symbol);
-    return resolveFromSymbol(aliased, checker, visited, depth + 1);
-  }
-
-  // re-export support
-  if ((symbol as any).exports) {
-    for (const exp of (symbol as any).exports.values()) {
-      const resolved = resolveFromSymbol(exp, checker, visited, depth + 1);
-      if (resolved) return resolved;
-    }
+    try {
+      const aliased = checker.getAliasedSymbol(symbol);
+      return resolveFromSymbol(aliased, checker, visited, depth + 1);
+    } catch {}
   }
 
+  // Declarations
   const decls = symbol.getDeclarations() ?? [];
 
   for (const decl of decls) {
-    // direct function
+    /**
+     * direct function
+     */
     if (isFunctionLike(decl)) {
       return decl;
     }
 
-    // VARIABLE → FUNCTION
+    // VARIABLE → FUNCTION const fn = () => {}
     if (ts.isVariableDeclaration(decl) && decl.initializer) {
       if (isFunctionLike(decl.initializer)) {
         return decl.initializer;
@@ -63,7 +63,12 @@ function resolveFromSymbol(
       }
     }
 
-    // MethodSignature (interface / type)
+    // CLASS METHOD
+    if (ts.isMethodDeclaration(decl)) {
+      return decl;
+    }
+
+    // interface / type method
     if (ts.isMethodSignature(decl)) {
       const parent = decl.parent;
 
@@ -71,14 +76,10 @@ function resolveFromSymbol(
         ts.isInterfaceDeclaration(parent) ||
         ts.isTypeLiteralNode(parent)
       ) {
-        const name = decl.name.getText();
-
         const type = checker.getTypeAtLocation(parent);
         const props = type.getProperties();
 
         for (const prop of props) {
-          if (prop.name !== name) continue;
-
           const resolved = resolveFromSymbol(
             prop,
             checker,
@@ -91,10 +92,24 @@ function resolveFromSymbol(
     }
 
     // fallback recursion
-    const s = checker.getSymbolAtLocation(decl);
-    if (s && s !== symbol) {
+    const inner = checker.getSymbolAtLocation(decl);
+    if (inner && inner !== symbol) {
       const resolved = resolveFromSymbol(
-        s,
+        inner,
+        checker,
+        visited,
+        depth + 1
+      );
+      if (resolved) return resolved;
+    }
+  }
+
+  // Exports (re-export)
+  const exports = (symbol as any).exports;
+  if (exports) {
+    for (const exp of exports.values()) {
+      const resolved = resolveFromSymbol(
+        exp,
         checker,
         visited,
         depth + 1
@@ -106,17 +121,19 @@ function resolveFromSymbol(
   return null;
 }
 
+// MAIN FUNCTION
 export function resolveFunctionFromCall(
   expr: ts.Expression,
   checker: ts.TypeChecker
 ): ts.FunctionLikeDeclaration | null {
-
-  // tracker.track
+  // obj.method()
   if (ts.isPropertyAccessExpression(expr)) {
     let symbol = checker.getSymbolAtLocation(expr.name);
 
     if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
-      symbol = checker.getAliasedSymbol(symbol);
+      try {
+        symbol = checker.getAliasedSymbol(symbol);
+      } catch {}
     }
 
     if (symbol) {
@@ -125,7 +142,7 @@ export function resolveFunctionFromCall(
     }
   }
 
-  // tracker["track"]
+  // obj["method"]()
   if (ts.isElementAccessExpression(expr)) {
     const symbol = checker.getSymbolAtLocation(expr.argumentExpression);
 
@@ -135,7 +152,7 @@ export function resolveFunctionFromCall(
     }
   }
 
-  // normal call signatures
+  // Call signatures
   const type = checker.getTypeAtLocation(expr);
   const signatures = type.getCallSignatures();
 
@@ -157,7 +174,23 @@ export function resolveFunctionFromCall(
     }
   }
 
-  // fallback
+  // Identifier fallback
+  if (ts.isIdentifier(expr)) {
+    let symbol = checker.getSymbolAtLocation(expr);
+
+    if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
+      try {
+        symbol = checker.getAliasedSymbol(symbol);
+      } catch {}
+    }
+
+    if (symbol) {
+      const resolved = resolveFromSymbol(symbol, checker);
+      if (resolved) return resolved;
+    }
+  }
+
+  // LAST fallback
   const symbol = checker.getSymbolAtLocation(expr);
   if (symbol) {
     return resolveFromSymbol(symbol, checker);

package/src/engine/engine.ts

@@ -2,16 +2,16 @@ import path from "path";
 import fs from "fs";
 
 import { TSService } from "./languageService";
-import { ScanResult, scanSource } from "./scanner";
+import { scanSource } from "./scanner";
 import { DependencyGraph } from "./graph";
 import { hash } from "./hash";
-import { EventraConfig } from "../types";
+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>();
 
@@ -71,10 +71,17 @@ export class EventraEngine {
       return this.empty();
     }
 
-    // обновляем graph
+    // update graph
     this.graph.update(file, source);
 
-    const res = scanSource(source, checker, config);
+    const res = scanSource(
+      source,
+      checker,
+      config,
+      new Set(),
+      undefined,
+      this.wrapperCache
+    );
     this.fileResults.set(file, res);
 
     return res;
@@ -86,6 +93,7 @@ export class EventraEngine {
     content: string,
     config: EventraConfig
   ) {
+    this.wrapperCache.clear();
     file = this.normalize(file);
 
     const res = this.scanFile(file, content, config);
@@ -124,7 +132,14 @@ export class EventraEngine {
 
       this.graph.update(abs, source);
 
-      const r = scanSource(source, checker, config);
+      const r = scanSource(
+        source,
+        checker,
+        config,
+        new Set(),
+        undefined,
+        this.wrapperCache
+      );
       this.fileResults.set(abs, r);
     }
 
@@ -144,6 +159,7 @@ export class EventraEngine {
 
   // REMOVE FILE
   removeFile(file: string, config?: EventraConfig) {
+    this.wrapperCache.clear();
     file = this.normalize(file);
 
     const dependents = this.graph.getAllDependentsDeep(file);
@@ -191,7 +207,10 @@ export class EventraEngine {
           wrappers: [],
           functionWrappers: [],
           sync: { include: [], exclude: [] },
-        }
+        },
+        new Set(),
+        undefined,
+        this.wrapperCache
       );
 
       this.fileResults.set(abs, r);

package/src/engine/languageService.ts

@@ -7,9 +7,10 @@ export class TSService {
   private fileNames = new Set<string>();
   private service: ts.LanguageService;
 
-  private compilerOptions: ts.CompilerOptions;
-  private baseUrl: string;
-  private paths: Record<string, string[]>;
+  private readonly compilerOptions: ts.CompilerOptions;
+  private readonly baseUrl: string;
+  private readonly paths: Record<string, string[]>;
+
   private usage = new Map<string, number>();
   private tick = 0;
   private MAX_FILES = 2000;
@@ -23,6 +24,7 @@ export class TSService {
 
     let compilerOptions: ts.CompilerOptions = {
       allowJs: true,
+      allowNonTsExtensions: true,
       jsx: ts.JsxEmit.React,
       jsxImportSource: "react",
       moduleResolution: ts.ModuleResolutionKind.Node16,
@@ -60,7 +62,17 @@ export class TSService {
     this.paths = paths;
 
     const host: ts.LanguageServiceHost = {
-      getScriptFileNames: () => Array.from(this.fileNames),
+      getScriptFileNames: () => {
+        if (this.fileNames.size === 0) {
+          return ts.sys.readDirectory(
+            this.root,
+            [".ts", ".tsx", ".js", ".jsx"],
+            undefined,
+            undefined
+          );
+        }
+        return Array.from(this.fileNames);
+      },
 
       getScriptVersion: (file) => {
         file = this.normalize(file);
@@ -69,13 +81,29 @@ export class TSService {
 
       getScriptSnapshot: (file) => {
         file = this.normalize(file);
-
         const f = this.files.get(file);
         if (f) {
           this.touch(file);
           return ts.ScriptSnapshot.fromString(f.content);
         }
+        if (file.endsWith(".tsx")) {
+          const original = file.replace(/\.tsx$/, "");
+
+          if (fs.existsSync(original)) {
+            const content = fs.readFileSync(original, "utf-8");
+
+            this.files.set(file, {
+              content,
+              version: 1,
+            });
+
+            this.fileNames.add(file);
+            this.touch(file);
+            this.evictIfNeeded();
 
+            return ts.ScriptSnapshot.fromString(content);
+          }
+        }
         try {
           if (fs.existsSync(file)) {
             const content = fs.readFileSync(file, "utf-8");
@@ -93,16 +121,22 @@ export class TSService {
           }
         } catch {}
 
-        // fallback
         return ts.ScriptSnapshot.fromString("");
       },
-
       getCurrentDirectory: () => this.root,
       getCompilationSettings: () => this.compilerOptions,
       getDefaultLibFileName: (opts) =>
         ts.getDefaultLibFilePath(opts),
-      fileExists: ts.sys.fileExists,
-      readFile: ts.sys.readFile,
+      fileExists: (file) => {
+        file = this.normalize(file);
+        return this.files.has(file) || ts.sys.fileExists(file);
+      },
+
+      readFile: (file) => {
+        file = this.normalize(file);
+        return this.files.get(file)?.content ?? ts.sys.readFile(file);
+      },
+
       readDirectory: ts.sys.readDirectory,
     };
 
@@ -122,7 +156,7 @@ export class TSService {
   private evictIfNeeded() {
     if (this.fileNames.size <= this.MAX_FILES) return;
 
-    let oldestFile: string | null = null;
+    let oldest: string | null = null;
     let oldestTick = Infinity;
 
     for (const f of this.fileNames) {
@@ -130,20 +164,20 @@ export class TSService {
 
       if (t < oldestTick) {
         oldestTick = t;
-        oldestFile = f;
+        oldest = f;
       }
     }
 
-    if (oldestFile) {
-      this.files.delete(oldestFile);
-      this.fileNames.delete(oldestFile);
-      this.usage.delete(oldestFile);
+    if (oldest) {
+      this.files.delete(oldest);
+      this.fileNames.delete(oldest);
+      this.usage.delete(oldest);
     }
   }
 
   private ensureProgram() {
     try {
-      this.service.getProgram();
+      this.service.getProgram()?.getTypeChecker();
     } catch {}
   }