bunchee 3.3.1 → 3.3.2

package/dist/cli.js

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

package/dist/index.js

@@ -61,6 +61,130 @@ function chunkSizeCollector() {
     };
 }
 
+function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$3(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function exit(err) {
+    logger.error(err);
+    process.exit(1);
+}
+function getPackageMeta(cwd) {
+    return _getPackageMeta.apply(this, arguments);
+}
+function _getPackageMeta() {
+    _getPackageMeta = _async_to_generator$3(function*(cwd) {
+        const pkgFilePath = path__default.default.resolve(cwd, 'package.json');
+        let targetPackageJson = {};
+        try {
+            targetPackageJson = JSON.parse((yield fs__default.default.readFile(pkgFilePath, {
+                encoding: 'utf-8'
+            })));
+        } catch (_) {}
+        return targetPackageJson;
+    });
+    return _getPackageMeta.apply(this, arguments);
+}
+const logger = {
+    log (arg) {
+        console.log(arg);
+    },
+    warn (arg) {
+        console.log('\x1b[33m' + arg + '\x1b[0m');
+    },
+    error (arg) {
+        console.error('\x1b[31m' + arg + '\x1b[0m');
+    }
+};
+function fileExists(filePath) {
+    return _fileExists.apply(this, arguments);
+}
+function _fileExists() {
+    _fileExists = _async_to_generator$3(function*(filePath) {
+        try {
+            yield fs__default.default.access(filePath);
+            return true;
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                return false;
+            }
+            throw err;
+        }
+    });
+    return _fileExists.apply(this, arguments);
+}
+// . -> pkg name
+// ./lite -> <pkg name>/lite
+function getExportPath(pkg, cwd, exportName) {
+    const name = pkg.name || path__default.default.basename(cwd);
+    if (exportName === '.' || !exportName) return name;
+    return path__default.default.join(name, exportName);
+}
+const isNotNull = (n)=>Boolean(n);
+const SRC = 'src' // resolve from src/ directory
+;
+function resolveSourceFile(cwd, filename) {
+    return path__default.default.resolve(cwd, SRC, filename);
+}
+// Map '.' -> './index.[ext]'
+// Map './lite' -> './lite.[ext]'
+// Return undefined if no match or if it's package.json exports
+function getSourcePathFromExportPath(cwd, exportPath) {
+    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){
+            // 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;
+            }
+        }
+        return;
+    });
+    return _getSourcePathFromExportPath.apply(this, arguments);
+}
+// Unlike path.basename, forcedly removing extension
+function filenameWithoutExtension(file) {
+    return file ? file.replace(new RegExp(`${path__default.default.extname(file)}$`), '') : undefined;
+}
+
 function getTypings(pkg) {
     return pkg.types || pkg.typings;
 }
@@ -276,125 +400,11 @@ function getExportConditionDist(pkg, parsedExportCondition, cwd) {
     }
     return dist;
 }
-
-function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-        var info = gen[key](arg);
-        var value = info.value;
-    } catch (error) {
-        reject(error);
-        return;
-    }
-    if (info.done) {
-        resolve(value);
-    } else {
-        Promise.resolve(value).then(_next, _throw);
-    }
-}
-function _async_to_generator$3(fn) {
-    return function() {
-        var self = this, args = arguments;
-        return new Promise(function(resolve, reject) {
-            var gen = fn.apply(self, args);
-            function _next(value) {
-                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
-            }
-            function _throw(err) {
-                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
-            }
-            _next(undefined);
-        });
-    };
-}
-function exit(err) {
-    logger.error(err);
-    process.exit(1);
-}
-function getPackageMeta(cwd) {
-    return _getPackageMeta.apply(this, arguments);
-}
-function _getPackageMeta() {
-    _getPackageMeta = _async_to_generator$3(function*(cwd) {
-        const pkgFilePath = path__default.default.resolve(cwd, 'package.json');
-        let targetPackageJson = {};
-        try {
-            targetPackageJson = JSON.parse((yield fs__default.default.readFile(pkgFilePath, {
-                encoding: 'utf-8'
-            })));
-        } catch (_) {}
-        return targetPackageJson;
-    });
-    return _getPackageMeta.apply(this, arguments);
-}
-const logger = {
-    log (arg) {
-        console.log(arg);
-    },
-    warn (arg) {
-        console.log('\x1b[33m' + arg + '\x1b[0m');
-    },
-    error (arg) {
-        console.error('\x1b[31m' + arg + '\x1b[0m');
-    }
-};
-function fileExists(filePath) {
-    return _fileExists.apply(this, arguments);
-}
-function _fileExists() {
-    _fileExists = _async_to_generator$3(function*(filePath) {
-        try {
-            yield fs__default.default.access(filePath);
-            return true;
-        } catch (err) {
-            if (err.code === 'ENOENT') {
-                return false;
-            }
-            throw err;
-        }
-    });
-    return _fileExists.apply(this, arguments);
-}
-// . -> pkg name
-// ./lite -> <pkg name>/lite
-function getExportPath(pkg, cwd, exportName) {
-    const name = pkg.name || path__default.default.basename(cwd);
-    if (exportName === '.' || !exportName) return name;
-    return path__default.default.join(name, exportName);
-}
-const isNotNull = (n)=>Boolean(n);
-const SRC = 'src' // resolve from src/ directory
-;
-function resolveSourceFile(cwd, filename) {
-    return path__default.default.resolve(cwd, SRC, filename);
-}
-// Map '.' -> './index.[ext]'
-// Map './lite' -> './lite.[ext]'
-// Return undefined if no match or if it's package.json exports
-function getSourcePathFromExportPath(cwd, exportPath) {
-    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){
-            // 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;
-            }
-        }
-        return;
-    });
-    return _getSourcePathFromExportPath.apply(this, arguments);
+function getTypeFilePath(entryFilePath, exportCondition, cwd) {
+    const name = filenameWithoutExtension(entryFilePath);
+    const firstDistPath = exportCondition ? Object.values(exportCondition.export)[0] : undefined;
+    const exportName = (exportCondition == null ? void 0 : exportCondition.name) || 'index';
+    return entryFilePath ? name + '.d.ts' : path.resolve(firstDistPath ? path.dirname(firstDistPath) : path.join(cwd, 'dist'), (exportName === '.' ? 'index' : exportName) + '.d.ts');
 }
 
 function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
@@ -466,7 +476,7 @@ function getBuildEnv(envs) {
     }, {});
     return envVars;
 }
-function buildInputConfig(entry, pkg, options, cwd, { tsConfigPath , tsCompilerOptions  }, dtsOnly) {
+function buildInputConfig(entry, pkg, options, cwd, { tsConfigPath , tsCompilerOptions  }, dts) {
     var _options_external;
     const externals = options.noExternal ? [] : [
         pkg.peerDependencies,
@@ -482,7 +492,7 @@ function buildInputConfig(entry, pkg, options, cwd, { tsConfigPath , tsCompilerO
         shebang__default.default(),
         sizePlugin
     ];
-    const plugins = (dtsOnly ? [
+    const plugins = (dts ? [
         ...commonPlugins,
         useTypescript && require('rollup-plugin-dts').default({
             compilerOptions: _extends$1({}, tsCompilerOptions, {
@@ -559,7 +569,7 @@ function buildInputConfig(entry, pkg, options, cwd, { tsConfigPath , tsCompilerO
         onwarn (warning, warn) {
             const code = warning.code || '';
             // Some may not have types, like CLI binary
-            if (dtsOnly && code === 'EMPTY_BUNDLE') return;
+            if (dts && code === 'EMPTY_BUNDLE') return;
             if ([
                 'MIXED_EXPORTS',
                 'PREFER_NAMED_EXPORTS',
@@ -586,17 +596,16 @@ function hasEsmExport(exportPaths, tsCompilerOptions) {
     }
     return Boolean(hasEsm || (tsCompilerOptions == null ? void 0 : tsCompilerOptions.esModuleInterop));
 }
-function buildOutputConfigs(pkg, exportPaths, options, exportCondition, cwd, { tsCompilerOptions  }, dtsOnly) {
+function buildOutputConfigs(pkg, exportPaths, options, exportCondition, cwd, { tsCompilerOptions  }, dts) {
     const { format  } = options;
     // Add esm mark and interop helper if esm export is detected
     const useEsModuleMark = hasEsmExport(exportPaths, tsCompilerOptions);
     const typings = getTypings(pkg);
     const file = options.file && path.resolve(cwd, options.file);
     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 name = filenameWithoutExtension(file);
     // 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);
+    const dtsFile = exportCondition.export['types'] ? path.resolve(cwd, exportCondition.export['types']) : file ? name + '.d.ts' : path.resolve(dtsDir, (exportCondition.name === '.' ? 'index' : exportCondition.name) + '.d.ts');
     // If there's dts file, use `output.file`
     const dtsPathConfig = dtsFile ? {
         file: dtsFile
@@ -605,7 +614,7 @@ function buildOutputConfigs(pkg, exportPaths, options, exportCondition, cwd, { t
     };
     return _extends$1({
         name: pkg.name || name
-    }, dtsOnly ? dtsPathConfig : {
+    }, dts ? dtsPathConfig : {
         file: file
     }, {
         format,
@@ -618,44 +627,46 @@ function buildOutputConfigs(pkg, exportPaths, options, exportCondition, cwd, { t
     });
 }
 // build configs for each entry from package exports
-function buildEntryConfig(pkg, entryPath, exportPaths, bundleConfig, cwd, tsOptions, dtsOnly) {
+function buildEntryConfig(pkg, entryPath, exportPaths, bundleConfig, cwd, tsOptions, dts) {
     return _buildEntryConfig.apply(this, arguments);
 }
 function _buildEntryConfig() {
-    _buildEntryConfig = _async_to_generator$2(function*(pkg, entryPath, exportPaths, bundleConfig, cwd, tsOptions, dtsOnly) {
+    _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) {
             // 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, dtsOnly);
+            const rollupConfig = buildConfig(entry, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, dts);
             return rollupConfig;
         }));
         return (yield Promise.all(configs)).filter((n)=>Boolean(n));
     });
     return _buildEntryConfig.apply(this, arguments);
 }
-function buildConfig(entry, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, dtsOnly) {
+function buildConfig(entry, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, dts) {
     const { file  } = bundleConfig;
     const useTypescript = Boolean(tsOptions.tsConfigPath);
     const options = _extends$1({}, bundleConfig, {
         useTypescript
     });
-    const inputOptions = buildInputConfig(entry, pkg, options, cwd, tsOptions, dtsOnly);
+    const inputOptions = buildInputConfig(entry, pkg, options, cwd, tsOptions, dts);
     const outputExports = getExportConditionDist(pkg, exportCondition, cwd);
     let outputConfigs = [];
     // Generate dts job - single config
-    if (dtsOnly) {
+    if (dts) {
         outputConfigs = [
             buildOutputConfigs(pkg, exportPaths, _extends$1({}, bundleConfig, {
                 format: 'es',
                 useTypescript
-            }), exportCondition, cwd, tsOptions, dtsOnly)
+            }), exportCondition, cwd, tsOptions, dts)
         ];
     } else {
         // multi outputs with specified format
@@ -664,7 +675,7 @@ function buildConfig(entry, pkg, exportPaths, bundleConfig, exportCondition, cwd
                 file: exportDist.file,
                 format: exportDist.format,
                 useTypescript
-            }), exportCondition, cwd, tsOptions, dtsOnly);
+            }), exportCondition, cwd, tsOptions, dts);
         });
         // CLI output option is always prioritized
         if (file) {
@@ -675,7 +686,7 @@ function buildConfig(entry, pkg, exportPaths, bundleConfig, exportCondition, cwd
                     file,
                     format: bundleConfig.format || fallbackFormat,
                     useTypescript
-                }), exportCondition, cwd, tsOptions, dtsOnly)
+                }), exportCondition, cwd, tsOptions, dts)
             ];
         }
     }
@@ -849,6 +860,8 @@ function _bundle() {
         // const exportPathsLength = Object.keys(exportPaths).length
         const isMultiEntries = hasMultiEntryExport(exportPaths) // exportPathsLength > 1
         ;
+        // has `types` field in package.json or has `types` exports in any export condition for multi-entries
+        const hasTypings = Object.values(exportPaths).some((condition)=>condition.hasOwnProperty('types'));
         const tsConfig = yield resolveTsConfig(cwd);
         const hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
         const defaultTsOptions = {
@@ -862,11 +875,22 @@ function _bundle() {
             entryPath = entryPath || (yield getSourcePathFromExportPath(cwd, '.')) || '';
         }
         if (entryPath) {
+            let mainEntryPath;
+            let typesEntryPath;
             // with -o option
             if (options.file) {
-                exportPaths['.'] = constructDefaultExportCondition(options.file, packageType);
+                mainEntryPath = options.file;
             } else if (exportKeys.length === 0) {
-                exportPaths['.'] = constructDefaultExportCondition('dist/index.js', packageType);
+                mainEntryPath = path.resolve(cwd, 'dist/index.js');
+            }
+            if (mainEntryPath) {
+                if (options.dts) {
+                    typesEntryPath = getTypeFilePath(mainEntryPath, undefined, cwd);
+                }
+                exportPaths['.'] = constructDefaultExportCondition({
+                    main: mainEntryPath,
+                    types: typesEntryPath
+                }, packageType);
             }
         }
         const bundleOrWatch = (rollupConfig)=>{
@@ -888,8 +912,6 @@ function _bundle() {
             err.name = 'NOT_EXISTED';
             return Promise.reject(err);
         }
-        // has `types` field in package.json or has `types` exports in any export condition for multi-entries
-        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;

package/package.json

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