bunchee 4.2.10 → 4.3.0

package/README.md

@@ -35,39 +35,96 @@ npm install --save-dev bunchee typescript
 
 Create your library entry file and package.json.
 ```sh
-cd ./my-lib && mkdir src
-touch ./src/index.ts
-touch package.json
+cd ./my-lib
+mkdir src && touch ./src/index.ts
 ```
 
+#### Prepare
+
+```sh
+# Use bunchee to prepare package.json configuration
+npm bunchee --prepare
+# "If you're using other package manager such as pnpm"
+# pnpm bunchee --prepare
+
+# "Or use with npx"
+# npx bunchee@latest --prepare
+```
+
+Or you can checkout the following cases to configure your package.json.
+
+<details>
+  <summary> JavaScript</summary>
+
 Then use use the [exports field in package.json](https://nodejs.org/api/packages.html#exports-sugar) to configure different conditions and leverage the same functionality as other bundlers, such as webpack. The exports field allows you to define multiple conditions.
 ```json
 {
   "files": ["dist"],
   "exports": {
-    "import": "./dist/index.mjs",
-    "require": "./dist/index.cjs"
+    "import": "./dist/es/index.mjs",
+    "require": "./dist/cjs/index.cjs"
+  },
+  "scripts": {
+    "build": "bunchee"
+  }
+}
+```
+</details>
+
+<details>
+  <summary>TypeScript</summary>
+
+If you're build a TypeScript library, separate the types from the main entry file and specify the types path in package.json. When you're using `.mjs` or `.cjs` extensions with TypeScript and modern module resolution (above node16), TypeScript will require specific type declaration files like `.d.mts` or `.d.cts` to match the extension. `bunchee` can automatically generate them to match the types to match the condition and extensions. One example is to configure your exports like this in package.json:
+
+```json
+{
+  "files": ["dist"],
+  "exports": {
+    "import": {
+      "types": "./dist/es/index.d.mts",
+      "default": "./dist/es/index.mjs"
+    },
+    "require": {
+      "types": "./dist/cjs/index.d.cts",
+      "default": "./dist/cjs/index.cjs"
+    }
   },
   "scripts": {
     "build": "bunchee"
   }
 }
 ```
+</details>
+
+
+<details>
+  <summary>Hybrid (CJS & ESM) Module Resolution with TypeScript</summary>
+If you're using TypeScript with Node 10 and Node 16 module resolution, you can use the `types` field in package.json to specify the types path. Then `bunchee` will generate the types file with the same extension as the main entry file.
 
-If you want to use ESM package, change the `type` field in package.json to `module`, `bunchee` will change the output format to ESM.
 ```json
 {
-  "type": "module",
   "files": ["dist"],
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/es/index.mjs",
+  "types": "./dist/cjs/index.d.ts",
   "exports": {
-    "import": "./dist/index.mjs",
-    "require": "./dist/index.cjs"
+    "import": {
+      "types": "./dist/es/index.d.mts",
+      "default": "./dist/es/index.mjs"
+    },
+    "require": {
+      "types": "./dist/cjs/index.d.cts",
+      "default": "./dist/cjs/index.cjs"
+    }
   },
   "scripts": {
     "build": "bunchee"
   }
 }
 ```
+</details>
+
+#### Build
 
 Then files in `src` folders will be treated as entry files and match the export names in package.json. For example:
 `src/index.ts` will match the exports name `"."` or the only main export.
@@ -122,28 +179,6 @@ Then you need to add two entry files `index.ts` and `lite.ts` in project root di
 
 It will also look up for `index.<ext>` file under the directory having the name of the export path. For example, if you have `"./lite": "./dist/lite.js"` in exports field, then it will look up for `./lite/index.js` as the entry file as well.
 
-### TypeScript Declaration
-
-When you're using `.mjs` or `.cjs` extensions with TypeScript and modern module resolution (above node16), TypeScript will require specific type declaration files like `.d.mts` or `.d.cts` to match the extension.
-`bunchee` can automatically generate them to match the types to match the condition and extensions. One example is to configure your exports like this in package.json:
-
-```json
-{
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
-    }
-  }
-}
-```
-
 ### Multiple Runtime
 
 For exports condition like `react-native`, `react-server` and `edge-light` as they're special platforms, they could have different exports or different code conditions. In this case bunchee provides an override input source file convention if you want to build them as different code bundle.
@@ -322,7 +357,6 @@ This will match the export names `"foo"` and `"bar"` and will be treated as the
 {
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
     "./foo": {
@@ -380,26 +414,6 @@ output
 export default "hello world"
 ```
 
-### TypeScript
-
-By default bunchee includes Typescript v3.9.x inside as a dependency. If you want to use your own version, just install typescript as another dev dependency then bunchee will automatically pick it.
-
-```sh
-npm i -D bunchee typescript
-```
-
-Create `tsconfig.json` to specify any compiler options for TypeScript.
-
-This library requires at least TypeScript 4.1.x.
-
-Adding `"types"` or `"typing"` field in your package.json, types will be generated with that path.
-
-```json
-{
-  "types": "dist/types/index.d.ts"
-}
-```
-
 ### Node.js API
 
 ```ts

package/dist/bin/cli.js

@@ -1,16 +1,41 @@
 #!/usr/bin/env node
 var path = require('path');
 var arg = require('arg');
-var fs = require('fs/promises');
+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 = [
+    'js',
+    'cjs',
+    'mjs',
+    'jsx',
+    'ts',
+    'tsx',
+    'cts',
+    'mts'
+];
+const SRC = 'src';
+const dtsExtensionsMap = {
+    js: 'd.ts',
+    cjs: 'd.cts',
+    mjs: 'd.mts'
+};
+const tsExtensions = [
+    'ts',
+    'tsx',
+    'cts',
+    'mts'
+];
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -64,25 +89,29 @@ picocolors.exports.createColors = createColors;
 var picocolorsExports = picocolors.exports;
 var pc = /*@__PURE__*/ getDefaultExportFromCjs(picocolorsExports);
 
+const defaultColorFn = (text)=>text;
+function color(prefixColor) {
+    return pc.isColorSupported ? pc[prefixColor] : defaultColorFn;
+}
 const logger = {
     log (...arg) {
-        console.log('  ', ...arg);
+        console.log(...arg);
     },
     warn (...arg) {
-        console.warn(' ⚠️', ...arg);
+        console.warn(color('yellow')('⚠️'), ...arg);
     },
     error (...arg) {
-        console.error(' ⨯', ...arg);
+        console.error(color('red')('⨯'), ...arg);
     },
     info (...arg) {
-        console.log(' ✓', ...arg);
+        console.log(color('green')('✓'), ...arg);
     }
 };
 function paint(prefix, prefixColor, ...arg) {
     if (pc.isColorSupported) {
-        console.log(' ' + pc[prefixColor](prefix), ...arg);
+        console.log(pc[prefixColor](prefix), ...arg);
     } else {
-        console.log(' ' + prefix, ...arg);
+        console.log(prefix, ...arg);
     }
 }
 
@@ -97,15 +126,19 @@ 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;
 }
+function isTypescriptFile(filename) {
+    const ext = path__default.default.extname(filename).slice(1);
+    return tsExtensions.includes(ext);
+}
 async function fileExists(filePath) {
     try {
-        await fs__default.default.access(filePath);
+        await fsp__default.default.access(filePath);
         return true;
     } catch (err) {
         if (err.code === 'ENOENT') {
@@ -114,8 +147,209 @@ async function fileExists(filePath) {
         throw err;
     }
 }
+const hasAvailableExtension = (filename)=>availableExtensions.includes(path__default.default.extname(filename).slice(1));
+const baseNameWithoutExtension = (filename)=>path__default.default.basename(filename, path__default.default.extname(filename));
+
+var version = "4.3.0";
 
-var version = "4.2.10";
+function relativify(path) {
+    return path.startsWith('.') ? path : `./${path}`;
+}
+
+const DIST = 'dist';
+// Output with posix style in package.json
+function getDistPath(...subPaths) {
+    return `./${DIST}/${subPaths.join('/')}`;
+}
+const normalizeBaseNameToExportName = (baseName)=>{
+    return /^index(\.|$)/.test(baseName) ? '.' : relativify(baseName);
+};
+function createExportCondition(exportName, sourceFile, moduleType) {
+    const isTsSourceFile = isTypescriptFile(sourceFile);
+    let cjsExtension = 'js';
+    if (moduleType === 'module') {
+        cjsExtension = 'cjs';
+    }
+    if (isTsSourceFile) {
+        return {
+            import: {
+                types: getDistPath('es', `${exportName}.d.mts`),
+                default: getDistPath('es', `${exportName}.mjs`)
+            },
+            require: {
+                types: getDistPath('cjs', `${exportName}.${dtsExtensionsMap[cjsExtension]}`),
+                default: getDistPath('cjs', `${exportName}.${cjsExtension}`)
+            }
+        };
+    }
+    return {
+        import: getDistPath(`${exportName}.mjs`),
+        require: getDistPath(`${exportName}.${cjsExtension}`)
+    };
+}
+async function collectSourceEntries(sourceFolderPath) {
+    const bins = new Map();
+    const exportsEntries = new Map();
+    const entryFileDirentList = await fsp__default.default.readdir(sourceFolderPath, {
+        withFileTypes: true
+    });
+    for (const dirent of entryFileDirentList){
+        if (dirent.isDirectory()) {
+            if (dirent.name === 'bin') {
+                const binDirentList = await fsp__default.default.readdir(path__default.default.join(sourceFolderPath, dirent.name), {
+                    withFileTypes: true
+                });
+                for (const binDirent of binDirentList){
+                    if (binDirent.isFile()) {
+                        const binFile = path__default.default.join(sourceFolderPath, dirent.name, binDirent.name);
+                        const binName = baseNameWithoutExtension(binDirent.name);
+                        if (fs__default.default.existsSync(binFile)) {
+                            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}`);
+                    if (fs__default.default.existsSync(indexFile)) {
+                        exportsEntries.set(dirent.name, indexFile);
+                        break;
+                    }
+                }
+            }
+        } else if (dirent.isFile()) {
+            const isAvailableExtension = availableExtensions.includes(path__default.default.extname(dirent.name).slice(1));
+            if (isAvailableExtension) {
+                const baseName = baseNameWithoutExtension(dirent.name);
+                const isBinFile = baseName === 'bin';
+                if (isBinFile) {
+                    bins.set('.', dirent.name);
+                } else {
+                    if (hasAvailableExtension(dirent.name)) {
+                        exportsEntries.set(baseName, dirent.name);
+                    }
+                }
+            }
+        }
+    }
+    return {
+        bins,
+        exportsEntries
+    };
+}
+function createExportConditionPair(exportName, sourceFile, moduleType) {
+    // <exportName>.<specialCondition>
+    let specialCondition;
+    let exportCondName;
+    if (exportName.indexOf('.') > 0) {
+        const [originExportName, specialConditionName] = exportName.split('.');
+        specialCondition = {
+            [specialConditionName]: getDistPath('es', `${originExportName}-${specialConditionName}.mjs`)
+        };
+        exportCondName = normalizeBaseNameToExportName(originExportName);
+        return [
+            exportCondName,
+            specialCondition
+        ];
+    }
+    exportCondName = normalizeBaseNameToExportName(exportName);
+    const exportCond = createExportCondition(exportName, sourceFile, moduleType);
+    return [
+        exportCondName,
+        exportCond
+    ];
+}
+async function prepare(cwd) {
+    const sourceFolder = path__default.default.resolve(cwd, SRC);
+    if (!fs__default.default.existsSync(sourceFolder)) {
+        logger.error(`Source folder ${sourceFolder} does not exist. Cannot proceed to configure \`exports\` field.`);
+        process.exit(1);
+    }
+    const pkgJsonPath = path__default.default.join(cwd, 'package.json');
+    let pkgJson = {};
+    if (fs__default.default.existsSync(pkgJsonPath)) {
+        const pkgJsonString = await fsp__default.default.readFile(pkgJsonPath, 'utf-8');
+        pkgJson = JSON.parse(pkgJsonString);
+    }
+    // configure `files` field with `dist`
+    const files = pkgJson.files || [];
+    if (!files.includes(DIST)) {
+        files.push(DIST);
+    }
+    pkgJson.files = files;
+    let isUsingTs = false;
+    // 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.`);
+        }
+    }
+    // Configure as ESM package by default if there's no `type` field
+    if (!pkgJson.type) {
+        pkgJson.type = 'module';
+    }
+    if (bins.size > 0) {
+        logger.log('Discovered binaries entries:');
+        const maxLengthOfBinName = Math.max(...Array.from(bins.keys()).map((binName)=>normalizeBaseNameToExportName(binName).length));
+        for (const [binName, binFile] of bins.entries()){
+            const spaces = ' '.repeat(Math.max(maxLengthOfBinName - normalizeBaseNameToExportName(binName).length, 0));
+            logger.log(`  ${normalizeBaseNameToExportName(binName)}${spaces}: ${binFile}`);
+        }
+        if (bins.size === 1 && bins.has('.')) {
+            pkgJson.bin = getDistPath('bin', 'index.js');
+        } else {
+            pkgJson.bin = {};
+            for (const [binName] of bins.entries()){
+                pkgJson.bin[binName === '.' ? pkgJson.name : binName] = getDistPath('bin', binName + '.js');
+            }
+        }
+    }
+    if (exportsEntries.size > 0) {
+        logger.log('Discovered exports entries:');
+        const maxLengthOfExportName = Math.max(...Array.from(exportsEntries.keys()).map((exportName)=>normalizeBaseNameToExportName(exportName).length));
+        for (const [exportName, exportFile] of exportsEntries.entries()){
+            const spaces = ' '.repeat(Math.max(maxLengthOfExportName - normalizeBaseNameToExportName(exportName).length, 0));
+            logger.log(`  ${normalizeBaseNameToExportName(exportName)}${spaces}: ${exportFile}`);
+        }
+        const pkgExports = {};
+        for (const [exportName, sourceFile] of exportsEntries.entries()){
+            const [key, value] = createExportConditionPair(exportName, sourceFile, pkgJson.type);
+            pkgExports[key] = {
+                ...value,
+                ...pkgExports[key]
+            };
+        }
+        // Configure node10 module resolution
+        if (exportsEntries.has('index')) {
+            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 (isUsingTs) {
+                pkgJson.types = isESM ? mainExport.import.types : mainExport.require.types;
+            }
+        }
+        // Assign the properties by order: files, main, module, types, exports
+        if (Object.keys(pkgExports).length > 0) {
+            pkgJson.exports = pkgExports;
+        }
+    }
+    await fsp__default.default.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+    logger.info('Configured `exports` in package.json');
+}
 
 const helpMessage = `
 Usage: bunchee [options]
@@ -127,6 +361,7 @@ Options:
   -o, --output <file>    specify output filename
   -f, --format <format>  type of output (esm, amd, cjs, iife, umd, system), default: esm
   -h, --help             output usage information
+  --prepare              auto configure package.json exports for building
   --external <mod>       specify an external dependency, separate by comma
   --no-external          do not bundle external dependencies
   --target <target>      js features target: swc target es versions. default: es2015
@@ -172,6 +407,7 @@ function parseCliArgs(argv) {
         '--env': String,
         '--external': String,
         '--no-external': Boolean,
+        '--prepare': Boolean,
         '-h': '--help',
         '-v': '--version',
         '-w': '--watch',
@@ -197,7 +433,8 @@ function parseCliArgs(argv) {
         runtime: args['--runtime'],
         target: args['--target'],
         external: !!args['--no-external'] ? null : args['--external'],
-        env: args['--env']
+        env: args['--env'],
+        prepare: !!args['--prepare']
     };
     return parsedArgs;
 }
@@ -225,6 +462,9 @@ async function run(args) {
     if (args.help) {
         return help();
     }
+    if (args.prepare) {
+        return await prepare(cwd);
+    }
     const entry = source ? path__default.default.resolve(cwd, source) : '';
     try {
         await bunchee.bundle(entry, bundleConfig);
@@ -241,7 +481,7 @@ async function run(args) {
         return;
     }
     // build mode
-    console.log();
+    logger.log();
     paint('✓', 'green', `bunchee ${version} build completed`);
     await lintPackage(cwd);
 }

package/dist/index.d.ts

@@ -1,6 +1,9 @@
 import { JscTarget } from '@swc/types';
 import { OutputOptions } from 'rollup';
 
+type ExportCondition = string | {
+    [key: string]: ExportCondition | string;
+};
 type BundleConfig = {
     file?: string;
     cwd?: string;
@@ -13,6 +16,20 @@ type BundleConfig = {
     env?: string[];
     dts?: boolean;
     runtime?: string;
+    pkg?: PackageMetadata;
+};
+type PackageMetadata = {
+    name?: string;
+    main?: string;
+    bin?: string | Record<string, string>;
+    module?: string;
+    type?: 'commonjs' | 'module';
+    dependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    peerDependenciesMeta?: Record<string, Record<string, string>>;
+    exports?: string | Record<string, ExportCondition>;
+    types?: string;
+    typings?: string;
 };
 
 declare function bundle(entryPath: string, { cwd: _cwd, ...options }?: BundleConfig): Promise<any>;

package/dist/index.js

@@ -52,12 +52,11 @@ const availableExportConventions = [
     'edge-light'
 ];
 const availableESExtensionsRegex = /\.(m|c)?[jt]sx?$/;
-const dtsExtensionRegex = /\.d\.(m|c)?ts$/;
 const SRC = 'src';
-const dtsExtensions = {
-    js: '.d.ts',
-    cjs: '.d.cts',
-    mjs: '.d.mts'
+const dtsExtensionsMap = {
+    js: 'd.ts',
+    cjs: 'd.cts',
+    mjs: 'd.mts'
 };
 const disabledWarnings = new Set([
     'MIXED_EXPORTS',
@@ -120,27 +119,24 @@ picocolors.exports.createColors = createColors;
 var picocolorsExports = picocolors.exports;
 var pc = /*@__PURE__*/ getDefaultExportFromCjs(picocolorsExports);
 
+const defaultColorFn = (text)=>text;
+function color(prefixColor) {
+    return pc.isColorSupported ? pc[prefixColor] : defaultColorFn;
+}
 const logger = {
     log (...arg) {
-        console.log('  ', ...arg);
+        console.log(...arg);
     },
     warn (...arg) {
-        console.warn(' ⚠️', ...arg);
+        console.warn(color('yellow')('⚠️'), ...arg);
     },
     error (...arg) {
-        console.error(' ⨯', ...arg);
+        console.error(color('red')('⨯'), ...arg);
     },
     info (...arg) {
-        console.log(' ✓', ...arg);
+        console.log(color('green')('✓'), ...arg);
     }
 };
-function paint(prefix, prefixColor, ...arg) {
-    if (pc.isColorSupported) {
-        console.log(' ' + pc[prefixColor](prefix), ...arg);
-    } else {
-        console.log(' ' + prefix, ...arg);
-    }
-}
 
 function exit(err) {
     logger.error(err);
@@ -209,7 +205,7 @@ async function getSourcePathFromExportPath(cwd, exportPath, exportType) {
     return;
 }
 // Unlike path.basename, forcedly removing extension
-function filenameWithoutExtension(file) {
+function filePathWithoutExtension(file) {
     return file ? file.replace(new RegExp(`${path__default.default.extname(file)}$`), '') : undefined;
 }
 const nonNullable = (n)=>Boolean(n);
@@ -223,8 +219,8 @@ function resolveTypescript(cwd) {
     m.paths = module$1.Module._nodeModulePaths(cwd);
     try {
         ts = m.require('typescript');
-    } catch (_) {
-        console.error(_);
+    } catch (e) {
+        console.error(e);
         if (!hasLoggedTsWarning) {
             hasLoggedTsWarning = true;
             exit('Could not load TypeScript compiler. Try to install `typescript` as dev dependency');
@@ -610,7 +606,7 @@ const getExportTypeDist = (parsedExportCondition, cwd)=>{
             continue;
         }
         const ext = path.extname(filePath).slice(1);
-        const typeFile = getDistPath(`${filenameWithoutExtension(filePath) || ''}${dtsExtensions[ext]}`, cwd);
+        const typeFile = getDistPath(`${filePathWithoutExtension(filePath) || ''}.${dtsExtensionsMap[ext]}`, cwd);
         if (existed.has(typeFile)) {
             continue;
         }
@@ -691,7 +687,7 @@ function getExportConditionDist(pkg, parsedExportCondition, cwd) {
     return dist;
 }
 function getTypeFilePath(entryFilePath, exportCondition, cwd) {
-    const name = filenameWithoutExtension(entryFilePath);
+    const name = filePathWithoutExtension(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');
@@ -727,22 +723,20 @@ function getBuildEnv(envs) {
     return envVars;
 }
 /**
- * return { '<pkg>/<export>': '<absolute source path> }
- */ function getEntriesAlias(entries) {
+ * return { '<absolute source path>': '<pkg>/<export>' }
+ */ function getReversedAlias(entries) {
     const alias = {};
     for (const [entryImportPath, exportCondition] of Object.entries(entries)){
-        alias[entryImportPath] = exportCondition.source;
+        const exportType = entryImportPath.split('.')[1] // e.g. index.react-server, pick react-server
+        ;
+        if (!exportType) {
+            alias[exportCondition.source] = entryImportPath;
+        }
     }
     return alias;
 }
-async function buildInputConfig(entry, entries, pkg, options, cwd, { tsConfigPath, tsCompilerOptions }, pluginContext, dts) {
-    const entriesAlias = getEntriesAlias(entries);
-    const reversedAlias = {};
-    for (const [key, value] of Object.entries(entriesAlias)){
-        if (value !== entry) {
-            reversedAlias[value] = key;
-        }
-    }
+async function buildInputConfig(entry, options, buildContext, dts) {
+    const { entries, pkg, cwd, tsOptions: { tsConfigPath, tsCompilerOptions }, pluginContext } = buildContext;
     const hasNoExternal = options.external === null;
     var _options_external;
     const externals = hasNoExternal ? [] : [
@@ -750,7 +744,8 @@ async function buildInputConfig(entry, entries, pkg, options, cwd, { tsConfigPat
         pkg.dependencies,
         pkg.peerDependenciesMeta
     ].filter((n)=>Boolean(n)).map((o)=>Object.keys(o)).reduce((a, b)=>a.concat(b), []).concat((_options_external = options.external) != null ? _options_external : []);
-    for (const [exportImportPath, entryFilePath] of Object.entries(entriesAlias)){
+    for (const [exportImportPath, exportCondition] of Object.entries(entries)){
+        const entryFilePath = exportCondition.source;
         if (entryFilePath !== entry) {
             externals.push(exportImportPath);
             externals.push(entryFilePath);
@@ -782,12 +777,16 @@ async function buildInputConfig(entry, entries, pkg, options, cwd, { tsConfigPat
         inlineSourcesContent: false,
         isModule: true
     };
-    const sizePlugin = pluginContext.sizeCollector.plugin(cwd);
+    const sizePlugin = pluginContext.outputState.plugin(cwd);
     // common plugins for both dts and ts assets that need to be processed
     const commonPlugins = [
         sizePlugin,
         aliasEntries({
-            entries: reversedAlias
+            entries: {
+                ...pluginContext.entriesAlias,
+                // Do not alias current alias of package
+                [entry]: null
+            }
         })
     ];
     const typesPlugins = [
@@ -960,14 +959,15 @@ function createSplitChunks(dependencyGraphMap, entryFiles) {
         return;
     };
 }
-function buildOutputConfigs(entries, pkg, exportPaths, options, exportCondition, cwd, { tsCompilerOptions }, pluginContext, dts) {
+function buildOutputConfigs(options, exportCondition, buildContext, dts) {
     const { format } = options;
+    const { entries, pkg, exportPaths, cwd, tsOptions: { tsCompilerOptions }, pluginContext } = buildContext;
     // 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');
-    const name = filenameWithoutExtension(file);
+    const name = filePathWithoutExtension(file);
     // TODO: simplify dts file name detection
     const dtsFile = file ? file : exportCondition.export['types'] ? path.resolve(cwd, exportCondition.export['types']) : path.resolve(dtsDir, (exportCondition.name === '.' ? 'index' : exportCondition.name) + '.d.ts');
     const dtsPathConfig = {
@@ -995,10 +995,11 @@ function buildOutputConfigs(entries, pkg, exportPaths, options, exportCondition,
         entryFileNames: path.basename(outputFile)
     };
 }
-async function buildEntryConfig(entries, pkg, exportPaths, bundleConfig, cwd, tsOptions, pluginContext, dts) {
+async function buildEntryConfig(bundleConfig, pluginContext, dts) {
     const configs = [];
+    const { entries } = pluginContext;
     for (const exportCondition of Object.values(entries)){
-        const rollupConfig = buildConfig(entries, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, pluginContext, dts);
+        const rollupConfig = buildConfig(bundleConfig, exportCondition, pluginContext, dts);
         configs.push(rollupConfig);
     }
     return await Promise.all(configs);
@@ -1040,7 +1041,9 @@ async function buildEntryConfig(entries, pkg, exportPaths, bundleConfig, cwd, ts
             name: entryExport,
             export: exportCondForType
         };
-        const entryImportPath = path__default.default.join(pkg.name || '', exportCondition.name) + (exportType ? `.${exportType}` : '');
+        const nameWithExportPath = pkg.name ? path__default.default.join(pkg.name, exportCondition.name) : exportCondition.name;
+        const needsDelimiter = !nameWithExportPath.endsWith('.') && exportType;
+        const entryImportPath = nameWithExportPath + (needsDelimiter ? '.' : '') + exportType;
         entries[entryImportPath] = exportCondition;
     }
     const binaryExports = pkg.bin;
@@ -1090,47 +1093,48 @@ async function buildEntryConfig(entries, pkg, exportPaths, bundleConfig, cwd, ts
     await Promise.all(collectEntriesPromises);
     return entries;
 }
-async function buildConfig(entries, pkg, exportPaths, bundleConfig, exportCondition, cwd, tsOptions, pluginContext, dts) {
+async function buildConfig(bundleConfig, exportCondition, pluginContext, dts) {
     const { file } = bundleConfig;
+    const { pkg, cwd, tsOptions } = pluginContext;
     const useTypescript = Boolean(tsOptions.tsConfigPath);
     const options = {
         ...bundleConfig,
         useTypescript
     };
     const entry = exportCondition.source;
-    const inputOptions = await buildInputConfig(entry, entries, pkg, options, cwd, tsOptions, pluginContext, dts);
+    const inputOptions = await buildInputConfig(entry, options, pluginContext, dts);
     const outputExports = getExportConditionDist(pkg, exportCondition, cwd);
     let outputConfigs = [];
     // Generate dts job - single config
     if (dts) {
         const typeOutputExports = getExportTypeDist(exportCondition, cwd);
-        outputConfigs = typeOutputExports.map((typeFile)=>buildOutputConfigs(entries, pkg, exportPaths, {
+        outputConfigs = typeOutputExports.map((typeFile)=>buildOutputConfigs({
                 ...bundleConfig,
                 format: 'es',
                 useTypescript,
                 file: typeFile
-            }, exportCondition, cwd, tsOptions, pluginContext, dts));
+            }, exportCondition, pluginContext, dts));
     } else {
         // multi outputs with specified format
         outputConfigs = outputExports.map((exportDist)=>{
-            return buildOutputConfigs(entries, pkg, exportPaths, {
+            return buildOutputConfigs({
                 ...bundleConfig,
                 file: exportDist.file,
                 format: exportDist.format,
                 useTypescript
-            }, exportCondition, cwd, tsOptions, pluginContext, dts);
+            }, exportCondition, pluginContext, dts);
         });
         // CLI output option is always prioritized
         if (file) {
             var _outputExports_;
             const fallbackFormat = (_outputExports_ = outputExports[0]) == null ? void 0 : _outputExports_.format;
             outputConfigs = [
-                buildOutputConfigs(entries, pkg, exportPaths, {
+                buildOutputConfigs({
                     ...bundleConfig,
                     file,
                     format: bundleConfig.format || fallbackFormat,
                     useTypescript
-                }, exportCondition, cwd, tsOptions, pluginContext, dts)
+                }, exportCondition, pluginContext, dts)
             ];
         }
     }
@@ -1141,7 +1145,11 @@ async function buildConfig(entries, pkg, exportPaths, bundleConfig, exportCondit
     };
 }
 
-function createChunkSizeCollector({ entries }) {
+function relativify(path) {
+    return path.startsWith('.') ? path : `./${path}`;
+}
+
+function createOutputState({ entries }) {
     const sizeStats = new Map();
     function addSize({ fileName, size, sourceFileName, exportPath }) {
         if (!sizeStats.has(exportPath)) {
@@ -1157,8 +1165,8 @@ function createChunkSizeCollector({ entries }) {
         }
     }
     const reversedMapping = new Map();
-    Object.entries(entries).forEach(([, entry])=>{
-        reversedMapping.set(entry.source, entry.name || '.');
+    Object.entries(entries).forEach(([resolvedExportName, entry])=>{
+        reversedMapping.set(entry.source, resolvedExportName);
     });
     return {
         plugin: (cwd)=>{
@@ -1189,20 +1197,70 @@ function createChunkSizeCollector({ entries }) {
         }
     };
 }
-function logSizeStats(sizeCollector) {
+function isBin(filename) {
+    return filename === 'bin' || filename.startsWith('bin/');
+}
+function isTypeFile(filename) {
+    return filename.endsWith('.d.ts') || filename.endsWith('.d.mts') || filename.endsWith('.d.cts');
+}
+function normalizeExportName(exportName) {
+    const isBinary = isBin(exportName);
+    let result = exportName;
+    const isSubpathExport = exportName.includes('/');
+    const isSpecialExport = exportName.includes('.');
+    if (isBinary) {
+        result = (exportName.replace(/bin(\/|$)/, '') || '.') + ' (bin)';
+    } else if (isSubpathExport || isSpecialExport) {
+        const subExportName = exportName.split('/')[1] || exportName;
+        if (subExportName.includes('.') && subExportName !== '.') {
+            const [originExportName, specialCondition] = subExportName.split('.');
+            result = (isSubpathExport ? relativify(originExportName) : '.') + ' (' + specialCondition + ')';
+        } else {
+            result = isSubpathExport ? relativify(subExportName) : '.';
+        }
+    } else {
+        result = '.';
+    }
+    return result;
+}
+function getExportNameWithoutExportCondition(exportName) {
+    return exportName.includes('.') ? exportName.split('.')[0] : exportName;
+}
+function logOutputState(sizeCollector) {
     const stats = sizeCollector.getSizeStats();
     const allFileNameLengths = Array.from(stats.values()).flat(1).map(([filename])=>filename.length);
-    const maxLength = Math.max(...allFileNameLengths);
-    [
+    const maxFilenameLength = Math.max(...allFileNameLengths);
+    const statsArray = [
         ...stats.entries()
-    ].sort(([a], [b])=>a.length - b.length).forEach(([, filesList])=>{
-        filesList.forEach((item)=>{
+    ].sort(([a], [b])=>{
+        const comp = getExportNameWithoutExportCondition(a).length - getExportNameWithoutExportCondition(b).length;
+        return comp === 0 ? a.localeCompare(b) : comp;
+    });
+    const maxLengthOfExportName = Math.max(...statsArray.map(([exportName])=>normalizeExportName(exportName).length));
+    console.log(pc.underline('Exports'), ' '.repeat(Math.max(maxLengthOfExportName - 'Exports'.length, 0)), pc.underline('File'), ' '.repeat(Math.max(maxFilenameLength - 'File'.length, 0)), pc.underline('Size'));
+    statsArray.forEach(([exportName, filesList])=>{
+        // sort by file type, first js files then types, js/mjs/cjs are prioritized than .d.ts/.d.mts/.d.cts
+        filesList.sort(([a], [b])=>{
+            const aIsType = isTypeFile(a);
+            const bIsType = isTypeFile(b);
+            if (aIsType && bIsType) {
+                return 0;
+            }
+            if (aIsType) {
+                return 1;
+            }
+            if (bIsType) {
+                return -1;
+            }
+            return 0;
+        }).forEach((item, index)=>{
             const [filename, , size] = item;
-            const padding = ' '.repeat(maxLength - filename.length);
-            const isTypeFile = dtsExtensionRegex.test(filename);
-            const action = isTypeFile ? '[types]' : '[chunk]';
+            const normalizedExportName = normalizeExportName(exportName);
+            const prefix = index === 0 ? normalizedExportName + ' '.repeat(maxLengthOfExportName - normalizedExportName.length) : ' '.repeat(maxLengthOfExportName);
+            const sizePadding = ' '.repeat(maxFilenameLength - filename.length);
             const prettiedSize = prettyBytes__default.default(size);
-            paint('  ' + action, isTypeFile ? 'blue' : 'white', `${filename}${padding}  - ${prettiedSize}`);
+            const isType = isTypeFile(filename);
+            console.log(` ${prefix} ${pc[isType ? 'dim' : 'bold'](filename)}${sizePadding}  ${prettiedSize}`);
         });
     });
 }
@@ -1233,7 +1291,7 @@ async function getExportables(cwd, excludeKeys) {
 function mapWildcard(wildcardExports, exportables) {
     return exportables.map((exportable)=>{
         const isFile = exportable.includes('.');
-        const filename = isFile ? filenameWithoutExtension(exportable) : exportable;
+        const filename = isFile ? filePathWithoutExtension(exportable) : exportable;
         return {
             [`./${filename}`]: Object.fromEntries(Object.entries(wildcardExports['./*']).map(([key, value])=>[
                     key,
@@ -1320,12 +1378,9 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
         const { input, exportName } = rollupConfig;
         const exportPath = getExportPath(pkg, cwd, exportName);
         // Log original entry file relative path
-        const source = typeof input.input === 'string' ? path.relative(cwd, input.input) : exportPath;
-        const buildMetadata = {
-            source
-        };
+        typeof input.input === 'string' ? path.relative(cwd, input.input) : exportPath;
         if (options.watch) {
-            return Promise.resolve(runWatch(rollupConfig, buildMetadata));
+            return Promise.resolve(runWatch(rollupConfig));
         }
         return runBundle(rollupConfig);
     };
@@ -1337,21 +1392,30 @@ async function bundle(entryPath, { cwd: _cwd, ...options } = {}) {
         return Promise.reject(err);
     }
     const entries = await collectEntries(pkg, entryPath, exportPaths, cwd);
-    const sizeCollector = createChunkSizeCollector({
+    const sizeCollector = createOutputState({
         entries
     });
-    const pluginContext = {
-        sizeCollector,
-        moduleDirectiveLayerMap: new Map()
+    const entriesAlias = getReversedAlias(entries);
+    const buildContext = {
+        entries,
+        pkg,
+        exportPaths,
+        cwd,
+        tsOptions: defaultTsOptions,
+        pluginContext: {
+            outputState: sizeCollector,
+            moduleDirectiveLayerMap: new Map(),
+            entriesAlias
+        }
     };
-    const buildConfigs = await buildEntryConfig(entries, pkg, exportPaths, options, cwd, defaultTsOptions, pluginContext, false);
+    const buildConfigs = await buildEntryConfig(options, buildContext, false);
     const assetsJobs = buildConfigs.map((rollupConfig)=>bundleOrWatch(rollupConfig));
-    const typesJobs = hasTsConfig ? (await buildEntryConfig(entries, pkg, exportPaths, options, cwd, defaultTsOptions, pluginContext, true)).map((rollupConfig)=>bundleOrWatch(rollupConfig)) : [];
+    const typesJobs = hasTsConfig ? (await buildEntryConfig(options, buildContext, true)).map((rollupConfig)=>bundleOrWatch(rollupConfig)) : [];
     const result = await Promise.all(assetsJobs.concat(typesJobs));
     if (result.length === 0) {
         logger.warn('The "src" directory does not contain any entry files. ' + 'For proper usage, please refer to the following link: ' + 'https://github.com/huozhi/bunchee#usage');
     }
-    logSizeStats(sizeCollector);
+    logOutputState(sizeCollector);
     return result;
 }
 function runWatch({ input, output }, metadata) {
@@ -1375,7 +1439,6 @@ function runWatch({ input, output }, metadata) {
                 }
             case 'START':
                 {
-                    logger.log(`Start building ${metadata.source} ...`);
                     break;
                 }
             case 'END':

package/package.json

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