bunchee 4.3.2 → 4.3.4

package/README.md

@@ -34,6 +34,7 @@ npm install --save-dev bunchee typescript
 ### Configuration
 
 Create your library entry file and package.json.
+
 ```sh
 cd ./my-lib
 mkdir src && touch ./src/index.ts
@@ -57,6 +58,7 @@ Or you can checkout the following cases to configure your package.json.
   <summary> JavaScript</summary>
 
 Then use use the [exports field in package.json](https://nodejs.org/api/packages.html#exports-sugar) to configure different conditions and leverage the same functionality as other bundlers, such as webpack. The exports field allows you to define multiple conditions.
+
 ```json
 {
   "files": ["dist"],
@@ -69,6 +71,7 @@ Then use use the [exports field in package.json](https://nodejs.org/api/packages
   }
 }
 ```
+
 </details>
 
 <details>
@@ -94,8 +97,8 @@ If you're build a TypeScript library, separate the types from the main entry fil
   }
 }
 ```
-</details>
 
+</details>
 
 <details>
   <summary>Hybrid (CJS & ESM) Module Resolution with TypeScript</summary>
@@ -122,6 +125,7 @@ If you're using TypeScript with Node 10 and Node 16 module resolution, you can u
   }
 }
 ```
+
 </details>
 
 #### Build
@@ -240,7 +244,6 @@ This will match the `bin` field in package.json as:
 
 > Note: For multiple `bin` files, the filename should match the key name in the `bin` field.
 
-
 ### Server Components
 
 `bunchee` supports to build server components and server actions with library directives like `"use client"` or `"use server"`. It will generate the corresponding chunks for client and server that scope the client and server boundaries properly.
@@ -280,7 +283,7 @@ bunchee ./src/index.js --runtime node --target es2019
 
 #### Specifying extra external dependencies
 
-By default, `bunchee` will mark all the `dependencies` and `peerDependencies` as externals so you don't need to pass them as CLI args. 
+By default, `bunchee` will mark all the `dependencies` and `peerDependencies` as externals so you don't need to pass them as CLI args.
 But if there's any dependency that used but not in the dependency list and you want to mark as external, you can use the `--external` option to specify them.
 
 ```sh
@@ -309,7 +312,6 @@ bunchee --env=ENV1,ENV2,ENV3
 
 Replace `ENV1`, `ENV2`, and `ENV3` with the names of the environment variables you want to include in your bundled code. These environment variables will be inlined during the bundling process.
 
-
 You can use `index.<export-type>.<ext>` to override the input source file for specific export name. Or using `<export-path>/index.<export-type>.<ext>` also works. Such as:
 
 ```
@@ -321,7 +323,6 @@ You can use `index.<export-type>.<ext>` to override the input source file for sp
 
 This will match the export name `"react-server"` and `"edge-light"` then use the corresponding input source file to build the bundle.
 
-
 ### Wildcard Exports
 
 Bunchee implements the Node.js feature of using the asterisk `*` as a wildcard to match the exportable entry files.
@@ -402,6 +403,7 @@ If you just want to import a file as string content, you can name the extension
 For example:
 
 src/index.ts
+
 ```js
 import data from './data.txt'
 
@@ -409,11 +411,13 @@ export default data
 ```
 
 src/data.txt
+
 ```txt
 hello world
 ```
 
 output
+
 ```
 export default "hello world"
 ```
@@ -450,7 +454,6 @@ If you specify `target` option in `tsconfig.json`, then you don't have to pass i
 
 `bunchee` has support for checking the package bundles are matched with package exports configuration.
 
-
 ### License
 
 MIT

package/dist/bin/cli.js

@@ -14,7 +14,7 @@ var fs__default = /*#__PURE__*/_interopDefault(fs);
 var fsp__default = /*#__PURE__*/_interopDefault(fsp);
 var require$$0__default = /*#__PURE__*/_interopDefault(require$$0);
 
-const availableExtensions = [
+const availableExtensions = new Set([
     'js',
     'cjs',
     'mjs',
@@ -23,19 +23,19 @@ const availableExtensions = [
     'tsx',
     'cts',
     'mts'
-];
+]);
 const SRC = 'src';
 const dtsExtensionsMap = {
     js: 'd.ts',
     cjs: 'd.cts',
     mjs: 'd.mts'
 };
-const tsExtensions = [
+const tsExtensions = new Set([
     'ts',
     'tsx',
     'cts',
     'mts'
-];
+]);
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -134,21 +134,28 @@ async function getPackageMeta(cwd) {
 }
 function isTypescriptFile(filename) {
     const ext = path__default.default.extname(filename).slice(1);
-    return tsExtensions.includes(ext);
+    return tsExtensions.has(ext);
 }
 function fileExists(filePath) {
     return fs__default.default.existsSync(filePath);
 }
-const hasAvailableExtension = (filename)=>availableExtensions.includes(path__default.default.extname(filename).slice(1));
+const hasAvailableExtension = (filename)=>availableExtensions.has(path__default.default.extname(filename).slice(1));
+// TODO: add unit test
 const baseNameWithoutExtension = (filename)=>path__default.default.basename(filename, path__default.default.extname(filename));
 
-var version = "4.3.2";
+var version = "4.3.4";
 
 function relativify(path) {
     return path.startsWith('.') ? path : `./${path}`;
 }
 
 const DIST = 'dist';
+const DEFAULT_TS_CONFIG = {
+    compilerOptions: {
+        module: 'ESNext',
+        moduleResolution: 'bundler'
+    }
+};
 // Output with posix style in package.json
 function getDistPath(...subPaths) {
     return `./${DIST}/${subPaths.join('/')}`;
@@ -159,14 +166,16 @@ const normalizeBaseNameToExportName = (baseName)=>{
 function createExportCondition(exportName, sourceFile, moduleType) {
     const isTsSourceFile = isTypescriptFile(sourceFile);
     let cjsExtension = 'js';
+    let esmExtension = 'mjs';
     if (moduleType === 'module') {
         cjsExtension = 'cjs';
+        esmExtension = 'js';
     }
     if (isTsSourceFile) {
         return {
             import: {
-                types: getDistPath('es', `${exportName}.d.mts`),
-                default: getDistPath('es', `${exportName}.mjs`)
+                types: getDistPath('es', `${exportName}.${dtsExtensionsMap[esmExtension]}`),
+                default: getDistPath('es', `${exportName}.${esmExtension}`)
             },
             require: {
                 types: getDistPath('cjs', `${exportName}.${dtsExtensionsMap[cjsExtension]}`),
@@ -193,18 +202,17 @@ async function collectSourceEntries(sourceFolderPath) {
                 });
                 for (const binDirent of binDirentList){
                     if (binDirent.isFile()) {
-                        const binFile = path__default.default.join(sourceFolderPath, dirent.name, binDirent.name);
+                        const binFileAbsolutePath = path__default.default.join(sourceFolderPath, dirent.name, binDirent.name);
                         const binName = baseNameWithoutExtension(binDirent.name);
-                        if (fs__default.default.existsSync(binFile)) {
+                        if (fs__default.default.existsSync(binFileAbsolutePath)) {
                             bins.set(binName, binDirent.name);
                         }
                     }
                 }
             } else {
                 // Search folder/<index>.<ext> convention entries
-                const extensions = availableExtensions;
-                for (const extension of extensions){
-                    const indexFile = path__default.default.join(sourceFolderPath, dirent.name, `index.${extension}`);
+                for (const extension of availableExtensions){
+                    const indexFile = path__default.default.join(dirent.name, `index.${extension}`);
                     if (fs__default.default.existsSync(indexFile)) {
                         exportsEntries.set(dirent.name, indexFile);
                         break;
@@ -212,7 +220,7 @@ async function collectSourceEntries(sourceFolderPath) {
                 }
             }
         } else if (dirent.isFile()) {
-            const isAvailableExtension = availableExtensions.includes(path__default.default.extname(dirent.name).slice(1));
+            const isAvailableExtension = availableExtensions.has(path__default.default.extname(dirent.name).slice(1));
             if (isAvailableExtension) {
                 const baseName = baseNameWithoutExtension(dirent.name);
                 const isBinFile = baseName === 'bin';
@@ -277,16 +285,16 @@ async function prepare(cwd) {
     // Collect bins and exports entries
     const { bins, exportsEntries } = await collectSourceEntries(sourceFolder);
     const tsconfigPath = path__default.default.join(cwd, 'tsconfig.json');
-    if (!fs__default.default.existsSync(tsconfigPath)) {
-        const sourceFiles = [
-            ...exportsEntries.values()
-        ].concat([
-            ...bins.values()
-        ]);
-        const hasTypeScriptFiles = sourceFiles.some((filename)=>isTypescriptFile(filename));
-        if (hasTypeScriptFiles) {
-            isUsingTs = true;
-            await fsp__default.default.writeFile(tsconfigPath, '{}', 'utf-8');
+    const sourceFiles = [
+        ...exportsEntries.values()
+    ].concat([
+        ...bins.values()
+    ]);
+    const hasTypeScriptFiles = sourceFiles.some((filename)=>isTypescriptFile(filename));
+    if (hasTypeScriptFiles) {
+        isUsingTs = true;
+        if (!fs__default.default.existsSync(tsconfigPath)) {
+            await fsp__default.default.writeFile(tsconfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
             logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
         }
     }
@@ -333,12 +341,19 @@ async function prepare(cwd) {
             pkgJson.main = isUsingTs ? mainExport[mainCondition].default : mainExport[mainCondition];
             pkgJson.module = isUsingTs ? mainExport.import.default : mainExport.import;
             if (isUsingTs) {
-                pkgJson.types = isESM ? mainExport.import.types : mainExport.require.types;
+                pkgJson.types = mainExport[mainCondition].types;
             }
         }
         // Assign the properties by order: files, main, module, types, exports
         if (Object.keys(pkgExports).length > 0) {
-            pkgJson.exports = pkgExports;
+            if (!pkgJson.exports) {
+                pkgJson.exports = pkgExports;
+            } else {
+                // Update existing exports
+                Object.keys(pkgExports).forEach((exportName)=>{
+                    pkgJson.exports[exportName] = pkgExports[exportName];
+                });
+            }
         }
     }
     await fsp__default.default.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));

package/dist/index.js

@@ -30,7 +30,7 @@ var esmShim__default = /*#__PURE__*/_interopDefault(esmShim);
 var preserveDirectives__default = /*#__PURE__*/_interopDefault(preserveDirectives);
 var prettyBytes__default = /*#__PURE__*/_interopDefault(prettyBytes);
 
-const availableExtensions = [
+const availableExtensions = new Set([
     'js',
     'cjs',
     'mjs',
@@ -39,7 +39,7 @@ const availableExtensions = [
     'tsx',
     'cts',
     'mts'
-];
+]);
 const nodeResolveExtensions = [
     '.mjs',
     '.cjs',
@@ -48,11 +48,11 @@ const nodeResolveExtensions = [
     '.node',
     '.jsx'
 ];
-const availableExportConventions = [
+const availableExportConventions = new Set([
     'react-server',
     'react-native',
     'edge-light'
-];
+]);
 const availableESExtensionsRegex = /\.(m|c)?[jt]sx?$/;
 const SRC = 'src';
 const dtsExtensionsMap = {
@@ -191,7 +191,7 @@ async function getSourcePathFromExportPath(cwd, exportPath, exportType) {
         if (exportPath === '.') exportPath = './index';
         // Find convention-based source file for specific export types
         // $binary represents `pkg.bin`
-        if (availableExportConventions.includes(exportType) && exportType !== '$binary') {
+        if (availableExportConventions.has(exportType) && exportType !== '$binary') {
             const filename = await findSourceEntryFile(cwd, exportPath, exportType, ext);
             if (filename) return filename;
         }
@@ -200,13 +200,16 @@ async function getSourcePathFromExportPath(cwd, exportPath, exportType) {
     }
     return;
 }
+// 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;
 }
 const nonNullable = (n)=>Boolean(n);
-const hasAvailableExtension = (filename)=>availableExtensions.includes(path__default.default.extname(filename).slice(1));
+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));
 
 let hasLoggedTsWarning = false;
 function resolveTypescript(cwd) {
@@ -391,9 +394,6 @@ function prependDirectives() {
 function getTypings(pkg) {
     return pkg.types || pkg.typings;
 }
-function getDistPath(distPath, cwd) {
-    return path.resolve(cwd, distPath);
-}
 // Reached the end of the export path
 function isExportLike(field) {
     if (typeof field === 'string') return true;
@@ -585,31 +585,6 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
     }
     return pathsMap;
 }
-const getExportTypeDist = (parsedExportCondition, cwd)=>{
-    const existed = new Set();
-    const exportTypes = Object.keys(parsedExportCondition.export);
-    for (const key of exportTypes){
-        if (key === 'module') {
-            continue;
-        }
-        const filePath = parsedExportCondition.export[key];
-        if (key === 'types') {
-            const typeFile = getDistPath(filePath, cwd);
-            if (existed.has(typeFile)) {
-                continue;
-            }
-            existed.add(typeFile);
-            continue;
-        }
-        const ext = path.extname(filePath).slice(1);
-        const typeFile = getDistPath(`${filePathWithoutExtension(filePath) || ''}.${dtsExtensionsMap[ext]}`, cwd);
-        if (existed.has(typeFile)) {
-            continue;
-        }
-        existed.add(typeFile);
-    }
-    return Array.from(existed);
-};
 function getPackageType(pkg) {
     return pkg.type || 'commonjs';
 }
@@ -638,55 +613,43 @@ function isEsmExportName(name, ext) {
         'module'
     ].includes(name) || ext === 'mjs';
 }
-function isCjsExportName(pkg, name, ext) {
+function isCjsExportName(pkg, exportCondition, ext) {
     const isESModule = isESModulePackage(pkg.type);
     return !isESModule && [
         'require',
-        'main',
-        'node'
-    ].includes(name) && ext !== 'mjs' || ext === 'cjs';
+        'main'
+    ].includes(exportCondition) && ext !== 'mjs' || ext === 'cjs';
 }
-function getExportConditionDist(pkg, parsedExportCondition, cwd) {
+function getExportsDistFilesOfCondition(pkg, parsedExportCondition, cwd) {
     const dist = [];
-    const existed = new Set();
-    const exportTypes = Object.keys(parsedExportCondition.export);
-    for (const exportType of exportTypes){
-        if (exportType === 'types') {
+    const exportConditionNames = Object.keys(parsedExportCondition.export);
+    const uniqueFiles = new Set();
+    for (const exportCondition of exportConditionNames){
+        if (exportCondition === 'types') {
             continue;
         }
-        const filePath = parsedExportCondition.export[exportType];
+        const filePath = parsedExportCondition.export[exportCondition];
         const ext = path.extname(filePath).slice(1);
-        const relativePath = parsedExportCondition.export[exportType];
-        const distFile = getDistPath(relativePath, cwd);
-        let format = 'esm';
-        if (isCjsExportName(pkg, exportType, ext)) {
-            format = 'cjs';
-        }
-        // Deduplicate the same path jobs
-        // TODO: detect conflicts paths but with different format
-        if (existed.has(distFile)) {
+        const relativePath = parsedExportCondition.export[exportCondition];
+        const distFile = path.resolve(cwd, relativePath);
+        const format = isCjsExportName(pkg, exportCondition, ext) ? 'cjs' : 'esm';
+        if (uniqueFiles.has(distFile)) {
             continue;
         }
-        existed.add(distFile);
+        uniqueFiles.add(distFile);
         dist.push({
             format,
             file: distFile
         });
     }
-    if (dist.length === 0 && !pkg.bin) {
-        const defaultFormat = isESModulePackage(pkg.type) ? 'esm' : 'cjs';
-        dist.push({
-            format: defaultFormat,
-            file: getDistPath('dist/index.js', cwd)
-        });
-    }
     return dist;
 }
-function getTypeFilePath(entryFilePath, exportCondition, cwd) {
-    const name = filePathWithoutExtension(entryFilePath);
-    const firstDistPath = exportCondition ? Object.values(exportCondition.export)[0] : undefined;
-    const exportName = (exportCondition == null ? void 0 : exportCondition.name) || 'index';
-    return entryFilePath ? name + '.d.ts' : path.resolve(firstDistPath ? path.dirname(firstDistPath) : path.join(cwd, 'dist'), (exportName === '.' ? 'index' : exportName) + '.d.ts');
+function getExportFileTypePath(absoluteJsBundlePath) {
+    const dirName = path.dirname(absoluteJsBundlePath);
+    const baseName = baseNameWithoutExtension(absoluteJsBundlePath);
+    const ext = path.extname(absoluteJsBundlePath).slice(1);
+    const typeExtension = dtsExtensionsMap[ext];
+    return path.join(dirName, baseName + '.' + typeExtension);
 }
 function getExportTypeFromFile(filename, pkgType) {
     const isESModule = isESModulePackage(pkgType);
@@ -719,7 +682,9 @@ function getBuildEnv(envs) {
     return envVars;
 }
 /**
- * return { '<absolute source path>': '<pkg>/<export>' }
+ * return { 
+ *   <absolute source path>: <pkg>/<export>
+ * }
  */ function getReversedAlias(entries) {
     const alias = {};
     for (const [entryImportPath, exportCondition] of Object.entries(entries)){
@@ -731,7 +696,7 @@ function getBuildEnv(envs) {
     }
     return alias;
 }
-async function buildInputConfig(entry, options, buildContext, dts) {
+async function buildInputConfig(entry, options, buildContext, exportCondition, dts) {
     const { entries, pkg, cwd, tsOptions: { tsConfigPath, tsCompilerOptions }, pluginContext } = buildContext;
     const hasNoExternal = options.external === null;
     var _options_external;
@@ -747,11 +712,12 @@ async function buildInputConfig(entry, options, buildContext, dts) {
             externals.push(entryFilePath);
         }
     }
-    const { useTypescript, runtime, target: jscTarget, minify: shouldMinify } = options;
+    const { useTypeScript } = buildContext;
+    const { runtime, target: jscTarget, minify: shouldMinify } = options;
     const hasSpecifiedTsTarget = Boolean(tsCompilerOptions.target && tsConfigPath);
     const swcParserConfig = {
-        syntax: useTypescript ? 'typescript' : 'ecmascript',
-        [useTypescript ? 'tsx' : 'jsx']: true,
+        syntax: useTypeScript ? 'typescript' : 'ecmascript',
+        [useTypeScript ? 'tsx' : 'jsx']: true,
         exportDefaultFrom: true
     };
     const swcOptions = {
@@ -791,7 +757,7 @@ async function buildInputConfig(entry, options, buildContext, dts) {
             skip: true
         })
     ];
-    if (useTypescript) {
+    if (useTypeScript) {
         const { options: overrideResolvedTsOptions } = await convertCompilerOptions(cwd, {
             declaration: true,
             noEmit: false,
@@ -801,16 +767,14 @@ async function buildInputConfig(entry, options, buildContext, dts) {
             declarationMap: false,
             skipLibCheck: true,
             target: 'ESNext',
-            // Some react types required this to be false by default.
-            // Some type package like express might need this as it has other dependencies.
-            // Let users able to toggle this in tsconfig.
-            preserveSymlinks: 'preserveSymlinks' in tsCompilerOptions ? tsCompilerOptions.preserveSymlinks : false,
             ...!tsCompilerOptions.jsx ? {
                 jsx: 'react-jsx'
             } : undefined,
             // error TS5074: Option '--incremental' can only be specified using tsconfig, emitting to single
             // file or when option '--tsBuildInfoFile' is specified.
-            incremental: false
+            ...tsCompilerOptions.incremental && !tsCompilerOptions.tsBuildInfoFile ? {
+                incremental: false
+            } : undefined
         });
         const dtsPlugin = require('rollup-plugin-dts').default({
             tsconfig: tsConfigPath,
@@ -960,22 +924,17 @@ function buildOutputConfigs(options, exportCondition, buildContext, dts) {
     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 typings = getTypings(pkg);
-    const file = options.file && path.resolve(cwd, options.file);
-    const dtsDir = typings ? path.dirname(path.resolve(cwd, typings)) : path.resolve(cwd, 'dist');
-    const name = filePathWithoutExtension(file);
-    // TODO: simplify dts file name detection
-    const dtsFile = file ? file : exportCondition.export['types'] ? path.resolve(cwd, exportCondition.export['types']) : path.resolve(dtsDir, (exportCondition.name === '.' ? 'index' : exportCondition.name) + '.d.ts');
-    const dtsPathConfig = {
-        dir: dtsFile ? path.dirname(dtsFile) : dtsDir
-    };
-    const outputFile = dtsFile || file;
+    const absoluteOutputFile = path.resolve(cwd, options.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 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 {
         name: pkg.name || name,
-        ...dts ? dtsPathConfig : {
-            dir: path.dirname(outputFile)
-        },
+        dir: dts ? typesDir : jsDir,
         format,
         exports: 'named',
         esModule: useEsModuleMark || 'if-default-prop',
@@ -1013,9 +972,9 @@ async function buildEntryConfig(bundleConfig, pluginContext, dts) {
             ...exportCondRef
         };
         // Special cases of export type, only pass down the exportPaths for the type
-        if (availableExportConventions.includes(exportType)) {
+        if (availableExportConventions.has(exportType)) {
             exportCondForType = {
-                [entryExport]: exportCondRef[exportType]
+                [exportType]: exportCondRef[exportType]
             };
         // Basic export type, pass down the exportPaths with erasing the special ones
         } else {
@@ -1098,42 +1057,61 @@ async function buildConfig(bundleConfig, exportCondition, pluginContext, dts) {
         useTypescript
     };
     const entry = exportCondition.source;
-    const inputOptions = await buildInputConfig(entry, options, 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((typeFile)=>buildOutputConfigs({
-                ...bundleConfig,
-                format: 'es',
-                useTypescript,
-                file: typeFile
-            }, exportCondition, pluginContext, dts));
+    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) {
+        const defaultFormat = isESModulePackage(pkg.type) ? 'esm' : 'cjs';
+        outputExports.push({
+            format: defaultFormat,
+            file: path.join(cwd, 'dist/index.js')
+        });
+    }
+    let bundleOptions = [];
+    // multi outputs with specified format
+    // CLI output option is always prioritized
+    if (file) {
+        var _outputExports_;
+        const fallbackFormat = (_outputExports_ = outputExports[0]) == null ? void 0 : _outputExports_.format;
+        bundleOptions = [
+            {
+                resolvedFile: path.resolve(cwd, file),
+                format: bundleConfig.format || fallbackFormat
+            }
+        ];
     } else {
-        // multi outputs with specified format
-        outputConfigs = outputExports.map((exportDist)=>{
-            return buildOutputConfigs({
-                ...bundleConfig,
-                file: exportDist.file,
-                format: exportDist.format,
-                useTypescript
-            }, exportCondition, pluginContext, dts);
+        bundleOptions = outputExports.map((exportDist)=>{
+            return {
+                resolvedFile: path.resolve(cwd, exportDist.file),
+                format: exportDist.format
+            };
         });
-        // CLI output option is always prioritized
-        if (file) {
-            var _outputExports_;
-            const fallbackFormat = (_outputExports_ = outputExports[0]) == null ? void 0 : _outputExports_.format;
-            outputConfigs = [
-                buildOutputConfigs({
-                    ...bundleConfig,
-                    file,
-                    format: bundleConfig.format || fallbackFormat,
-                    useTypescript
-                }, exportCondition, pluginContext, dts)
-            ];
-        }
     }
+    if (dts) {
+        // types could have duplicates, dedupe them
+        // e.g. { types, import, .. } use the same `types` condition with all conditions
+        const uniqTypes = new Set();
+        bundleOptions.forEach((bundleOption)=>{
+            if (exportCondition.export.types) {
+                uniqTypes.add(path.resolve(cwd, exportCondition.export.types));
+            }
+            const typeForExtension = getExportFileTypePath(bundleOption.resolvedFile);
+            uniqTypes.add(typeForExtension);
+        });
+        bundleOptions = Array.from(uniqTypes).map((typeFile)=>{
+            return {
+                resolvedFile: typeFile,
+                format: 'es'
+            };
+        });
+    }
+    const outputConfigs = bundleOptions.map((bundleOption)=>{
+        return buildOutputConfigs({
+            ...bundleConfig,
+            file: bundleOption.resolvedFile,
+            format: bundleOption.format
+        }, exportCondition, pluginContext, dts);
+    });
     return {
         input: inputOptions,
         output: outputConfigs,
@@ -1336,8 +1314,6 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
     const resolvedWildcardExports = await resolveWildcardExports(pkg.exports, cwd);
     const packageType = getPackageType(pkg);
     const exportPaths = getExportPaths(pkg, packageType, resolvedWildcardExports);
-    const exportKeys = Object.keys(exportPaths).filter((key)=>key !== './package.json');
-    // const exportPathsLength = Object.keys(exportPaths).length
     const isMultiEntries = hasMultiEntryExport(exportPaths) // exportPathsLength > 1
     ;
     const hasBin = Boolean(pkg.bin);
@@ -1359,12 +1335,10 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
         // with -o option
         if (options.file) {
             mainEntryPath = options.file;
-        } else if (exportKeys.length === 0) {
-            mainEntryPath = path.resolve(cwd, 'dist/index.js');
         }
         if (mainEntryPath) {
             if (options.dts) {
-                typesEntryPath = getTypeFilePath(mainEntryPath, undefined, cwd);
+                typesEntryPath = getExportFileTypePath(mainEntryPath);
             }
             exportPaths['.'] = constructDefaultExportCondition({
                 main: mainEntryPath,
@@ -1409,6 +1383,7 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
         exportPaths,
         cwd,
         tsOptions: defaultTsOptions,
+        useTypeScript: hasTsConfig,
         pluginContext: {
             outputState: sizeCollector,
             moduleDirectiveLayerMap: new Map(),
@@ -1422,7 +1397,9 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
     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');
     }
-    logOutputState(sizeCollector);
+    if (!options.watch) {
+        logOutputState(sizeCollector);
+    }
     return result;
 }
 function runWatch({ input, output }, metadata) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunchee",
-  "version": "4.3.2",
+  "version": "4.3.4",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",
@@ -54,12 +54,12 @@
     "@rollup/plugin-replace": "^5.0.5",
     "@rollup/plugin-wasm": "^6.2.2",
     "@rollup/pluginutils": "^5.1.0",
-    "@swc/core": "^1.3.99",
+    "@swc/core": "^1.3.102",
     "@swc/helpers": "^0.5.3",
     "arg": "^5.0.2",
     "pretty-bytes": "^5.6.0",
     "publint": "~0.2.7",
-    "rollup": "^4.9.1",
+    "rollup": "^4.9.4",
     "rollup-plugin-dts": "^6.1.0",
     "rollup-plugin-swc3": "^0.11.0",
     "rollup-preserve-directives": "^1.1.1",