bunchee 5.0.0 → 5.1.0

package/README.md

@@ -14,7 +14,7 @@
   </a>
 </p>
 
-**bunchee** is a zero configuration bundler makes bundling JS/tS library effortless. It's built on top of Rollup and SWC ⚡️, allowing you to focus on writing code and generating multiple bundles (CommonJS or ESModule) at the same time.
+**bunchee** is a zero configuration bundler makes bundling JS/TS library effortless. It's built on top of Rollup and SWC ⚡️, allowing you to focus on writing code and generating multiple bundles (CommonJS or ESModule) at the same time.
 It uses the standard exports configuration in `package.json` as the only source of truth, and uses entry file conventions to match your exports and build them into bundles.
 
 ## Quick Start

package/dist/bin/cli.js

@@ -162,7 +162,8 @@ function isTypescriptFile(filename) {
 function fileExists(filePath) {
     return fs__default.default.existsSync(filePath);
 }
-const hasAvailableExtension = (filename)=>availableExtensions.has(path__default.default.extname(filename).slice(1));
+// 'index.server.js' -> 'index'
+const getFileBasename = (str)=>str.split('.')[0];
 const hasCjsExtension = (filename)=>path__default.default.extname(filename) === '.cjs';
 const getMainFieldExportType = (pkg)=>{
     const isEsmPkg = isESModulePackage(pkg.type);
@@ -183,23 +184,27 @@ function joinRelativePath(...segments) {
 function isESModulePackage(packageType) {
     return packageType === 'module';
 }
+function isBinExportPath(exportPath) {
+    return exportPath === BINARY_TAG || exportPath.startsWith(BINARY_TAG + '/');
+}
 
 function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exportToDist) {
     // End of searching, export value is file path.
     // <export key>: <export value> (string)
     if (typeof exportValue === 'string') {
         const composedTypes = new Set(exportTypes);
-        composedTypes.add(exportKey.startsWith('.') ? 'default' : exportKey);
-        const exportInfo = exportToDist.get(currentPath);
+        const exportType = exportKey.startsWith('.') ? 'default' : exportKey;
+        composedTypes.add(exportType);
+        const exportInfo = exportToDist.get(mapExportFullPath(currentPath));
         const exportCondition = Array.from(composedTypes).join('.');
         if (!exportInfo) {
             const outputConditionPair = [
                 exportValue,
                 exportCondition
             ];
-            exportToDist.set(currentPath, [
+            addToExportDistMap(exportToDist, currentPath, [
                 outputConditionPair
-            ]);
+            ], runtimeExportConventions.has(exportType) ? exportType : undefined);
         } else {
             exportInfo.push([
                 exportValue,
@@ -225,10 +230,26 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
         }
     }
 }
+const mapExportFullPath = (exportPath)=>exportPath === '.' ? './index' : exportPath;
+function addToExportDistMap(exportToDist, exportPath, outputConditionPairs, specialExportType) {
+    const fullPath = mapExportFullPath(exportPath);
+    // + (specialExportType ? '.' + specialExportType : '')
+    const existingExportInfo = exportToDist.get(fullPath);
+    if (!existingExportInfo) {
+        exportToDist.set(fullPath, outputConditionPairs);
+    } else {
+        existingExportInfo.push(...outputConditionPairs);
+    }
+}
 /**
  * parseExports - parse package.exports field and other fields like main,module to a map
  *
  * map from export path to output path and export conditions
+ *
+ * exportToDist: {
+ *  './index': { development: ..., default: ... }
+ *  './index.react-server': { development: ..., default: ... }
+ * }
  */ function parseExports(pkg) {
     var _pkg_exports;
     const exportsField = (_pkg_exports = pkg.exports) != null ? _pkg_exports : {};
@@ -243,7 +264,7 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
             exportsField,
             defaultCondition
         ];
-        exportToDist.set(currentPath, [
+        addToExportDistMap(exportToDist, currentPath, [
             outputConditionPair
         ]);
     } else {
@@ -265,7 +286,7 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
             bins,
             defaultCondition
         ];
-        exportToDist.set(BINARY_TAG, [
+        addToExportDistMap(exportToDist, BINARY_TAG, [
             outputConditionPair
         ]);
     } else {
@@ -277,7 +298,7 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
                 binDistPath,
                 exportType
             ];
-            exportToDist.set(exportPath, [
+            addToExportDistMap(exportToDist, exportPath, [
                 outputConditionPair
             ]);
         }
@@ -287,9 +308,7 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
         const mainExportPath = pkg.main;
         const moduleExportPath = pkg.module;
         const typesEntryPath = pkg.types;
-        const existingExportInfo = exportToDist.get('.');
-        exportToDist.set('.', [
-            ...existingExportInfo || [],
+        addToExportDistMap(exportToDist, './index', [
             Boolean(mainExportPath) && [
                 mainExportPath,
                 getMainFieldExportType(pkg)
@@ -455,7 +474,7 @@ function lint$1(pkg) {
     }
 }
 
-var version = "5.0.0";
+var version = "5.1.0";
 
 function relativify(path) {
     return path.startsWith('.') ? path : `./${path}`;
@@ -470,20 +489,20 @@ async function writeDefaultTsconfig(tsConfigPath) {
 // shared.<export condition>.ts -> ./shared
 // index.ts -> ./index
 // index.development.ts -> ./index.development
-function sourceFilenameToExportPath(filename) {
+function sourceFilenameToExportFullPath(filename) {
     const baseName = baseNameWithoutExtension(filename);
     let exportPath = baseName;
     return relativify(exportPath);
 }
-// ./index -> import|require|default
+// ./index -> default
 // ./index.development -> development
 // ./index.react-server -> react-server
 function getExportTypeFromExportPath(exportPath) {
     // Skip the first two segments: `.` and `index`
     const exportTypes = exportPath.split('.').slice(2);
-    return getExportTypeFromExportTypes(exportTypes);
+    return getExportTypeFromExportTypesArray(exportTypes);
 }
-function getSpecialExportTypeFromExportPath(composedExportType) {
+function getSpecialExportTypeFromComposedExportPath(composedExportType) {
     const exportTypes = composedExportType.split('.');
     for (const exportType of exportTypes){
         if (specialExportConventions.has(exportType)) {
@@ -492,7 +511,7 @@ function getSpecialExportTypeFromExportPath(composedExportType) {
     }
     return 'default';
 }
-function getExportTypeFromExportTypes(types) {
+function getExportTypeFromExportTypesArray(types) {
     let exportType = 'default';
     new Set(types).forEach((value)=>{
         if (specialExportConventions.has(value)) {
@@ -524,6 +543,95 @@ function normalizeExportPath(exportPath) {
     }
     return baseName;
 }
+async function collectSourceEntriesByExportPath(sourceFolderPath, originalSubpath, bins, exportsEntries) {
+    const isBinaryPath = isBinExportPath(originalSubpath);
+    const subpath = originalSubpath.replace(BINARY_TAG, 'bin');
+    const absoluteDirPath = path__default.default.join(sourceFolderPath, subpath);
+    const isDirectory = fs__default.default.existsSync(absoluteDirPath) ? (await fsp__default.default.stat(absoluteDirPath)).isDirectory() : false;
+    if (isDirectory) {
+        if (isBinaryPath) {
+            const binDirentList = await fsp__default.default.readdir(absoluteDirPath, {
+                withFileTypes: true
+            });
+            for (const binDirent of binDirentList){
+                if (binDirent.isFile()) {
+                    const binFileAbsolutePath = path__default.default.join(binDirent.path, binDirent.name);
+                    if (fs__default.default.existsSync(binFileAbsolutePath)) {
+                        bins.set(normalizeExportPath(originalSubpath), binFileAbsolutePath);
+                    }
+                }
+            }
+        } else {
+            // Search folder/index.<ext> convention entries
+            for (const extension of availableExtensions){
+                const indexAbsoluteFile = path__default.default.join(absoluteDirPath, `index.${extension}`);
+                // Search folder/index.<special type>.<ext> convention entries
+                for (const specialExportType of runtimeExportConventions){
+                    const indexSpecialAbsoluteFile = path__default.default.join(absoluteDirPath, `index.${specialExportType}.${extension}`);
+                    if (fs__default.default.existsSync(indexSpecialAbsoluteFile)) {
+                        // Add special export path
+                        // { ./<export path>.<special cond>: { <special cond>: 'index.<special cond>.<ext>' } }
+                        const exportPath = relativify(subpath);
+                        const specialExportPath = exportPath + '.' + specialExportType;
+                        const sourceFilesMap = exportsEntries.get(specialExportPath) || {};
+                        sourceFilesMap[specialExportType] = indexSpecialAbsoluteFile;
+                        exportsEntries.set(specialExportPath, sourceFilesMap);
+                    }
+                }
+                if (fs__default.default.existsSync(indexAbsoluteFile) && !isTestFile(indexAbsoluteFile)) {
+                    const exportPath = relativify(subpath);
+                    const sourceFilesMap = exportsEntries.get(exportPath) || {};
+                    const exportType = getExportTypeFromExportPath(exportPath);
+                    sourceFilesMap[exportType] = indexAbsoluteFile;
+                    exportsEntries.set(exportPath, sourceFilesMap);
+                    break;
+                }
+            }
+        }
+    } else {
+        // subpath could be a file
+        const dirName = path.dirname(subpath);
+        const baseName = path.basename(subpath);
+        // Read current file's directory
+        const dirPath = path__default.default.join(sourceFolderPath, dirName);
+        if (!fs__default.default.existsSync(dirPath)) {
+            return;
+        }
+        const dirents = await fsp__default.default.readdir(dirPath, {
+            withFileTypes: true
+        });
+        for (const dirent of dirents){
+            // index.development.js -> index.development
+            const direntBaseName = baseNameWithoutExtension(dirent.name);
+            const ext = path.extname(dirent.name).slice(1);
+            if (!dirent.isFile() || direntBaseName !== baseName || !availableExtensions.has(ext)) {
+                continue;
+            }
+            if (isTestFile(dirent.name)) {
+                continue;
+            }
+            const sourceFileAbsolutePath = path__default.default.join(dirent.path, dirent.name);
+            if (isBinaryPath) {
+                bins.set(originalSubpath, sourceFileAbsolutePath);
+            } else {
+                let sourceFilesMap = exportsEntries.get(originalSubpath) || {};
+                const exportType = getExportTypeFromExportPath(originalSubpath);
+                sourceFilesMap[exportType] = sourceFileAbsolutePath;
+                if (specialExportConventions.has(exportType)) {
+                    // e.g. ./foo/index.react-server -> ./foo/index
+                    const fallbackExportPath = sourceFilenameToExportFullPath(originalSubpath);
+                    const fallbackSourceFilesMap = exportsEntries.get(fallbackExportPath) || {};
+                    sourceFilesMap = {
+                        ...fallbackSourceFilesMap,
+                        ...sourceFilesMap
+                    };
+                }
+                exportsEntries.set(originalSubpath, sourceFilesMap);
+            }
+        }
+    }
+}
+// For `prepare`
 async function collectSourceEntries(sourceFolderPath) {
     const bins = new Map();
     const exportsEntries = new Map();
@@ -536,65 +644,27 @@ async function collectSourceEntries(sourceFolderPath) {
     const entryFileDirentList = await fsp__default.default.readdir(sourceFolderPath, {
         withFileTypes: true
     });
+    // Collect source files for `exports` field
     for (const dirent of entryFileDirentList){
-        if (dirent.isDirectory()) {
-            if (dirent.name === 'bin') {
-                const binDirentList = await fsp__default.default.readdir(path__default.default.join(sourceFolderPath, dirent.name), {
-                    withFileTypes: true
-                });
-                for (const binDirent of binDirentList){
-                    if (binDirent.isFile()) {
-                        const binFileAbsolutePath = path__default.default.join(sourceFolderPath, dirent.name, binDirent.name);
-                        const binExportPath = sourceFilenameToExportPath(binDirent.name);
-                        if (fs__default.default.existsSync(binFileAbsolutePath)) {
-                            bins.set(path.posix.join(BINARY_TAG, binExportPath), binFileAbsolutePath);
-                        }
-                    }
-                }
-            } else {
-                // Search folder/index.<ext> convention entries
-                for (const extension of availableExtensions){
-                    const indexAbsoluteFile = path__default.default.join(dirent.path, dirent.name, `index.${extension}`);
-                    // Search folder/index.<special type>.<ext> convention entries
-                    for (const specialExportType of runtimeExportConventions){
-                        const indexSpecialAbsoluteFile = path__default.default.join(dirent.path, dirent.name, `index.${specialExportType}.${extension}`);
-                        if (fs__default.default.existsSync(indexSpecialAbsoluteFile)) {
-                            // Add special export path
-                            // { ./<export path>.<special cond>: { <special cond>: 'index.<special cond>.<ext>' } }
-                            const exportPath = sourceFilenameToExportPath(dirent.name);
-                            const specialExportPath = exportPath + '.' + specialExportType;
-                            const sourceFilesMap = exportsEntries.get(specialExportPath) || {};
-                            sourceFilesMap[specialExportType] = indexSpecialAbsoluteFile;
-                            exportsEntries.set(specialExportPath, sourceFilesMap);
-                        }
-                    }
-                    if (fs__default.default.existsSync(indexAbsoluteFile) && !isTestFile(indexAbsoluteFile)) {
-                        const exportPath = sourceFilenameToExportPath(dirent.name);
-                        const sourceFilesMap = exportsEntries.get(exportPath) || {};
-                        const exportType = getExportTypeFromExportPath(exportPath);
-                        sourceFilesMap[exportType] = indexAbsoluteFile;
-                        exportsEntries.set(exportPath, sourceFilesMap);
-                        break;
-                    }
-                }
-            }
-        } else if (dirent.isFile()) {
-            const isAvailableExtension = availableExtensions.has(path__default.default.extname(dirent.name).slice(1));
-            if (isAvailableExtension) {
-                const exportPath = sourceFilenameToExportPath(dirent.name);
-                const isBinFile = exportPath === './bin';
-                const fullPath = path__default.default.join(sourceFolderPath, dirent.name);
-                if (isBinFile) {
-                    bins.set(BINARY_TAG, fullPath);
-                } else {
-                    if (hasAvailableExtension(dirent.name) && !isTestFile(dirent.name)) {
-                        const sourceFilesMap = exportsEntries.get(exportPath) || {};
-                        const exportType = getExportTypeFromExportPath(exportPath);
-                        sourceFilesMap[exportType] = fullPath;
-                        exportsEntries.set(exportPath, sourceFilesMap);
-                    }
-                }
+        if (getFileBasename(dirent.name) === 'bin') {
+            continue;
+        }
+        const exportPath = sourceFilenameToExportFullPath(dirent.name);
+        await collectSourceEntriesByExportPath(sourceFolderPath, exportPath, bins, exportsEntries);
+    }
+    // Collect source files for `bin` field
+    const binDirent = entryFileDirentList.find((dirent)=>getFileBasename(dirent.name) === 'bin');
+    if (binDirent) {
+        if (binDirent.isDirectory()) {
+            const binDirentList = await fsp__default.default.readdir(path__default.default.join(binDirent.path, binDirent.name), {
+                withFileTypes: true
+            });
+            for (const binDirent of binDirentList){
+                const binExportPath = path.posix.join(BINARY_TAG, getFileBasename(binDirent.name));
+                await collectSourceEntriesByExportPath(sourceFolderPath, binExportPath, bins, exportsEntries);
             }
+        } else {
+            await collectSourceEntriesByExportPath(sourceFolderPath, BINARY_TAG, bins, exportsEntries);
         }
     }
     return {
@@ -646,7 +716,7 @@ function createExportCondition(exportName, sourceFile, moduleType) {
 function createExportConditionPair(exportName, sourceFile, moduleType) {
     // <exportName>.<specialCondition>
     let specialCondition;
-    const specialConditionName = getSpecialExportTypeFromExportPath(exportName);
+    const specialConditionName = getSpecialExportTypeFromComposedExportPath(exportName);
     const normalizedExportPath = normalizeExportPath(exportName);
     if (specialConditionName !== 'default') {
         // e.g.
@@ -741,10 +811,10 @@ async function prepare(cwd) {
         const pkgExports = {};
         for (const [exportName, sourceFilesMap] of exportsEntries.entries()){
             for (const sourceFile of Object.values(sourceFilesMap)){
-                const [key, value] = createExportConditionPair(exportName, sourceFile, pkgJson.type);
-                pkgExports[key] = {
-                    ...value,
-                    ...pkgExports[key]
+                const [normalizedExportPath, conditions] = createExportConditionPair(exportName, sourceFile, pkgJson.type);
+                pkgExports[normalizedExportPath] = {
+                    ...conditions,
+                    ...pkgExports[normalizedExportPath]
                 };
             }
         }

package/dist/index.js

@@ -238,7 +238,6 @@ function filePathWithoutExtension(filePath) {
     }
     return filePath;
 }
-const hasAvailableExtension = (filename)=>availableExtensions.has(path__default.default.extname(filename).slice(1));
 const hasCjsExtension = (filename)=>path__default.default.extname(filename) === '.cjs';
 const getMainFieldExportType = (pkg)=>{
     const isEsmPkg = isESModulePackage(pkg.type);
@@ -282,6 +281,9 @@ async function removeOutputDir(output, cwd) {
         removedDirs.add(dir);
     }
 }
+function isBinExportPath(exportPath) {
+    return exportPath === BINARY_TAG || exportPath.startsWith(BINARY_TAG + '/');
+}
 
 const memoize = (fn, cacheKey, cacheArg)=>{
     const cache = cacheArg || new Map();
@@ -533,27 +535,25 @@ function relativify(path) {
 // e.g.
 // For a resolved file, if it's one of the entries,
 // aliases it as export path, such as <absolute file> -> <pkg>/<export path>
-function aliasEntries({ entry, entries, entriesAlias, format, dts }) {
-    let currentDistPath = '';
+function aliasEntries({ entry, entries, entriesAlias, format, dts, cwd }) {
     const entryAliasWithoutSelf = {
         ...entriesAlias,
         [entry]: null
     };
     const pathToRelativeDistMap = new Map();
     for (const [, exportCondition] of Object.entries(entries)){
-        var _Object_entries_find;
-        const { import: importCond, require: requireCond, default: defaultCond } = exportCondition.export;
-        const firstCond = (_Object_entries_find = Object.entries(exportCondition.export).find(([key, cond])=>key !== 'types' && cond != null)) == null ? void 0 : _Object_entries_find[1];
+        const exportDistMaps = exportCondition.export;
         if (dts) {
-            const fallbackCond = defaultCond || firstCond;
-            // For cjs, use require() instead of import
-            const firstDistPath = (format === 'cjs' ? requireCond : importCond) || fallbackCond;
-            if (firstDistPath) {
-                if (entry !== exportCondition.source) {
-                    pathToRelativeDistMap.set(exportCondition.source, firstDistPath);
-                } else {
-                    currentDistPath = firstDistPath;
-                }
+            var _Object_entries_find;
+            // Search types + [format] condition from entries map
+            // e.g. import.types, require.types
+            const typeCond = (_Object_entries_find = Object.entries(exportDistMaps).find(([composedKey, cond])=>{
+                const typesSet = new Set(composedKey.split('.'));
+                const formatCond = format === 'cjs' ? 'require' : 'import';
+                return typesSet.has('types') && typesSet.has(formatCond) && cond != null;
+            })) == null ? void 0 : _Object_entries_find[1];
+            if (typeCond) {
+                pathToRelativeDistMap.set(exportCondition.source, typeCond);
             }
         }
     }
@@ -561,23 +561,25 @@ function aliasEntries({ entry, entries, entriesAlias, format, dts }) {
         name: 'alias',
         resolveId: {
             async handler (source, importer, options) {
-                const resolvedId = await this.resolve(source, importer, options);
-                if (resolvedId != null) {
+                const resolved = await this.resolve(source, importer, options);
+                if (resolved != null) {
                     if (dts) {
                         // For types, generate relative path to the other type files,
                         // this will be compatible for the node10 ts module resolution.
-                        const aliasedId = pathToRelativeDistMap.get(resolvedId.id);
-                        if (aliasedId != null && aliasedId !== currentDistPath) {
-                            const ext = path__default.default.extname(aliasedId);
-                            const filePathBase = filePathWithoutExtension(path__default.default.relative(path__default.default.dirname(currentDistPath), aliasedId));
-                            const relativePath = relativify(filePathBase + ext);
+                        const resolvedDist = pathToRelativeDistMap.get(resolved.id);
+                        const entryDist = pathToRelativeDistMap.get(entry);
+                        if (resolved.id !== entry && entryDist && resolvedDist) {
+                            const absoluteEntryDist = path__default.default.resolve(cwd, entryDist);
+                            const absoluteResolvedDist = path__default.default.resolve(cwd, resolvedDist);
+                            const filePathBase = path__default.default.relative(path__default.default.dirname(absoluteEntryDist), absoluteResolvedDist);
+                            const relativePath = relativify(filePathBase);
                             return {
                                 id: relativePath,
                                 external: true
                             };
                         }
                     } else {
-                        const aliasedId = entryAliasWithoutSelf[resolvedId.id];
+                        const aliasedId = entryAliasWithoutSelf[resolved.id];
                         if (aliasedId != null) {
                             return {
                                 id: aliasedId
@@ -613,22 +615,40 @@ function prependDirectives() {
     };
 }
 
+const prependShebang = (entry)=>({
+        name: 'prependShebang',
+        transform: (code, id)=>{
+            if (id !== entry) return;
+            const shebang = '#!/usr/bin/env node\n';
+            if (code.startsWith(shebang)) return;
+            const magicString = new MagicString__default.default(code);
+            magicString.prepend(shebang);
+            return {
+                code: magicString.toString(),
+                map: magicString.generateMap({
+                    hires: true
+                })
+            };
+        }
+    });
+
 function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exportToDist) {
     // End of searching, export value is file path.
     // <export key>: <export value> (string)
     if (typeof exportValue === 'string') {
         const composedTypes = new Set(exportTypes);
-        composedTypes.add(exportKey.startsWith('.') ? 'default' : exportKey);
-        const exportInfo = exportToDist.get(currentPath);
+        const exportType = exportKey.startsWith('.') ? 'default' : exportKey;
+        composedTypes.add(exportType);
+        const exportInfo = exportToDist.get(mapExportFullPath(currentPath));
         const exportCondition = Array.from(composedTypes).join('.');
         if (!exportInfo) {
             const outputConditionPair = [
                 exportValue,
                 exportCondition
             ];
-            exportToDist.set(currentPath, [
+            addToExportDistMap(exportToDist, currentPath, [
                 outputConditionPair
-            ]);
+            ], runtimeExportConventions.has(exportType) ? exportType : undefined);
         } else {
             exportInfo.push([
                 exportValue,
@@ -654,10 +674,26 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
         }
     }
 }
+const mapExportFullPath = (exportPath)=>exportPath === '.' ? './index' : exportPath;
+function addToExportDistMap(exportToDist, exportPath, outputConditionPairs, specialExportType) {
+    const fullPath = mapExportFullPath(exportPath);
+    // + (specialExportType ? '.' + specialExportType : '')
+    const existingExportInfo = exportToDist.get(fullPath);
+    if (!existingExportInfo) {
+        exportToDist.set(fullPath, outputConditionPairs);
+    } else {
+        existingExportInfo.push(...outputConditionPairs);
+    }
+}
 /**
  * parseExports - parse package.exports field and other fields like main,module to a map
  *
  * map from export path to output path and export conditions
+ *
+ * exportToDist: {
+ *  './index': { development: ..., default: ... }
+ *  './index.react-server': { development: ..., default: ... }
+ * }
  */ function parseExports(pkg) {
     var _pkg_exports;
     const exportsField = (_pkg_exports = pkg.exports) != null ? _pkg_exports : {};
@@ -672,7 +708,7 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
             exportsField,
             defaultCondition
         ];
-        exportToDist.set(currentPath, [
+        addToExportDistMap(exportToDist, currentPath, [
             outputConditionPair
         ]);
     } else {
@@ -694,7 +730,7 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
             bins,
             defaultCondition
         ];
-        exportToDist.set(BINARY_TAG, [
+        addToExportDistMap(exportToDist, BINARY_TAG, [
             outputConditionPair
         ]);
     } else {
@@ -706,7 +742,7 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
                 binDistPath,
                 exportType
             ];
-            exportToDist.set(exportPath, [
+            addToExportDistMap(exportToDist, exportPath, [
                 outputConditionPair
             ]);
         }
@@ -716,9 +752,7 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
         const mainExportPath = pkg.main;
         const moduleExportPath = pkg.module;
         const typesEntryPath = pkg.types;
-        const existingExportInfo = exportToDist.get('.');
-        exportToDist.set('.', [
-            ...existingExportInfo || [],
+        addToExportDistMap(exportToDist, './index', [
             Boolean(mainExportPath) && [
                 mainExportPath,
                 getMainFieldExportType(pkg)
@@ -836,7 +870,7 @@ function getExportTypeFromFile(filename, pkgType) {
 // shared.<export condition>.ts -> ./shared
 // index.ts -> ./index
 // index.development.ts -> ./index.development
-function sourceFilenameToExportPath(filename) {
+function sourceFilenameToExportFullPath(filename) {
     const baseName = baseNameWithoutExtension(filename);
     let exportPath = baseName;
     return relativify(exportPath);
@@ -844,8 +878,8 @@ function sourceFilenameToExportPath(filename) {
 async function collectEntriesFromParsedExports(cwd, parsedExportsInfo, sourceFile) {
     const entries = {};
     if (sourceFile) {
-        const defaultExport = parsedExportsInfo.get('.')[0];
-        entries['.'] = {
+        const defaultExport = parsedExportsInfo.get('./index')[0];
+        entries['./index'] = {
             source: sourceFile,
             name: '.',
             export: {
@@ -854,13 +888,13 @@ async function collectEntriesFromParsedExports(cwd, parsedExportsInfo, sourceFil
         };
     }
     // Find source files
-    const { bins, exportsEntries } = await collectSourceEntries(path.join(cwd, SRC));
+    const { bins, exportsEntries } = await collectSourceEntriesFromExportPaths(path.join(cwd, SRC), parsedExportsInfo);
     // A mapping between each export path and its related special export conditions,
     // excluding the 'default' export condition.
-    // { '.' => Set('development') }
+    // { './index' => Set('development', 'edge-light') }
     const pathSpecialConditionsMap = {};
     for (const [exportPath] of exportsEntries){
-        const normalizedExportPath = normalizeExportPath(exportPath);
+        const normalizedExportPath = stripSpecialCondition(exportPath);
         if (!pathSpecialConditionsMap[normalizedExportPath]) {
             pathSpecialConditionsMap[normalizedExportPath] = new Set();
         }
@@ -871,17 +905,19 @@ async function collectEntriesFromParsedExports(cwd, parsedExportsInfo, sourceFil
     }
     // Traverse source files and try to match the entries
     // Find exports from parsed exports info
-    // entryExportPath can be: '.', './index.development', './shared.edge-light', etc.
+    // entryExportPath can be: './index', './index.development', './shared.edge-light', etc.
     for (const [entryExportPath, sourceFilesMap] of exportsEntries){
-        const normalizedExportPath = normalizeExportPath(entryExportPath);
+        const normalizedExportPath = stripSpecialCondition(entryExportPath);
         const entryExportPathType = getExportTypeFromExportPath(entryExportPath);
         const outputExports = parsedExportsInfo.get(normalizedExportPath);
         if (!outputExports) {
             continue;
         }
-        for (const [outputPath, composedExportType] of outputExports){
-            const matchedExportType = getSpecialExportTypeFromExportPath(composedExportType);
+        for (const [outputPath, outputComposedExportType] of outputExports){
             // export type can be: default, development, react-server, etc.
+            const matchedExportType = getSpecialExportTypeFromComposedExportPath(outputComposedExportType);
+            const specialSet = pathSpecialConditionsMap[normalizedExportPath];
+            const hasSpecialEntry = specialSet.has(matchedExportType);
             const sourceFile = sourceFilesMap[matchedExportType] || sourceFilesMap.default;
             if (!sourceFile) {
                 continue;
@@ -892,18 +928,19 @@ async function collectEntriesFromParsedExports(cwd, parsedExportsInfo, sourceFil
                     name: normalizedExportPath,
                     export: {}
                 };
+            } else if (matchedExportType === entryExportPathType) {
+                entries[entryExportPath].source = sourceFile;
             }
-            const exportMap = entries[entryExportPath].export;
-            if (entryExportPathType === 'default' && matchedExportType !== 'default' && pathSpecialConditionsMap[normalizedExportPath].size > 0) {
-                continue;
+            // output exports match
+            if (matchedExportType === entryExportPathType || !hasSpecialEntry && matchedExportType !== 'default') {
+                const exportMap = entries[entryExportPath].export;
+                exportMap[outputComposedExportType] = outputPath;
             }
-            exportMap[composedExportType] = outputPath;
         }
     }
     // Handling binaries
     for (const [exportPath, sourceFile] of bins){
-        const normalizedExportPath = normalizeExportPath(exportPath);
-        const outputExports = parsedExportsInfo.get(normalizedExportPath);
+        const outputExports = parsedExportsInfo.get(exportPath);
         if (!outputExports) {
             continue;
         }
@@ -919,15 +956,15 @@ async function collectEntriesFromParsedExports(cwd, parsedExportsInfo, sourceFil
     }
     return entries;
 }
-// ./index -> import|require|default
+// ./index -> default
 // ./index.development -> development
 // ./index.react-server -> react-server
 function getExportTypeFromExportPath(exportPath) {
     // Skip the first two segments: `.` and `index`
     const exportTypes = exportPath.split('.').slice(2);
-    return getExportTypeFromExportTypes(exportTypes);
+    return getExportTypeFromExportTypesArray(exportTypes);
 }
-function getSpecialExportTypeFromExportPath(composedExportType) {
+function getSpecialExportTypeFromComposedExportPath(composedExportType) {
     const exportTypes = composedExportType.split('.');
     for (const exportType of exportTypes){
         if (specialExportConventions.has(exportType)) {
@@ -936,7 +973,7 @@ function getSpecialExportTypeFromExportPath(composedExportType) {
     }
     return 'default';
 }
-function getExportTypeFromExportTypes(types) {
+function getExportTypeFromExportTypesArray(types) {
     let exportType = 'default';
     new Set(types).forEach((value)=>{
         if (specialExportConventions.has(value)) {
@@ -968,85 +1005,152 @@ function normalizeExportPath(exportPath) {
     }
     return baseName;
 }
-async function collectSourceEntries(sourceFolderPath) {
-    const bins = new Map();
-    const exportsEntries = new Map();
-    if (!fs__default.default.existsSync(sourceFolderPath)) {
-        return {
-            bins,
-            exportsEntries
-        };
-    }
-    const entryFileDirentList = await fsp__default.default.readdir(sourceFolderPath, {
-        withFileTypes: true
-    });
-    for (const dirent of entryFileDirentList){
-        if (dirent.isDirectory()) {
-            if (dirent.name === 'bin') {
-                const binDirentList = await fsp__default.default.readdir(path__default.default.join(sourceFolderPath, dirent.name), {
-                    withFileTypes: true
-                });
-                for (const binDirent of binDirentList){
-                    if (binDirent.isFile()) {
-                        const binFileAbsolutePath = path__default.default.join(sourceFolderPath, dirent.name, binDirent.name);
-                        const binExportPath = sourceFilenameToExportPath(binDirent.name);
-                        if (fs__default.default.existsSync(binFileAbsolutePath)) {
-                            bins.set(path.posix.join(BINARY_TAG, binExportPath), binFileAbsolutePath);
-                        }
+// ./index.react-server -> ./index
+function stripSpecialCondition(exportPath) {
+    return exportPath.split('.').slice(0, 2).join('.');
+}
+async function collectSourceEntriesByExportPath(sourceFolderPath, originalSubpath, bins, exportsEntries) {
+    const isBinaryPath = isBinExportPath(originalSubpath);
+    const subpath = originalSubpath.replace(BINARY_TAG, 'bin');
+    const absoluteDirPath = path__default.default.join(sourceFolderPath, subpath);
+    const isDirectory = fs__default.default.existsSync(absoluteDirPath) ? (await fsp__default.default.stat(absoluteDirPath)).isDirectory() : false;
+    if (isDirectory) {
+        if (isBinaryPath) {
+            const binDirentList = await fsp__default.default.readdir(absoluteDirPath, {
+                withFileTypes: true
+            });
+            for (const binDirent of binDirentList){
+                if (binDirent.isFile()) {
+                    const binFileAbsolutePath = path__default.default.join(binDirent.path, binDirent.name);
+                    if (fs__default.default.existsSync(binFileAbsolutePath)) {
+                        bins.set(normalizeExportPath(originalSubpath), binFileAbsolutePath);
                     }
                 }
-            } else {
-                // Search folder/index.<ext> convention entries
-                for (const extension of availableExtensions){
-                    const indexAbsoluteFile = path__default.default.join(dirent.path, dirent.name, `index.${extension}`);
-                    // Search folder/index.<special type>.<ext> convention entries
-                    for (const specialExportType of runtimeExportConventions){
-                        const indexSpecialAbsoluteFile = path__default.default.join(dirent.path, dirent.name, `index.${specialExportType}.${extension}`);
-                        if (fs__default.default.existsSync(indexSpecialAbsoluteFile)) {
-                            // Add special export path
-                            // { ./<export path>.<special cond>: { <special cond>: 'index.<special cond>.<ext>' } }
-                            const exportPath = sourceFilenameToExportPath(dirent.name);
-                            const specialExportPath = exportPath + '.' + specialExportType;
-                            const sourceFilesMap = exportsEntries.get(specialExportPath) || {};
-                            sourceFilesMap[specialExportType] = indexSpecialAbsoluteFile;
-                            exportsEntries.set(specialExportPath, sourceFilesMap);
-                        }
-                    }
-                    if (fs__default.default.existsSync(indexAbsoluteFile) && !isTestFile(indexAbsoluteFile)) {
-                        const exportPath = sourceFilenameToExportPath(dirent.name);
-                        const sourceFilesMap = exportsEntries.get(exportPath) || {};
-                        const exportType = getExportTypeFromExportPath(exportPath);
-                        sourceFilesMap[exportType] = indexAbsoluteFile;
-                        exportsEntries.set(exportPath, sourceFilesMap);
-                        break;
+            }
+        } else {
+            // Search folder/index.<ext> convention entries
+            for (const extension of availableExtensions){
+                const indexAbsoluteFile = path__default.default.join(absoluteDirPath, `index.${extension}`);
+                // Search folder/index.<special type>.<ext> convention entries
+                for (const specialExportType of runtimeExportConventions){
+                    const indexSpecialAbsoluteFile = path__default.default.join(absoluteDirPath, `index.${specialExportType}.${extension}`);
+                    if (fs__default.default.existsSync(indexSpecialAbsoluteFile)) {
+                        // Add special export path
+                        // { ./<export path>.<special cond>: { <special cond>: 'index.<special cond>.<ext>' } }
+                        const exportPath = relativify(subpath);
+                        const specialExportPath = exportPath + '.' + specialExportType;
+                        const sourceFilesMap = exportsEntries.get(specialExportPath) || {};
+                        sourceFilesMap[specialExportType] = indexSpecialAbsoluteFile;
+                        exportsEntries.set(specialExportPath, sourceFilesMap);
                     }
                 }
+                if (fs__default.default.existsSync(indexAbsoluteFile) && !isTestFile(indexAbsoluteFile)) {
+                    const exportPath = relativify(subpath);
+                    const sourceFilesMap = exportsEntries.get(exportPath) || {};
+                    const exportType = getExportTypeFromExportPath(exportPath);
+                    sourceFilesMap[exportType] = indexAbsoluteFile;
+                    exportsEntries.set(exportPath, sourceFilesMap);
+                    break;
+                }
             }
-        } else if (dirent.isFile()) {
-            const isAvailableExtension = availableExtensions.has(path__default.default.extname(dirent.name).slice(1));
-            if (isAvailableExtension) {
-                const exportPath = sourceFilenameToExportPath(dirent.name);
-                const isBinFile = exportPath === './bin';
-                const fullPath = path__default.default.join(sourceFolderPath, dirent.name);
-                if (isBinFile) {
-                    bins.set(BINARY_TAG, fullPath);
-                } else {
-                    if (hasAvailableExtension(dirent.name) && !isTestFile(dirent.name)) {
-                        const sourceFilesMap = exportsEntries.get(exportPath) || {};
-                        const exportType = getExportTypeFromExportPath(exportPath);
-                        sourceFilesMap[exportType] = fullPath;
-                        exportsEntries.set(exportPath, sourceFilesMap);
-                    }
+        }
+    } else {
+        // subpath could be a file
+        const dirName = path.dirname(subpath);
+        const baseName = path.basename(subpath);
+        // Read current file's directory
+        const dirPath = path__default.default.join(sourceFolderPath, dirName);
+        if (!fs__default.default.existsSync(dirPath)) {
+            return;
+        }
+        const dirents = await fsp__default.default.readdir(dirPath, {
+            withFileTypes: true
+        });
+        for (const dirent of dirents){
+            // index.development.js -> index.development
+            const direntBaseName = baseNameWithoutExtension(dirent.name);
+            const ext = path.extname(dirent.name).slice(1);
+            if (!dirent.isFile() || direntBaseName !== baseName || !availableExtensions.has(ext)) {
+                continue;
+            }
+            if (isTestFile(dirent.name)) {
+                continue;
+            }
+            const sourceFileAbsolutePath = path__default.default.join(dirent.path, dirent.name);
+            if (isBinaryPath) {
+                bins.set(originalSubpath, sourceFileAbsolutePath);
+            } else {
+                let sourceFilesMap = exportsEntries.get(originalSubpath) || {};
+                const exportType = getExportTypeFromExportPath(originalSubpath);
+                sourceFilesMap[exportType] = sourceFileAbsolutePath;
+                if (specialExportConventions.has(exportType)) {
+                    // e.g. ./foo/index.react-server -> ./foo/index
+                    const fallbackExportPath = sourceFilenameToExportFullPath(originalSubpath);
+                    const fallbackSourceFilesMap = exportsEntries.get(fallbackExportPath) || {};
+                    sourceFilesMap = {
+                        ...fallbackSourceFilesMap,
+                        ...sourceFilesMap
+                    };
                 }
+                exportsEntries.set(originalSubpath, sourceFilesMap);
             }
         }
     }
+}
+/**
+ * exportsEntries {
+ *   "./index" => {
+ *      "development" => source"
+ *      "react-server" => "source"
+ *   },
+ *  "./index.react-server" => {
+ *      "development" => source"
+ *      "react-server" => "source"
+ *   }
+ *  }
+ */ async function collectSourceEntriesFromExportPaths(sourceFolderPath, parsedExportsInfo) {
+    const bins = new Map();
+    const exportsEntries = new Map();
+    for (const [exportPath, exportInfo] of parsedExportsInfo.entries()){
+        const specialConditions = new Set();
+        for (const [_, composedExportType] of exportInfo){
+            const specialExportType = getSpecialExportTypeFromComposedExportPath(composedExportType);
+            if (specialExportType !== 'default') {
+                specialConditions.add(specialExportType);
+            }
+        }
+        await collectSourceEntriesByExportPath(sourceFolderPath, exportPath, bins, exportsEntries);
+        for (const specialCondition of specialConditions){
+            await collectSourceEntriesByExportPath(sourceFolderPath, exportPath + '.' + specialCondition, bins, exportsEntries);
+        }
+    }
     return {
         bins,
         exportsEntries
     };
 }
 
+function getModuleLayer(moduleMeta) {
+    const directives = (moduleMeta.preserveDirectives || {
+        directives: []
+    }).directives.map((d)=>d.replace(/^use /, '')).filter((d)=>d !== 'strict');
+    const moduleLayer = directives[0];
+    return moduleLayer;
+}
+function getCustomModuleLayer(moduleId) {
+    const segments = path__default.default.basename(moduleId).split('.');
+    if (segments.length >= 2) {
+        const [layerSegment, ext] = segments.slice(-2);
+        const baseName = segments[0];
+        const match = layerSegment.match(/^(\w+)-runtime$/);
+        const layer = match && match[1];
+        if (availableExtensions.has(ext) && layer && layer.length > 0) {
+            return baseName + '-' + layer;
+        }
+    }
+    return undefined;
+}
+
 const swcMinifyOptions = {
     compress: {
         directives: false
@@ -1105,7 +1209,7 @@ const memoizeDtsPluginByKey = memoizeByKey(createDtsPlugin);
     for (const [entryExportPath, exportCondition] of Object.entries(entries)){
         const normalizedExportPath = normalizeExportPath(entryExportPath);
         // entryExportPath format: ./index, ./shared, etc.
-        const specialExportType = getSpecialExportTypeFromExportPath(entryExportPath);
+        const specialExportType = getSpecialExportTypeFromComposedExportPath(entryExportPath);
         if (specialExportType === 'default') {
             alias[exportCondition.source] = path.posix.join(name || '', normalizedExportPath);
         }
@@ -1115,6 +1219,7 @@ const memoizeDtsPluginByKey = memoizeByKey(createDtsPlugin);
 async function buildInputConfig(entry, bundleConfig, exportCondition, buildContext, dts) {
     var _bundleConfig_file, _bundleConfig_file1;
     const { entries, pkg, cwd, tsOptions: { tsConfigPath, tsCompilerOptions }, pluginContext } = buildContext;
+    const isBinEntry = isBinExportPath(exportCondition.name);
     const hasNoExternal = bundleConfig.external === null;
     var _bundleConfig_external;
     const externals = hasNoExternal ? [] : [
@@ -1161,18 +1266,20 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
     // common plugins for both dts and ts assets that need to be processed
     // If it's a .d.ts file under non-ESM package or .d.cts file, use cjs types alias.
     const aliasFormat = dts ? ((_bundleConfig_file = bundleConfig.file) == null ? void 0 : _bundleConfig_file.endsWith('.d.cts')) || ((_bundleConfig_file1 = bundleConfig.file) == null ? void 0 : _bundleConfig_file1.endsWith('.d.ts')) && !isESModulePackage(pkg.type) ? 'cjs' : 'esm' : bundleConfig.format;
+    const aliasPlugin = aliasEntries({
+        entry,
+        entries,
+        entriesAlias: pluginContext.entriesAlias,
+        format: aliasFormat,
+        dts,
+        cwd
+    });
     const commonPlugins = [
         json__default.default(),
-        sizePlugin,
-        aliasEntries({
-            entry,
-            entries,
-            entriesAlias: pluginContext.entriesAlias,
-            format: aliasFormat,
-            dts
-        })
+        sizePlugin
     ];
     const typesPlugins = [
+        aliasPlugin,
         ...commonPlugins,
         inlineCss({
             skip: true
@@ -1188,14 +1295,15 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
     }
     const plugins = (dts ? typesPlugins : [
         ...commonPlugins,
+        preserveDirectives__default.default(),
+        aliasPlugin,
         inlineCss({
             exclude: /node_modules/
         }),
         rawContent({
             exclude: /node_modules/
         }),
-        preserveDirectives__default.default(),
-        prependDirectives(),
+        isBinEntry && prependShebang(entry),
         replace__default.default({
             values: inlineDefinedValues,
             preventAssignment: true
@@ -1215,7 +1323,8 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
         }),
         commonjs__default.default({
             exclude: bundleConfig.external || null
-        })
+        }),
+        prependDirectives()
     ]).filter(isNotNull);
     return {
         input: entry,
@@ -1235,30 +1344,13 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
             if (code === 'CIRCULAR_DEPENDENCY' && /Circular dependency:(\s|\S)*node_modules/.test(warning.message)) {
                 return;
             }
+            if (code === 'MODULE_LEVEL_DIRECTIVE') {
+                return;
+            }
             warn(warning);
         }
     };
 }
-function getModuleLater(moduleMeta) {
-    const directives = (moduleMeta.preserveDirectives || {
-        directives: []
-    }).directives.map((d)=>d.replace(/^use /, '')).filter((d)=>d !== 'strict');
-    const moduleLayer = directives[0];
-    return moduleLayer;
-}
-function getCustomModuleLayer(moduleId) {
-    const segments = path__default.default.basename(moduleId).split('.');
-    if (segments.length >= 2) {
-        const [layerSegment, ext] = segments.slice(-2);
-        const baseName = segments[0];
-        const match = layerSegment.match(/^(\w+)-runtime$/);
-        const layer = match && match[1];
-        if (availableExtensions.has(ext) && layer && layer.length > 0) {
-            return baseName + '-' + layer;
-        }
-    }
-    return undefined;
-}
 // dependencyGraphMap: Map<subModuleId, Set<entryParentId>>
 function createSplitChunks(dependencyGraphMap, entryFiles) {
     // If there's existing chunk being splitted, and contains a layer { <id>: <chunkGroup> }
@@ -1270,7 +1362,7 @@ function createSplitChunks(dependencyGraphMap, entryFiles) {
         }
         const { isEntry } = moduleInfo;
         const moduleMeta = moduleInfo.meta;
-        const moduleLayer = getModuleLater(moduleMeta);
+        const moduleLayer = getModuleLayer(moduleMeta);
         if (!isEntry) {
             const cachedCustomModuleLayer = splitChunksGroupMap.get(id);
             if (cachedCustomModuleLayer) return cachedCustomModuleLayer;
@@ -1288,7 +1380,7 @@ function createSplitChunks(dependencyGraphMap, entryFiles) {
                 if (!subModuleInfo) {
                     continue;
                 }
-                const subModuleLayer = getModuleLater(moduleMeta);
+                const subModuleLayer = getModuleLayer(moduleMeta);
                 if (subModuleLayer === moduleLayer) {
                     if (!dependencyGraphMap.has(subId)) {
                         dependencyGraphMap.set(subId, new Set());
@@ -1311,7 +1403,7 @@ function createSplitChunks(dependencyGraphMap, entryFiles) {
                     // If other entry is dependency of this entry
                     if (entryFiles.has(id)) {
                         const entryModuleInfo = ctx.getModuleInfo(id);
-                        const entryModuleLayer = getModuleLater(entryModuleInfo ? entryModuleInfo.meta : {});
+                        const entryModuleLayer = getModuleLayer(entryModuleInfo ? entryModuleInfo.meta : {});
                         return entryModuleLayer === moduleLayer;
                     }
                     return false;
@@ -1520,20 +1612,17 @@ function createOutputState({ entries }) {
         }
     };
 }
-function isBin(filename) {
-    return filename === BINARY_TAG || filename.startsWith(BINARY_TAG + '/');
-}
 function isTypeFile(filename) {
     return filename.endsWith('.d.ts') || filename.endsWith('.d.mts') || filename.endsWith('.d.cts');
 }
 function normalizeExportName(exportName) {
-    const isBinary = isBin(exportName);
+    const isBinary = isBinExportPath(exportName);
     let result = exportName;
     if (isBinary) {
         result = (exportName.replace(new RegExp(`^\\${BINARY_TAG}\\/?`), '') || '.') + ' (bin)';
     } else {
         const normalizedExportPath = normalizeExportPath(exportName);
-        const specialConditionName = getSpecialExportTypeFromExportPath(exportName);
+        const specialConditionName = getSpecialExportTypeFromComposedExportPath(exportName);
         result = normalizedExportPath + (specialConditionName !== 'default' ? ` (${specialConditionName})` : '');
     }
     return result;
@@ -1674,7 +1763,7 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
             if (options.dts) {
                 typesEntryPath = getExportFileTypePath(mainExportPath);
             }
-            parsedExportsInfo.set('.', [
+            parsedExportsInfo.set('./index', [
                 [
                     mainExportPath,
                     'default'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunchee",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",