bunchee 4.1.1 → 4.2.1

package/dist/bin/cli.js

@@ -2,6 +2,7 @@
 var path = require('path');
 var arg = require('arg');
 var fs = require('fs/promises');
+var bunchee = require('bunchee');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -54,7 +55,7 @@ async function fileExists(filePath) {
     }
 }
 
-var version = "4.1.1";
+var version = "4.2.1";
 
 const helpMessage = `
 Usage: bunchee [options]
@@ -165,11 +166,10 @@ async function run(args) {
         return help();
     }
     const entry = source ? path__default.default.resolve(cwd, source) : '';
-    const bundle = require('../index').bundle;
     let timeStart = Date.now();
     let timeEnd;
     try {
-        await bundle(entry, bundleConfig);
+        await bunchee.bundle(entry, bundleConfig);
         timeEnd = Date.now();
     } catch (err) {
         if (err.name === 'NOT_EXISTED') {

package/dist/index.js

@@ -10,9 +10,9 @@ var json = require('@rollup/plugin-json');
 var pluginNodeResolve = require('@rollup/plugin-node-resolve');
 var replace = require('@rollup/plugin-replace');
 var esmShim = require('@rollup/plugin-esm-shim');
-var prettyBytes = require('pretty-bytes');
-var pluginutils = require('@rollup/pluginutils');
 var preserveDirectives = require('rollup-preserve-directives');
+var pluginutils = require('@rollup/pluginutils');
+var prettyBytes = require('pretty-bytes');
 var module$1 = require('module');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -23,96 +23,8 @@ var commonjs__default = /*#__PURE__*/_interopDefault(commonjs);
 var json__default = /*#__PURE__*/_interopDefault(json);
 var replace__default = /*#__PURE__*/_interopDefault(replace);
 var esmShim__default = /*#__PURE__*/_interopDefault(esmShim);
-var prettyBytes__default = /*#__PURE__*/_interopDefault(prettyBytes);
 var preserveDirectives__default = /*#__PURE__*/_interopDefault(preserveDirectives);
-
-const availableExtensions = [
-    'js',
-    'cjs',
-    'mjs',
-    'jsx',
-    'ts',
-    'tsx',
-    'cts',
-    'mts'
-];
-const availableExportConventions = [
-    'react-server',
-    'react-native',
-    'edge-light'
-];
-const availableESExtensionsRegex = /\.(m|c)?[jt]sx?$/;
-const dtsExtensionRegex = /\.d\.(m|c)?ts$/;
-const SRC = 'src';
-const dtsExtensions = {
-    js: '.d.ts',
-    cjs: '.d.cts',
-    mjs: '.d.mts'
-};
-
-const logger = {
-    log (...arg) {
-        console.log('  ', ...arg);
-    },
-    warn (...arg) {
-        console.warn(' ⚠️', ...arg);
-    },
-    error (...arg) {
-        console.error(' ⨯', ...arg);
-    },
-    info (...arg) {
-        console.log(' ✓', ...arg);
-    }
-};
-
-function createChunkSizeCollector() {
-    const sizes = new Map();
-    function addSize(name, size) {
-        sizes.set(name, size);
-    }
-    return {
-        plugin: (cwd)=>{
-            return {
-                name: 'collect-sizes',
-                augmentChunkHash () {
-                // Do nothing, but use the hook to keep the plugin instance alive
-                },
-                renderChunk (code, chunk, options) {
-                    const dir = options.dir || options.file && path__default.default.dirname(options.file);
-                    let fileName = chunk.fileName;
-                    if (dir) {
-                        const filePath = path__default.default.join(dir, fileName);
-                        fileName = filePath.startsWith(cwd) ? path__default.default.relative(cwd, filePath) : filePath;
-                    }
-                    addSize(fileName, code.length);
-                    return null;
-                }
-            };
-        },
-        getSizeStats () {
-            const sizeStats = [];
-            sizes.forEach((size, name)=>{
-                sizeStats.push([
-                    name,
-                    prettyBytes__default.default(size),
-                    size
-                ]);
-            });
-            return sizeStats;
-        }
-    };
-}
-// This can also be passed down as stats from top level
-const sizeCollector = createChunkSizeCollector();
-function logSizeStats() {
-    const stats = sizeCollector.getSizeStats();
-    const maxLength = Math.max(...stats.map(([filename])=>filename.length));
-    stats.forEach(([filename, prettiedSize])=>{
-        const padding = ' '.repeat(maxLength - filename.length);
-        const action = dtsExtensionRegex.test(filename) ? 'Typed' : 'Built';
-        logger.info(`${action} ${filename}${padding} - ${prettiedSize}`);
-    });
-}
+var prettyBytes__default = /*#__PURE__*/_interopDefault(prettyBytes);
 
 function minifyCSS(content) {
     return content.replace(/\/\*[\s\S]*?\*\/|([^:]|^)\/\/.*$|(?:^|\s)(\s+)|\s*([\{\};,:])\s*|\s+(!)\s+/g, (match, p1, p2, p3, p4)=>{
@@ -206,6 +118,31 @@ function rawContent({ exclude }) {
     };
 }
 
+// Alias entries to import path
+// e.g.
+// For a resolved file, if it's one of the entries,
+// aliases it as export path, such as <absolute file> -> <pkg>/<export path>
+function aliasEntries({ entries }) {
+    return {
+        name: 'alias',
+        resolveId: {
+            async handler (source, importer, options) {
+                const resolvedId = await this.resolve(source, importer, options);
+                if (resolvedId != null) {
+                    const aliasedId = entries[resolvedId.id];
+                    if (aliasedId != null) {
+                        return {
+                            id: aliasedId,
+                            external: true
+                        };
+                    }
+                }
+                return null;
+            }
+        }
+    };
+}
+
 function prependDirectives() {
     return {
         name: 'prependDirective',
@@ -231,6 +168,53 @@ function prependDirectives() {
     };
 }
 
+const availableExtensions = [
+    'js',
+    'cjs',
+    'mjs',
+    'jsx',
+    'ts',
+    'tsx',
+    'cts',
+    'mts'
+];
+const nodeResolveExtensions = [
+    '.mjs',
+    '.cjs',
+    '.js',
+    '.json',
+    '.node',
+    '.jsx'
+];
+const availableExportConventions = [
+    'react-server',
+    'react-native',
+    'edge-light'
+];
+const availableESExtensionsRegex = /\.(m|c)?[jt]sx?$/;
+const dtsExtensionRegex = /\.d\.(m|c)?ts$/;
+const SRC = 'src';
+const dtsExtensions = {
+    js: '.d.ts',
+    cjs: '.d.cts',
+    mjs: '.d.mts'
+};
+
+const logger = {
+    log (...arg) {
+        console.log('  ', ...arg);
+    },
+    warn (...arg) {
+        console.warn(' ⚠️', ...arg);
+    },
+    error (...arg) {
+        console.error(' ⨯', ...arg);
+    },
+    info (...arg) {
+        console.log(' ✓', ...arg);
+    }
+};
+
 function exit(err) {
     logger.error(err);
     process.exit(1);
@@ -521,28 +505,29 @@ function isEsmExportName(name, ext) {
         'module'
     ].includes(name) || ext === 'mjs';
 }
-function isCjsExportName(name, ext) {
-    return [
+function isCjsExportName(pkg, name, ext) {
+    const isESModule = isESModulePackage(pkg.type);
+    return !isESModule && [
         'require',
         'main',
         'node',
         'default'
-    ].includes(name) || ext === 'cjs';
+    ].includes(name) && ext !== 'mjs' || ext === 'cjs';
 }
 function getExportConditionDist(pkg, parsedExportCondition, cwd) {
     const dist = [];
     const existed = new Set();
     const exportTypes = Object.keys(parsedExportCondition.export);
-    for (const key of exportTypes){
-        if (key === 'types') {
+    for (const exportType of exportTypes){
+        if (exportType === 'types') {
             continue;
         }
-        const filePath = parsedExportCondition.export[key];
+        const filePath = parsedExportCondition.export[exportType];
         const ext = path.extname(filePath).slice(1);
-        const relativePath = parsedExportCondition.export[key];
+        const relativePath = parsedExportCondition.export[exportType];
         const distFile = getDistPath(relativePath, cwd);
         let format = 'esm';
-        if (isCjsExportName(key, ext)) {
+        if (isCjsExportName(pkg, exportType, ext)) {
             format = 'cjs';
         }
         // Deduplicate the same path jobs
@@ -595,16 +580,36 @@ function getBuildEnv(envs) {
     }, {});
     return envVars;
 }
-async function buildInputConfig(entry, pkg, options, cwd, { tsConfigPath, tsCompilerOptions }, dts) {
+/**
+ * return { '<pkg>/<export>': '<absolute source path> }
+ */ function getEntriesAlias(entries) {
+    const alias = {};
+    for (const [entryImportPath, exportCondition] of Object.entries(entries)){
+        alias[entryImportPath] = exportCondition.source;
+    }
+    return alias;
+}
+async function buildInputConfig(entry, entries, pkg, options, cwd, { tsConfigPath, tsCompilerOptions }, pluginContext, dts) {
+    const entriesAlias = getEntriesAlias(entries);
+    const reversedAlias = {};
+    for (const [key, value] of Object.entries(entriesAlias)){
+        if (value !== entry) {
+            reversedAlias[value] = key;
+        }
+    }
     const hasNoExternal = options.external === null;
     var _options_external;
     const externals = hasNoExternal ? [] : [
         pkg.peerDependencies,
         pkg.dependencies,
         pkg.peerDependenciesMeta
-    ].filter((n)=>Boolean(n)).map((o)=>Object.keys(o)).reduce((a, b)=>a.concat(b), []).concat(((_options_external = options.external) != null ? _options_external : []).concat(pkg.name ? [
-        pkg.name
-    ] : []));
+    ].filter((n)=>Boolean(n)).map((o)=>Object.keys(o)).reduce((a, b)=>a.concat(b), []).concat((_options_external = options.external) != null ? _options_external : []);
+    for (const [exportImportPath, entryFilePath] of Object.entries(entriesAlias)){
+        if (entryFilePath !== entry) {
+            externals.push(exportImportPath);
+            externals.push(entryFilePath);
+        }
+    }
     const { useTypescript, runtime, target: jscTarget, minify: shouldMinify } = options;
     const hasSpecifiedTsTarget = Boolean(tsCompilerOptions.target && tsConfigPath);
     const swcParserConfig = {
@@ -631,10 +636,13 @@ async function buildInputConfig(entry, pkg, options, cwd, { tsConfigPath, tsComp
         inlineSourcesContent: false,
         isModule: true
     };
-    const sizePlugin = sizeCollector.plugin(cwd);
+    const sizePlugin = pluginContext.sizeCollector.plugin(cwd);
     // common plugins for both dts and ts assets that need to be processed
     const commonPlugins = [
-        sizePlugin
+        sizePlugin,
+        aliasEntries({
+            entries: reversedAlias
+        })
     ];
     const baseResolvedTsOptions = {
         declaration: true,
@@ -692,14 +700,7 @@ async function buildInputConfig(entry, pkg, options, cwd, { tsConfigPath, tsComp
         }),
         pluginNodeResolve.nodeResolve({
             preferBuiltins: runtime === 'node',
-            extensions: [
-                '.mjs',
-                '.cjs',
-                '.js',
-                '.json',
-                '.node',
-                '.jsx'
-            ]
+            extensions: nodeResolveExtensions
         }),
         commonjs__default.default({
             exclude: options.external || null
@@ -731,7 +732,8 @@ async function buildInputConfig(entry, pkg, options, cwd, { tsConfigPath, tsComp
                 'MIXED_EXPORTS',
                 'PREFER_NAMED_EXPORTS',
                 'UNRESOLVED_IMPORT',
-                'THIS_IS_UNDEFINED'
+                'THIS_IS_UNDEFINED',
+                'INVALID_ANNOTATION'
             ].includes(code)) return;
             // If the circular dependency warning is from node_modules, ignore it
             if (code === 'CIRCULAR_DEPENDENCY' && /Circular dependency: node_modules/.test(warning.message)) {
@@ -753,23 +755,58 @@ function hasEsmExport(exportPaths, tsCompilerOptions) {
     }
     return Boolean(hasEsm || (tsCompilerOptions == null ? void 0 : tsCompilerOptions.esModuleInterop));
 }
-const splitChunks = (id, ctx)=>{
-    const moduleInfo = ctx.getModuleInfo(id);
-    const moduleMeta = moduleInfo == null ? void 0 : moduleInfo.meta;
-    if (!moduleInfo || !moduleMeta) {
-        return;
-    }
+function getModuleLater(moduleMeta) {
     const directives = (moduleMeta.preserveDirectives || {
         directives: []
     }).directives.map((d)=>d.replace(/^use /, '')).filter((d)=>d !== 'strict');
     const moduleLayer = directives[0];
-    if (moduleLayer && !moduleMeta.isEntry) {
-        const chunkName = path__default.default.basename(id, path__default.default.extname(id));
-        return `${chunkName}-${moduleLayer}`;
-    }
-    return;
-};
-function buildOutputConfigs(pkg, exportPaths, options, exportCondition, cwd, { tsCompilerOptions }, dts) {
+    return moduleLayer;
+}
+// dependencyGraphMap: Map<subModuleId, Set<entryParentId>>
+function createSplitChunks(dependencyGraphMap) {
+    return function splitChunks(id, ctx) {
+        const moduleInfo = ctx.getModuleInfo(id);
+        if (!moduleInfo) {
+            return;
+        }
+        const { isEntry } = moduleInfo;
+        const moduleMeta = moduleInfo.meta;
+        const moduleLayer = getModuleLater(moduleMeta);
+        // Collect the sub modules of the entry, if they're having layer, and the same layer with the entry, push them to the dependencyGraphMap.
+        if (isEntry) {
+            const subModuleIds = ctx.getModuleIds();
+            for (const subId of subModuleIds){
+                const subModuleInfo = ctx.getModuleInfo(subId);
+                if (!subModuleInfo) {
+                    continue;
+                }
+                const subModuleLayer = getModuleLater(moduleMeta);
+                if (subModuleLayer === moduleLayer) {
+                    if (!dependencyGraphMap.has(subId)) {
+                        dependencyGraphMap.set(subId, new Set());
+                    }
+                    dependencyGraphMap.get(subId).add(id);
+                }
+            }
+        }
+        // If current module has a layer, and it's not an entry
+        if (moduleLayer && !isEntry) {
+            // If the module is imported by the entry:
+            // when the module layer is same as entry layer, keep it as part of entry and don't split it;
+            // when the module layer is different from entry layer, split the module into a separate chunk as a separate boundary.
+            if (dependencyGraphMap.has(id)) {
+                const parentModuleLayers = Array.from(dependencyGraphMap.get(id));
+                if (parentModuleLayers.every((layer)=>layer === moduleLayer)) {
+                    return;
+                }
+                const chunkName = path__default.default.basename(id, path__default.default.extname(id));
+                return `${chunkName}-${moduleLayer}`;
+            }
+        }
+        return;
+    };
+}
+function buildOutputConfigs(pkg, exportPaths, options, exportCondition, cwd, { tsCompilerOptions }, pluginContext, dts) {
     const { format } = options;
     // Add esm mark and interop helper if esm export is detected
     const useEsModuleMark = hasEsmExport(exportPaths, tsCompilerOptions);
@@ -795,7 +832,7 @@ function buildOutputConfigs(pkg, exportPaths, options, exportCondition, cwd, { t
         freeze: false,
         strict: false,
         sourcemap: options.sourcemap,
-        manualChunks: splitChunks,
+        manualChunks: createSplitChunks(pluginContext.moduleDirectiveLayerMap),
         chunkFileNames: '[name]-[hash].js',
         // By default in rollup, when creating multiple chunks, transitive imports of entry chunks
         // will be added as empty imports to the entry chunks. Disable to avoid imports hoist outside of boundaries
@@ -803,56 +840,54 @@ function buildOutputConfigs(pkg, exportPaths, options, exportCondition, cwd, { t
         entryFileNames: path.basename(outputFile)
     };
 }
-// build configs for each entry from package exports
-async function buildEntryConfig(pkg, entryPath, exportPaths, bundleConfig, cwd, tsOptions, dts) {
+async function buildEntryConfig(entries, pkg, exportPaths, bundleConfig, cwd, tsOptions, pluginContext, dts) {
     const configs = [];
-    Object.keys(exportPaths).forEach(async (entryExport)=>{
-        const exportCond = exportPaths[entryExport];
-        const buildConfigs = [
-            createBuildConfig('', exportCond)
-        ];
-        // For dts job, only build the default config.
-        // For assets job, build all configs.
-        if (!dts) {
+    for (const exportCondition of Object.values(entries)){
+        const rollupConfig = buildConfig(entries, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, pluginContext, dts);
+        configs.push(rollupConfig);
+    }
+    return await Promise.all(configs);
+}
+/*
+ * build configs for each entry from package exports
+ *
+ * return { <pkg>/<export>: { input: InputOptions, output: OutputOptions[] }
+ */ async function collectEntries(pkg, entryPath, exportPaths, cwd) {
+    const entries = {};
+    async function collectEntry(// export type, e.g. react-server, edge-light those special cases required suffix
+    exportType, exportCondRef, // export name, e.g. ./<export-path> in exports field of package.json
+    entryExport) {
+        let exportCondForType = {
+            ...exportCondRef
+        };
+        // Special cases of export type, only pass down the exportPaths for the type
+        if (availableExportConventions.includes(exportType)) {
+            exportCondForType = {
+                [entryExport]: exportCondRef[exportType]
+            };
+        // Basic export type, pass down the exportPaths with erasing the special ones
+        } else {
             for (const exportType of availableExportConventions){
-                if (exportCond[exportType]) {
-                    buildConfigs.push(createBuildConfig(exportType, exportCond));
-                }
+                delete exportCondForType[exportType];
             }
         }
-        async function createBuildConfig(exportType, exportCondRef) {
-            let exportCondForType = {
-                ...exportCondRef
-            };
-            // Special cases of export type, only pass down the exportPaths for the type
-            if (availableExportConventions.includes(exportType)) {
-                exportCondForType = {
-                    [entryExport]: exportCondRef[exportType]
-                };
-            // Basic export type, pass down the exportPaths with erasing the special ones
-            } else {
-                for (const exportType of availableExportConventions){
-                    delete exportCondForType[exportType];
-                }
-            }
-            let source = entryPath;
-            if (!source) {
-                source = await getSourcePathFromExportPath(cwd, entryExport, exportType);
-            }
-            if (!source) {
-                return undefined;
-            }
-            const exportCondition = {
-                source,
-                name: entryExport,
-                export: exportCondForType
-            };
-            const entry = resolveSourceFile(cwd, source);
-            const rollupConfig = buildConfig(entry, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, dts);
-            return rollupConfig;
+        let source = entryPath;
+        if (source) {
+            source = resolveSourceFile(cwd, source);
+        } else {
+            source = await getSourcePathFromExportPath(cwd, entryExport, exportType);
         }
-        configs.push(...buildConfigs);
-    });
+        if (!source) {
+            return undefined;
+        }
+        const exportCondition = {
+            source,
+            name: entryExport,
+            export: exportCondForType
+        };
+        const entryImportPath = path__default.default.join(pkg.name || '', exportCondition.name) + (exportType ? `.${exportType}` : '');
+        entries[entryImportPath] = exportCondition;
+    }
     const binaryExports = pkg.bin;
     if (binaryExports) {
         // binDistPaths: [ [ 'bin1', './dist/bin1.js'], [ 'bin2', './dist/bin2.js'] ]
@@ -883,35 +918,45 @@ async function buildEntryConfig(pkg, entryPath, exportPaths, bundleConfig, cwd,
                 continue;
             }
             const binEntryPath = await resolveSourceFile(cwd, source);
-            const binEntryConfig = buildConfig(binEntryPath, pkg, binExportPaths, bundleConfig, {
+            entries[binName] = {
                 source: binEntryPath,
                 name: binName,
                 export: binExportPaths[binName]
-            }, cwd, tsOptions, dts);
-            configs.push(binEntryConfig);
+            };
         }
     }
-    return (await Promise.all(configs)).filter(nonNullable);
+    const collectEntriesPromises = Object.keys(exportPaths).map(async (entryExport)=>{
+        const exportCond = exportPaths[entryExport];
+        await collectEntry('', exportCond, entryExport);
+        for (const exportType of availableExportConventions){
+            if (exportCond[exportType]) {
+                await collectEntry(exportType, exportCond, entryExport);
+            }
+        }
+    });
+    await Promise.all(collectEntriesPromises);
+    return entries;
 }
-async function buildConfig(entry, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, dts) {
+async function buildConfig(entries, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, pluginContext, dts) {
     const { file } = bundleConfig;
     const useTypescript = Boolean(tsOptions.tsConfigPath);
     const options = {
         ...bundleConfig,
         useTypescript
     };
-    const inputOptions = await buildInputConfig(entry, pkg, options, cwd, tsOptions, dts);
+    const entry = exportCondition.source;
+    const inputOptions = await buildInputConfig(entry, entries, pkg, options, cwd, tsOptions, pluginContext, dts);
     const outputExports = getExportConditionDist(pkg, exportCondition, cwd);
     let outputConfigs = [];
     // Generate dts job - single config
     if (dts) {
         const typeOutputExports = getExportTypeDist(exportCondition, cwd);
-        outputConfigs = typeOutputExports.map((v)=>buildOutputConfigs(pkg, exportPaths, {
+        outputConfigs = typeOutputExports.map((typeFile)=>buildOutputConfigs(pkg, exportPaths, {
                 ...bundleConfig,
                 format: 'es',
                 useTypescript,
-                file: v
-            }, exportCondition, cwd, tsOptions, dts));
+                file: typeFile
+            }, exportCondition, cwd, tsOptions, pluginContext, dts));
     } else {
         // multi outputs with specified format
         outputConfigs = outputExports.map((exportDist)=>{
@@ -920,7 +965,7 @@ async function buildConfig(entry, pkg, exportPaths, bundleConfig, exportConditio
                 file: exportDist.file,
                 format: exportDist.format,
                 useTypescript
-            }, exportCondition, cwd, tsOptions, dts);
+            }, exportCondition, cwd, tsOptions, pluginContext, dts);
         });
         // CLI output option is always prioritized
         if (file) {
@@ -932,7 +977,7 @@ async function buildConfig(entry, pkg, exportPaths, bundleConfig, exportConditio
                     file,
                     format: bundleConfig.format || fallbackFormat,
                     useTypescript
-                }, exportCondition, cwd, tsOptions, dts)
+                }, exportCondition, cwd, tsOptions, pluginContext, dts)
             ];
         }
     }
@@ -943,6 +988,72 @@ async function buildConfig(entry, pkg, exportPaths, bundleConfig, exportConditio
     };
 }
 
+function createChunkSizeCollector({ entries }) {
+    const sizeStats = new Map();
+    function addSize({ fileName, size, sourceFileName, exportPath }) {
+        if (!sizeStats.has(exportPath)) {
+            sizeStats.set(exportPath, []);
+        }
+        const distFilesStats = sizeStats.get(exportPath);
+        if (distFilesStats) {
+            distFilesStats.push([
+                fileName,
+                sourceFileName,
+                size
+            ]);
+        }
+    }
+    const reversedMapping = new Map();
+    Object.entries(entries).forEach(([, entry])=>{
+        reversedMapping.set(entry.source, entry.name || '.');
+    });
+    return {
+        plugin: (cwd)=>{
+            return {
+                name: 'collect-sizes',
+                augmentChunkHash () {
+                // Do nothing, but use the hook to keep the plugin instance alive
+                },
+                renderChunk (code, chunk, options) {
+                    const sourceId = chunk.facadeModuleId || '';
+                    const dir = options.dir || options.file && path__default.default.dirname(options.file);
+                    let fileName = chunk.fileName;
+                    if (dir) {
+                        const filePath = path__default.default.join(dir, fileName);
+                        fileName = filePath.startsWith(cwd) ? path__default.default.relative(cwd, filePath) : filePath;
+                    }
+                    addSize({
+                        fileName,
+                        size: code.length,
+                        sourceFileName: sourceId,
+                        exportPath: reversedMapping.get(sourceId) || '.'
+                    });
+                    return null;
+                }
+            };
+        },
+        getSizeStats () {
+            return sizeStats;
+        }
+    };
+}
+function logSizeStats(sizeCollector) {
+    const stats = sizeCollector.getSizeStats();
+    const allFileNameLengths = Array.from(stats.values()).flat(1).map(([filename])=>filename.length);
+    const maxLength = Math.max(...allFileNameLengths);
+    [
+        ...stats.entries()
+    ].sort(([a], [b])=>a.length - b.length).forEach(([, filesList])=>{
+        filesList.forEach((item)=>{
+            const [filename, , size] = item;
+            const padding = ' '.repeat(maxLength - filename.length);
+            const action = dtsExtensionRegex.test(filename) ? 'Typed' : 'Built';
+            const prettiedSize = prettyBytes__default.default(size);
+            logger.info(`${action} ${filename}${padding} - ${prettiedSize}`);
+        });
+    });
+}
+
 let hasLoggedTsWarning = false;
 function resolveTypescript(cwd) {
     let ts;
@@ -1107,15 +1218,22 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
         err.name = 'NOT_EXISTED';
         return Promise.reject(err);
     }
-    let result;
-    const buildConfigs = await buildEntryConfig(pkg, entryPath, exportPaths, options, cwd, defaultTsOptions, false);
+    const entries = await collectEntries(pkg, entryPath, exportPaths, cwd);
+    const sizeCollector = createChunkSizeCollector({
+        entries
+    });
+    const pluginContext = {
+        sizeCollector,
+        moduleDirectiveLayerMap: new Map()
+    };
+    const buildConfigs = await buildEntryConfig(entries, pkg, exportPaths, options, cwd, defaultTsOptions, pluginContext, false);
     const assetsJobs = buildConfigs.map((rollupConfig)=>bundleOrWatch(rollupConfig));
-    const typesJobs = hasTsConfig ? (await buildEntryConfig(pkg, entryPath, exportPaths, options, cwd, defaultTsOptions, true)).map((rollupConfig)=>bundleOrWatch(rollupConfig)) : [];
-    result = await Promise.all(assetsJobs.concat(typesJobs));
+    const typesJobs = hasTsConfig ? (await buildEntryConfig(entries, pkg, exportPaths, options, cwd, defaultTsOptions, pluginContext, true)).map((rollupConfig)=>bundleOrWatch(rollupConfig)) : [];
+    const result = await Promise.all(assetsJobs.concat(typesJobs));
     if (result.length === 0) {
         logger.warn('The "src" directory does not contain any entry files. ' + 'For proper usage, please refer to the following link: ' + 'https://github.com/huozhi/bunchee#usage');
     }
-    logSizeStats();
+    logSizeStats(sizeCollector);
     return result;
 }
 function runWatch({ input, output }, metadata) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunchee",
-  "version": "4.1.1",
+  "version": "4.2.1",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",
@@ -47,7 +47,7 @@
   "dependencies": {
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-esm-shim": "^0.1.5",
-    "@rollup/plugin-json": "^6.0.1",
+    "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-replace": "^5.0.5",
     "@rollup/plugin-wasm": "^6.2.2",
@@ -56,8 +56,8 @@
     "@swc/helpers": "^0.5.3",
     "arg": "^5.0.2",
     "pretty-bytes": "^5.6.0",
-    "publint": "~0.2.6",
-    "rollup": "^4.6.1",
+    "publint": "~0.2.7",
+    "rollup": "^4.9.1",
     "rollup-plugin-dts": "^6.1.0",
     "rollup-plugin-swc3": "^0.11.0",
     "rollup-preserve-directives": "^1.1.0",
@@ -86,7 +86,8 @@
     "prettier": "^3.0.0",
     "react": "^18.2.0",
     "tsx": "^4.6.2",
-    "typescript": "^5.3.2"
+    "typescript": "^5.3.2",
+    "bunchee": "link:./"
   },
   "lint-staged": {
     "*.{ts,tsx,js,jsx,md,json,yml}": "prettier --write"