@eventra_dev/eventra-cli 0.1.29 → 0.1.31

package/README.md

@@ -170,7 +170,6 @@ eventra send
   "events": [],
   "wrappers": [],
   "functionWrappers": [],
-  "aliases": {},
   "sync": {
     "include": ["**/*.{ts,tsx,js,jsx,vue,svelte,astro}"],
     "exclude": ["node_modules", "dist", ".next", ".git"]

package/dist/engine/engine.js

@@ -14,6 +14,7 @@ const boundary_1 = require("./boundary");
 class EventraEngine {
     ts;
     graph;
+    wrapperCache = new Map();
     fileResults = new Map();
     fileHash = new Map();
     constructor(root) {
@@ -54,14 +55,15 @@ class EventraEngine {
         if (!source || !checker) {
             return this.empty();
         }
-        // обновляем graph
+        // update graph
         this.graph.update(file, source);
-        const res = (0, scanner_1.scanSource)(source, checker, config);
+        const res = (0, scanner_1.scanSource)(source, checker, config, new Set(), undefined, this.wrapperCache);
         this.fileResults.set(file, res);
         return res;
     }
     // UPDATE FILE (incremental)
     updateFile(file, content, config) {
+        this.wrapperCache.clear();
         file = this.normalize(file);
         const res = this.scanFile(file, content, config);
         const dependents = this.graph.getAllDependentsDeep(file);
@@ -89,7 +91,7 @@ class EventraEngine {
             if (!source || !checker)
                 continue;
             this.graph.update(abs, source);
-            const r = (0, scanner_1.scanSource)(source, checker, config);
+            const r = (0, scanner_1.scanSource)(source, checker, config, new Set(), undefined, this.wrapperCache);
             this.fileResults.set(abs, r);
         }
         return res;
@@ -104,6 +106,7 @@ class EventraEngine {
     }
     // REMOVE FILE
     removeFile(file, config) {
+        this.wrapperCache.clear();
         file = this.normalize(file);
         const dependents = this.graph.getAllDependentsDeep(file);
         this.ts.removeFile(file);
@@ -138,7 +141,7 @@ class EventraEngine {
                 wrappers: [],
                 functionWrappers: [],
                 sync: { include: [], exclude: [] },
-            });
+            }, new Set(), undefined, this.wrapperCache);
             this.fileResults.set(abs, r);
         }
     }

package/dist/engine/functionAnalyzer.js

@@ -10,25 +10,11 @@ function findTrackParamIndex(fn) {
     fn.parameters.forEach((p, i) => {
         if (typescript_1.default.isIdentifier(p.name)) {
             paramIndex.set(p.name.text, i);
-            // default param: (name = "x")
-            if (p.initializer && typescript_1.default.isStringLiteral(p.initializer)) {
-                if (i === 0)
-                    return 0;
-            }
         }
     });
     let result = null;
-    function unwrap(node) {
-        // as / parentheses
-        while (typescript_1.default.isAsExpression(node) ||
-            typescript_1.default.isParenthesizedExpression(node)) {
-            node = node.expression;
-        }
-        return node;
-    }
-    function checkArg(arg) {
-        arg = unwrap(arg);
-        // identifier → param
+    function check(arg) {
+        // identifier
         if (typescript_1.default.isIdentifier(arg)) {
             const idx = paramIndex.get(arg.text);
             if (idx !== undefined) {
@@ -36,12 +22,7 @@ function findTrackParamIndex(fn) {
                 return true;
             }
         }
-        // string literal
-        if (typescript_1.default.isStringLiteral(arg)) {
-            result = 0;
-            return true;
-        }
-        // template `${name}`
+        // template
         if (typescript_1.default.isTemplateExpression(arg)) {
             for (const span of arg.templateSpans) {
                 if (typescript_1.default.isIdentifier(span.expression)) {
@@ -52,49 +33,33 @@ function findTrackParamIndex(fn) {
                     }
                 }
             }
-            result = 0;
-            return true;
         }
         // object { event: name }
         if (typescript_1.default.isObjectLiteralExpression(arg)) {
             for (const prop of arg.properties) {
                 if (!typescript_1.default.isPropertyAssignment(prop))
                     continue;
-                const name = prop.name.getText();
-                if (["event", "name", "type"].includes(name)) {
-                    return checkArg(prop.initializer);
+                const key = prop.name.getText();
+                if (["event", "name", "type"].includes(key)) {
+                    return check(prop.initializer);
                 }
             }
         }
-        // call: String(name)
-        if (typescript_1.default.isCallExpression(arg)) {
-            for (const inner of arg.arguments) {
-                if (checkArg(inner))
-                    return true;
-            }
-        }
         return false;
     }
     function visit(node) {
         if (result !== null)
             return;
         if (typescript_1.default.isCallExpression(node)) {
-            let isTrackCall = false;
-            if (typescript_1.default.isPropertyAccessExpression(node.expression)) {
-                if (node.expression.name.text === "track") {
-                    isTrackCall = true;
-                }
-            }
-            if (typescript_1.default.isIdentifier(node.expression)) {
-                if (node.expression.text === "track") {
-                    isTrackCall = true;
-                }
-            }
-            if (isTrackCall) {
-                for (const arg of node.arguments) {
-                    if (checkArg(arg))
-                        return;
-                }
+            const expr = node.expression;
+            const isTrack = (typescript_1.default.isIdentifier(expr) && expr.text === "track") ||
+                (typescript_1.default.isPropertyAccessExpression(expr) &&
+                    expr.name.text === "track");
+            if (!isTrack)
+                return;
+            for (const arg of node.arguments) {
+                if (check(arg))
+                    return;
             }
         }
         typescript_1.default.forEachChild(node, visit);

package/dist/engine/resolver.js

@@ -11,7 +11,7 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
         return { values: [], dynamic: true };
     }
     seen.add(node);
-    // PARAM MAPPING
+    // PARAM MAP (wrapper args)
     if (typescript_1.default.isIdentifier(node) && paramMap?.has(node.text)) {
         return resolveNodeValue(paramMap.get(node.text), checker, paramMap, seen);
     }
@@ -19,36 +19,19 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
     if (typescript_1.default.isStringLiteral(node)) {
         return { values: [node.text], dynamic: false };
     }
-    // ARRAY
-    if (typescript_1.default.isArrayLiteralExpression(node)) {
-        const values = [];
-        for (const el of node.elements) {
-            const res = resolveNodeValue(el, checker, paramMap, seen);
-            if (res.values.length) {
-                values.push(...res.values);
-            }
-        }
-        return {
-            values: [...new Set(values)],
-            dynamic: true
-        };
-    }
     // 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);
-            if (res.values.length) {
-                results = results.flatMap(r => res.values.map(v => r + v));
-            }
-            else {
-                results = results.map(r => r + "*");
-            }
+            results = results.flatMap(r => res.values.length
+                ? res.values.map(v => r + v)
+                : [r + "*"]);
             results = results.map(r => r + span.literal.text);
         }
         return { values: results, dynamic: true };
     }
-    // CONDITIONAL
+    // CONDITIONAL (a ? b : c)
     if (typescript_1.default.isConditionalExpression(node)) {
         const a = resolveNodeValue(node.whenTrue, checker, paramMap, seen);
         const b = resolveNodeValue(node.whenFalse, checker, paramMap, seen);
@@ -57,23 +40,57 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
             dynamic: true,
         };
     }
+    // OBJECT → берём ВСЕ значения (без привязки к ключам)
+    if (typescript_1.default.isObjectLiteralExpression(node)) {
+        const values = [];
+        for (const prop of node.properties) {
+            if (!typescript_1.default.isPropertyAssignment(prop))
+                continue;
+            const res = resolveNodeValue(prop.initializer, checker, paramMap, seen);
+            values.push(...res.values);
+        }
+        return {
+            values: [...new Set(values)],
+            dynamic: true,
+        };
+    }
+    // ARRAY
+    if (typescript_1.default.isArrayLiteralExpression(node)) {
+        const values = [];
+        for (const el of node.elements) {
+            const res = resolveNodeValue(el, checker, paramMap, seen);
+            values.push(...res.values);
+        }
+        return {
+            values: [...new Set(values)],
+            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
     if (typescript_1.default.isIdentifier(node)) {
         let symbol = checker.getSymbolAtLocation(node);
         if (!symbol)
             return { values: [], dynamic: true };
-        // INLINE FIRST
+        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);
             }
-        }
-        // unwrap export
-        symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
-        if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
-            symbol = checker.getAliasedSymbol(symbol);
-        }
-        for (const decl of symbol.getDeclarations() ?? []) {
+            // enum
             if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
                 if (typescript_1.default.isStringLiteral(decl.initializer)) {
                     return {
@@ -83,29 +100,9 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
-        const type = checker.getTypeAtLocation(node);
-        // UNION
-        if (type.isUnion()) {
-            const values = [];
-            for (const t of type.types) {
-                if (t.flags & typescript_1.default.TypeFlags.StringLiteral) {
-                    values.push(t.value);
-                }
-            }
-            if (values.length) {
-                return { values, dynamic: false };
-            }
-        }
-        // STRING LITERAL TYPE
-        if (type.flags & typescript_1.default.TypeFlags.StringLiteral) {
-            return {
-                values: [type.value],
-                dynamic: false
-            };
-        }
         return { values: [], dynamic: true };
     }
-    // PROPERTY ACCESS
+    // PROPERTY ACCESS (ENUM / CONST)
     if (typescript_1.default.isPropertyAccessExpression(node)) {
         const symbol = checker.getSymbolAtLocation(node);
         if (symbol) {
@@ -124,96 +121,18 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
-        const constantValue = checker.getConstantValue(node);
-        if (typeof constantValue === "string") {
-            return { values: [constantValue], dynamic: false };
-        }
-        const type = checker.getTypeAtLocation(node);
-        if (type.flags & typescript_1.default.TypeFlags.StringLiteral) {
-            return {
-                values: [type.value],
-                dynamic: false,
-            };
-        }
-        // object literal resolve
-        if (typescript_1.default.isIdentifier(node.expression)) {
-            const objSymbol = checker.getSymbolAtLocation(node.expression);
-            if (objSymbol) {
-                for (const decl of objSymbol.getDeclarations() ?? []) {
-                    if (typescript_1.default.isVariableDeclaration(decl) &&
-                        decl.initializer &&
-                        typescript_1.default.isObjectLiteralExpression(decl.initializer)) {
-                        for (const prop of decl.initializer.properties) {
-                            if (!typescript_1.default.isPropertyAssignment(prop))
-                                continue;
-                            const name = prop.name.getText();
-                            if (name === node.name.text) {
-                                return resolveNodeValue(prop.initializer, checker, paramMap, seen);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        // fallback
-        return resolveNodeValue(node.name, checker, paramMap, seen);
-    }
-    // ARRAY ACCESS
-    if (typescript_1.default.isElementAccessExpression(node)) {
-        const obj = resolveNodeValue(node.expression, checker, paramMap, seen);
-        if (!node.argumentExpression) {
-            return { values: obj.values, dynamic: true };
-        }
-        const index = resolveNodeValue(node.argumentExpression, checker, paramMap, seen);
-        if (index.values.length === 1) {
-            const i = Number(index.values[0]);
-            if (!Number.isNaN(i) && obj.values[i] !== undefined) {
-                return {
-                    values: [obj.values[i]],
-                    dynamic: false,
-                };
-            }
-        }
-        return obj.values.length
-            ? { values: obj.values, dynamic: true }
-            : { values: [], dynamic: true };
+        return { values: [], dynamic: true };
     }
-    // OBJECT
-    if (typescript_1.default.isObjectLiteralExpression(node)) {
+    // CALL → unwrap args
+    if (typescript_1.default.isCallExpression(node)) {
         const values = [];
-        for (const prop of node.properties) {
-            if (!typescript_1.default.isPropertyAssignment(prop))
-                continue;
-            const name = prop.name.getText();
-            if (["event", "name", "type"].includes(name)) {
-                const res = resolveNodeValue(prop.initializer, checker, paramMap, seen);
-                values.push(...res.values);
-            }
-        }
-        return {
-            values: [...new Set(values)],
-            dynamic: true
-        };
-    }
-    // BINARY ("btn_" + name)
-    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);
-            if (!left.values.length) {
-                return { values: [], dynamic: true };
-            }
-            return {
-                values: left.values.flatMap(l => right.values.length
-                    ? right.values.map(r => l + r)
-                    : [l + "*"]),
-                dynamic: true,
-            };
+        for (const arg of node.arguments) {
+            const res = resolveNodeValue(arg, checker, paramMap, seen);
+            values.push(...res.values);
         }
-    }
-    // CALL → dynamic
-    if (typescript_1.default.isCallExpression(node)) {
-        return { values: [], dynamic: true };
+        return values.length
+            ? { values, dynamic: true }
+            : { values: [], dynamic: true };
     }
     return { values: [], dynamic: true };
 }