@eventra_dev/eventra-cli 2.3.0 → 2.3.2

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

@@ -6,9 +6,60 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveFunctionFromCall = resolveFunctionFromCall;
 const typescript_1 = __importDefault(require("typescript"));
 const exportResolver_1 = require("./exportResolver");
+const utils_1 = require("../shared/utils");
 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)) {
+        const value = (0, utils_1.unwrapExpression)(returned);
+        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 +115,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 +142,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/shared/utils.js

@@ -4,21 +4,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExpressionWrapper = isExpressionWrapper;
 exports.unwrapExpression = unwrapExpression;
 exports.getPropertyName = getPropertyName;
 exports.getCallName = getCallName;
 exports.getFunctionName = getFunctionName;
 const typescript_1 = __importDefault(require("typescript"));
+/** A node that only wraps an expression without changing what it is: `(x)`, `x as T`, `<T>x`, `x!`, `x satisfies T`. */
+function isExpressionWrapper(node) {
+    return (typescript_1.default.isAsExpression(node) ||
+        typescript_1.default.isTypeAssertionExpression(node) ||
+        typescript_1.default.isNonNullExpression(node) ||
+        typescript_1.default.isParenthesizedExpression(node) ||
+        typescript_1.default.isSatisfiesExpression(node));
+}
 // track(payload?.event as string)
 // track((payload.event))
 // track(payload!.event)
 function unwrapExpression(expression) {
     let current = expression;
-    while (typescript_1.default.isAsExpression(current) ||
-        typescript_1.default.isTypeAssertionExpression(current) ||
-        typescript_1.default.isNonNullExpression(current) ||
-        typescript_1.default.isParenthesizedExpression(current) ||
-        typescript_1.default.isSatisfiesExpression(current)) {
+    while (isExpressionWrapper(current)) {
         current = current.expression;
     }
     return current;

package/dist/analysis/symbols/symbolUtils.js

@@ -5,7 +5,10 @@ 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"));
+const utils_1 = require("../shared/utils");
 /**
  * Symbol an identifier *refers to*. For the name in a shorthand property (`{ event }`) a plain
  * `getSymbolAtLocation` yields the property's own symbol, not the variable/parameter it reads.
@@ -53,5 +56,41 @@ 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, possibly in parentheses, `as` or `!`. */
+function isReturnedFunction(node) {
+    if (!typescript_1.default.isArrowFunction(node) && !typescript_1.default.isFunctionExpression(node)) {
+        return false;
+    }
+    // `inner` is the outermost wrapper around the function, or the function itself
+    let inner = node;
+    let outer = node.parent;
+    while ((0, utils_1.isExpressionWrapper)(outer)) {
+        inner = outer;
+        outer = outer.parent;
+    }
+    return typescript_1.default.isReturnStatement(outer) || (typescript_1.default.isArrowFunction(outer) && outer.body === inner);
+}
+/**
+ * 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/dist/cli/sync.js

@@ -18,7 +18,10 @@ async function sync({ strict = false } = {}) {
     // report what was saved: with skipped files that is the union of the known and
     // the found events, not just what this scan found
     const saved = await (0, scanResults_1.persistScanResults)(config, engine, { preserveKnown: skipped.length > 0 });
-    console.log(chalk_1.default.green(`Found ${(0, skipped_1.plural)(saved.events?.length ?? 0, "event")}, ${(0, skipped_1.plural)(saved.functionWrappers?.length ?? 0, "function wrapper")}`));
+    // normalizeConfig always fills functionWrappers; the type only marks it optional
+    /* v8 ignore next */
+    const wrapperCount = saved.functionWrappers?.length ?? 0;
+    console.log(chalk_1.default.green(`Found ${(0, skipped_1.plural)(saved.events.length, "event")}, ${(0, skipped_1.plural)(wrapperCount, "function wrapper")}`));
     await plugins.runDynamicEventReporters(engine.getAllDynamicOccurrences());
     (0, skipped_1.reportSkipped)(skipped);
     (0, skipped_1.reportIgnored)(ignored);

package/dist/cli/watch.js

@@ -221,6 +221,8 @@ async function watch() {
         .on("add", schedule)
         .on("unlink", (file) => {
         const abs = normalize(file);
+        // chokidar's `ignored` already drops excluded paths, so this only guards against a stray event
+        /* v8 ignore next */
         if (filter.isExcluded(abs))
             return;
         // a file that failed to analyse is in no set but is still remembered as skipped

package/dist/plugin/builtins/consoleDynamicEventReporter.js

@@ -9,7 +9,8 @@ const path_1 = __importDefault(require("path"));
 // paths are printed relative to where the command runs, with forward slashes
 function displayPath(fileName) {
     const relative = path_1.default.relative(process.cwd(), fileName);
-    const outside = relative === ".." || relative.startsWith(`..${path_1.default.sep}`) || relative.startsWith("../");
+    // path.relative always joins with path.sep, so that is the only separator to look for
+    const outside = relative === ".." || relative.startsWith(`..${path_1.default.sep}`);
     const shown = relative && !outside && !path_1.default.isAbsolute(relative) ? relative : fileName;
     return shown.replace(/\\/g, "/");
 }

package/dist/plugin/registry.js

@@ -23,9 +23,9 @@ function templateRegionOf(content) {
 }
 // `__eventra_x_template_event__(expr)` (callText may be cut with an ellipsis)
 function templateExpression(occurrence) {
-    const open = occurrence.callText.indexOf("(");
-    let expression = open === -1 ? occurrence.callText : occurrence.callText.slice(open + 1);
-    expression = expression.endsWith(")") ? expression.slice(0, -1) : expression;
+    // no "(" gives indexOf -1, so slice(0) keeps the whole text
+    const afterOpen = occurrence.callText.slice(occurrence.callText.indexOf("(") + 1);
+    const expression = afterOpen.endsWith(")") ? afterOpen.slice(0, -1) : afterOpen;
     // Angular qualifies a bare name with `this.`; the template never writes it
     return occurrence.calleeText.includes("_angular_") ? expression.replace(/^this\./, "") : expression;
 }
@@ -86,11 +86,8 @@ class PluginRegistry {
     }
     /** Disk paths produced by the last preprocess run for a source file (for watch unlink). */
     getVirtualPathsForSource(fileName) {
-        const mapped = this.sourceToVirtuals.get(this.normalizePath(fileName));
-        if (mapped && mapped.length > 0) {
-            return mapped;
-        }
-        return [this.normalizePath(fileName)];
+        // a source is only recorded with at least one virtual file, so a hit is never empty
+        return this.sourceToVirtuals.get(this.normalizePath(fileName)) ?? [this.normalizePath(fileName)];
     }
     async preprocessFile(input) {
         const sourceKey = this.normalizePath(input.fileName);

package/package.json

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