bunchee 4.3.4 → 4.4.0

package/README.md

@@ -64,7 +64,7 @@ Then use use the [exports field in package.json](https://nodejs.org/api/packages
   "files": ["dist"],
   "exports": {
     "import": "./dist/es/index.mjs",
-    "require": "./dist/cjs/index.cjs"
+    "require": "./dist/cjs/index.js"
   },
   "scripts": {
     "build": "bunchee"
@@ -88,8 +88,8 @@ If you're build a TypeScript library, separate the types from the main entry fil
       "default": "./dist/es/index.mjs"
     },
     "require": {
-      "types": "./dist/cjs/index.d.cts",
-      "default": "./dist/cjs/index.cjs"
+      "types": "./dist/cjs/index.d.ts",
+      "default": "./dist/cjs/index.js"
     }
   },
   "scripts": {
@@ -107,13 +107,13 @@ If you're using TypeScript with Node 10 and Node 16 module resolution, you can u
 ```json
 {
   "files": ["dist"],
-  "main": "./dist/cjs/index.cjs",
+  "main": "./dist/cjs/index.js",
   "module": "./dist/es/index.mjs",
   "types": "./dist/cjs/index.d.ts",
   "exports": {
     "import": {
-      "types": "./dist/es/index.d.mts",
-      "default": "./dist/es/index.mjs"
+      "types": "./dist/es/index.d.ts",
+      "default": "./dist/es/index.js"
     },
     "require": {
       "types": "./dist/cjs/index.d.cts",
@@ -268,6 +268,7 @@ If you're using `"use client"` or `"use server"` in a file that used as a depend
 - Types (`--dts`): Generate TypeScript declaration files along with assets.
 - Minify (`-m`): Compress output.
 - Watch (`-w`): Watch for source file changes.
+- No Clean(`--no-clean`): Do not clean the dist folder before building. (default: `false`)
 
 ```sh
 cd <project-root-dir>
@@ -323,6 +324,21 @@ 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.
 
+#### Auto Development and Production Mode
+
+`process.env.NODE_ENV` is injected by default if present that you don't need to manually inject yourself. If you need to separate the development build and production build, `bunchee` provides different export conditions for development and production mode with `development` and `production` export conditions.
+
+```json
+{
+  "exports": {
+    "development": "./dist/index.development.js",
+    "production": "./dist/index.production.js"
+  }
+}
+```
+
+Then you can use `bunchee` to build the development bundle and production bundle automatically.
+
 ### Wildcard Exports
 
 Bunchee implements the Node.js feature of using the asterisk `*` as a wildcard to match the exportable entry files.
@@ -439,6 +455,7 @@ await bundle(path.resolve('./src/index.ts'), {
   target: 'es2015', // ES syntax target
   runtime: 'nodejs', // 'browser' | 'nodejs'
   cwd: process.cwd(), // string
+  clean: true, // boolean
 })
 ```
 

package/dist/bin/cli.js

@@ -3,6 +3,7 @@ var path = require('path');
 var arg = require('arg');
 var fs = require('fs');
 var fsp = require('fs/promises');
+require('rimraf');
 var require$$0 = require('tty');
 var bunchee = require('bunchee');
 
@@ -25,6 +26,7 @@ const availableExtensions = new Set([
     'mts'
 ]);
 const SRC = 'src';
+const DIST = 'dist';
 const dtsExtensionsMap = {
     js: 'd.ts',
     cjs: 'd.cts',
@@ -36,6 +38,12 @@ const tsExtensions = new Set([
     'cts',
     'mts'
 ]);
+const DEFAULT_TS_CONFIG = {
+    compilerOptions: {
+        module: 'ESNext',
+        moduleResolution: 'bundler'
+    }
+};
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -140,22 +148,372 @@ function fileExists(filePath) {
     return fs__default.default.existsSync(filePath);
 }
 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));
+const isTestFile = (filename)=>/\.(test|spec)$/.test(baseNameWithoutExtension(filename));
+
+function getTypings(pkg) {
+    return pkg.types || pkg.typings;
+}
+// Reached the end of the export path
+function isExportLike(field) {
+    if (typeof field === 'string') return true;
+    return Object.entries(field).every(// Every value is string and key is not start with '.'
+    ([key, value])=>typeof value === 'string' && !key.startsWith('.'));
+}
+function constructFullExportCondition(exportCondition, packageType) {
+    let fullExportCond;
+    if (typeof exportCondition === 'string') {
+        const exportType = getExportTypeFromFile(exportCondition, packageType);
+        fullExportCond = {
+            [exportType]: exportCondition
+        };
+    } else {
+        const exportTypes = Object.keys(exportCondition);
+        fullExportCond = {};
+        exportTypes.forEach((exportType)=>{
+            const condition = exportCondition[exportType];
+            // Filter out nullable value
+            if (condition) {
+                fullExportCond[exportType] = condition;
+            }
+        });
+    }
+    return fullExportCond;
+}
+function joinRelativePath(...segments) {
+    let result = path.join(...segments);
+    // If the first segment starts with '.', ensure the result does too.
+    if (segments[0] === '.' && !result.startsWith('.')) {
+        result = './' + result;
+    }
+    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;
+    if (isExportLike(exportCondition)) {
+        const fullExportCondition = constructFullExportCondition(exportCondition, packageType);
+        if (exportPath.startsWith('.')) {
+            paths[exportPath] = {
+                ...paths[exportPath],
+                ...fullExportCondition
+            };
+        } else {
+            const exportJsBundlePath = getFirstExportPath(fullExportCondition);
+            // exportPath is exportType, import, require, ...
+            // merge to currentPath
+            paths[currentPath] = {
+                ...paths[currentPath],
+                [exportPath]: exportJsBundlePath
+            };
+        }
+        return;
+    }
+    Object.keys(exportCondition).forEach((subpath)=>{
+        if (subpath.startsWith('.')) {
+            // subpath is actual export path, ./a, ./b, ...
+            const nestedExportPath = joinRelativePath(currentPath, subpath);
+            const nestedExportCondition = exportCondition[subpath];
+            findExport(nestedExportPath, nestedExportCondition, paths, packageType, nestedExportPath);
+        } else {
+            // subpath is exportType, import, require, ...
+            const exportType = subpath;
+            const defaultPath = typeof exportCondition[subpath] === 'object' ? exportCondition[subpath].default : exportCondition[subpath];
+            const nestedExportCondition = {
+                [exportType]: defaultPath
+            };
+            findExport(exportPath, nestedExportCondition, paths, packageType, currentPath);
+        }
+    });
+}
+/**
+ *
+ * Convert package.exports field to paths mapping
+ * Example
+ *
+ * Input:
+ * {
+ *   "./sub": {
+ *     "import": {
+ *       "types": "./sub.js",
+ *       "default": "./sub.cjs",
+ *     }
+ *   }
+ * }
+ *
+ * Output:
+ * {
+ *   "./sub": {
+ *     "import": "./sub.js",
+ *     "require": "./sub.cjs",
+ *     "types": "./sub.d.ts",
+ *   }
+ * }
+ *
+ */ function parseExport(exportsCondition, packageType) {
+    const paths = {};
+    const initialPath = '.';
+    if (typeof exportsCondition === 'string') {
+        paths[initialPath] = constructFullExportCondition(exportsCondition, packageType);
+    } else if (typeof exportsCondition === 'object') {
+        if (isExportLike(exportsCondition)) {
+            paths[initialPath] = constructFullExportCondition(exportsCondition, packageType);
+        } else {
+            Object.keys(exportsCondition).forEach((key)=>{
+                const exportCondition = exportsCondition[key];
+                findExport(key, exportCondition, paths, packageType, initialPath);
+            });
+        }
+    }
+    return paths;
+}
+/**
+ * Get package exports paths
+ *
+ * Example:
+ *
+ * ```json
+ * {
+ *  "exports": {
+ *    ".": {
+ *      "require": "./dist/index.cjs",
+ *      "module": "./dist/index.esm.js",
+ *      "default": "./dist/index.esm.js"
+ *    },
+ *    "./foo": {
+ *      "require": "./dist/foo.cjs",
+ *      "module": "./dist/foo.esm.js",
+ *      "default": "./dist/foo.esm.js"
+ *   }
+ * }
+ *
+ * ```
+ *
+ * will be parsed to:
+ *
+ * ```js
+ * {
+ *   '.': {
+ *     main: './dist/index.cjs',
+ *     module: './dist/index.esm.js',
+ *     export: './dist/index.esm.js'
+ *   },
+ *   './foo': {
+ *     main: './dist/foo.cjs',
+ *     module: './dist/foo.esm.js',
+ *     export: './dist/foo.esm.js'
+ *   }
+ *
+ *
+ * pkg.main and pkg.module will be added to ['.'] if exists
+ */ function getExportPaths(pkg, resolvedWildcardExports) {
+    var _pathsMap_;
+    let pathsMap = {};
+    const packageType = getPackageType(pkg);
+    const isEsmPackage = isESModulePackage(packageType);
+    const exportsConditions = resolvedWildcardExports != null ? resolvedWildcardExports : pkg.exports;
+    if (exportsConditions) {
+        const paths = parseExport(exportsConditions, packageType);
+        pathsMap = {
+            ...pathsMap,
+            ...paths
+        };
+    }
+    // main export '.' from main/module/typings
+    const defaultMainExport = constructFullExportCondition({
+        [isEsmPackage ? 'import' : 'require']: pkg.main,
+        module: pkg.module,
+        types: getTypings(pkg)
+    }, packageType);
+    if (!isEsmPackage && ((_pathsMap_ = pathsMap['.']) == null ? void 0 : _pathsMap_['require'])) {
+        // pathsMap's exports.require are prioritized.
+        defaultMainExport['require'] = pathsMap['.']['require'];
+    }
+    // Merge the main export into '.' paths
+    const mainExport = {
+        ...pathsMap['.'],
+        ...defaultMainExport
+    };
+    // main export is not empty
+    if (Object.keys(mainExport).length > 0) {
+        pathsMap['.'] = {
+            ...pathsMap['.'],
+            ...mainExport
+        };
+    }
+    return pathsMap;
+}
+function getPackageType(pkg) {
+    return pkg.type || 'commonjs';
+}
+function isESModulePackage(packageType) {
+    return packageType === 'module';
+}
+function getExportTypeFromFile(filename, pkgType) {
+    const isESModule = isESModulePackage(pkgType);
+    const isCjsExt = filename.endsWith('.cjs');
+    const isEsmExt = filename.endsWith('.mjs');
+    const exportType = isEsmExt ? 'import' : isCjsExt ? 'require' : isESModule ? 'import' : 'require';
+    return exportType;
+}
+
+function lint$1(pkg) {
+    const { name, main, exports } = pkg;
+    const isESM = isESModulePackage(pkg.type);
+    const exportPaths = getExportPaths(pkg);
+    if (!name) {
+        logger.warn('Missing package name');
+    }
+    const state = {
+        badMainExtension: false,
+        badMainExport: false,
+        invalidExportsFieldType: false,
+        badCjsRequireExport: {
+            value: false,
+            paths: []
+        },
+        badCjsImportExport: {
+            value: false,
+            paths: []
+        },
+        badEsmRequireExport: {
+            value: false,
+            paths: []
+        },
+        badEsmImportExport: {
+            value: false,
+            paths: []
+        }
+    };
+    // Validate ESM package
+    if (isESM) {
+        if (main && hasCjsExtension(main)) {
+            state.badMainExtension = true;
+        }
+        if (exports) {
+            if (typeof exports === 'string') {
+                if (hasCjsExtension(exports)) {
+                    state.badMainExport = true;
+                }
+            }
+            if (typeof exports !== 'object') {
+                state.invalidExportsFieldType = true;
+            } else {
+                Object.keys(exportPaths).forEach((key)=>{
+                    const exportConditions = exportPaths[key];
+                    if (typeof exportConditions === 'object') {
+                        var // @ts-ignore TODO: fix the type
+                        _exportConditions_require, // @ts-ignore TODO: fix the type
+                        _exportConditions_import;
+                        var _exportConditions_require_default;
+                        const requirePath = (_exportConditions_require_default = (_exportConditions_require = exportConditions.require) == null ? void 0 : _exportConditions_require.default) != null ? _exportConditions_require_default : exportConditions.require;
+                        var _exportConditions_import_default;
+                        const importPath = (_exportConditions_import_default = (_exportConditions_import = exportConditions.import) == null ? void 0 : _exportConditions_import.default) != null ? _exportConditions_import_default : exportConditions.import;
+                        const requireExt = requirePath && path__default.default.extname(requirePath);
+                        const importExt = importPath && path__default.default.extname(importPath);
+                        if (requireExt === '.mjs' || requireExt === '.js') {
+                            state.badEsmRequireExport.value = true;
+                            state.badEsmRequireExport.paths.push(requirePath);
+                        }
+                        if (importExt === '.cjs') {
+                            state.badEsmImportExport.value = true;
+                            state.badEsmImportExport.paths.push(importPath);
+                        }
+                    }
+                });
+            }
+        }
+    } else {
+        // Validate CJS package
+        if (exports) {
+            if (typeof exports === 'string') {
+                if (!hasCjsExtension(exports)) {
+                    state.badMainExport = true;
+                }
+            }
+            if (typeof exports !== 'object') {
+                state.invalidExportsFieldType = true;
+            } else {
+                Object.keys(exportPaths).forEach((key)=>{
+                    const exportConditions = exportPaths[key];
+                    if (typeof exportConditions === 'object') {
+                        var // @ts-ignore TODO: fix the type
+                        _exportConditions_require, // @ts-ignore TODO: fix the type
+                        _exportConditions_import;
+                        var _exportConditions_require_default;
+                        const requirePath = (_exportConditions_require_default = (_exportConditions_require = exportConditions.require) == null ? void 0 : _exportConditions_require.default) != null ? _exportConditions_require_default : exportConditions.require;
+                        var _exportConditions_import_default;
+                        const importPath = (_exportConditions_import_default = (_exportConditions_import = exportConditions.import) == null ? void 0 : _exportConditions_import.default) != null ? _exportConditions_import_default : exportConditions.import;
+                        const requireExt = requirePath && path__default.default.extname(requirePath);
+                        const importExt = importPath && path__default.default.extname(importPath);
+                        if (requireExt === '.mjs') {
+                            state.badCjsRequireExport.value = true;
+                            state.badCjsRequireExport.paths.push(requirePath);
+                        }
+                        if (importExt === '.js' || importExt === '.cjs') {
+                            state.badCjsImportExport.value = true;
+                            state.badCjsImportExport.paths.push(importPath);
+                        }
+                    }
+                });
+            }
+        }
+    }
+    if (state.badMainExtension) {
+        logger.warn('Cannot export `main` field with .cjs extension in ESM package, only .mjs and .js extensions are allowed');
+    }
+    if (state.badMainExport) {
+        logger.warn('Cannot export `exports` field with .cjs extension in ESM package, only .mjs and .js extensions are allowed');
+    }
+    if (state.invalidExportsFieldType) {
+        logger.warn('Invalid exports field type, only object or string is allowed');
+    }
+    if (state.badCjsRequireExport.value) {
+        logger.warn('Cannot export `require` field with .mjs extension in CJS package, only .cjs and .js extensions are allowed');
+        state.badCjsRequireExport.paths.forEach((p)=>{
+            logger.warn(`  ${p}`);
+        });
+    }
+    if (state.badCjsImportExport.value) {
+        logger.warn('Cannot export `import` field with .js or .cjs extension in CJS package, only .mjs extensions are allowed');
+        state.badCjsImportExport.paths.forEach((p)=>{
+            logger.warn(`  ${p}`);
+        });
+    }
+    if (state.badEsmRequireExport.value) {
+        logger.warn('Cannot export `require` field with .js or .mjs extension in ESM package, only .cjs extensions are allowed');
+        state.badEsmRequireExport.paths.forEach((p)=>{
+            logger.warn(`  ${p}`);
+        });
+    }
+    if (state.badEsmImportExport.value) {
+        logger.warn('Cannot export `import` field with .cjs extension in ESM package, only .js and .mjs extensions are allowed');
+        state.badEsmImportExport.paths.forEach((p)=>{
+            logger.warn(`  ${p}`);
+        });
+    }
+}
 
-var version = "4.3.4";
+var version = "4.4.0";
 
 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('/')}`;
@@ -213,7 +571,7 @@ async function collectSourceEntries(sourceFolderPath) {
                 // Search folder/<index>.<ext> convention entries
                 for (const extension of availableExtensions){
                     const indexFile = path__default.default.join(dirent.name, `index.${extension}`);
-                    if (fs__default.default.existsSync(indexFile)) {
+                    if (fs__default.default.existsSync(indexFile) && !isTestFile(indexFile)) {
                         exportsEntries.set(dirent.name, indexFile);
                         break;
                     }
@@ -227,7 +585,7 @@ async function collectSourceEntries(sourceFolderPath) {
                 if (isBinFile) {
                     bins.set('.', dirent.name);
                 } else {
-                    if (hasAvailableExtension(dirent.name)) {
+                    if (hasAvailableExtension(dirent.name) && !isTestFile(dirent.name)) {
                         exportsEntries.set(baseName, dirent.name);
                     }
                 }
@@ -373,6 +731,7 @@ Options:
   --prepare              auto configure package.json exports for building
   --external <mod>       specify an external dependency, separate by comma
   --no-external          do not bundle external dependencies
+  --no-clean             do not clean dist folder before building, default: false
   --target <target>      js features target: swc target es versions. default: es2015
   --runtime <runtime>    build runtime (nodejs, browser). default: browser
   --env <env>            inlined process env variables, separate by comma. default: NODE_ENV
@@ -383,21 +742,12 @@ Options:
 function help() {
     logger.log(helpMessage);
 }
-async function lintPackage(cwd) {
+async function lint(cwd) {
     // Not package.json detected, skip package linting
     if (!await hasPackageJson(cwd)) {
         return;
     }
-    const { publint } = await import('publint');
-    const { formatMessage } = await import('publint/utils');
-    const { messages } = await publint({
-        pkgDir: cwd,
-        level: 'error'
-    });
-    const pkg = await getPackageMeta(cwd);
-    for (const message of messages){
-        console.log(formatMessage(message, pkg));
-    }
+    await lint$1(await getPackageMeta(cwd));
 }
 function parseCliArgs(argv) {
     let args;
@@ -416,6 +766,7 @@ function parseCliArgs(argv) {
         '--env': String,
         '--external': String,
         '--no-external': Boolean,
+        '--no-clean': Boolean,
         '--prepare': Boolean,
         '-h': '--help',
         '-v': '--version',
@@ -442,6 +793,7 @@ function parseCliArgs(argv) {
         runtime: args['--runtime'],
         target: args['--target'],
         external: !!args['--no-external'] ? null : args['--external'],
+        clean: !args['--no-clean'],
         env: args['--env'],
         prepare: !!args['--prepare']
     };
@@ -449,7 +801,7 @@ function parseCliArgs(argv) {
 }
 async function run(args) {
     var _args_external;
-    const { source, format, watch, minify, sourcemap, target, runtime, dts, env } = args;
+    const { source, format, watch, minify, sourcemap, target, runtime, dts, env, clean } = args;
     const cwd = args.cwd || process.cwd();
     const file = args.file ? path__default.default.resolve(cwd, args.file) : undefined;
     const bundleConfig = {
@@ -463,7 +815,8 @@ async function run(args) {
         watch: !!watch,
         minify: !!minify,
         sourcemap: sourcemap === false ? false : true,
-        env: (env == null ? void 0 : env.split(',')) || []
+        env: (env == null ? void 0 : env.split(',')) || [],
+        clean
     };
     if (args.version) {
         return logger.log(version);
@@ -475,6 +828,8 @@ async function run(args) {
         return await prepare(cwd);
     }
     const entry = source ? path__default.default.resolve(cwd, source) : '';
+    // lint package
+    await lint(cwd);
     try {
         await bunchee.bundle(entry, bundleConfig);
     } catch (err) {
@@ -492,7 +847,6 @@ async function run(args) {
     // build mode
     logger.log();
     paint('✓', 'green', `bunchee ${version} build completed`);
-    await lintPackage(cwd);
 }
 async function main() {
     let params, error;

package/dist/index.d.ts

@@ -17,6 +17,7 @@ type BundleConfig = {
     dts?: boolean;
     runtime?: string;
     pkg?: PackageMetadata;
+    clean?: boolean;
 };
 type PackageMetadata = {
     name?: string;

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;
         }
@@ -207,7 +233,6 @@ function filePathWithoutExtension(file) {
 }
 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));
 
@@ -249,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
@@ -284,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;
@@ -296,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),
@@ -305,7 +326,7 @@ function inlineCss(options) {
                 }
             };
         },
-        renderChunk (code, options) {
+        renderChunk (code) {
             const dependenciesIds = this.getModuleIds();
             let foundCss = false;
             for (const depId of dependenciesIds){
@@ -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,
@@ -668,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');
     }
@@ -679,10 +711,17 @@ 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 { 
+ * return {
  *   <absolute source path>: <pkg>/<export>
  * }
  */ function getReversedAlias(entries) {
@@ -712,6 +751,7 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
             externals.push(entryFilePath);
         }
     }
+    const envValues = getBuildEnv(options.env || [], exportCondition.export);
     const { useTypeScript } = buildContext;
     const { runtime, target: jscTarget, minify: shouldMinify } = options;
     const hasSpecifiedTsTarget = Boolean(tsCompilerOptions.target && tsConfigPath);
@@ -794,7 +834,7 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
         preserveDirectives__default.default(),
         prependDirectives(),
         replace__default.default({
-            values: getBuildEnv(options.env || []),
+            values: envValues,
             preventAssignment: true
         }),
         pluginNodeResolve.nodeResolve({
@@ -959,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 = {
-                [exportType]: 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'] ]
@@ -1036,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);
                 }
             }
         }
@@ -1204,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 = [
@@ -1313,12 +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 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) || {}
@@ -1329,6 +1381,7 @@ 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;
@@ -1346,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));
         }
@@ -1373,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
     });
@@ -1402,7 +1462,7 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
     }
     return result;
 }
-function runWatch({ input, output }, metadata) {
+function runWatch({ input, output }) {
     const watchOptions = [
         {
             ...input,
@@ -1436,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));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunchee",
-  "version": "4.3.4",
+  "version": "4.4.0",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",
@@ -57,8 +57,9 @@
     "@swc/core": "^1.3.102",
     "@swc/helpers": "^0.5.3",
     "arg": "^5.0.2",
+    "clean-css": "^5.3.3",
     "pretty-bytes": "^5.6.0",
-    "publint": "~0.2.7",
+    "rimraf": "^5.0.5",
     "rollup": "^4.9.4",
     "rollup-plugin-dts": "^6.1.0",
     "rollup-plugin-swc3": "^0.11.0",
@@ -80,6 +81,7 @@
     "@huozhi/testing-package": "1.0.0",
     "@swc/jest": "^0.2.29",
     "@swc/types": "^0.1.5",
+    "@types/clean-css": "^4.2.11",
     "@types/jest": "29.0.0",
     "@types/node": "^20.4.1",
     "bunchee": "link:./",
@@ -106,7 +108,11 @@
       "^.+\\.(t|j)sx?$": [
         "@swc/jest"
       ]
-    }
+    },
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      "<rootDir>/test/integration/.*/*src"
+    ]
   },
   "packageManager": "pnpm@8.8.0"
 }