@eventra_dev/eventra-cli 0.1.6 → 0.1.7

package/dist/commands/check.js

@@ -25,7 +25,7 @@ async function check({ fix = false }) {
         try {
             const raw = await promises_1.default.readFile(file, "utf-8");
             const { content, virtualFile } = (0, processFile_1.processFile)(file, raw);
-            engine.scanFile(virtualFile, content);
+            engine.scanFile(virtualFile, content, config);
         }
         catch (err) {
             console.log(chalk_1.default.yellow(`Skipped: ${file}`));

package/dist/commands/sync.js

@@ -23,11 +23,19 @@ async function sync() {
         return;
     }
     const engine = new engine_1.EventraEngine(process.cwd());
+    const detectedFn = new Set();
+    const detectedCmp = new Map();
     for (const file of files) {
         try {
             const raw = await promises_1.default.readFile(file, "utf-8");
             const { content, virtualFile } = (0, processFile_1.processFile)(file, raw);
-            engine.scanFile(virtualFile, content);
+            const res = engine.scanFile(virtualFile, content, config);
+            for (const w of res.detectedFunctionWrappers) {
+                detectedFn.add(w);
+            }
+            for (const [k, v] of res.detectedComponentWrappers) {
+                detectedCmp.set(k, v);
+            }
         }
         catch (err) {
             console.log(chalk_1.default.yellow(`Skipped: ${file}`));
@@ -36,8 +44,34 @@ async function sync() {
             }
         }
     }
+    // EVENTS
     const events = engine.getAllEvents().sort();
-    config.events = events;
+    const mergedEvents = new Set(config.events ?? []);
+    events.forEach(e => mergedEvents.add(e));
+    config.events = [...mergedEvents].sort();
+    // FUNCTION WRAPPERS
+    config.functionWrappers = mergeUnique(config.functionWrappers ?? [], [...detectedFn].map(name => ({ name })), w => w.name);
+    // COMPONENT WRAPPERS
+    config.wrappers = mergeUnique(config.wrappers ?? [], [...detectedCmp.entries()].map(([name, prop]) => ({
+        name,
+        prop,
+    })), w => `${w.name}:${w.prop}`);
     await (0, config_1.saveConfig)(config);
     console.log(chalk_1.default.green(`Found ${events.length} events`));
+    if (detectedFn.size) {
+        console.log(chalk_1.default.blue("\nDetected function wrappers:"));
+        detectedFn.forEach(w => console.log(chalk_1.default.gray(`• ${w}`)));
+    }
+    if (detectedCmp.size) {
+        console.log(chalk_1.default.blue("\nDetected component wrappers:"));
+        detectedCmp.forEach((prop, name) => console.log(chalk_1.default.gray(`• ${name} (${prop})`)));
+    }
+}
+// HELPERS
+function mergeUnique(a, b, key) {
+    const map = new Map();
+    [...b, ...a].forEach(item => {
+        map.set(key(item), item);
+    });
+    return [...map.values()];
 }

package/dist/commands/watch.js

@@ -24,7 +24,7 @@ async function watch() {
         try {
             const raw = await promises_1.default.readFile(file, "utf-8");
             const { content, virtualFile } = (0, processFile_1.processFile)(file, raw);
-            engine.scanFile(virtualFile, content);
+            engine.scanFile(virtualFile, content, config);
         }
         catch {
             console.log(chalk_1.default.gray(`skip: ${file}`));
@@ -46,7 +46,7 @@ async function watch() {
             try {
                 const raw = await promises_1.default.readFile(file, "utf-8");
                 const { content, virtualFile } = (0, processFile_1.processFile)(file, raw);
-                engine.updateFile(virtualFile, content);
+                engine.updateFile(virtualFile, content, config);
             }
             catch {
                 console.log(chalk_1.default.gray(`skip: ${file}`));

package/dist/engine/callResolver.js

@@ -5,18 +5,71 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveFunctionFromCall = resolveFunctionFromCall;
 const typescript_1 = __importDefault(require("typescript"));
+function isFunctionLike(node) {
+    return (typescript_1.default.isFunctionDeclaration(node) ||
+        typescript_1.default.isMethodDeclaration(node) ||
+        typescript_1.default.isConstructorDeclaration(node) ||
+        typescript_1.default.isFunctionExpression(node) ||
+        typescript_1.default.isArrowFunction(node));
+}
+function resolveFromSymbol(symbol, checker, visited = new Set()) {
+    if (visited.has(symbol))
+        return null;
+    visited.add(symbol);
+    // alias unwrap
+    if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+        const aliased = checker.getAliasedSymbol(symbol);
+        return resolveFromSymbol(aliased, checker, visited);
+    }
+    const decls = symbol.getDeclarations() ?? [];
+    for (const decl of decls) {
+        if (isFunctionLike(decl)) {
+            return decl;
+        }
+        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);
+                    if (resolved)
+                        return resolved;
+                }
+            }
+        }
+        // fallback
+        const s = checker.getSymbolAtLocation(decl);
+        if (s) {
+            const resolved = resolveFromSymbol(s, checker, visited);
+            if (resolved)
+                return resolved;
+        }
+    }
+    return null;
+}
 function resolveFunctionFromCall(expr, checker) {
     const type = checker.getTypeAtLocation(expr);
     const signatures = type.getCallSignatures();
     for (const sig of signatures) {
         const decl = sig.getDeclaration();
-        if (decl &&
-            (typescript_1.default.isFunctionDeclaration(decl) ||
-                typescript_1.default.isMethodDeclaration(decl) ||
-                typescript_1.default.isFunctionExpression(decl) ||
-                typescript_1.default.isArrowFunction(decl))) {
+        if (!decl)
+            continue;
+        if (isFunctionLike(decl)) {
             return decl;
         }
+        // MethodSignature case
+        if (typescript_1.default.isMethodSignature(decl)) {
+            const symbol = checker.getSymbolAtLocation(decl.name);
+            if (symbol) {
+                const resolved = resolveFromSymbol(symbol, checker);
+                if (resolved)
+                    return resolved;
+            }
+        }
     }
     return null;
 }

package/dist/engine/engine.js

@@ -8,53 +8,60 @@ const hash_1 = require("./hash");
 class EventraEngine {
     ts;
     graph;
-    fileEvents = new Map();
+    fileResults = new Map();
     fileHash = new Map();
     constructor(root) {
         this.ts = new languageService_1.TSService(root);
         const { baseUrl, paths } = this.ts.getModuleResolutionConfig();
         this.graph = new graph_1.DependencyGraph(baseUrl, paths);
     }
-    scanFile(file, content) {
+    scanFile(file, content, config) {
         const h = (0, hash_1.hash)(content);
-        // cache
         if (this.fileHash.get(file) === h) {
-            return this.fileEvents.get(file) ?? new Set();
+            return (this.fileResults.get(file) ?? {
+                events: new Set(),
+                detectedFunctionWrappers: new Set(),
+                detectedComponentWrappers: new Map(),
+            });
         }
         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 new Set();
-        // обновляем graph
+        if (!source || !checker) {
+            return {
+                events: new Set(),
+                detectedFunctionWrappers: new Set(),
+                detectedComponentWrappers: new Map(),
+            };
+        }
         this.graph.update(file, source);
-        const events = (0, scanner_1.scanSource)(source, checker);
-        this.fileEvents.set(file, events);
-        return events;
+        const res = (0, scanner_1.scanSource)(source, checker, config);
+        this.fileResults.set(file, res);
+        return res;
     }
-    updateFile(file, content) {
-        const events = this.scanFile(file, content);
-        const dependents = this.graph.getDependents(file);
+    updateFile(file, content, config) {
+        const res = this.scanFile(file, content, config);
+        const dependents = this.graph.getAllDependentsDeep(file);
         for (const dep of dependents) {
             const source = this.ts.getSourceFile(dep);
             const checker = this.ts.getChecker();
             if (!source || !checker)
                 continue;
-            const ev = (0, scanner_1.scanSource)(source, checker);
-            this.fileEvents.set(dep, ev);
+            const r = (0, scanner_1.scanSource)(source, checker, config);
+            this.fileResults.set(dep, r);
         }
-        return events;
+        return res;
     }
     getAllEvents() {
         const all = new Set();
-        for (const set of this.fileEvents.values()) {
-            set.forEach(e => all.add(e));
+        for (const r of this.fileResults.values()) {
+            r.events.forEach(e => all.add(e));
         }
         return [...all];
     }
     removeFile(file) {
-        this.fileEvents.delete(file);
+        this.fileResults.delete(file);
         this.fileHash.delete(file);
         this.graph.remove(file);
     }

package/dist/engine/graph.js

@@ -12,6 +12,7 @@ class DependencyGraph {
     paths;
     reverse = new Map();
     exports = new Map();
+    fileCache = new Map();
     constructor(baseUrl, paths) {
         this.baseUrl = baseUrl;
         this.paths = paths;
@@ -19,37 +20,36 @@ class DependencyGraph {
     normalize(file) {
         return path_1.default.resolve(file);
     }
-    // TS-like resolver
     resolveModule(module, from) {
-        // relative
         if (module.startsWith(".")) {
             const abs = path_1.default.resolve(path_1.default.dirname(from), module);
             return this.resolveFile(abs);
         }
-        // paths mapping
         for (const key in this.paths) {
-            const pattern = key.replace("*", "(.*)");
+            const pattern = key.replace(/\*/g, "(.*)");
             const regex = new RegExp("^" + pattern + "$");
             const match = module.match(regex);
             if (!match)
                 continue;
-            const wildcard = match[1] || "";
+            const wildcard = match.slice(1);
             for (const target of this.paths[key]) {
-                const replaced = target.replace("*", wildcard);
+                let replaced = target;
+                wildcard.forEach(w => {
+                    replaced = replaced.replace("*", w);
+                });
                 const abs = path_1.default.resolve(this.baseUrl, replaced);
                 const resolved = this.resolveFile(abs);
                 if (resolved)
                     return resolved;
             }
         }
-        // baseUrl fallback
         const abs = path_1.default.resolve(this.baseUrl, module);
-        const resolved = this.resolveFile(abs);
-        if (resolved)
-            return resolved;
-        return null;
+        return this.resolveFile(abs);
     }
     resolveFile(base) {
+        if (this.fileCache.has(base)) {
+            return this.fileCache.get(base);
+        }
         const tryFiles = [
             base,
             base + ".ts",
@@ -62,16 +62,18 @@ class DependencyGraph {
         ];
         for (const f of tryFiles) {
             if (fs_1.default.existsSync(f)) {
-                return this.normalize(f);
+                const normalized = this.normalize(f);
+                this.fileCache.set(base, normalized);
+                return normalized;
             }
         }
+        this.fileCache.set(base, null);
         return null;
     }
     update(file, source) {
         const normalizedFile = this.normalize(file);
         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, "");
                 const resolved = this.resolveModule(module, normalizedFile);
@@ -82,16 +84,12 @@ class DependencyGraph {
                 }
                 this.reverse.get(resolved).add(normalizedFile);
             }
-            // EXPORT *
             if (typescript_1.default.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
                 const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
                 const resolved = this.resolveModule(module, normalizedFile);
                 if (!resolved)
                     continue;
-                if (!this.exports.has(normalizedFile)) {
-                    this.exports.set(normalizedFile, new Set());
-                }
-                this.exports.get(normalizedFile).add(resolved);
+                this.exports.get(normalizedFile)?.add(resolved);
                 if (!this.reverse.has(resolved)) {
                     this.reverse.set(resolved, new Set());
                 }
@@ -99,15 +97,36 @@ class DependencyGraph {
             }
         }
     }
-    getDependents(file) {
-        return [...(this.reverse.get(this.normalize(file)) ?? [])];
+    getAllDependentsDeep(file) {
+        const start = this.normalize(file);
+        const visited = new Set();
+        const result = new Set();
+        const walk = (f) => {
+            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(file) {
         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);
+        }
     }
 }
 exports.DependencyGraph = DependencyGraph;

package/dist/engine/resolver.js

@@ -37,6 +37,11 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
         let symbol = checker.getSymbolAtLocation(node);
         if (!symbol)
             return null;
+        for (const decl of symbol.getDeclarations() ?? []) {
+            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+                return resolveNodeValue(decl.initializer, checker, paramMap, seen);
+            }
+        }
         symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
         if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
             symbol = checker.getAliasedSymbol(symbol);

package/dist/engine/scanner.js

@@ -7,94 +7,195 @@ exports.scanSource = scanSource;
 const typescript_1 = __importDefault(require("typescript"));
 const resolver_1 = require("./resolver");
 const callResolver_1 = require("./callResolver");
+const exportResolver_1 = require("./exportResolver");
 const functionAnalyzer_1 = require("./functionAnalyzer");
+const TRACKING_NAMES = new Set(["track", "event", "capture", "send"]);
 function getCallName(expr) {
     if (typescript_1.default.isIdentifier(expr))
         return expr.text;
-    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+    if (typescript_1.default.isPropertyAccessExpression(expr))
         return expr.name.text;
-    }
     return "";
 }
-function pickBestArg(args, checker, paramMap) {
-    let best = null;
-    for (const arg of args) {
-        const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
-        if (!res?.values?.length)
-            continue;
-        let score = 0;
-        if (!res.dynamic)
-            score += 3;
-        if (res.values.every(v => v.length < 50))
-            score += 2;
-        if (res.values.some(v => v.includes("*")))
-            score -= 2;
-        if (!best || score > best.score) {
-            best = { score, node: arg };
+function getJsxAttrName(name) {
+    if (typescript_1.default.isIdentifier(name))
+        return name.text;
+    if (typescript_1.default.isJsxNamespacedName(name))
+        return name.name.text;
+    return null;
+}
+function isValidEvent(v) {
+    return (v &&
+        v.length > 1 &&
+        v.length < 100 &&
+        !v.includes(" ") &&
+        /^[a-zA-Z0-9._:-]+$/.test(v));
+}
+function isPropUsedInTracking(fn, prop) {
+    let found = false;
+    function visit(node) {
+        if (typescript_1.default.isCallExpression(node)) {
+            const name = getCallName(node.expression);
+            if (!TRACKING_NAMES.has(name))
+                return;
+            for (const arg of node.arguments) {
+                if ((typescript_1.default.isIdentifier(arg) && arg.text === prop) ||
+                    (typescript_1.default.isPropertyAccessExpression(arg) &&
+                        arg.name.text === prop)) {
+                    found = true;
+                }
+            }
         }
+        typescript_1.default.forEachChild(node, visit);
     }
-    return best?.node;
+    visit(fn);
+    return found;
 }
-function scanSource(source, checker, visited = new Set(), depth = 0) {
-    if (depth > 5)
-        return new Set();
+function scanSource(source, checker, config, visited = new Set(), depth = 0) {
     const events = new Set();
-    if (visited.has(source.fileName))
-        return events;
+    const detectedFunctionWrappers = new Set();
+    const detectedComponentWrappers = new Map();
+    if (depth > 5 || visited.has(source.fileName)) {
+        return { events, detectedFunctionWrappers, detectedComponentWrappers };
+    }
     visited.add(source.fileName);
     function visit(node) {
+        // CALL EXPRESSIONS
         if (typescript_1.default.isCallExpression(node)) {
             const name = getCallName(node.expression);
-            if (/(track|event|capture|send)/i.test(name)) {
-                const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-                const paramMap = new Map();
-                if (fn && typescript_1.default.isFunctionLike(fn)) {
-                    fn.parameters.forEach((param, index) => {
-                        const arg = node.arguments[index];
-                        if (!arg)
-                            return;
-                        if (typescript_1.default.isIdentifier(param.name)) {
-                            paramMap.set(param.name.text, arg);
-                        }
+            const isKnownWrapper = config.functionWrappers.some(w => w.name === name);
+            const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
+            const isAutoWrapper = fn && (0, functionAnalyzer_1.findTrackParamIndex)(fn) !== null;
+            const isTracking = isKnownWrapper ||
+                TRACKING_NAMES.has(name) ||
+                isAutoWrapper;
+            if (!isTracking)
+                return;
+            // AUTO DETECT WRAPPER
+            if (!isKnownWrapper &&
+                fn &&
+                !TRACKING_NAMES.has(name)) {
+                detectedFunctionWrappers.add(name);
+            }
+            const paramMap = new Map();
+            if (fn && typescript_1.default.isFunctionLike(fn)) {
+                fn.parameters.forEach((param, i) => {
+                    const arg = node.arguments[i];
+                    if (!arg)
+                        return;
+                    if (typescript_1.default.isIdentifier(param.name)) {
+                        paramMap.set(param.name.text, arg);
+                    }
+                });
+            }
+            let handled = false;
+            if (fn) {
+                const idx = (0, functionAnalyzer_1.findTrackParamIndex)(fn);
+                if (idx !== null && node.arguments[idx]) {
+                    const res = (0, resolver_1.resolveNodeValue)(node.arguments[idx], checker, paramMap);
+                    res?.values.forEach(v => {
+                        if (isValidEvent(v))
+                            events.add(v);
                     });
+                    handled = true;
+                }
+            }
+            // fallback
+            if (!handled) {
+                for (const arg of node.arguments) {
+                    const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
+                    res?.values.forEach(v => {
+                        if (isValidEvent(v))
+                            events.add(v);
+                    });
+                }
+            }
+            // cross-file traversal
+            if (fn) {
+                const sf = fn.getSourceFile();
+                if (!visited.has(sf.fileName)) {
+                    const res = scanSource(sf, checker, config, visited, depth + 1);
+                    res.events.forEach(e => events.add(e));
                 }
-                if (fn && typescript_1.default.isFunctionLike(fn)) {
-                    const idx = (0, functionAnalyzer_1.findTrackParamIndex)(fn);
-                    if (idx !== null) {
-                        const realArg = node.arguments[idx];
-                        if (realArg) {
-                            const res = (0, resolver_1.resolveNodeValue)(realArg, checker, paramMap);
-                            res?.values.forEach(v => {
-                                if (v &&
-                                    v.length > 1 &&
-                                    v.length < 100 &&
-                                    !v.includes(" ") &&
-                                    /^[a-zA-Z0-9._:-]+$/.test(v)) {
-                                    events.add(v);
-                                }
-                            });
-                            return;
-                        }
+            }
+        }
+        // JSX COMPONENTS
+        if (typescript_1.default.isJsxSelfClosingElement(node) ||
+            typescript_1.default.isJsxOpeningElement(node)) {
+            const tagNode = typescript_1.default.isPropertyAccessExpression(node.tagName)
+                ? node.tagName.name
+                : node.tagName;
+            let symbol = checker.getSymbolAtLocation(tagNode);
+            if (symbol) {
+                const resolved = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker);
+                if (resolved)
+                    symbol = resolved;
+            }
+            if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
+                const aliased = checker.getAliasedSymbol(symbol);
+                if (aliased)
+                    symbol = aliased;
+            }
+            if (!symbol)
+                return;
+            const tagName = typescript_1.default.isPropertyAccessExpression(node.tagName)
+                ? node.tagName.name.getText()
+                : node.tagName.getText();
+            const declarations = symbol.getDeclarations();
+            if (!declarations)
+                return;
+            for (const decl of declarations) {
+                let fn = null;
+                if (typescript_1.default.isFunctionDeclaration(decl)) {
+                    fn = decl;
+                }
+                if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+                    const init = decl.initializer;
+                    if (typescript_1.default.isArrowFunction(init) ||
+                        typescript_1.default.isFunctionExpression(init)) {
+                        fn = init;
                     }
                 }
-                // fallback (heuristic)
-                const target = pickBestArg(node.arguments, checker, paramMap);
-                if (target) {
-                    const res = (0, resolver_1.resolveNodeValue)(target, checker, paramMap);
+                if (!fn)
+                    continue;
+                const param = fn.parameters[0];
+                if (!param)
+                    continue;
+                if (!typescript_1.default.isObjectBindingPattern(param.name))
+                    continue;
+                for (const el of param.name.elements) {
+                    const prop = el.name.getText();
+                    const isEvent = isPropUsedInTracking(fn, prop) ||
+                        config.wrappers.some(w => w.name === tagName && w.prop === prop);
+                    if (!isEvent)
+                        continue;
+                    const attr = node.attributes.properties.find(p => {
+                        if (!typescript_1.default.isJsxAttribute(p))
+                            return false;
+                        return getJsxAttrName(p.name) === prop;
+                    });
+                    if (!attr || !attr.initializer)
+                        continue;
+                    const expr = typescript_1.default.isJsxExpression(attr.initializer)
+                        ? attr.initializer.expression
+                        : attr.initializer;
+                    if (!expr)
+                        continue;
+                    const res = (0, resolver_1.resolveNodeValue)(expr, checker);
                     res?.values.forEach(v => {
-                        if (v &&
-                            v.length > 1 &&
-                            v.length < 100 &&
-                            !v.includes(" ") &&
-                            /^[a-zA-Z0-9._:-]+$/.test(v)) {
+                        if (isValidEvent(v))
                             events.add(v);
-                        }
                     });
+                    detectedComponentWrappers.set(tagName, prop);
                 }
             }
         }
         typescript_1.default.forEachChild(node, visit);
     }
     visit(source);
-    return events;
+    return {
+        events,
+        detectedFunctionWrappers,
+        detectedComponentWrappers,
+    };
 }

package/package.json

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

package/src/commands/check.ts

@@ -28,7 +28,7 @@ export async function check({ fix = false }: { fix?: boolean }) {
 
       const { content, virtualFile } = processFile(file, raw);
 
-      engine.scanFile(virtualFile, content);
+      engine.scanFile(virtualFile, content, config);
 
     } catch (err) {
       console.log(chalk.yellow(`Skipped: ${file}`));