package-build-stats 8.2.3 → 8.2.5

package/build/utils/common.utils.js

@@ -0,0 +1,112 @@
+import childProcess from 'child_process';
+import path from 'path';
+import { builtinModules } from 'module';
+import fs from 'fs';
+import os from 'os';
+const homeDirectory = os.homedir();
+export const getBuiltInModules = () => builtinModules.flatMap(mod => [mod, 'node:' + mod]);
+export function exec(command, options, timeout) {
+    let timerId;
+    return new Promise((resolve, reject) => {
+        const child = childProcess.exec(command, options, (error, stdout, stderr) => {
+            if (error) {
+                reject(stderr);
+            }
+            else {
+                resolve(stdout);
+            }
+            if (timerId) {
+                clearTimeout(timerId);
+            }
+        });
+        if (timeout) {
+            timerId = setTimeout(() => {
+                if (child.pid) {
+                    process.kill(child.pid);
+                }
+                reject(`Execution of ${command.substring(0, 40)}... cancelled as it exceeded a timeout of ${timeout} ms`);
+            }, timeout * 10);
+        }
+    });
+}
+/**
+ * Gets external peerDeps that shouldn't be a
+ * part of the build in a regex format -
+ * /(^dep-a$|^dep-a\/|^dep-b$|^dep-b\/)\//
+ */
+export function getExternals(packageName, installPath) {
+    const packageJSONPath = path.join(installPath, 'node_modules', packageName, 'package.json');
+    const packageJSON = JSON.parse(fs.readFileSync(packageJSONPath, 'utf-8'));
+    const dependencies = Object.keys(packageJSON.dependencies || {});
+    const peerDependencies = Object.keys(packageJSON.peerDependencies || {});
+    // All packages with name same as a built-in node module, but
+    // haven't explicitly been added as an npm dependency or aren't the package itself
+    // are externals
+    const builtInExternals = getBuiltInModules().filter(mod => !dependencies.includes(mod) && mod !== packageName);
+    return {
+        externalPackages: peerDependencies,
+        externalBuiltIns: builtInExternals,
+    };
+}
+function expandTilde(pathString) {
+    return homeDirectory
+        ? pathString.replace(/^~(?=$|\/|\\)/, homeDirectory)
+        : pathString;
+}
+function isLocalPackageString(packageString) {
+    const packageJsonPath = path.resolve(packageString, 'package.json');
+    try {
+        if (fs.existsSync(packageJsonPath)) {
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+function isScopedPackageString(packageString) {
+    return packageString.startsWith('@');
+}
+function parseLocalPackageString(packageString) {
+    const fullPath = path.resolve(packageString, 'package.json');
+    const packageJSON = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+    return {
+        name: packageJSON.name,
+        version: packageJSON.version,
+        scoped: packageJSON.name.startsWith('@'),
+        normalPath: packageString,
+        isLocal: true,
+    };
+}
+function parseScopedPackageString(packageString) {
+    const lastAtIndex = packageString.lastIndexOf('@');
+    return {
+        name: lastAtIndex === 0
+            ? packageString
+            : packageString.substring(0, lastAtIndex),
+        version: lastAtIndex === 0 ? null : packageString.substring(lastAtIndex + 1),
+        scoped: true,
+    };
+}
+function parseUnscopedPackageString(packageString) {
+    const lastAtIndex = packageString.lastIndexOf('@');
+    return {
+        name: lastAtIndex === -1
+            ? packageString
+            : packageString.substring(0, lastAtIndex),
+        version: lastAtIndex === -1 ? null : packageString.substring(lastAtIndex + 1),
+        scoped: false,
+    };
+}
+export function parsePackageString(packageString) {
+    const normalPackageString = expandTilde(packageString);
+    if (isLocalPackageString(normalPackageString)) {
+        return parseLocalPackageString(normalPackageString);
+    }
+    else if (isScopedPackageString(normalPackageString)) {
+        return parseScopedPackageString(normalPackageString);
+    }
+    else {
+        return parseUnscopedPackageString(normalPackageString);
+    }
+}

package/build/utils/exports.utils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Export scanning using oxc-parser and oxc-resolver
+ *
+ * This implementation follows the pattern from oxc-linter's export.rs
+ * using the public npm packages oxc-parser and oxc-resolver.
+ */
+type ResolvedExports = {
+    [key: string]: string;
+};
+/**
+ * Get all exports from a package
+ *
+ * This is the main entry point that matches the API of getAllExports in exports.utils.ts
+ */
+export declare function getAllExports(packageString: string, context: string, lookupPath: string, installPath?: string): Promise<ResolvedExports>;
+/**
+ * Get exports details from code (compatibility function)
+ *
+ * This provides the same API as the existing getExportsDetails for backward compatibility
+ * Returns simple string arrays for exports (without moduleRequest info)
+ */
+export declare function getExportsDetails(code: string, filename?: string): {
+    exports: string[];
+    exportAllLocations: string[];
+};
+export {};

package/build/utils/exports.utils.js

@@ -0,0 +1,192 @@
+/**
+ * Export scanning using oxc-parser and oxc-resolver
+ *
+ * This implementation follows the pattern from oxc-linter's export.rs
+ * using the public npm packages oxc-parser and oxc-resolver.
+ */
+import { parseSync } from 'oxc-parser';
+import { ResolverFactory } from 'oxc-resolver';
+import path from 'path';
+import fs from 'fs/promises';
+import Telemetry from './telemetry.utils.js';
+import { performance } from 'perf_hooks';
+// Initialize resolver with ESM-first configuration
+// - main_fields: ["module", "main"] - prioritize ESM entry points
+// - condition_names: ["import", "default", "require"] - ESM-first export conditions
+//   NOTE: We intentionally exclude "node" because Node.js conditional exports resolution
+//   uses the PACKAGE's exports field order (not our conditionNames order) to determine
+//   priority. Packages like Vue have "node" before "import" in their exports, so including
+//   "node" would resolve to CJS files instead of ESM. We keep "require" as a fallback for
+//   packages that only export via "require" condition.
+// - extensions: all common JS/TS extensions
+// - symlinks: false - keep paths as-is without resolving symlinks (matches enhanced-resolve behavior)
+const resolver = new ResolverFactory({
+    extensions: [
+        '.mjs',
+        '.js',
+        '.mts',
+        '.ts',
+        '.jsx',
+        '.tsx',
+        '.cjs',
+        '.cts',
+        '.json',
+    ],
+    mainFields: ['module', 'main'], // ESM-first: prioritize "module" field over "main"
+    conditionNames: ['import', 'default', 'require'], // ESM-first: exclude "node" which resolves to CJS
+    symlinks: false, // Don't resolve symlinks to match enhanced-resolve behavior
+});
+/**
+ * Extract export information from parsed oxc module
+ */
+function getExportsFromStaticExports(staticExports) {
+    const exports = [];
+    const exportAllLocations = [];
+    staticExports.forEach(staticExport => {
+        staticExport.entries.forEach((entry) => {
+            var _a, _b;
+            // Skip type-only exports (TypeScript type exports)
+            if (entry.isType) {
+                return;
+            }
+            // Handle different export types based on importName kind
+            switch (entry.importName.kind) {
+                case 'AllButDefault': // export * from "mod"
+                case 'All': // export * as ns from "mod"
+                    if (entry.moduleRequest) {
+                        exportAllLocations.push(entry.moduleRequest.value);
+                    }
+                    break;
+                case 'Name': // export { foo } or export { foo } from "mod"
+                case 'None': // export const foo = 1
+                    // Get the export name
+                    if (entry.exportName.kind === 'Name' && entry.exportName.name) {
+                        exports.push({
+                            name: entry.exportName.name,
+                            moduleRequest: (_a = entry.moduleRequest) === null || _a === void 0 ? void 0 : _a.value, // Track the source module for re-exports
+                        });
+                    }
+                    else if (entry.exportName.kind === 'Default') {
+                        exports.push({
+                            name: 'default',
+                            moduleRequest: (_b = entry.moduleRequest) === null || _b === void 0 ? void 0 : _b.value,
+                        });
+                    }
+                    break;
+            }
+        });
+    });
+    return { exports, exportAllLocations };
+}
+/**
+ * Resolve a module path from a given context
+ */
+async function resolveModule(context, lookupPath) {
+    const result = resolver.sync(context, lookupPath);
+    if (!result.path) {
+        throw new Error(`Cannot resolve module '${lookupPath}' from '${context}'`);
+    }
+    return result.path;
+}
+/**
+ * Recursively walk exports following export * statements
+ *
+ * This mirrors the walk_exported_recursive function in export.rs
+ */
+async function walkExportsRecursive(context, lookupPath, visited, rootContext, _isRootCall = false) {
+    // Use rootContext for calculating relative paths, context for resolution
+    const root = rootContext || context;
+    const resolvedPath = await resolveModule(context, lookupPath);
+    // Avoid circular dependencies
+    if (visited.has(resolvedPath)) {
+        return {};
+    }
+    visited.add(resolvedPath);
+    // Parse the file to get exports
+    const code = await fs.readFile(resolvedPath, 'utf8');
+    const parseResult = parseSync(resolvedPath, code, {
+        sourceType: 'module',
+    });
+    // Check if file has module syntax
+    if (!parseResult.module.hasModuleSyntax) {
+        return {};
+    }
+    const { exports, exportAllLocations } = getExportsFromStaticExports(parseResult.module.staticExports);
+    const resolvedExports = {};
+    // Add direct exports from this module, resolving re-exports to their source files
+    for (const exp of exports) {
+        let sourcePath = resolvedPath;
+        // If this is a re-export (export { foo } from './module.js'), resolve to the source file
+        if (exp.moduleRequest) {
+            try {
+                sourcePath = await resolveModule(path.dirname(resolvedPath), exp.moduleRequest);
+            }
+            catch {
+                // If resolution fails, fall back to current file
+                sourcePath = resolvedPath;
+            }
+        }
+        // Use path.relative() to calculate the relative path from root to sourcePath
+        // This works correctly since symlinks are not resolved (symlinks: false in resolver config)
+        const relativePath = root
+            ? path.relative(root, sourcePath)
+            : path.basename(sourcePath);
+        resolvedExports[exp.name] = relativePath;
+    }
+    // Recursively process export * statements
+    const promises = exportAllLocations.map(async (location) => {
+        const starExports = await walkExportsRecursive(path.dirname(resolvedPath), location, visited, root);
+        // Merge star exports into our exports
+        Object.keys(starExports).forEach(expKey => {
+            resolvedExports[expKey] = starExports[expKey];
+        });
+    });
+    await Promise.all(promises);
+    return resolvedExports;
+}
+/**
+ * Get all exports from a package
+ *
+ * This is the main entry point that matches the API of getAllExports in exports.utils.ts
+ */
+export async function getAllExports(packageString, context, lookupPath, installPath) {
+    const startTime = performance.now();
+    const visited = new Set();
+    try {
+        // Read package.json to get the entry point
+        const packageJsonPath = path.join(context, 'package.json');
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+        // Prefer module field for ESM, fallback to main, then default
+        let entryPoint = packageJson.module || packageJson.main || './index.js';
+        // Normalize entry point to start with ./
+        if (!entryPoint.startsWith('./') && !entryPoint.startsWith('../')) {
+            entryPoint = './' + entryPoint;
+        }
+        // Resolve the entry point relative to context
+        // Pass installPath as rootContext for calculating relative paths
+        const results = await walkExportsRecursive(context, entryPoint, visited, installPath, true);
+        Telemetry.walkPackageExportsTree(packageString, startTime, true);
+        return results;
+    }
+    catch (err) {
+        Telemetry.walkPackageExportsTree(packageString, startTime, false, err);
+        throw err;
+    }
+}
+/**
+ * Get exports details from code (compatibility function)
+ *
+ * This provides the same API as the existing getExportsDetails for backward compatibility
+ * Returns simple string arrays for exports (without moduleRequest info)
+ */
+export function getExportsDetails(code, filename = 'module.js') {
+    const parseResult = parseSync(filename, code, {
+        sourceType: 'module',
+    });
+    const result = getExportsFromStaticExports(parseResult.module.staticExports);
+    // Return simple string array for backward compatibility
+    return {
+        exports: result.exports.map(exp => exp.name),
+        exportAllLocations: result.exportAllLocations,
+    };
+}

package/build/utils/installation.utils.d.ts

@@ -0,0 +1,9 @@
+import { InstallPackageOptions } from '../common.types.js';
+declare const InstallationUtils: {
+    getInstallPath(packageName: string): string;
+    preparePath(packageName: string, clientOption?: "npm" | "yarn" | "pnpm" | "bun" | Array<"npm" | "yarn" | "pnpm" | "bun">): Promise<string>;
+    installPackage(packageString: string, installPath: string, installOptions: InstallPackageOptions): Promise<void>;
+    _installWithClient(packageString: string, installPath: string, installOptions: InstallPackageOptions, currentClient: "npm" | "yarn" | "pnpm" | "bun"): Promise<void>;
+    cleanupPath(installPath: string): Promise<void>;
+};
+export default InstallationUtils;

package/build/utils/installation.utils.js

@@ -0,0 +1,203 @@
+import { rimraf } from 'rimraf';
+import path from 'path';
+import fs from 'fs/promises';
+import sanitize from 'sanitize-filename';
+import { randomUUID } from 'crypto';
+import createDebug from 'debug';
+const debug = createDebug('bp:worker');
+import { InstallError, PackageNotFoundError } from '../errors/CustomError.js';
+import { exec } from './common.utils.js';
+import config from '../config/config.js';
+import Telemetry from './telemetry.utils.js';
+import { performance } from 'perf_hooks';
+// When operating on a local directory, force npm to copy directory structure
+// and all dependencies instead of just symlinking files
+const wrapPackCommand = (packagePath) => `$(npm pack --ignore-scripts ${packagePath} | tail -1)`;
+const InstallationUtils = {
+    getInstallPath(packageName) {
+        const id = randomUUID().slice(0, 8);
+        return path.join(config.tmp, 'packages', sanitize(`build-${packageName}-${id}`));
+    },
+    async preparePath(packageName, clientOption) {
+        const startTime = performance.now();
+        const installPath = InstallationUtils.getInstallPath(packageName);
+        if (process.env.DEBUG_TIMING) {
+            console.log(`[TIMING] preparePath.getInstallPath: ${(performance.now() - startTime).toFixed(2)}ms`);
+        }
+        const step1 = performance.now();
+        await fs.mkdir(config.tmp, { recursive: true });
+        await fs.mkdir(installPath, { recursive: true });
+        if (process.env.DEBUG_TIMING) {
+            console.log(`[TIMING] preparePath.mkdir: ${(performance.now() - step1).toFixed(2)}ms`);
+        }
+        const step2 = performance.now();
+        // Check if yarn is being used (either as single value or in array)
+        const clients = clientOption
+            ? Array.isArray(clientOption)
+                ? clientOption
+                : [clientOption]
+            : [];
+        const isUsingYarn = clients.includes('yarn');
+        const packageJson = {
+            dependencies: {},
+            browserslist: [
+                'last 5 Chrome versions',
+                'last 5 Firefox versions',
+                'Safari >= 9',
+                'edge >= 12',
+            ],
+        };
+        // Add packageManager field if yarn is being used (required by corepack)
+        if (isUsingYarn) {
+            packageJson.packageManager = 'yarn@1.22.22';
+        }
+        await fs.writeFile(path.join(installPath, 'package.json'), JSON.stringify(packageJson));
+        if (process.env.DEBUG_TIMING) {
+            console.log(`[TIMING] preparePath.writeFile: ${(performance.now() - step2).toFixed(2)}ms`);
+            console.log(`[TIMING] preparePath.total: ${(performance.now() - startTime).toFixed(2)}ms`);
+        }
+        return installPath;
+    },
+    async installPackage(packageString, installPath, installOptions) {
+        const { client = ['bun', 'npm'], // Default: try bun first, fallback to npm
+        limitConcurrency: _limitConcurrency, networkConcurrency: _networkConcurrency, additionalPackages: _additionalPackages = [], isLocal: _isLocal, installTimeout: _installTimeout = 45000, } = installOptions;
+        // Normalize client to array
+        const clients = Array.isArray(client) ? client : [client];
+        // Try each client in order until one succeeds
+        let lastError = null;
+        for (let i = 0; i < clients.length; i++) {
+            const currentClient = clients[i];
+            const isLastClient = i === clients.length - 1;
+            try {
+                await InstallationUtils._installWithClient(packageString, installPath, {
+                    ...installOptions,
+                    client: currentClient,
+                }, currentClient);
+                // Success! Log which client was used
+                if (installOptions.debug || process.env.DEBUG_TIMING) {
+                    console.log(`[INSTALL] Successfully installed with ${currentClient}`);
+                }
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                if (!isLastClient) {
+                    // Try next client
+                    debug(`Installation with ${currentClient} failed, trying next client...`);
+                    if (installOptions.debug) {
+                        console.log(`[INSTALL] ${currentClient} failed, trying ${clients[i + 1]}...`);
+                    }
+                }
+            }
+        }
+        // All clients failed
+        throw lastError;
+    },
+    async _installWithClient(packageString, installPath, installOptions, currentClient) {
+        let flags, command;
+        let installStartTime = performance.now();
+        const { limitConcurrency, networkConcurrency, additionalPackages = [], isLocal, installTimeout = 45000, } = installOptions;
+        if (currentClient === 'yarn') {
+            flags = [
+                'ignore-flags',
+                'ignore-engines',
+                'skip-integrity-check',
+                'exact',
+                'json',
+                'no-progress',
+                'silent',
+                'no-lockfile',
+                'no-bin-links',
+                'ignore-optional',
+            ];
+            if (limitConcurrency) {
+                flags.push('mutex network');
+            }
+            if (networkConcurrency) {
+                flags.push(`network-concurrency ${networkConcurrency}`);
+            }
+            command = `yarn add ${packageString} ${additionalPackages.join(' ')} --${flags.join(' --')}`;
+        }
+        else if (currentClient === 'npm') {
+            flags = [
+                // Setting cache is required for concurrent `npm install`s to work
+                `cache=${path.join(config.tmp, 'cache')}`,
+                'no-package-lock',
+                'no-shrinkwrap',
+                'legacy-peer-deps',
+                'no-optional',
+                'no-bin-links',
+                'progress false',
+                'loglevel error',
+                'ignore-scripts',
+                'save-exact',
+                'production',
+                'json',
+            ];
+            command = `npm install ${isLocal ? wrapPackCommand(packageString) : packageString} ${additionalPackages.join(' ')} --${flags.join(' --')}`;
+        }
+        else if (currentClient === 'pnpm') {
+            flags = ['no-optional', 'loglevel error', 'ignore-scripts', 'save-exact'];
+            command = `pnpm add ${packageString} ${additionalPackages.join(' ')} --${[].join(' --')}`;
+        }
+        else if (currentClient === 'bun') {
+            flags = [
+                'no-save', // Don't update package.json or save lockfile
+                'production', // Don't install devDependencies
+                'ignore-scripts', // Skip lifecycle scripts
+                'no-progress', // Disable progress bar
+                'silent', // Don't log anything
+            ];
+            // Add network concurrency if specified
+            if (networkConcurrency) {
+                flags.push(`network-concurrency=${networkConcurrency}`);
+            }
+            command = `bun add ${packageString} ${additionalPackages.join(' ')} --cache-dir=${path.join(config.tmp, 'cache', 'bun')} --${flags.join(' --')}`;
+        }
+        else {
+            console.error('No valid client specified');
+            process.exit(1);
+        }
+        debug('install start %s', packageString);
+        try {
+            const execStartTime = performance.now();
+            await exec(command, {
+                cwd: installPath,
+                maxBuffer: 1024 * 500,
+            }, installTimeout);
+            const execDuration = performance.now() - execStartTime;
+            if (process.env.DEBUG_TIMING) {
+                console.log(`[TIMING] installPackage.exec (${currentClient}): ${execDuration.toFixed(2)}ms`);
+            }
+            debug('install finish %s', packageString);
+            Telemetry.installPackage(packageString, true, installStartTime, {
+                ...installOptions,
+                client: currentClient,
+            });
+        }
+        catch (err) {
+            if (installOptions.debug || process.env.DEBUG_TIMING) {
+                console.log(`[INSTALL ERROR] ${currentClient}:`, err);
+            }
+            Telemetry.installPackage(packageString, false, installStartTime, {
+                ...installOptions,
+                client: currentClient,
+            });
+            if (typeof err === 'string' && err.includes('code E404')) {
+                throw new PackageNotFoundError(err);
+            }
+            else {
+                throw new InstallError(err);
+            }
+        }
+    },
+    async cleanupPath(installPath) {
+        try {
+            await rimraf(installPath);
+        }
+        catch (err) {
+            console.error('cleaning up path ', installPath, ' failed due to ', err);
+        }
+    },
+};
+export default InstallationUtils;

package/build/utils/telemetry.utils.d.ts

@@ -0,0 +1,17 @@
+import type { Emitter, EventType } from 'mitt';
+type Events = Record<EventType, unknown>;
+declare const emitter: Emitter<Events>;
+export { emitter };
+export default class Telemetry {
+    static installPackage(packageString: string, isSuccessful: boolean, startTime: number, options: any, error?: any): void;
+    static getPackageJSONDetails(packageName: string, isSuccessful: boolean, startTime: number, error?: any): void;
+    static buildPackage(packageName: string, isSuccessful: boolean, startTime: number, options: any, error?: any): void;
+    static compilePackage(packageName: string, isSuccessful: boolean, startTime: number, options: any, error?: any): void;
+    static packageStats(packageString: string, isSuccessful: boolean, startTime: number, options: any, error?: any): void;
+    static parseWebpackStats(packageName: string, isSuccessful: boolean, startTime: number, error?: any): void;
+    static dependencySizes(packageName: string, startTime: number, isSuccessful: boolean, options: any, error?: any): void;
+    static assetsGZIPParseTime(packageName: string, startTime: number): void;
+    static walkPackageExportsTree(packageString: string, startTime: number, isSuccessful: boolean, error?: any): void;
+    static packageExports(packageString: string, startTime: number, isSuccessful: boolean, error?: any): void;
+    static packageExportsSizes(packageString: string, startTime: number, isSuccessful: boolean, options: any, error?: any): void;
+}

package/build/utils/telemetry.utils.js

@@ -0,0 +1,121 @@
+import mitt from 'mitt';
+import { parsePackageString } from './common.utils.js';
+import { performance } from 'perf_hooks';
+import _ from 'lodash';
+import createDebug from 'debug';
+const debug = createDebug('bp-telemetry');
+const emitter = mitt();
+export { emitter };
+emitter.on('*', (type, data) => {
+    debug('Telementry Event: %s  %o', type, data);
+});
+function errorToObject(error) {
+    if (!error)
+        return;
+    if (error && typeof error === 'object') {
+        const errorObject = {};
+        Object.getOwnPropertyNames(error).forEach(key => {
+            // @ts-ignore
+            errorObject[key] =
+                typeof error[key] === 'object'
+                    ? errorToObject(error[key])
+                    : String(error[key]).substring(0, 40);
+        });
+        return errorObject;
+    }
+    return { error };
+}
+export default class Telemetry {
+    static installPackage(packageString, isSuccessful, startTime, options, error = null) {
+        emitter.emit('TASK_PACKAGE_INSTALL', {
+            package: parsePackageString(packageString),
+            isSuccessful,
+            duration: performance.now() - startTime,
+            options,
+            error: errorToObject(error),
+        });
+    }
+    static getPackageJSONDetails(packageName, isSuccessful, startTime, error = null) {
+        emitter.emit('TASK_PACKAGE_JSON_DETAILS', {
+            package: { name: packageName },
+            isSuccessful,
+            duration: performance.now() - startTime,
+            error: errorToObject(error),
+        });
+    }
+    static buildPackage(packageName, isSuccessful, startTime, options, error = null) {
+        emitter.emit('TASK_PACKAGE_BUILD', {
+            package: { name: packageName },
+            isSuccessful,
+            duration: performance.now() - startTime,
+            options: _.omit(options, 'customImports'),
+            error: errorToObject(error),
+        });
+    }
+    static compilePackage(packageName, isSuccessful, startTime, options, error = null) {
+        emitter.emit('TASK_PACKAGE_COMPILE', {
+            packageName,
+            isSuccessful,
+            duration: performance.now() - startTime,
+            options,
+            error: errorToObject(error),
+        });
+    }
+    static packageStats(packageString, isSuccessful, startTime, options, error = null) {
+        emitter.emit('TASK_PACKAGE_STATS', {
+            package: parsePackageString(packageString),
+            isSuccessful,
+            duration: performance.now() - startTime,
+            options,
+            error: errorToObject(error),
+        });
+    }
+    static parseWebpackStats(packageName, isSuccessful, startTime, error = null) {
+        emitter.emit('TASK_PACKAGE_PARSE_WEBPACK_STATS', {
+            package: { name: packageName },
+            isSuccessful,
+            duration: performance.now() - startTime,
+            error: errorToObject(error),
+        });
+    }
+    static dependencySizes(packageName, startTime, isSuccessful, options, error = null) {
+        emitter.emit('TASK_PACKAGE_DEPENDENCY_SIZES', {
+            package: { name: packageName },
+            duration: performance.now() - startTime,
+            isSuccessful,
+            options,
+            error: errorToObject(error),
+        });
+    }
+    static assetsGZIPParseTime(packageName, startTime) {
+        emitter.emit('TASK_PACKAGE_ASSETS_GZIP_PARSE_TIME', {
+            package: { name: packageName },
+            duration: performance.now() - startTime,
+        });
+    }
+    static walkPackageExportsTree(packageString, startTime, isSuccessful, error = null) {
+        emitter.emit('TASK_PACKAGE_EXPORTS_TREEWALK', {
+            package: parsePackageString(packageString),
+            isSuccessful,
+            duration: performance.now() - startTime,
+            error: errorToObject(error),
+        });
+    }
+    static packageExports(packageString, startTime, isSuccessful, error = null) {
+        emitter.emit('TASK_PACKAGE_EXPORTS', {
+            package: parsePackageString(packageString),
+            isSuccessful,
+            duration: performance.now() - startTime,
+            error: errorToObject(error),
+        });
+    }
+    static packageExportsSizes(packageString, startTime, isSuccessful, options, error = null) {
+        emitter.emit('TASK_PACKAGE_EXPORTS_SIZES', {
+            package: parsePackageString(packageString),
+            duration: performance.now() - startTime,
+            isSuccessful,
+            error: errorToObject(error),
+            options,
+        });
+    }
+}