package-build-stats 8.0.1 → 8.0.3

package/build/common.types.d.ts

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/config/config.d.ts

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

package/build/config/config.js

@@ -0,0 +1,10 @@
+"use strict";
+// Use ES6 supported by Node v6.10 only!
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+exports.default = {
+    tmp: path_1.default.join('/tmp', 'tmp-build'),
+};

package/build/config/makeRspackConfig.d.ts

@@ -0,0 +1,11 @@
+import type { Entry, Configuration } from '@rspack/core';
+import { Externals } from '../common.types';
+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

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = makeRspackConfig;
+const autoprefixer_1 = __importDefault(require("autoprefixer"));
+const escape_string_regexp_1 = __importDefault(require("escape-string-regexp"));
+const core_1 = __importDefault(require("@rspack/core"));
+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: {
+            runtimeChunk: { name: 'runtime' },
+            realContentHash: false,
+            minimize: minify,
+            // 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: [
+                        core_1.default.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: [
+                        core_1.default.CssExtractRspackPlugin.loader,
+                        require.resolve('css-loader'),
+                        {
+                            loader: require.resolve('postcss-loader'),
+                            options: {
+                                postcssOptions: {
+                                    plugins: [(0, autoprefixer_1.default)()],
+                                },
+                            },
+                        },
+                        require.resolve('sass-loader'),
+                    ],
+                },
+                {
+                    test: /\.less$/,
+                    type: 'javascript/auto',
+                    use: [
+                        core_1.default.CssExtractRspackPlugin.loader,
+                        require.resolve('css-loader'),
+                        {
+                            loader: require.resolve('postcss-loader'),
+                            options: {
+                                postcssOptions: {
+                                    plugins: [
+                                        (0, autoprefixer_1.default)({
+                                            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 core_1.default.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 => `^${(0, escape_string_regexp_1.default)(dep)}$|^${(0, escape_string_regexp_1.default)(dep)}\\/`)
+        .join('|');
+    externalsRegex = `(${externalsRegex})`;
+    return new RegExp(externalsRegex);
+}

package/build/errors/CustomError.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnexpectedBuildError = exports.MissingDependencyError = exports.MinifyError = exports.CLIBuildError = exports.PackageNotFoundError = exports.InstallError = exports.EntryPointError = exports.BuildError = void 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,
+        };
+    }
+}
+class BuildError extends CustomError {
+    constructor(originalError, extra) {
+        super('BuildError', originalError, extra);
+        Object.setPrototypeOf(this, BuildError.prototype);
+    }
+}
+exports.BuildError = BuildError;
+class EntryPointError extends CustomError {
+    constructor(originalError, extra) {
+        super('EntryPointError', originalError, extra);
+        Object.setPrototypeOf(this, EntryPointError.prototype);
+    }
+}
+exports.EntryPointError = EntryPointError;
+class InstallError extends CustomError {
+    constructor(originalError, extra) {
+        super('InstallError', originalError, extra);
+        Object.setPrototypeOf(this, InstallError.prototype);
+    }
+}
+exports.InstallError = InstallError;
+class PackageNotFoundError extends CustomError {
+    constructor(originalError, extra) {
+        super('PackageNotFoundError', originalError, extra);
+        Object.setPrototypeOf(this, PackageNotFoundError.prototype);
+    }
+}
+exports.PackageNotFoundError = PackageNotFoundError;
+class CLIBuildError extends CustomError {
+    constructor(originalError, extra) {
+        super('CLIBuildError', originalError, extra);
+        Object.setPrototypeOf(this, CLIBuildError.prototype);
+    }
+}
+exports.CLIBuildError = CLIBuildError;
+class MinifyError extends CustomError {
+    constructor(originalError, extra) {
+        super('MinifyError', originalError, extra);
+        Object.setPrototypeOf(this, MinifyError.prototype);
+    }
+}
+exports.MinifyError = MinifyError;
+class MissingDependencyError extends CustomError {
+    constructor(originalError, extra) {
+        super('MissingDependencyError', originalError, extra);
+        this.missingModules = extra.missingModules;
+        Object.setPrototypeOf(this, MissingDependencyError.prototype);
+    }
+}
+exports.MissingDependencyError = MissingDependencyError;
+class UnexpectedBuildError extends CustomError {
+    constructor(originalError, extra) {
+        super('UnexpectedBuildError', originalError, extra);
+        Object.setPrototypeOf(this, UnexpectedBuildError.prototype);
+    }
+}
+exports.UnexpectedBuildError = UnexpectedBuildError;

package/build/getDependencySizeTree.d.ts

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,277 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const core_1 = require("@swc/core");
+const CustomError_1 = require("./errors/CustomError");
+const telemetry_utils_1 = __importDefault(require("./utils/telemetry.utils"));
+const perf_hooks_1 = require("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_1.default.sep + '.+\\' + path_1.default.sep + 'node_modules\\' + path_1.default.sep;
+    const packages = moduleFilePath.split(new RegExp('\\' + path_1.default.sep + 'node_modules\\' + path_1.default.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_1.default.sep) + 1;
+        lastPackageName = lastSegment.slice(0, offset + lastSegment.slice(offset).indexOf(path_1.default.sep));
+    }
+    else {
+        lastPackageName = lastSegment.slice(0, lastSegment.indexOf(path_1.default.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 (0, core_1.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 = perf_hooks_1.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, pkgIndex) => {
+            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 || '');
+            const minifiedCode = 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 CustomError_1.MinifyError(error, {
+                message: message,
+                filePath: filename,
+            });
+        }
+    });
+    try {
+        const results = await Promise.all(resultPromises);
+        telemetry_utils_1.default.dependencySizes(packageName, startTime, true, { minifier: 'swc' });
+        return results;
+    }
+    catch (e) {
+        telemetry_utils_1.default.dependencySizes(packageName, startTime, false, { minifier: 'swc' }, e);
+        throw e;
+    }
+}
+exports.default = bundleSizeTree;

package/build/getPackageExportSizes.d.ts

@@ -0,0 +1,18 @@
+import { GetPackageStatsOptions, InstallPackageOptions } from './common.types';
+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>;
+}>;