@eventra_dev/eventra-cli 2.3.0 → 2.3.1

package/dist/analysis/extractor/extractor.js

@@ -8,6 +8,7 @@ const typescript_1 = __importDefault(require("typescript"));
 const resolver_1 = require("../resolver/resolver");
 const evaluationContext_1 = require("../shared/evaluationContext");
 const propagationExtractor_1 = require("./propagationExtractor");
+const symbolUtils_1 = require("../symbols/symbolUtils");
 const eventValidation_1 = require("../shared/eventValidation");
 const dynamicOccurrence_1 = require("../shared/dynamicOccurrence");
 function extractEvents(index, checker, _config, evaluationCache, exportCache, resolvedCallCache, returnPropagationCache, wrapperRegistry) {
@@ -38,7 +39,7 @@ function extractEvents(index, checker, _config, evaluationCache, exportCache, re
     visit(index.sourceFile);
     return {
         events,
-        detectedFunctionWrappers: new Set(index.wrappers.map(wrapper => wrapper.symbol.getName())),
+        detectedFunctionWrappers: new Set(index.wrappers.map(wrapper => (0, symbolUtils_1.wrapperName)(wrapper.declaration, wrapper.symbol))),
         dynamicOccurrences,
     };
 }

package/dist/analysis/resolver/callResolver.js

@@ -9,6 +9,59 @@ const exportResolver_1 = require("./exportResolver");
 function isFunctionLike(node) {
     return (typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isMethodDeclaration(node) || typescript_1.default.isArrowFunction(node) || typescript_1.default.isFunctionExpression(node));
 }
+/** `return expr` statements of a function body, not looking into functions nested in it. */
+function returnedExpressions(fn) {
+    if (!fn.body) {
+        return [];
+    }
+    if (!typescript_1.default.isBlock(fn.body)) {
+        return [fn.body];
+    }
+    const found = [];
+    const visit = (node) => {
+        if (typescript_1.default.isFunctionLike(node)) {
+            return;
+        }
+        if (typescript_1.default.isReturnStatement(node) && node.expression) {
+            found.push(node.expression);
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(fn.body);
+    return found;
+}
+const MAX_RETURN_HOPS = 4;
+/**
+ * The function a call hands back: `useTracker()` for `function useTracker() { return (n) => t.track(n) }`,
+ * where the returned value is a function expression or a name bound to one.
+ */
+function resolveReturnedFunction(call, checker, callCache, exportCache, hops) {
+    if (hops > MAX_RETURN_HOPS) {
+        return null;
+    }
+    const factory = resolveFunctionFromCall(call.expression, checker, callCache, exportCache, hops + 1);
+    if (!factory) {
+        return null;
+    }
+    for (const returned of returnedExpressions(factory)) {
+        let value = returned;
+        while (typescript_1.default.isParenthesizedExpression(value) || typescript_1.default.isAsExpression(value) || typescript_1.default.isNonNullExpression(value)) {
+            value = value.expression;
+        }
+        if (isFunctionLike(value)) {
+            return value;
+        }
+        if (typescript_1.default.isIdentifier(value)) {
+            for (const next of checker.getSymbolAtLocation(value)?.getDeclarations() ?? []) {
+                const resolved = resolveDeclaration(next, checker);
+                if (resolved) {
+                    return resolved;
+                }
+            }
+        }
+    }
+    return null;
+}
 function resolveDeclaration(declaration, checker) {
     // function foo() {}
     if (isFunctionLike(declaration)) {
@@ -64,7 +117,15 @@ function getExpressionSymbol(expression, checker) {
     // track()
     return checker.getSymbolAtLocation(expression);
 }
-function resolveFunctionFromCall(expression, checker, callCache, exportCache) {
+function resolveFunctionFromCall(expression, checker, callCache, exportCache, hops = 0) {
+    // useTracker()("x")
+    let callee = expression;
+    while (typescript_1.default.isParenthesizedExpression(callee)) {
+        callee = callee.expression;
+    }
+    if (typescript_1.default.isCallExpression(callee)) {
+        return resolveReturnedFunction(callee, checker, callCache, exportCache, hops);
+    }
     let symbol = getExpressionSymbol(expression, checker);
     if (!symbol) {
         return null;
@@ -83,7 +144,10 @@ function resolveFunctionFromCall(expression, checker, callCache, exportCache) {
     // declaration resolution
     const declarations = symbol.getDeclarations() ?? [];
     for (const declaration of declarations) {
-        const resolved = resolveDeclaration(declaration, checker);
+        // const track = useTracker(); track("x")
+        const resolved = resolveDeclaration(declaration, checker) ?? (typescript_1.default.isVariableDeclaration(declaration) && declaration.initializer && typescript_1.default.isCallExpression(declaration.initializer)
+            ? resolveReturnedFunction(declaration.initializer, checker, callCache, exportCache, hops)
+            : null);
         if (!resolved) {
             continue;
         }

package/dist/analysis/sdk/isEventraTrackCall.js

@@ -91,7 +91,12 @@ function isEventraNewExpression(node, checker) {
         return false;
     }
     const symbol = checker.getSymbolAtLocation(expr);
-    return symbol ? isEventraSymbol(symbol, checker) : false;
+    if (symbol && isEventraSymbol(symbol, checker)) {
+        return true;
+    }
+    // `const { Eventra } = await import("@eventra_dev/eventra-sdk")`: the binding is not an import, but
+    // the instance it builds is still typed as the SDK's class
+    return typeLooksLikeEventra(checker.getTypeAtLocation(node), checker);
 }
 function typeLooksLikeEventra(type, checker, depth = 0) {
     // cycle guard - TypeScript flattens union/intersection types (a literal
@@ -115,7 +120,63 @@ function typeLooksLikeEventra(type, checker, depth = 0) {
     }
     return false;
 }
-function isEventraReceiverExpression(receiver, checker) {
+const MAX_RECEIVER_HOPS = 6;
+/** `return expr` statements of a function body, not looking into functions nested in it. */
+function returnedExpressions(fn) {
+    if (!fn.body) {
+        return [];
+    }
+    if (!typescript_1.default.isBlock(fn.body)) {
+        return [fn.body];
+    }
+    const found = [];
+    const visit = (node) => {
+        if (typescript_1.default.isFunctionLike(node)) {
+            return;
+        }
+        if (typescript_1.default.isReturnStatement(node) && node.expression) {
+            found.push(node.expression);
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(fn.body);
+    return found;
+}
+function functionOf(decl) {
+    if (typescript_1.default.isFunctionDeclaration(decl) || typescript_1.default.isMethodDeclaration(decl)) {
+        return decl;
+    }
+    if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer && (typescript_1.default.isArrowFunction(decl.initializer) || typescript_1.default.isFunctionExpression(decl.initializer))) {
+        return decl.initializer;
+    }
+    return undefined;
+}
+/** `t = new Eventra(...)` anywhere in the file of a variable's declaration: a lazily filled `let t: any`. */
+function assignedValues(symbol, checker) {
+    const values = [];
+    const files = new Set((symbol.getDeclarations() ?? []).map((decl) => decl.getSourceFile()));
+    for (const file of files) {
+        const visit = (node) => {
+            if (typescript_1.default.isBinaryExpression(node) &&
+                node.operatorToken.kind === typescript_1.default.SyntaxKind.EqualsToken &&
+                typescript_1.default.isIdentifier(node.left) &&
+                checker.getSymbolAtLocation(node.left) === symbol) {
+                values.push(node.right);
+            }
+            typescript_1.default.forEachChild(node, visit);
+        };
+        visit(file);
+    }
+    return values;
+}
+function isEventraReceiverExpression(receiver, checker, hops = 0) {
+    if (hops > MAX_RECEIVER_HOPS) {
+        return false;
+    }
+    // `(await getTracker()).track(...)`, `(tracker as Eventra).track(...)`, `tracker!.track(...)`
+    if (typescript_1.default.isParenthesizedExpression(receiver) || typescript_1.default.isAwaitExpression(receiver) || typescript_1.default.isNonNullExpression(receiver) || typescript_1.default.isAsExpression(receiver)) {
+        return isEventraReceiverExpression(receiver.expression, checker, hops + 1);
+    }
     if (typescript_1.default.isNewExpression(receiver)) {
         return isEventraNewExpression(receiver, checker);
     }
@@ -126,6 +187,18 @@ function isEventraReceiverExpression(receiver, checker) {
     if (typeLooksLikeEventra(type, checker)) {
         return true;
     }
+    // `getTracker().track(...)` where the getter's type is lost (`any`) but what it returns is a tracker
+    if (typescript_1.default.isCallExpression(receiver)) {
+        const callee = typescript_1.default.isIdentifier(receiver.expression) || typescript_1.default.isPropertyAccessExpression(receiver.expression)
+            ? checker.getSymbolAtLocation(typescript_1.default.isIdentifier(receiver.expression) ? receiver.expression : receiver.expression.name)
+            : undefined;
+        for (const decl of callee?.getDeclarations() ?? []) {
+            const fn = functionOf(decl);
+            if (fn && returnedExpressions(fn).some((returned) => isEventraReceiverExpression(returned, checker, hops + 1))) {
+                return true;
+            }
+        }
+    }
     if (typescript_1.default.isIdentifier(receiver)) {
         const symbol = checker.getSymbolAtLocation(receiver);
         if (!symbol) {
@@ -134,6 +207,9 @@ function isEventraReceiverExpression(receiver, checker) {
         // See the identical `?? []` above isEventraSymbol's declaration loop: a
         // real ts.Symbol here always has a declarations array.
         /* v8 ignore next */
+        if (assignedValues(symbol, checker).some((value) => isEventraReceiverExpression(value, checker, hops + 1))) {
+            return true;
+        }
         for (const decl of symbol.getDeclarations() ?? []) {
             if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
                 if (typescript_1.default.isNewExpression(decl.initializer) && isEventraNewExpression(decl.initializer, checker)) {
@@ -167,7 +243,7 @@ function isEventraReceiverExpression(receiver, checker) {
         }
     }
     if (typescript_1.default.isPropertyAccessExpression(receiver) || typescript_1.default.isPropertyAccessChain(receiver)) {
-        return isEventraReceiverExpression(receiver.expression, checker);
+        return isEventraReceiverExpression(receiver.expression, checker, hops + 1);
     }
     return false;
 }

package/dist/analysis/symbols/symbolUtils.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getValueSymbol = getValueSymbol;
 exports.getFunctionSymbol = getFunctionSymbol;
+exports.isReturnedFunction = isReturnedFunction;
+exports.wrapperName = wrapperName;
 const typescript_1 = __importDefault(require("typescript"));
 /**
  * Symbol an identifier *refers to*. For the name in a shorthand property (`{ event }`) a plain
@@ -53,5 +55,44 @@ function getFunctionSymbol(node, checker) {
     if (typescript_1.default.isExportAssignment(parent)) {
         return checker.getSymbolAtLocation(node);
     }
+    // `return (name) => ...` / `() => (name) => ...`: a function a hook or factory hands back has no
+    // name of its own, but the binder still gives it a symbol, and that is what a call of the result
+    // (`const track = useTracker(); track("x")`) is matched against.
+    if (isReturnedFunction(node)) {
+        return node.symbol;
+    }
     return undefined;
 }
+/** An arrow/function expression that is the value of a `return`, or the concise body of an arrow. */
+function isReturnedFunction(node) {
+    if (!typescript_1.default.isArrowFunction(node) && !typescript_1.default.isFunctionExpression(node)) {
+        return false;
+    }
+    let outer = node.parent;
+    while (typescript_1.default.isParenthesizedExpression(outer)) {
+        outer = outer.parent;
+    }
+    return typescript_1.default.isReturnStatement(outer) || (typescript_1.default.isArrowFunction(outer) && unparen(outer.body) === node);
+}
+function unparen(node) {
+    while (typescript_1.default.isParenthesizedExpression(node)) {
+        node = node.expression;
+    }
+    return node;
+}
+/**
+ * The name a wrapper is reported under: its own, or for an anonymous returned function the hook that
+ * returns it (`useTracker` for `function useTracker() { return (n) => t.track(n); }`).
+ */
+function wrapperName(declaration, symbol) {
+    if (!isReturnedFunction(declaration)) {
+        return symbol.getName();
+    }
+    const owner = typescript_1.default.findAncestor(declaration.parent, (n) => typescript_1.default.isFunctionLike(n));
+    const ownerName = owner && owner.name;
+    if (ownerName && typescript_1.default.isIdentifier(ownerName)) {
+        return ownerName.text;
+    }
+    const holder = owner?.parent;
+    return holder && typescript_1.default.isVariableDeclaration(holder) && typescript_1.default.isIdentifier(holder.name) ? holder.name.text : symbol.getName();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Static analytics event extraction CLI powered by the TypeScript compiler API",
   "license": "MIT",
   "author": {