@eventra_dev/eventra-cli 0.1.6 → 0.1.8

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

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExternalFile = isExternalFile;
+const path_1 = __importDefault(require("path"));
+function isExternalFile(file) {
+    const normalized = path_1.default.resolve(file);
+    return (normalized.includes(`${path_1.default.sep}node_modules${path_1.default.sep}`) ||
+        normalized.includes(`${path_1.default.sep}dist${path_1.default.sep}`) ||
+        normalized.includes(`${path_1.default.sep}build${path_1.default.sep}`) ||
+        normalized.endsWith(".d.ts"));
+}

package/dist/engine/callResolver.js

@@ -5,18 +5,74 @@ 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(), depth = 0) {
+    if (visited.has(symbol))
+        return null;
+    if (depth > 5)
+        return null;
+    visited.add(symbol);
+    // unwrap alias
+    if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+        const aliased = checker.getAliasedSymbol(symbol);
+        return resolveFromSymbol(aliased, checker, visited, depth + 1);
+    }
+    const decls = symbol.getDeclarations() ?? [];
+    for (const decl of decls) {
+        if (isFunctionLike(decl)) {
+            return decl;
+        }
+        // MethodSignature
+        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;
+                }
+            }
+        }
+        // SAFE fallback
+        const s = checker.getSymbolAtLocation(decl);
+        if (s && s !== symbol) {
+            const resolved = resolveFromSymbol(s, checker, visited, depth + 1);
+            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;
         }
+        // interface method
+        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

@@ -5,58 +5,109 @@ const languageService_1 = require("./languageService");
 const scanner_1 = require("./scanner");
 const graph_1 = require("./graph");
 const hash_1 = require("./hash");
+const boundary_1 = require("./boundary");
 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) {
+    // SCAN FILE
+    scanFile(file, content, config) {
         const h = (0, hash_1.hash)(content);
-        // cache
+        // skip unchanged
         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(),
+            };
+        }
+        // update dependency graph
         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);
+    // UPDATE FILE (incremental)
+    updateFile(file, content, config) {
+        const res = this.scanFile(file, content, config);
+        const dependents = this.graph.getAllDependentsDeep(file);
         for (const dep of dependents) {
+            // skip external files
+            if ((0, boundary_1.isExternalFile)(dep))
+                continue;
             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 depContent = this.ts.getFileContent(dep);
+            if (!depContent)
+                continue;
+            const h = (0, hash_1.hash)(depContent);
+            // skip unchanged dependents
+            if (this.fileHash.get(dep) === h)
+                continue;
+            this.fileHash.set(dep, h);
+            this.graph.update(dep, source);
+            const r = (0, scanner_1.scanSource)(source, checker, config);
+            this.fileResults.set(dep, r);
         }
-        return events;
+        return res;
     }
+    // GET ALL EVENTS
     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);
+    // REMOVE FILE
+    removeFile(file, config) {
+        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 source = this.ts.getSourceFile(dep);
+            const checker = this.ts.getChecker();
+            if (!source || !checker)
+                continue;
+            const content = this.ts.getFileContent(dep);
+            if (!content)
+                continue;
+            const h = (0, hash_1.hash)(content);
+            // skip unchanged
+            if (this.fileHash.get(dep) === h)
+                continue;
+            this.fileHash.set(dep, h);
+            const r = (0, scanner_1.scanSource)(source, checker, config ?? {
+                events: [],
+                wrappers: [],
+                functionWrappers: [],
+                sync: { include: [], exclude: [] },
+            });
+            this.fileResults.set(dep, r);
+        }
     }
 }
 exports.EventraEngine = EventraEngine;

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

@@ -48,6 +48,9 @@ class TSService {
             },
             getScriptVersion: (file) => this.files.get(file)?.version.toString() ?? "0",
             getScriptSnapshot: (file) => {
+                if (!this.fileNames.has(file)) {
+                    return undefined;
+                }
                 const f = this.files.get(file);
                 if (f) {
                     return typescript_1.default.ScriptSnapshot.fromString(f.content);
@@ -83,6 +86,13 @@ class TSService {
     getSourceFile(file) {
         return this.getProgram()?.getSourceFile(file);
     }
+    getFileContent(file) {
+        return this.files.get(file)?.content;
+    }
+    removeFile(file) {
+        this.files.delete(file);
+        this.fileNames.delete(file);
+    }
     getModuleResolutionConfig() {
         return {
             baseUrl: this.baseUrl,

package/dist/engine/resolver.js

@@ -12,7 +12,7 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
     seen.add(node);
     // param mapping
     if (typescript_1.default.isIdentifier(node) && paramMap?.has(node.text)) {
-        return resolveNodeValue(paramMap.get(node.text), checker, paramMap);
+        return resolveNodeValue(paramMap.get(node.text), checker, paramMap, seen);
     }
     if (typescript_1.default.isStringLiteral(node)) {
         return { values: [node.text], dynamic: false };
@@ -37,8 +37,16 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
         let symbol = checker.getSymbolAtLocation(node);
         if (!symbol)
             return null;
+        // variable inline resolve FIRST
+        for (const decl of symbol.getDeclarations() ?? []) {
+            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+                return resolveNodeValue(decl.initializer, checker, paramMap, seen);
+            }
+        }
+        const original = symbol;
         symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
-        if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+        // avoid alias loop
+        if (symbol !== original && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
             symbol = checker.getAliasedSymbol(symbol);
         }
         for (const decl of symbol.getDeclarations() ?? []) {