@eventra_dev/eventra-cli 0.1.33 → 0.2.1

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 };
 }