bunchee 4.3.4 → 4.4.1

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;
@@ -86,8 +94,9 @@ let createColors = (enabled = isColorSupported)=>({
     });
 picocolors.exports = createColors();
 picocolors.exports.createColors = createColors;
+
 var picocolorsExports = picocolors.exports;
-var pc = /*@__PURE__*/ getDefaultExportFromCjs(picocolorsExports);
+var pc = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
 
 const defaultColorFn = (text)=>text;
 function color(prefixColor) {
@@ -140,22 +149,379 @@ 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
+    let mainExportCondition;
+    if (pkg.main) {
+        const mainExportType = isEsmPackage ? hasCjsExtension(pkg.main) ? 'require' : 'import' : 'require';
+        mainExportCondition = {
+            [mainExportType]: pkg.main
+        };
+    }
+    const defaultMainExport = constructFullExportCondition({
+        ...mainExportCondition,
+        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 (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 {
+        if (main && path__default.default.extname(main) === '.mjs') {
+            state.badMainExtension = true;
+        }
+        // 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 .mjs extension in CJS package, only .js extension is allowed');
+    }
+    if (state.badMainExport) {
+        logger.warn('Cannot export `exports` field with .cjs extension in ESM package, only .mjs and .js extensions are allowed');
+    }
+    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.1";
 
 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 +579,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 +593,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);
                     }
                 }
@@ -351,7 +717,9 @@ async function prepare(cwd) {
             } else {
                 // Update existing exports
                 Object.keys(pkgExports).forEach((exportName)=>{
-                    pkgJson.exports[exportName] = pkgExports[exportName];
+                    if (pkgJson.exports[exportName]) {
+                        pkgJson.exports[exportName] = pkgExports[exportName];
+                    }
                 });
             }
         }
@@ -373,6 +741,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 +752,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 +776,7 @@ function parseCliArgs(argv) {
         '--env': String,
         '--external': String,
         '--no-external': Boolean,
+        '--no-clean': Boolean,
         '--prepare': Boolean,
         '-h': '--help',
         '-v': '--version',
@@ -442,6 +803,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 +811,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 +825,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);
@@ -474,9 +837,11 @@ async function run(args) {
     if (args.prepare) {
         return await prepare(cwd);
     }
-    const entry = source ? path__default.default.resolve(cwd, source) : '';
+    const cliEntry = source ? path__default.default.resolve(cwd, source) : '';
+    // lint package
+    await lint(cwd);
     try {
-        await bunchee.bundle(entry, bundleConfig);
+        await bunchee.bundle(cliEntry, bundleConfig);
     } catch (err) {
         if (err.name === 'NOT_EXISTED') {
             help();
@@ -492,7 +857,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;
@@ -32,6 +33,6 @@ type PackageMetadata = {
     typings?: string;
 };
 
-declare function bundle(entryPath: string, { cwd: _cwd, ...options }?: BundleConfig): Promise<any>;
+declare function bundle(cliEntryPath: string, { cwd: _cwd, ...options }?: BundleConfig): Promise<any>;
 
 export { type BundleConfig, bundle };

package/dist/index.js

@@ -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;
 }
@@ -118,8 +82,62 @@ let createColors = (enabled = isColorSupported)=>({
     });
 picocolors.exports = createColors();
 picocolors.exports.createColors = createColors;
+
 var picocolorsExports = picocolors.exports;
-var pc = /*@__PURE__*/ getDefaultExportFromCjs(picocolorsExports);
+var pc = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
+
+const availableExtensions = new Set([
+    'js',
+    '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) {
@@ -154,15 +172,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 +218,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;
         }
@@ -249,14 +276,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 +303,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 +319,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 +328,7 @@ function inlineCss(options) {
                 }
             };
         },
-        renderChunk (code, options) {
+        renderChunk (code) {
             const dependenciesIds = this.getModuleIds();
             let foundCss = false;
             for (const depId of dependenciesIds){
@@ -428,6 +451,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 +474,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 +581,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,12 +594,16 @@ 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
+    let mainExportCondition;
+    if (pkg.main) {
+        const mainExportType = isEsmPackage ? hasCjsExtension(pkg.main) ? 'require' : 'import' : 'require';
+        mainExportCondition = {
+            [mainExportType]: pkg.main
+        };
+    }
     const defaultMainExport = constructFullExportCondition({
-        [isEsmPackage ? 'import' : 'require']: pkg.main,
+        ...mainExportCondition,
         module: pkg.module,
         types: getTypings(pkg)
     }, packageType);
@@ -668,7 +708,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 +720,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 +760,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);
@@ -758,6 +807,13 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
         })
     ];
     if (useTypeScript) {
+        const enableIncrementalWithoutBuildInfo = tsCompilerOptions.incremental && !tsCompilerOptions.tsBuildInfoFile;
+        const incrementalOptions = enableIncrementalWithoutBuildInfo ? {
+            incremental: false
+        } : undefined;
+        const compositeOptions = tsCompilerOptions.composite && enableIncrementalWithoutBuildInfo ? {
+            composite: false
+        } : undefined;
         const { options: overrideResolvedTsOptions } = await convertCompilerOptions(cwd, {
             declaration: true,
             noEmit: false,
@@ -772,9 +828,9 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
             } : undefined,
             // error TS5074: Option '--incremental' can only be specified using tsconfig, emitting to single
             // file or when option '--tsBuildInfoFile' is specified.
-            ...tsCompilerOptions.incremental && !tsCompilerOptions.tsBuildInfoFile ? {
-                incremental: false
-            } : undefined
+            ...incrementalOptions,
+            // error TS6379: Composite projects may not disable incremental compilation.
+            ...compositeOptions
         });
         const dtsPlugin = require('rollup-plugin-dts').default({
             tsconfig: tsConfigPath,
@@ -794,24 +850,25 @@ 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({
             preferBuiltins: runtime === 'node',
             extensions: nodeResolveExtensions
         }),
-        commonjs__default.default({
-            exclude: options.external || null
-        }),
-        json__default.default(),
         pluginWasm.wasm(),
         rollupPluginSwc3.swc({
             include: availableESExtensionsRegex,
             exclude: 'node_modules',
-            tsconfig: tsConfigPath,
+            // Use `false` to disable retrieving tsconfig.json
+            tsconfig: tsConfigPath != null ? tsConfigPath : false,
             ...swcOptions
-        })
+        }),
+        commonjs__default.default({
+            exclude: options.external || null
+        }),
+        json__default.default()
     ]).filter(isNotNull);
     return {
         input: entry,
@@ -959,48 +1016,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 +1093,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 +1269,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 = [
@@ -1232,11 +1301,12 @@ function logOutputState(sizeCollector) {
         }).forEach((item, index)=>{
             const [filename, , size] = item;
             const normalizedExportName = normalizeExportName(exportName);
-            const prefix = index === 0 ? normalizedExportName + ' '.repeat(maxLengthOfExportName - normalizedExportName.length) : ' '.repeat(maxLengthOfExportName);
-            const sizePadding = ' '.repeat(maxFilenameLength - filename.length);
-            const prettiedSize = prettyBytes__default.default(size);
+            const prefix = index === 0 ? normalizedExportName : ' '.repeat(normalizedExportName.length);
+            const filenamePadding = ' '.repeat(Math.max(maxLengthOfExportName, 'Exports'.length) - normalizedExportName.length);
             const isType = isTypeFile(filename);
-            console.log(` ${prefix} ${pc[isType ? 'dim' : 'bold'](filename)}${sizePadding}  ${prettiedSize}`);
+            const sizePadding = ' '.repeat(Math.max(maxFilenameLength, 'File'.length) - filename.length);
+            const prettiedSize = prettyBytes__default.default(size);
+            console.log(prefix, filenamePadding, `${pc[isType ? 'dim' : 'bold'](filename)}`, sizePadding, prettiedSize);
         });
     });
 }
@@ -1305,7 +1375,7 @@ function hasMultiEntryExport(exportPaths) {
     const exportKeys = Object.keys(exportPaths).filter((key)=>key !== './package.json');
     return exportKeys.length > 0 && exportKeys.every((name)=>name.startsWith('.'));
 }
-async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
+async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
     const cwd = path.resolve(process.cwd(), _cwd || '');
     assignDefault(options, 'format', 'es');
     assignDefault(options, 'minify', false);
@@ -1313,12 +1383,13 @@ 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);
+    const isFromCli = Boolean(cliEntryPath);
+    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) || {}
@@ -1327,9 +1398,10 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
     if (!isMultiEntries) {
         // Use specified string file path if possible, then fallback to the default behavior entry picking logic
         // e.g. "exports": "./dist/index.js" -> use "./index.<ext>" as entry
-        entryPath = entryPath || await getSourcePathFromExportPath(cwd, '.', 'default') || '';
+        cliEntryPath = cliEntryPath || await getSourcePathFromExportPath(cwd, '.', 'default') || '';
     }
-    if (entryPath) {
+    // Handle CLI input
+    if (cliEntryPath) {
         let mainEntryPath;
         let typesEntryPath;
         // with -o option
@@ -1346,21 +1418,22 @@ 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) {
+            if (!isFromCli) {
+                await removeOutputDir(rollupConfig.output);
+            }
+        }
         if (options.watch) {
             return Promise.resolve(runWatch(rollupConfig));
         }
         return runBundle(rollupConfig);
     };
-    const hasSpecifiedEntryFile = entryPath ? fs__default.default.existsSync(entryPath) && (await fsp__default.default.stat(entryPath)).isFile() : false;
+    const hasSpecifiedEntryFile = cliEntryPath ? fs__default.default.existsSync(cliEntryPath) && (await fsp__default.default.stat(cliEntryPath)).isFile() : false;
     const hasNoEntry = !hasSpecifiedEntryFile && !isMultiEntries && !hasBin;
     if (hasNoEntry) {
-        if (entryPath) {
-            const err = new Error(`Entry file "${entryPath}" does not exist`);
+        if (cliEntryPath) {
+            const err = new Error(`Entry file "${cliEntryPath}" does not exist`);
             err.name = 'NOT_EXISTED';
             return Promise.reject(err);
         } else if (cwd) {
@@ -1372,7 +1445,15 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
             }
         }
     }
-    const entries = await collectEntries(pkg, entryPath, exportPaths, cwd);
+    const entries = await collectEntries(pkg, cliEntryPath, exportPaths, cwd);
+    const hasTypeScriptFiles = Object.values(entries).some((entry)=>isTypescriptFile(entry.source));
+    if (hasTypeScriptFiles && !hasTsConfig) {
+        const tsConfigPath = path.resolve(cwd, 'tsconfig.json');
+        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 +1483,7 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
     }
     return result;
 }
-function runWatch({ input, output }, metadata) {
+function runWatch({ input, output }) {
     const watchOptions = [
         {
             ...input,
@@ -1436,6 +1517,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.1",
   "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"
 }