bunchee 3.0.1 → 3.1.1

package/README.md

@@ -39,9 +39,9 @@ You can use the `exports` field to support different conditions and leverage the
 ```json
 {
   "exports": {
-    "require": "dist/index.cjs",
+    "module": "dist/index.esm.js",
     "import": "dist/index.mjs",
-    "module": "dist/index.esm.js"
+    "require": "dist/index.cjs"
   },
   "scripts": {
     "build": "bunchee"
@@ -124,7 +124,7 @@ Replace `ENV1`, `ENV2`, and `ENV3` with the names of the environment variables y
 
 ### Entry Files Convention
 
-While `exports` filed is becoming the standard of exporting in node.js, bunchee also supports to build multiple exports all in one command.
+While `exports` field is becoming the standard of exporting in node.js, bunchee also supports to build multiple exports all in one command.
 
 What you need to do is just add an entry file with the name (`[name].[ext]`) that matches the exported name from exports field in package.json. For instance:
 

package/dist/cli.js

@@ -3,6 +3,12 @@ var path = require('path');
 var arg = require('arg');
 var fs = require('fs/promises');
 
+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);
+
 function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -37,15 +43,24 @@ function exit(err) {
     process.exit(1);
 }
 const formatDuration = (duration)=>duration >= 1000 ? `${duration / 1000}s` : `${duration}ms`;
+function hasPackageJson(cwd) {
+    return _hasPackageJson.apply(this, arguments);
+}
+function _hasPackageJson() {
+    _hasPackageJson = _async_to_generator$1(function*(cwd) {
+        return yield fileExists(path__default.default.resolve(cwd, 'package.json'));
+    });
+    return _hasPackageJson.apply(this, arguments);
+}
 function getPackageMeta(cwd) {
     return _getPackageMeta.apply(this, arguments);
 }
 function _getPackageMeta() {
     _getPackageMeta = _async_to_generator$1(function*(cwd) {
-        const pkgFilePath = path.resolve(cwd, 'package.json');
+        const pkgFilePath = path__default.default.resolve(cwd, 'package.json');
         let targetPackageJson = {};
         try {
-            targetPackageJson = JSON.parse((yield fs.readFile(pkgFilePath, {
+            targetPackageJson = JSON.parse((yield fs__default.default.readFile(pkgFilePath, {
                 encoding: 'utf-8'
             })));
         } catch (_) {}
@@ -64,8 +79,25 @@ const logger = {
         console.error('\x1b[31m' + arg + '\x1b[0m');
     }
 };
+function fileExists(filePath) {
+    return _fileExists.apply(this, arguments);
+}
+function _fileExists() {
+    _fileExists = _async_to_generator$1(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);
+}
 
-var version = "3.0.1";
+var version = "3.1.1";
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -123,6 +155,10 @@ function lintPackage(cwd) {
 }
 function _lintPackage() {
     _lintPackage = _async_to_generator(function*(cwd) {
+        // Not package.json detected, skip package linting
+        if (!(yield hasPackageJson(cwd))) {
+            return;
+        }
         const { publint  } = yield import('publint');
         const { printMessage  } = yield import('publint/utils');
         const messages = yield publint({
@@ -138,7 +174,7 @@ function _lintPackage() {
 }
 function parseCliArgs(argv) {
     let args;
-    args = arg({
+    args = arg__default.default({
         '--cwd': String,
         '--dts': Boolean,
         '--output': String,
@@ -190,7 +226,7 @@ function _run() {
         var _args_external;
         const { source , format , watch , minify , sourcemap , target , runtime , dts , env  } = args;
         const cwd = args.cwd || process.cwd();
-        const file = args.file ? path.resolve(cwd, args.file) : undefined;
+        const file = args.file ? path__default.default.resolve(cwd, args.file) : undefined;
         const bundleConfig = {
             dts,
             file,
@@ -210,7 +246,7 @@ function _run() {
         if (args.help) {
             return help();
         }
-        const entry = source ? path.resolve(cwd, source) : '';
+        const entry = source ? path__default.default.resolve(cwd, source) : '';
         const bundle = require('./index').bundle;
         let timeStart = Date.now();
         let timeEnd;

package/dist/index.d.ts

@@ -23,6 +23,6 @@ type BundleConfig = {
 };
 type ExportCondition = string | Record<ExportType, string>;
 
-declare function bundle(entryPath: string, { cwd, ...options }?: BundleConfig): Promise<any>;
+declare function bundle(entryPath: string, { cwd: _cwd, ...options }?: BundleConfig): Promise<any>;
 
 export { BundleConfig, bundle };

package/dist/index.js

@@ -3,25 +3,67 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var fs = require('fs/promises');
 var path = require('path');
 var rollup = require('rollup');
-var fs$1 = require('fs');
-var module$1 = require('module');
 var rollupPluginSwc3 = require('rollup-plugin-swc3');
 var commonjs = require('@rollup/plugin-commonjs');
 var shebang = require('rollup-plugin-preserve-shebang');
 var json = require('@rollup/plugin-json');
 var pluginNodeResolve = require('@rollup/plugin-node-resolve');
 var replace = require('@rollup/plugin-replace');
+var prettyBytes = require('pretty-bytes');
+var module$1 = require('module');
 
-const rootDir = process.cwd();
-var config = {
-    rootDir
-};
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var commonjs__default = /*#__PURE__*/_interopDefault(commonjs);
+var shebang__default = /*#__PURE__*/_interopDefault(shebang);
+var json__default = /*#__PURE__*/_interopDefault(json);
+var replace__default = /*#__PURE__*/_interopDefault(replace);
+var prettyBytes__default = /*#__PURE__*/_interopDefault(prettyBytes);
+
+function chunkSizeCollector() {
+    const sizes = new Map();
+    function addSize(name, size) {
+        sizes.set(name, size);
+    }
+    return {
+        plugin: (cwd)=>{
+            return {
+                name: 'collect-sizes',
+                augmentChunkHash () {
+                // Do nothing, but use the hook to keep the plugin instance alive
+                },
+                renderChunk (code, chunk, options) {
+                    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));
+                    }
+                    addSize(fileName, code.length);
+                    return null;
+                }
+            };
+        },
+        getSizeStats () {
+            const sizeStats = [];
+            sizes.forEach((size, name)=>{
+                sizeStats.push([
+                    name,
+                    prettyBytes__default.default(size),
+                    size
+                ]);
+            });
+            return sizeStats;
+        }
+    };
+}
 
 function getTypings(pkg) {
     return pkg.types || pkg.typings;
 }
-function getDistPath(distPath) {
-    return path.resolve(config.rootDir, distPath);
+function getDistPath(distPath, cwd) {
+    return path.resolve(cwd, distPath);
 }
 function findExport(field) {
     if (!field) return;
@@ -40,7 +82,46 @@ function parseExport(exportsCondition) {
     }
     return paths;
 }
-function getExportPaths(pkg) {
+/**
+ * Get package exports paths
+ *
+ * Example:
+ *
+ * ```json
+ * {
+ *  "exports": {
+ *    ".": {
+ *      "require": "./dist/index.cjs",
+ *      "module": "./dist/index.esm.js",
+ *      "default": "./dist/index.esm.js"
+ *    },
+ *    "./foo": {
+ *      "require": "./dist/foo.cjs",
+ *      "module": "./dist/foo.esm.js",
+ *      "default": "./dist/foo.esm.js"
+ *   }
+ * }
+ *
+ * ```
+ *
+ * will be parsed to:
+ *
+ * ```js
+ * {
+ *   '.': {
+ *     main: './dist/index.cjs',
+ *     module: './dist/index.esm.js',
+ *     export: './dist/index.esm.js'
+ *   },
+ *   './foo': {
+ *     main: './dist/foo.cjs',
+ *     module: './dist/foo.esm.js',
+ *     export: './dist/foo.esm.js'
+ *   }
+ *
+ *
+ * pkg.main and pkg.module will be added to ['.'] if exists
+ */ function getExportPaths(pkg) {
     const pathsMap = {};
     const mainExport = {};
     if (pkg.main) {
@@ -68,67 +149,64 @@ function getExportPaths(pkg) {
     pathsMap['.'] = mainExport;
     return pathsMap;
 }
-function getExportDist(pkg) {
+function getExportDist(pkg, cwd) {
     const paths = getExportPaths(pkg)['.'];
     const dist = [];
     if (paths.main) {
         dist.push({
             format: 'cjs',
-            file: getDistPath(paths.main)
+            file: getDistPath(paths.main, cwd)
         });
     }
     if (paths.module) {
         dist.push({
             format: 'esm',
-            file: getDistPath(paths.module)
+            file: getDistPath(paths.module, cwd)
         });
     }
     if (paths.export) {
         dist.push({
             format: 'esm',
-            file: getDistPath(paths.export)
+            file: getDistPath(paths.export, cwd)
         });
     }
     // default fallback to output `dist/index.js` in default esm format
     if (dist.length === 0) {
         dist.push({
             format: 'esm',
-            file: getDistPath('dist/index.js')
+            file: getDistPath('dist/index.js', cwd)
         });
     }
     return dist;
 }
-function getExportConditionDist(pkg, exportCondition) {
-    // const pkgExports = pkg.exports || {}
+function getExportConditionDist(pkg, exportCondition, cwd) {
     const dist = [];
     // "exports": "..."
     if (typeof exportCondition === 'string') {
         dist.push({
             format: pkg.type === 'module' ? 'esm' : 'cjs',
-            file: getDistPath(exportCondition)
+            file: getDistPath(exportCondition, cwd)
         });
     } else {
         // "./<subexport>": { }
-        const subExports = exportCondition // pkgExports[subExport]
-        ;
+        const subExports = exportCondition;
         // Ignore json exports, like "./package.json"
-        // if (subExport.endsWith('.json')) return dist
         if (typeof subExports === 'string') {
             dist.push({
                 format: 'esm',
-                file: getDistPath(subExports)
+                file: getDistPath(subExports, cwd)
             });
         } else {
             if (subExports.require) {
                 dist.push({
                     format: 'cjs',
-                    file: getDistPath(subExports.require)
+                    file: getDistPath(subExports.require, cwd)
                 });
             }
             if (subExports.import) {
                 dist.push({
                     format: 'esm',
-                    file: getDistPath(subExports.import)
+                    file: getDistPath(subExports.import, cwd)
                 });
             }
         }
@@ -136,7 +214,7 @@ function getExportConditionDist(pkg, exportCondition) {
     return dist;
 }
 
-function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -150,16 +228,16 @@ function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$1(fn) {
+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$1(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -169,16 +247,15 @@ function exit(err) {
     logger.error(err);
     process.exit(1);
 }
-const formatDuration = (duration)=>duration >= 1000 ? `${duration / 1000}s` : `${duration}ms`;
 function getPackageMeta(cwd) {
     return _getPackageMeta.apply(this, arguments);
 }
 function _getPackageMeta() {
-    _getPackageMeta = _async_to_generator$1(function*(cwd) {
-        const pkgFilePath = path.resolve(cwd, 'package.json');
+    _getPackageMeta = _async_to_generator$3(function*(cwd) {
+        const pkgFilePath = path__default.default.resolve(cwd, 'package.json');
         let targetPackageJson = {};
         try {
-            targetPackageJson = JSON.parse((yield fs.readFile(pkgFilePath, {
+            targetPackageJson = JSON.parse((yield fs__default.default.readFile(pkgFilePath, {
                 encoding: 'utf-8'
             })));
         } catch (_) {}
@@ -197,17 +274,13 @@ const logger = {
         console.error('\x1b[31m' + arg + '\x1b[0m');
     }
 };
-function isTypescript(filename) {
-    const ext = path.extname(filename);
-    return ext === '.ts' || ext === '.tsx';
-}
 function fileExists(filePath) {
     return _fileExists.apply(this, arguments);
 }
 function _fileExists() {
-    _fileExists = _async_to_generator$1(function*(filePath) {
+    _fileExists = _async_to_generator$3(function*(filePath) {
         try {
-            yield fs.access(filePath);
+            yield fs__default.default.access(filePath);
             return true;
         } catch (err) {
             if (err.code === 'ENOENT') {
@@ -218,8 +291,78 @@ function _fileExists() {
     });
     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 asyncGeneratorStep$2(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$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
 function _extends$1() {
     _extends$1 = Object.assign || function(target) {
         for(var i = 1; i < arguments.length; i++){
@@ -245,22 +388,8 @@ const minifyOptions = {
         toplevel: true
     }
 };
-let hasLoggedTsWarning = false;
-function resolveTypescript(cwd) {
-    let ts;
-    const m = new module$1.Module('', undefined);
-    m.paths = module$1.Module._nodeModulePaths(cwd);
-    try {
-        ts = m.require('typescript');
-    } catch (_) {
-        console.error(_);
-        if (!hasLoggedTsWarning) {
-            hasLoggedTsWarning = true;
-            exit('Could not load TypeScript compiler. Try to install `typescript` as dev dependency');
-        }
-    }
-    return ts;
-}
+// This can also be passed down as stats from top level
+const sizeCollector = chunkSizeCollector();
 function getBuildEnv(envs) {
     if (!envs.includes('NODE_ENV')) {
         envs.push('NODE_ENV');
@@ -274,7 +403,7 @@ function getBuildEnv(envs) {
     }, {});
     return envVars;
 }
-function buildInputConfig(entry, pkg, options, { tsConfigPath , tsCompilerOptions , dtsOnly  }) {
+function buildInputConfig(entry, pkg, options, cwd, { tsConfigPath , tsCompilerOptions  }, dtsOnly) {
     var _options_external;
     const externals = options.noExternal ? [] : [
         pkg.peerDependencies,
@@ -285,8 +414,13 @@ function buildInputConfig(entry, pkg, options, { tsConfigPath , tsCompilerOption
     ] : []));
     const { useTypescript , runtime , target: jscTarget , minify  } = options;
     const hasSpecifiedTsTarget = Boolean((tsCompilerOptions == null ? void 0 : tsCompilerOptions.target) && tsConfigPath);
+    const sizePlugin = sizeCollector.plugin(cwd);
+    const commonPlugins = [
+        shebang__default.default(),
+        sizePlugin
+    ];
     const plugins = (dtsOnly ? [
-        shebang(),
+        ...commonPlugins,
         useTypescript && require('rollup-plugin-dts').default({
             compilerOptions: _extends$1({}, tsCompilerOptions, {
                 declaration: true,
@@ -304,7 +438,8 @@ function buildInputConfig(entry, pkg, options, { tsConfigPath , tsCompilerOption
             })
         })
     ] : [
-        replace({
+        ...commonPlugins,
+        replace__default.default({
             values: getBuildEnv(options.env || []),
             preventAssignment: true
         }),
@@ -318,11 +453,10 @@ function buildInputConfig(entry, pkg, options, { tsConfigPath , tsCompilerOption
                 '.jsx'
             ]
         }),
-        commonjs({
+        commonjs__default.default({
             include: /node_modules\//
         }),
-        json(),
-        shebang(),
+        json__default.default(),
         rollupPluginSwc3.swc({
             include: /\.(m|c)?[jt]sx?$/,
             exclude: 'node_modules',
@@ -375,20 +509,28 @@ function buildInputConfig(entry, pkg, options, { tsConfigPath , tsCompilerOption
         }
     };
 }
-function buildOutputConfigs(options, pkg, { tsCompilerOptions , dtsOnly  }) {
+function hasEsmExport(exportPaths, tsCompilerOptions) {
+    let hasEsm = false;
+    for(const key in exportPaths){
+        const exportInfo = exportPaths[key];
+        if (exportInfo.import || exportInfo.module) {
+            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);
-    // respect if tsconfig.json has `esModuleInterop` config;
-    // add ESModule mark if cjs and ESModule are both generated;
-    // TODO: support `import` in exportCondition
-    const mainExport = exportPaths['.'];
-    const useEsModuleMark = Boolean(tsCompilerOptions.esModuleInterop || mainExport.main && mainExport.module);
+    // 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(config.rootDir, options.file);
-    const dtsDir = typings ? path.dirname(path.resolve(config.rootDir, typings)) : path.resolve(config.rootDir, 'dist');
+    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 dtsFile = file ? name + '.d.ts' : (exportCondition == null ? void 0 : exportCondition.name) ? path.resolve(dtsDir, (exportCondition.name === '.' ? 'index' : exportCondition.name) + '.d.ts') : typings && path.resolve(config.rootDir, typings);
+    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);
     // If there's dts file, use `output.file`
     const dtsPathConfig = dtsFile ? {
         file: dtsFile
@@ -402,79 +544,164 @@ function buildOutputConfigs(options, pkg, { tsCompilerOptions , dtsOnly  }) {
     }, {
         format,
         exports: 'named',
-        esModule: useEsModuleMark,
+        esModule: useEsModuleMark || 'if-default-prop',
+        interop: 'auto',
         freeze: false,
         strict: false,
         sourcemap: options.sourcemap
     });
 }
-function buildConfig(entry, pkg, bundleConfig, dtsOnly) {
+// build configs for each entry from package exports
+function buildEntryConfig(pkg, 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);
+            if (!source) return undefined;
+            if (dtsOnly && !(tsOptions == null ? void 0 : tsOptions.tsConfigPath)) return;
+            bundleConfig.exportCondition = {
+                source,
+                name: entryExport,
+                export: packageExports[entryExport]
+            };
+            const entry = resolveSourceFile(cwd, source);
+            const rollupConfig = buildConfig(entry, pkg, bundleConfig, 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;
     const { file  } = bundleConfig;
-    const useTypescript = isTypescript(entry);
+    const useTypescript = Boolean(tsOptions.tsConfigPath);
     const options = _extends$1({}, bundleConfig, {
         useTypescript
     });
-    let tsCompilerOptions = {};
-    let tsConfigPath;
-    if (useTypescript) {
-        const ts = resolveTypescript(config.rootDir);
-        tsConfigPath = path.resolve(config.rootDir, 'tsconfig.json');
-        if (fs$1.existsSync(tsConfigPath)) {
-            const basePath = tsConfigPath ? path.dirname(tsConfigPath) : config.rootDir;
-            const tsconfigJSON = ts.readConfigFile(tsConfigPath, ts.sys.readFile).config;
-            tsCompilerOptions = ts.parseJsonConfigFileContent(tsconfigJSON, ts.sys, basePath).options;
-        } else {
-            tsConfigPath = undefined;
-            exit('tsconfig.json is missing in your project directory');
-        }
-    }
-    const typescriptOptions = {
-        dtsOnly,
-        tsConfigPath,
-        tsCompilerOptions
-    };
-    const inputOptions = buildInputConfig(entry, pkg, options, typescriptOptions);
-    const outputExports = options.exportCondition ? getExportConditionDist(pkg, options.exportCondition.export) : getExportDist(pkg);
+    const inputOptions = buildInputConfig(entry, pkg, options, cwd, tsOptions, dtsOnly);
+    const outputExports = options.exportCondition ? getExportConditionDist(pkg, options.exportCondition.export, cwd) : getExportDist(pkg, cwd);
     let outputConfigs = [];
     // Generate dts job - single config
     if (dtsOnly) {
         outputConfigs = [
-            buildOutputConfigs(_extends$1({}, bundleConfig, {
+            buildOutputConfigs(pkg, _extends$1({}, bundleConfig, {
                 format: 'es',
                 useTypescript
-            }), pkg, typescriptOptions)
+            }), cwd, tsOptions, dtsOnly)
         ];
     } else {
         // multi outputs with specified format
         outputConfigs = outputExports.map((exportDist)=>{
-            return buildOutputConfigs(_extends$1({}, bundleConfig, {
+            return buildOutputConfigs(pkg, _extends$1({}, bundleConfig, {
                 file: exportDist.file,
                 format: exportDist.format,
                 useTypescript
-            }), pkg, typescriptOptions);
+            }), 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(_extends$1({}, bundleConfig, {
+                buildOutputConfigs(pkg, _extends$1({}, bundleConfig, {
                     file,
                     format: bundleConfig.format || fallbackFormat,
                     useTypescript
-                }), pkg, typescriptOptions)
+                }), cwd, tsOptions, dtsOnly)
             ];
         }
     }
     return {
         input: inputOptions,
         output: outputConfigs,
-        exportName: ((_options_exportCondition = options.exportCondition) == null ? void 0 : _options_exportCondition.name) || '.',
-        dtsOnly
+        exportName: ((_options_exportCondition = options.exportCondition) == null ? void 0 : _options_exportCondition.name) || '.'
     };
 }
 
+function asyncGeneratorStep$1(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$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+let hasLoggedTsWarning = false;
+function resolveTypescript(cwd) {
+    let ts;
+    const m = new module$1.Module('', undefined);
+    m.paths = module$1.Module._nodeModulePaths(cwd);
+    try {
+        ts = m.require('typescript');
+    } catch (_) {
+        console.error(_);
+        if (!hasLoggedTsWarning) {
+            hasLoggedTsWarning = true;
+            exit('Could not load TypeScript compiler. Try to install `typescript` as dev dependency');
+        }
+    }
+    return ts;
+}
+function resolveTsConfig(cwd) {
+    return _resolveTsConfig.apply(this, arguments);
+}
+function _resolveTsConfig() {
+    _resolveTsConfig = _async_to_generator$1(function*(cwd) {
+        let tsCompilerOptions = {};
+        let tsConfigPath;
+        const ts = resolveTypescript(cwd);
+        tsConfigPath = path.resolve(cwd, 'tsconfig.json');
+        if (yield fileExists(tsConfigPath)) {
+            const basePath = tsConfigPath ? path.dirname(tsConfigPath) : cwd;
+            const tsconfigJSON = ts.readConfigFile(tsConfigPath, ts.sys.readFile).config;
+            tsCompilerOptions = ts.parseJsonConfigFileContent(tsconfigJSON, ts.sys, basePath).options;
+        } else {
+            tsConfigPath = undefined;
+            return null;
+        }
+        return {
+            tsCompilerOptions,
+            tsConfigPath
+        };
+    });
+    return _resolveTsConfig.apply(this, arguments);
+}
+
+function logSizeStats() {
+    const stats = sizeCollector.getSizeStats();
+    const maxLength = Math.max(...stats.map(([filename])=>filename.length));
+    stats.forEach(([filename, prettiedSize])=>{
+        const padding = ' '.repeat(maxLength - filename.length);
+        const action = filename.endsWith('.d.ts') ? 'Typed' : 'Built';
+        logger.log(` ✓  ${action} ${filename}${padding} - ${prettiedSize}`);
+    });
+}
+
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -530,48 +757,11 @@ function _object_without_properties_loose(source, excluded) {
     }
     return target;
 }
-const SRC = 'src' // resolve from src/ directory
-;
-function logBuild(exportPath, dtsOnly, duration) {
-    logger.log(` ✓  ${dtsOnly ? 'Typed' : 'Built'} ${exportPath} ${formatDuration(duration)}`);
-}
 function assignDefault(options, name, defaultValue) {
     if (!(name in options) || options[name] == null) {
         options[name] = defaultValue;
     }
 }
-function resolveSourceFile(cwd, filename) {
-    return path.resolve(cwd, SRC, filename);
-}
-function getSourcePathFromExportPath(cwd, exportPath) {
-    return _getSourcePathFromExportPath.apply(this, arguments);
-}
-function _getSourcePathFromExportPath() {
-    _getSourcePathFromExportPath = // Map '.' -> './index.[ext]'
-    // Map './lite' -> './lite.[ext]'
-    // Return undefined if no match or if it's package.json exports
-    _async_to_generator(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 hasMultiEntryExport(pkg) {
     const packageExportsField = pkg.exports || {};
     if (typeof packageExportsField === 'string') return false;
@@ -583,58 +773,42 @@ function bundle(entryPath) {
 }
 function _bundle() {
     _bundle = _async_to_generator(function*(entryPath, _param = {}) {
-        var { cwd  } = _param, options = _object_without_properties_loose(_param, [
+        var { cwd: _cwd  } = _param, options = _object_without_properties_loose(_param, [
             "cwd"
         ]);
-        config.rootDir = path.resolve(process.cwd(), cwd || '');
+        const cwd = path.resolve(process.cwd(), _cwd || '');
         assignDefault(options, 'format', 'es');
         assignDefault(options, 'minify', false);
         assignDefault(options, 'target', 'es2015');
-        const pkg = yield getPackageMeta(config.rootDir);
+        const pkg = yield getPackageMeta(cwd);
         const packageExportsField = pkg.exports || {};
         const isMultiEntries = hasMultiEntryExport(pkg);
+        const tsConfig = yield resolveTsConfig(cwd);
+        const hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
+        const defaultTsOptions = {
+            tsConfigPath: tsConfig == null ? void 0 : tsConfig.tsConfigPath,
+            tsCompilerOptions: (tsConfig == null ? void 0 : tsConfig.tsCompilerOptions) || {}
+        };
         // Handle single entry file
         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(config.rootDir, '.')) || '';
-        }
-        function buildEntryConfig(packageExports, dtsOnly) {
-            return _buildEntryConfig.apply(this, arguments);
-        }
-        function _buildEntryConfig() {
-            _buildEntryConfig = _async_to_generator(function*(packageExports, dtsOnly) {
-                const configs = Object.keys(packageExports).map(/*#__PURE__*/ _async_to_generator(function*(entryExport) {
-                    const source = yield getSourcePathFromExportPath(config.rootDir, entryExport);
-                    if (!source) return undefined;
-                    if (dtsOnly && !isTypescript(source)) return;
-                    options.exportCondition = {
-                        source,
-                        name: entryExport,
-                        export: packageExports[entryExport]
-                    };
-                    const entry = resolveSourceFile(cwd, source);
-                    const rollupConfig = buildConfig(entry, pkg, options, dtsOnly);
-                    return rollupConfig;
-                }));
-                return (yield Promise.all(configs)).filter((n)=>Boolean(n));
-            });
-            return _buildEntryConfig.apply(this, arguments);
+            entryPath = entryPath || (yield getSourcePathFromExportPath(cwd, '.')) || '';
         }
         const bundleOrWatch = (rollupConfig)=>{
             const { input , exportName  } = rollupConfig;
-            const exportPath = getExportPath(pkg, exportName);
+            const exportPath = getExportPath(pkg, cwd, exportName);
             // Log original entry file relative path
-            const source = typeof input.input === 'string' ? path.relative(config.rootDir, input.input) : exportPath;
+            const source = typeof input.input === 'string' ? path.relative(cwd, input.input) : exportPath;
             const buildMetadata = {
                 source
             };
             if (options.watch) {
                 return Promise.resolve(runWatch(rollupConfig, buildMetadata));
             }
-            return runBundle(rollupConfig, buildMetadata);
+            return runBundle(rollupConfig);
         };
-        const hasSpecifiedEntryFile = entryPath ? (yield fileExists(entryPath)) && (yield fs.stat(entryPath)).isFile() : false;
+        const hasSpecifiedEntryFile = entryPath ? (yield fileExists(entryPath)) && (yield fs__default.default.stat(entryPath)).isFile() : false;
         if (!hasSpecifiedEntryFile && !isMultiEntries) {
             const err = new Error(`Entry file \`${entryPath}\` is not existed`);
             err.name = 'NOT_EXISTED';
@@ -646,30 +820,26 @@ function _bundle() {
         if (hasTypings) {
             options.dts = hasTypings;
         }
+        let result;
         if (isMultiEntries) {
-            const pkgExports = packageExportsField;
-            const buildConfigs = yield buildEntryConfig(pkgExports, false);
+            const buildConfigs = yield buildEntryConfig(pkg, options, cwd, defaultTsOptions, false);
             const assetsJobs = buildConfigs.map((rollupConfig)=>bundleOrWatch(rollupConfig));
-            const typesJobs = options.dts ? (yield buildEntryConfig(pkgExports, true)).map((rollupConfig)=>bundleOrWatch(rollupConfig)) : [];
-            return yield Promise.all(assetsJobs.concat(typesJobs));
-        }
-        // Generate types
-        if (isTypescript(entryPath) && options.dts) {
-            yield bundleOrWatch(buildConfig(entryPath, pkg, options, true));
+            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 rollupConfig = buildConfig(entryPath, pkg, options, false);
-        return bundleOrWatch(rollupConfig);
+        logSizeStats();
+        return result;
     });
     return _bundle.apply(this, arguments);
 }
-// . -> pkg name
-// ./lite -> <pkg name>/lite
-function getExportPath(pkg, exportName) {
-    const name = pkg.name || path.basename(config.rootDir);
-    if (exportName === '.' || !exportName) return name;
-    return path.join(name, exportName);
-}
-function runWatch({ input , output , dtsOnly  }, metadata) {
+function runWatch({ input , output  }, metadata) {
     const watchOptions = [
         _extends({}, input, {
             output: output,
@@ -681,7 +851,6 @@ function runWatch({ input , output , dtsOnly  }, metadata) {
         })
     ];
     const watcher = rollup.watch(watchOptions);
-    let startTime = Date.now();
     watcher.on('event', (event)=>{
         switch(event.code){
             case 'ERROR':
@@ -690,14 +859,11 @@ function runWatch({ input , output , dtsOnly  }, metadata) {
                 }
             case 'START':
                 {
-                    startTime = Date.now();
                     logger.log(`Start building ${metadata.source} ...`);
                     break;
                 }
             case 'END':
                 {
-                    const duration = Date.now() - startTime;
-                    logBuild(metadata.source, dtsOnly, duration);
                     break;
                 }
             default:
@@ -706,15 +872,11 @@ function runWatch({ input , output , dtsOnly  }, metadata) {
     });
     return watcher;
 }
-function runBundle({ input , output , dtsOnly  }, jobOptions) {
-    const startTime = Date.now();
+function runBundle({ input , output  }) {
     return rollup.rollup(input).then((bundle)=>{
         const writeJobs = output.map((options)=>bundle.write(options));
         return Promise.all(writeJobs);
-    }, onError).then(()=>{
-        const duration = Date.now() - startTime;
-        logBuild(jobOptions.source, dtsOnly, duration);
-    });
+    }, onError);
 }
 function onError(error) {
     if (!error) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunchee",
-  "version": "3.0.1",
+  "version": "3.1.1",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": {
     "bunchee": "./dist/cli.js"
@@ -31,6 +31,10 @@
     "dist",
     "*.md"
   ],
+  "prettier": {
+    "semi": false,
+    "singleQuote": true
+  },
   "engines": {
     "node": ">= 16"
   },
@@ -48,6 +52,7 @@
     "@swc/core": "1.3.46",
     "@swc/helpers": "0.5.0",
     "arg": "5.0.2",
+    "pretty-bytes": "5.6.0",
     "publint": "0.1.11",
     "rollup": "3.20.2",
     "rollup-plugin-dts": "5.3.0",