@eventra_dev/eventra-cli 2.2.0 → 2.3.1

package/dist/cli/init.js

@@ -3,10 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInstalled = isInstalled;
 exports.init = init;
 const chalk_1 = __importDefault(require("chalk"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const inquirer_1 = __importDefault(require("inquirer"));
+const module_1 = require("module");
 const path_1 = __importDefault(require("path"));
 const config_1 = require("../config/config");
 const sinkPresets_1 = require("../plugin/builtins/sinkPresets");
@@ -15,8 +17,8 @@ const projectDependencies_1 = require("./projectDependencies");
  * Looks for analytics libraries in package.json (and workspace members) and, if there are any,
  * asks which of them Eventra should read events from. Everything detected is pre-selected.
  */
-async function chooseSinks(yes) {
-    const detected = (0, sinkPresets_1.detectSinkPresets)(await (0, projectDependencies_1.collectDependencyNames)(process.cwd()));
+async function chooseSinks(yes, dependencyNames) {
+    const detected = (0, sinkPresets_1.detectSinkPresets)(dependencyNames);
     if (detected.length === 0)
         return [];
     console.log(chalk_1.default.gray(`Found analytics in package.json: ${detected.map((d) => d.packages.join(", ")).join("; ")}`));
@@ -36,12 +38,40 @@ async function chooseSinks(yes) {
     ]);
     return presets.map((preset) => ({ preset }));
 }
+/** Framework dependency -> the plugin that reads its template files (`.vue`, `.svelte`, `.astro`, Angular templates). */
+const FRAMEWORK_PLUGINS = {
+    vue: "@eventra_dev/cli-plugin-vue",
+    svelte: "@eventra_dev/cli-plugin-svelte",
+    astro: "@eventra_dev/cli-plugin-astro",
+    "@angular/core": "@eventra_dev/cli-plugin-angular",
+};
+/** True when the plugin package can be loaded from the project, which is where `sync` will look for it. */
+function isInstalled(plugin) {
+    try {
+        (0, module_1.createRequire)(path_1.default.join(process.cwd(), "package.json")).resolve(plugin);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The plugins for the frameworks found in package.json (and workspace members), split by whether they are
+ * installed. Without a plugin, events fired from component files are never seen. Only an installed one is
+ * written to `plugins`: `sync` stops on a plugin it cannot load, and an `init` followed by `sync` must not.
+ */
+function detectPlugins(dependencyNames, installed) {
+    const found = Object.entries(FRAMEWORK_PLUGINS)
+        .filter(([dependency]) => dependencyNames.has(dependency))
+        .map(([, plugin]) => plugin);
+    return { enabled: found.filter(installed), missing: found.filter((plugin) => !installed(plugin)) };
+}
 const DEFAULT_ENDPOINT = "https://api.eventra.dev/api/v1/cli/events";
 /**
  * `yes` is the non-interactive mode (CI, scripts): defaults for every answer,
  * and an existing eventra.json is never overwritten.
  */
-async function init({ yes = false } = {}) {
+async function init({ yes = false, isPluginInstalled = isInstalled } = {}) {
     if (await fs_extra_1.default.pathExists(path_1.default.join(process.cwd(), config_1.CONFIG_NAME))) {
         if (yes) {
             console.log(chalk_1.default.yellow(`${config_1.CONFIG_NAME} already exists, keeping it`));
@@ -76,7 +106,9 @@ async function init({ yes = false } = {}) {
                 default: DEFAULT_ENDPOINT,
             },
         ]);
-    const sinks = await chooseSinks(yes);
+    const dependencyNames = await (0, projectDependencies_1.collectDependencyNames)(process.cwd());
+    const sinks = await chooseSinks(yes, dependencyNames);
+    const { enabled: plugins, missing: missingPlugins } = detectPlugins(dependencyNames, isPluginInstalled);
     console.log("");
     console.log(chalk_1.default.gray("Eventra detects @eventra_dev/eventra-sdk usage:"));
     console.log(chalk_1.default.gray('• tracker.track("event.name")'));
@@ -88,21 +120,24 @@ async function init({ yes = false } = {}) {
         endpoint,
         events: [],
         functionWrappers: [],
+        ...(plugins.length > 0 ? { plugins } : {}),
         ...(sinks.length > 0 ? { sinks } : {}),
         sync: {
             include: [
                 "**/*.{ts,tsx,js,jsx}",
             ],
-            exclude: [
-                "node_modules",
-                "dist",
-                ".next",
-                ".git",
-            ],
+            exclude: [...config_1.INIT_EXCLUDE],
         },
     };
     await (0, config_1.saveConfig)(config);
     console.log(chalk_1.default.green("eventra.json created"));
+    if (plugins.length > 0) {
+        console.log(chalk_1.default.green(`plugins: ${plugins.join(", ")}`));
+    }
+    if (missingPlugins.length > 0) {
+        console.log(chalk_1.default.yellow(`Component files are not read yet: npm install -D ${missingPlugins.join(" ")}`));
+        console.log(chalk_1.default.yellow(`then add ${missingPlugins.map((p) => `"${p}"`).join(", ")} to "plugins" in ${config_1.CONFIG_NAME}`));
+    }
     if (sinks.length > 0) {
         console.log(chalk_1.default.green(`sinks: ${sinks.map((s) => s.preset).join(", ")}`));
     }

package/dist/cli/projectDependencies.js

@@ -3,13 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.memberGlob = exports.MAX_WORKSPACE_PACKAGES = void 0;
+exports.stringList = stringList;
+exports.pnpmWorkspacePatterns = pnpmWorkspacePatterns;
+exports.staysInsideProject = staysInsideProject;
 exports.collectDependencyNames = collectDependencyNames;
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const DEPENDENCY_FIELDS = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
 /** Upper bound on workspace members read, so a huge monorepo cannot make `init` crawl. */
-const MAX_WORKSPACE_PACKAGES = 300;
+exports.MAX_WORKSPACE_PACKAGES = 300;
 /**
  * Parsed package.json, or null when it is missing or not JSON. Whatever else the file holds (an
  * array, a number) is returned as is: every reader below only looks up named properties on it, which
@@ -86,10 +90,11 @@ async function workspacePatterns(rootDir, rootPackage) {
  * `!apps/skipped/package.json`, which fast-glob treats as an exclusion of exactly those files.
  */
 const memberGlob = (pattern) => `${pattern}/package.json`;
+exports.memberGlob = memberGlob;
 /** Member package.json paths for the patterns; a pattern fast-glob rejects (a NUL byte, say) yields none. */
 async function findMembers(rootDir, patterns) {
     try {
-        return await (0, fast_glob_1.default)(patterns.map(memberGlob), { cwd: rootDir, ignore: ["**/node_modules/**"] });
+        return await (0, fast_glob_1.default)(patterns.map(exports.memberGlob), { cwd: rootDir, ignore: ["**/node_modules/**"] });
     }
     catch {
         // Stryker disable next-line ArrayDeclaration: a stray path that is not a package.json is read as "no package.json"
@@ -108,7 +113,7 @@ async function collectDependencyNames(rootDir) {
     for (const name of dependencyNames(rootPackage))
         names.add(name);
     const patterns = await workspacePatterns(rootDir, rootPackage);
-    const members = (await findMembers(rootDir, patterns)).slice(0, MAX_WORKSPACE_PACKAGES);
+    const members = (await findMembers(rootDir, patterns)).slice(0, exports.MAX_WORKSPACE_PACKAGES);
     for (const member of members) {
         const memberPackage = await readPackage(path_1.default.join(rootDir, member));
         if (memberPackage !== null)

package/dist/compiler/compilerContext.js

@@ -8,6 +8,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const typescript_1 = __importDefault(require("typescript"));
 const documentRegistry_1 = require("./documentRegistry");
+const workspacePackages_1 = require("./workspacePackages");
 class CompilerContext {
     rootDir;
     registry = new documentRegistry_1.DocumentRegistry();
@@ -22,9 +23,15 @@ class CompilerContext {
     // scan and flushes once, so an eager build in the constructor was thrown away.
     programInstance;
     rootNames = new Set();
-    // Only set while withResolutionCache() runs: it memoises fileExists results,
-    // so it must never outlive one batch of resolutions against one program.
-    activeResolutionCache;
+    // compiler options of the nearest tsconfig.json above a folder (the root one for files outside any other)
+    optionsByDir = new Map();
+    // the options a project starts from before any tsconfig.json is applied
+    defaultOptions;
+    workspacePackages;
+    // one module resolution cache per set of options; only alive while a program is built or a batch runs
+    resolutionCaches = new Map();
+    // how many builds or batches are running that share the caches (a rebuild can start inside a batch)
+    cachingDepth = 0;
     constructor(rootDir) {
         this.rootDir = rootDir;
         const localTsconfig = path_1.default.join(rootDir, "tsconfig.json");
@@ -45,6 +52,7 @@ class CompilerContext {
             allowNonTsExtensions: true,
             incremental: false,
         };
+        this.defaultOptions = compilerOptions;
         if (configPath) {
             const config = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
             if (config.error) {
@@ -55,17 +63,138 @@ class CompilerContext {
                 ...compilerOptions,
                 ...parsed.options,
             };
+            // A solution-style tsconfig (`"files": []` plus `references`, the Vite and Vue template) keeps its
+            // `@/*` aliases in a referenced config, so without this every aliased import stays unresolved.
+            if (!parsed.options.paths) {
+                Object.assign(compilerOptions, this.pathOptionsFromReferences(parsed.projectReferences));
+            }
             for (const file of parsed.fileNames) {
                 this.rootNames.add(this.normalize(file));
             }
         }
         this.compilerOptions = compilerOptions;
+        this.workspacePackages = (0, workspacePackages_1.findWorkspacePackages)(rootDir);
         this.host = typescript_1.default.createCompilerHost(this.compilerOptions, true);
         this.patchCompilerHost();
     }
     normalize(fileName) {
         return this.registry.normalize(fileName);
     }
+    /**
+     * Compiler options for resolving the imports of `fromFile`: those of the nearest tsconfig.json above
+     * it. A monorepo keeps one per app (`@/*` means a different folder in each) and often none at the root;
+     * a single root-level tsconfig.json answers for every file below it, as it always did.
+     */
+    optionsFor(fromFile) {
+        // an installed package may ship a tsconfig.json of its own: its settings are for building it, not for this project
+        if (fromFile.split(/[\\/]/).includes("node_modules"))
+            return this.compilerOptions;
+        const visited = [];
+        let options = this.compilerOptions;
+        for (let dir = path_1.default.dirname(fromFile);; dir = path_1.default.dirname(dir)) {
+            const cached = this.optionsByDir.get(dir);
+            const own = cached ?? this.readDirectoryOptions(dir);
+            if (own) {
+                options = own;
+                visited.push(dir);
+                break;
+            }
+            visited.push(dir);
+            // a file outside the project, or the top of the filesystem, keeps the root options
+            if (path_1.default.relative(this.rootDir, dir).startsWith("..") || path_1.default.dirname(dir) === dir || dir === this.rootDir)
+                break;
+        }
+        for (const dir of visited)
+            this.optionsByDir.set(dir, options);
+        return options;
+    }
+    /** The options a folder's own tsconfig.json sets, `undefined` when it has none (the root's are already loaded). */
+    readDirectoryOptions(dir) {
+        if (dir === this.rootDir)
+            return this.compilerOptions;
+        const configPath = path_1.default.join(dir, "tsconfig.json");
+        if (!fs_1.default.existsSync(configPath))
+            return undefined;
+        const config = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
+        if (config.error)
+            return undefined;
+        const parsed = typescript_1.default.parseJsonConfigFileContent(config.config, typescript_1.default.sys, dir);
+        return {
+            ...this.defaultOptions,
+            ...parsed.options,
+            ...(parsed.options.paths ? {} : this.aliasesWithout(parsed.options, parsed.projectReferences)),
+        };
+    }
+    /**
+     * Aliases for a config that sets no `paths` of its own: those of its project references, or else the root's.
+     * A tsconfig.json that only adjusts a few options (a `tests/` one, say) does not mean the root's `@/*` stopped
+     * being valid there, and the root's aliases applied to every file before configs were read per folder.
+     */
+    aliasesWithout(own, references) {
+        const fromReferences = this.pathOptionsFromReferences(references);
+        if (fromReferences.paths)
+            return fromReferences;
+        const { paths, baseUrl, pathsBasePath } = this.compilerOptions;
+        return { paths, baseUrl: own.baseUrl ?? baseUrl, pathsBasePath };
+    }
+    cacheFor(options) {
+        if (this.cachingDepth === 0)
+            return undefined;
+        let cache = this.resolutionCaches.get(options);
+        if (!cache) {
+            cache = typescript_1.default.createModuleResolutionCache(this.rootDir, (fileName) => this.normalize(fileName), options);
+            this.resolutionCaches.set(options, cache);
+        }
+        return cache;
+    }
+    /** Where a monorepo package's own folder is for an import of it (`@acme/lib`, `@acme/lib/hooks/x`), if it is one. */
+    workspaceTargets(moduleName) {
+        let best;
+        for (const [name, dir] of this.workspacePackages) {
+            if ((moduleName === name || moduleName.startsWith(`${name}/`)) && (!best || name.length > best.name.length)) {
+                best = { name, dir };
+            }
+        }
+        if (!best)
+            return [];
+        const sub = moduleName.slice(best.name.length + 1);
+        // the package's sources may sit in src/ while its package.json points at a build that is not there
+        return [path_1.default.join(best.dir, sub), path_1.default.join(best.dir, "src", sub)];
+    }
+    resolveImport(moduleName, containingFile, redirectedReference, mode) {
+        const options = this.optionsFor(containingFile);
+        const cache = this.cacheFor(options);
+        const resolved = typescript_1.default.resolveModuleName(moduleName, containingFile, options, this.host, cache, redirectedReference, mode);
+        if (resolved.resolvedModule)
+            return resolved;
+        // not installed, so no node_modules link: a package of this very monorepo is found by its folder
+        for (const target of this.workspaceTargets(moduleName)) {
+            const viaWorkspace = typescript_1.default.resolveModuleName(target, containingFile, options, this.host, cache, redirectedReference, mode);
+            if (viaWorkspace.resolvedModule)
+                return viaWorkspace;
+        }
+        return resolved;
+    }
+    /**
+     * Alias options (`paths`, `baseUrl`) of the first referenced tsconfig that defines `paths`. A
+     * reference that is unreadable or has no aliases is skipped; only aliases are taken, never the files.
+     */
+    pathOptionsFromReferences(references) {
+        for (const reference of references ?? []) {
+            const referenced = typescript_1.default.sys.directoryExists(reference.path)
+                ? path_1.default.join(reference.path, "tsconfig.json")
+                : reference.path;
+            const config = typescript_1.default.readConfigFile(referenced, typescript_1.default.sys.readFile);
+            if (config.error)
+                continue;
+            const { options } = typescript_1.default.parseJsonConfigFileContent(config.config, typescript_1.default.sys, path_1.default.dirname(referenced));
+            if (options.paths) {
+                const { paths, baseUrl, pathsBasePath } = options;
+                return { paths, baseUrl, pathsBasePath };
+            }
+        }
+        return {};
+    }
     resolveLanguageVersion(languageVersionOrOptions) {
         if (typeof languageVersionOrOptions === "object") {
             return languageVersionOrOptions.languageVersion;
@@ -127,6 +256,7 @@ class CompilerContext {
             const normalized = this.normalize(fileName);
             return this.registry.has(normalized) || fs_1.default.existsSync(normalized);
         };
+        this.host.resolveModuleNameLiterals = (literals, containingFile, redirectedReference, _options, containingSourceFile) => literals.map((literal) => this.resolveImport(literal.text, containingFile, redirectedReference, typescript_1.default.getModeForUsageLocation(containingSourceFile, literal, this.compilerOptions)));
         this.host.getCanonicalFileName = (f) => this.normalize(f);
         this.host.useCaseSensitiveFileNames = () => true;
         this.host.getCurrentDirectory = () => this.rootDir;
@@ -146,7 +276,29 @@ class CompilerContext {
         return typescript_1.default.ScriptKind.Unknown;
     }
     rebuildProgram() {
-        this.programInstance = typescript_1.default.createProgram([...this.rootNames], this.compilerOptions, this.host);
+        // options are re-read from disk with every build, so an edited nested tsconfig.json is seen
+        this.optionsByDir.clear();
+        this.withSharedCaches(() => {
+            this.programInstance = typescript_1.default.createProgram([...this.rootNames], this.compilerOptions, this.host);
+        });
+    }
+    /**
+     * Imports resolved while `fn` runs share caches, as they do in TypeScript's own host. Files may appear or
+     * go between runs, so nothing is kept after the outermost one; a run started inside another (a lazy
+     * program build inside a batch) joins it instead of dropping its caches.
+     */
+    withSharedCaches(fn) {
+        if (this.cachingDepth === 0)
+            this.resolutionCaches.clear();
+        this.cachingDepth++;
+        try {
+            return fn();
+        }
+        finally {
+            this.cachingDepth--;
+            if (this.cachingDepth === 0)
+                this.resolutionCaches.clear();
+        }
     }
     get program() {
         if (!this.programInstance) {
@@ -160,16 +312,7 @@ class CompilerContext {
      * same directory lookups. The cache is dropped when `fn` returns.
      */
     withResolutionCache(fn) {
-        if (this.activeResolutionCache) {
-            return fn();
-        }
-        this.activeResolutionCache = typescript_1.default.createModuleResolutionCache(this.rootDir, (fileName) => this.normalize(fileName), this.compilerOptions);
-        try {
-            return fn();
-        }
-        finally {
-            this.activeResolutionCache = undefined;
-        }
+        return this.withSharedCaches(fn);
     }
     /** Register file content without rebuilding the TS program (batch via {@link flushUpdates}). */
     stageFile(fileName, content) {
@@ -271,8 +414,7 @@ class CompilerContext {
         ];
     }
     resolveModule(moduleName, fromFile) {
-        const resolved = typescript_1.default.resolveModuleName(moduleName, this.normalize(fromFile), this.compilerOptions, this.host, this.activeResolutionCache);
-        return resolved.resolvedModule?.resolvedFileName;
+        return this.resolveImport(moduleName, this.normalize(fromFile)).resolvedModule?.resolvedFileName;
     }
     getResolvedModules(fileName) {
         const source = this.getSourceFile(fileName);

package/dist/compiler/workspacePackages.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findWorkspacePackages = findWorkspacePackages;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const projectDependencies_1 = require("../cli/projectDependencies");
+function readJson(file) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The packages of a monorepo (`workspaces` in package.json, or pnpm-workspace.yaml) by name, mapped to
+ * their folder. `import "@acme/lib/hooks/x"` then resolves to a folder of the repo itself, so a project
+ * whose dependencies are not installed still links its own packages together.
+ */
+function findWorkspacePackages(rootDir) {
+    const packages = new Map();
+    const rootPackage = readJson(path_1.default.join(rootDir, "package.json"));
+    if (!rootPackage)
+        return packages;
+    const workspaces = rootPackage.workspaces;
+    const fromPackageJson = Array.isArray(workspaces)
+        ? (0, projectDependencies_1.stringList)(workspaces)
+        : (0, projectDependencies_1.stringList)(workspaces?.packages);
+    let fromPnpm = [];
+    try {
+        fromPnpm = (0, projectDependencies_1.pnpmWorkspacePatterns)(fs_1.default.readFileSync(path_1.default.join(rootDir, "pnpm-workspace.yaml"), "utf8"));
+    }
+    catch {
+        // no pnpm-workspace.yaml (or an unreadable one): the package.json patterns are all there is
+    }
+    const patterns = [...fromPackageJson, ...fromPnpm].filter(projectDependencies_1.staysInsideProject);
+    if (patterns.length === 0)
+        return packages;
+    let members;
+    try {
+        members = fast_glob_1.default.sync(patterns.map(projectDependencies_1.memberGlob), { cwd: rootDir, ignore: ["**/node_modules/**"] });
+    }
+    catch {
+        // a pattern fast-glob rejects: no members
+        return packages;
+    }
+    for (const member of members.slice(0, projectDependencies_1.MAX_WORKSPACE_PACKAGES)) {
+        const name = readJson(path_1.default.join(rootDir, member))?.name;
+        if (typeof name === "string" && name !== "" && !packages.has(name)) {
+            packages.set(name, path_1.default.dirname(path_1.default.join(rootDir, member)));
+        }
+    }
+    return packages;
+}

package/dist/config/config.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOCAL_CONFIG_NAME = exports.CONFIG_NAME = void 0;
+exports.INIT_EXCLUDE = exports.LOCAL_CONFIG_NAME = exports.CONFIG_NAME = void 0;
 exports.normalizeConfig = normalizeConfig;
 exports.loadConfig = loadConfig;
 exports.describeConfigProblem = describeConfigProblem;
@@ -22,7 +22,22 @@ exports.CONFIG_NAME = "eventra.json";
  */
 exports.LOCAL_CONFIG_NAME = "eventra.local.json";
 const DEFAULT_INCLUDE = ["**/*.{ts,tsx,js,jsx}"];
+// what a config without `sync.exclude` has always skipped; changing it would change the scan of every
+// existing project that never wrote its own list
 const DEFAULT_EXCLUDE = ["node_modules", "dist", ".next", ".git"];
+/**
+ * What `eventra init` writes into a new eventra.json: the default above plus folders and files whose
+ * code is not the product. Events fired from a test are not features, and on a large repository the tests
+ * alone can double the files scanned. Written out, so it is visible and editable. `build` and `out` are
+ * left out on purpose: they are as likely to be a source folder as output.
+ */
+exports.INIT_EXCLUDE = [
+    ...DEFAULT_EXCLUDE,
+    "coverage",
+    "**/*.{test,spec}.{ts,tsx,js,jsx}",
+    "**/__tests__/**",
+    "**/__mocks__/**",
+];
 function normalizeSinks(sinks) {
     if (!Array.isArray(sinks))
         return [];

package/dist/core/EventraEngine.js

@@ -14,6 +14,7 @@ const resolvedCallCache_1 = require("../analysis/cache/resolvedCallCache");
 const resolvedExportCache_1 = require("../analysis/cache/resolvedExportCache");
 const returnPropagationCache_1 = require("../analysis/cache/returnPropagationCache");
 const analyzeFile_1 = require("../analysis/engine/analyzeFile");
+const wrapperChains_1 = require("../analysis/scanner/wrapperChains");
 const wrapperRegistry_1 = require("../analysis/symbols/wrapperRegistry");
 const loadPlugins_1 = require("../plugin/loadPlugins");
 const EMPTY_RESULT = () => ({
@@ -117,6 +118,17 @@ class EventraEngine {
         for (const sf of sources) {
             this.indexFile(sf.fileName, config);
         }
+        this.resolveWrapperChains();
+    }
+    // Wrappers that reach a sink only through another wrapper (`trackEvent` -> `capture` -> the SDK
+    // call) need every file indexed first, so this runs after the files are indexed, never per file.
+    resolveWrapperChains() {
+        const found = (0, wrapperChains_1.resolveWrapperChains)(this.fileIndices.values(), this.compiler.getChecker(), this.wrapperRegistry, this.resolvedCallCache, this.resolvedExportCache);
+        for (const [file, wrappers] of found) {
+            const index = this.fileIndices.get(file);
+            const kept = index.wrappers.filter((w) => !wrappers.some((n) => n.declaration === w.declaration));
+            this.fileIndices.set(file, { ...index, wrappers: [...kept, ...wrappers] });
+        }
     }
     beginPreload() {
         this.isPreloading = true;
@@ -213,6 +225,7 @@ class EventraEngine {
             this.scannedFiles.add(file);
             this.indexFile(file, config);
         }
+        this.resolveWrapperChains();
         for (const file of normalized) {
             this.extractFile(file, config);
         }
@@ -310,6 +323,7 @@ class EventraEngine {
         this.scannedFiles.add(this.normalize(fileName));
         this.refreshChecker();
         this.indexFile(fileName, config);
+        this.resolveWrapperChains();
         return this.extractFile(fileName, config);
     }
     async removeFile(fileName, config) {

package/dist/index.js

@@ -39,45 +39,53 @@ var __importDefault = (this && this.__importDefault) || function (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(package_json_1.default.version);
-program
-    .command("init")
-    .option("-y, --yes", "do not prompt: accept defaults and keep an existing eventra.json")
-    .action(async (opts) => {
-    const { init } = await Promise.resolve().then(() => __importStar(require("./cli/init")));
-    await init({ yes: opts.yes });
+const respawn_1 = require("./respawn");
+// a large repository can need more memory than Node's default: start again with enough
+(0, respawn_1.respawnWithMoreHeap)().then((respawned) => {
+    if (!respawned)
+        run();
 });
-program
-    .command("sync")
-    .option("--strict", "exit with a non-zero code if any file could not be analysed")
-    .action(async (opts) => {
-    const { sync } = await Promise.resolve().then(() => __importStar(require("./cli/sync")));
-    await sync({ strict: opts.strict });
-});
-program
-    .command("check")
-    .option("--fix", "auto fix issues")
-    .option("--strict", "exit with a non-zero code if any file could not be analysed")
-    .action(async (opts) => {
-    const { check } = await Promise.resolve().then(() => __importStar(require("./cli/check")));
-    await check({ fix: opts.fix, strict: opts.strict });
-});
-program
-    .command("watch")
-    .description("Watch files and detect events in real-time")
-    .action(async () => {
-    const { watch } = await Promise.resolve().then(() => __importStar(require("./cli/watch")));
-    await watch();
-});
-program
-    .command("send")
-    .option("--trust-endpoint", "approve the current eventra.json endpoint for local use")
-    .action(async (opts) => {
-    const { send } = await Promise.resolve().then(() => __importStar(require("./cli/send")));
-    await send({ trustEndpoint: opts.trustEndpoint });
-});
-program.parse();
+function run() {
+    const program = new commander_1.Command();
+    program
+        .name("eventra")
+        .description("Eventra CLI")
+        .version(package_json_1.default.version);
+    program
+        .command("init")
+        .option("-y, --yes", "do not prompt: accept defaults and keep an existing eventra.json")
+        .action(async (opts) => {
+        const { init } = await Promise.resolve().then(() => __importStar(require("./cli/init")));
+        await init({ yes: opts.yes });
+    });
+    program
+        .command("sync")
+        .option("--strict", "exit with a non-zero code if any file could not be analysed")
+        .action(async (opts) => {
+        const { sync } = await Promise.resolve().then(() => __importStar(require("./cli/sync")));
+        await sync({ strict: opts.strict });
+    });
+    program
+        .command("check")
+        .option("--fix", "auto fix issues")
+        .option("--strict", "exit with a non-zero code if any file could not be analysed")
+        .action(async (opts) => {
+        const { check } = await Promise.resolve().then(() => __importStar(require("./cli/check")));
+        await check({ fix: opts.fix, strict: opts.strict });
+    });
+    program
+        .command("watch")
+        .description("Watch files and detect events in real-time")
+        .action(async () => {
+        const { watch } = await Promise.resolve().then(() => __importStar(require("./cli/watch")));
+        await watch();
+    });
+    program
+        .command("send")
+        .option("--trust-endpoint", "approve the current eventra.json endpoint for local use")
+        .action(async (opts) => {
+        const { send } = await Promise.resolve().then(() => __importStar(require("./cli/send")));
+        await send({ trustEndpoint: opts.trustEndpoint });
+    });
+    program.parse();
+}