bunchee 4.3.1 → 4.3.3

package/dist/bin/cli.js

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
 var path = require('path');
 var arg = require('arg');
+var fs = require('fs');
 var fsp = require('fs/promises');
 var require$$0 = require('tty');
 var bunchee = require('bunchee');
-var fs = require('fs');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var path__default = /*#__PURE__*/_interopDefault(path);
 var arg__default = /*#__PURE__*/_interopDefault(arg);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
 var fsp__default = /*#__PURE__*/_interopDefault(fsp);
 var require$$0__default = /*#__PURE__*/_interopDefault(require$$0);
-var fs__default = /*#__PURE__*/_interopDefault(fs);
 
-const availableExtensions = [
+const availableExtensions = new Set([
     'js',
     'cjs',
     'mjs',
@@ -23,19 +23,19 @@ const availableExtensions = [
     'tsx',
     'cts',
     'mts'
-];
+]);
 const SRC = 'src';
 const dtsExtensionsMap = {
     js: 'd.ts',
     cjs: 'd.cts',
     mjs: 'd.mts'
 };
-const tsExtensions = [
+const tsExtensions = new Set([
     'ts',
     'tsx',
     'cts',
     'mts'
-];
+]);
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -119,8 +119,8 @@ function exit(err) {
     logger.error(err);
     process.exit(1);
 }
-async function hasPackageJson(cwd) {
-    return await fileExists(path__default.default.resolve(cwd, 'package.json'));
+function hasPackageJson(cwd) {
+    return fileExists(path__default.default.resolve(cwd, 'package.json'));
 }
 async function getPackageMeta(cwd) {
     const pkgFilePath = path__default.default.resolve(cwd, 'package.json');
@@ -134,29 +134,27 @@ async function getPackageMeta(cwd) {
 }
 function isTypescriptFile(filename) {
     const ext = path__default.default.extname(filename).slice(1);
-    return tsExtensions.includes(ext);
+    return tsExtensions.has(ext);
 }
-async function fileExists(filePath) {
-    try {
-        await fsp__default.default.access(filePath);
-        return true;
-    } catch (err) {
-        if (err.code === 'ENOENT') {
-            return false;
-        }
-        throw err;
-    }
+function fileExists(filePath) {
+    return fs__default.default.existsSync(filePath);
 }
-const hasAvailableExtension = (filename)=>availableExtensions.includes(path__default.default.extname(filename).slice(1));
+const hasAvailableExtension = (filename)=>availableExtensions.has(path__default.default.extname(filename).slice(1));
 const baseNameWithoutExtension = (filename)=>path__default.default.basename(filename, path__default.default.extname(filename));
 
-var version = "4.3.1";
+var version = "4.3.3";
 
 function relativify(path) {
     return path.startsWith('.') ? path : `./${path}`;
 }
 
 const DIST = 'dist';
+const DEFAULT_TS_CONFIG = {
+    compilerOptions: {
+        module: 'ESNext',
+        moduleResolution: 'bundler'
+    }
+};
 // Output with posix style in package.json
 function getDistPath(...subPaths) {
     return `./${DIST}/${subPaths.join('/')}`;
@@ -201,18 +199,17 @@ async function collectSourceEntries(sourceFolderPath) {
                 });
                 for (const binDirent of binDirentList){
                     if (binDirent.isFile()) {
-                        const binFile = path__default.default.join(sourceFolderPath, dirent.name, binDirent.name);
+                        const binFileAbsolutePath = path__default.default.join(sourceFolderPath, dirent.name, binDirent.name);
                         const binName = baseNameWithoutExtension(binDirent.name);
-                        if (fs__default.default.existsSync(binFile)) {
+                        if (fs__default.default.existsSync(binFileAbsolutePath)) {
                             bins.set(binName, binDirent.name);
                         }
                     }
                 }
             } else {
                 // Search folder/<index>.<ext> convention entries
-                const extensions = availableExtensions;
-                for (const extension of extensions){
-                    const indexFile = path__default.default.join(sourceFolderPath, dirent.name, `index.${extension}`);
+                for (const extension of availableExtensions){
+                    const indexFile = path__default.default.join(dirent.name, `index.${extension}`);
                     if (fs__default.default.existsSync(indexFile)) {
                         exportsEntries.set(dirent.name, indexFile);
                         break;
@@ -220,7 +217,7 @@ async function collectSourceEntries(sourceFolderPath) {
                 }
             }
         } else if (dirent.isFile()) {
-            const isAvailableExtension = availableExtensions.includes(path__default.default.extname(dirent.name).slice(1));
+            const isAvailableExtension = availableExtensions.has(path__default.default.extname(dirent.name).slice(1));
             if (isAvailableExtension) {
                 const baseName = baseNameWithoutExtension(dirent.name);
                 const isBinFile = baseName === 'bin';
@@ -285,18 +282,18 @@ async function prepare(cwd) {
     // Collect bins and exports entries
     const { bins, exportsEntries } = await collectSourceEntries(sourceFolder);
     const tsconfigPath = path__default.default.join(cwd, 'tsconfig.json');
-    if (!fs__default.default.existsSync(tsconfigPath)) {
-        const sourceFiles = [
-            ...exportsEntries.values()
-        ].concat([
-            ...bins.values()
-        ]);
-        const hasTypeScriptFiles = sourceFiles.some((filename)=>isTypescriptFile(filename));
-        if (hasTypeScriptFiles) {
-            isUsingTs = true;
-            await fsp__default.default.writeFile(tsconfigPath, '{}', 'utf-8');
-            logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
+    const sourceFiles = [
+        ...exportsEntries.values()
+    ].concat([
+        ...bins.values()
+    ]);
+    const hasTypeScriptFiles = sourceFiles.some((filename)=>isTypescriptFile(filename));
+    if (hasTypeScriptFiles) {
+        isUsingTs = true;
+        if (!fs__default.default.existsSync(tsconfigPath)) {
+            await fsp__default.default.writeFile(tsconfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
         }
+        logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
     }
     // Configure as ESM package by default if there's no package.json
     if (!hasPackageJson) {
@@ -338,10 +335,14 @@ async function prepare(cwd) {
             const isESM = pkgJson.type === 'module';
             const mainExport = pkgExports['.'];
             const mainCondition = isESM ? 'import' : 'require';
-            pkgJson.main = isUsingTs ? mainExport[mainCondition].default : mainExport[mainCondition];
-            pkgJson.module = isUsingTs ? mainExport.import.default : mainExport.import;
+            if (!pkgJson.main) {
+                pkgJson.main = isUsingTs ? mainExport[mainCondition].default : mainExport[mainCondition];
+            }
+            if (!pkgJson.module) {
+                pkgJson.module = isUsingTs ? mainExport.import.default : mainExport.import;
+            }
             if (isUsingTs) {
-                pkgJson.types = isESM ? mainExport.import.types : mainExport.require.types;
+                pkgJson.types = mainExport[mainCondition].types;
             }
         }
         // Assign the properties by order: files, main, module, types, exports

package/dist/index.js

@@ -1,8 +1,9 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var fs = require('fs/promises');
-var path = require('path');
 var rollup = require('rollup');
+var fsp = require('fs/promises');
+var fs = require('fs');
+var path = require('path');
 var module$1 = require('module');
 var require$$0 = require('tty');
 var pluginWasm = require('@rollup/plugin-wasm');
@@ -18,6 +19,7 @@ var prettyBytes = require('pretty-bytes');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var fsp__default = /*#__PURE__*/_interopDefault(fsp);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var path__default = /*#__PURE__*/_interopDefault(path);
 var require$$0__default = /*#__PURE__*/_interopDefault(require$$0);
@@ -28,7 +30,7 @@ var esmShim__default = /*#__PURE__*/_interopDefault(esmShim);
 var preserveDirectives__default = /*#__PURE__*/_interopDefault(preserveDirectives);
 var prettyBytes__default = /*#__PURE__*/_interopDefault(prettyBytes);
 
-const availableExtensions = [
+const availableExtensions = new Set([
     'js',
     'cjs',
     'mjs',
@@ -37,7 +39,7 @@ const availableExtensions = [
     'tsx',
     'cts',
     'mts'
-];
+]);
 const nodeResolveExtensions = [
     '.mjs',
     '.cjs',
@@ -46,11 +48,11 @@ const nodeResolveExtensions = [
     '.node',
     '.jsx'
 ];
-const availableExportConventions = [
+const availableExportConventions = new Set([
     'react-server',
     'react-native',
     'edge-light'
-];
+]);
 const availableESExtensionsRegex = /\.(m|c)?[jt]sx?$/;
 const SRC = 'src';
 const dtsExtensionsMap = {
@@ -146,22 +148,14 @@ async function getPackageMeta(cwd) {
     const pkgFilePath = path__default.default.resolve(cwd, 'package.json');
     let targetPackageJson = {};
     try {
-        targetPackageJson = JSON.parse(await fs__default.default.readFile(pkgFilePath, {
+        targetPackageJson = JSON.parse(await fsp__default.default.readFile(pkgFilePath, {
             encoding: 'utf-8'
         }));
     } catch (_) {}
     return targetPackageJson;
 }
-async function fileExists(filePath) {
-    try {
-        await fs__default.default.access(filePath);
-        return true;
-    } catch (err) {
-        if (err.code === 'ENOENT') {
-            return false;
-        }
-        throw err;
-    }
+function fileExists(filePath) {
+    return fs__default.default.existsSync(filePath);
 }
 // . -> pkg name
 // ./lite -> <pkg name>/lite
@@ -174,14 +168,14 @@ const isNotNull = (n)=>Boolean(n);
 function resolveSourceFile(cwd, filename) {
     return path__default.default.resolve(cwd, SRC, filename);
 }
-async function findSourceEntryFile(cwd, exportPath, exportTypeSuffix, ext) {
+function findSourceEntryFile(cwd, exportPath, exportTypeSuffix, ext) {
     const filename = resolveSourceFile(cwd, `${exportPath}${exportTypeSuffix ? `.${exportTypeSuffix}` : ''}.${ext}`);
-    if (await fileExists(filename)) {
+    if (fileExists(filename)) {
         return filename;
     }
     const subFolderIndexFilename = resolveSourceFile(cwd, `${exportPath}/index${exportTypeSuffix ? `.${exportTypeSuffix}` : ''}.${ext}`);
     try {
-        if (await fileExists(subFolderIndexFilename)) {
+        if (fileExists(subFolderIndexFilename)) {
             return subFolderIndexFilename;
         }
     } catch  {}
@@ -197,7 +191,7 @@ async function getSourcePathFromExportPath(cwd, exportPath, exportType) {
         if (exportPath === '.') exportPath = './index';
         // Find convention-based source file for specific export types
         // $binary represents `pkg.bin`
-        if (availableExportConventions.includes(exportType) && exportType !== '$binary') {
+        if (availableExportConventions.has(exportType) && exportType !== '$binary') {
             const filename = await findSourceEntryFile(cwd, exportPath, exportType, ext);
             if (filename) return filename;
         }
@@ -211,7 +205,7 @@ function filePathWithoutExtension(file) {
     return file ? file.replace(new RegExp(`${path__default.default.extname(file)}$`), '') : undefined;
 }
 const nonNullable = (n)=>Boolean(n);
-const hasAvailableExtension = (filename)=>availableExtensions.includes(path__default.default.extname(filename).slice(1));
+const hasAvailableExtension = (filename)=>availableExtensions.has(path__default.default.extname(filename).slice(1));
 const hasCjsExtension = (filename)=>path__default.default.extname(filename) === '.cjs';
 
 let hasLoggedTsWarning = false;
@@ -230,11 +224,11 @@ function resolveTypescript(cwd) {
     }
     return ts;
 }
-async function resolveTsConfig(cwd) {
+function resolveTsConfig(cwd) {
     let tsCompilerOptions = {};
     let tsConfigPath;
     tsConfigPath = path.resolve(cwd, 'tsconfig.json');
-    if (await fileExists(tsConfigPath)) {
+    if (fileExists(tsConfigPath)) {
         const ts = resolveTypescript(cwd);
         const basePath = tsConfigPath ? path.dirname(tsConfigPath) : cwd;
         const tsconfigJSON = ts.readConfigFile(tsConfigPath, ts.sys.readFile).config;
@@ -1019,7 +1013,7 @@ async function buildEntryConfig(bundleConfig, pluginContext, dts) {
             ...exportCondRef
         };
         // Special cases of export type, only pass down the exportPaths for the type
-        if (availableExportConventions.includes(exportType)) {
+        if (availableExportConventions.has(exportType)) {
             exportCondForType = {
                 [entryExport]: exportCondRef[exportType]
             };
@@ -1151,6 +1145,8 @@ function relativify(path) {
     return path.startsWith('.') ? path : `./${path}`;
 }
 
+// Example: @foo/bar -> bar
+const removeScope = (exportPath)=>exportPath.replace(/^@[^/]+\//, '');
 function createOutputState({ entries }) {
     const sizeStats = new Map();
     function addSize({ fileName, size, sourceFileName, exportPath }) {
@@ -1183,7 +1179,7 @@ function createOutputState({ entries }) {
                         }
                         const size = chunk.code.length;
                         const sourceFileName = chunk.facadeModuleId || '';
-                        const exportPath = reversedMapping.get(sourceFileName) || '.';
+                        const exportPath = removeScope(reversedMapping.get(sourceFileName) || '.');
                         addSize({
                             fileName: path__default.default.isAbsolute(cwd) ? path__default.default.relative(cwd, filePath) : filePath,
                             size,
@@ -1275,7 +1271,7 @@ const getWildcardExports = (exportsCondition)=>{
 };
 const isExportable = async (dirent, pathname)=>{
     if (dirent.isDirectory()) {
-        const innerDirents = await fs__default.default.readdir(path__default.default.join(pathname, dirent.name), {
+        const innerDirents = await fsp__default.default.readdir(path__default.default.join(pathname, dirent.name), {
             withFileTypes: true
         });
         return innerDirents.some(({ name })=>name.startsWith('index') && hasAvailableExtension(name));
@@ -1284,7 +1280,7 @@ const isExportable = async (dirent, pathname)=>{
 };
 async function getExportables(cwd, excludeKeys) {
     const pathname = path__default.default.resolve(cwd, SRC);
-    const dirents = await fs__default.default.readdir(pathname, {
+    const dirents = await fsp__default.default.readdir(pathname, {
         withFileTypes: true
     });
     const exportables = await Promise.all(dirents.map(async (dirent)=>await isExportable(dirent, pathname) && !excludeKeys.includes(dirent.name) ? dirent.name : undefined));
@@ -1386,12 +1382,21 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
         }
         return runBundle(rollupConfig);
     };
-    const hasSpecifiedEntryFile = entryPath ? await fileExists(entryPath) && (await fs__default.default.stat(entryPath)).isFile() : false;
+    const hasSpecifiedEntryFile = entryPath ? fs__default.default.existsSync(entryPath) && (await fsp__default.default.stat(entryPath)).isFile() : false;
     const hasNoEntry = !hasSpecifiedEntryFile && !isMultiEntries && !hasBin;
     if (hasNoEntry) {
-        const err = new Error(`Entry file \`${entryPath}\` is not existed`);
-        err.name = 'NOT_EXISTED';
-        return Promise.reject(err);
+        if (entryPath) {
+            const err = new Error(`Entry file "${entryPath}" does not exist`);
+            err.name = 'NOT_EXISTED';
+            return Promise.reject(err);
+        } else if (cwd) {
+            const hasProjectDir = fs__default.default.existsSync(cwd) && (await fsp__default.default.stat(cwd)).isDirectory();
+            if (!hasProjectDir) {
+                const err = new Error(`Project directory "${cwd}" does not exist`);
+                err.name = 'NOT_EXISTED';
+                return Promise.reject(err);
+            }
+        }
     }
     const entries = await collectEntries(pkg, entryPath, exportPaths, cwd);
     const sizeCollector = createOutputState({
@@ -1437,7 +1442,8 @@ function runWatch({ input, output }, metadata) {
         switch(event.code){
             case 'ERROR':
                 {
-                    return onError(event.error);
+                    logError(event.error);
+                    break;
                 }
             case 'START':
                 {
@@ -1457,14 +1463,18 @@ function runBundle({ input, output }) {
     return rollup.rollup(input).then((bundle)=>{
         const writeJobs = output.map((options)=>bundle.write(options));
         return Promise.all(writeJobs);
-    }, onError);
+    }, catchErrorHandler);
 }
-function onError(error) {
+function logError(error) {
     if (!error) return;
     // logging source code in format
     if (error.frame) {
         process.stderr.write(error.frame + '\n');
     }
+}
+function catchErrorHandler(error) {
+    if (!error) return;
+    logError(error);
     // filter out the rollup plugin error information such as loc/frame/code...
     const err = new Error(error.message);
     err.stack = error.stack;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunchee",
-  "version": "4.3.1",
+  "version": "4.3.3",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",
@@ -54,12 +54,12 @@
     "@rollup/plugin-replace": "^5.0.5",
     "@rollup/plugin-wasm": "^6.2.2",
     "@rollup/pluginutils": "^5.1.0",
-    "@swc/core": "^1.3.99",
+    "@swc/core": "^1.3.102",
     "@swc/helpers": "^0.5.3",
     "arg": "^5.0.2",
     "pretty-bytes": "^5.6.0",
     "publint": "~0.2.7",
-    "rollup": "^4.9.1",
+    "rollup": "^4.9.4",
     "rollup-plugin-dts": "^6.1.0",
     "rollup-plugin-swc3": "^0.11.0",
     "rollup-preserve-directives": "^1.1.1",