@eventra_dev/eventra-cli 0.1.32 → 0.1.34

package/ARCHITECTURE.md

@@ -0,0 +1,88 @@
+# Eventra CLI Architecture
+
+## High-Level Flow
+
+FILES → parseUniversal → TSService → scanSource → Engine → CLI
+
+---
+
+## Diagram
+
+```
+                +-------------------+
+                |   Source Files    |
+                +---------+---------+
+                          |
+                          v
+                +-------------------+
+                |  parseUniversal   |
+                | (normalize input) |
+                +---------+---------+
+                          |
+                          v
+                +-------------------+
+                |    TSService      |
+                | (AST + Types)     |
+                +---------+---------+
+                          |
+                          v
+                +-------------------+
+                |    scanSource     |
+                | (core analyzer)   |
+                +----+------+-------+
+                     |      |
+                     |      |
+                     v      v
+          +----------------+----------------+
+          |                                 |
++-------------------+            +-----------------------+
+| Function Wrappers |            | Component Wrappers    |
++-------------------+            +-----------------------+
+          |                                 |
+          +---------------+-----------------+
+                          |
+                          v
+                +-------------------+
+                | resolveNodeValue  |
+                | (extract values)  |
+                +---------+---------+
+                          |
+                          v
+                +-------------------+
+                | EventraEngine     |
+                | (orchestration)   |
+                +---------+---------+
+                          |
+                          v
+                +-------------------+
+                | CLI (sync/check)  |
+                +-------------------+
+```
+
+---
+
+## Modules
+
+### Parser
+Extracts JS from any framework (Vue, Svelte, Astro, HTML).
+
+### TSService
+Provides TypeScript AST and type resolution.
+
+### Scanner
+Finds:
+- track() calls
+- wrappers
+- values
+
+### Engine
+Handles:
+- caching
+- dependency graph
+- incremental updates
+
+---
+
+## Goal
+
+Static analytics extraction without runtime.

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

@@ -15,9 +15,6 @@ class TSService {
     compilerOptions;
     baseUrl;
     paths;
-    usage = new Map();
-    tick = 0;
-    MAX_FILES = 2000;
     constructor(root) {
         this.root = root;
         const configPath = typescript_1.default.findConfigFile(root, typescript_1.default.sys.fileExists, "tsconfig.json");
@@ -49,11 +46,12 @@ class TSService {
         this.compilerOptions = compilerOptions;
         this.baseUrl = baseUrl;
         this.paths = paths;
+        const allFiles = typescript_1.default.sys.readDirectory(root, [".ts", ".tsx", ".js", ".jsx"], undefined, undefined);
+        for (const f of allFiles) {
+            this.fileNames.add(this.normalize(f));
+        }
         const host = {
             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) => {
@@ -62,11 +60,12 @@ class TSService {
             },
             getScriptSnapshot: (file) => {
                 file = this.normalize(file);
+                // из памяти
                 const f = this.files.get(file);
                 if (f) {
-                    this.touch(file);
                     return typescript_1.default.ScriptSnapshot.fromString(f.content);
                 }
+                // virtual TSX (vue/svelte/astro)
                 if (file.endsWith(".tsx")) {
                     const original = file.replace(/\.tsx$/, "");
                     if (fs_1.default.existsSync(original)) {
@@ -76,8 +75,6 @@ class TSService {
                             version: 1,
                         });
                         this.fileNames.add(file);
-                        this.touch(file);
-                        this.evictIfNeeded();
                         return typescript_1.default.ScriptSnapshot.fromString(content);
                     }
                 }
@@ -89,8 +86,6 @@ class TSService {
                             version: 1,
                         });
                         this.fileNames.add(file);
-                        this.touch(file);
-                        this.evictIfNeeded();
                         return typescript_1.default.ScriptSnapshot.fromString(content);
                     }
                 }
@@ -112,35 +107,12 @@ class TSService {
         };
         this.service = typescript_1.default.createLanguageService(host);
     }
-    // INTERNAL
     normalize(file) {
         return path_1.default.resolve(file).replace(/\\/g, "/");
     }
-    touch(file) {
-        this.tick++;
-        this.usage.set(file, this.tick);
-    }
-    evictIfNeeded() {
-        if (this.fileNames.size <= this.MAX_FILES)
-            return;
-        let oldest = null;
-        let oldestTick = Infinity;
-        for (const f of this.fileNames) {
-            const t = this.usage.get(f) ?? 0;
-            if (t < oldestTick) {
-                oldestTick = t;
-                oldest = f;
-            }
-        }
-        if (oldest) {
-            this.files.delete(oldest);
-            this.fileNames.delete(oldest);
-            this.usage.delete(oldest);
-        }
-    }
     ensureProgram() {
         try {
-            this.service.getProgram()?.getTypeChecker();
+            this.service.getProgram();
         }
         catch { }
     }
@@ -153,15 +125,12 @@ class TSService {
             version: prev ? prev.version + 1 : 1,
         });
         this.fileNames.add(file);
-        this.touch(file);
-        this.evictIfNeeded();
         this.ensureProgram();
     }
     removeFile(file) {
         file = this.normalize(file);
         this.files.delete(file);
         this.fileNames.delete(file);
-        this.usage.delete(file);
         this.ensureProgram();
     }
     getProgram() {

package/dist/engine/resolver.js

@@ -6,32 +6,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveNodeValue = resolveNodeValue;
 const typescript_1 = __importDefault(require("typescript"));
 const exportResolver_1 = require("./exportResolver");
+const callResolver_1 = require("./callResolver");
 function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
-    if (seen.has(node)) {
+    if (seen.has(node))
         return { values: [], dynamic: true };
-    }
     seen.add(node);
-    // PARAM MAP (wrapper args)
+    // param passthrough
     if (typescript_1.default.isIdentifier(node) && paramMap?.has(node.text)) {
         return resolveNodeValue(paramMap.get(node.text), checker, paramMap, seen);
     }
-    // STRING
+    // string
     if (typescript_1.default.isStringLiteral(node)) {
         return { values: [node.text], dynamic: false };
     }
-    // TEMPLATE
+    // template
     if (typescript_1.default.isTemplateExpression(node)) {
         let results = node.head.text ? [node.head.text] : [""];
         for (const span of node.templateSpans) {
-            const res = resolveNodeValue(span.expression, checker, paramMap, seen);
-            results = results.flatMap(r => res.values.length
-                ? res.values.map(v => r + v)
-                : [r + "*"]);
-            results = results.map(r => r + span.literal.text);
+            const r = resolveNodeValue(span.expression, checker, paramMap, seen);
+            results = results.flatMap(s => r.values.length ? r.values.map(v => s + v) : [s + "*"]);
+            results = results.map(s => s + span.literal.text);
         }
         return { values: results, dynamic: true };
     }
-    // CONDITIONAL (a ? b : c)
+    // ternary
     if (typescript_1.default.isConditionalExpression(node)) {
         const a = resolveNodeValue(node.whenTrue, checker, paramMap, seen);
         const b = resolveNodeValue(node.whenFalse, checker, paramMap, seen);
@@ -40,99 +38,112 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
             dynamic: true,
         };
     }
-    // OBJECT → берём ВСЕ значения (без привязки к ключам)
+    // object (event/name priority)
     if (typescript_1.default.isObjectLiteralExpression(node)) {
-        const values = [];
-        for (const prop of node.properties) {
-            if (!typescript_1.default.isPropertyAssignment(prop))
+        for (const p of node.properties) {
+            if (typescript_1.default.isPropertyAssignment(p)) {
+                const key = p.name.getText();
+                if (key === "event" || key === "name") {
+                    return resolveNodeValue(p.initializer, checker, paramMap, seen);
+                }
+            }
+        }
+        const vals = [];
+        for (const p of node.properties) {
+            if (!typescript_1.default.isPropertyAssignment(p))
                 continue;
-            const res = resolveNodeValue(prop.initializer, checker, paramMap, seen);
-            values.push(...res.values);
+            const r = resolveNodeValue(p.initializer, checker, paramMap, seen);
+            vals.push(...r.values);
         }
-        return {
-            values: [...new Set(values)],
-            dynamic: true,
-        };
+        return { values: [...new Set(vals)], dynamic: true };
     }
-    // ARRAY
+    // array
     if (typescript_1.default.isArrayLiteralExpression(node)) {
-        const values = [];
+        const vals = [];
         for (const el of node.elements) {
-            const res = resolveNodeValue(el, checker, paramMap, seen);
-            values.push(...res.values);
+            const r = resolveNodeValue(el, checker, paramMap, seen);
+            vals.push(...r.values);
         }
+        return { values: [...new Set(vals)], dynamic: true };
+    }
+    // concat
+    if (typescript_1.default.isBinaryExpression(node) &&
+        node.operatorToken.kind === typescript_1.default.SyntaxKind.PlusToken) {
+        const l = resolveNodeValue(node.left, checker, paramMap, seen);
+        const r = resolveNodeValue(node.right, checker, paramMap, seen);
         return {
-            values: [...new Set(values)],
+            values: l.values.flatMap(a => r.values.length ? r.values.map(b => a + b) : [a + "*"]),
             dynamic: true,
         };
     }
-    // BINARY CONCAT
-    if (typescript_1.default.isBinaryExpression(node)) {
-        if (node.operatorToken.kind === typescript_1.default.SyntaxKind.PlusToken) {
-            const left = resolveNodeValue(node.left, checker, paramMap, seen);
-            const right = resolveNodeValue(node.right, checker, paramMap, seen);
-            return {
-                values: left.values.flatMap(l => right.values.length
-                    ? right.values.map(r => l + r)
-                    : [l + "*"]),
-                dynamic: true,
-            };
-        }
-    }
-    // IDENTIFIER
+    // identifier (const / enum)
     if (typescript_1.default.isIdentifier(node)) {
-        let symbol = checker.getSymbolAtLocation(node);
-        if (!symbol)
+        let s = checker.getSymbolAtLocation(node);
+        if (!s)
             return { values: [], dynamic: true };
-        symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
-        // const VAR = "click"
-        for (const decl of symbol.getDeclarations() ?? []) {
-            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
-                return resolveNodeValue(decl.initializer, checker, paramMap, seen);
+        s = (0, exportResolver_1.resolveExportedSymbol)(s, checker) ?? s;
+        for (const d of s.getDeclarations() ?? []) {
+            if (typescript_1.default.isVariableDeclaration(d) && d.initializer) {
+                return resolveNodeValue(d.initializer, checker, paramMap, seen);
             }
-            // enum
-            if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
-                if (typescript_1.default.isStringLiteral(decl.initializer)) {
-                    return {
-                        values: [decl.initializer.text],
-                        dynamic: false,
-                    };
-                }
+            if (typescript_1.default.isEnumMember(d) && d.initializer && typescript_1.default.isStringLiteral(d.initializer)) {
+                return { values: [d.initializer.text], dynamic: false };
             }
         }
         return { values: [], dynamic: true };
     }
-    // PROPERTY ACCESS (ENUM / CONST)
+    // PROPERTY ACCESS (OBJECT + ENUM)
     if (typescript_1.default.isPropertyAccessExpression(node)) {
-        const symbol = checker.getSymbolAtLocation(node);
-        if (symbol) {
-            let s = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
-            if (s.flags & typescript_1.default.SymbolFlags.Alias) {
-                s = checker.getAliasedSymbol(s);
-            }
-            for (const decl of s.getDeclarations() ?? []) {
-                if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
-                    if (typescript_1.default.isStringLiteral(decl.initializer)) {
-                        return {
-                            values: [decl.initializer.text],
-                            dynamic: false,
-                        };
+        const obj = node.expression;
+        const prop = node.name.text;
+        // object literal lookup
+        if (typescript_1.default.isIdentifier(obj)) {
+            const sym = checker.getSymbolAtLocation(obj);
+            if (sym) {
+                const s = (0, exportResolver_1.resolveExportedSymbol)(sym, checker) ?? sym;
+                for (const d of s.getDeclarations() ?? []) {
+                    if (typescript_1.default.isVariableDeclaration(d) &&
+                        d.initializer &&
+                        typescript_1.default.isObjectLiteralExpression(d.initializer)) {
+                        for (const p of d.initializer.properties) {
+                            if (typescript_1.default.isPropertyAssignment(p) &&
+                                p.name.getText() === prop) {
+                                return resolveNodeValue(p.initializer, checker, paramMap, seen);
+                            }
+                        }
                     }
                 }
             }
         }
+        // enum fallback
+        const sym = checker.getSymbolAtLocation(node);
+        if (sym) {
+            let s = (0, exportResolver_1.resolveExportedSymbol)(sym, checker) ?? sym;
+            if (s.flags & typescript_1.default.SymbolFlags.Alias)
+                s = checker.getAliasedSymbol(s);
+            for (const d of s.getDeclarations() ?? []) {
+                if (typescript_1.default.isEnumMember(d) && d.initializer && typescript_1.default.isStringLiteral(d.initializer)) {
+                    return { values: [d.initializer.text], dynamic: false };
+                }
+            }
+        }
         return { values: [], dynamic: true };
     }
-    // CALL → unwrap args
+    // CALL (unwrap + dive into wrapper body)
     if (typescript_1.default.isCallExpression(node)) {
-        const values = [];
-        for (const arg of node.arguments) {
-            const res = resolveNodeValue(arg, checker, paramMap, seen);
-            values.push(...res.values);
+        const vals = [];
+        // args
+        for (const a of node.arguments) {
+            const r = resolveNodeValue(a, checker, paramMap, seen);
+            vals.push(...r.values);
+        }
+        // dive into called function (wrapper support)
+        const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
+        if (fn?.body) {
+            const r = resolveNodeValue(fn.body, checker, paramMap, seen);
+            vals.push(...r.values);
         }
-        return values.length
-            ? { values, dynamic: true }
-            : { values: [], dynamic: true };
+        return { values: [...new Set(vals)], dynamic: true };
     }
     return { values: [], dynamic: true };
 }