@eventra_dev/eventra-cli 0.1.25 → 0.1.26

package/dist/commands/watch.js

@@ -13,6 +13,9 @@ const config_1 = require("../utils/config");
 const engine_1 = require("../engine/engine");
 const processFile_1 = require("../utils/processFile");
 const getVirtualFile_1 = require("../utils/getVirtualFile");
+function normalize(file) {
+    return path_1.default.resolve(file).replace(/\\/g, "/");
+}
 async function watch() {
     const config = await (0, config_1.loadConfig)();
     if (!config)
@@ -29,28 +32,29 @@ async function watch() {
     // COLLECT + CACHE
     for (const file of files) {
         try {
-            const raw = await promises_1.default.readFile(file, "utf-8");
+            const abs = normalize(file);
+            const raw = await promises_1.default.readFile(abs, "utf-8");
             if (raw.length > 2_000_000)
-                continue; // safeguard
-            const parsed = (0, processFile_1.processFile)(file, raw);
-            cache.set(file, parsed);
-            toScan.add(file);
+                continue;
+            const parsed = (0, processFile_1.processFile)(abs, raw);
+            cache.set(abs, parsed);
+            toScan.add(abs);
             for (const dep of parsed.deps) {
-                const absDep = path_1.default.resolve(dep);
-                toScan.add(absDep);
+                toScan.add(normalize(dep));
             }
         }
         catch {
             console.log(chalk_1.default.gray(`skip: ${file}`));
         }
     }
-    // PRELOAD (TS PROGRAM)
+    // PRELOAD
     for (const file of toScan) {
         try {
             let parsed = cache.get(file);
             if (!parsed) {
                 const raw = await promises_1.default.readFile(file, "utf-8");
                 parsed = (0, processFile_1.processFile)(file, raw);
+                cache.set(file, parsed);
             }
             const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
             engine.preloadFile?.(virtual, parsed.content);
@@ -68,7 +72,7 @@ async function watch() {
             const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
             engine.scanFile(virtual, parsed.content, config);
             for (const dep of parsed.deps) {
-                watchedDeps.add(path_1.default.resolve(dep));
+                watchedDeps.add(normalize(dep));
             }
         }
         catch { }
@@ -94,19 +98,33 @@ async function watch() {
                 const parsed = (0, processFile_1.processFile)(item.real, raw);
                 cache.set(item.real, parsed);
                 engine.updateFile(item.virtual, parsed.content, config);
-                // DEPS
+                // DEPENDENCY DIFF
+                const nextDeps = new Set();
                 for (const dep of parsed.deps) {
-                    const absDep = path_1.default.resolve(dep);
-                    if (!watchedDeps.has(absDep)) {
-                        watcher.add(absDep);
-                        watchedDeps.add(absDep);
+                    nextDeps.add(normalize(dep));
+                }
+                // add new deps
+                for (const dep of nextDeps) {
+                    if (!watchedDeps.has(dep)) {
+                        watcher.add(dep);
+                        watchedDeps.add(dep);
                     }
+                }
+                // remove old deps
+                for (const dep of [...watchedDeps]) {
+                    if (!nextDeps.has(dep)) {
+                        watcher.unwatch(dep);
+                        watchedDeps.delete(dep);
+                    }
+                }
+                // preload deps
+                for (const dep of nextDeps) {
                     try {
-                        const depRaw = await promises_1.default.readFile(absDep, "utf-8");
-                        const depParsed = (0, processFile_1.processFile)(absDep, depRaw);
-                        cache.set(absDep, depParsed);
-                        const depVirtual = (0, getVirtualFile_1.getVirtualFile)(absDep);
-                        engine.updateFile(depVirtual, depParsed.content, config);
+                        const raw = await promises_1.default.readFile(dep, "utf-8");
+                        const parsedDep = (0, processFile_1.processFile)(dep, raw);
+                        cache.set(dep, parsedDep);
+                        const virtual = (0, getVirtualFile_1.getVirtualFile)(dep);
+                        engine.updateFile(virtual, parsedDep.content, config);
                     }
                     catch { }
                 }
@@ -130,13 +148,13 @@ async function watch() {
     };
     // SCHEDULER
     const schedule = (file) => {
-        const abs = path_1.default.resolve(file);
+        const abs = normalize(file);
         const virtual = (0, getVirtualFile_1.getVirtualFile)(abs);
         console.log(chalk_1.default.gray(`change: ${file}`));
         queued.set(abs, { real: abs, virtual });
         if (timer)
             clearTimeout(timer);
-        timer = setTimeout(run, 250);
+        timer = setTimeout(run, 200);
     };
     // WATCHER
     const watcher = chokidar_1.default.watch(config.sync.include, {
@@ -148,7 +166,7 @@ async function watch() {
         .on("add", schedule)
         .on("change", schedule)
         .on("unlink", async (file) => {
-        const abs = path_1.default.resolve(file);
+        const abs = normalize(file);
         console.log(chalk_1.default.gray(`remove: ${file}`));
         const virtual = (0, getVirtualFile_1.getVirtualFile)(abs);
         engine.removeFile(virtual, config);
@@ -162,7 +180,7 @@ async function watch() {
         .on("error", (err) => {
         console.error(chalk_1.default.red("Watcher error:"), err);
     });
-    // WATCH DEPS
+    // WATCH DEPS INIT
     for (const dep of watchedDeps) {
         watcher.add(dep);
     }

package/dist/engine/callResolver.js

@@ -23,15 +23,37 @@ function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
         const aliased = checker.getAliasedSymbol(symbol);
         return resolveFromSymbol(aliased, checker, visited, depth + 1);
     }
+    // re-export support
+    if (symbol.exports) {
+        for (const exp of symbol.exports.values()) {
+            const resolved = resolveFromSymbol(exp, checker, visited, depth + 1);
+            if (resolved)
+                return resolved;
+        }
+    }
     const decls = symbol.getDeclarations() ?? [];
     for (const decl of decls) {
+        // direct function
         if (isFunctionLike(decl)) {
             return decl;
         }
-        // MethodSignature
+        // VARIABLE → FUNCTION
+        if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+            if (isFunctionLike(decl.initializer)) {
+                return decl.initializer;
+            }
+            const innerSymbol = checker.getSymbolAtLocation(decl.initializer);
+            if (innerSymbol && innerSymbol !== symbol) {
+                const resolved = resolveFromSymbol(innerSymbol, checker, visited, depth + 1);
+                if (resolved)
+                    return resolved;
+            }
+        }
+        // MethodSignature (interface / type)
         if (typescript_1.default.isMethodSignature(decl)) {
             const parent = decl.parent;
-            if (typescript_1.default.isInterfaceDeclaration(parent) || typescript_1.default.isTypeLiteralNode(parent)) {
+            if (typescript_1.default.isInterfaceDeclaration(parent) ||
+                typescript_1.default.isTypeLiteralNode(parent)) {
                 const name = decl.name.getText();
                 const type = checker.getTypeAtLocation(parent);
                 const props = type.getProperties();
@@ -44,7 +66,7 @@ function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
                 }
             }
         }
-        // SAFE fallback
+        // fallback recursion
         const s = checker.getSymbolAtLocation(decl);
         if (s && s !== symbol) {
             const resolved = resolveFromSymbol(s, checker, visited, depth + 1);
@@ -55,6 +77,28 @@ function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
     return null;
 }
 function resolveFunctionFromCall(expr, checker) {
+    // tracker.track
+    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+        let symbol = checker.getSymbolAtLocation(expr.name);
+        if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
+            symbol = checker.getAliasedSymbol(symbol);
+        }
+        if (symbol) {
+            const resolved = resolveFromSymbol(symbol, checker);
+            if (resolved)
+                return resolved;
+        }
+    }
+    // tracker["track"]
+    if (typescript_1.default.isElementAccessExpression(expr)) {
+        const symbol = checker.getSymbolAtLocation(expr.argumentExpression);
+        if (symbol) {
+            const resolved = resolveFromSymbol(symbol, checker);
+            if (resolved)
+                return resolved;
+        }
+    }
+    // normal call signatures
     const type = checker.getTypeAtLocation(expr);
     const signatures = type.getCallSignatures();
     for (const sig of signatures) {
@@ -64,7 +108,6 @@ function resolveFunctionFromCall(expr, checker) {
         if (isFunctionLike(decl)) {
             return decl;
         }
-        // interface method
         if (typescript_1.default.isMethodSignature(decl)) {
             const symbol = checker.getSymbolAtLocation(decl.name);
             if (symbol) {
@@ -74,5 +117,10 @@ function resolveFunctionFromCall(expr, checker) {
             }
         }
     }
+    // fallback
+    const symbol = checker.getSymbolAtLocation(expr);
+    if (symbol) {
+        return resolveFromSymbol(symbol, checker);
+    }
     return null;
 }

package/dist/engine/engine.js

@@ -1,6 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventraEngine = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 const languageService_1 = require("./languageService");
 const scanner_1 = require("./scanner");
 const graph_1 = require("./graph");
@@ -16,31 +21,40 @@ class EventraEngine {
         const { baseUrl, paths } = this.ts.getModuleResolutionConfig();
         this.graph = new graph_1.DependencyGraph(baseUrl, paths);
     }
+    normalize(file) {
+        return path_1.default.resolve(file).replace(/\\/g, "/");
+    }
+    empty() {
+        return {
+            events: new Set(),
+            detectedFunctionWrappers: new Set(),
+            detectedComponentWrappers: new Map(),
+        };
+    }
+    // PRELOAD
     preloadFile(file, content) {
+        file = this.normalize(file);
         this.ts.updateFile(file, content);
+        const source = this.ts.getSourceFile(file);
+        if (source) {
+            this.graph.update(file, source);
+        }
     }
     // SCAN FILE
     scanFile(file, content, config) {
+        file = this.normalize(file);
         const h = (0, hash_1.hash)(content);
-        // skip unchanged
         if (this.fileHash.get(file) === h) {
-            return (this.fileResults.get(file) ?? {
-                events: new Set(),
-                detectedFunctionWrappers: new Set(),
-                detectedComponentWrappers: new Map(),
-            });
+            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 {
-                events: new Set(),
-                detectedFunctionWrappers: new Set(),
-                detectedComponentWrappers: new Map(),
-            };
+            return this.empty();
         }
+        // обновляем graph
         this.graph.update(file, source);
         const res = (0, scanner_1.scanSource)(source, checker, config);
         this.fileResults.set(file, res);
@@ -48,26 +62,35 @@ class EventraEngine {
     }
     // UPDATE FILE (incremental)
     updateFile(file, content, config) {
+        file = this.normalize(file);
         const res = this.scanFile(file, content, config);
         const dependents = this.graph.getAllDependentsDeep(file);
         for (const dep of dependents) {
-            if ((0, boundary_1.isExternalFile)(dep))
-                continue;
-            const depContent = this.ts.getFileContent(dep);
-            if (!depContent)
+            const abs = this.normalize(dep);
+            if ((0, boundary_1.isExternalFile)(abs))
                 continue;
+            let depContent = this.ts.getFileContent(abs);
+            if (!depContent) {
+                try {
+                    depContent = fs_1.default.readFileSync(abs, "utf-8");
+                }
+                catch {
+                    continue;
+                }
+            }
             const h = (0, hash_1.hash)(depContent);
-            if (this.fileHash.get(dep) === h)
+            if (this.fileHash.get(abs) === h) {
                 continue;
-            this.fileHash.set(dep, h);
-            this.ts.updateFile(dep, depContent);
-            const source = this.ts.getSourceFile(dep);
+            }
+            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(dep, source);
+            this.graph.update(abs, source);
             const r = (0, scanner_1.scanSource)(source, checker, config);
-            this.fileResults.set(dep, r);
+            this.fileResults.set(abs, r);
         }
         return res;
     }
@@ -81,33 +104,42 @@ class EventraEngine {
     }
     // REMOVE FILE
     removeFile(file, config) {
+        file = this.normalize(file);
+        const dependents = this.graph.getAllDependentsDeep(file);
         this.ts.removeFile(file);
         this.fileResults.delete(file);
         this.fileHash.delete(file);
         this.graph.remove(file);
-        const dependents = this.graph.getAllDependentsDeep(file);
         for (const dep of dependents) {
-            if ((0, boundary_1.isExternalFile)(dep))
-                continue;
-            const content = this.ts.getFileContent(dep);
-            if (!content)
+            const abs = this.normalize(dep);
+            if ((0, boundary_1.isExternalFile)(abs))
                 continue;
+            let content = this.ts.getFileContent(abs);
+            if (!content) {
+                try {
+                    content = fs_1.default.readFileSync(abs, "utf-8");
+                }
+                catch {
+                    continue;
+                }
+            }
             const h = (0, hash_1.hash)(content);
-            if (this.fileHash.get(dep) === h)
+            if (this.fileHash.get(abs) === h)
                 continue;
-            this.fileHash.set(dep, h);
-            this.ts.updateFile(dep, content);
-            const source = this.ts.getSourceFile(dep);
+            this.fileHash.set(abs, h);
+            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 = (0, scanner_1.scanSource)(source, checker, config ?? {
                 events: [],
                 wrappers: [],
                 functionWrappers: [],
                 sync: { include: [], exclude: [] },
             });
-            this.fileResults.set(dep, r);
+            this.fileResults.set(abs, r);
         }
     }
 }

package/dist/engine/exportResolver.js

@@ -5,21 +5,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveExportedSymbol = resolveExportedSymbol;
 const typescript_1 = __importDefault(require("typescript"));
+function isRealDeclaration(node) {
+    return (typescript_1.default.isFunctionDeclaration(node) ||
+        typescript_1.default.isVariableDeclaration(node) ||
+        typescript_1.default.isClassDeclaration(node));
+}
 function resolveExportedSymbol(symbol, checker, visited = new Set()) {
     if (visited.has(symbol))
         return null;
     visited.add(symbol);
+    // unwrap alias
     if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
         const aliased = checker.getAliasedSymbol(symbol);
         return resolveExportedSymbol(aliased, checker, visited);
     }
-    if (symbol.getDeclarations()?.length) {
+    // 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;
     }
-    const declarations = symbol.getDeclarations() ?? [];
-    for (const decl of declarations) {
+    // exports (re-export)
+    for (const decl of decls) {
         const source = decl.getSourceFile();
-        const moduleSymbol = checker.getSymbolAtLocation(source);
+        const moduleSymbol = source.symbol;
         if (!moduleSymbol)
             continue;
         const exports = checker.getExportsOfModule(moduleSymbol);

package/dist/engine/functionAnalyzer.js

@@ -10,19 +10,81 @@ function findTrackParamIndex(fn) {
     fn.parameters.forEach((p, i) => {
         if (typescript_1.default.isIdentifier(p.name)) {
             paramIndex.set(p.name.text, i);
+            // default param: (name = "x")
+            if (p.initializer && typescript_1.default.isStringLiteral(p.initializer)) {
+                if (i === 0)
+                    return 0;
+            }
         }
     });
     let result = null;
+    function unwrap(node) {
+        // as / parentheses
+        while (typescript_1.default.isAsExpression(node) ||
+            typescript_1.default.isParenthesizedExpression(node)) {
+            node = node.expression;
+        }
+        return node;
+    }
+    function checkArg(arg) {
+        arg = unwrap(arg);
+        // identifier → param
+        if (typescript_1.default.isIdentifier(arg)) {
+            const idx = paramIndex.get(arg.text);
+            if (idx !== undefined) {
+                result = idx;
+                return true;
+            }
+        }
+        // string literal
+        if (typescript_1.default.isStringLiteral(arg)) {
+            result = 0;
+            return true;
+        }
+        // template `${name}`
+        if (typescript_1.default.isTemplateExpression(arg)) {
+            for (const span of arg.templateSpans) {
+                if (typescript_1.default.isIdentifier(span.expression)) {
+                    const idx = paramIndex.get(span.expression.text);
+                    if (idx !== undefined) {
+                        result = idx;
+                        return true;
+                    }
+                }
+            }
+            result = 0;
+            return true;
+        }
+        // object { event: name }
+        if (typescript_1.default.isObjectLiteralExpression(arg)) {
+            for (const prop of arg.properties) {
+                if (!typescript_1.default.isPropertyAssignment(prop))
+                    continue;
+                const name = prop.name.getText();
+                if (["event", "name", "type"].includes(name)) {
+                    return checkArg(prop.initializer);
+                }
+            }
+        }
+        // call: String(name)
+        if (typescript_1.default.isCallExpression(arg)) {
+            for (const inner of arg.arguments) {
+                if (checkArg(inner))
+                    return true;
+            }
+        }
+        return false;
+    }
     function visit(node) {
+        if (result !== null)
+            return;
         if (typescript_1.default.isCallExpression(node)) {
             let isTrackCall = false;
             if (typescript_1.default.isPropertyAccessExpression(node.expression)) {
-                const method = node.expression.name.text;
-                if (method === "track") {
+                if (node.expression.name.text === "track") {
                     isTrackCall = true;
                 }
             }
-            // fallback
             if (typescript_1.default.isIdentifier(node.expression)) {
                 if (node.expression.text === "track") {
                     isTrackCall = true;
@@ -30,17 +92,8 @@ function findTrackParamIndex(fn) {
             }
             if (isTrackCall) {
                 for (const arg of node.arguments) {
-                    if (typescript_1.default.isIdentifier(arg)) {
-                        const idx = paramIndex.get(arg.text);
-                        if (idx !== undefined) {
-                            result = idx;
-                            return;
-                        }
-                    }
-                    if (typescript_1.default.isStringLiteral(arg)) {
-                        result = 0;
+                    if (checkArg(arg))
                         return;
-                    }
                 }
             }
         }

package/dist/engine/graph.js

@@ -18,13 +18,16 @@ class DependencyGraph {
         this.paths = paths;
     }
     normalize(file) {
-        return path_1.default.resolve(file);
+        return path_1.default.resolve(file).replace(/\\/g, "/");
     }
+    // MODULE RESOLVE
     resolveModule(module, from) {
+        // relative import
         if (module.startsWith(".")) {
             const abs = path_1.default.resolve(path_1.default.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 + "$");
@@ -43,9 +46,19 @@ class DependencyGraph {
                     return resolved;
             }
         }
+        // node resolution (safe)
+        try {
+            const resolved = require.resolve(module, {
+                paths: [path_1.default.dirname(from)],
+            });
+            return this.normalize(resolved);
+        }
+        catch { }
+        // fallback
         const abs = path_1.default.resolve(this.baseUrl, module);
         return this.resolveFile(abs);
     }
+    // FILE RESOLVE
     resolveFile(base) {
         if (this.fileCache.has(base)) {
             return this.fileCache.get(base);
@@ -56,6 +69,12 @@ class DependencyGraph {
             base + ".tsx",
             base + ".js",
             base + ".jsx",
+            base + ".mjs",
+            base + ".cjs",
+            base + ".d.ts",
+            base + ".vue",
+            base + ".svelte",
+            base + ".astro",
             path_1.default.join(base, "index.ts"),
             path_1.default.join(base, "index.tsx"),
             path_1.default.join(base, "index.js"),
@@ -70,12 +89,22 @@ class DependencyGraph {
         this.fileCache.set(base, null);
         return null;
     }
+    // UPDATE GRAPH
     update(file, source) {
         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 (typescript_1.default.isImportDeclaration(stmt)) {
-                const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+                // ignore import type
+                if (stmt.importClause?.importKind === "type")
+                    continue;
+                const module = stmt.moduleSpecifier
+                    .getText()
+                    .replace(/['"]/g, "");
                 const resolved = this.resolveModule(module, normalizedFile);
                 if (!resolved)
                     continue;
@@ -84,8 +113,13 @@ class DependencyGraph {
                 }
                 this.reverse.get(resolved).add(normalizedFile);
             }
-            if (typescript_1.default.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
-                const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+            // EXPORT (re-export)
+            if (typescript_1.default.isExportDeclaration(stmt)) {
+                if (!stmt.moduleSpecifier)
+                    continue;
+                const module = stmt.moduleSpecifier
+                    .getText()
+                    .replace(/['"]/g, "");
                 const resolved = this.resolveModule(module, normalizedFile);
                 if (!resolved)
                     continue;
@@ -97,6 +131,7 @@ class DependencyGraph {
             }
         }
     }
+    // DEPENDENTS
     getAllDependentsDeep(file) {
         const start = this.normalize(file);
         const visited = new Set();
@@ -116,6 +151,7 @@ class DependencyGraph {
         walk(start);
         return [...result];
     }
+    // REMOVE
     remove(file) {
         const normalized = this.normalize(file);
         this.reverse.delete(normalized);