package-build-stats 8.2.1 → 8.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "package-build-stats",
-  "version": "8.2.1",
+  "version": "8.2.3",
   "type": "module",
   "author": "Shubham Kanodia <shubham.kanodia10@gmail.com>",
   "repository": "https://github.com/pastelsky/package-build-stats",

package/src/utils/installation.utils.ts

@@ -239,7 +239,9 @@ const InstallationUtils = {
 
       command = `bun add ${packageString} ${additionalPackages.join(
         ' ',
-      )} --${flags.join(' --')}`
+      )} --cache-dir=${path.join(config.tmp, 'cache', 'bun')} --${flags.join(
+        ' --',
+      )}`
     } else {
       console.error('No valid client specified')
       process.exit(1)

package/build/common.types.d.ts

@@ -1,26 +0,0 @@
-type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
-type AllOptions = {
-    customImports?: Array<string>;
-    splitCustomImports?: boolean;
-    debug?: boolean;
-    minify?: boolean;
-    esm?: boolean;
-    entryFilename?: string;
-    client?: PackageManager | PackageManager[];
-    limitConcurrency?: boolean;
-    networkConcurrency?: number;
-    additionalPackages?: Array<string>;
-    isLocal?: boolean;
-    installTimeout?: number;
-};
-export type BuildPackageOptions = Pick<AllOptions, 'customImports' | 'splitCustomImports' | 'debug' | 'minify'> & {
-    includeDependencySizes: boolean;
-};
-export type CreateEntryPointOptions = Pick<AllOptions, 'esm' | 'customImports' | 'entryFilename'>;
-export type InstallPackageOptions = Pick<AllOptions, 'client' | 'limitConcurrency' | 'networkConcurrency' | 'additionalPackages' | 'isLocal' | 'installTimeout' | 'debug'>;
-export type GetPackageStatsOptions = Pick<AllOptions, 'client' | 'limitConcurrency' | 'networkConcurrency' | 'debug' | 'customImports' | 'installTimeout' | 'minify'>;
-export type Externals = {
-    externalPackages: Array<string>;
-    externalBuiltIns: Array<string>;
-};
-export {};

package/build/common.types.js

@@ -1 +0,0 @@
-export {};

package/build/config/config.d.ts

@@ -1,4 +0,0 @@
-declare const _default: {
-    tmp: string;
-};
-export default _default;

package/build/config/config.js

@@ -1,5 +0,0 @@
-// Use ES6 supported by Node v6.10 only!
-import path from 'path';
-export default {
-    tmp: path.join('/tmp', 'tmp-build'),
-};

package/build/config/makeRspackConfig.d.ts

@@ -1,11 +0,0 @@
-import type { Entry, Configuration } from '@rspack/core';
-import { Externals } from '../common.types.js';
-type MakeRspackConfigOptions = {
-    packageName: string;
-    externals: Externals;
-    debug?: boolean;
-    minify?: boolean;
-    entry: Entry;
-};
-export default function makeRspackConfig({ packageName: _packageName, entry, externals, debug: _debug, minify, }: MakeRspackConfigOptions): Configuration;
-export {};

package/build/config/makeRspackConfig.js

@@ -1,170 +0,0 @@
-import autoprefixer from 'autoprefixer';
-import escapeRegex from 'escape-string-regexp';
-import rspack from '@rspack/core';
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-export default function makeRspackConfig({ packageName: _packageName, entry, externals, debug: _debug, minify = true, }) {
-    const externalsRegex = makeExternalsRegex(externals.externalPackages);
-    const isExternalRequest = (request) => {
-        const isPeerDep = externals.externalPackages.length
-            ? externalsRegex.test(request)
-            : false;
-        const isBuiltIn = externals.externalBuiltIns.includes(request);
-        return isPeerDep || isBuiltIn;
-    };
-    const configuration = {
-        entry: entry,
-        mode: 'production',
-        devtool: _debug ? 'source-map' : false,
-        optimization: {
-            // Use 'multiple' to create a separate runtime chunk per entry point
-            // 'single' or { name: 'runtime' } shares one runtime across all entries,
-            // which breaks tree-shaking when building many exports simultaneously
-            runtimeChunk: 'multiple',
-            realContentHash: false,
-            minimize: minify,
-            // Enable tree-shaking optimizations
-            usedExports: true, // Mark unused exports for removal
-            sideEffects: true, // Respect package.json sideEffects field
-            // Rspack automatically uses its built-in default minifiers:
-            // - SwcJsMinimizerRspackPlugin for JS (SWC-based, very fast)
-            // - LightningCssMinimizerRspackPlugin for CSS (Lightning CSS-based)
-            // See: https://rspack.rs/guide/optimization/production
-            splitChunks: {
-                cacheGroups: {
-                    styles: {
-                        name: 'main',
-                        test: /\.css$/,
-                        chunks: 'all',
-                    },
-                },
-            },
-        },
-        stats: {
-            source: true,
-            modules: true,
-            nestedModules: true,
-            reasons: true,
-            depth: true,
-            chunkModules: true,
-        },
-        resolve: {
-            modules: ['node_modules'],
-            extensions: [
-                '.web.mjs',
-                '.mjs',
-                '.web.js',
-                '.js',
-                '.mjs',
-                '.json',
-                '.css',
-                '.sass',
-                '.scss',
-            ],
-            mainFields: ['browser', 'module', 'main', 'style'],
-        },
-        module: {
-            rules: [
-                {
-                    type: 'javascript/auto',
-                    test: /\.mjs$/,
-                    use: [],
-                },
-                {
-                    test: /\.css$/,
-                    type: 'javascript/auto',
-                    use: [
-                        rspack.CssExtractRspackPlugin.loader,
-                        require.resolve('css-loader'),
-                    ],
-                },
-                {
-                    test: /\.(html|svelte)$/,
-                    use: {
-                        loader: require.resolve('svelte-loader'),
-                        options: {
-                            emitCss: true,
-                        },
-                    },
-                },
-                // {
-                //   test: /\.vue$/,
-                //   loader: require.resolve('vue-loader'),
-                // },
-                {
-                    test: /\.(scss|sass)$/,
-                    type: 'javascript/auto',
-                    use: [
-                        rspack.CssExtractRspackPlugin.loader,
-                        require.resolve('css-loader'),
-                        {
-                            loader: require.resolve('postcss-loader'),
-                            options: {
-                                postcssOptions: {
-                                    plugins: [autoprefixer()],
-                                },
-                            },
-                        },
-                        require.resolve('sass-loader'),
-                    ],
-                },
-                {
-                    test: /\.less$/,
-                    type: 'javascript/auto',
-                    use: [
-                        rspack.CssExtractRspackPlugin.loader,
-                        require.resolve('css-loader'),
-                        {
-                            loader: require.resolve('postcss-loader'),
-                            options: {
-                                postcssOptions: {
-                                    plugins: [
-                                        autoprefixer({
-                                            overrideBrowserslist: [
-                                                'last 5 Chrome versions',
-                                                'last 5 Firefox versions',
-                                                'Safari >= 8',
-                                                'Explorer >= 10',
-                                                'edge >= 12',
-                                            ],
-                                        }),
-                                    ],
-                                },
-                            },
-                        },
-                        {
-                            loader: require.resolve('less-loader'),
-                            options: {
-                                lessOptions: {
-                                    javascriptEnabled: true,
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-        },
-        plugins: [
-            new rspack.CssExtractRspackPlugin({
-                filename: '[name].bundle.css',
-            }),
-        ],
-        node: {
-            global: false,
-        },
-        output: {
-            filename: '[name].bundle.js',
-        },
-        externals: ({ request }, callback) => isExternalRequest(request || '')
-            ? callback(undefined, 'commonjs ' + request)
-            : callback(undefined),
-    };
-    return configuration;
-}
-function makeExternalsRegex(externals) {
-    let externalsRegex = externals
-        .map(dep => `^${escapeRegex(dep)}$|^${escapeRegex(dep)}\\/`)
-        .join('|');
-    externalsRegex = `(${externalsRegex})`;
-    return new RegExp(externalsRegex);
-}

package/build/errors/CustomError.d.ts

@@ -1,42 +0,0 @@
-/**
- * Wraps the original error with a identifiable
- * name.
- */
-declare class CustomError extends Error {
-    originalError: any;
-    extra: any;
-    constructor(name: string, originalError: Error, extra?: any);
-    toJSON(): {
-        name: string;
-        originalError: any;
-        extra: any;
-    };
-}
-export declare class BuildError extends CustomError {
-    constructor(originalError: any, extra?: any);
-}
-export declare class EntryPointError extends CustomError {
-    constructor(originalError: any, extra?: any);
-}
-export declare class InstallError extends CustomError {
-    constructor(originalError: any, extra?: any);
-}
-export declare class PackageNotFoundError extends CustomError {
-    constructor(originalError: any, extra?: any);
-}
-export declare class CLIBuildError extends CustomError {
-    constructor(originalError: any, extra?: any);
-}
-export declare class MinifyError extends CustomError {
-    constructor(originalError: any, extra?: any);
-}
-export declare class MissingDependencyError extends CustomError {
-    missingModules: Array<string>;
-    constructor(originalError: any, extra: {
-        missingModules: Array<string>;
-    });
-}
-export declare class UnexpectedBuildError extends CustomError {
-    constructor(originalError: any, extra?: any);
-}
-export {};

package/build/errors/CustomError.js

@@ -1,69 +0,0 @@
-/**
- * Wraps the original error with a identifiable
- * name.
- */
-class CustomError extends Error {
-    constructor(name, originalError, extra) {
-        super(name);
-        this.name = name;
-        this.originalError = originalError;
-        this.extra = extra;
-        Object.setPrototypeOf(this, CustomError.prototype);
-    }
-    toJSON() {
-        return {
-            name: this.name,
-            originalError: this.originalError,
-            extra: this.extra,
-        };
-    }
-}
-export class BuildError extends CustomError {
-    constructor(originalError, extra) {
-        super('BuildError', originalError, extra);
-        Object.setPrototypeOf(this, BuildError.prototype);
-    }
-}
-export class EntryPointError extends CustomError {
-    constructor(originalError, extra) {
-        super('EntryPointError', originalError, extra);
-        Object.setPrototypeOf(this, EntryPointError.prototype);
-    }
-}
-export class InstallError extends CustomError {
-    constructor(originalError, extra) {
-        super('InstallError', originalError, extra);
-        Object.setPrototypeOf(this, InstallError.prototype);
-    }
-}
-export class PackageNotFoundError extends CustomError {
-    constructor(originalError, extra) {
-        super('PackageNotFoundError', originalError, extra);
-        Object.setPrototypeOf(this, PackageNotFoundError.prototype);
-    }
-}
-export class CLIBuildError extends CustomError {
-    constructor(originalError, extra) {
-        super('CLIBuildError', originalError, extra);
-        Object.setPrototypeOf(this, CLIBuildError.prototype);
-    }
-}
-export class MinifyError extends CustomError {
-    constructor(originalError, extra) {
-        super('MinifyError', originalError, extra);
-        Object.setPrototypeOf(this, MinifyError.prototype);
-    }
-}
-export class MissingDependencyError extends CustomError {
-    constructor(originalError, extra) {
-        super('MissingDependencyError', originalError, extra);
-        this.missingModules = extra.missingModules;
-        Object.setPrototypeOf(this, MissingDependencyError.prototype);
-    }
-}
-export class UnexpectedBuildError extends CustomError {
-    constructor(originalError, extra) {
-        super('UnexpectedBuildError', originalError, extra);
-        Object.setPrototypeOf(this, UnexpectedBuildError.prototype);
-    }
-}

package/build/getDependencySizeTree.d.ts

@@ -1,6 +0,0 @@
-type RspackStatsCompilation = NonNullable<ReturnType<NonNullable<import('@rspack/core').Stats['toJson']>>>;
-declare function bundleSizeTree(packageName: string, stats: RspackStatsCompilation): Promise<{
-    name: string;
-    approximateSize: number;
-}[]>;
-export default bundleSizeTree;

package/build/getDependencySizeTree.js

@@ -1,271 +0,0 @@
-import path from 'path';
-import { minify } from '@swc/core';
-import { MinifyError } from './errors/CustomError.js';
-import Telemetry from './utils/telemetry.utils.js';
-import { performance } from 'perf_hooks';
-function modulePath(identifier) {
-    // the format of module paths is
-    //   '(<loader expression>!)?/path/to/module.js'
-    // OR
-    // 'javascript/esm|/some/path'
-    let loaderRegex = /.*!/;
-    const withoutLoader = identifier.replace(loaderRegex, '');
-    if (withoutLoader.includes('|'))
-        return withoutLoader.split('|')[1];
-    return withoutLoader;
-}
-function getUtf8Size(value) {
-    const size = Buffer.byteLength(value, 'utf8');
-    if (process.env.DEBUG_SIZE && Math.random() < 0.01) {
-        // Only debug 1% to avoid spam
-        console.log(`Size: ${size} bytes`);
-    }
-    return size;
-}
-/**
- * Extract all package names from a module path to build a dependency chain.
- * For example: /node_modules/a/node_modules/b/index.js returns ['a', 'b']
- * This preserves the old behavior of showing nested dependencies.
- */
-function extractPackageNamesFromPath(moduleFilePath) {
-    // pnpm will serve packages from a global symlink (.pnpm/package@version/node_modules/package)
-    // needs to be stripped off
-    const pnpmPrefix = '.pnpm\\' + path.sep + '.+\\' + path.sep + 'node_modules\\' + path.sep;
-    const packages = moduleFilePath.split(new RegExp('\\' + path.sep + 'node_modules\\' + path.sep + `(?:${pnpmPrefix})?`));
-    if (packages.length <= 1)
-        return [];
-    const lastSegment = packages.pop();
-    if (!lastSegment)
-        return [];
-    // Extract the package name from the last segment
-    let lastPackageName;
-    if (lastSegment[0] === '@') {
-        // package is a scoped package
-        const offset = lastSegment.indexOf(path.sep) + 1;
-        lastPackageName = lastSegment.slice(0, offset + lastSegment.slice(offset).indexOf(path.sep));
-    }
-    else {
-        lastPackageName = lastSegment.slice(0, lastSegment.indexOf(path.sep));
-    }
-    packages.push(lastPackageName);
-    packages.shift(); // Remove the first empty element
-    return packages;
-}
-async function minifyDependencyCode(source) {
-    if (process.env.DEBUG_SIZE) {
-        console.log('Minifying dependency code...');
-    }
-    try {
-        const startTime = Date.now();
-        const result = await minify(source, {
-            compress: true,
-            mangle: true,
-            module: true, // Treat as ES module to support import/export
-        });
-        const minifyTime = Date.now() - startTime;
-        if (process.env.DEBUG_SIZE) {
-            console.log(`Minify completed in ${minifyTime}ms`);
-        }
-        return { code: result.code };
-    }
-    catch (error) {
-        if (process.env.DEBUG_SIZE) {
-            console.log('Minify error occurred');
-        }
-        console.error('SWC minify error:', error);
-        throw error;
-    }
-}
-function normaliseModuleSource(mod) {
-    const identifier = mod.identifier || '';
-    const isJSON = identifier.endsWith('.json');
-    const rawSource = mod.source;
-    if (process.env.DEBUG_SIZE) {
-        console.log(`Normalising module: ${identifier}`);
-    }
-    if (rawSource === undefined || rawSource === null) {
-        if (process.env.DEBUG_SIZE) {
-            console.log(`No source for module: ${identifier}`);
-        }
-        return null;
-    }
-    let source;
-    if (typeof rawSource === 'string') {
-        source = rawSource;
-        if (process.env.DEBUG_SIZE) {
-            console.log(`Source is string`);
-        }
-    }
-    else if (Buffer.isBuffer(rawSource)) {
-        source = rawSource.toString('utf8');
-        if (process.env.DEBUG_SIZE) {
-            console.log(`Source is buffer`);
-        }
-    }
-    else {
-        source = String(rawSource);
-        if (process.env.DEBUG_SIZE) {
-            console.log(`Source is other type`);
-        }
-    }
-    const finalSource = isJSON ? `$a$=${source}` : source;
-    if (process.env.DEBUG_SIZE) {
-        console.log(`Module source normalised (length: ${finalSource.length})`);
-    }
-    return finalSource;
-}
-async function bundleSizeTree(packageName, stats) {
-    const startTime = performance.now();
-    const statsTree = {
-        packageName: '<root>',
-        sources: [],
-        children: [],
-    };
-    if (!stats.modules)
-        return [];
-    // Collect modules with their sources
-    const modules = [];
-    const makeModule = (mod) => {
-        const identifier = mod.identifier || '';
-        const resolvedPath = modulePath(identifier);
-        const source = normaliseModuleSource(mod);
-        if (!source)
-            return null;
-        return {
-            path: resolvedPath,
-            source,
-        };
-    };
-    const filteredModules = stats.modules.filter(mod => { var _a; return !(((_a = mod.name) === null || _a === void 0 ? void 0 : _a.startsWith('external')) || mod.moduleType === 'runtime'); });
-    if (process.env.DEBUG_SIZE) {
-        console.log(`\n[LOCAL] ==================== ${packageName} ====================`);
-    }
-    filteredModules.forEach(mod => {
-        if (mod.modules) {
-            if (process.env.DEBUG_SIZE) {
-                console.log(`Module has ${mod.modules.length} sub-modules`);
-            }
-            mod.modules.forEach(subMod => {
-                const made = makeModule(subMod);
-                if (made)
-                    modules.push(made);
-            });
-        }
-        else {
-            const made = makeModule(mod);
-            if (made)
-                modules.push(made);
-        }
-    });
-    if (process.env.DEBUG_SIZE) {
-        console.log(`Collected ${modules.length} total modules`);
-    }
-    modules.sort((a, b) => {
-        if (a === b) {
-            return 0;
-        }
-        else {
-            return a < b ? -1 : 1;
-        }
-    });
-    // Build tree structure from module paths
-    modules.forEach((mod, modIndex) => {
-        const packages = extractPackageNamesFromPath(mod.path);
-        if (process.env.DEBUG_SIZE && modIndex < 5) {
-            console.log(`[${modIndex}] Extracted packages: ${packages.join(' > ')}`);
-        }
-        if (packages.length === 0) {
-            if (process.env.DEBUG_SIZE && modIndex < 5) {
-                console.log(`[${modIndex}] No packages found in path`);
-            }
-            return;
-        }
-        let parent = statsTree;
-        packages.forEach(pkg => {
-            const existing = parent.children.filter(child => child.packageName === pkg);
-            if (existing.length > 0) {
-                existing[0].sources.push(mod.source);
-                if (process.env.DEBUG_SIZE && modIndex < 5) {
-                    console.log(`[${modIndex}] Added to existing package: ${pkg}`);
-                }
-                parent = existing[0];
-            }
-            else {
-                const newChild = {
-                    path: mod.path,
-                    packageName: pkg,
-                    sources: [mod.source],
-                    children: [],
-                };
-                parent.children.push(newChild);
-                if (process.env.DEBUG_SIZE && modIndex < 5) {
-                    console.log(`[${modIndex}] Created new package: ${pkg}`);
-                }
-                parent = newChild;
-            }
-        });
-    });
-    // The old webpack implementation returned only the first-level children
-    // We need to preserve that behavior
-    const flattenedItems = statsTree.children;
-    if (process.env.DEBUG_SIZE) {
-        console.log(`\n[LOCAL] Tree structure built with ${flattenedItems.length} top-level dependencies:`);
-    }
-    const resultPromises = flattenedItems
-        .map(treeItem => ({
-        ...treeItem,
-        sources: treeItem.sources.filter(source => !!source),
-    }))
-        .filter(treeItem => treeItem.sources.length)
-        .map(async (treeItem) => {
-        if (process.env.DEBUG_SIZE) {
-            console.log(`\n[LOCAL] Processing dependency: ${treeItem.packageName}`);
-        }
-        const sourceMinifiedPromises = treeItem.sources.map(async (code, idx) => {
-            const originalSize = getUtf8Size(code);
-            if (process.env.DEBUG_SIZE) {
-                console.log(`Source ${idx}: ${originalSize} bytes (original)`);
-            }
-            const minified = await minifyDependencyCode(code);
-            const minifiedSize = getUtf8Size(minified.code || '');
-            if (process.env.DEBUG_SIZE) {
-                console.log(`Source ${idx}: ${minifiedSize} bytes (minified)`);
-            }
-            return minified;
-        });
-        try {
-            const sources = await Promise.all(sourceMinifiedPromises);
-            const size = sources.reduce((acc, source, idx) => {
-                const sourceSize = getUtf8Size(source.code || '');
-                if (process.env.DEBUG_SIZE) {
-                    console.log(`Total accumulation at idx ${idx}: ${acc + sourceSize} bytes`);
-                }
-                return acc + sourceSize;
-            }, 0);
-            if (process.env.DEBUG_SIZE) {
-                console.log(`Final size for ${treeItem.packageName}: ${size} bytes`);
-            }
-            return {
-                name: treeItem.packageName,
-                approximateSize: size,
-            };
-        }
-        catch (error) {
-            const { message, filename } = error;
-            throw new MinifyError(error, {
-                message: message,
-                filePath: filename,
-            });
-        }
-    });
-    try {
-        const results = await Promise.all(resultPromises);
-        Telemetry.dependencySizes(packageName, startTime, true, { minifier: 'swc' });
-        return results;
-    }
-    catch (e) {
-        Telemetry.dependencySizes(packageName, startTime, false, { minifier: 'swc' }, e);
-        throw e;
-    }
-}
-export default bundleSizeTree;

package/build/getPackageExportSizes.d.ts

@@ -1,18 +0,0 @@
-import { GetPackageStatsOptions, InstallPackageOptions } from './common.types.js';
-export declare function getAllPackageExports(packageString: string, options?: InstallPackageOptions): Promise<{
-    [key: string]: string;
-}>;
-export declare function getPackageExportSizes(packageString: string, options?: GetPackageStatsOptions): Promise<{
-    assets: {
-        path: string;
-        name: string;
-        type: string;
-        size: number;
-        gzip: number;
-    }[];
-    dependencySizes?: Array<{
-        name: string;
-        approximateSize: number;
-    }>;
-    ignoredMissingDependencies?: Array<string>;
-}>;