bunchee 4.4.0 → 4.4.2

package/dist/bin/cli.js

@@ -25,6 +25,13 @@ const availableExtensions = new Set([
     'cts',
     'mts'
 ]);
+const suffixedExportConventions = new Set([
+    'react-server',
+    'react-native',
+    'edge-light',
+    'development',
+    'production'
+]);
 const SRC = 'src';
 const DIST = 'dist';
 const dtsExtensionsMap = {
@@ -94,8 +101,9 @@ let createColors = (enabled = isColorSupported)=>({
     });
 picocolors.exports = createColors();
 picocolors.exports.createColors = createColors;
+
 var picocolorsExports = picocolors.exports;
-var pc = /*@__PURE__*/ getDefaultExportFromCjs(picocolorsExports);
+var pc = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
 
 const defaultColorFn = (text)=>text;
 function color(prefixColor) {
@@ -202,6 +210,9 @@ const getFirstExportPath = (fullExportCondition)=>{
     }
     return fullExportCondition;
 };
+const joinExportAndCondition = (exportPath, condition)=>{
+    return (exportPath === '.' ? '' : exportPath) + '.' + condition;
+};
 function findExport(exportPath, exportCondition, paths, packageType, currentPath) {
     // Skip `types` field, it cannot be the entry point
     if (exportPath === 'types') return;
@@ -214,12 +225,20 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
             };
         } else {
             const exportJsBundlePath = getFirstExportPath(fullExportCondition);
-            // exportPath is exportType, import, require, ...
-            // merge to currentPath
-            paths[currentPath] = {
-                ...paths[currentPath],
-                [exportPath]: exportJsBundlePath
-            };
+            if (suffixedExportConventions.has(exportPath)) {
+                const specialPath = joinExportAndCondition(currentPath, exportPath);
+                paths[specialPath] = {
+                    ...paths[specialPath],
+                    ...exportCondition
+                };
+            } else {
+                // exportPath is exportType, import, require, ...
+                // merge to currentPath
+                paths[currentPath] = {
+                    ...paths[currentPath],
+                    [exportPath]: exportJsBundlePath
+                };
+            }
         }
         return;
     }
@@ -232,6 +251,25 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
         } else {
             // subpath is exportType, import, require, ...
             const exportType = subpath;
+            if (typeof exportCondition[subpath] === 'object') {
+                const defaultPath = exportCondition[subpath].default;
+                if (defaultPath) {
+                    const nestedExportCondition = {
+                        [exportType]: defaultPath
+                    };
+                    findExport(exportPath, nestedExportCondition, paths, packageType, currentPath);
+                }
+                // Find special export type, such as import: { development: './dev.js', production: './prod.js' }
+                const conditionSpecialTypes = Object.keys(exportCondition[exportType]).filter((key)=>suffixedExportConventions.has(key));
+                if (conditionSpecialTypes.length > 0) {
+                    for (const conditionSpecialType of conditionSpecialTypes){
+                        const nestedExportConditionPath = {
+                            [exportType]: exportCondition[exportType][conditionSpecialType]
+                        };
+                        findExport(conditionSpecialType, nestedExportConditionPath, paths, packageType, currentPath);
+                    }
+                }
+            }
             const defaultPath = typeof exportCondition[subpath] === 'object' ? exportCondition[subpath].default : exportCondition[subpath];
             const nestedExportCondition = {
                 [exportType]: defaultPath
@@ -334,8 +372,15 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
         };
     }
     // main export '.' from main/module/typings
+    let mainExportCondition;
+    if (pkg.main) {
+        const mainExportType = isEsmPackage ? hasCjsExtension(pkg.main) ? 'require' : 'import' : 'require';
+        mainExportCondition = {
+            [mainExportType]: pkg.main
+        };
+    }
     const defaultMainExport = constructFullExportCondition({
-        [isEsmPackage ? 'import' : 'require']: pkg.main,
+        ...mainExportCondition,
         module: pkg.module,
         types: getTypings(pkg)
     }, packageType);
@@ -401,9 +446,6 @@ function lint$1(pkg) {
     };
     // Validate ESM package
     if (isESM) {
-        if (main && hasCjsExtension(main)) {
-            state.badMainExtension = true;
-        }
         if (exports) {
             if (typeof exports === 'string') {
                 if (hasCjsExtension(exports)) {
@@ -438,6 +480,9 @@ function lint$1(pkg) {
             }
         }
     } else {
+        if (main && path__default.default.extname(main) === '.mjs') {
+            state.badMainExtension = true;
+        }
         // Validate CJS package
         if (exports) {
             if (typeof exports === 'string') {
@@ -474,7 +519,7 @@ function lint$1(pkg) {
         }
     }
     if (state.badMainExtension) {
-        logger.warn('Cannot export `main` field with .cjs extension in ESM package, only .mjs and .js extensions are allowed');
+        logger.warn('Cannot export `main` field with .mjs extension in CJS package, only .js extension is allowed');
     }
     if (state.badMainExport) {
         logger.warn('Cannot export `exports` field with .cjs extension in ESM package, only .mjs and .js extensions are allowed');
@@ -508,7 +553,7 @@ function lint$1(pkg) {
     }
 }
 
-var version = "4.4.0";
+var version = "4.4.2";
 
 function relativify(path) {
     return path.startsWith('.') ? path : `./${path}`;
@@ -709,7 +754,9 @@ async function prepare(cwd) {
             } else {
                 // Update existing exports
                 Object.keys(pkgExports).forEach((exportName)=>{
-                    pkgJson.exports[exportName] = pkgExports[exportName];
+                    if (pkgJson.exports[exportName]) {
+                        pkgJson.exports[exportName] = pkgExports[exportName];
+                    }
                 });
             }
         }
@@ -827,11 +874,11 @@ async function run(args) {
     if (args.prepare) {
         return await prepare(cwd);
     }
-    const entry = source ? path__default.default.resolve(cwd, source) : '';
+    const cliEntry = source ? path__default.default.resolve(cwd, source) : '';
     // lint package
     await lint(cwd);
     try {
-        await bunchee.bundle(entry, bundleConfig);
+        await bunchee.bundle(cliEntry, bundleConfig);
     } catch (err) {
         if (err.name === 'NOT_EXISTED') {
             help();

package/dist/index.d.ts

@@ -33,6 +33,6 @@ type PackageMetadata = {
     typings?: string;
 };
 
-declare function bundle(entryPath: string, { cwd: _cwd, ...options }?: BundleConfig): Promise<any>;
+declare function bundle(cliEntryPath: string, { cwd: _cwd, ...options }?: BundleConfig): Promise<any>;
 
 export { type BundleConfig, bundle };

package/dist/index.js

@@ -82,8 +82,9 @@ let createColors = (enabled = isColorSupported)=>({
     });
 picocolors.exports = createColors();
 picocolors.exports.createColors = createColors;
+
 var picocolorsExports = picocolors.exports;
-var pc = /*@__PURE__*/ getDefaultExportFromCjs(picocolorsExports);
+var pc = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
 
 const availableExtensions = new Set([
     'js',
@@ -228,11 +229,18 @@ async function getSourcePathFromExportPath(cwd, exportPath, exportType) {
 }
 // TODO: add unit test
 // Unlike path.basename, forcedly removing extension
-function filePathWithoutExtension(file) {
-    return file ? file.replace(new RegExp(`${path__default.default.extname(file)}$`), '') : undefined;
+function filePathWithoutExtension(filePath) {
+    if (!filePath) return;
+    const lastDotIndex = filePath.lastIndexOf('.');
+    const lastSlashIndex = filePath.lastIndexOf('/');
+    if (lastDotIndex !== -1 && lastDotIndex > lastSlashIndex) {
+        return filePath.slice(0, filePath.indexOf('.', lastSlashIndex + 1));
+    }
+    return filePath;
 }
 const nonNullable = (n)=>Boolean(n);
 const hasAvailableExtension = (filename)=>availableExtensions.has(path__default.default.extname(filename).slice(1));
+const hasCjsExtension = (filename)=>path__default.default.extname(filename) === '.cjs';
 // TODO: add unit test
 const baseNameWithoutExtension = (filename)=>path__default.default.basename(filename, path__default.default.extname(filename));
 
@@ -365,23 +373,64 @@ function rawContent({ exclude }) {
     };
 }
 
+function relativify(path) {
+    return path.startsWith('.') ? path : `./${path}`;
+}
+
 // 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 }) {
+function aliasEntries({ entry, entries, entriesAlias, format, dts }) {
+    let currentDistPath = '';
+    const entryAliasWithoutSelf = {
+        ...entriesAlias,
+        [entry]: null
+    };
+    const pathToRelativeDistMap = new Map();
+    for (const [, exportCondition] of Object.entries(entries)){
+        var _Object_entries_find;
+        const { import: importCond, require: requireCond, default: defaultCond } = exportCondition.export;
+        const firstCond = (_Object_entries_find = Object.entries(exportCondition.export).find(([key, cond])=>key !== 'types' && cond != null)) == null ? void 0 : _Object_entries_find[1];
+        if (dts) {
+            const fallbackCond = defaultCond || firstCond;
+            // For cjs, use require() instead of import
+            const firstDistPath = (format === 'cjs' ? requireCond : importCond) || fallbackCond;
+            if (firstDistPath) {
+                if (entry !== exportCondition.source) {
+                    pathToRelativeDistMap.set(exportCondition.source, firstDistPath);
+                } else {
+                    currentDistPath = firstDistPath;
+                }
+            }
+        }
+    }
     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
-                        };
+                    if (dts) {
+                        // For types, generate relative path to the other type files,
+                        // this will be compatible for the node10 ts module resolution.
+                        const aliasedId = pathToRelativeDistMap.get(resolvedId.id);
+                        if (aliasedId != null && aliasedId !== currentDistPath) {
+                            const ext = path__default.default.extname(aliasedId);
+                            const filePathBase = filePathWithoutExtension(path__default.default.relative(path__default.default.dirname(currentDistPath), aliasedId));
+                            const relativePath = relativify(filePathBase + ext);
+                            return {
+                                id: relativePath,
+                                external: true
+                            };
+                        }
+                    } else {
+                        const aliasedId = entryAliasWithoutSelf[resolvedId.id];
+                        if (aliasedId != null) {
+                            return {
+                                id: aliasedId
+                            };
+                        }
                     }
                 }
                 return null;
@@ -461,6 +510,9 @@ const getFirstExportPath = (fullExportCondition)=>{
     }
     return fullExportCondition;
 };
+const joinExportAndCondition = (exportPath, condition)=>{
+    return (exportPath === '.' ? '' : exportPath) + '.' + condition;
+};
 function findExport(exportPath, exportCondition, paths, packageType, currentPath) {
     // Skip `types` field, it cannot be the entry point
     if (exportPath === 'types') return;
@@ -473,12 +525,20 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
             };
         } else {
             const exportJsBundlePath = getFirstExportPath(fullExportCondition);
-            // exportPath is exportType, import, require, ...
-            // merge to currentPath
-            paths[currentPath] = {
-                ...paths[currentPath],
-                [exportPath]: exportJsBundlePath
-            };
+            if (suffixedExportConventions.has(exportPath)) {
+                const specialPath = joinExportAndCondition(currentPath, exportPath);
+                paths[specialPath] = {
+                    ...paths[specialPath],
+                    ...exportCondition
+                };
+            } else {
+                // exportPath is exportType, import, require, ...
+                // merge to currentPath
+                paths[currentPath] = {
+                    ...paths[currentPath],
+                    [exportPath]: exportJsBundlePath
+                };
+            }
         }
         return;
     }
@@ -491,6 +551,25 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
         } else {
             // subpath is exportType, import, require, ...
             const exportType = subpath;
+            if (typeof exportCondition[subpath] === 'object') {
+                const defaultPath = exportCondition[subpath].default;
+                if (defaultPath) {
+                    const nestedExportCondition = {
+                        [exportType]: defaultPath
+                    };
+                    findExport(exportPath, nestedExportCondition, paths, packageType, currentPath);
+                }
+                // Find special export type, such as import: { development: './dev.js', production: './prod.js' }
+                const conditionSpecialTypes = Object.keys(exportCondition[exportType]).filter((key)=>suffixedExportConventions.has(key));
+                if (conditionSpecialTypes.length > 0) {
+                    for (const conditionSpecialType of conditionSpecialTypes){
+                        const nestedExportConditionPath = {
+                            [exportType]: exportCondition[exportType][conditionSpecialType]
+                        };
+                        findExport(conditionSpecialType, nestedExportConditionPath, paths, packageType, currentPath);
+                    }
+                }
+            }
             const defaultPath = typeof exportCondition[subpath] === 'object' ? exportCondition[subpath].default : exportCondition[subpath];
             const nestedExportCondition = {
                 [exportType]: defaultPath
@@ -593,8 +672,15 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
         };
     }
     // main export '.' from main/module/typings
+    let mainExportCondition;
+    if (pkg.main) {
+        const mainExportType = isEsmPackage ? hasCjsExtension(pkg.main) ? 'require' : 'import' : 'require';
+        mainExportCondition = {
+            [mainExportType]: pkg.main
+        };
+    }
     const defaultMainExport = constructFullExportCondition({
-        [isEsmPackage ? 'import' : 'require']: pkg.main,
+        ...mainExportCondition,
         module: pkg.module,
         types: getTypings(pkg)
     }, packageType);
@@ -646,10 +732,12 @@ function isEsmExportName(name, ext) {
 }
 function isCjsExportName(pkg, exportCondition, ext) {
     const isESModule = isESModulePackage(pkg.type);
-    return !isESModule && [
+    const isCjsCondition = [
         'require',
         'main'
-    ].includes(exportCondition) && ext !== 'mjs' || ext === 'cjs';
+    ].includes(exportCondition);
+    const isNotEsmExportName = !isEsmExportName(exportCondition, ext);
+    return !isESModule && isNotEsmExportName && (ext !== 'mjs' || isCjsCondition) || ext === 'cjs';
 }
 function getExportsDistFilesOfCondition(pkg, parsedExportCondition, cwd) {
     const dist = [];
@@ -700,7 +788,7 @@ const swcMinifyOptions = {
     }
 };
 // return { 'process.env.<key>': '<value>' }
-function getBuildEnv(envs, exportConditions) {
+function getBuildEnv(envs, parsedExportCondition) {
     if (!envs.includes('NODE_ENV')) {
         envs.push('NODE_ENV');
     }
@@ -711,8 +799,10 @@ function getBuildEnv(envs, exportConditions) {
         }
         return acc;
     }, {});
+    // handle .development, .production
+    const condName = parsedExportCondition.name.startsWith('.') ? parsedExportCondition.name.slice(1) : parsedExportCondition.name;
+    const exportConditionNames = new Set(Object.keys(parsedExportCondition.export).concat(condName));
     // For development and production convention, we override the NODE_ENV value
-    const exportConditionNames = new Set(Object.keys(exportConditions));
     if (exportConditionNames.has('development')) {
         envVars['process.env.NODE_ENV'] = JSON.stringify('development');
     } else if (exportConditionNames.has('production')) {
@@ -735,15 +825,16 @@ function getBuildEnv(envs, exportConditions) {
     }
     return alias;
 }
-async function buildInputConfig(entry, options, buildContext, exportCondition, dts) {
+async function buildInputConfig(entry, bundleConfig, exportCondition, buildContext, dts) {
+    var _bundleConfig_file;
     const { entries, pkg, cwd, tsOptions: { tsConfigPath, tsCompilerOptions }, pluginContext } = buildContext;
-    const hasNoExternal = options.external === null;
-    var _options_external;
+    const hasNoExternal = bundleConfig.external === null;
+    var _bundleConfig_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 : []);
+    ].filter((n)=>Boolean(n)).map((o)=>Object.keys(o)).reduce((a, b)=>a.concat(b), []).concat((_bundleConfig_external = bundleConfig.external) != null ? _bundleConfig_external : []);
     for (const [exportImportPath, exportCondition] of Object.entries(entries)){
         const entryFilePath = exportCondition.source;
         if (entryFilePath !== entry) {
@@ -751,9 +842,9 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
             externals.push(entryFilePath);
         }
     }
-    const envValues = getBuildEnv(options.env || [], exportCondition.export);
+    const envValues = getBuildEnv(bundleConfig.env || [], exportCondition);
     const { useTypeScript } = buildContext;
-    const { runtime, target: jscTarget, minify: shouldMinify } = options;
+    const { runtime, target: jscTarget, minify: shouldMinify } = bundleConfig;
     const hasSpecifiedTsTarget = Boolean(tsCompilerOptions.target && tsConfigPath);
     const swcParserConfig = {
         syntax: useTypeScript ? 'typescript' : 'ecmascript',
@@ -771,24 +862,25 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
             ...shouldMinify && {
                 minify: {
                     ...swcMinifyOptions,
-                    sourceMap: options.sourcemap
+                    sourceMap: bundleConfig.sourcemap
                 }
             }
         },
-        sourceMaps: options.sourcemap,
+        sourceMaps: bundleConfig.sourcemap,
         inlineSourcesContent: false,
         isModule: true
     };
     const sizePlugin = pluginContext.outputState.plugin(cwd);
     // common plugins for both dts and ts assets that need to be processed
+    const aliasFormat = dts ? ((_bundleConfig_file = bundleConfig.file) == null ? void 0 : _bundleConfig_file.endsWith('.d.cts')) ? 'cjs' : 'esm' : bundleConfig.format;
     const commonPlugins = [
         sizePlugin,
         aliasEntries({
-            entries: {
-                ...pluginContext.entriesAlias,
-                // Do not alias current alias of package
-                [entry]: null
-            }
+            entry,
+            entries,
+            entriesAlias: pluginContext.entriesAlias,
+            format: aliasFormat,
+            dts
         })
     ];
     const typesPlugins = [
@@ -798,6 +890,13 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
         })
     ];
     if (useTypeScript) {
+        const enableIncrementalWithoutBuildInfo = tsCompilerOptions.incremental && !tsCompilerOptions.tsBuildInfoFile;
+        const incrementalOptions = enableIncrementalWithoutBuildInfo ? {
+            incremental: false
+        } : undefined;
+        const compositeOptions = tsCompilerOptions.composite && enableIncrementalWithoutBuildInfo ? {
+            composite: false
+        } : undefined;
         const { options: overrideResolvedTsOptions } = await convertCompilerOptions(cwd, {
             declaration: true,
             noEmit: false,
@@ -812,9 +911,9 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
             } : undefined,
             // error TS5074: Option '--incremental' can only be specified using tsconfig, emitting to single
             // file or when option '--tsBuildInfoFile' is specified.
-            ...tsCompilerOptions.incremental && !tsCompilerOptions.tsBuildInfoFile ? {
-                incremental: false
-            } : undefined
+            ...incrementalOptions,
+            // error TS6379: Composite projects may not disable incremental compilation.
+            ...compositeOptions
         });
         const dtsPlugin = require('rollup-plugin-dts').default({
             tsconfig: tsConfigPath,
@@ -841,17 +940,18 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
             preferBuiltins: runtime === 'node',
             extensions: nodeResolveExtensions
         }),
-        commonjs__default.default({
-            exclude: options.external || null
-        }),
-        json__default.default(),
         pluginWasm.wasm(),
         rollupPluginSwc3.swc({
             include: availableESExtensionsRegex,
             exclude: 'node_modules',
-            tsconfig: tsConfigPath,
+            // Use `false` to disable retrieving tsconfig.json
+            tsconfig: tsConfigPath != null ? tsConfigPath : false,
             ...swcOptions
-        })
+        }),
+        commonjs__default.default({
+            exclude: bundleConfig.external || null
+        }),
+        json__default.default()
     ]).filter(isNotNull);
     return {
         input: entry,
@@ -959,20 +1059,21 @@ function createSplitChunks(dependencyGraphMap, entryFiles) {
         return;
     };
 }
-function buildOutputConfigs(options, exportCondition, buildContext, dts) {
-    const { format } = options;
+async function buildOutputConfigs(entry, bundleConfig, exportCondition, buildContext, dts) {
+    const { format } = bundleConfig;
     const { entries, pkg, exportPaths, cwd, tsOptions: { tsCompilerOptions }, pluginContext } = buildContext;
     // Add esm mark and interop helper if esm export is detected
     const useEsModuleMark = hasEsmExport(exportPaths, tsCompilerOptions);
-    const absoluteOutputFile = path.resolve(cwd, options.file);
+    const absoluteOutputFile = path.resolve(cwd, bundleConfig.file);
     const name = filePathWithoutExtension(absoluteOutputFile);
     var _exportCondition_export_types;
-    const dtsFile = path.resolve(cwd, dts ? options.file : (_exportCondition_export_types = exportCondition.export.types) != null ? _exportCondition_export_types : getExportFileTypePath(options.file));
+    const dtsFile = path.resolve(cwd, dts ? bundleConfig.file : (_exportCondition_export_types = exportCondition.export.types) != null ? _exportCondition_export_types : getExportFileTypePath(bundleConfig.file));
     const typesDir = path.dirname(dtsFile);
     const jsDir = path.dirname(absoluteOutputFile);
     const outputFile = dts ? dtsFile : absoluteOutputFile;
     const entryFiles = new Set(Object.values(entries).map((entry)=>entry.source));
-    return {
+    const inputOptions = await buildInputConfig(entry, bundleConfig, exportCondition, buildContext, dts);
+    const outputOptions = {
         name: pkg.name || name,
         dir: dts ? typesDir : jsDir,
         format,
@@ -981,7 +1082,7 @@ function buildOutputConfigs(options, exportCondition, buildContext, dts) {
         interop: 'auto',
         freeze: false,
         strict: false,
-        sourcemap: options.sourcemap,
+        sourcemap: bundleConfig.sourcemap,
         manualChunks: createSplitChunks(pluginContext.moduleDirectiveLayerMap, entryFiles),
         chunkFileNames: '[name]-[hash].js',
         // By default in rollup, when creating multiple chunks, transitive imports of entry chunks
@@ -989,19 +1090,24 @@ function buildOutputConfigs(options, exportCondition, buildContext, dts) {
         hoistTransitiveImports: false,
         entryFileNames: path.basename(outputFile)
     };
+    return {
+        input: inputOptions,
+        output: outputOptions
+    };
 }
 async function buildEntryConfig(bundleConfig, pluginContext, dts) {
     const configs = [];
     const { entries } = pluginContext;
     for (const exportCondition of Object.values(entries)){
-        const rollupConfig = buildConfig(bundleConfig, exportCondition, pluginContext, dts);
-        configs.push(rollupConfig);
+        const rollupConfigs = await buildConfig(bundleConfig, exportCondition, pluginContext, dts);
+        configs.push(...rollupConfigs);
     }
-    return await Promise.all(configs);
+    return configs;
 }
 async function collectEntry(// export type, e.g. react-server, edge-light those special cases required suffix
 exportType, options) {
-    const { cwd, pkg, entries, entryPath, exportCondRef, entryExport } = options;
+    const { cwd, pkg, entries, entryPath, exportCondRef, entryExport: originEntryExport } = options;
+    let entryExport = originEntryExport;
     let exportCondForType = {
         ...exportCondRef
     };
@@ -1010,8 +1116,13 @@ exportType, options) {
         exportCondForType = {
             [exportType]: exportCondRef[exportType]
         };
-    // Basic export type, pass down the exportPaths with erasing the special ones
+    } else if (exportType[0] === '.' && suffixedExportConventions.has(exportType.slice(1))) {
+        // e.g. .development, .production that has both esm and cjs export
+        exportCondForType = exportCondRef;
+        exportType = exportType.slice(1);
+        entryExport = entryExport.replace(exportType, '');
     } else {
+        // Basic export type, pass down the exportPaths with erasing the special ones
         for (const exportType of suffixedExportConventions){
             delete exportCondForType[exportType];
         }
@@ -1027,7 +1138,7 @@ exportType, options) {
     }
     const exportCondition = {
         source,
-        name: entryExport,
+        name: originEntryExport,
         export: exportCondForType
     };
     const nameWithExportPath = pkg.name ? path__default.default.join(pkg.name, exportCondition.name) : exportCondition.name;
@@ -1089,6 +1200,8 @@ exportType, options) {
             for (const exportCondType of suffixedExportConventions){
                 if (exportCond[exportCondType]) {
                     await collectEntry(exportCondType, collectEntryOptions);
+                } else if (entryExport === '.' + exportCondType) {
+                    await collectEntry(entryExport, collectEntryOptions);
                 }
             }
         }
@@ -1098,14 +1211,8 @@ exportType, options) {
 }
 async function buildConfig(bundleConfig, exportCondition, pluginContext, dts) {
     const { file } = bundleConfig;
-    const { pkg, cwd, tsOptions } = pluginContext;
-    const useTypescript = Boolean(tsOptions.tsConfigPath);
-    const options = {
-        ...bundleConfig,
-        useTypescript
-    };
+    const { pkg, cwd } = pluginContext;
     const entry = exportCondition.source;
-    const inputOptions = await buildInputConfig(entry, options, pluginContext, exportCondition, dts);
     const outputExports = getExportsDistFilesOfCondition(pkg, exportCondition, cwd);
     // If there's nothing found, give a default output
     if (outputExports.length === 0 && !pkg.bin) {
@@ -1149,26 +1256,18 @@ async function buildConfig(bundleConfig, exportCondition, pluginContext, dts) {
         bundleOptions = Array.from(uniqTypes).map((typeFile)=>{
             return {
                 resolvedFile: typeFile,
-                format: 'es'
+                format: 'esm'
             };
         });
     }
-    const outputConfigs = bundleOptions.map((bundleOption)=>{
-        return buildOutputConfigs({
+    const outputConfigs = bundleOptions.map(async (bundleOption)=>{
+        return await buildOutputConfigs(entry, {
             ...bundleConfig,
             file: bundleOption.resolvedFile,
             format: bundleOption.format
         }, exportCondition, pluginContext, dts);
     });
-    return {
-        input: inputOptions,
-        output: outputConfigs,
-        exportName: exportCondition.name || '.'
-    };
-}
-
-function relativify(path) {
-    return path.startsWith('.') ? path : `./${path}`;
+    return Promise.all(outputConfigs);
 }
 
 // Example: @foo/bar -> bar
@@ -1284,11 +1383,12 @@ function logOutputState(sizeCollector) {
         }).forEach((item, index)=>{
             const [filename, , size] = item;
             const normalizedExportName = normalizeExportName(exportName);
-            const prefix = index === 0 ? normalizedExportName + ' '.repeat(maxLengthOfExportName - normalizedExportName.length) : ' '.repeat(maxLengthOfExportName);
-            const sizePadding = ' '.repeat(maxFilenameLength - filename.length);
-            const prettiedSize = prettyBytes__default.default(size);
+            const prefix = index === 0 ? normalizedExportName : ' '.repeat(normalizedExportName.length);
+            const filenamePadding = ' '.repeat(Math.max(maxLengthOfExportName, 'Exports'.length) - normalizedExportName.length);
             const isType = isTypeFile(filename);
-            console.log(` ${prefix} ${pc[isType ? 'dim' : 'bold'](filename)}${sizePadding}  ${prettiedSize}`);
+            const sizePadding = ' '.repeat(Math.max(maxFilenameLength, 'File'.length) - filename.length);
+            const prettiedSize = prettyBytes__default.default(size);
+            console.log(prefix, filenamePadding, `${pc[isType ? 'dim' : 'bold'](filename)}`, sizePadding, prettiedSize);
         });
     });
 }
@@ -1357,9 +1457,9 @@ function hasMultiEntryExport(exportPaths) {
     const exportKeys = Object.keys(exportPaths).filter((key)=>key !== './package.json');
     return exportKeys.length > 0 && exportKeys.every((name)=>name.startsWith('.'));
 }
-async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
+async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
     const cwd = path.resolve(process.cwd(), _cwd || '');
-    assignDefault(options, 'format', 'es');
+    assignDefault(options, 'format', 'esm');
     assignDefault(options, 'minify', false);
     assignDefault(options, 'target', 'es2015');
     const pkg = await getPackageMeta(cwd);
@@ -1369,6 +1469,7 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
     const isMultiEntries = hasMultiEntryExport(exportPaths) // exportPathsLength > 1
     ;
     const hasBin = Boolean(pkg.bin);
+    const isFromCli = Boolean(cliEntryPath);
     let tsConfig = await resolveTsConfig(cwd);
     let hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
     const defaultTsOptions = {
@@ -1379,10 +1480,10 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
     if (!isMultiEntries) {
         // Use specified string file path if possible, then fallback to the default behavior entry picking logic
         // e.g. "exports": "./dist/index.js" -> use "./index.<ext>" as entry
-        entryPath = entryPath || await getSourcePathFromExportPath(cwd, '.', 'default') || '';
+        cliEntryPath = cliEntryPath || await getSourcePathFromExportPath(cwd, '.', 'default') || '';
     }
     // Handle CLI input
-    if (entryPath) {
+    if (cliEntryPath) {
         let mainEntryPath;
         let typesEntryPath;
         // with -o option
@@ -1401,18 +1502,20 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
     }
     const bundleOrWatch = async (rollupConfig)=>{
         if (options.clean) {
-            await removeOutputDir(rollupConfig.output);
+            if (!isFromCli) {
+                await removeOutputDir(rollupConfig.output);
+            }
         }
         if (options.watch) {
             return Promise.resolve(runWatch(rollupConfig));
         }
         return runBundle(rollupConfig);
     };
-    const hasSpecifiedEntryFile = entryPath ? fs__default.default.existsSync(entryPath) && (await fsp__default.default.stat(entryPath)).isFile() : false;
+    const hasSpecifiedEntryFile = cliEntryPath ? fs__default.default.existsSync(cliEntryPath) && (await fsp__default.default.stat(cliEntryPath)).isFile() : false;
     const hasNoEntry = !hasSpecifiedEntryFile && !isMultiEntries && !hasBin;
     if (hasNoEntry) {
-        if (entryPath) {
-            const err = new Error(`Entry file "${entryPath}" does not exist`);
+        if (cliEntryPath) {
+            const err = new Error(`Entry file "${cliEntryPath}" does not exist`);
             err.name = 'NOT_EXISTED';
             return Promise.reject(err);
         } else if (cwd) {
@@ -1424,7 +1527,7 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
             }
         }
     }
-    const entries = await collectEntries(pkg, entryPath, exportPaths, cwd);
+    const entries = await collectEntries(pkg, cliEntryPath, exportPaths, cwd);
     const hasTypeScriptFiles = Object.values(entries).some((entry)=>isTypescriptFile(entry.source));
     if (hasTypeScriptFiles && !hasTsConfig) {
         const tsConfigPath = path.resolve(cwd, 'tsconfig.json');
@@ -1497,15 +1600,11 @@ function runWatch({ input, output }) {
     return watcher;
 }
 async function removeOutputDir(output) {
-    const dirs = new Set(output.map(({ dir })=>dir));
-    for (const dir of dirs){
-        if (dir) await removeDir(dir);
-    }
+    if (output.dir) await removeDir(output.dir);
 }
 function runBundle({ input, output }) {
     return rollup.rollup(input).then((bundle)=>{
-        const writeJobs = output.map((options)=>bundle.write(options));
-        return Promise.all(writeJobs);
+        return bundle.write(output);
     }, catchErrorHandler);
 }
 function logError(error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunchee",
-  "version": "4.4.0",
+  "version": "4.4.2",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",