bunchee 4.3.3 → 4.4.0

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,21 +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));
 
-var version = "4.3.3";
+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.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('/')}`;
@@ -165,14 +524,16 @@ const normalizeBaseNameToExportName = (baseName)=>{
 function createExportCondition(exportName, sourceFile, moduleType) {
     const isTsSourceFile = isTypescriptFile(sourceFile);
     let cjsExtension = 'js';
+    let esmExtension = 'mjs';
     if (moduleType === 'module') {
         cjsExtension = 'cjs';
+        esmExtension = 'js';
     }
     if (isTsSourceFile) {
         return {
             import: {
-                types: getDistPath('es', `${exportName}.d.mts`),
-                default: getDistPath('es', `${exportName}.mjs`)
+                types: getDistPath('es', `${exportName}.${dtsExtensionsMap[esmExtension]}`),
+                default: getDistPath('es', `${exportName}.${esmExtension}`)
             },
             require: {
                 types: getDistPath('cjs', `${exportName}.${dtsExtensionsMap[cjsExtension]}`),
@@ -210,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;
                     }
@@ -224,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);
                     }
                 }
@@ -292,8 +653,8 @@ async function prepare(cwd) {
         isUsingTs = true;
         if (!fs__default.default.existsSync(tsconfigPath)) {
             await fsp__default.default.writeFile(tsconfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
+            logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
         }
-        logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
     }
     // Configure as ESM package by default if there's no package.json
     if (!hasPackageJson) {
@@ -335,19 +696,22 @@ async function prepare(cwd) {
             const isESM = pkgJson.type === 'module';
             const mainExport = pkgExports['.'];
             const mainCondition = isESM ? 'import' : 'require';
-            if (!pkgJson.main) {
-                pkgJson.main = isUsingTs ? mainExport[mainCondition].default : mainExport[mainCondition];
-            }
-            if (!pkgJson.module) {
-                pkgJson.module = isUsingTs ? mainExport.import.default : mainExport.import;
-            }
+            pkgJson.main = isUsingTs ? mainExport[mainCondition].default : mainExport[mainCondition];
+            pkgJson.module = isUsingTs ? mainExport.import.default : mainExport.import;
             if (isUsingTs) {
                 pkgJson.types = mainExport[mainCondition].types;
             }
         }
         // Assign the properties by order: files, main, module, types, exports
         if (Object.keys(pkgExports).length > 0) {
-            pkgJson.exports = pkgExports;
+            if (!pkgJson.exports) {
+                pkgJson.exports = pkgExports;
+            } else {
+                // Update existing exports
+                Object.keys(pkgExports).forEach((exportName)=>{
+                    pkgJson.exports[exportName] = pkgExports[exportName];
+                });
+            }
         }
     }
     await fsp__default.default.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
@@ -367,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
@@ -377,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;
@@ -410,6 +766,7 @@ function parseCliArgs(argv) {
         '--env': String,
         '--external': String,
         '--no-external': Boolean,
+        '--no-clean': Boolean,
         '--prepare': Boolean,
         '-h': '--help',
         '-v': '--version',
@@ -436,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']
     };
@@ -443,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 = {
@@ -457,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);
@@ -469,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) {
@@ -486,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;