@eventra_dev/eventra-cli 0.3.6 → 0.3.10

package/dist/compiler/compilerContext.js

@@ -14,11 +14,12 @@ class CompilerContext {
     registry = new documentRegistry_1.DocumentRegistry();
     compilerOptions;
     host;
-    builder;
+    program = typescript_1.default.createProgram([], {});
     rootNames = new Set();
     constructor(rootDir) {
         this.rootDir = rootDir;
-        const configPath = typescript_1.default.findConfigFile(rootDir, typescript_1.default.sys.fileExists, "tsconfig.json");
+        const localTsconfig = path_1.default.join(rootDir, "tsconfig.json");
+        const configPath = fs_1.default.existsSync(localTsconfig) ? localTsconfig : undefined;
         let compilerOptions = {
             target: typescript_1.default.ScriptTarget.ESNext,
             module: typescript_1.default.ModuleKind.ESNext,
@@ -33,7 +34,7 @@ class CompilerContext {
             esModuleInterop: true,
             resolveJsonModule: true,
             allowNonTsExtensions: true,
-            incremental: true,
+            incremental: false,
         };
         if (configPath) {
             const config = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
@@ -52,30 +53,59 @@ class CompilerContext {
         this.compilerOptions = compilerOptions;
         this.host = typescript_1.default.createCompilerHost(this.compilerOptions, true);
         this.patchCompilerHost();
-        this.builder = typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram([...this.rootNames], this.compilerOptions, this.host);
+        this.rebuildProgram();
     }
     normalize(fileName) {
         return this.registry.normalize(fileName);
     }
+    resolveLanguageVersion(languageVersionOrOptions) {
+        if (typeof languageVersionOrOptions === "object") {
+            return languageVersionOrOptions.languageVersion;
+        }
+        return languageVersionOrOptions;
+    }
+    attachVersion(sourceFile, fileName) {
+        const normalized = this.normalize(fileName);
+        sourceFile.version =
+            this.registry.getVersion(normalized);
+        return sourceFile;
+    }
+    createSourceFileFromRegistry(fileName, languageVersion) {
+        const normalized = this.normalize(fileName);
+        const snapshot = this.registry.getSnapshot(normalized);
+        if (!snapshot) {
+            return undefined;
+        }
+        const sourceFile = typescript_1.default.createSourceFile(normalized, snapshot.getText(0, snapshot.getLength()), languageVersion, true, this.getScriptKind(normalized));
+        return this.attachVersion(sourceFile, normalized);
+    }
     patchCompilerHost() {
-        const originalGetSourceFile = this.host.getSourceFile;
-        this.host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+        const originalGetSourceFile = this.host.getSourceFile.bind(this.host);
+        this.host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+            const languageVersion = this.resolveLanguageVersion(languageVersionOrOptions);
             const normalized = this.normalize(fileName);
             this.registry.ensure(normalized);
-            const snapshot = this.registry.getSnapshot(normalized);
-            if (!snapshot) {
-                return originalGetSourceFile(normalized, languageVersion, onError, shouldCreateNewSourceFile);
+            const fromRegistry = this.createSourceFileFromRegistry(normalized, languageVersion);
+            if (fromRegistry) {
+                return fromRegistry;
+            }
+            const fromDisk = originalGetSourceFile(normalized, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+            if (!fromDisk) {
+                return undefined;
+            }
+            if (!this.registry.has(normalized)) {
+                this.registry.update(normalized, fromDisk.getFullText());
             }
-            return typescript_1.default.createSourceFile(normalized, snapshot.getText(0, snapshot.getLength()), languageVersion, true, this.getScriptKind(normalized));
+            return this.attachVersion(fromDisk, normalized);
         };
         this.host.readFile = (fileName) => {
             const normalized = this.normalize(fileName);
             this.registry.ensure(normalized);
-            return (this.registry.getContent(normalized) ?? fs_1.default.readFileSync(normalized, "utf8"));
+            return this.registry.getContent(normalized) ?? fs_1.default.readFileSync(normalized, "utf8");
         };
         this.host.fileExists = (fileName) => {
             const normalized = this.normalize(fileName);
-            return (this.registry.has(normalized) || fs_1.default.existsSync(normalized));
+            return this.registry.has(normalized) || fs_1.default.existsSync(normalized);
         };
         this.host.getCanonicalFileName = (f) => this.normalize(f);
         this.host.useCaseSensitiveFileNames = () => true;
@@ -83,64 +113,62 @@ class CompilerContext {
         this.host.getNewLine = () => "\n";
     }
     getScriptKind(fileName) {
-        if (fileName.endsWith(".tsx")) {
+        if (fileName.endsWith(".tsx"))
             return typescript_1.default.ScriptKind.TSX;
-        }
-        if (fileName.endsWith(".ts")) {
+        if (fileName.endsWith(".ts"))
             return typescript_1.default.ScriptKind.TS;
-        }
-        if (fileName.endsWith(".jsx")) {
+        if (fileName.endsWith(".jsx"))
             return typescript_1.default.ScriptKind.JSX;
-        }
-        if (fileName.endsWith(".js")) {
+        if (fileName.endsWith(".js"))
             return typescript_1.default.ScriptKind.JS;
-        }
-        if (fileName.endsWith(".json")) {
+        if (fileName.endsWith(".json"))
             return typescript_1.default.ScriptKind.JSON;
-        }
         return typescript_1.default.ScriptKind.Unknown;
     }
-    rebuild() {
-        this.builder = typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram([...this.rootNames], this.compilerOptions, this.host, this.builder);
+    rebuildProgram() {
+        this.program = typescript_1.default.createProgram([...this.rootNames], this.compilerOptions, this.host);
+    }
+    /** Register file content without rebuilding the TS program (batch via {@link flushUpdates}). */
+    stageFile(fileName, content) {
+        const normalized = this.normalize(fileName);
+        this.registry.update(normalized, content);
+        this.rootNames.add(normalized);
+    }
+    flushUpdates() {
+        this.rebuildProgram();
     }
     async updateFile(fileName, content) {
         const normalized = this.normalize(fileName);
         const processed = await (0, processFile_1.processFile)(normalized, content);
-        this.registry.update(processed.fileName, processed.content);
-        this.rootNames.add(processed.fileName);
-        this.rebuild();
+        this.stageFile(processed.fileName, processed.content);
+        this.rebuildProgram();
     }
     removeFile(fileName) {
         const normalized = this.normalize(fileName);
         this.registry.remove(normalized);
         this.rootNames.delete(normalized);
-        this.rebuild();
-    }
-    invalidate() {
-        this.registry.invalidate();
-        this.rebuild();
+        this.rebuildProgram();
     }
     getProgram() {
-        return this.builder.getProgram();
+        return this.program;
     }
     getChecker() {
-        return this.builder.getProgram().getTypeChecker();
+        return this.program.getTypeChecker();
     }
     getSourceFile(fileName) {
-        return this.builder.getProgram().getSourceFile(this.normalize(fileName));
+        return this.program.getSourceFile(this.normalize(fileName));
     }
     getSemanticDiagnostics(fileName) {
-        const program = this.builder.getProgram();
         if (!fileName) {
-            return typescript_1.default.getPreEmitDiagnostics(program);
+            return typescript_1.default.getPreEmitDiagnostics(this.program);
         }
         const sourceFile = this.getSourceFile(fileName);
         if (!sourceFile) {
             return [];
         }
         return [
-            ...program.getSemanticDiagnostics(sourceFile),
-            ...program.getSyntacticDiagnostics(sourceFile),
+            ...this.program.getSemanticDiagnostics(sourceFile),
+            ...this.program.getSyntacticDiagnostics(sourceFile),
         ];
     }
     resolveModule(moduleName, fromFile) {
@@ -162,20 +190,14 @@ class CompilerContext {
                 continue;
             }
             const resolved = this.resolveModule(specifier.text, source.fileName);
-            if (!resolved) {
-                continue;
+            if (resolved) {
+                modules.add(this.normalize(resolved));
             }
-            modules.add(this.normalize(resolved));
         }
-        return [
-            ...modules,
-        ];
+        return [...modules];
     }
     getAllSourceFiles() {
-        return this.builder.getProgram().getSourceFiles().filter(sf => !sf.isDeclarationFile);
-    }
-    getRealFileName(fileName) {
-        return fileName;
+        return this.program.getSourceFiles().filter((sf) => !sf.isDeclarationFile);
     }
 }
 exports.CompilerContext = CompilerContext;

package/dist/config/config.js

@@ -13,10 +13,21 @@ exports.CONFIG_NAME = "eventra.json";
 const DEFAULT_INCLUDE = ["**/*.{ts,tsx,js,jsx}"];
 const DEFAULT_EXCLUDE = ["node_modules", "dist", ".next", ".git"];
 function normalizeConfig(config) {
+    const functionWrappers = (config.functionWrappers ?? [])
+        .filter((w) => w?.name)
+        .map((w) => ({ name: w.name }));
+    const seen = new Set();
+    const uniqueWrappers = functionWrappers.filter((w) => {
+        if (seen.has(w.name))
+            return false;
+        seen.add(w.name);
+        return true;
+    });
     return {
         apiKey: config.apiKey ?? "",
         endpoint: config.endpoint ?? "",
-        events: config.events ?? [],
+        events: [...(config.events ?? [])].sort(),
+        functionWrappers: uniqueWrappers.sort((a, b) => a.name.localeCompare(b.name)),
         sync: {
             include: config.sync?.include ?? DEFAULT_INCLUDE,
             exclude: config.sync?.exclude ?? DEFAULT_EXCLUDE,
@@ -25,7 +36,7 @@ function normalizeConfig(config) {
 }
 async function loadConfig() {
     const configPath = path_1.default.join(process.cwd(), exports.CONFIG_NAME);
-    if (!await fs_extra_1.default.pathExists(configPath)) {
+    if (!(await fs_extra_1.default.pathExists(configPath))) {
         return null;
     }
     try {

package/dist/core/EventraEngine.js

@@ -14,8 +14,9 @@ const resolvedCallCache_1 = require("../analysis/cache/resolvedCallCache");
 const resolvedExportCache_1 = require("../analysis/cache/resolvedExportCache");
 const returnPropagationCache_1 = require("../analysis/cache/returnPropagationCache");
 const symbolInvalidation_1 = require("../analysis/cache/symbolInvalidation");
+const analyzeFile_1 = require("../analysis/engine/analyzeFile");
 const wrapperRegistry_1 = require("../analysis/symbols/wrapperRegistry");
-const recursiveWrapperAnalyzer_1 = require("../analysis/engine/recursiveWrapperAnalyzer");
+const processFile_1 = require("../filesystem/processFile");
 const EMPTY_RESULT = () => ({
     events: new Set(),
     detectedFunctionWrappers: new Set(),
@@ -29,11 +30,13 @@ class EventraEngine {
     returnPropagationCache = new returnPropagationCache_1.ReturnPropagationCache();
     resolvedExportCache = new resolvedExportCache_1.ResolvedExportCache();
     wrapperRegistry;
+    fileIndices = new Map();
     fileResults = new Map();
     normalizedPathCache = new Map();
     isPreloading = false;
     lastConfig = {
         events: [],
+        functionWrappers: [],
         sync: {
             include: [],
             exclude: [],
@@ -43,7 +46,7 @@ class EventraEngine {
         this.compiler = new compilerContext_1.CompilerContext(rootDir);
         this.wrapperRegistry = new wrapperRegistry_1.WrapperRegistry(this.compiler.getChecker(), this.resolvedExportCache);
         this.scheduler = new scheduler_1.Scheduler(async (updates) => {
-            // APPLY UPDATES
+            const affected = new Set();
             for (const [file, content] of updates) {
                 const existing = this.compiler.getSourceFile(file);
                 if (existing) {
@@ -51,27 +54,17 @@ class EventraEngine {
                 }
                 await this.compiler.updateFile(file, content);
                 this.updateImportGraph(file);
-            }
-            // COLLECT AFFECTED FILES
-            const affected = new Set();
-            for (const file of updates.keys()) {
-                const dependents = this.importGraph.collectDependents(file);
-                for (const dependent of dependents) {
+                affected.add(file);
+                for (const dependent of this.importGraph.collectDependents(file)) {
                     affected.add(dependent);
                 }
             }
-            // RE-ANALYZE
-            for (const file of affected) {
-                await this.analyzeFile(file, this.lastConfig);
-            }
+            await this.reanalyzeFiles([...affected], this.lastConfig);
         });
     }
     beginPreload() {
         this.isPreloading = true;
     }
-    endPreload() {
-        this.isPreloading = false;
-    }
     normalize(fileName) {
         const cached = this.normalizedPathCache.get(fileName);
         if (cached) {
@@ -113,45 +106,92 @@ class EventraEngine {
             throw new Error("preload phase not active");
         }
         const normalized = this.normalize(fileName);
-        await this.compiler.updateFile(normalized, content);
-        this.updateImportGraph(normalized);
+        const processed = await (0, processFile_1.processFile)(normalized, content);
+        this.compiler.stageFile(processed.fileName, processed.content);
+    }
+    endPreload() {
+        this.isPreloading = false;
+        this.compiler.flushUpdates();
+        for (const sourceFile of this.compiler.getAllSourceFiles()) {
+            this.updateImportGraph(sourceFile.fileName);
+        }
     }
     async updateFile(fileName, content, config) {
         this.lastConfig = config;
         const normalized = this.normalize(fileName);
         await this.scheduler.enqueue(normalized, content);
     }
+    refreshChecker() {
+        this.wrapperRegistry.setChecker(this.compiler.getChecker());
+    }
+    async runFullAnalysis(fileNames, config) {
+        this.lastConfig = config;
+        this.refreshChecker();
+        const normalized = fileNames.map((f) => this.normalize(f));
+        for (const file of normalized) {
+            this.indexFile(file, config);
+        }
+        for (const file of normalized) {
+            this.extractFile(file, config);
+        }
+    }
+    async reanalyzeFiles(fileNames, config) {
+        this.lastConfig = config;
+        this.refreshChecker();
+        const normalized = fileNames.map((f) => this.normalize(f));
+        for (const file of normalized) {
+            this.indexFile(file, config);
+        }
+        for (const file of normalized) {
+            this.extractFile(file, config);
+        }
+    }
+    indexFile(fileName, _config) {
+        const normalized = this.normalize(fileName);
+        const source = this.compiler.getSourceFile(normalized);
+        if (!source) {
+            this.fileIndices.delete(normalized);
+            return;
+        }
+        const index = (0, analyzeFile_1.indexSourceFile)(source, this.compiler.getChecker(), this.wrapperRegistry);
+        this.fileIndices.set(normalized, index);
+    }
+    extractFile(fileName, config) {
+        const normalized = this.normalize(fileName);
+        const index = this.fileIndices.get(normalized);
+        if (!index) {
+            this.fileResults.delete(normalized);
+            return EMPTY_RESULT();
+        }
+        const result = (0, analyzeFile_1.extractFromIndex)(index, config, this.compiler.getChecker(), this.wrapperRegistry, this.evaluationCache, this.resolvedCallCache, this.returnPropagationCache, this.resolvedExportCache);
+        this.fileResults.set(normalized, result);
+        return result;
+    }
     async scanFile(fileName, config) {
         this.lastConfig = config;
-        return await this.analyzeFile(fileName, config);
+        this.refreshChecker();
+        this.indexFile(fileName, config);
+        return this.extractFile(fileName, config);
     }
     async removeFile(fileName, config) {
         const normalized = this.normalize(fileName);
+        const existing = this.compiler.getSourceFile(normalized);
+        if (existing) {
+            (0, symbolInvalidation_1.invalidateSourceFileSymbols)(existing, this.compiler.getChecker(), this.evaluationCache, this.resolvedCallCache, this.resolvedExportCache, this.returnPropagationCache, this.wrapperRegistry);
+        }
         const affected = this.importGraph.collectDependents(normalized);
         this.importGraph.removeFile(normalized);
         this.compiler.removeFile(normalized);
+        this.fileIndices.delete(normalized);
         this.fileResults.delete(normalized);
         this.normalizedPathCache.delete(fileName);
         this.normalizedPathCache.delete(normalized);
         const nextConfig = config ?? this.lastConfig;
-        for (const file of affected) {
-            if (file === normalized) {
-                continue;
-            }
-            await this.analyzeFile(file, nextConfig);
+        const toReanalyze = [...affected].filter((f) => f !== normalized);
+        if (toReanalyze.length > 0) {
+            await this.reanalyzeFiles(toReanalyze, nextConfig);
         }
     }
-    async analyzeFile(fileName, config) {
-        const normalized = this.normalize(fileName);
-        const source = this.compiler.getSourceFile(normalized);
-        if (!source) {
-            this.fileResults.delete(normalized);
-            return EMPTY_RESULT();
-        }
-        const result = await (0, recursiveWrapperAnalyzer_1.analyzeFileRecursive)(source, config, this.wrapperRegistry, this.evaluationCache, this.resolvedCallCache, this.returnPropagationCache, this.resolvedExportCache);
-        this.fileResults.set(normalized, result);
-        return result;
-    }
     getAllEvents() {
         const events = new Set();
         for (const result of this.fileResults.values()) {
@@ -159,9 +199,21 @@ class EventraEngine {
                 events.add(event);
             }
         }
-        return [
-            ...events,
-        ].sort();
+        return [...events].sort();
+    }
+    getAllFunctionWrappers() {
+        const wrappers = new Set();
+        for (const result of this.fileResults.values()) {
+            for (const name of result.detectedFunctionWrappers) {
+                if (name && name !== "anonymous" && !name.startsWith("__")) {
+                    wrappers.add(name);
+                }
+            }
+        }
+        return [...wrappers].sort();
+    }
+    getScanResult(fileName) {
+        return this.fileResults.get(this.normalize(fileName)) ?? EMPTY_RESULT();
     }
 }
 exports.EventraEngine = EventraEngine;

package/dist/core/projectScanner.js

@@ -7,9 +7,11 @@ exports.scanProject = scanProject;
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
+const eventraSdk_1 = require("../analysis/sdk/eventraSdk");
 const EventraEngine_1 = require("./EventraEngine");
 const processFile_1 = require("../filesystem/processFile");
 const getVirtualFile_1 = require("../filesystem/getVirtualFile");
+const SDK_TYPES_FILE = "__eventra_sdk_types__.d.ts";
 async function getParsedFile(file, cache) {
     const existing = cache.get(file);
     if (existing)
@@ -27,7 +29,6 @@ async function scanProject(config) {
     const engine = new EventraEngine_1.EventraEngine(process.cwd());
     const cache = new Map();
     const toScan = new Set();
-    // COLLECT
     for (const file of files) {
         try {
             const raw = await promises_1.default.readFile(file, "utf8");
@@ -37,32 +38,32 @@ async function scanProject(config) {
             cache.set(file, parsed);
             toScan.add(file);
             for (const dep of parsed.dependencies) {
-                toScan.add(path_1.default.resolve(path_1.default.dirname(file), dep));
+                if (dep.startsWith(".") || dep.startsWith("/")) {
+                    toScan.add(path_1.default.resolve(path_1.default.dirname(file), dep));
+                }
             }
         }
-        catch {
+        catch (err) {
+            console.error(`skip: ${file}`, err instanceof Error ? err.message : err);
         }
     }
-    // PRELOAD
+    const virtualFiles = [SDK_TYPES_FILE, ...toScan].map((f) => (0, getVirtualFile_1.getVirtualFile)(f));
     engine.beginPreload();
+    await engine.preloadFile(SDK_TYPES_FILE, eventraSdk_1.EVENTRA_SDK_SHIM);
     for (const file of toScan) {
         try {
             const parsed = await getParsedFile(file, cache);
             await engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content);
         }
-        catch {
+        catch (err) {
+            console.error(`preload skip: ${file}`, err instanceof Error ? err.message : err);
         }
     }
     engine.endPreload();
-    // SCAN
+    await engine.runFullAnalysis(virtualFiles, config);
     const results = new Map();
     for (const file of toScan) {
-        try {
-            const result = await engine.scanFile((0, getVirtualFile_1.getVirtualFile)(file), config);
-            results.set(file, result);
-        }
-        catch {
-        }
+        results.set(file, engine.getScanResult((0, getVirtualFile_1.getVirtualFile)(file)));
     }
     return {
         engine,

package/dist/core/scanResults.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConfigFromScan = buildConfigFromScan;
+exports.persistScanResults = persistScanResults;
+const config_1 = require("../config/config");
+function buildConfigFromScan(config, engine) {
+    const functionWrappers = engine
+        .getAllFunctionWrappers()
+        .map((name) => ({ name }));
+    return {
+        ...config,
+        events: engine.getAllEvents(),
+        functionWrappers,
+    };
+}
+async function persistScanResults(config, engine) {
+    await (0, config_1.saveConfig)(buildConfigFromScan(config, engine));
+}

package/dist/index.js

@@ -33,13 +33,17 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
+const package_json_1 = __importDefault(require("../package.json"));
 const program = new commander_1.Command();
 program
     .name("eventra")
     .description("Eventra CLI")
-    .version("0.0.1");
+    .version(package_json_1.default.version);
 program
     .command("init")
     .action(async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.3.6",
+  "version": "0.3.10",
   "description": "Static analytics event extraction CLI powered by the TypeScript compiler API",
   "license": "MIT",
   "type": "commonjs",
@@ -25,7 +25,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsx src/index.ts",
-    "test": "tsx tests/run.ts",
+    "test": "pnpm run clean && pnpm run build && tsx tests/run.ts",
     "clean": "rm -rf dist"
   },
   "dependencies": {

package/dist/analysis/engine/recursiveWrapperAnalyzer.js

@@ -1,76 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzeFileRecursive = analyzeFileRecursive;
-const typescript_1 = __importDefault(require("typescript"));
-const propagationAnalyzer_1 = require("../scanner/analyzer/propagationAnalyzer");
-const extractor_1 = require("../extractor/extractor");
-async function analyzeFileRecursive(sourceFile, config, wrapperRegistry, evaluationCache, resolvedCallCache, returnPropagationCache, resolvedExportCache) {
-    const checker = wrapperRegistry["checker"];
-    const sinks = [];
-    const wrappers = [];
-    const trackCalls = [];
-    // Support empty functionWrappers
-    const wrapperNames = new Set(config.functionWrappers?.map(w => w.name) ?? []);
-    function visit(node, parentFunction) {
-        // Detect calls to configured wrapper functions
-        if (typescript_1.default.isCallExpression(node)) {
-            const callName = getCallName(node.expression);
-            if (wrapperNames.has(callName)) {
-                // Track this wrapper call
-                sinks.push({ call: node, trackedArguments: [{ index: 0, propertyPath: [] }] });
-                trackCalls.push({
-                    node,
-                    sourceFile,
-                    trackedArguments: node.arguments.filter(typescript_1.default.isExpression)
-                });
-            }
-        }
-        // Detect and analyze function declarations / expressions / methods
-        if (typescript_1.default.isFunctionDeclaration(node) ||
-            typescript_1.default.isFunctionExpression(node) ||
-            typescript_1.default.isArrowFunction(node) ||
-            typescript_1.default.isMethodDeclaration(node)) {
-            const localSinks = sinks.filter(s => isNodeInside(s.call, node));
-            const wrapper = (0, propagationAnalyzer_1.analyzeWrapperPropagation)(node, checker, localSinks);
-            if (wrapper) {
-                wrappers.push(wrapper);
-                wrapperRegistry.set(wrapper);
-            }
-            // Recurse into function body
-            if (node.body) {
-                typescript_1.default.forEachChild(node.body, child => visit(child, node));
-            }
-            return;
-        }
-        // Recurse into child nodes
-        typescript_1.default.forEachChild(node, child => visit(child, parentFunction));
-    }
-    visit(sourceFile);
-    // Extract events from tracked calls and wrapper metadata
-    return (0, extractor_1.extractEvents)({
-        fileName: sourceFile.fileName,
-        sourceFile,
-        sinks,
-        trackCalls,
-        wrappers,
-    }, checker, config, evaluationCache, resolvedExportCache, resolvedCallCache, returnPropagationCache, wrapperRegistry);
-}
-function isNodeInside(child, fn) {
-    let current = child;
-    while (current) {
-        if (current === fn)
-            return true;
-        current = current.parent;
-    }
-    return false;
-}
-function getCallName(expr) {
-    if (typescript_1.default.isIdentifier(expr))
-        return expr.text;
-    if (typescript_1.default.isPropertyAccessExpression(expr) || typescript_1.default.isPropertyAccessChain(expr))
-        return expr.name.text;
-    return "";
-}