@eventra_dev/eventra-cli 0.1.28 → 0.1.30

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

package/dist/engine/scanner.js

@@ -7,9 +7,8 @@ exports.scanSource = scanSource;
 const typescript_1 = __importDefault(require("typescript"));
 const resolver_1 = require("./resolver");
 const callResolver_1 = require("./callResolver");
-const exportResolver_1 = require("./exportResolver");
 const functionAnalyzer_1 = require("./functionAnalyzer");
-const trackingDetector_1 = require("./trackingDetector");
+const boundary_1 = require("./boundary");
 function getCallName(expr) {
     if (typescript_1.default.isIdentifier(expr))
         return expr.text;
@@ -17,23 +16,6 @@ function getCallName(expr) {
         return expr.name.text;
     return "";
 }
-function getJsxAttrName(name) {
-    if (typescript_1.default.isIdentifier(name))
-        return name.text;
-    if (typescript_1.default.isJsxNamespacedName(name))
-        return name.name.text;
-    return null;
-}
-// unwrap
-function unwrap(expr) {
-    while (typescript_1.default.isAsExpression(expr) ||
-        typescript_1.default.isParenthesizedExpression(expr) ||
-        typescript_1.default.isTypeAssertionExpression(expr) ||
-        typescript_1.default.isNonNullExpression(expr)) {
-        expr = expr.expression;
-    }
-    return expr;
-}
 function isValidEvent(v) {
     return (v &&
         v.length > 1 &&
@@ -41,31 +23,7 @@ function isValidEvent(v) {
         !v.includes(" ") &&
         /^[a-zA-Z0-9._:-]+$/.test(v));
 }
-function isPropUsedInTracking(fn, checker, prop) {
-    let found = false;
-    function visit(node) {
-        if (typescript_1.default.isCallExpression(node)) {
-            if (!(0, trackingDetector_1.isTrackingCall)(node, checker)) {
-                typescript_1.default.forEachChild(node, visit);
-                return;
-            }
-            for (const arg of node.arguments) {
-                const a = unwrap(arg);
-                if ((typescript_1.default.isIdentifier(a) && a.text === prop) ||
-                    (typescript_1.default.isPropertyAccessExpression(a) &&
-                        a.name.text === prop)) {
-                    found = true;
-                }
-            }
-        }
-        typescript_1.default.forEachChild(node, visit);
-    }
-    if (fn.body) {
-        visit(fn.body);
-    }
-    return found;
-}
-function scanSource(source, checker, config, visited = new Set(), depth = 0, inheritedParamMap) {
+function scanSource(source, checker, config, visited = new Set(), inheritedParamMap) {
     const events = new Set();
     const detectedFunctionWrappers = new Set();
     const detectedComponentWrappers = new Map();
@@ -74,40 +32,24 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
     }
     visited.add(source.fileName);
     function visit(node) {
-        // CALL EXPRESSIONS
         if (typescript_1.default.isCallExpression(node)) {
             const name = getCallName(node.expression);
             const isKnownWrapper = config.functionWrappers.some(w => w.name === name);
-            const isTrackingByType = (0, trackingDetector_1.isTrackingCall)(node, checker);
-            let resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-            const isAutoWrapper = resolvedFn && (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn) !== null;
-            let isTracking = isKnownWrapper ||
-                isTrackingByType ||
-                isAutoWrapper ||
-                name.startsWith("$");
-            // fallback track(...)
-            if (!isTracking) {
-                if (typescript_1.default.isPropertyAccessExpression(node.expression) &&
-                    node.expression.name.text === "track") {
-                    isTracking = true;
-                }
-                else if (typescript_1.default.isIdentifier(node.expression) &&
-                    node.expression.text === "track") {
-                    isTracking = true;
-                }
-            }
+            const resolvedFn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
+            const isAutoWrapper = !!resolvedFn && (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn) !== null;
+            const isTracking = name === "track" ||
+                isKnownWrapper ||
+                (isAutoWrapper &&
+                    resolvedFn &&
+                    !(0, boundary_1.isExternalFile)(resolvedFn.getSourceFile().fileName));
             if (!isTracking) {
                 typescript_1.default.forEachChild(node, visit);
                 return;
             }
-            // DETECT WRAPPERS
-            if (!isKnownWrapper &&
-                isAutoWrapper &&
-                !isTrackingByType &&
-                !name.startsWith("track")) {
+            // авто-детект wrapper
+            if (!isKnownWrapper && isAutoWrapper && name !== "track") {
                 detectedFunctionWrappers.add(name);
             }
-            // PARAM MAP
             const paramMap = new Map(inheritedParamMap ?? []);
             if (resolvedFn && typescript_1.default.isFunctionLike(resolvedFn)) {
                 resolvedFn.parameters.forEach((param, i) => {
@@ -119,97 +61,24 @@ function scanSource(source, checker, config, visited = new Set(), depth = 0, inh
                     }
                 });
             }
-            let handled = false;
-            // MAIN RESOLVE
+            // ✅ ТОЛЬКО правильный аргумент
             if (resolvedFn) {
                 const idx = (0, functionAnalyzer_1.findTrackParamIndex)(resolvedFn);
                 if (idx !== null && node.arguments[idx]) {
                     const res = (0, resolver_1.resolveNodeValue)(node.arguments[idx], checker, paramMap);
-                    res.values.forEach(v => {
-                        if (isValidEvent(v))
-                            events.add(v);
-                    });
-                    handled = true;
-                }
-            }
-            // fallback
-            if (!handled) {
-                for (const arg of node.arguments) {
-                    const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
-                    res.values.forEach(v => {
-                        if (isValidEvent(v))
+                    for (const v of res.values) {
+                        if (isValidEvent(v)) {
                             events.add(v);
-                    });
+                        }
+                    }
                 }
             }
             // CROSS FILE
             if (resolvedFn) {
                 const sf = resolvedFn.getSourceFile();
                 if (!visited.has(sf.fileName)) {
-                    const res = scanSource(sf, checker, config, visited, depth + 1, paramMap);
-                    res.events.forEach(e => events.add(e));
-                }
-            }
-        }
-        // JSX
-        if (typescript_1.default.isJsxSelfClosingElement(node) ||
-            typescript_1.default.isJsxOpeningElement(node)) {
-            const tagNode = typescript_1.default.isPropertyAccessExpression(node.tagName)
-                ? node.tagName.name
-                : node.tagName;
-            let symbol = checker.getSymbolAtLocation(tagNode);
-            if (symbol) {
-                symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
-            }
-            if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
-                symbol = checker.getAliasedSymbol(symbol);
-            }
-            if (!symbol) {
-                typescript_1.default.forEachChild(node, visit);
-                return;
-            }
-            const tagName = typescript_1.default.isPropertyAccessExpression(node.tagName)
-                ? node.tagName.name.getText()
-                : node.tagName.getText();
-            for (const decl of symbol.getDeclarations() ?? []) {
-                let fn = null;
-                if (typescript_1.default.isFunctionDeclaration(decl))
-                    fn = decl;
-                if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
-                    const init = decl.initializer;
-                    if (typescript_1.default.isArrowFunction(init) ||
-                        typescript_1.default.isFunctionExpression(init)) {
-                        fn = init;
-                    }
-                }
-                if (!fn)
-                    continue;
-                const param = fn.parameters[0];
-                if (!param || !typescript_1.default.isObjectBindingPattern(param.name))
-                    continue;
-                for (const el of param.name.elements) {
-                    const prop = el.name.getText();
-                    const isEvent = isPropUsedInTracking(fn, checker, prop) ||
-                        config.wrappers.some(w => w.name === tagName && w.prop === prop);
-                    if (!isEvent)
-                        continue;
-                    const attr = node.attributes.properties.find(p => {
-                        if (!typescript_1.default.isJsxAttribute(p))
-                            return false;
-                        return getJsxAttrName(p.name) === prop;
-                    });
-                    if (!attr || !attr.initializer)
-                        continue;
-                    const expr = typescript_1.default.isJsxExpression(attr.initializer)
-                        ? attr.initializer.expression
-                        : attr.initializer;
-                    if (!expr)
-                        continue;
-                    const paramMap = new Map();
-                    paramMap.set(prop, expr);
-                    const res = scanSource(fn.getSourceFile(), checker, config, visited, depth + 1, paramMap);
+                    const res = scanSource(sf, checker, config, visited, paramMap);
                     res.events.forEach(e => events.add(e));
-                    detectedComponentWrappers.set(tagName, prop);
                 }
             }
         }

package/dist/engine/trackingDetector.js

@@ -5,64 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTrackingCall = isTrackingCall;
 const typescript_1 = __importDefault(require("typescript"));
-function isStringLike(type) {
-    return ((type.flags & typescript_1.default.TypeFlags.StringLike) !== 0 ||
-        (type.flags & typescript_1.default.TypeFlags.StringLiteral) !== 0);
-}
-function hasTrackLikeSignature(type, checker) {
-    const sigs = type.getCallSignatures();
-    for (const sig of sigs) {
-        const params = sig.getParameters();
-        if (!params.length)
-            continue;
-        const t = checker.getTypeOfSymbolAtLocation(params[0], params[0].valueDeclaration);
-        if (isStringLike(t)) {
-            return true;
-        }
-    }
-    return false;
-}
-function isEventraLikeType(type, checker) {
-    const props = type.getProperties();
-    for (const prop of props) {
-        const decl = prop.valueDeclaration ?? prop.declarations?.[0];
-        if (!decl)
-            continue;
-        const t = checker.getTypeOfSymbolAtLocation(prop, decl);
-        if (hasTrackLikeSignature(t, checker)) {
-            return true;
-        }
-    }
-    return false;
-}
-function isTrackingCall(node, checker) {
+function isTrackingCall(node) {
     const expr = node.expression;
-    // fn(...)
     if (typescript_1.default.isIdentifier(expr)) {
-        const type = checker.getTypeAtLocation(expr);
-        if (hasTrackLikeSignature(type, checker)) {
-            return true;
-        }
+        return expr.text === "track";
     }
-    // obj.method(...)
     if (typescript_1.default.isPropertyAccessExpression(expr)) {
-        const objType = checker.getTypeAtLocation(expr.expression);
-        // объект похож на tracker
-        if (isEventraLikeType(objType, checker)) {
-            return true;
-        }
-        // fallback
-        const methodType = checker.getTypeAtLocation(expr.name);
-        if (hasTrackLikeSignature(methodType, checker)) {
-            return true;
-        }
-    }
-    // obj["track"](...)
-    if (typescript_1.default.isElementAccessExpression(expr)) {
-        const objType = checker.getTypeAtLocation(expr.expression);
-        if (isEventraLikeType(objType, checker)) {
-            return true;
-        }
+        return expr.name.text === "track";
     }
     return false;
 }