bunchee 4.4.8 → 5.0.0-beta.2

package/dist/bin/cli.js

@@ -26,13 +26,19 @@ const availableExtensions = new Set([
     'cts',
     'mts'
 ]);
-const suffixedExportConventions = new Set([
+const runtimeExportConventions = new Set([
     'react-server',
     'react-native',
-    'edge-light',
+    'edge-light'
+]);
+const optimizeConventions = new Set([
     'development',
     'production'
 ]);
+const specialExportConventions = new Set([
+    ...runtimeExportConventions,
+    ...optimizeConventions
+]);
 const SRC = 'src';
 const DIST = 'dist';
 const dtsExtensionsMap = {
@@ -52,6 +58,7 @@ const DEFAULT_TS_CONFIG = {
         moduleResolution: 'bundler'
     }
 };
+const BINARY_TAG = '$binary';
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -158,256 +165,147 @@ function fileExists(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);
+    const mainExportType = isEsmPkg && pkg.main ? hasCjsExtension(pkg.main) ? 'require' : 'import' : 'require';
+    return mainExportType;
+};
 // 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 getPackageTypings(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);
+    let result = path__default.default.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;
-};
-const joinExportAndCondition = (exportPath, condition)=>{
-    return (exportPath === '.' ? '' : exportPath) + '.' + condition;
-};
-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
-            };
+function isESModulePackage(packageType) {
+    return packageType === 'module';
+}
+
+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 exportCondition = Array.from(composedTypes).join('.');
+        if (!exportInfo) {
+            const outputConditionPair = [
+                exportValue,
+                exportCondition
+            ];
+            exportToDist.set(currentPath, [
+                outputConditionPair
+            ]);
         } else {
-            const exportJsBundlePath = getFirstExportPath(fullExportCondition);
-            if (suffixedExportConventions.has(exportPath)) {
-                const specialPath = joinExportAndCondition(currentPath, exportPath);
-                paths[specialPath] = {
-                    ...paths[specialPath],
-                    ...exportCondition
-                };
-            } else {
-                // exportPath is exportType, import, require, ...
-                // merge to currentPath
-                paths[currentPath] = {
-                    ...paths[currentPath],
-                    [exportPath]: exportJsBundlePath
-                };
-            }
+            exportInfo.push([
+                exportValue,
+                exportCondition
+            ]);
         }
         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;
-            if (typeof exportCondition[subpath] === 'object') {
-                const defaultPath = exportCondition[subpath].default;
-                if (defaultPath) {
-                    const nestedExportCondition = {
-                        [exportType]: defaultPath
-                    };
-                    findExport(exportPath, nestedExportCondition, paths, packageType, currentPath);
-                }
-                // Find special export type, such as import: { development: './dev.js', production: './prod.js' }
-                const conditionSpecialTypes = Object.keys(exportCondition[exportType]).filter((key)=>suffixedExportConventions.has(key));
-                if (conditionSpecialTypes.length > 0) {
-                    for (const conditionSpecialType of conditionSpecialTypes){
-                        const nestedExportConditionPath = {
-                            [exportType]: exportCondition[exportType][conditionSpecialType]
-                        };
-                        findExport(conditionSpecialType, nestedExportConditionPath, paths, packageType, currentPath);
-                    }
-                }
-            }
-            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);
+    const exportKeys = Object.keys(exportValue);
+    for (const exportKey of exportKeys){
+        // Clone the set to avoid modifying the parent set
+        const childExports = new Set(exportTypes);
+        // Normalize child export value to a map
+        const childExportValue = exportValue[exportKey];
+        // Visit export path: ./subpath, ./subpath2, ...
+        if (exportKey.startsWith('.')) {
+            const childPath = joinRelativePath(currentPath, exportKey);
+            collectExportPath(childExportValue, exportKey, childPath, childExports, exportToDist);
         } else {
-            Object.keys(exportsCondition).forEach((key)=>{
-                const exportCondition = exportsCondition[key];
-                findExport(key, exportCondition, paths, packageType, initialPath);
-            });
+            // Visit export type: import, require, ...
+            childExports.add(exportKey);
+            collectExportPath(childExportValue, exportKey, currentPath, childExports, exportToDist);
         }
     }
-    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"
- *   }
- * }
- *
- * ```
+ * parseExports - parse package.exports field and other fields like main,module to a map
  *
- * 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
-        };
+ * map from export path to output path and export conditions
+ */ function parseExports(pkg) {
+    var _pkg_exports;
+    const exportsField = (_pkg_exports = pkg.exports) != null ? _pkg_exports : {};
+    var _pkg_bin;
+    const bins = (_pkg_bin = pkg.bin) != null ? _pkg_bin : {};
+    const exportToDist = new Map();
+    const isEsmPkg = isESModulePackage(pkg.type);
+    const defaultCondition = isEsmPkg ? 'import' : 'require';
+    let currentPath = '.';
+    if (typeof exportsField === 'string') {
+        const outputConditionPair = [
+            exportsField,
+            defaultCondition
+        ];
+        exportToDist.set(currentPath, [
+            outputConditionPair
+        ]);
+    } else {
+        // keys means unknown if they're relative path or export type
+        const exportConditionKeys = Object.keys(exportsField);
+        for (const exportKey of exportConditionKeys){
+            const exportValue = exportsField[exportKey];
+            const exportTypes = new Set();
+            const isExportPath = exportKey.startsWith('.');
+            const childPath = isExportPath ? joinRelativePath(currentPath, exportKey) : currentPath;
+            if (!isExportPath) {
+                exportTypes.add(exportKey);
+            }
+            collectExportPath(exportValue, exportKey, childPath, exportTypes, exportToDist);
+        }
     }
-    const defaultMainExport = constructFullExportCondition({
-        ...mainExportCondition,
-        module: pkg.module,
-        types: getPackageTypings(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
-        };
+    if (typeof bins === 'string') {
+        const outputConditionPair = [
+            bins,
+            defaultCondition
+        ];
+        exportToDist.set(BINARY_TAG, [
+            outputConditionPair
+        ]);
+    } else {
+        for (const binName of Object.keys(bins)){
+            const binDistPath = bins[binName];
+            const exportType = getExportTypeFromFile(binDistPath, pkg.type);
+            const exportPath = path.posix.join(BINARY_TAG, binName);
+            const outputConditionPair = [
+                binDistPath,
+                exportType
+            ];
+            exportToDist.set(exportPath, [
+                outputConditionPair
+            ]);
+        }
     }
-    return pathsMap;
-}
-function getPackageType(pkg) {
-    return pkg.type || 'commonjs';
-}
-function isESModulePackage(packageType) {
-    return packageType === 'module';
+    // Handle package.json global exports fields
+    if (pkg.main || pkg.module || pkg.types) {
+        const mainExportPath = pkg.main;
+        const moduleExportPath = pkg.module;
+        const typesEntryPath = pkg.types;
+        const existingExportInfo = exportToDist.get('.');
+        exportToDist.set('.', [
+            ...existingExportInfo || [],
+            Boolean(mainExportPath) && [
+                mainExportPath,
+                getMainFieldExportType(pkg)
+            ],
+            Boolean(moduleExportPath) && [
+                moduleExportPath,
+                'import'
+            ],
+            Boolean(typesEntryPath) && [
+                typesEntryPath,
+                'types'
+            ]
+        ].filter(Boolean));
+    }
+    return exportToDist;
 }
 function getExportTypeFromFile(filename, pkgType) {
     const isESModule = isESModulePackage(pkgType);
@@ -420,7 +318,7 @@ function getExportTypeFromFile(filename, pkgType) {
 function lint$1(pkg) {
     const { name, main, exports } = pkg;
     const isESM = isESModulePackage(pkg.type);
-    const exportPaths = getExportPaths(pkg);
+    const parsedExports = parseExports(pkg);
     if (!name) {
         logger.warn('Missing package name');
     }
@@ -456,16 +354,17 @@ function lint$1(pkg) {
             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;
+                parsedExports.forEach((outputPairs)=>{
+                    for (const [outputPath, composedExportType] of outputPairs){
+                        const exportTypes = new Set(composedExportType.split('.'));
+                        let requirePath = '';
+                        let importPath = '';
+                        if (exportTypes.has('require')) {
+                            requirePath = outputPath;
+                        }
+                        if (exportTypes.has('import')) {
+                            importPath = outputPath;
+                        }
                         const requireExt = requirePath && path__default.default.extname(requirePath);
                         const importExt = importPath && path__default.default.extname(importPath);
                         if (requireExt === '.mjs' || requireExt === '.js') {
@@ -494,16 +393,17 @@ function lint$1(pkg) {
             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;
+                parsedExports.forEach((outputPairs)=>{
+                    for (const [outputPath, composedExportType] of outputPairs){
+                        const exportTypes = new Set(composedExportType.split('.'));
+                        let requirePath = '';
+                        let importPath = '';
+                        if (exportTypes.has('require')) {
+                            requirePath = outputPath;
+                        }
+                        if (exportTypes.has('import')) {
+                            importPath = outputPath;
+                        }
                         const requireExt = requirePath && path__default.default.extname(requirePath);
                         const importExt = importPath && path__default.default.extname(importPath);
                         if (requireExt === '.mjs') {
@@ -558,7 +458,7 @@ function lint$1(pkg) {
     }
 }
 
-var version = "4.4.8";
+var version = "5.0.0-beta.2";
 
 function relativify(path) {
     return path.startsWith('.') ? path : `./${path}`;
@@ -569,41 +469,73 @@ async function writeDefaultTsconfig(tsConfigPath) {
     logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
 }
 
-// Output with posix style in package.json
-function getDistPath(...subPaths) {
-    return `./${DIST}/${subPaths.join('/')}`;
+// shared.ts -> ./shared
+// shared.<export condition>.ts -> ./shared
+// index.ts -> ./index
+// index.development.ts -> ./index.development
+function sourceFilenameToExportPath(filename) {
+    const baseName = baseNameWithoutExtension(filename);
+    let exportPath = baseName;
+    return relativify(exportPath);
 }
-const normalizeBaseNameToExportName = (baseName)=>{
-    return /^index(\.|$)/.test(baseName) ? '.' : relativify(baseName);
-};
-function createExportCondition(exportName, sourceFile, moduleType) {
-    const isTsSourceFile = isTypescriptFile(sourceFile);
-    let cjsExtension = 'js';
-    let esmExtension = 'mjs';
-    if (moduleType === 'module') {
-        cjsExtension = 'cjs';
-        esmExtension = 'js';
+// ./index -> import|require|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);
+}
+function getSpecialExportTypeFromExportPath(composedExportType) {
+    const exportTypes = composedExportType.split('.');
+    for (const exportType of exportTypes){
+        if (specialExportConventions.has(exportType)) {
+            return exportType;
+        }
     }
-    if (isTsSourceFile) {
-        return {
-            import: {
-                types: getDistPath('es', `${exportName}.${dtsExtensionsMap[esmExtension]}`),
-                default: getDistPath('es', `${exportName}.${esmExtension}`)
-            },
-            require: {
-                types: getDistPath('cjs', `${exportName}.${dtsExtensionsMap[cjsExtension]}`),
-                default: getDistPath('cjs', `${exportName}.${cjsExtension}`)
-            }
-        };
+    return 'default';
+}
+function getExportTypeFromExportTypes(types) {
+    let exportType = 'default';
+    new Set(types).forEach((value)=>{
+        if (specialExportConventions.has(value)) {
+            exportType = value;
+        } else if (value === 'import' || value === 'require' || value === 'types') {
+            exportType = value;
+        }
+    });
+    return exportType;
+}
+// ./index -> .
+// ./index.development -> .
+// ./index.react-server -> .
+// ./shared -> ./shared
+// ./shared.development -> ./shared
+// $binary -> $binary
+// $binary/index -> $binary
+// $binary/foo -> $binary/foo
+function normalizeExportPath(exportPath) {
+    if (exportPath.startsWith(BINARY_TAG)) {
+        if (exportPath === `${BINARY_TAG}/index`) {
+            exportPath = BINARY_TAG;
+        }
+        return exportPath;
     }
-    return {
-        import: getDistPath(`${exportName}.mjs`),
-        require: getDistPath(`${exportName}.${cjsExtension}`)
-    };
+    const baseName = exportPath.split('.').slice(0, 2).join('.');
+    if (baseName === './index') {
+        return '.';
+    }
+    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
     });
@@ -616,18 +548,35 @@ async function collectSourceEntries(sourceFolderPath) {
                 for (const binDirent of binDirentList){
                     if (binDirent.isFile()) {
                         const binFileAbsolutePath = path__default.default.join(sourceFolderPath, dirent.name, binDirent.name);
-                        const binName = baseNameWithoutExtension(binDirent.name);
+                        const binExportPath = sourceFilenameToExportPath(binDirent.name);
                         if (fs__default.default.existsSync(binFileAbsolutePath)) {
-                            bins.set(binName, binDirent.name);
+                            bins.set(path.posix.join(BINARY_TAG, binExportPath), binFileAbsolutePath);
                         }
                     }
                 }
             } else {
-                // Search folder/<index>.<ext> convention entries
+                // 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) && !isTestFile(indexFile)) {
-                        exportsEntries.set(dirent.name, indexFile);
+                    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;
                     }
                 }
@@ -635,13 +584,17 @@ async function collectSourceEntries(sourceFolderPath) {
         } else if (dirent.isFile()) {
             const isAvailableExtension = availableExtensions.has(path__default.default.extname(dirent.name).slice(1));
             if (isAvailableExtension) {
-                const baseName = baseNameWithoutExtension(dirent.name);
-                const isBinFile = baseName === 'bin';
+                const exportPath = sourceFilenameToExportPath(dirent.name);
+                const isBinFile = exportPath === './bin';
+                const fullPath = path__default.default.join(sourceFolderPath, dirent.name);
                 if (isBinFile) {
-                    bins.set('.', dirent.name);
+                    bins.set(BINARY_TAG, fullPath);
                 } else {
                     if (hasAvailableExtension(dirent.name) && !isTestFile(dirent.name)) {
-                        exportsEntries.set(baseName, dirent.name);
+                        const sourceFilesMap = exportsEntries.get(exportPath) || {};
+                        const exportType = getExportTypeFromExportPath(exportPath);
+                        sourceFilesMap[exportType] = fullPath;
+                        exportsEntries.set(exportPath, sourceFilesMap);
                     }
                 }
             }
@@ -652,25 +605,68 @@ async function collectSourceEntries(sourceFolderPath) {
         exportsEntries
     };
 }
+
+// Output with posix style in package.json
+function getDistPath(...subPaths) {
+    return relativify(path.posix.join(DIST, ...subPaths));
+}
+function stripeBinaryTag(exportName) {
+    // Add \ to decode leading $
+    return exportName.replace(/\$binary\//, '');
+}
+const normalizeBaseNameToExportName = (name)=>{
+    const baseName = stripeBinaryTag(name);
+    return /^\.\/index(\.|$)/.test(baseName) ? '.' : relativify(baseName);
+};
+function createExportCondition(exportName, sourceFile, moduleType) {
+    const isTsSourceFile = isTypescriptFile(sourceFile);
+    let cjsExtension = 'js';
+    let esmExtension = 'mjs';
+    if (moduleType === 'module') {
+        cjsExtension = 'cjs';
+        esmExtension = 'js';
+    }
+    if (exportName === '.') {
+        exportName = 'index';
+    }
+    if (isTsSourceFile) {
+        return {
+            import: {
+                types: getDistPath('es', `${exportName}.${dtsExtensionsMap[esmExtension]}`),
+                default: getDistPath('es', `${exportName}.${esmExtension}`)
+            },
+            require: {
+                types: getDistPath('cjs', `${exportName}.${dtsExtensionsMap[cjsExtension]}`),
+                default: getDistPath('cjs', `${exportName}.${cjsExtension}`)
+            }
+        };
+    }
+    return {
+        import: getDistPath(`${exportName}.mjs`),
+        require: getDistPath(`${exportName}.${cjsExtension}`)
+    };
+}
 function createExportConditionPair(exportName, sourceFile, moduleType) {
     // <exportName>.<specialCondition>
     let specialCondition;
-    let exportCondName;
-    if (exportName.indexOf('.') > 0) {
-        const [originExportName, specialConditionName] = exportName.split('.');
+    const specialConditionName = getSpecialExportTypeFromExportPath(exportName);
+    const normalizedExportPath = normalizeExportPath(exportName);
+    if (specialConditionName !== 'default') {
+        // e.g.
+        // ./index.develop -> index
+        // ./foo.react-server -> foo
+        const fileBaseName = exportName.split('.').slice(0, 2).join('.').replace('./', '');
         specialCondition = {
-            [specialConditionName]: getDistPath('es', `${originExportName}-${specialConditionName}.mjs`)
+            [specialConditionName]: getDistPath('es', `${fileBaseName}-${specialConditionName}.mjs`)
         };
-        exportCondName = normalizeBaseNameToExportName(originExportName);
         return [
-            exportCondName,
+            normalizedExportPath,
             specialCondition
         ];
     }
-    exportCondName = normalizeBaseNameToExportName(exportName);
     const exportCond = createExportCondition(exportName, sourceFile, moduleType);
     return [
-        exportCondName,
+        normalizedExportPath,
         exportCond
     ];
 }
@@ -698,12 +694,17 @@ async function prepare(cwd) {
     // Collect bins and exports entries
     const { bins, exportsEntries } = await collectSourceEntries(sourceFolder);
     const tsConfigPath = path__default.default.join(cwd, 'tsconfig.json');
-    const sourceFiles = [
+    const exportsSourceFiles = [
         ...exportsEntries.values()
-    ].concat([
+    ].reduce((acc, sourceFiles)=>{
+        Object.values(sourceFiles).forEach((sourceFile)=>acc.add(sourceFile));
+        return acc;
+    }, new Set());
+    const allSourceFiles = [
+        ...exportsSourceFiles,
         ...bins.values()
-    ]);
-    const hasTypeScriptFiles = sourceFiles.some((filename)=>isTypescriptFile(filename));
+    ].map((absoluteFilePath)=>absoluteFilePath);
+    const hasTypeScriptFiles = allSourceFiles.some((filename)=>isTypescriptFile(filename));
     if (hasTypeScriptFiles) {
         isUsingTs = true;
         if (!fs__default.default.existsSync(tsConfigPath)) {
@@ -719,13 +720,14 @@ async function prepare(cwd) {
         const maxLengthOfBinName = Math.max(...Array.from(bins.keys()).map((binName)=>normalizeBaseNameToExportName(binName).length));
         for (const [binName, binFile] of bins.entries()){
             const spaces = ' '.repeat(Math.max(maxLengthOfBinName - normalizeBaseNameToExportName(binName).length, 0));
-            logger.log(`  ${normalizeBaseNameToExportName(binName)}${spaces}: ${binFile}`);
+            logger.log(`  ${normalizeBaseNameToExportName(binName)}${spaces}: ${path__default.default.basename(binFile)}`);
         }
-        if (bins.size === 1 && bins.has('.')) {
+        if (bins.size === 1 && bins.has(BINARY_TAG)) {
             pkgJson.bin = getDistPath('bin', 'index.js');
         } else {
             pkgJson.bin = {};
-            for (const [binName] of bins.entries()){
+            for (const [binOriginName] of bins.entries()){
+                const binName = stripeBinaryTag(binOriginName);
                 pkgJson.bin[binName === '.' ? pkgJson.name : binName] = getDistPath('bin', binName + '.js');
             }
         }
@@ -733,20 +735,24 @@ async function prepare(cwd) {
     if (exportsEntries.size > 0) {
         logger.log('Discovered exports entries:');
         const maxLengthOfExportName = Math.max(...Array.from(exportsEntries.keys()).map((exportName)=>normalizeBaseNameToExportName(exportName).length));
-        for (const [exportName, exportFile] of exportsEntries.entries()){
+        for (const [exportName, sourceFilesMap] of exportsEntries.entries()){
             const spaces = ' '.repeat(Math.max(maxLengthOfExportName - normalizeBaseNameToExportName(exportName).length, 0));
-            logger.log(`  ${normalizeBaseNameToExportName(exportName)}${spaces}: ${exportFile}`);
+            for (const exportFile of Object.values(sourceFilesMap)){
+                logger.log(`  ${normalizeBaseNameToExportName(exportName)}${spaces}: ${path__default.default.basename(exportFile)}`);
+            }
         }
         const pkgExports = {};
-        for (const [exportName, sourceFile] of exportsEntries.entries()){
-            const [key, value] = createExportConditionPair(exportName, sourceFile, pkgJson.type);
-            pkgExports[key] = {
-                ...value,
-                ...pkgExports[key]
-            };
+        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]
+                };
+            }
         }
         // Configure node10 module resolution
-        if (exportsEntries.has('index')) {
+        if (exportsEntries.has('./index')) {
             const isESM = pkgJson.type === 'module';
             const mainExport = pkgExports['.'];
             const mainCondition = isESM ? 'import' : 'require';
@@ -793,7 +799,8 @@ Options:
   --env <env>            inlined process env variables, separate by comma. default: NODE_ENV
   --cwd <cwd>            specify current working directory
   --sourcemap            enable sourcemap generation, default: false
-  --dts                  determine if need to generate types, default: false
+  --dts                  determine if need to generate types, default: undefined
+  --no-dts               do not generate types, default: undefined
 `;
 function help() {
     logger.log(helpMessage);
@@ -810,6 +817,7 @@ function parseCliArgs(argv) {
     args = arg__default.default({
         '--cwd': String,
         '--dts': Boolean,
+        '--no-dts': Boolean,
         '--output': String,
         '--format': String,
         '--watch': Boolean,
@@ -843,7 +851,7 @@ function parseCliArgs(argv) {
         minify: args['--minify'],
         sourcemap: !!args['--sourcemap'],
         cwd: args['--cwd'],
-        dts: args['--dts'],
+        dts: args['--no-dts'] ? false : args['--dts'],
         help: args['--help'],
         version: args['--version'],
         runtime: args['--runtime'],
@@ -861,7 +869,7 @@ async function run(args) {
     const cwd = args.cwd || process.cwd();
     const file = args.file ? path__default.default.resolve(cwd, args.file) : undefined;
     const bundleConfig = {
-        dts,
+        dts: typeof dts === 'boolean' ? dts : undefined,
         file,
         format,
         cwd,