bunchee 3.2.1 → 3.3.1

package/dist/cli.js

@@ -97,7 +97,7 @@ function _fileExists() {
     return _fileExists.apply(this, arguments);
 }
 
-var version = "3.2.1";
+var version = "3.3.1";
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 import { JscTarget } from '@swc/core';
 import { OutputOptions } from 'rollup';
 
-type ExportType = 'require' | 'export' | 'default' | string;
 type BundleConfig = {
     file?: string;
     cwd?: string;
@@ -15,13 +14,7 @@ type BundleConfig = {
     env?: string[];
     dts?: boolean;
     runtime?: string;
-    exportCondition?: {
-        source: string;
-        name: string;
-        export: ExportCondition;
-    };
 };
-type ExportCondition = string | Record<ExportType, string>;
 
 declare function bundle(entryPath: string, { cwd: _cwd, ...options }?: BundleConfig): Promise<any>;
 

package/dist/index.js

@@ -39,7 +39,8 @@ function chunkSizeCollector() {
                     const dir = options.dir || options.file && path__default.default.dirname(options.file);
                     let fileName = chunk.fileName;
                     if (dir) {
-                        fileName = path__default.default.relative(cwd, path__default.default.join(dir, fileName));
+                        const filePath = path__default.default.join(dir, fileName);
+                        fileName = filePath.startsWith(cwd) ? path__default.default.relative(cwd, filePath) : filePath;
                     }
                     addSize(fileName, code.length);
                     return null;
@@ -66,20 +67,87 @@ function getTypings(pkg) {
 function getDistPath(distPath, cwd) {
     return path.resolve(cwd, distPath);
 }
-function findExport(field) {
-    if (!field) return;
-    if (typeof field === 'string') return field;
-    const value = field['.'] || field['import'] || field['module'] || field['default'];
-    return findExport(value);
+// 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 '.'
+    // TODO: check key is ExportType
+    ([key, value])=>typeof value === 'string' && !key.startsWith('.'));
+}
+function constructFullExportCondition(value, packageType) {
+    const isCommonjs = packageType === 'commonjs';
+    let result;
+    if (typeof value === 'string') {
+        result = {
+            [isCommonjs ? 'require' : 'import']: value
+        };
+    } else {
+        // TODO: valid export condition, warn if it's not valid
+        const keys = Object.keys(value);
+        result = {};
+        keys.forEach((key)=>{
+            // Filter out nullable value
+            if (key in value && value[key]) {
+                result[key] = value[key];
+            }
+        });
+    }
+    return result;
+}
+function joinRelativePath(...segments) {
+    let result = path.join(...segments);
+    // If the first segment starts with './', ensure the result does too.
+    if (segments[0] === '.' && !result.startsWith('./')) {
+        result = './' + result;
+    }
+    return result;
 }
-function parseExport(exportsCondition) {
+function findExport(name, value, paths, packageType) {
+    // TODO: handle export condition based on package.type
+    if (isExportLike(value)) {
+        paths[name] = constructFullExportCondition(value, packageType);
+        return;
+    }
+    Object.keys(value).forEach((subpath)=>{
+        const nextName = joinRelativePath(name, subpath);
+        const nestedValue = value[subpath];
+        findExport(nextName, nestedValue, paths, packageType);
+    });
+}
+/**
+ *
+ * Convert package.exports field to paths mapping
+ * Example
+ *
+ * Input:
+ * {
+ *   ".": {
+ *     "sub": {
+ *       "import": "./sub.js",
+ *       "require": "./sub.cjs",
+ *       "types": "./sub.d.ts
+ *     }
+ *   }
+ * }
+ *
+ * Output:
+  * {
+  *   "./sub": {
+  *     "import": "./sub.js",
+  *     "require": "./sub.cjs",
+  *     "types": "./sub.d.ts,
+  *   }
+  * }
+  *
+ */ function parseExport(exportsCondition, packageType) {
     const paths = {};
     if (typeof exportsCondition === 'string') {
-        paths.export = exportsCondition;
-    } else {
-        paths.main = paths.main || exportsCondition['require'] || exportsCondition['node'] || exportsCondition['default'];
-        paths.module = paths.module || exportsCondition['module'];
-        paths.export = findExport(exportsCondition);
+        paths['.'] = constructFullExportCondition(exportsCondition, packageType);
+    } else if (typeof exportsCondition === 'object') {
+        Object.keys(exportsCondition).forEach((key)=>{
+            const value = exportsCondition[key];
+            findExport(key, value, paths, packageType);
+        });
     }
     return paths;
 }
@@ -124,55 +192,83 @@ function parseExport(exportsCondition) {
  * pkg.main and pkg.module will be added to ['.'] if exists
  */ function getExportPaths(pkg) {
     const pathsMap = {};
-    const mainExport = {};
-    if (pkg.main) {
-        mainExport.main = pkg.main;
-    }
-    if (pkg.module) {
-        mainExport.module = pkg.module;
-    }
-    pathsMap['.'] = mainExport;
+    const packageType = getPackageType(pkg);
     const { exports: exportsConditions  } = pkg;
     if (exportsConditions) {
-        if (typeof exportsConditions === 'string') {
-            mainExport.export = exportsConditions;
-        } else {
-            const exportKeys = Object.keys(exportsConditions);
-            if (exportKeys.some((key)=>key.startsWith('.'))) {
-                exportKeys.forEach((subExport)=>{
-                    pathsMap[subExport] = parseExport(exportsConditions[subExport]);
-                });
-            } else {
-                Object.assign(mainExport, parseExport(exportsConditions));
-            }
-        }
+        const paths = parseExport(exportsConditions, packageType);
+        Object.assign(pathsMap, paths);
+    }
+    // main export '.' from main/module/typings
+    const defaultMainExport = constructFullExportCondition({
+        [packageType === 'commonjs' ? 'require' : 'import']: pkg.main,
+        module: pkg.module,
+        types: getTypings(pkg)
+    }, packageType);
+    // Merge the main export into '.' paths
+    const mainExport = Object.assign({}, pathsMap['.'], defaultMainExport);
+    // main export is not empty
+    if (Object.keys(mainExport).length > 0) {
+        pathsMap['.'] = mainExport;
     }
-    pathsMap['.'] = mainExport;
     return pathsMap;
 }
-function getExportDist(pkg, cwd) {
-    const paths = getExportPaths(pkg)['.'];
+function getPackageType(pkg) {
+    return pkg.type || 'commonjs';
+}
+function constructDefaultExportCondition(value, packageType) {
+    const objValue = typeof value === 'string' ? {
+        [packageType === 'commonjs' ? 'require' : 'import']: value,
+        types: getTypings(value)
+    } : value;
+    return constructFullExportCondition(objValue, packageType);
+}
+function isEsmExportName(name) {
+    return [
+        'import',
+        'module',
+        'react-native',
+        'react-server',
+        'edge-light'
+    ].includes(name);
+}
+function isCjsExportName(name) {
+    return [
+        'require',
+        'main',
+        'node',
+        'default'
+    ].includes(name);
+}
+function getExportConditionDist(pkg, parsedExportCondition, cwd) {
     const dist = [];
-    if (paths.main) {
-        dist.push({
-            format: 'cjs',
-            file: getDistPath(paths.main, cwd)
-        });
-    }
-    if (paths.module) {
-        dist.push({
-            format: 'esm',
-            file: getDistPath(paths.module, cwd)
-        });
-    }
-    if (paths.export) {
+    const existed = new Set();
+    const exportTypes = Object.keys(parsedExportCondition.export);
+    for (const key of exportTypes){
+        if (key === 'types') {
+            continue;
+        }
+        const relativePath = parsedExportCondition.export[key];
+        const distFile = getDistPath(relativePath, cwd);
+        let format = 'esm';
+        if (isEsmExportName(key)) {
+            format = 'esm';
+        } else if (isCjsExportName(key)) {
+            format = 'cjs';
+        }
+        // Deduplicate the same path jobs
+        // TODO: detect conflicts paths but with different format
+        if (existed.has(distFile)) {
+            continue;
+        }
+        existed.add(distFile);
         dist.push({
-            format: 'esm',
-            file: getDistPath(paths.export, cwd)
+            format,
+            file: distFile
         });
     }
-    // default fallback to output `dist/index.js` in default esm format
     if (dist.length === 0) {
+        // TODO: Deprecate this warning and behavior in v3
+        console.error(`Doesn't fin any exports in ${pkg.name}, using default dist path dist/index.js`);
         dist.push({
             format: 'esm',
             file: getDistPath('dist/index.js', cwd)
@@ -180,40 +276,6 @@ function getExportDist(pkg, cwd) {
     }
     return dist;
 }
-function getExportConditionDist(pkg, exportCondition, cwd) {
-    const dist = [];
-    // "exports": "..."
-    if (typeof exportCondition === 'string') {
-        dist.push({
-            format: pkg.type === 'module' ? 'esm' : 'cjs',
-            file: getDistPath(exportCondition, cwd)
-        });
-    } else {
-        // "./<subexport>": { }
-        const subExports = exportCondition;
-        // Ignore json exports, like "./package.json"
-        if (typeof subExports === 'string') {
-            dist.push({
-                format: 'esm',
-                file: getDistPath(subExports, cwd)
-            });
-        } else {
-            if (subExports.require) {
-                dist.push({
-                    format: 'cjs',
-                    file: getDistPath(subExports.require, cwd)
-                });
-            }
-            if (subExports.import) {
-                dist.push({
-                    format: 'esm',
-                    file: getDistPath(subExports.import, cwd)
-                });
-            }
-        }
-    }
-    return dist;
-}
 
 function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -516,16 +578,16 @@ function hasEsmExport(exportPaths, tsCompilerOptions) {
     let hasEsm = false;
     for(const key in exportPaths){
         const exportInfo = exportPaths[key];
-        if (exportInfo.import || exportInfo.module) {
+        const exportNames = Object.keys(exportInfo);
+        if (exportNames.some((name)=>isEsmExportName(name))) {
             hasEsm = true;
             break;
         }
     }
     return Boolean(hasEsm || (tsCompilerOptions == null ? void 0 : tsCompilerOptions.esModuleInterop));
 }
-function buildOutputConfigs(pkg, options, cwd, { tsCompilerOptions  }, dtsOnly) {
-    const { format , exportCondition  } = options;
-    const exportPaths = getExportPaths(pkg);
+function buildOutputConfigs(pkg, exportPaths, options, exportCondition, cwd, { tsCompilerOptions  }, dtsOnly) {
+    const { format  } = options;
     // Add esm mark and interop helper if esm export is detected
     const useEsModuleMark = hasEsmExport(exportPaths, tsCompilerOptions);
     const typings = getTypings(pkg);
@@ -533,7 +595,8 @@ function buildOutputConfigs(pkg, options, cwd, { tsCompilerOptions  }, dtsOnly)
     const dtsDir = typings ? path.dirname(path.resolve(cwd, typings)) : path.resolve(cwd, 'dist');
     // file base name without extension
     const name = file ? file.replace(new RegExp(`${path.extname(file)}$`), '') : undefined;
-    const dtsFile = file ? name + '.d.ts' : (exportCondition == null ? void 0 : exportCondition.name) ? path.resolve(dtsDir, (exportCondition.name === '.' ? 'index' : exportCondition.name) + '.d.ts') : typings && path.resolve(cwd, typings);
+    // TODO: simplify dts file name detection
+    const dtsFile = exportCondition.export['types'] ? path.resolve(cwd, exportCondition.export['types']) : file ? name + '.d.ts' : (exportCondition == null ? void 0 : exportCondition.name) ? path.resolve(dtsDir, (exportCondition.name === '.' ? 'index' : exportCondition.name) + '.d.ts') : typings && path.resolve(cwd, typings);
     // If there's dts file, use `output.file`
     const dtsPathConfig = dtsFile ? {
         file: dtsFile
@@ -555,73 +618,71 @@ function buildOutputConfigs(pkg, options, cwd, { tsCompilerOptions  }, dtsOnly)
     });
 }
 // build configs for each entry from package exports
-function buildEntryConfig(pkg, bundleConfig, cwd, tsOptions, dtsOnly) {
+function buildEntryConfig(pkg, entryPath, exportPaths, bundleConfig, cwd, tsOptions, dtsOnly) {
     return _buildEntryConfig.apply(this, arguments);
 }
 function _buildEntryConfig() {
-    _buildEntryConfig = _async_to_generator$2(function*(pkg, bundleConfig, cwd, tsOptions, dtsOnly) {
-        const packageExports = pkg.exports || {};
-        const configs = Object.keys(packageExports).map(/*#__PURE__*/ _async_to_generator$2(function*(entryExport) {
-            const source = yield getSourcePathFromExportPath(cwd, entryExport);
+    _buildEntryConfig = _async_to_generator$2(function*(pkg, entryPath, exportPaths, bundleConfig, cwd, tsOptions, dtsOnly) {
+        const configs = Object.keys(exportPaths).map(/*#__PURE__*/ _async_to_generator$2(function*(entryExport) {
+            // TODO: improve the source detection
+            const source = entryPath || (yield getSourcePathFromExportPath(cwd, entryExport));
             if (!source) return undefined;
-            if (dtsOnly && !(tsOptions == null ? void 0 : tsOptions.tsConfigPath)) return;
-            bundleConfig.exportCondition = {
+            const exportCondition = {
                 source,
                 name: entryExport,
-                export: packageExports[entryExport]
+                export: exportPaths[entryExport]
             };
             const entry = resolveSourceFile(cwd, source);
-            const rollupConfig = buildConfig(entry, pkg, bundleConfig, cwd, tsOptions, dtsOnly);
+            const rollupConfig = buildConfig(entry, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, dtsOnly);
             return rollupConfig;
         }));
         return (yield Promise.all(configs)).filter((n)=>Boolean(n));
     });
     return _buildEntryConfig.apply(this, arguments);
 }
-function buildConfig(entry, pkg, bundleConfig, cwd, tsOptions, dtsOnly) {
-    var _options_exportCondition;
+function buildConfig(entry, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, dtsOnly) {
     const { file  } = bundleConfig;
     const useTypescript = Boolean(tsOptions.tsConfigPath);
     const options = _extends$1({}, bundleConfig, {
         useTypescript
     });
     const inputOptions = buildInputConfig(entry, pkg, options, cwd, tsOptions, dtsOnly);
-    const outputExports = options.exportCondition ? getExportConditionDist(pkg, options.exportCondition.export, cwd) : getExportDist(pkg, cwd);
+    const outputExports = getExportConditionDist(pkg, exportCondition, cwd);
     let outputConfigs = [];
     // Generate dts job - single config
     if (dtsOnly) {
         outputConfigs = [
-            buildOutputConfigs(pkg, _extends$1({}, bundleConfig, {
+            buildOutputConfigs(pkg, exportPaths, _extends$1({}, bundleConfig, {
                 format: 'es',
                 useTypescript
-            }), cwd, tsOptions, dtsOnly)
+            }), exportCondition, cwd, tsOptions, dtsOnly)
         ];
     } else {
         // multi outputs with specified format
         outputConfigs = outputExports.map((exportDist)=>{
-            return buildOutputConfigs(pkg, _extends$1({}, bundleConfig, {
+            return buildOutputConfigs(pkg, exportPaths, _extends$1({}, bundleConfig, {
                 file: exportDist.file,
                 format: exportDist.format,
                 useTypescript
-            }), cwd, tsOptions, dtsOnly);
+            }), exportCondition, cwd, tsOptions, dtsOnly);
         });
         // CLI output option is always prioritized
         if (file) {
             var _outputExports_;
             const fallbackFormat = (_outputExports_ = outputExports[0]) == null ? void 0 : _outputExports_.format;
             outputConfigs = [
-                buildOutputConfigs(pkg, _extends$1({}, bundleConfig, {
+                buildOutputConfigs(pkg, exportPaths, _extends$1({}, bundleConfig, {
                     file,
                     format: bundleConfig.format || fallbackFormat,
                     useTypescript
-                }), cwd, tsOptions, dtsOnly)
+                }), exportCondition, cwd, tsOptions, dtsOnly)
             ];
         }
     }
     return {
         input: inputOptions,
         output: outputConfigs,
-        exportName: ((_options_exportCondition = options.exportCondition) == null ? void 0 : _options_exportCondition.name) || '.'
+        exportName: exportCondition.name || '.'
     };
 }
 
@@ -765,10 +826,8 @@ function assignDefault(options, name, defaultValue) {
         options[name] = defaultValue;
     }
 }
-function hasMultiEntryExport(pkg) {
-    const packageExportsField = pkg.exports || {};
-    if (typeof packageExportsField === 'string') return false;
-    const exportKeys = (packageExportsField ? Object.keys(packageExportsField) : []).filter((key)=>key !== './package.json');
+function hasMultiEntryExport(exportPaths) {
+    const exportKeys = Object.keys(exportPaths).filter((key)=>key !== './package.json');
     return exportKeys.length > 0 && exportKeys.every((name)=>name.startsWith('.'));
 }
 function bundle(entryPath) {
@@ -784,8 +843,12 @@ function _bundle() {
         assignDefault(options, 'minify', false);
         assignDefault(options, 'target', 'es2015');
         const pkg = yield getPackageMeta(cwd);
-        const packageExportsField = pkg.exports || {};
-        const isMultiEntries = hasMultiEntryExport(pkg);
+        const packageType = getPackageType(pkg);
+        const exportPaths = getExportPaths(pkg);
+        const exportKeys = Object.keys(exportPaths).filter((key)=>key !== './package.json');
+        // const exportPathsLength = Object.keys(exportPaths).length
+        const isMultiEntries = hasMultiEntryExport(exportPaths) // exportPathsLength > 1
+        ;
         const tsConfig = yield resolveTsConfig(cwd);
         const hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
         const defaultTsOptions = {
@@ -798,6 +861,14 @@ function _bundle() {
             // e.g. "exports": "./dist/index.js" -> use "./index.<ext>" as entry
             entryPath = entryPath || (yield getSourcePathFromExportPath(cwd, '.')) || '';
         }
+        if (entryPath) {
+            // with -o option
+            if (options.file) {
+                exportPaths['.'] = constructDefaultExportCondition(options.file, packageType);
+            } else if (exportKeys.length === 0) {
+                exportPaths['.'] = constructDefaultExportCondition('dist/index.js', packageType);
+            }
+        }
         const bundleOrWatch = (rollupConfig)=>{
             const { input , exportName  } = rollupConfig;
             const exportPath = getExportPath(pkg, cwd, exportName);
@@ -818,25 +889,16 @@ function _bundle() {
             return Promise.reject(err);
         }
         // has `types` field in package.json or has `types` exports in any export condition for multi-entries
-        const hasTypings = !!getTypings(pkg) || typeof packageExportsField === 'object' && Array.from(Object.values(packageExportsField || {})).some((condition)=>condition.hasOwnProperty('types'));
+        const hasTypings = Object.values(exportPaths).some((condition)=>condition.hasOwnProperty('types'));
         // Enable types generation if it's types field specified in package.json
         if (hasTypings) {
             options.dts = hasTypings;
         }
         let result;
-        if (isMultiEntries) {
-            const buildConfigs = yield buildEntryConfig(pkg, options, cwd, defaultTsOptions, false);
-            const assetsJobs = buildConfigs.map((rollupConfig)=>bundleOrWatch(rollupConfig));
-            const typesJobs = options.dts ? (yield buildEntryConfig(pkg, options, cwd, defaultTsOptions, true)).map((rollupConfig)=>bundleOrWatch(rollupConfig)) : [];
-            result = yield Promise.all(assetsJobs.concat(typesJobs));
-        } else {
-            // Generate types
-            if (hasTsConfig && options.dts) {
-                yield bundleOrWatch(buildConfig(entryPath, pkg, options, cwd, defaultTsOptions, true));
-            }
-            const rollupConfig = buildConfig(entryPath, pkg, options, cwd, defaultTsOptions, false);
-            result = yield bundleOrWatch(rollupConfig);
-        }
+        const buildConfigs = yield buildEntryConfig(pkg, entryPath, exportPaths, options, cwd, defaultTsOptions, false);
+        const assetsJobs = buildConfigs.map((rollupConfig)=>bundleOrWatch(rollupConfig));
+        const typesJobs = hasTsConfig && options.dts ? (yield buildEntryConfig(pkg, entryPath, exportPaths, options, cwd, defaultTsOptions, true)).map((rollupConfig)=>bundleOrWatch(rollupConfig)) : [];
+        result = yield Promise.all(assetsJobs.concat(typesJobs));
         logSizeStats();
         return result;
     });

package/package.json

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

package/dist/cli.d.ts

@@ -1 +0,0 @@
-#!/usr/bin/env node