@eventra_dev/eventra-cli 0.1.31 → 0.1.33

package/dist/utils/universal.js

@@ -5,23 +5,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseUniversal = parseUniversal;
 const path_1 = __importDefault(require("path"));
-// SAFE COMMENT STRIP
+/* ---------------------------------- */
+/* COMMENT STRIP (SAFE)               */
+/* ---------------------------------- */
 function stripComments(input) {
     return input
         .replace(/<!--[\s\S]*?-->/g, "")
         .replace(/\/\*[\s\S]*?\*\//g, "");
 }
-// TRACK FILTER
+/* ---------------------------------- */
+/* TRACK DETECTOR                     */
+/* ---------------------------------- */
 function looksLikeTracking(code) {
-    return /\btrack\w*\s*\(/.test(code);
+    return /\btrack\s*\(|\.track\s*\(/.test(code);
 }
-// SAFE {} PARSER
+/* ---------------------------------- */
+/* 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;
@@ -40,7 +58,9 @@ function extractBracedExpressions(input) {
     }
     return result;
 }
-// HTML handlers
+/* ---------------------------------- */
+/* HTML HANDLERS                      */
+/* ---------------------------------- */
 function extractHTMLHandlers(input) {
     const result = [];
     const regex = /\bon\w+\s*=\s*["']([^"']+)["']/g;
@@ -51,7 +71,9 @@ function extractHTMLHandlers(input) {
     }
     return result;
 }
-// VUE handlers
+/* ---------------------------------- */
+/* VUE HANDLERS                       */
+/* ---------------------------------- */
 function extractVueHandlers(input) {
     const result = [];
     const regex = /(?:@|v-on:)[\w:-]+\s*=\s*["']([^"']+)["']/g;
@@ -62,23 +84,27 @@ function extractVueHandlers(input) {
     }
     return result;
 }
-// SVELTE handlers
+/* ---------------------------------- */
+/* SVELTE HANDLERS                    */
+/* ---------------------------------- */
 function extractSvelteHandlers(input) {
     const result = [];
-    const regex = /\bon:[\w]+\s*=\s*{([^}]+)}/g;
+    const regex = /\bon:[\w]+\s*=\s*{([\s\S]*?)}/g;
     for (const m of input.matchAll(regex)) {
-        if (looksLikeTracking(m[1])) {
-            result.push(m[1]);
-        }
+        const expr = m[1];
+        const nested = extractBracedExpressions(`{${expr}}`);
+        result.push(...nested);
     }
     return result;
 }
-// SCRIPT EXTRACTION
+/* ---------------------------------- */
+/* SCRIPT EXTRACTION                  */
+/* ---------------------------------- */
 function extractScripts(input, file) {
     const scripts = [];
     const deps = [];
-    // src scripts
-    const srcRegex = /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g;
+    // <script src="">
+    const srcRegex = /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/gi;
     for (const m of input.matchAll(srcRegex)) {
         const src = m[1];
         const resolved = src.startsWith("/")
@@ -86,8 +112,8 @@ function extractScripts(input, file) {
             : path_1.default.resolve(path_1.default.dirname(file), src);
         deps.push(resolved);
     }
-    // inline scripts
-    const scriptRegex = /<script\b[^>]*>([\s\S]*?)<\/script>/g;
+    // 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]);
@@ -96,9 +122,27 @@ function extractScripts(input, file) {
     const noScripts = input.replace(scriptRegex, "");
     return { scripts, deps, noScripts };
 }
-// DYNAMIC IMPORTS
+/* ---------------------------------- */
+/* 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 IMPORTS                    */
+/* ---------------------------------- */
 function extractDynamicImports(input, file) {
     const deps = [];
+    const calls = [];
     const regex = /import\(\s*["'](.+?)["']\s*\)/g;
     for (const m of input.matchAll(regex)) {
         const mod = m[1];
@@ -106,16 +150,21 @@ function extractDynamicImports(input, file) {
             ? path_1.default.resolve(process.cwd(), "." + mod)
             : path_1.default.resolve(path_1.default.dirname(file), mod);
         deps.push(resolved);
+        if (looksLikeTracking(mod)) {
+            calls.push(`import("${mod}")`);
+        }
     }
-    return deps;
+    return { deps, calls };
 }
-// MAIN
+/* ---------------------------------- */
+/* MAIN                               */
+/* ---------------------------------- */
 function parseUniversal(content, file) {
     const parts = [];
     const deps = [];
     const clean = stripComments(content);
     /* ---------- ASTRO FRONTMATTER ---------- */
-    const fm = clean.match(/^---([\s\S]*?)---/);
+    const fm = clean.match(/^\s*---([\s\S]*?)---/);
     if (fm?.[1]) {
         parts.push(fm[1]);
     }
@@ -130,7 +179,10 @@ function parseUniversal(content, file) {
     /* ---------- JSX / TEMPLATE ---------- */
     parts.push(...extractBracedExpressions(clean));
     /* ---------- IMPORTS ---------- */
-    deps.push(...extractDynamicImports(clean, file));
+    deps.push(...extractStaticImports(clean, file));
+    const dyn = extractDynamicImports(clean, file);
+    deps.push(...dyn.deps);
+    parts.push(...dyn.calls);
     return {
         code: [...new Set(parts)].join("\n"),
         deps: [...new Set(deps.filter(Boolean))],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "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/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 {}
   }