package-build-stats 8.2.3 → 8.2.5

package/build/getPackageExportSizes.js

@@ -0,0 +1,95 @@
+import Telemetry from './utils/telemetry.utils.js';
+import { performance } from 'perf_hooks';
+import path from 'path';
+import createDebug from 'debug';
+const debug = createDebug('bp:worker');
+import { getExternals, parsePackageString } from './utils/common.utils.js';
+import { getAllExports } from './utils/exports.utils.js';
+import InstallationUtils from './utils/installation.utils.js';
+import BuildUtils from './utils/build.utils.js';
+async function installPackage(packageString, installPath, options) {
+    const { isLocal } = parsePackageString(packageString);
+    await InstallationUtils.installPackage(packageString, installPath, {
+        isLocal,
+        client: options.client,
+        limitConcurrency: options.limitConcurrency,
+        networkConcurrency: options.networkConcurrency,
+        installTimeout: options.installTimeout,
+    });
+}
+export async function getAllPackageExports(packageString, options = {}) {
+    const startTime = performance.now();
+    const { name: packageName, normalPath } = parsePackageString(packageString);
+    const installPath = await InstallationUtils.preparePath(packageName);
+    try {
+        await installPackage(packageString, installPath, options);
+        // The package is installed in node_modules subdirectory
+        const packagePath = normalPath || path.join(installPath, 'node_modules', packageName);
+        const results = await getAllExports(packageString, packagePath, packageName, installPath);
+        Telemetry.packageExports(packageString, startTime, true);
+        return results;
+    }
+    catch (err) {
+        Telemetry.packageExports(packageString, startTime, false, err);
+        throw err;
+    }
+    finally {
+        await InstallationUtils.cleanupPath(installPath);
+    }
+}
+export async function getPackageExportSizes(packageString, options = {}) {
+    const startTime = performance.now();
+    const timings = {};
+    const { name: packageName, normalPath } = parsePackageString(packageString);
+    const preparePathStart = performance.now();
+    const installPath = await InstallationUtils.preparePath(packageName);
+    timings.preparePath = performance.now() - preparePathStart;
+    console.log(`[PERF] [ExportSizes] preparePath: ${timings.preparePath.toFixed(2)}ms`);
+    try {
+        const installStart = performance.now();
+        await installPackage(packageString, installPath, options);
+        timings.install = performance.now() - installStart;
+        console.log(`[PERF] [ExportSizes] installPackage: ${timings.install.toFixed(2)}ms`);
+        // The package is installed in node_modules subdirectory
+        const packagePath = normalPath || path.join(installPath, 'node_modules', packageName);
+        const getAllExportsStart = performance.now();
+        const exportMap = await getAllExports(packageString, packagePath, packageName, installPath);
+        timings.getAllExports = performance.now() - getAllExportsStart;
+        console.log(`[PERF] [ExportSizes] getAllExports: ${timings.getAllExports.toFixed(2)}ms`);
+        const exports = Object.keys(exportMap).filter(exp => !(exp === 'default'));
+        debug('Got %d exports for %s', exports.length, packageString);
+        console.log(`[PERF] [ExportSizes] Found ${exports.length} exports`);
+        const externalsStart = performance.now();
+        const externals = getExternals(packageName, installPath);
+        timings.getExternals = performance.now() - externalsStart;
+        console.log(`[PERF] [ExportSizes] getExternals: ${timings.getExternals.toFixed(2)}ms`);
+        const buildStart = performance.now();
+        const builtDetails = await BuildUtils.buildPackageIgnoringMissingDeps({
+            name: packageName,
+            installPath,
+            externals,
+            options: {
+                customImports: exports,
+                splitCustomImports: true,
+                includeDependencySizes: false,
+            },
+        });
+        timings.build = performance.now() - buildStart;
+        console.log(`[PERF] [ExportSizes] buildPackage: ${timings.build.toFixed(2)}ms`);
+        Telemetry.packageExportsSizes(packageString, startTime, true, options);
+        return {
+            ...builtDetails,
+            assets: builtDetails.assets.map(asset => ({
+                ...asset,
+                path: exportMap[asset.name],
+            })),
+        };
+    }
+    catch (err) {
+        Telemetry.packageExportsSizes(packageString, startTime, false, options, err);
+        throw err;
+    }
+    finally {
+        await InstallationUtils.cleanupPath(installPath);
+    }
+}

package/build/getPackageStats.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Parts of the code are inspired from the `import-cost` project
+ * @see https://github.com/wix/import-cost/blob/master/packages/import-cost/src/webpack.js
+ */
+import { GetPackageStatsOptions } from './common.types.js';
+export default function getPackageStats(packageString: string, options?: GetPackageStatsOptions): Promise<{
+    size: number;
+    gzip: number;
+    assets: Array<{
+        name: string;
+        type: string;
+        size: number;
+        gzip: number;
+    }>;
+    dependencySizes?: Array<{
+        name: string;
+        approximateSize: number;
+    }>;
+    ignoredMissingDependencies?: Array<string>;
+    dependencyCount?: number | undefined;
+    hasJSNext?: any;
+    hasJSModule?: any;
+    isModuleType?: boolean | undefined;
+    hasSideEffects?: any;
+    peerDependencies?: string[] | undefined;
+}>;

package/build/getPackageStats.js

@@ -0,0 +1,98 @@
+/**
+ * Parts of the code are inspired from the `import-cost` project
+ * @see https://github.com/wix/import-cost/blob/master/packages/import-cost/src/webpack.js
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { getExternals, parsePackageString } from './utils/common.utils.js';
+import InstallationUtils from './utils/installation.utils.js';
+import BuildUtils from './utils/build.utils.js';
+import { UnexpectedBuildError } from './errors/CustomError.js';
+import Telemetry from './utils/telemetry.utils.js';
+import { performance } from 'perf_hooks';
+function getPackageJSONDetails(packageName, installPath) {
+    const startTime = performance.now();
+    const packageJSONPath = path.join(installPath, 'node_modules', packageName, 'package.json');
+    return fs.readFile(packageJSONPath, 'utf8').then((contents) => {
+        const parsedJSON = JSON.parse(contents);
+        Telemetry.getPackageJSONDetails(packageName, true, startTime);
+        return {
+            dependencyCount: 'dependencies' in parsedJSON
+                ? Object.keys(parsedJSON.dependencies).length
+                : 0,
+            hasJSNext: parsedJSON['jsnext:main'] || false,
+            hasJSModule: parsedJSON['module'] || false,
+            isModuleType: parsedJSON['type'] === 'module',
+            hasSideEffects: 'sideEffects' in parsedJSON ? parsedJSON['sideEffects'] : true,
+            peerDependencies: 'peerDependencies' in parsedJSON
+                ? Object.keys(parsedJSON.peerDependencies)
+                : [],
+        };
+    }, err => {
+        Telemetry.getPackageJSONDetails(packageName, false, startTime, err);
+    });
+}
+export default async function getPackageStats(packageString, options = {}) {
+    const startTime = performance.now();
+    const timings = {};
+    const { name: packageName, isLocal } = parsePackageString(packageString);
+    const preparePathStart = performance.now();
+    const installPath = await InstallationUtils.preparePath(packageName, options.client);
+    timings.preparePath = performance.now() - preparePathStart;
+    console.log(`[PERF] preparePath: ${timings.preparePath.toFixed(2)}ms`);
+    try {
+        const installStart = performance.now();
+        await InstallationUtils.installPackage(packageString, installPath, {
+            isLocal,
+            client: options.client,
+            limitConcurrency: options.limitConcurrency,
+            networkConcurrency: options.networkConcurrency,
+            installTimeout: options.installTimeout,
+        });
+        timings.install = performance.now() - installStart;
+        console.log(`[PERF] installPackage: ${timings.install.toFixed(2)}ms`);
+        const externalsStart = performance.now();
+        const externals = getExternals(packageName, installPath);
+        timings.getExternals = performance.now() - externalsStart;
+        console.log(`[PERF] getExternals: ${timings.getExternals.toFixed(2)}ms`);
+        const parallelStart = performance.now();
+        const [pacakgeJSONDetails, builtDetails] = await Promise.all([
+            getPackageJSONDetails(packageName, installPath),
+            BuildUtils.buildPackageIgnoringMissingDeps({
+                name: packageName,
+                installPath,
+                externals,
+                options: {
+                    debug: options.debug,
+                    minify: options.minify !== false,
+                    customImports: options.customImports,
+                    includeDependencySizes: true,
+                },
+            }),
+        ]);
+        timings.parallelBuild = performance.now() - parallelStart;
+        console.log(`[PERF] parallel (packageJSON + build): ${timings.parallelBuild.toFixed(2)}ms`);
+        const hasCSSAsset = builtDetails.assets.some(asset => asset.type === 'css');
+        const mainAsset = builtDetails.assets.find(asset => asset.name === 'main' && asset.type === (hasCSSAsset ? 'css' : 'js'));
+        if (!mainAsset) {
+            throw new UnexpectedBuildError('Did not find a main asset in the built bundle');
+        }
+        const totalTime = performance.now() - startTime;
+        Telemetry.packageStats(packageString, true, totalTime, options);
+        return {
+            ...pacakgeJSONDetails,
+            ...builtDetails,
+            size: mainAsset.size,
+            gzip: mainAsset.gzip,
+        };
+    }
+    catch (e) {
+        Telemetry.packageStats(packageString, false, performance.now() - startTime, options);
+        throw e;
+    }
+    finally {
+        if (!options.debug) {
+            await InstallationUtils.cleanupPath(installPath);
+        }
+    }
+}

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export { default as getPackageStats } from './getPackageStats.js';
+export * from './errors/CustomError.js';
+export * from './getPackageExportSizes.js';
+export { emitter as eventQueue } from './utils/telemetry.utils.js';

package/build/index.js

@@ -0,0 +1,4 @@
+export { default as getPackageStats } from './getPackageStats.js';
+export * from './errors/CustomError.js';
+export * from './getPackageExportSizes.js';
+export { emitter as eventQueue } from './utils/telemetry.utils.js';

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

@@ -0,0 +1,51 @@
+import { Entry } from '@rspack/core';
+import type { Stats } from '@rspack/core';
+import { Externals, BuildPackageOptions, CreateEntryPointOptions } from '../common.types.js';
+type CompilePackageArgs = {
+    name: string;
+    externals: Externals;
+    entry: Entry;
+    debug?: boolean;
+    minify?: boolean;
+};
+type CompilePackageReturn = {
+    stats: Stats;
+    error: Error | null;
+};
+type BuildPackageArgs = {
+    name: string;
+    installPath: string;
+    externals: Externals;
+    options: BuildPackageOptions;
+};
+type BuildPackageResult = {
+    assets: Array<{
+        name: string;
+        type: string;
+        size: number;
+        gzip: number;
+    }>;
+    dependencySizes?: Array<{
+        name: string;
+        approximateSize: number;
+    }>;
+};
+type BuildPackageResultWithIgnored = BuildPackageResult & {
+    ignoredMissingDependencies?: Array<string>;
+};
+declare function getCompilationErrors(stats: Stats): import("@rspack/core").RspackError[];
+declare const BuildUtils: {
+    createEntryPoint(packageName: string, installPath: string, options: CreateEntryPointOptions): string;
+    compilePackage({ name, entry, externals, debug, minify, }: CompilePackageArgs): Promise<CompilePackageReturn>;
+    _parseMissingModules(errors: ReturnType<typeof getCompilationErrors>): string[];
+    buildPackage({ name, installPath, externals, options, }: BuildPackageArgs): Promise<{
+        assets: {
+            name: string;
+            type: string;
+            size: number;
+            gzip: number;
+        }[];
+    }>;
+    buildPackageIgnoringMissingDeps({ name, externals, installPath, options, }: BuildPackageArgs): Promise<BuildPackageResultWithIgnored>;
+};
+export default BuildUtils;

package/build/utils/build.utils.js

@@ -0,0 +1,288 @@
+import path from 'path';
+import { rspack } from '@rspack/core';
+import isValidNPMName from 'is-valid-npm-name';
+import { gzipSync } from 'zlib';
+import fs from 'fs';
+import getDependencySizes from '../getDependencySizeTree.js';
+import makeRspackConfig from '../config/makeRspackConfig.js';
+import { performance } from 'perf_hooks';
+import { BuildError, CLIBuildError, EntryPointError, MissingDependencyError, UnexpectedBuildError, } from '../errors/CustomError.js';
+import Telemetry from './telemetry.utils.js';
+function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+function getCompilationErrors(stats) {
+    return [...stats.compilation.errors].filter(notEmpty).flat();
+}
+function closeCompiler(compiler) {
+    return new Promise((resolve, reject) => {
+        compiler.close(error => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+const BuildUtils = {
+    createEntryPoint(packageName, installPath, options) {
+        const entryPath = path.join(installPath, options.entryFilename || 'index.js');
+        let importStatement;
+        if (options.esm) {
+            if (options.customImports) {
+                importStatement = `
+          import { ${options.customImports.join(', ')} } from '${packageName}'; 
+          console.log(${options.customImports.join(', ')})
+     `;
+            }
+            else {
+                importStatement = `import * as p from '${packageName}'; console.log(p)`;
+            }
+        }
+        else {
+            if (options.customImports) {
+                importStatement = `
+        const { ${options.customImports.join(', ')} } = require('${packageName}'); 
+        console.log(${options.customImports.join(', ')})
+        `;
+            }
+            else {
+                importStatement = `const p = require('${packageName}'); console.log(p)`;
+            }
+        }
+        try {
+            fs.writeFileSync(entryPath, importStatement, 'utf-8');
+            return entryPath;
+        }
+        catch (err) {
+            throw new EntryPointError(err);
+        }
+    },
+    compilePackage({ name, entry, externals, debug, minify, }) {
+        const startTime = performance.now();
+        const options = makeRspackConfig({
+            packageName: name,
+            entry,
+            externals,
+            debug,
+            minify,
+        });
+        const compiler = rspack(options);
+        return new Promise((resolve, reject) => {
+            compiler.run(async (error, stats) => {
+                try {
+                    if (!stats) {
+                        throw new Error('stats is null');
+                    }
+                    await closeCompiler(compiler);
+                    if (error) {
+                        console.error(error);
+                        Telemetry.compilePackage(name, false, startTime, {}, error);
+                    }
+                    else {
+                        Telemetry.compilePackage(name, true, startTime, {});
+                    }
+                    resolve({ stats, error });
+                }
+                catch (closeError) {
+                    reject(closeError);
+                }
+            });
+        });
+    },
+    _parseMissingModules(errors) {
+        // There's a better way to get the missing module's name, maybe ?
+        const missingModuleRegex = /Can't resolve '(.+)' in/;
+        const missingModules = errors.map(err => {
+            const matches = err.message.match(missingModuleRegex);
+            if (!matches) {
+                throw new UnexpectedBuildError('Expected to find a file path in the module not found error, but found none. Regex for this might be out of date.');
+            }
+            const missingFilePath = matches[1];
+            let packageNameMatch;
+            if (missingFilePath.startsWith('@')) {
+                packageNameMatch = missingFilePath.match(/@[^/]+\/[^/]+/); // @babel/runtime/object/create -> @babel/runtime
+            }
+            else {
+                packageNameMatch = missingFilePath.match(/[^/]+/); // babel-runtime/object/create -> babel-runtime
+            }
+            if (!packageNameMatch) {
+                throw new UnexpectedBuildError('Failed to resolve the missing package name. Regex for this might be out of date.');
+            }
+            return packageNameMatch[0];
+        });
+        let uniqueMissingModules = Array.from(new Set(missingModules));
+        uniqueMissingModules = uniqueMissingModules.filter(mod => !mod.startsWith(`${uniqueMissingModules[0]}/`));
+        return uniqueMissingModules;
+    },
+    async buildPackage({ name, installPath, externals, options, }) {
+        var _a;
+        let entry = {};
+        if (options.splitCustomImports) {
+            if (!options.customImports || !options.customImports.length) {
+                return { assets: [] };
+            }
+            options.customImports.forEach(importt => {
+                entry[importt] = BuildUtils.createEntryPoint(name, installPath, {
+                    customImports: [importt],
+                    entryFilename: importt,
+                    esm: true,
+                });
+            });
+        }
+        else {
+            entry['main'] = BuildUtils.createEntryPoint(name, installPath, {
+                esm: true,
+                customImports: options.customImports,
+            });
+        }
+        const { stats, error } = await BuildUtils.compilePackage({
+            name,
+            entry,
+            externals,
+            debug: options.debug,
+            minify: options.minify,
+        });
+        const jsonStatsStartTime = performance.now();
+        let jsonStats = stats.toJson({
+            assets: true,
+            source: true,
+            chunks: false,
+            chunkGroups: false,
+            chunkModules: true,
+            modules: true,
+            nestedModules: true,
+            reasons: true,
+            depth: true,
+            errors: true,
+            entrypoints: false,
+            warnings: false,
+        });
+        if (!jsonStats) {
+            Telemetry.parseWebpackStats(name, false, jsonStatsStartTime);
+            throw new UnexpectedBuildError('Expected webpack json stats to be non-null, but was null');
+        }
+        else {
+            Telemetry.parseWebpackStats(name, true, jsonStatsStartTime);
+        }
+        const compilationErrors = getCompilationErrors(stats);
+        if (error && !stats) {
+            throw new BuildError(error);
+        }
+        else if (compilationErrors.length) {
+            const missingModules = BuildUtils._parseMissingModules(compilationErrors);
+            if (missingModules.length) {
+                if (missingModules.length === 1 && missingModules[0] === name) {
+                    throw new EntryPointError(compilationErrors.map(err => err.message));
+                }
+                else {
+                    throw new MissingDependencyError(compilationErrors.map(err => err.toString()), { missingModules });
+                }
+            }
+            else if (jsonStats.errors && jsonStats.errors.length > 0) {
+                if (jsonStats.errors.some(error => error.message.includes("Unexpected character '#'"))) {
+                    throw new CLIBuildError(jsonStats.errors);
+                }
+                else {
+                    throw new BuildError(jsonStats.errors);
+                }
+            }
+            else {
+                throw new UnexpectedBuildError('The webpack stats object was unexpectedly empty');
+            }
+        }
+        else {
+            const getAssetStats = async (asset) => {
+                const bundle = path.join(process.cwd(), 'dist', asset.name);
+                const bundleContents = await fs.promises.readFile(bundle);
+                const gzip = gzipSync(bundleContents, {}).length;
+                const matches = asset.name.match(/(.+?)\.bundle\.(.+)$/);
+                if (!matches) {
+                    throw new UnexpectedBuildError('Found an asset without the `.bundle` suffix. ' +
+                        'A loader customization might be needed to recognize this asset type' +
+                        asset.name);
+                }
+                const [, entryName, extension] = matches;
+                return {
+                    name: entryName,
+                    type: extension,
+                    size: asset.size,
+                    gzip,
+                };
+            };
+            const assetStatsPromises = ((_a = jsonStats === null || jsonStats === void 0 ? void 0 : jsonStats.assets) === null || _a === void 0 ? void 0 : _a.filter(asset => {
+                var _a;
+                return !((_a = asset.chunkNames) === null || _a === void 0 ? void 0 : _a.some(name => name === 'runtime' ||
+                    (typeof name === 'string' && name.startsWith('runtime~'))));
+            }).filter(asset => typeof asset.name === 'string' &&
+                !asset.name.endsWith('LICENSE.txt')).map(getAssetStats)) || [];
+            const assetStats = await Promise.all(assetStatsPromises);
+            Telemetry.assetsGZIPParseTime(name, performance.now());
+            let dependencySizeResults = {};
+            if (options.includeDependencySizes) {
+                const dependencySizes = await getDependencySizes(name, jsonStats);
+                dependencySizeResults = {
+                    dependencySizes,
+                };
+            }
+            return {
+                assets: assetStats || [],
+                ...dependencySizeResults,
+            };
+        }
+    },
+    async buildPackageIgnoringMissingDeps({ name, externals, installPath, options, }) {
+        const buildStartTime = performance.now();
+        let buildIteration = 1;
+        try {
+            const buildResult = await BuildUtils.buildPackage({
+                name,
+                externals,
+                installPath,
+                options,
+            });
+            Telemetry.buildPackage(name, true, buildStartTime, {
+                ...options,
+                buildIteration,
+            });
+            return buildResult;
+        }
+        catch (e) {
+            buildIteration++;
+            if (e instanceof MissingDependencyError &&
+                e.missingModules.length <= 6 &&
+                e.missingModules.every(mod => isValidNPMName(mod))) {
+                const { missingModules } = e.extra;
+                const newExternals = {
+                    ...externals,
+                    externalPackages: externals.externalPackages.concat(missingModules),
+                };
+                const rebuiltResult = await BuildUtils.buildPackage({
+                    name,
+                    externals: newExternals,
+                    installPath,
+                    options,
+                });
+                Telemetry.buildPackage(name, true, buildStartTime, {
+                    ...options,
+                    buildIteration,
+                    missingModules,
+                });
+                return {
+                    ignoredMissingDependencies: missingModules,
+                    ...rebuiltResult,
+                };
+            }
+            else {
+                Telemetry.buildPackage(name, false, buildStartTime, {
+                    ...options,
+                    buildIteration,
+                }, e);
+                throw e;
+            }
+        }
+    },
+};
+export default BuildUtils;

package/build/utils/common.utils.d.ts

@@ -0,0 +1,20 @@
+export declare const getBuiltInModules: () => string[];
+export declare function exec(command: string, options: any, timeout?: number): Promise<unknown>;
+/**
+ * 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 declare function getExternals(packageName: string, installPath: string): {
+    externalPackages: string[];
+    externalBuiltIns: string[];
+};
+type ParsePackageResult = {
+    name: string;
+    version: string | null;
+    scoped: boolean;
+    isLocal?: boolean;
+    normalPath?: string;
+};
+export declare function parsePackageString(packageString: string): ParsePackageResult;
+export {};