@eventra_dev/eventra-cli 0.3.1 → 0.3.3

package/README.md

@@ -9,17 +9,6 @@
 [![TypeScript](https://img.shields.io/badge/typescript-ready-blue.svg)](https://www.typescriptlang.org/)
 [![License](https://img.shields.io/npm/l/@eventra_dev/eventra-cli)]()
 
-<p align="center">
-<img src="./assets/eventra-icon-animated.svg" width="120">
-</p>
-
-# Eventra CLI
-
-[![npm version](https://img.shields.io/npm/v/@eventra_dev/eventra-cli.svg)](https://www.npmjs.com/package/@eventra_dev/eventra-cli)
-[![npm downloads](https://img.shields.io/npm/dm/@eventra_dev/eventra-cli.svg)](https://www.npmjs.com/package/@eventra_dev/eventra-cli)
-[![TypeScript](https://img.shields.io/badge/typescript-ready-blue.svg)](https://www.typescriptlang.org/)
-[![License](https://img.shields.io/npm/l/@eventra_dev/eventra-cli)]()
-
 Eventra CLI automatically discovers and tracks event usage across your codebase — even through abstractions like wrappers, propagation chains, variables, and cross-file calls.
 
 ---
@@ -28,7 +17,7 @@ Eventra CLI automatically discovers and tracks event usage across your codebase
 
 Eventra scans your JavaScript and TypeScript codebase using a TypeScript-powered semantic engine and extracts analytics event usage statically.
 
-It supports wrapper propagation, return propagation, cross-file resolution, and incremental dependency-aware analysis.
+It supports semantic parameter propagation, return propagation, cross-file resolution, and incremental dependency-aware analysis.
 
 No runtime instrumentation required.
 
@@ -150,7 +139,7 @@ function trackFeature(name: string) {
 trackFeature("click")
 ```
 
-##### Wrapper propagation
+##### Semantic parameter propagation
 
 ```ts
 function trackEvent(props: {

package/dist/analysis/cache/evaluationCache.js

@@ -1,5 +1,4 @@
 "use strict";
-// src/analysis/cache/evaluationCache.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvaluationCache = void 0;
 class EvaluationCache {
@@ -14,8 +13,7 @@ class EvaluationCache {
         this.cache.delete(symbol);
     }
     clear() {
-        this.cache =
-            new WeakMap();
+        this.cache = new WeakMap();
     }
 }
 exports.EvaluationCache = EvaluationCache;

package/dist/analysis/cache/resolvedCallCache.js

@@ -1,5 +1,4 @@
 "use strict";
-// src/analysis/cache/resolvedCallCache.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResolvedCallCache = void 0;
 class ResolvedCallCache {
@@ -14,8 +13,7 @@ class ResolvedCallCache {
         this.cache.delete(symbol);
     }
     clear() {
-        this.cache =
-            new WeakMap();
+        this.cache = new WeakMap();
     }
 }
 exports.ResolvedCallCache = ResolvedCallCache;

package/dist/analysis/cache/resolvedExportCache.js

@@ -1,5 +1,4 @@
 "use strict";
-// src/analysis/cache/resolvedExportCache.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResolvedExportCache = void 0;
 class ResolvedExportCache {
@@ -14,8 +13,7 @@ class ResolvedExportCache {
         this.cache.delete(symbol);
     }
     clear() {
-        this.cache =
-            new WeakMap();
+        this.cache = new WeakMap();
     }
 }
 exports.ResolvedExportCache = ResolvedExportCache;

package/dist/analysis/cache/returnPropagationCache.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnPropagationCache = void 0;
+class ReturnPropagationCache {
+    cache = new WeakMap();
+    get(declaration) {
+        return this.cache.get(declaration);
+    }
+    set(declaration, value) {
+        this.cache.set(declaration, value);
+    }
+    delete(declaration) {
+        this.cache.delete(declaration);
+    }
+    clear() {
+        this.cache = new WeakMap();
+    }
+}
+exports.ReturnPropagationCache = ReturnPropagationCache;

package/dist/analysis/cache/symbolInvalidation.js

@@ -1,18 +1,24 @@
 "use strict";
-// src/analysis/cache/symbolInvalidation.ts
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.invalidateSourceFileSymbols = invalidateSourceFileSymbols;
 const typescript_1 = __importDefault(require("typescript"));
-function invalidateSourceFileSymbols(sourceFile, checker, evaluationCache, resolvedCallCache, resolvedExportCache) {
+function isFunctionLike(node) {
+    return (typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isMethodDeclaration(node) || typescript_1.default.isArrowFunction(node) || typescript_1.default.isFunctionExpression(node));
+}
+function invalidateSourceFileSymbols(sourceFile, checker, evaluationCache, resolvedCallCache, resolvedExportCache, returnPropagationCache, wrapperRegistry) {
     function visit(node) {
         const symbol = checker.getSymbolAtLocation(node);
         if (symbol) {
             evaluationCache.delete(symbol);
             resolvedCallCache.delete(symbol);
             resolvedExportCache.delete(symbol);
+            wrapperRegistry.delete(symbol);
+        }
+        if (isFunctionLike(node)) {
+            returnPropagationCache.delete(node);
         }
         typescript_1.default.forEachChild(node, visit);
     }

package/dist/analysis/extractor/extractor.js

@@ -1,5 +1,4 @@
 "use strict";
-// src/analysis/extractor/extractor.ts
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -10,18 +9,14 @@ const resolver_1 = require("../resolver/resolver");
 const evaluationContext_1 = require("../shared/evaluationContext");
 const propagationExtractor_1 = require("./propagationExtractor");
 function isValidEvent(value) {
-    return (value.length > 0
-        && value.length < 160
-        && /^[a-zA-Z0-9:_./-]+$/.test(value));
+    return (value.length > 0 && value.length < 160 && /^[a-zA-Z0-9:_./-]+$/.test(value));
 }
-function extractEvents(index, checker, _config, evaluationCache, exportCache, resolvedCallCache, wrapperRegistry) {
+function extractEvents(index, checker, _config, evaluationCache, exportCache, resolvedCallCache, returnPropagationCache, wrapperRegistry) {
     const events = new Set();
-    //
     // direct track sinks
-    //
     for (const call of index.trackCalls) {
         for (const argument of call.trackedArguments) {
-            const resolved = (0, resolver_1.resolveNodeValue)(argument, checker, (0, evaluationContext_1.createEvaluationContext)(), new Set(), evaluationCache, resolvedCallCache, exportCache);
+            const resolved = (0, resolver_1.resolveNodeValue)(argument, checker, (0, evaluationContext_1.createEvaluationContext)(), new Set(), evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
             for (const value of resolved.values) {
                 if (isValidEvent(value)) {
                     events.add(value);
@@ -29,12 +24,10 @@ function extractEvents(index, checker, _config, evaluationCache, exportCache, re
             }
         }
     }
-    //
-    // wrapper propagation
-    //
+    const propagationVisited = new Set();
     function visit(node) {
         if (typescript_1.default.isCallExpression(node)) {
-            (0, propagationExtractor_1.extractPropagationEvents)(node, checker, wrapperRegistry, resolvedCallCache, evaluationCache, exportCache, events, new Set());
+            (0, propagationExtractor_1.extractPropagationEvents)(node, checker, wrapperRegistry, resolvedCallCache, returnPropagationCache, evaluationCache, exportCache, events, propagationVisited);
         }
         typescript_1.default.forEachChild(node, visit);
     }
@@ -42,6 +35,5 @@ function extractEvents(index, checker, _config, evaluationCache, exportCache, re
     return {
         events,
         detectedFunctionWrappers: new Set(index.wrappers.map(wrapper => wrapper.symbol.getName())),
-        detectedComponentWrappers: new Map(),
     };
 }

package/dist/analysis/extractor/propagationExtractor.js

@@ -1,21 +1,47 @@
 "use strict";
-// src/analysis/extractor/propagationExtractor.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractPropagationEvents = extractPropagationEvents;
+const typescript_1 = __importDefault(require("typescript"));
 const callResolver_1 = require("../resolver/callResolver");
 const resolver_1 = require("../resolver/resolver");
 const evaluationContext_1 = require("../shared/evaluationContext");
 function isValidEvent(value) {
-    return (value.length > 0
-        && value.length < 160
-        && /^[a-zA-Z0-9:_./-]+$/.test(value));
+    return (value.length > 0 && value.length < 160 && /^[a-zA-Z0-9:_./-]+$/.test(value));
 }
-function extractPropagationEvents(call, checker, wrapperRegistry, resolvedCallCache, evaluationCache, exportCache, events, visited) {
+function resolveObjectPath(expression, path) {
+    let current = expression;
+    for (const segment of path) {
+        if (!typescript_1.default.isObjectLiteralExpression(current)) {
+            return null;
+        }
+        let matched = null;
+        for (const property of current.properties) {
+            if (!typescript_1.default.isPropertyAssignment(property) && !typescript_1.default.isShorthandPropertyAssignment(property)) {
+                continue;
+            }
+            const propertyName = typescript_1.default.isIdentifier(property.name) ? property.name.text : typescript_1.default.isStringLiteral(property.name) ? property.name.text : property.name.getText();
+            if (propertyName !== segment) {
+                continue;
+            }
+            matched = typescript_1.default.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
+            break;
+        }
+        if (!matched) {
+            return null;
+        }
+        current = matched;
+    }
+    return current;
+}
+function extractPropagationEvents(call, checker, wrapperRegistry, resolvedCallCache, returnPropagationCache, evaluationCache, exportCache, events, visited) {
     const resolved = (0, callResolver_1.resolveFunctionFromCall)(call.expression, checker, resolvedCallCache, exportCache);
     if (!resolved) {
         return;
     }
-    const semantic = wrapperRegistry.get(resolved, checker, exportCache);
+    const semantic = wrapperRegistry.get(resolved);
     if (!semantic) {
         return;
     }
@@ -27,23 +53,38 @@ function extractPropagationEvents(call, checker, wrapperRegistry, resolvedCallCa
         return;
     }
     visited.add(signature);
-    for (const propagation of semantic.propagations) {
-        extractPropagation(propagation, call, checker, evaluationCache, resolvedCallCache, exportCache, events);
+    try {
+        for (const propagation of semantic.propagations) {
+            extractPropagation(propagation, call, checker, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache, events);
+        }
+    }
+    finally {
+        visited.delete(signature);
     }
 }
-function extractPropagation(propagation, call, checker, evaluationCache, resolvedCallCache, exportCache, events) {
-    const argument = call.arguments[propagation.sourceParameterIndex];
+function extractPropagation(propagation, call, checker, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache, events) {
+    let argument = call.arguments[propagation.sourceParameterIndex];
     if (!argument) {
         return;
     }
+    // wrapper({
+    //   nested: {
+    //     event: "x"
+    //   }
+    // })
+    if (propagation.propertyPath.length > 0) {
+        const resolvedPath = resolveObjectPath(argument, propagation.propertyPath);
+        if (!resolvedPath) {
+            return;
+        }
+        argument = resolvedPath;
+    }
     const context = (0, evaluationContext_1.createEvaluationContext)();
-    const parameterSymbol = checker.getSymbolAtLocation(propagation
-        .sourceParameter
-        .name);
+    const parameterSymbol = checker.getSymbolAtLocation(propagation.sourceParameter.name);
     if (parameterSymbol) {
         context.parameterBindings.set(parameterSymbol, argument);
     }
-    const resolved = (0, resolver_1.resolveNodeValue)(propagation.targetNode, checker, context, new Set(), evaluationCache, resolvedCallCache, exportCache);
+    const resolved = (0, resolver_1.resolveNodeValue)(propagation.targetNode, checker, context, new Set(), evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
     for (const value of resolved.values) {
         if (isValidEvent(value)) {
             events.add(value);

package/dist/analysis/resolver/callResolver.js

@@ -1,5 +1,4 @@
 "use strict";
-// src/analysis/resolver/callResolver.ts
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,59 +7,37 @@ exports.resolveFunctionFromCall = resolveFunctionFromCall;
 const typescript_1 = __importDefault(require("typescript"));
 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 (typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isMethodDeclaration(node) || typescript_1.default.isArrowFunction(node) || typescript_1.default.isFunctionExpression(node));
 }
 function resolveDeclaration(declaration) {
-    //
     // function foo() {}
-    //
     if (isFunctionLike(declaration)) {
         return declaration;
     }
-    //
     // const foo = () => {}
-    //
-    if (typescript_1.default.isVariableDeclaration(declaration)
-        && declaration.initializer
-        && isFunctionLike(declaration.initializer)) {
+    if (typescript_1.default.isVariableDeclaration(declaration) && declaration.initializer && isFunctionLike(declaration.initializer)) {
         return declaration.initializer;
     }
-    //
     // class field = () => {}
-    //
-    if (typescript_1.default.isPropertyDeclaration(declaration)
-        && declaration.initializer
-        && isFunctionLike(declaration.initializer)) {
+    if (typescript_1.default.isPropertyDeclaration(declaration) && declaration.initializer && isFunctionLike(declaration.initializer)) {
         return declaration.initializer;
     }
     return null;
 }
 function getExpressionSymbol(expression, checker) {
-    //
     // analytics.track()
-    //
     if (typescript_1.default.isPropertyAccessExpression(expression)) {
         return checker.getSymbolAtLocation(expression.name);
     }
-    //
     // analytics?.track()
-    //
     if (typescript_1.default.isPropertyAccessChain(expression)) {
         return checker.getSymbolAtLocation(expression.name);
     }
-    //
     // analytics["track"]()
-    //
-    if (typescript_1.default.isElementAccessExpression(expression)
-        && expression.argumentExpression) {
+    if (typescript_1.default.isElementAccessExpression(expression) && expression.argumentExpression) {
         return checker.getSymbolAtLocation(expression.argumentExpression);
     }
-    //
     // track()
-    //
     return checker.getSymbolAtLocation(expression);
 }
 function resolveFunctionFromCall(expression, checker, callCache, exportCache) {
@@ -68,32 +45,19 @@ function resolveFunctionFromCall(expression, checker, callCache, exportCache) {
     if (!symbol) {
         return null;
     }
-    //
     // export unwrap
-    //
-    symbol =
-        (0, exportResolver_1.resolveExportedSymbol)(symbol, checker, exportCache)
-            ?? symbol;
-    //
+    symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker, exportCache) ?? symbol;
     // alias unwrap
-    //
-    if (symbol.flags
-        & typescript_1.default.SymbolFlags.Alias) {
-        symbol =
-            checker.getAliasedSymbol(symbol);
+    if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
     }
-    //
     // cache
-    //
     const cached = callCache.get(symbol);
     if (cached !== undefined) {
         return cached;
     }
-    //
     // declaration resolution
-    //
-    const declarations = symbol.getDeclarations()
-        ?? [];
+    const declarations = symbol.getDeclarations() ?? [];
     for (const declaration of declarations) {
         const resolved = resolveDeclaration(declaration);
         if (!resolved) {
@@ -102,24 +66,18 @@ function resolveFunctionFromCall(expression, checker, callCache, exportCache) {
         callCache.set(symbol, resolved);
         return resolved;
     }
-    //
     // fallback:
     // type signatures
-    //
-    const type = checker.getTypeOfSymbolAtLocation(symbol, declarations[0]
-        ?? expression);
+    const type = checker.getTypeOfSymbolAtLocation(symbol, declarations[0] ?? expression);
     const signatures = checker.getSignaturesOfType(type, typescript_1.default.SignatureKind.Call);
     for (const signature of signatures) {
         const declaration = signature.declaration;
-        if (declaration
-            && isFunctionLike(declaration)) {
+        if (declaration && isFunctionLike(declaration)) {
             callCache.set(symbol, declaration);
             return declaration;
         }
     }
-    //
     // unresolved
-    //
     callCache.set(symbol, null);
     return null;
 }

package/dist/analysis/resolver/exportResolver.js

@@ -1,5 +1,4 @@
 "use strict";
-// src/analysis/resolver/exportResolver.ts
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -17,54 +16,40 @@ function isConcreteDeclaration(node) {
         || typescript_1.default.isPropertyDeclaration(node));
 }
 function resolveExportedSymbol(symbol, checker, cache, visited) {
-    const seen = visited
-        ?? new Set();
+    const seen = visited ?? new Set();
     const cached = cache.get(symbol);
     if (cached !== undefined) {
         return cached;
     }
-    //
     // cycle guard
-    //
     if (seen.has(symbol)) {
         cache.set(symbol, null);
         return null;
     }
     seen.add(symbol);
-    //
     // alias unwrap
-    //
-    if (symbol.flags
-        & typescript_1.default.SymbolFlags.Alias) {
+    if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
         const aliased = checker.getAliasedSymbol(symbol);
         const resolved = resolveExportedSymbol(aliased, checker, cache, seen);
         cache.set(symbol, resolved);
         return resolved;
     }
-    //
     // export unwrap
-    //
     const exportSymbol = checker.getExportSymbolOfSymbol(symbol);
-    if (exportSymbol
-        && exportSymbol !== symbol) {
+    if (exportSymbol && exportSymbol !== symbol) {
         const resolved = resolveExportedSymbol(exportSymbol, checker, cache, seen);
         cache.set(symbol, resolved);
         return resolved;
     }
-    //
     // declaration existence
-    //
-    const declarations = symbol.getDeclarations()
-        ?? [];
+    const declarations = symbol.getDeclarations() ?? [];
     for (const declaration of declarations) {
         if (isConcreteDeclaration(declaration)) {
             cache.set(symbol, symbol);
             return symbol;
         }
     }
-    //
     // final validation
-    //
     const valid = declarations.some(isConcreteDeclaration);
     if (valid) {
         cache.set(symbol, symbol);