bunchee 3.3.4 → 3.4.0

package/dist/cli.js

@@ -76,7 +76,7 @@ const logger = {
         console.log('\x1b[33m' + arg + '\x1b[0m');
     },
     error (arg) {
-        console.error('\x1b[31m' + arg + '\x1b[0m');
+        console.error('\x1b[31m' + (arg instanceof Error ? arg.stack : arg) + '\x1b[0m');
     }
 };
 function fileExists(filePath) {
@@ -97,7 +97,7 @@ function _fileExists() {
     return _fileExists.apply(this, arguments);
 }
 
-var version = "3.3.4";
+var version = "3.4.0";
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {

package/dist/index.js

@@ -118,7 +118,7 @@ const logger = {
         console.log('\x1b[33m' + arg + '\x1b[0m');
     },
     error (arg) {
-        console.error('\x1b[31m' + arg + '\x1b[0m');
+        console.error('\x1b[31m' + (arg instanceof Error ? arg.stack : arg) + '\x1b[0m');
     }
 };
 function fileExists(filePath) {
@@ -151,30 +151,55 @@ const SRC = 'src' // resolve from src/ directory
 function resolveSourceFile(cwd, filename) {
     return path__default.default.resolve(cwd, SRC, filename);
 }
+function findSourceEntryFile(cwd, exportPath, exportTypeSuffix, ext) {
+    return _findSourceEntryFile.apply(this, arguments);
+}
+function _findSourceEntryFile() {
+    _findSourceEntryFile = _async_to_generator$3(function*(cwd, exportPath, exportTypeSuffix, ext) {
+        const filename = resolveSourceFile(cwd, `${exportPath}${exportTypeSuffix ? `.${exportTypeSuffix}` : ''}.${ext}`);
+        if (yield fileExists(filename)) {
+            return filename;
+        }
+        const subFolderIndexFilename = resolveSourceFile(cwd, `${exportPath}/index${exportTypeSuffix ? `.${exportTypeSuffix}` : ''}.${ext}`);
+        if (yield fileExists(subFolderIndexFilename)) {
+            return subFolderIndexFilename;
+        }
+        return undefined;
+    });
+    return _findSourceEntryFile.apply(this, arguments);
+}
 // Map '.' -> './index.[ext]'
 // Map './lite' -> './lite.[ext]'
 // Return undefined if no match or if it's package.json exports
-function getSourcePathFromExportPath(cwd, exportPath) {
+const availableExtensions = [
+    'js',
+    'cjs',
+    'mjs',
+    'jsx',
+    'ts',
+    'tsx'
+];
+const availableExportConventions = [
+    'react-server',
+    'react-native',
+    'edge-light'
+];
+function getSourcePathFromExportPath(cwd, exportPath, exportType) {
     return _getSourcePathFromExportPath.apply(this, arguments);
 }
 function _getSourcePathFromExportPath() {
-    _getSourcePathFromExportPath = _async_to_generator$3(function*(cwd, exportPath) {
-        const exts = [
-            'js',
-            'cjs',
-            'mjs',
-            'jsx',
-            'ts',
-            'tsx'
-        ];
-        for (const ext of exts){
+    _getSourcePathFromExportPath = _async_to_generator$3(function*(cwd, exportPath, exportType) {
+        for (const ext of availableExtensions){
             // ignore package.json
             if (exportPath.endsWith('package.json')) return;
             if (exportPath === '.') exportPath = './index';
-            const filename = resolveSourceFile(cwd, `${exportPath}.${ext}`);
-            if (yield fileExists(filename)) {
-                return filename;
+            // Find convention-based source file for specific export types
+            if (availableExportConventions.includes(exportType)) {
+                const filename = yield findSourceEntryFile(cwd, exportPath, exportType, ext);
+                if (filename) return filename;
             }
+            const filename = yield findSourceEntryFile(cwd, exportPath, null, ext);
+            if (filename) return filename;
         }
         return;
     });
@@ -184,6 +209,7 @@ function _getSourcePathFromExportPath() {
 function filenameWithoutExtension(file) {
     return file ? file.replace(new RegExp(`${path__default.default.extname(file)}$`), '') : undefined;
 }
+const nonNullable = (n)=>Boolean(n);
 
 function getTypings(pkg) {
     return pkg.types || pkg.typings;
@@ -350,22 +376,19 @@ function constructDefaultExportCondition(value, packageType) {
     } : value;
     return constructFullExportCondition(objValue, packageType);
 }
-function isEsmExportName(name) {
+function isEsmExportName(name, ext) {
     return [
         'import',
-        'module',
-        'react-native',
-        'react-server',
-        'edge-light'
-    ].includes(name);
+        'module'
+    ].includes(name) || ext === 'mjs';
 }
-function isCjsExportName(name) {
+function isCjsExportName(name, ext) {
     return [
         'require',
         'main',
         'node',
         'default'
-    ].includes(name);
+    ].includes(name) || ext === 'cjs';
 }
 function getExportConditionDist(pkg, parsedExportCondition, cwd) {
     const dist = [];
@@ -375,12 +398,14 @@ function getExportConditionDist(pkg, parsedExportCondition, cwd) {
         if (key === 'types') {
             continue;
         }
+        const filePath = parsedExportCondition.export[key];
+        const ext = path.extname(filePath).slice(1);
         const relativePath = parsedExportCondition.export[key];
         const distFile = getDistPath(relativePath, cwd);
         let format = 'esm';
-        if (isEsmExportName(key)) {
+        if (isEsmExportName(key, ext)) {
             format = 'esm';
-        } else if (isCjsExportName(key)) {
+        } else if (isCjsExportName(key, ext)) {
             format = 'cjs';
         }
         // Deduplicate the same path jobs
@@ -592,8 +617,8 @@ function hasEsmExport(exportPaths, tsCompilerOptions) {
     let hasEsm = false;
     for(const key in exportPaths){
         const exportInfo = exportPaths[key];
-        const exportNames = Object.keys(exportInfo);
-        if (exportNames.some((name)=>isEsmExportName(name))) {
+        const exportInfoEntries = Object.entries(exportInfo);
+        if (exportInfoEntries.some(([exportType, file])=>isEsmExportName(exportType, file))) {
             hasEsm = true;
             break;
         }
@@ -636,22 +661,56 @@ function buildEntryConfig(pkg, entryPath, exportPaths, bundleConfig, cwd, tsOpti
 }
 function _buildEntryConfig() {
     _buildEntryConfig = _async_to_generator$2(function*(pkg, entryPath, exportPaths, bundleConfig, cwd, tsOptions, dts) {
-        const configs = Object.keys(exportPaths).map(/*#__PURE__*/ _async_to_generator$2(function*(entryExport) {
+        const configs = [];
+        Object.keys(exportPaths).forEach(/*#__PURE__*/ _async_to_generator$2(function*(entryExport) {
             // TODO: improve the source detection
-            const source = entryPath || (yield getSourcePathFromExportPath(cwd, entryExport));
-            if (!source) return undefined;
-            // For dts, only build types filed
-            if (dts && !exportPaths[entryExport]['types']) return undefined;
-            const exportCondition = {
-                source,
-                name: entryExport,
-                export: exportPaths[entryExport]
-            };
-            const entry = resolveSourceFile(cwd, source);
-            const rollupConfig = buildConfig(entry, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, dts);
-            return rollupConfig;
+            const exportCond = exportPaths[entryExport];
+            const hasEdgeLight = !!exportCond['edge-light'];
+            const hasReactServer = !!exportCond['react-server'];
+            const buildConfigs = [
+                createBuildConfig('', exportCond) // default config
+            ];
+            if (hasEdgeLight) {
+                buildConfigs.push(createBuildConfig('edge-light', exportCond));
+            }
+            if (hasReactServer) {
+                buildConfigs.push(createBuildConfig('react-server', exportCond));
+            }
+            function createBuildConfig(exportType, exportCondRef) {
+                return _createBuildConfig.apply(this, arguments);
+            }
+            function _createBuildConfig() {
+                _createBuildConfig = _async_to_generator$2(function*(exportType, exportCondRef) {
+                    let exportCondForType = _extends$1({}, exportCondRef);
+                    // Special cases of export type, only pass down the exportPaths for the type
+                    if (availableExportConventions.includes(exportType)) {
+                        exportCondForType = {
+                            [entryExport]: exportCondRef[exportType]
+                        };
+                    // Basic export type, pass down the exportPaths with erasing the special ones
+                    } else {
+                        for (const exportType of availableExportConventions){
+                            delete exportCondForType[exportType];
+                        }
+                    }
+                    const source = entryPath || (yield getSourcePathFromExportPath(cwd, entryExport, exportType));
+                    if (!source) return undefined;
+                    // For dts, only build types filed
+                    if (dts && !exportCondRef['types']) return undefined;
+                    const exportCondition = {
+                        source,
+                        name: entryExport,
+                        export: exportCondForType
+                    };
+                    const entry = resolveSourceFile(cwd, source);
+                    const rollupConfig = buildConfig(entry, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, dts);
+                    return rollupConfig;
+                });
+                return _createBuildConfig.apply(this, arguments);
+            }
+            configs.push(...buildConfigs);
         }));
-        return (yield Promise.all(configs)).filter((n)=>Boolean(n));
+        return (yield Promise.all(configs)).filter(nonNullable);
     });
     return _buildEntryConfig.apply(this, arguments);
 }
@@ -876,7 +935,7 @@ function _bundle() {
         if (!isMultiEntries) {
             // Use specified string file path if possible, then fallback to the default behavior entry picking logic
             // e.g. "exports": "./dist/index.js" -> use "./index.<ext>" as entry
-            entryPath = entryPath || (yield getSourcePathFromExportPath(cwd, '.')) || '';
+            entryPath = entryPath || (yield getSourcePathFromExportPath(cwd, '.', 'default')) || '';
         }
         if (entryPath) {
             let mainEntryPath;

package/package.json

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