bunchee 4.4.1 → 4.4.3

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 = {
@@ -154,7 +161,7 @@ const hasCjsExtension = (filename)=>path__default.default.extname(filename) ===
 const baseNameWithoutExtension = (filename)=>path__default.default.basename(filename, path__default.default.extname(filename));
 const isTestFile = (filename)=>/\.(test|spec)$/.test(baseNameWithoutExtension(filename));
 
-function getTypings(pkg) {
+function getPackageTypings(pkg) {
     return pkg.types || pkg.typings;
 }
 // Reached the end of the export path
@@ -203,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;
@@ -215,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;
     }
@@ -233,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
@@ -345,7 +382,7 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
     const defaultMainExport = constructFullExportCondition({
         ...mainExportCondition,
         module: pkg.module,
-        types: getTypings(pkg)
+        types: getPackageTypings(pkg)
     }, packageType);
     if (!isEsmPackage && ((_pathsMap_ = pathsMap['.']) == null ? void 0 : _pathsMap_['require'])) {
         // pathsMap's exports.require are prioritized.
@@ -516,7 +553,7 @@ function lint$1(pkg) {
     }
 }
 
-var version = "4.4.1";
+var version = "4.4.3";
 
 function relativify(path) {
     return path.startsWith('.') ? path : `./${path}`;
@@ -851,7 +888,7 @@ async function run(args) {
     }
     // watching mode
     if (watch) {
-        logger.log(`Watching assets in ${cwd}...`);
+        logger.log(`Watching project ${cwd}...`);
         return;
     }
     // build mode

package/dist/index.js

@@ -4,6 +4,7 @@ var rollup = require('rollup');
 var fsp = require('fs/promises');
 var fs = require('fs');
 var path = require('path');
+var perf_hooks = require('perf_hooks');
 var require$$0 = require('tty');
 var module$1 = require('module');
 var rimraf = require('rimraf');
@@ -229,8 +230,14 @@ 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));
@@ -367,23 +374,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;
@@ -414,7 +462,7 @@ function prependDirectives() {
     };
 }
 
-function getTypings(pkg) {
+function getPackageTypings(pkg) {
     return pkg.types || pkg.typings;
 }
 // Reached the end of the export path
@@ -463,6 +511,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;
@@ -475,12 +526,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;
     }
@@ -493,6 +552,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
@@ -605,7 +683,7 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
     const defaultMainExport = constructFullExportCondition({
         ...mainExportCondition,
         module: pkg.module,
-        types: getTypings(pkg)
+        types: getPackageTypings(pkg)
     }, packageType);
     if (!isEsmPackage && ((_pathsMap_ = pathsMap['.']) == null ? void 0 : _pathsMap_['require'])) {
         // pathsMap's exports.require are prioritized.
@@ -635,7 +713,7 @@ function constructDefaultExportCondition(value, packageType) {
     const isEsmPackage = isESModulePackage(packageType);
     let exportCondition;
     if (typeof value === 'string') {
-        const types = getTypings(value);
+        const types = getPackageTypings(value);
         exportCondition = {
             [isEsmPackage ? 'import' : 'require']: value,
             ...types && {
@@ -655,10 +733,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 = [];
@@ -709,7 +789,7 @@ const swcMinifyOptions = {
     }
 };
 // return { 'process.env.<key>': '<value>' }
-function getBuildEnv(envs, exportConditions) {
+function getDefinedInlineVariables(envs, parsedExportCondition) {
     if (!envs.includes('NODE_ENV')) {
         envs.push('NODE_ENV');
     }
@@ -720,13 +800,18 @@ 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')) {
         envVars['process.env.NODE_ENV'] = JSON.stringify('production');
     }
+    if (exportConditionNames.has('edge-light')) {
+        envVars['EdgeRuntime'] = JSON.stringify('edge-runtime');
+    }
     return envVars;
 }
 /**
@@ -744,15 +829,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) {
@@ -760,9 +846,9 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
             externals.push(entryFilePath);
         }
     }
-    const envValues = getBuildEnv(options.env || [], exportCondition.export);
+    const inlineDefinedValues = getDefinedInlineVariables(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',
@@ -780,24 +866,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 = [
@@ -811,7 +898,7 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
         const incrementalOptions = enableIncrementalWithoutBuildInfo ? {
             incremental: false
         } : undefined;
-        const compositeOptions = tsCompilerOptions.composite && enableIncrementalWithoutBuildInfo ? {
+        const compositeOptions = tsCompilerOptions.composite ? {
             composite: false
         } : undefined;
         const { options: overrideResolvedTsOptions } = await convertCompilerOptions(cwd, {
@@ -850,7 +937,7 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
         preserveDirectives__default.default(),
         prependDirectives(),
         replace__default.default({
-            values: envValues,
+            values: inlineDefinedValues,
             preventAssignment: true
         }),
         pluginNodeResolve.nodeResolve({
@@ -866,7 +953,7 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
             ...swcOptions
         }),
         commonjs__default.default({
-            exclude: options.external || null
+            exclude: bundleConfig.external || null
         }),
         json__default.default()
     ]).filter(isNotNull);
@@ -976,20 +1063,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,
@@ -998,7 +1086,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
@@ -1006,19 +1094,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
     };
@@ -1027,8 +1120,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];
         }
@@ -1044,7 +1142,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;
@@ -1106,6 +1204,8 @@ exportType, options) {
             for (const exportCondType of suffixedExportConventions){
                 if (exportCond[exportCondType]) {
                     await collectEntry(exportCondType, collectEntryOptions);
+                } else if (entryExport === '.' + exportCondType) {
+                    await collectEntry(entryExport, collectEntryOptions);
                 }
             }
         }
@@ -1115,14 +1215,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) {
@@ -1166,26 +1260,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
@@ -1377,7 +1463,7 @@ function hasMultiEntryExport(exportPaths) {
 }
 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);
@@ -1421,11 +1507,11 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
     const bundleOrWatch = async (rollupConfig)=>{
         if (options.clean) {
             if (!isFromCli) {
-                await removeOutputDir(rollupConfig.output);
+                await removeOutputDir(rollupConfig.output, cwd);
             }
         }
         if (options.watch) {
-            return Promise.resolve(runWatch(rollupConfig));
+            return runWatch(rollupConfig);
         }
         return runBundle(rollupConfig);
     };
@@ -1474,12 +1560,15 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
     const buildConfigs = await buildEntryConfig(options, buildContext, false);
     const assetsJobs = buildConfigs.map((rollupConfig)=>bundleOrWatch(rollupConfig));
     const typesJobs = hasTsConfig ? (await buildEntryConfig(options, buildContext, true)).map((rollupConfig)=>bundleOrWatch(rollupConfig)) : [];
-    const result = await Promise.all(assetsJobs.concat(typesJobs));
+    const totalJobs = assetsJobs.concat(typesJobs);
+    const result = await Promise.all(totalJobs);
     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');
     }
     if (!options.watch) {
         logOutputState(sizeCollector);
+    } else {
+        logWatcherBuildTime(result);
     }
     return result;
 }
@@ -1496,37 +1585,49 @@ function runWatch({ input, output }) {
         }
     ];
     const watcher = rollup.watch(watchOptions);
-    watcher.on('event', (event)=>{
-        switch(event.code){
-            case 'ERROR':
-                {
-                    logError(event.error);
-                    break;
-                }
-            case 'START':
-                {
-                    break;
-                }
-            case 'END':
-                {
-                    break;
-                }
-            default:
-                return;
+    return watcher;
+}
+function logWatcherBuildTime(result) {
+    let watcherCounter = 0;
+    let startTime = 0;
+    result.map((watcher)=>{
+        function start() {
+            if (startTime === 0) startTime = perf_hooks.performance.now();
+        }
+        function end() {
+            watcherCounter++;
+            if (watcherCounter === result.length) {
+                logger.info(`Build in ${(perf_hooks.performance.now() - startTime).toFixed(2)}ms`);
+            }
         }
+        watcher.on('event', (event)=>{
+            switch(event.code){
+                case 'ERROR':
+                    {
+                        logError(event.error);
+                        break;
+                    }
+                case 'START':
+                    {
+                        start();
+                        break;
+                    }
+                case 'END':
+                    {
+                        end();
+                        break;
+                    }
+            }
+        });
     });
-    return watcher;
 }
-async function removeOutputDir(output) {
-    const dirs = new Set(output.map(({ dir })=>dir));
-    for (const dir of dirs){
-        if (dir) await removeDir(dir);
-    }
+async function removeOutputDir(output, cwd) {
+    const dir = output.dir;
+    if (dir && dir !== cwd) await removeDir(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.1",
+  "version": "4.4.3",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",
@@ -54,7 +54,7 @@
     "@rollup/plugin-replace": "^5.0.5",
     "@rollup/plugin-wasm": "^6.2.2",
     "@rollup/pluginutils": "^5.1.0",
-    "@swc/core": "^1.3.102",
+    "@swc/core": "^1.3.106",
     "@swc/helpers": "^0.5.3",
     "arg": "^5.0.2",
     "clean-css": "^5.3.3",
@@ -79,7 +79,7 @@
   },
   "devDependencies": {
     "@huozhi/testing-package": "1.0.0",
-    "@swc/jest": "^0.2.29",
+    "@swc/jest": "^0.2.31",
     "@swc/types": "^0.1.5",
     "@types/clean-css": "^4.2.11",
     "@types/jest": "29.0.0",