bunchee 3.3.4 → 3.4.1

package/README.md

@@ -61,7 +61,10 @@ Using pure ESM package?
 }
 ```
 
-Then just run `npm run build`, or `pnpm build` / `yarn build` if you're using these package managers.
+Then just run `npm run build`, or `pnpm build` / `yarn build` if you're using these package managers. The output format will based on the exports condition and also the file extension. Given an example:
+
+* It's CommonJS for `require` and ESM for `import` based on the exports condition.
+* It's CommonJS for `.js` and ESM for `.mjs` based on the extension regardless the exports condition. Then for export condition like "node" you could choose the format with your extension.
 
 ## Configuration
 
@@ -121,7 +124,6 @@ bunchee --env=ENV1,ENV2,ENV3
 
 Replace `ENV1`, `ENV2`, and `ENV3` with the names of the environment variables you want to include in your bundled code. These environment variables will be inlined during the bundling process.
 
-
 ### Entry Files Convention
 
 While `exports` field is becoming the standard of exporting in node.js, bunchee also supports to build multiple exports all in one command.
@@ -161,6 +163,35 @@ Then you need to add two entry files `index.ts` and `lite.ts` in project root di
   |- package.json
 ```
 
+It will also look up for `index.<ext>` file under the directory having the name of the export path. For example, if you have `"./lite": "./dist/lite.js"` in exports field, then it will look up for `./lite/index.js` as the entry file as well.
+
+### Special Exports Conventions
+
+For exports condition like `react-native`, `react-server` and `edge-light` as they're special platforms, they could have different exports or different code conditions. In this case bunchee provides an override input source file convention if you want to build them as different code bundle.
+
+For instance:
+
+```json
+{
+  "exports": {
+    "react-server": "./dist/react-server.mjs",
+    "edge-light": "./dist/edge-light.mjs",
+    "import": "./dist/index.mjs"
+  }
+}
+```
+
+You can use `index.<export-type>.<ext>` to override the input source file for specific export name. Or using `<export-path>/index.<export-type>.<ext>` also works. Such as:
+
+```
+|- src/
+  |- index/.ts
+  |- index.react-server.ts
+  |- index.edge-light.ts
+```
+
+This will match the export name `"react-server"` and `"edge-light"` then use the corresponding input source file to build the bundle.
+
 #### Package lint
 
 `bunchee` has support for checking the package bundles are matched with package exports configuration.

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.1";
 
 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,61 @@ 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 buildConfigs = [
+                createBuildConfig('', exportCond) // default config
+            ];
+            // For dts job, only build the default config.
+            // For assets job, build all configs.
+            if (!dts) {
+                if (exportCond['edge-light']) {
+                    buildConfigs.push(createBuildConfig('edge-light', exportCond));
+                }
+                if (exportCond['react-server']) {
+                    buildConfigs.push(createBuildConfig('react-server', exportCond));
+                }
+                if (exportCond['react-native']) {
+                    buildConfigs.push(createBuildConfig('react-native', 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 +940,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.1",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": {
     "bunchee": "./dist/cli.js"