bunchee 4.3.3 → 4.4.0

package/dist/index.js

@@ -4,8 +4,9 @@ var rollup = require('rollup');
 var fsp = require('fs/promises');
 var fs = require('fs');
 var path = require('path');
-var module$1 = require('module');
 var require$$0 = require('tty');
+var module$1 = require('module');
+var rimraf = require('rimraf');
 var pluginWasm = require('@rollup/plugin-wasm');
 var rollupPluginSwc3 = require('rollup-plugin-swc3');
 var commonjs = require('@rollup/plugin-commonjs');
@@ -14,6 +15,7 @@ var pluginNodeResolve = require('@rollup/plugin-node-resolve');
 var replace = require('@rollup/plugin-replace');
 var esmShim = require('@rollup/plugin-esm-shim');
 var preserveDirectives = require('rollup-preserve-directives');
+var CleanCSS = require('clean-css');
 var pluginutils = require('@rollup/pluginutils');
 var prettyBytes = require('pretty-bytes');
 
@@ -28,47 +30,9 @@ var json__default = /*#__PURE__*/_interopDefault(json);
 var replace__default = /*#__PURE__*/_interopDefault(replace);
 var esmShim__default = /*#__PURE__*/_interopDefault(esmShim);
 var preserveDirectives__default = /*#__PURE__*/_interopDefault(preserveDirectives);
+var CleanCSS__default = /*#__PURE__*/_interopDefault(CleanCSS);
 var prettyBytes__default = /*#__PURE__*/_interopDefault(prettyBytes);
 
-const availableExtensions = new Set([
-    'js',
-    'cjs',
-    'mjs',
-    'jsx',
-    'ts',
-    'tsx',
-    'cts',
-    'mts'
-]);
-const nodeResolveExtensions = [
-    '.mjs',
-    '.cjs',
-    '.js',
-    '.json',
-    '.node',
-    '.jsx'
-];
-const availableExportConventions = new Set([
-    'react-server',
-    'react-native',
-    'edge-light'
-]);
-const availableESExtensionsRegex = /\.(m|c)?[jt]sx?$/;
-const SRC = 'src';
-const dtsExtensionsMap = {
-    js: 'd.ts',
-    cjs: 'd.cts',
-    mjs: 'd.mts'
-};
-const disabledWarnings = new Set([
-    'MIXED_EXPORTS',
-    'PREFER_NAMED_EXPORTS',
-    'UNRESOLVED_IMPORT',
-    'THIS_IS_UNDEFINED',
-    'INVALID_ANNOTATION',
-    'UNUSED_EXTERNAL_IMPORT'
-]);
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -121,6 +85,59 @@ picocolors.exports.createColors = createColors;
 var picocolorsExports = picocolors.exports;
 var pc = /*@__PURE__*/ getDefaultExportFromCjs(picocolorsExports);
 
+const availableExtensions = new Set([
+    'js',
+    'cjs',
+    'mjs',
+    'jsx',
+    'ts',
+    'tsx',
+    'cts',
+    'mts'
+]);
+const nodeResolveExtensions = [
+    '.mjs',
+    '.cjs',
+    '.js',
+    '.json',
+    '.node',
+    '.jsx'
+];
+const suffixedExportConventions = new Set([
+    'react-server',
+    'react-native',
+    'edge-light',
+    'development',
+    'production'
+]);
+const availableESExtensionsRegex = /\.(m|c)?[jt]sx?$/;
+const SRC = 'src';
+const dtsExtensionsMap = {
+    js: 'd.ts',
+    cjs: 'd.cts',
+    mjs: 'd.mts'
+};
+const disabledWarnings = new Set([
+    'MIXED_EXPORTS',
+    'PREFER_NAMED_EXPORTS',
+    'UNRESOLVED_IMPORT',
+    'THIS_IS_UNDEFINED',
+    'INVALID_ANNOTATION',
+    'UNUSED_EXTERNAL_IMPORT'
+]);
+const tsExtensions = new Set([
+    'ts',
+    'tsx',
+    'cts',
+    'mts'
+]);
+const DEFAULT_TS_CONFIG = {
+    compilerOptions: {
+        module: 'ESNext',
+        moduleResolution: 'bundler'
+    }
+};
+
 const defaultColorFn = (text)=>text;
 function color(prefixColor) {
     return pc.isColorSupported ? pc[prefixColor] : defaultColorFn;
@@ -154,15 +171,24 @@ async function getPackageMeta(cwd) {
     } catch (_) {}
     return targetPackageJson;
 }
+function isTypescriptFile(filename) {
+    const ext = path__default.default.extname(filename).slice(1);
+    return tsExtensions.has(ext);
+}
 function fileExists(filePath) {
     return fs__default.default.existsSync(filePath);
 }
-// . -> pkg name
-// ./lite -> <pkg name>/lite
-function getExportPath(pkg, cwd, exportName) {
-    const name = pkg.name || path__default.default.basename(cwd);
-    if (exportName === '.' || !exportName) return name;
-    return path__default.default.join(name, exportName);
+async function removeDir(dirPath) {
+    try {
+        const dirStat = await fsp__default.default.stat(dirPath);
+        if (dirStat.isDirectory()) {
+            await rimraf.rimraf(dirPath);
+        }
+    } catch (err) {
+        if (err.code !== 'ENOENT') {
+            throw err;
+        }
+    }
 }
 const isNotNull = (n)=>Boolean(n);
 function resolveSourceFile(cwd, filename) {
@@ -191,7 +217,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.has(exportType) && exportType !== '$binary') {
+        if (suffixedExportConventions.has(exportType) && exportType !== '$binary') {
             const filename = await findSourceEntryFile(cwd, exportPath, exportType, ext);
             if (filename) return filename;
         }
@@ -200,13 +226,15 @@ 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.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) {
@@ -246,14 +274,6 @@ async function convertCompilerOptions(cwd, json) {
     return ts.convertCompilerOptionsFromJson(json, './');
 }
 
-function minifyCSS(content) {
-    return content.replace(/\/\*[\s\S]*?\*\/|([^:]|^)\/\/.*$|(?:^|\s)(\s+)|\s*([\{\};,:])\s*|\s+(!)\s+/g, (match, p1, p2, p3, p4)=>{
-        if (p1) return p1 === ' ' ? '' : p1;
-        if (p2) return ' ';
-        if (p3) return p3;
-        if (p4) return '!';
-    });
-}
 const helpers = {
     cssImport: {
         // have to assign r.type = 'text/css' to make it work in Safari
@@ -281,6 +301,10 @@ export default sheet`;
         }
     }
 };
+const cleanCssInstance = new CleanCSS__default.default({});
+function minify(code) {
+    return cleanCssInstance.minify(code).styles;
+}
 function inlineCss(options) {
     const cssIds = new Set();
     var _options_exclude;
@@ -293,7 +317,7 @@ function inlineCss(options) {
         transform (code, id) {
             if (!filter(id)) return;
             if (options.skip) return '';
-            const cssCode = minifyCSS(code);
+            const cssCode = minify(code);
             cssIds.add(id);
             return {
                 code: helpers.cssImport.create(cssCode),
@@ -302,7 +326,7 @@ function inlineCss(options) {
                 }
             };
         },
-        renderChunk (code, options) {
+        renderChunk (code) {
             const dependenciesIds = this.getModuleIds();
             let foundCss = false;
             for (const depId of dependenciesIds){
@@ -391,9 +415,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;
@@ -428,6 +449,18 @@ function joinRelativePath(...segments) {
     }
     return result;
 }
+const getFirstExportPath = (fullExportCondition)=>{
+    // Handle all export cond { <require|import|default>: ... }
+    if (typeof fullExportCondition === 'object') {
+        for (const key of Object.keys(fullExportCondition)){
+            if (key.startsWith('.') || key === 'types') {
+                continue;
+            }
+            return fullExportCondition[key];
+        }
+    }
+    return fullExportCondition;
+};
 function findExport(exportPath, exportCondition, paths, packageType, currentPath) {
     // Skip `types` field, it cannot be the entry point
     if (exportPath === 'types') return;
@@ -439,11 +472,12 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
                 ...fullExportCondition
             };
         } else {
+            const exportJsBundlePath = getFirstExportPath(fullExportCondition);
             // exportPath is exportType, import, require, ...
             // merge to currentPath
             paths[currentPath] = {
                 ...paths[currentPath],
-                [exportPath]: fullExportCondition.default
+                [exportPath]: exportJsBundlePath
             };
         }
         return;
@@ -545,10 +579,10 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
  *
  *
  * pkg.main and pkg.module will be added to ['.'] if exists
- */ function getExportPaths(pkg, pkgType, resolvedWildcardExports) {
+ */ function getExportPaths(pkg, resolvedWildcardExports) {
     var _pathsMap_;
     let pathsMap = {};
-    const packageType = pkgType != null ? pkgType : getPackageType(pkg);
+    const packageType = getPackageType(pkg);
     const isEsmPackage = isESModulePackage(packageType);
     const exportsConditions = resolvedWildcardExports != null ? resolvedWildcardExports : pkg.exports;
     if (exportsConditions) {
@@ -558,9 +592,6 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
             ...paths
         };
     }
-    if (isEsmPackage && pkg.main && hasCjsExtension(pkg.main)) {
-        exit('Cannot export main field with .cjs extension in ESM package, only .mjs and .js extensions are allowed');
-    }
     // main export '.' from main/module/typings
     const defaultMainExport = constructFullExportCondition({
         [isEsmPackage ? 'import' : 'require']: pkg.main,
@@ -585,31 +616,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 +644,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);
@@ -705,7 +699,8 @@ const swcMinifyOptions = {
         toplevel: true
     }
 };
-function getBuildEnv(envs) {
+// return { 'process.env.<key>': '<value>' }
+function getBuildEnv(envs, exportConditions) {
     if (!envs.includes('NODE_ENV')) {
         envs.push('NODE_ENV');
     }
@@ -716,10 +711,19 @@ function getBuildEnv(envs) {
         }
         return acc;
     }, {});
+    // 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');
+    }
     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 +735,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 +751,13 @@ async function buildInputConfig(entry, options, buildContext, dts) {
             externals.push(entryFilePath);
         }
     }
-    const { useTypescript, runtime, target: jscTarget, minify: shouldMinify } = options;
+    const envValues = getBuildEnv(options.env || [], exportCondition.export);
+    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 +797,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 +807,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,
@@ -830,7 +834,7 @@ async function buildInputConfig(entry, options, buildContext, dts) {
         preserveDirectives__default.default(),
         prependDirectives(),
         replace__default.default({
-            values: getBuildEnv(options.env || []),
+            values: envValues,
             preventAssignment: true
         }),
         pluginNodeResolve.nodeResolve({
@@ -960,22 +964,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',
@@ -1000,48 +999,48 @@ async function buildEntryConfig(bundleConfig, pluginContext, dts) {
     }
     return await Promise.all(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;
+    let exportCondForType = {
+        ...exportCondRef
+    };
+    // Special cases of export type, only pass down the exportPaths for the type
+    if (suffixedExportConventions.has(exportType)) {
+        exportCondForType = {
+            [exportType]: exportCondRef[exportType]
+        };
+    // Basic export type, pass down the exportPaths with erasing the special ones
+    } else {
+        for (const exportType of suffixedExportConventions){
+            delete exportCondForType[exportType];
+        }
+    }
+    let source = entryPath;
+    if (source) {
+        source = resolveSourceFile(cwd, source);
+    } else {
+        source = await getSourcePathFromExportPath(cwd, entryExport, exportType);
+    }
+    if (!source) {
+        return;
+    }
+    const exportCondition = {
+        source,
+        name: entryExport,
+        export: exportCondForType
+    };
+    const nameWithExportPath = pkg.name ? path__default.default.join(pkg.name, exportCondition.name) : exportCondition.name;
+    const needsDelimiter = !nameWithExportPath.endsWith('.') && exportType;
+    const entryImportPath = nameWithExportPath + (needsDelimiter ? '.' : '') + exportType;
+    entries[entryImportPath] = exportCondition;
+}
 /*
  * build configs for each entry from package exports
  *
  * return { <pkg>/<export>: { input: InputOptions, output: OutputOptions[] }
  */ async function collectEntries(pkg, entryPath, exportPaths, cwd) {
     const entries = {};
-    async function collectEntry(// export type, e.g. react-server, edge-light those special cases required suffix
-    exportType, exportCondRef, // export name, e.g. ./<export-path> in exports field of package.json
-    entryExport) {
-        let exportCondForType = {
-            ...exportCondRef
-        };
-        // Special cases of export type, only pass down the exportPaths for the type
-        if (availableExportConventions.has(exportType)) {
-            exportCondForType = {
-                [entryExport]: exportCondRef[exportType]
-            };
-        // Basic export type, pass down the exportPaths with erasing the special ones
-        } else {
-            for (const exportType of availableExportConventions){
-                delete exportCondForType[exportType];
-            }
-        }
-        let source = entryPath;
-        if (source) {
-            source = resolveSourceFile(cwd, source);
-        } else {
-            source = await getSourcePathFromExportPath(cwd, entryExport, exportType);
-        }
-        if (!source) {
-            return undefined;
-        }
-        const exportCondition = {
-            source,
-            name: entryExport,
-            export: exportCondForType
-        };
-        const nameWithExportPath = pkg.name ? path__default.default.join(pkg.name, exportCondition.name) : exportCondition.name;
-        const needsDelimiter = !nameWithExportPath.endsWith('.') && exportType;
-        const entryImportPath = nameWithExportPath + (needsDelimiter ? '.' : '') + exportType;
-        entries[entryImportPath] = exportCondition;
-    }
     const binaryExports = pkg.bin;
     if (binaryExports) {
         // binDistPaths: [ [ 'bin1', './dist/bin1.js'], [ 'bin2', './dist/bin2.js'] ]
@@ -1077,11 +1076,19 @@ async function buildEntryConfig(bundleConfig, pluginContext, dts) {
     }
     const collectEntriesPromises = Object.keys(exportPaths).map(async (entryExport)=>{
         const exportCond = exportPaths[entryExport];
+        const collectEntryOptions = {
+            cwd,
+            pkg,
+            entries,
+            entryPath,
+            exportCondRef: exportCond,
+            entryExport
+        };
         if (entryExport.startsWith('.')) {
-            await collectEntry('', exportCond, entryExport);
-            for (const exportType of availableExportConventions){
-                if (exportCond[exportType]) {
-                    await collectEntry(exportType, exportCond, entryExport);
+            await collectEntry('', collectEntryOptions);
+            for (const exportCondType of suffixedExportConventions){
+                if (exportCond[exportCondType]) {
+                    await collectEntry(exportCondType, collectEntryOptions);
                 }
             }
         }
@@ -1098,42 +1105,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
+            };
+        });
+    }
+    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'
+            };
         });
-        // 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)
-            ];
-        }
     }
+    const outputConfigs = bundleOptions.map((bundleOption)=>{
+        return buildOutputConfigs({
+            ...bundleConfig,
+            file: bundleOption.resolvedFile,
+            format: bundleOption.format
+        }, exportCondition, pluginContext, dts);
+    });
     return {
         input: inputOptions,
         output: outputConfigs,
@@ -1226,6 +1252,10 @@ function getExportNameWithoutExportCondition(exportName) {
 }
 function logOutputState(sizeCollector) {
     const stats = sizeCollector.getSizeStats();
+    if (stats.size === 0) {
+        logger.warn('No build info can be logged');
+        return;
+    }
     const allFileNameLengths = Array.from(stats.values()).flat(1).map(([filename])=>filename.length);
     const maxFilenameLength = Math.max(...allFileNameLengths);
     const statsArray = [
@@ -1335,14 +1365,12 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
     const pkg = await getPackageMeta(cwd);
     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 exportPaths = getExportPaths(pkg, resolvedWildcardExports);
     const isMultiEntries = hasMultiEntryExport(exportPaths) // exportPathsLength > 1
     ;
     const hasBin = Boolean(pkg.bin);
-    const tsConfig = await resolveTsConfig(cwd);
-    const hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
+    let tsConfig = await resolveTsConfig(cwd);
+    let hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
     const defaultTsOptions = {
         tsConfigPath: tsConfig == null ? void 0 : tsConfig.tsConfigPath,
         tsCompilerOptions: (tsConfig == null ? void 0 : tsConfig.tsCompilerOptions) || {}
@@ -1353,18 +1381,17 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
         // e.g. "exports": "./dist/index.js" -> use "./index.<ext>" as entry
         entryPath = entryPath || await getSourcePathFromExportPath(cwd, '.', 'default') || '';
     }
+    // Handle CLI input
     if (entryPath) {
         let mainEntryPath;
         let typesEntryPath;
         // 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,
@@ -1372,11 +1399,10 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
             }, packageType);
         }
     }
-    const bundleOrWatch = (rollupConfig)=>{
-        const { input, exportName } = rollupConfig;
-        const exportPath = getExportPath(pkg, cwd, exportName);
-        // Log original entry file relative path
-        typeof input.input === 'string' ? path.relative(cwd, input.input) : exportPath;
+    const bundleOrWatch = async (rollupConfig)=>{
+        if (options.clean) {
+            await removeOutputDir(rollupConfig.output);
+        }
         if (options.watch) {
             return Promise.resolve(runWatch(rollupConfig));
         }
@@ -1399,6 +1425,14 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
         }
     }
     const entries = await collectEntries(pkg, entryPath, exportPaths, cwd);
+    const hasTypeScriptFiles = Object.values(entries).some((entry)=>isTypescriptFile(entry.source));
+    if (hasTypeScriptFiles && !hasTsConfig) {
+        const tsConfigPath = path.resolve(cwd, 'tsconfig.json');
+        defaultTsOptions.tsConfigPath = 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.`);
+        hasTsConfig = true;
+    }
     const sizeCollector = createOutputState({
         entries
     });
@@ -1409,6 +1443,7 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
         exportPaths,
         cwd,
         tsOptions: defaultTsOptions,
+        useTypeScript: hasTsConfig,
         pluginContext: {
             outputState: sizeCollector,
             moduleDirectiveLayerMap: new Map(),
@@ -1422,10 +1457,12 @@ 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) {
+function runWatch({ input, output }) {
     const watchOptions = [
         {
             ...input,
@@ -1459,6 +1496,12 @@ function runWatch({ input, output }, metadata) {
     });
     return watcher;
 }
+async function removeOutputDir(output) {
+    const dirs = new Set(output.map(({ dir })=>dir));
+    for (const dir of dirs){
+        if (dir) await removeDir(dir);
+    }
+}
 function runBundle({ input, output }) {
     return rollup.rollup(input).then((bundle)=>{
         const writeJobs = output.map((options)=>bundle.write(options));