@eventra_dev/eventra-cli 0.1.5 → 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/exportResolver.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExportedSymbol = resolveExportedSymbol;
+const typescript_1 = __importDefault(require("typescript"));
+function resolveExportedSymbol(symbol, checker, visited = new Set()) {
+    if (visited.has(symbol))
+        return null;
+    visited.add(symbol);
+    if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+        const aliased = checker.getAliasedSymbol(symbol);
+        return resolveExportedSymbol(aliased, checker, visited);
+    }
+    if (symbol.getDeclarations()?.length) {
+        return symbol;
+    }
+    const declarations = symbol.getDeclarations() ?? [];
+    for (const decl of declarations) {
+        const source = decl.getSourceFile();
+        const moduleSymbol = checker.getSymbolAtLocation(source);
+        if (!moduleSymbol)
+            continue;
+        const exports = checker.getExportsOfModule(moduleSymbol);
+        for (const exp of exports) {
+            const resolved = resolveExportedSymbol(exp, checker, visited);
+            if (resolved?.getDeclarations()?.length) {
+                return resolved;
+            }
+        }
+    }
+    return symbol;
+}

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/languageService.js

@@ -43,7 +43,9 @@ class TSService {
         }
         this.compilerOptions = compilerOptions;
         const host = {
-            getScriptFileNames: () => [...this.fileNames],
+            getScriptFileNames: () => {
+                return [...new Set(this.fileNames)].sort((a, b) => a.localeCompare(b));
+            },
             getScriptVersion: (file) => this.files.get(file)?.version.toString() ?? "0",
             getScriptSnapshot: (file) => {
                 const f = this.files.get(file);

package/dist/engine/resolver.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveNodeValue = resolveNodeValue;
 const typescript_1 = __importDefault(require("typescript"));
+const exportResolver_1 = require("./exportResolver");
 function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
     if (seen.has(node))
         return null;
@@ -36,6 +37,12 @@ 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);
         }