@eventra_dev/eventra-cli 0.1.30 → 0.1.32

package/README.md

@@ -170,7 +170,6 @@ eventra send
   "events": [],
   "wrappers": [],
   "functionWrappers": [],
-  "aliases": {},
   "sync": {
     "include": ["**/*.{ts,tsx,js,jsx,vue,svelte,astro}"],
     "exclude": ["node_modules", "dist", ".next", ".git"]

package/dist/engine/callResolver.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveFunctionFromCall = resolveFunctionFromCall;
 const typescript_1 = __importDefault(require("typescript"));
+// HELPERS
 function isFunctionLike(node) {
     return (typescript_1.default.isFunctionDeclaration(node) ||
         typescript_1.default.isMethodDeclaration(node) ||
@@ -12,32 +13,33 @@ function isFunctionLike(node) {
         typescript_1.default.isFunctionExpression(node) ||
         typescript_1.default.isArrowFunction(node));
 }
+// symbol → function
 function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
+    if (!symbol)
+        return null;
     if (visited.has(symbol))
         return null;
-    if (depth > 5)
+    if (depth > 10)
         return null;
     visited.add(symbol);
-    // unwrap alias
+    // Alias unwrap (import/export)
     if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
-        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;
+        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 (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
             if (isFunctionLike(decl.initializer)) {
                 return decl.initializer;
@@ -49,17 +51,18 @@ function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
                     return resolved;
             }
         }
-        // MethodSignature (interface / type)
+        // CLASS METHOD
+        if (typescript_1.default.isMethodDeclaration(decl)) {
+            return decl;
+        }
+        // interface / type method
         if (typescript_1.default.isMethodSignature(decl)) {
             const parent = decl.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();
                 for (const prop of props) {
-                    if (prop.name !== name)
-                        continue;
                     const resolved = resolveFromSymbol(prop, checker, visited, depth + 1);
                     if (resolved)
                         return resolved;
@@ -67,21 +70,34 @@ function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
             }
         }
         // fallback recursion
-        const s = checker.getSymbolAtLocation(decl);
-        if (s && s !== symbol) {
-            const resolved = resolveFromSymbol(s, checker, visited, depth + 1);
+        const inner = checker.getSymbolAtLocation(decl);
+        if (inner && inner !== symbol) {
+            const resolved = resolveFromSymbol(inner, checker, visited, depth + 1);
+            if (resolved)
+                return resolved;
+        }
+    }
+    // Exports (re-export)
+    const exports = symbol.exports;
+    if (exports) {
+        for (const exp of exports.values()) {
+            const resolved = resolveFromSymbol(exp, checker, visited, depth + 1);
             if (resolved)
                 return resolved;
         }
     }
     return null;
 }
+// MAIN FUNCTION
 function resolveFunctionFromCall(expr, checker) {
-    // tracker.track
+    // obj.method()
     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);
+            try {
+                symbol = checker.getAliasedSymbol(symbol);
+            }
+            catch { }
         }
         if (symbol) {
             const resolved = resolveFromSymbol(symbol, checker);
@@ -89,7 +105,7 @@ function resolveFunctionFromCall(expr, checker) {
                 return resolved;
         }
     }
-    // tracker["track"]
+    // obj["method"]()
     if (typescript_1.default.isElementAccessExpression(expr)) {
         const symbol = checker.getSymbolAtLocation(expr.argumentExpression);
         if (symbol) {
@@ -98,7 +114,7 @@ function resolveFunctionFromCall(expr, checker) {
                 return resolved;
         }
     }
-    // normal call signatures
+    // Call signatures
     const type = checker.getTypeAtLocation(expr);
     const signatures = type.getCallSignatures();
     for (const sig of signatures) {
@@ -117,7 +133,22 @@ function resolveFunctionFromCall(expr, checker) {
             }
         }
     }
-    // fallback
+    // Identifier fallback
+    if (typescript_1.default.isIdentifier(expr)) {
+        let symbol = checker.getSymbolAtLocation(expr);
+        if (symbol && (symbol.flags & typescript_1.default.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/dist/engine/engine.js

@@ -14,6 +14,7 @@ const boundary_1 = require("./boundary");
 class EventraEngine {
     ts;
     graph;
+    wrapperCache = new Map();
     fileResults = new Map();
     fileHash = new Map();
     constructor(root) {
@@ -54,14 +55,15 @@ class EventraEngine {
         if (!source || !checker) {
             return this.empty();
         }
-        // обновляем graph
+        // update graph
         this.graph.update(file, source);
-        const res = (0, scanner_1.scanSource)(source, checker, config);
+        const res = (0, scanner_1.scanSource)(source, checker, config, new Set(), undefined, this.wrapperCache);
         this.fileResults.set(file, res);
         return res;
     }
     // UPDATE FILE (incremental)
     updateFile(file, content, config) {
+        this.wrapperCache.clear();
         file = this.normalize(file);
         const res = this.scanFile(file, content, config);
         const dependents = this.graph.getAllDependentsDeep(file);
@@ -89,7 +91,7 @@ class EventraEngine {
             if (!source || !checker)
                 continue;
             this.graph.update(abs, source);
-            const r = (0, scanner_1.scanSource)(source, checker, config);
+            const r = (0, scanner_1.scanSource)(source, checker, config, new Set(), undefined, this.wrapperCache);
             this.fileResults.set(abs, r);
         }
         return res;
@@ -104,6 +106,7 @@ class EventraEngine {
     }
     // REMOVE FILE
     removeFile(file, config) {
+        this.wrapperCache.clear();
         file = this.normalize(file);
         const dependents = this.graph.getAllDependentsDeep(file);
         this.ts.removeFile(file);
@@ -138,7 +141,7 @@ class EventraEngine {
                 wrappers: [],
                 functionWrappers: [],
                 sync: { include: [], exclude: [] },
-            });
+            }, new Set(), undefined, this.wrapperCache);
             this.fileResults.set(abs, r);
         }
     }

package/dist/engine/languageService.js

@@ -23,6 +23,7 @@ class TSService {
         const configPath = typescript_1.default.findConfigFile(root, typescript_1.default.sys.fileExists, "tsconfig.json");
         let compilerOptions = {
             allowJs: true,
+            allowNonTsExtensions: true,
             jsx: typescript_1.default.JsxEmit.React,
             jsxImportSource: "react",
             moduleResolution: typescript_1.default.ModuleResolutionKind.Node16,
@@ -49,7 +50,12 @@ class TSService {
         this.baseUrl = baseUrl;
         this.paths = paths;
         const host = {
-            getScriptFileNames: () => Array.from(this.fileNames),
+            getScriptFileNames: () => {
+                if (this.fileNames.size === 0) {
+                    return typescript_1.default.sys.readDirectory(this.root, [".ts", ".tsx", ".js", ".jsx"], undefined, undefined);
+                }
+                return Array.from(this.fileNames);
+            },
             getScriptVersion: (file) => {
                 file = this.normalize(file);
                 return this.files.get(file)?.version.toString() ?? "0";
@@ -61,6 +67,20 @@ class TSService {
                     this.touch(file);
                     return typescript_1.default.ScriptSnapshot.fromString(f.content);
                 }
+                if (file.endsWith(".tsx")) {
+                    const original = file.replace(/\.tsx$/, "");
+                    if (fs_1.default.existsSync(original)) {
+                        const content = fs_1.default.readFileSync(original, "utf-8");
+                        this.files.set(file, {
+                            content,
+                            version: 1,
+                        });
+                        this.fileNames.add(file);
+                        this.touch(file);
+                        this.evictIfNeeded();
+                        return typescript_1.default.ScriptSnapshot.fromString(content);
+                    }
+                }
                 try {
                     if (fs_1.default.existsSync(file)) {
                         const content = fs_1.default.readFileSync(file, "utf-8");
@@ -75,14 +95,19 @@ class TSService {
                     }
                 }
                 catch { }
-                // fallback
                 return typescript_1.default.ScriptSnapshot.fromString("");
             },
             getCurrentDirectory: () => this.root,
             getCompilationSettings: () => this.compilerOptions,
             getDefaultLibFileName: (opts) => typescript_1.default.getDefaultLibFilePath(opts),
-            fileExists: typescript_1.default.sys.fileExists,
-            readFile: typescript_1.default.sys.readFile,
+            fileExists: (file) => {
+                file = this.normalize(file);
+                return this.files.has(file) || typescript_1.default.sys.fileExists(file);
+            },
+            readFile: (file) => {
+                file = this.normalize(file);
+                return this.files.get(file)?.content ?? typescript_1.default.sys.readFile(file);
+            },
             readDirectory: typescript_1.default.sys.readDirectory,
         };
         this.service = typescript_1.default.createLanguageService(host);
@@ -98,24 +123,24 @@ class TSService {
     evictIfNeeded() {
         if (this.fileNames.size <= this.MAX_FILES)
             return;
-        let oldestFile = null;
+        let oldest = null;
         let oldestTick = Infinity;
         for (const f of this.fileNames) {
             const t = this.usage.get(f) ?? 0;
             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);
         }
     }
     ensureProgram() {
         try {
-            this.service.getProgram();
+            this.service.getProgram()?.getTypeChecker();
         }
         catch { }
     }

package/dist/engine/scanner.js

@@ -8,7 +8,23 @@ const typescript_1 = __importDefault(require("typescript"));
 const resolver_1 = require("./resolver");
 const callResolver_1 = require("./callResolver");
 const functionAnalyzer_1 = require("./functionAnalyzer");
-const boundary_1 = require("./boundary");
+const exportResolver_1 = require("./exportResolver");
+// UTILS
+function getJsxAttrName(name) {
+    if (typescript_1.default.isIdentifier(name))
+        return name.text;
+    if (typescript_1.default.isJsxNamespacedName(name))
+        return name.name.text;
+    return "";
+}
+function getJsxTagName(tag) {
+    if (typescript_1.default.isIdentifier(tag))
+        return tag.text;
+    if (typescript_1.default.isPropertyAccessExpression(tag)) {
+        return tag.name.text;
+    }
+    return "";
+}
 function getCallName(expr) {
     if (typescript_1.default.isIdentifier(expr))
         return expr.text;
@@ -23,33 +39,219 @@ function isValidEvent(v) {
         !v.includes(" ") &&
         /^[a-zA-Z0-9._:-]+$/.test(v));
 }
-function scanSource(source, checker, config, visited = new Set(), inheritedParamMap) {
+// COMPONENT ANALYSIS
+function getComponentPropsMap(fn) {
+    const map = new Map();
+    const firstParam = fn.parameters[0];
+    if (!firstParam)
+        return map;
+    // ({ event }) => ...
+    if (typescript_1.default.isObjectBindingPattern(firstParam.name)) {
+        for (const el of firstParam.name.elements) {
+            if (!typescript_1.default.isBindingElement(el))
+                continue;
+            const propName = el.propertyName?.getText() || el.name.getText();
+            map.set(el.name.getText(), propName);
+        }
+    }
+    // (props) => props.event
+    if (typescript_1.default.isIdentifier(firstParam.name)) {
+        map.set(firstParam.name.text, "*");
+    }
+    return map;
+}
+function findTrackedPropName(fn, checker) {
+    const propMap = getComponentPropsMap(fn);
+    let result = null;
+    function resolveIdentifierToProp(node) {
+        const mapped = propMap.get(node.text);
+        if (mapped && mapped !== "*")
+            return mapped;
+        const symbol = checker.getSymbolAtLocation(node);
+        if (!symbol)
+            return null;
+        for (const decl of symbol.getDeclarations() ?? []) {
+            // const e = props.event
+            if (typescript_1.default.isVariableDeclaration(decl) &&
+                decl.initializer &&
+                typescript_1.default.isPropertyAccessExpression(decl.initializer)) {
+                return decl.initializer.name.text;
+            }
+            // const e = event
+            if (typescript_1.default.isVariableDeclaration(decl) &&
+                decl.initializer &&
+                typescript_1.default.isIdentifier(decl.initializer)) {
+                const inner = propMap.get(decl.initializer.text);
+                if (inner)
+                    return inner;
+            }
+        }
+        return null;
+    }
+    function visit(node) {
+        if (result)
+            return;
+        if (typescript_1.default.isCallExpression(node)) {
+            const expr = node.expression;
+            const isTrack = (typescript_1.default.isIdentifier(expr) && expr.text === "track") ||
+                (typescript_1.default.isPropertyAccessExpression(expr) &&
+                    expr.name.text === "track");
+            if (!isTrack) {
+                typescript_1.default.forEachChild(node, visit);
+                return;
+            }
+            for (const arg of node.arguments) {
+                // track(event)
+                if (typescript_1.default.isIdentifier(arg)) {
+                    const prop = resolveIdentifierToProp(arg);
+                    if (prop) {
+                        result = prop;
+                        return;
+                    }
+                }
+                // track(props.a.b.event)
+                if (typescript_1.default.isPropertyAccessExpression(arg)) {
+                    let current = arg;
+                    while (typescript_1.default.isPropertyAccessExpression(current)) {
+                        result = current.name.text;
+                        return;
+                    }
+                }
+                // track(fn())
+                if (typescript_1.default.isCallExpression(arg)) {
+                    const inner = (0, callResolver_1.resolveFunctionFromCall)(arg.expression, checker);
+                    if (inner?.body) {
+                        visit(inner.body);
+                        if (result)
+                            return;
+                    }
+                }
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    if (fn.body)
+        visit(fn.body);
+    return result;
+}
+// MAIN SCANNER
+function scanSource(source, checker, config, visited = new Set(), inheritedParamMap, wrapperCache = new Map()) {
     const events = new Set();
     const detectedFunctionWrappers = new Set();
     const detectedComponentWrappers = new Map();
-    if (visited.size > 200 || visited.has(source.fileName)) {
+    if (visited.has(source.fileName) || visited.size > 200) {
         return { events, detectedFunctionWrappers, detectedComponentWrappers };
     }
     visited.add(source.fileName);
     function visit(node) {
+        // JSX WRAPPERS
+        if (typescript_1.default.isJsxSelfClosingElement(node) || typescript_1.default.isJsxOpeningElement(node)) {
+            const tagName = getJsxTagName(node.tagName);
+            // skip html
+            if (tagName[0] === tagName[0].toLowerCase()) {
+                typescript_1.default.forEachChild(node, visit);
+                return;
+            }
+            let wrapper = config.wrappers.find(w => w.name === tagName);
+            // AUTO DETECT
+            if (!wrapper) {
+                if (wrapperCache.has(tagName)) {
+                    const cached = wrapperCache.get(tagName);
+                    if (cached)
+                        wrapper = { name: tagName, prop: cached };
+                }
+                else {
+                    let symbol = checker.getSymbolAtLocation(node.tagName);
+                    if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
+                        symbol = checker.getAliasedSymbol(symbol);
+                    }
+                    if (symbol) {
+                        symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
+                        for (const decl of symbol.getDeclarations() ?? []) {
+                            let fn = null;
+                            if (typescript_1.default.isFunctionDeclaration(decl))
+                                fn = decl;
+                            if (typescript_1.default.isVariableDeclaration(decl) &&
+                                decl.initializer &&
+                                (typescript_1.default.isArrowFunction(decl.initializer) ||
+                                    typescript_1.default.isFunctionExpression(decl.initializer))) {
+                                fn = decl.initializer;
+                            }
+                            if (!fn)
+                                continue;
+                            const prop = findTrackedPropName(fn, checker);
+                            wrapperCache.set(tagName, prop ?? null);
+                            if (prop) {
+                                wrapper = { name: tagName, prop };
+                                detectedComponentWrappers.set(tagName, prop);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            if (wrapper) {
+                for (const attr of node.attributes.properties) {
+                    if (!typescript_1.default.isJsxAttribute(attr))
+                        continue;
+                    const name = getJsxAttrName(attr.name);
+                    if (name !== wrapper.prop)
+                        continue;
+                    if (!attr.initializer)
+                        continue;
+                    if (typescript_1.default.isStringLiteral(attr.initializer)) {
+                        const v = attr.initializer.text;
+                        if (isValidEvent(v))
+                            events.add(v);
+                    }
+                    if (typescript_1.default.isJsxExpression(attr.initializer)) {
+                        const expr = attr.initializer.expression;
+                        if (!expr)
+                            continue;
+                        const res = (0, resolver_1.resolveNodeValue)(expr, checker, inheritedParamMap);
+                        res.values.forEach(v => {
+                            if (isValidEvent(v))
+                                events.add(v);
+                        });
+                    }
+                }
+            }
+            typescript_1.default.forEachChild(node, visit);
+            return;
+        }
+        // FUNCTION CALLS
         if (typescript_1.default.isCallExpression(node)) {
-            const name = getCallName(node.expression);
-            const isKnownWrapper = config.functionWrappers.some(w => w.name === name);
+            let trackParamIndex = null;
+            let isTracking = false;
+            const callName = getCallName(node.expression);
+            // direct .track()
+            if (typescript_1.default.isPropertyAccessExpression(node.expression) &&
+                node.expression.name.text === "track") {
+                isTracking = true;
+                trackParamIndex = 0;
+            }
+            // config wrapper
+            const manualWrapper = config.functionWrappers.find(w => w.name === callName);
+            if (manualWrapper) {
+                isTracking = true;
+                trackParamIndex = 0;
+            }
+            // resolve function → check body
             const resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-            const isAutoWrapper = !!resolvedFn && (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn) !== null;
-            const isTracking = name === "track" ||
-                isKnownWrapper ||
-                (isAutoWrapper &&
-                    resolvedFn &&
-                    !(0, boundary_1.isExternalFile)(resolvedFn.getSourceFile().fileName));
+            if (resolvedFn) {
+                const idx = (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn);
+                if (idx !== null) {
+                    isTracking = true;
+                    trackParamIndex = idx;
+                    if (!manualWrapper && callName !== "track") {
+                        detectedFunctionWrappers.add(callName);
+                    }
+                }
+            }
             if (!isTracking) {
                 typescript_1.default.forEachChild(node, visit);
                 return;
             }
-            // авто-детект wrapper
-            if (!isKnownWrapper && isAutoWrapper && name !== "track") {
-                detectedFunctionWrappers.add(name);
-            }
             const paramMap = new Map(inheritedParamMap ?? []);
             if (resolvedFn && typescript_1.default.isFunctionLike(resolvedFn)) {
                 resolvedFn.parameters.forEach((param, i) => {
@@ -61,23 +263,18 @@ function scanSource(source, checker, config, visited = new Set(), inheritedParam
                     }
                 });
             }
-            // ✅ ТОЛЬКО правильный аргумент
-            if (resolvedFn) {
-                const idx = (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn);
-                if (idx !== null && node.arguments[idx]) {
-                    const res = (0, resolver_1.resolveNodeValue)(node.arguments[idx], checker, paramMap);
-                    for (const v of res.values) {
-                        if (isValidEvent(v)) {
-                            events.add(v);
-                        }
-                    }
-                }
+            if (trackParamIndex !== null && node.arguments[trackParamIndex]) {
+                const res = (0, resolver_1.resolveNodeValue)(node.arguments[trackParamIndex], checker, paramMap);
+                res.values.forEach(v => {
+                    if (isValidEvent(v))
+                        events.add(v);
+                });
             }
             // CROSS FILE
             if (resolvedFn) {
                 const sf = resolvedFn.getSourceFile();
                 if (!visited.has(sf.fileName)) {
-                    const res = scanSource(sf, checker, config, visited, paramMap);
+                    const res = scanSource(sf, checker, config, visited, paramMap, wrapperCache);
                     res.events.forEach(e => events.add(e));
                 }
             }

package/dist/utils/config.js

@@ -17,7 +17,6 @@ function normalizeConfig(config) {
         endpoint: config.endpoint ?? "",
         wrappers: config.wrappers ?? [],
         functionWrappers: config.functionWrappers ?? [],
-        aliases: config.aliases ?? {},
         sync: config.sync ?? {
             include: [
                 "**/*.{ts,tsx,js,jsx,vue,svelte,astro}"

package/dist/utils/processFile.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processFile = processFile;
 const universal_1 = require("./universal");
 function processFile(file, content) {
-    const { code, deps } = (0, universal_1.parseUniversal)(content, file);
+    const parsed = (0, universal_1.parseUniversal)(content, file);
     return {
-        content: code || "",
-        deps: [...new Set(deps.filter(Boolean))],
+        content: parsed.code || "",
+        deps: [...new Set(parsed.deps.filter(Boolean))],
     };
 }