@eventra_dev/eventra-cli 0.1.33 → 0.2.1

package/dist/commands/check.js

@@ -24,9 +24,9 @@ async function check({ fix = false }) {
         absolute: true,
     });
     const engine = new engine_1.EventraEngine(process.cwd());
-    const toScan = new Set();
     const cache = new Map();
-    // COLLECT + CACHE
+    const toScan = new Set();
+    // COLLECT
     for (const file of files) {
         try {
             const raw = await promises_1.default.readFile(file, "utf-8");
@@ -35,23 +35,17 @@ async function check({ fix = false }) {
             const parsed = (0, processFile_1.processFile)(file, raw);
             cache.set(file, parsed);
             toScan.add(file);
-            for (const dep of parsed.deps) {
-                toScan.add(path_1.default.resolve(dep));
-            }
+            parsed.deps.forEach(dep => toScan.add(path_1.default.resolve(dep)));
         }
         catch { }
     }
     // PRELOAD
     for (const file of toScan) {
         try {
-            let parsed = cache.get(file);
-            if (!parsed) {
-                const raw = await promises_1.default.readFile(file, "utf-8");
-                parsed = (0, processFile_1.processFile)(file, raw);
-                cache.set(file, parsed);
-            }
-            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
-            engine.preloadFile(virtual, parsed.content);
+            const parsed = cache.get(file);
+            if (!parsed)
+                continue;
+            engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content);
         }
         catch { }
     }
@@ -61,34 +55,24 @@ async function check({ fix = false }) {
             const parsed = cache.get(file);
             if (!parsed)
                 continue;
-            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
-            engine.scanFile(virtual, parsed.content, config);
+            engine.scanFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content, config);
         }
         catch { }
     }
-    // DIFF
     const found = new Set(engine.getAllEvents());
     const known = new Set(config.events ?? []);
-    const newEvents = [...found].filter(e => !known.has(e));
+    const added = [...found].filter(e => !known.has(e));
     const removed = [...known].filter(e => !found.has(e));
-    // FIX MODE
     if (fix) {
         config.events = [...found].sort();
         await (0, config_1.saveConfig)(config);
-        console.log(chalk_1.default.green(`\nSynced (${config.events.length} events)`));
+        console.log(chalk_1.default.green("Synced"));
         return;
     }
-    // CHECK MODE
-    if (newEvents.length || removed.length) {
-        if (newEvents.length) {
-            console.log(chalk_1.default.red("\nNew events:"));
-            newEvents.forEach(e => console.log(chalk_1.default.red(`+ ${e}`)));
-        }
-        if (removed.length) {
-            console.log(chalk_1.default.yellow("\nRemoved events:"));
-            removed.forEach(e => console.log(chalk_1.default.yellow(`- ${e}`)));
-        }
+    if (added.length || removed.length) {
+        added.forEach(e => console.log(chalk_1.default.red(`+ ${e}`)));
+        removed.forEach(e => console.log(chalk_1.default.yellow(`- ${e}`)));
         process.exit(1);
     }
-    console.log(chalk_1.default.green("\nAll good"));
+    console.log(chalk_1.default.green("All good"));
 }

package/dist/commands/sync.js

@@ -21,14 +21,10 @@ async function sync() {
         ignore: config.sync.exclude,
         absolute: true,
     });
-    if (!files.length) {
-        console.log(chalk_1.default.yellow("No files found"));
-        return;
-    }
     const engine = new engine_1.EventraEngine(process.cwd());
-    const toScan = new Set();
     const cache = new Map();
-    // COLLECT + CACHE
+    const toScan = new Set();
+    // COLLECT
     for (const file of files) {
         try {
             const raw = await promises_1.default.readFile(file, "utf-8");
@@ -37,9 +33,7 @@ async function sync() {
             const parsed = (0, processFile_1.processFile)(file, raw);
             cache.set(file, parsed);
             toScan.add(file);
-            for (const dep of parsed.deps) {
-                toScan.add(path_1.default.resolve(dep));
-            }
+            parsed.deps.forEach(dep => toScan.add(path_1.default.resolve(dep)));
         }
         catch { }
     }
@@ -52,8 +46,7 @@ async function sync() {
                 parsed = (0, processFile_1.processFile)(file, raw);
                 cache.set(file, parsed);
             }
-            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
-            engine.preloadFile(virtual, parsed.content);
+            engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content);
         }
         catch { }
     }
@@ -65,33 +58,22 @@ async function sync() {
             const parsed = cache.get(file);
             if (!parsed)
                 continue;
-            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
-            const res = engine.scanFile(virtual, parsed.content, config);
+            const res = engine.updateFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content, config);
             res.detectedFunctionWrappers.forEach(w => detectedFn.add(w));
-            for (const [k, v] of res.detectedComponentWrappers) {
-                detectedCmp.set(k, v);
-            }
-        }
-        catch {
-            console.log(chalk_1.default.gray(`skip: ${file}`));
+            res.detectedComponentWrappers.forEach((v, k) => detectedCmp.set(k, v));
         }
+        catch { }
     }
     // RESULT
     const events = engine.getAllEvents().sort();
     config.events = events;
     config.functionWrappers = mergeUnique(config.functionWrappers ?? [], [...detectedFn].map(name => ({ name })), w => w.name);
-    config.wrappers = mergeUnique(config.wrappers ?? [], [...detectedCmp.entries()].map(([name, prop]) => ({
-        name,
-        prop,
-    })), w => `${w.name}:${w.prop}`);
+    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`));
 }
-// HELPERS
 function mergeUnique(a, b, key) {
     const map = new Map();
-    [...b, ...a].forEach(item => {
-        map.set(key(item), item);
-    });
+    [...b, ...a].forEach(item => map.set(key(item), item));
     return [...map.values()];
 }

package/dist/commands/watch.js

@@ -13,180 +13,97 @@ const config_1 = require("../utils/config");
 const engine_1 = require("../engine/engine");
 const processFile_1 = require("../utils/processFile");
 const getVirtualFile_1 = require("../utils/getVirtualFile");
-function normalize(file) {
-    return path_1.default.resolve(file).replace(/\\/g, "/");
-}
 async function watch() {
     const config = await (0, config_1.loadConfig)();
     if (!config)
         return;
     console.log(chalk_1.default.blue("Watching...\n"));
+    const engine = new engine_1.EventraEngine(process.cwd());
+    const fileDeps = new Map();
+    const cache = new Map();
+    const watchedDeps = new Set();
+    const normalize = (f) => path_1.default.resolve(f).replace(/\\/g, "/");
+    // INITIAL LOAD
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude,
         absolute: true,
     });
-    const engine = new engine_1.EventraEngine(process.cwd());
-    const watchedDeps = new Set();
-    const cache = new Map();
-    const toScan = new Set();
-    // COLLECT + CACHE
     for (const file of files) {
         try {
             const abs = normalize(file);
             const raw = await promises_1.default.readFile(abs, "utf-8");
-            if (raw.length > 2_000_000)
-                continue;
             const parsed = (0, processFile_1.processFile)(abs, raw);
             cache.set(abs, parsed);
-            toScan.add(abs);
-            for (const dep of parsed.deps) {
-                toScan.add(normalize(dep));
-            }
-        }
-        catch {
-            console.log(chalk_1.default.gray(`skip: ${file}`));
-        }
-    }
-    // PRELOAD
-    for (const file of toScan) {
-        try {
-            let parsed = cache.get(file);
-            if (!parsed) {
-                const raw = await promises_1.default.readFile(file, "utf-8");
-                parsed = (0, processFile_1.processFile)(file, raw);
-                cache.set(file, parsed);
-            }
-            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
-            engine.preloadFile?.(virtual, parsed.content);
-        }
-        catch { }
-    }
-    // INITIAL SCAN
-    for (const file of toScan) {
-        try {
-            let parsed = cache.get(file);
-            if (!parsed) {
-                const raw = await promises_1.default.readFile(file, "utf-8");
-                parsed = (0, processFile_1.processFile)(file, raw);
-            }
-            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
-            engine.scanFile(virtual, parsed.content, config);
-            for (const dep of parsed.deps) {
-                watchedDeps.add(normalize(dep));
-            }
+            engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(abs), parsed.content);
+            engine.updateFile((0, getVirtualFile_1.getVirtualFile)(abs), parsed.content, config);
+            fileDeps.set(abs, new Set(parsed.deps.map(d => normalize(d))));
         }
         catch { }
     }
     config.events = engine.getAllEvents().sort();
     await (0, config_1.saveConfig)(config);
-    console.log(chalk_1.default.gray(`Initial: ${config.events.length} events\n`));
-    // QUEUE
-    let locked = false;
-    const queued = new Map();
+    console.log(chalk_1.default.gray(`Initial: ${config.events.length}\n`));
+    // WATCHER
+    const watcher = chokidar_1.default.watch([...files.map(normalize), ...watchedDeps], { ignoreInitial: true });
+    const queue = new Map();
     let timer = null;
     const run = async () => {
-        if (locked)
-            return;
-        locked = true;
-        const batch = [...queued.values()];
-        queued.clear();
-        for (const item of batch) {
+        const batch = [...queue.keys()];
+        queue.clear();
+        for (const file of batch) {
             try {
-                const raw = await promises_1.default.readFile(item.real, "utf-8");
-                if (raw.length > 2_000_000)
-                    continue;
-                const parsed = (0, processFile_1.processFile)(item.real, raw);
-                cache.set(item.real, parsed);
-                engine.updateFile(item.virtual, parsed.content, config);
-                // DEPENDENCY DIFF
-                const nextDeps = new Set();
-                for (const dep of parsed.deps) {
-                    nextDeps.add(normalize(dep));
-                }
+                const raw = await promises_1.default.readFile(file, "utf-8");
+                const parsed = (0, processFile_1.processFile)(file, raw);
+                cache.set(file, parsed);
+                engine.updateFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content, config);
+                //dependency diff
+                const abs = normalize(file);
+                const prevDeps = fileDeps.get(abs) ?? new Set();
+                const nextDeps = new Set(parsed.deps.map(d => normalize(d)));
                 // add new deps
                 for (const dep of nextDeps) {
-                    if (!watchedDeps.has(dep)) {
+                    if (!prevDeps.has(dep)) {
                         watcher.add(dep);
                         watchedDeps.add(dep);
                     }
                 }
                 // remove old deps
-                for (const dep of [...watchedDeps]) {
+                for (const dep of prevDeps) {
                     if (!nextDeps.has(dep)) {
                         watcher.unwatch(dep);
                         watchedDeps.delete(dep);
                     }
                 }
-                // preload deps
-                for (const dep of nextDeps) {
-                    try {
-                        const raw = await promises_1.default.readFile(dep, "utf-8");
-                        const parsedDep = (0, processFile_1.processFile)(dep, raw);
-                        cache.set(dep, parsedDep);
-                        const virtual = (0, getVirtualFile_1.getVirtualFile)(dep);
-                        engine.updateFile(virtual, parsedDep.content, config);
-                    }
-                    catch { }
-                }
+                fileDeps.set(abs, nextDeps);
             }
             catch {
-                console.log(chalk_1.default.gray(`skip: ${item.real}`));
+                console.log(chalk_1.default.gray(`skip: ${file}`));
             }
         }
-        // DIFF EVENTS
-        const next = engine.getAllEvents();
-        const added = next.filter(e => !config.events.includes(e));
-        const removed = config.events.filter(e => !next.includes(e));
-        if (added.length || removed.length) {
-            added.forEach(e => console.log(chalk_1.default.green(`+ ${e}`)));
-            removed.forEach(e => console.log(chalk_1.default.red(`- ${e}`)));
-            config.events = next.sort();
-            await (0, config_1.saveConfig)(config);
-            console.log(chalk_1.default.gray(`Total: ${config.events.length} events\n`));
-        }
-        locked = false;
+        const next = engine.getAllEvents().sort();
+        config.events = next;
+        await (0, config_1.saveConfig)(config);
+        console.log(chalk_1.default.green(`Updated: ${next.length}`));
     };
-    // SCHEDULER
     const schedule = (file) => {
         const abs = normalize(file);
-        const virtual = (0, getVirtualFile_1.getVirtualFile)(abs);
-        console.log(chalk_1.default.gray(`change: ${file}`));
-        queued.set(abs, { real: abs, virtual });
+        queue.set(abs, true);
         if (timer)
             clearTimeout(timer);
         timer = setTimeout(run, 200);
     };
-    // WATCHER
-    const watcher = chokidar_1.default.watch(config.sync.include, {
-        ignored: config.sync.exclude,
-        ignoreInitial: true,
-        persistent: true,
-    });
     watcher
-        .on("add", schedule)
         .on("change", schedule)
+        .on("add", schedule)
         .on("unlink", async (file) => {
         const abs = normalize(file);
-        console.log(chalk_1.default.gray(`remove: ${file}`));
-        const virtual = (0, getVirtualFile_1.getVirtualFile)(abs);
-        engine.removeFile(virtual, config);
-        watcher.unwatch(abs);
-        watchedDeps.delete(abs);
-        const next = engine.getAllEvents();
-        config.events = next.sort();
+        engine.removeFile((0, getVirtualFile_1.getVirtualFile)(abs), config);
+        const next = engine.getAllEvents().sort();
+        config.events = next;
         await (0, config_1.saveConfig)(config);
-        console.log(chalk_1.default.gray(`Total: ${config.events.length} events\n`));
-    })
-        .on("error", (err) => {
-        console.error(chalk_1.default.red("Watcher error:"), err);
+        console.log(chalk_1.default.red(`Removed → ${next.length}`));
     });
-    // WATCH DEPS INIT
-    for (const dep of watchedDeps) {
-        watcher.add(dep);
-    }
-    // EXIT
     process.on("SIGINT", async () => {
-        console.log(chalk_1.default.yellow("\nStopping watcher..."));
         await watcher.close();
         process.exit(0);
     });

package/dist/engine/callResolver.js

@@ -5,153 +5,54 @@ 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) {
+function isFn(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));
 }
-// symbol → function
-function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
-    if (!symbol)
+function resolveFromSymbol(symbol, checker, seen = new Set()) {
+    if (seen.has(symbol))
         return null;
-    if (visited.has(symbol))
-        return null;
-    if (depth > 10)
-        return null;
-    visited.add(symbol);
-    // Alias unwrap (import/export)
+    seen.add(symbol);
     if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
-        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
-         */
-        if (isFunctionLike(decl)) {
-            return decl;
-        }
-        // VARIABLE → FUNCTION const fn = () => {}
-        if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
-            if (isFunctionLike(decl.initializer)) {
-                return decl.initializer;
-            }
-            const innerSymbol = checker.getSymbolAtLocation(decl.initializer);
-            if (innerSymbol && innerSymbol !== symbol) {
-                const resolved = resolveFromSymbol(innerSymbol, checker, visited, depth + 1);
-                if (resolved)
-                    return resolved;
+        return resolveFromSymbol(checker.getAliasedSymbol(symbol), checker, seen);
+    }
+    for (const d of symbol.getDeclarations() ?? []) {
+        if (isFn(d))
+            return d;
+        if (typescript_1.default.isVariableDeclaration(d) && d.initializer) {
+            if (isFn(d.initializer))
+                return d.initializer;
+            const s = checker.getSymbolAtLocation(d.initializer);
+            if (s) {
+                const r = resolveFromSymbol(s, checker, seen);
+                if (r)
+                    return r;
             }
         }
-        // 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 type = checker.getTypeAtLocation(parent);
-                const props = type.getProperties();
-                for (const prop of props) {
-                    const resolved = resolveFromSymbol(prop, checker, visited, depth + 1);
-                    if (resolved)
-                        return resolved;
-                }
-            }
-        }
-        // fallback recursion
-        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) {
-    // obj.method()
+    // foo.bar()
     if (typescript_1.default.isPropertyAccessExpression(expr)) {
-        let symbol = checker.getSymbolAtLocation(expr.name);
-        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;
-        }
-    }
-    // obj["method"]()
-    if (typescript_1.default.isElementAccessExpression(expr)) {
-        const symbol = checker.getSymbolAtLocation(expr.argumentExpression);
-        if (symbol) {
-            const resolved = resolveFromSymbol(symbol, checker);
-            if (resolved)
-                return resolved;
+        const s = checker.getSymbolAtLocation(expr.name);
+        if (s) {
+            const r = resolveFromSymbol(s, checker);
+            if (r)
+                return r;
         }
     }
-    // Call signatures
+    // direct call
     const type = checker.getTypeAtLocation(expr);
-    const signatures = type.getCallSignatures();
-    for (const sig of signatures) {
-        const decl = sig.getDeclaration();
-        if (!decl)
-            continue;
-        if (isFunctionLike(decl)) {
-            return decl;
-        }
-        if (typescript_1.default.isMethodSignature(decl)) {
-            const symbol = checker.getSymbolAtLocation(decl.name);
-            if (symbol) {
-                const resolved = resolveFromSymbol(symbol, checker);
-                if (resolved)
-                    return resolved;
-            }
-        }
-    }
-    // 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);
-    }
+    for (const sig of type.getCallSignatures()) {
+        const d = sig.getDeclaration();
+        if (d && isFn(d))
+            return d;
+    }
+    const s = checker.getSymbolAtLocation(expr);
+    if (s)
+        return resolveFromSymbol(s, checker);
     return null;
 }

package/dist/engine/engine.js

@@ -41,7 +41,7 @@ class EventraEngine {
             this.graph.update(file, source);
         }
     }
-    // SCAN FILE
+    // SCAN FILE (cached)
     scanFile(file, content, config) {
         file = this.normalize(file);
         const h = (0, hash_1.hash)(content);
@@ -55,7 +55,6 @@ class EventraEngine {
         if (!source || !checker) {
             return this.empty();
         }
-        // update graph
         this.graph.update(file, source);
         const res = (0, scanner_1.scanSource)(source, checker, config, new Set(), undefined, this.wrapperCache);
         this.fileResults.set(file, res);
@@ -63,12 +62,19 @@ class EventraEngine {
     }
     // UPDATE FILE (incremental)
     updateFile(file, content, config) {
-        this.wrapperCache.clear();
         file = this.normalize(file);
+        // EARLY EXIT
+        if (this.fileHash.get(file) === (0, hash_1.hash)(content)) {
+            return this.fileResults.get(file) ?? this.empty();
+        }
+        // invalidate wrapper cache
+        this.wrapperCache.clear();
         const res = this.scanFile(file, content, config);
         const dependents = this.graph.getAllDependentsDeep(file);
         for (const dep of dependents) {
             const abs = this.normalize(dep);
+            if (abs === file)
+                continue; // self-skip
             if ((0, boundary_1.isExternalFile)(abs))
                 continue;
             let depContent = this.ts.getFileContent(abs);
@@ -106,15 +112,17 @@ class EventraEngine {
     }
     // REMOVE FILE
     removeFile(file, config) {
-        this.wrapperCache.clear();
         file = this.normalize(file);
+        this.wrapperCache.clear();
         const dependents = this.graph.getAllDependentsDeep(file);
+        this.graph.remove(file);
         this.ts.removeFile(file);
         this.fileResults.delete(file);
         this.fileHash.delete(file);
-        this.graph.remove(file);
         for (const dep of dependents) {
             const abs = this.normalize(dep);
+            if (abs === file)
+                continue;
             if ((0, boundary_1.isExternalFile)(abs))
                 continue;
             let content = this.ts.getFileContent(abs);
@@ -126,10 +134,7 @@ class EventraEngine {
                     continue;
                 }
             }
-            const h = (0, hash_1.hash)(content);
-            if (this.fileHash.get(abs) === h)
-                continue;
-            this.fileHash.set(abs, h);
+            this.fileHash.delete(abs);
             this.ts.updateFile(abs, content);
             const source = this.ts.getSourceFile(abs);
             const checker = this.ts.getChecker();