bunchee 6.2.0 → 6.3.1

package/README.md

@@ -14,8 +14,11 @@
   </a>
 </p>
 
-**bunchee** is a zero configuration bundler makes bundling JS/TS library effortless. It's built on top of Rollup and SWC ⚡️, allowing you to focus on writing code and generating multiple bundles (CommonJS or ESModule) at the same time.
-It uses the standard exports configuration in `package.json` as the only source of truth, and uses entry file conventions to match your exports and build them into bundles.
+---
+
+**bunchee** is a zero-configuration bundler designed to streamline package building by adhering to the `exports` field in your **package.json**. Powered by Rollup and SWC ⚡️, it generates output based on your config, supporting both CommonJS and ESModules.
+
+By using the standard `exports` configuration as the single source of truth, **bunchee** automatically aligns entry file conventions with your exports, ensuring seamless and efficient builds.
 
 ## Quick Start
 
@@ -36,14 +39,14 @@ mkdir src && touch ./src/index.ts && touch package.json
 
 Add the exports in `package.json`.
 
-```json
+```json5
 {
-  "name": "coffee",
-  "type": "module",
-  "main": "./dist/index.js",
-  "scripts": {
-    "build": "bunchee"
-  }
+  name: 'coffee',
+  type: 'module',
+  main: './dist/index.js',
+  scripts: {
+    build: 'bunchee',
+  },
 }
 ```
 
@@ -53,192 +56,118 @@ Add the exports in `package.json`.
 npm run build
 ```
 
-Then files in `src` folders will be treated as entry files and match the export names in package.json.
-Simply like Node.js module resolution, each export name will match the file in `src/` directory.
-
-For example:
-
-- `src/index.ts` will match the exports name `"."` or the only main export.
-- `src/lite.ts` will match the exports name `"./lite"`.
-- `src/react/index.ts` will match the exports name `"./react"`.
-
-Now just run `npm run build` (or `pnpm build` / `yarn build`) if you're using these package managers, `bunchee` will find the entry files and build them.
-The output format will based on the exports condition and also the file extension. Given an example:
-
-- It's CommonJS for `require` and ESM for `import` based on the exports condition.
-- It's CommonJS for `.js` and ESM for `.mjs` based on the extension regardless the exports condition. Then for export condition like "node" you could choose the format with your extension.
-
-> [!NOTE]
-> All the `dependencies` and `peerDependencies` will be marked as external automatically and not included in the bundle. If you want to include them in the bundle, you can use the `--no-external` option.
-
-#### Prepare Package
-
-```sh
-# Use bunchee to prepare package.json configuration
-npm exec bunchee prepare
-# "If you're using other package manager such as pnpm"
-# pnpm bunchee prepare
+## Usage
 
-# "Or use with npx"
-# npx bunchee@latest prepare
-```
+### Entry Files
 
-Or you can checkout the following cases to configure your package.json.
+Then files in `src` folders will be treated as entry files and match the export names in package.json.
+Simply like Node.js module resolution, each export name will match the file in `src/` directory.
 
-<details>
-  <summary>JavaScript ESModule</summary>
+Here's a example of entry files and exports configuration:
 
-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.
+| **File**             | **Exports Name**       |
+| -------------------- | ---------------------- |
+| `src/index.ts`       | `"."` (default export) |
+| `src/lite.ts`        | `"./lite"`             |
+| `src/react/index.ts` | `"./react"`            |
 
-```json
+```json5
 {
-  "files": ["dist"],
-  "type": "module",
-  "exports": {
-    ".": "./dist/es/index.js",
-    "./react": "./dist/es/react.js"
+  name: 'coffee',
+  scripts: {
+    build: 'bunchee',
   },
-  "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. Types exports need to stay on the top of each export with `types` condition, and you can use `default` condition for the JS bundle file.
-
-```json
-{
-  "files": ["dist"],
-  "type": "module",
-  "main": "./dist/index.js",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+  type: 'module',
+  exports: {
+    // entry: ./src/index.ts
+    '.': {
+      import: './dist/index.js',
+      require: './dist/index.cjs',
     },
-    "./react": {
-      "types": "./dist/react/index.d.ts",
-      "default": "./dist/react/index.js"
-    }
-  },
-  "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.
+    // entry: ./src/lite.ts
+    './lite': './dist/lite.js',
 
-_NOTE_: 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.
-
-```json
-{
-  "files": ["dist"],
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    "import": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "require": {
-      "types": "./dist/index.d.cts",
-      "default": "./dist/index.cjs"
-    }
+    // entry: ./src/react/index.ts
+    './react': './dist/react.js',
   },
-  "scripts": {
-    "build": "bunchee"
-  }
 }
 ```
 
-</details>
+### Output Formats
 
-#### Lint Package
+**bunchee** detects the format of each entry-point based on export condition type or the file extension. It supports the following output formats:
 
-`lint` command will check the package.json configuration is valid or not, it can valid few things like:
+| `package.json` Field | Output format                    |
+| -------------------- | -------------------------------- |
+| `main`               | Default                          |
+| `types`              | TypeScript declaration           |
+| `exports`            | Default                          |
+| `exports.require`    | CommonJS                         |
+| `exports.import`     | Default                          |
+| `exports.types`      | TypeScript declaration of export |
+| `bin`                | Default                          |
+| `bin.<name>`         | Default                          |
 
-- if the entry files are matched with the exports conditions.
-- if the entry files are matched with the exports paths.
+The **Default** output format is determined by the file extension:
 
-```sh
-# Use bunchee to lint if the package.json configuration is valid
-npm exec bunchee lint
-```
+| File Extension | Output format                                                                                                                                                                           |
+| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `.js`          | Determined by `package.json#type`, CommonJS by default                                                                                                                                  |
+| `.cjs`         | [CommonJS](https://nodejs.org/api/packages.html#:~:text=Files%20ending%20with%20.cjs%20are%20always%20loaded%20as%20CommonJS%20regardless%20of%20the%20nearest%20parent%20package.json) |
+| `.mjs`         | [ECMAScript Modules](https://nodejs.org/api/modules.html#the-mjs-extension)                                                                                                             |
 
-## Usage
+### External Dependencies
 
-### File Conventions
+The `dependencies` and `peerDependencies` will be marked as externalized and wont be included in the bundle. If you want to include them in the bundle, you can use the `--no-external` option. Or you can import the `devDependencies` in your source code to bundle them.
 
-While `exports` field is becoming the standard of exporting in node.js, bunchee also supports to build multiple exports all in one command.
+```json5
+{
+  // Externalized
+  dependencies: {
+    /* ... */
+  },
+  peerDependencies: {
+    /* ... */
+  },
 
-Provide entry files with the name (`[name].[ext]`) that matches the exported name from exports field in package.json. For instance:
+  // Bundled
+  devDependencies: {
+    /* ... */
+  },
+}
+```
 
-- `<cwd>/src/index.ts` will match `"."` export name or the if there's only one main export.
-- `<cwd>/src/lite.ts` will match `"./lite"` export name.
+### Multiple Runtime
 
-The build script can be just `bunchee` without configure any input sources for each exports. Of course you can still specify other arguments as you need.
-Briefly, the entry files from `src/` folder will do matching with `exports` conditions from `package.json` and build them into bundles.
+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.
 
-Assuming you have default export package as `"."` and subpath export `"./lite"` with different exports condition listed in package.json
+For instance:
 
-```json
+```json5
 {
-  "name": "example",
-  "scripts": {
-    "build": "bunchee"
+  exports: {
+    'react-server': './dist/react-server.mjs',
+    'edge-light': './dist/edge-light.mjs',
+    import: './dist/index.mjs',
   },
-  "type": "module",
-  "exports": {
-    "./lite": "./dist/lite.js",
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    }
-  }
 }
 ```
 
-Then you need to add two entry files `index.ts` and `lite.ts` in project root directory to match the export name `"."` and `"./lite"`, bunchee will associate these entry files with export names then use them as input source and output paths information.
-
-```
-- my-lib/
-  |- src/
-    |- lite.ts
-    |- index.ts
-  |- package.json
-```
-
-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.
-
-### 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.
+### Path Alias
 
-For instance:
+`bunchee` supports both TypeScript `paths` config and Node.js [`imports field`](https://nodejs.org/api/packages.html#subpath-imports) in `package.json` for path aliasing. It will resolve the path alias to the correct file path. If you're using modern TypeScript versions, you can also directly configure the `imports` field in `package.json` and it will work as a charm.
 
-```json
+```json5
+// package.json
 {
-  "exports": {
-    "react-server": "./dist/react-server.mjs",
-    "edge-light": "./dist/edge-light.mjs",
-    "import": "./dist/index.mjs"
-  }
+  imports: {
+    '#util': './src/utils.ts',
+  },
 }
 ```
 
-### Executables
+### Binary CLI
 
 To build executable files with the `bin` field in package.json, `bunchee` requires you to create the `bin` directory under `src` directory. The source file matching will be same as the entry files convention.
 
@@ -252,45 +181,49 @@ For example:
 
 This will match the `bin` field in package.json as:
 
-```json
+```json5
 {
-  "bin": "./dist/bin.js"
+  bin: './dist/bin.js',
 }
 ```
 
-For multiple executable files, you can create multiple files under the `bin` directory.
+If you have multiple binaries, you can create multiple files under the `bin` directory. Check the below example for more details.
+
+<details>
+  <summary>Multiple Binaries</summary>
+
+For named executable files, you can create multiple files under the `bin` directory.
 
 ```bash
 |- src/
   |- bin/
-    |- foo.ts
-    |- bar.ts
+
 ```
 
 This will match the `bin` field in package.json as:
 
-```json
+```json5
 {
-  "bin": {
-    "foo": "./dist/bin/a.js",
-    "bar": "./dist/bin/b.js"
-  }
+  bin: {
+    foo: './dist/bin/a.js',
+    bar: './dist/bin/b.js',
+  },
 }
 ```
 
+</details>
+
 > Note: For multiple `bin` files, the filename should match the key name in the `bin` field.
 
 ### Server Components
 
-`bunchee` supports to build server components and server actions with library directives like `"use client"` or `"use server"`. It will generate the corresponding chunks for client and server that scope the client and server boundaries properly.
-Then when the library is integrated to an app such as Next.js, app bundler can transform the client components and server actions correctly and maximum the benefits.
-
-If you're using `"use client"` or `"use server"` in entry file, then it will be preserved on top and the dist file of that entry will become a client component.
-If you're using `"use client"` or `"use server"` in a file that used as a dependency for an entry, then that file containing directives be split into a separate chunk and hoist the directives to the top of the chunk.
+**bunchee** supports building React Server Components and Server Actions with directives like `"use client"` or `"use server"`. It generates separate chunks for the server or client boundaries. When integrated to framework like Next.js, it can correctly handles the boundaries with the split chunks.
 
 ### Shared Modules
 
-In some cases, you may need to share code across multiple bundles without promoting them to separate entries or exports. These modules should be bundled into shared chunks that can be reused by various bundles. By convention, files or directories **prefixed with an underscore** (`_<name>.<ext>` or `_<name>/**`) are treated as **shared modules**. They're private and not exposed publicly as entry points or exports. Testing, mocking related files are ignored. e.g. `_foo/a.test.ts` will not be treated as shared module.
+Sometimes, you may want to share a chunk across multiple bundles without promoting it to separate entries or exports, such as single instance of React context module, shared utils, etc. In these cases, **shared modules** will help you achieve the goal. Files or directories **prefixed with an underscore** (`_<name>.<ext>` or `_<name>/**`) will be treated as **shared modules**.
+
+These conventions are kept private and are not going to be treat as shared modules or entry points. For example, test or mock files like `_foo/a.test.ts` will be ignored and not included as shared modules.
 
 <details>
   <summary>Shared Utils Example</summary>
@@ -351,38 +284,23 @@ This convention keeps shared modules private while enabling efficient bundling a
 
 #### CLI Options
 
-`bunchee` CLI provides few options to create different bundles or generating types.
-
-- Output (`-o <file>`): Specify output filename.
-- Format (`-f <format>`): Set output format (default: `'esm'`).
-- External (`--external <dep,>`): Specifying extra external dependencies, by default it is the list of `dependencies` and `peerDependencies` from `package.json`. Values are separate by comma.
-- Target (`--target <target>`): Set ECMAScript target (default: `'es2015'`).
-- Runtime (`--runtime <runtime>`): Set build runtime (default: `'browser'`).
-- Environment (`--env <env,>`): Define environment variables. (default: `[]`, separate by comma)
-- Working Directory (`--cwd <cwd>`): Set current working directory where containing `package.json`.
-- Minify (`-m`): Compress output.
-- Watch (`-w`): Watch for source file changes.
-- No Clean(`--no-clean`): Do not clean the dist folder before building. (default: `false`)
-- TSConfig (`--tsconfig <path>`): Specify the path to the TypeScript configuration file. (default: `tsconfig.json`)
-- Bundle Types (`--dts-bundle`): Bundle type declaration files. (default: `false`)
+`bunchee` CLI provides few options to create different bundles or generating types. Call `bunchee --help` to see the help information in the terminal.
+
+Here are the available options for the CLI:
 
 ```sh
 cd <project-root-dir>
 
-# specifying input, output and format
+# Build based on the package.json configuration
+bunchee --runtime node -o ./dist/bundle.js
+bunchee -f esm -o --target es2022 ./dist/bundle.esm.js
 
-bunchee ./src/index.js -f cjs -o ./dist/bundle.js
-bunchee ./src/index.js -f esm -o ./dist/bundle.esm.js
-
-# build node.js library, or change target to es2019
-bunchee ./src/index.js --runtime node --target es2019
+# Specify the input source file
+bunchee ./src/foo.ts -o ./dist/foo.js
 ```
 
 #### Specifying extra external dependencies
 
-By default, `bunchee` will mark all the `dependencies` and `peerDependencies` as externals so you don't need to pass them as CLI args.
-But if there's any dependency that used but not in the dependency list and you want to mark as external, you can use the `--external` option to specify them.
-
 ```sh
 bunchee --external=dep1,dep2,dep3
 ```
@@ -399,6 +317,112 @@ bunchee --no-external
 
 This will include all dependencies within your output bundle.
 
+#### Prepare Package
+
+```sh
+# Use bunchee to prepare package.json configuration
+npm exec 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 ESModule</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.
+
+```json5
+{
+  files: ['dist'],
+  type: 'module',
+  exports: {
+    '.': './dist/es/index.js',
+    './react': './dist/es/react.js',
+  },
+  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. Types exports need to stay on the top of each export with `types` condition, and you can use `default` condition for the JS bundle file.
+
+```json5
+{
+  files: ['dist'],
+  type: 'module',
+  main: './dist/index.js',
+  exports: {
+    '.': {
+      types: './dist/index.d.ts',
+      default: './dist/index.js',
+    },
+    './react': {
+      types: './dist/react/index.d.ts',
+      default: './dist/react/index.js',
+    },
+  },
+  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.
+
+_NOTE_: 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.
+
+```json5
+{
+  files: ['dist'],
+  type: 'module',
+  main: './dist/index.js',
+  module: './dist/index.js',
+  types: './dist/index.d.ts',
+  exports: {
+    import: {
+      types: './dist/index.d.ts',
+      default: './dist/index.js',
+    },
+    require: {
+      types: './dist/index.d.cts',
+      default: './dist/index.cjs',
+    },
+  },
+  scripts: {
+    build: 'bunchee',
+  },
+}
+```
+
+</details>
+
+#### Lint Package
+
+`lint` command will check the package.json configuration is valid or not, it can valid few things like:
+
+- if the entry files are matched with the exports conditions.
+- if the entry files are matched with the exports paths.
+
+```sh
+# Use bunchee to lint if the package.json configuration is valid
+npm exec bunchee lint
+```
+
 ### Environment Variables
 
 To pass environment variables to your bundled code, use the --env option followed by a comma-separated list of environment variable names:
@@ -424,12 +448,12 @@ This will match the export name `"react-server"` and `"edge-light"` then use the
 
 `process.env.NODE_ENV` is injected by default if present that you don't need to manually inject yourself. If you need to separate the development build and production build, `bunchee` provides different export conditions for development and production mode with `development` and `production` export conditions.
 
-```json
+```json5
 {
-  "exports": {
-    "development": "./dist/index.development.js",
-    "production": "./dist/index.production.js"
-  }
+  exports: {
+    development: './dist/index.development.js',
+    production: './dist/index.production.js',
+  },
 }
 ```
 
@@ -512,14 +536,14 @@ To target a range of browsers, you can use the `browserslist` field in `package.
 
 For example:
 
-```json
+```json5
 {
-  "browserslist": [
-    "last 1 version",
-    "> 1%",
-    "maintained node versions",
-    "not dead"
-  ]
+  browserslist: [
+    'last 1 version',
+    '> 1%',
+    'maintained node versions',
+    'not dead',
+  ],
 }
 ```
 

package/dist/bin/cli.js

@@ -69,9 +69,13 @@ const tsExtensions = new Set([
 ]);
 const DEFAULT_TS_CONFIG = {
     compilerOptions: {
+        target: 'ES2022',
         module: 'ESNext',
         moduleResolution: 'bundler'
-    }
+    },
+    include: [
+        'src'
+    ]
 };
 const BINARY_TAG = '$binary';
 const PRIVATE_GLOB_PATTERN = '**/_*/**';
@@ -642,7 +646,7 @@ function lint$1(pkg) {
     }
 }
 
-var version = "6.2.0";
+var version = "6.3.1";
 
 async function writeDefaultTsconfig(tsConfigPath) {
     await fs.promises.writeFile(tsConfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
@@ -1198,11 +1202,11 @@ async function run(args) {
         cwd,
         target,
         runtime,
-        external: args.external === null ? null : ((_args_external = args.external) == null ? void 0 : _args_external.split(',')) || [],
+        external: args.external === null ? null : ((_args_external = args.external) == null ? undefined : _args_external.split(',')) || [],
         watch: !!watch,
         minify: !!minify,
         sourcemap: sourcemap === false ? false : true,
-        env: (env == null ? void 0 : env.split(',')) || [],
+        env: (env == null ? undefined : env.split(',')) || [],
         clean,
         tsconfig
     };
@@ -1256,7 +1260,7 @@ async function run(args) {
             if (assetJobs.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');
             }
-            const outputState = initialBuildContext == null ? void 0 : initialBuildContext.pluginContext.outputState;
+            const outputState = initialBuildContext == null ? undefined : initialBuildContext.pluginContext.outputState;
             if (outputState) {
                 logOutputState(outputState.getSizeStats());
             }
@@ -1268,7 +1272,7 @@ async function run(args) {
         onBuildEnd
     };
     if (watch) {
-        logger.log(`Watching project ${cwd}...`);
+        logger.log(`Watching changes in the project directory...`);
     }
     try {
         await index_js.bundle(cliEntry, bundleConfig);
@@ -1279,7 +1283,7 @@ async function run(args) {
                 error: err
             };
         }
-        if ((buildError == null ? void 0 : buildError.digest) === 'bunchee:not-existed') {
+        if ((buildError == null ? undefined : buildError.digest) === 'bunchee:not-existed') {
             help();
         } else {
             if (watch) {

package/dist/index.js

@@ -159,14 +159,7 @@ const runtimeExportConventionsFallback = new Map([
             'default'
         ]
     ],
-    [
-        'browser',
-        [
-            'import',
-            'default'
-        ]
-    ],
-    // it could be CJS or ESM
+    // Fallback to default when unsure
     [
         'electron',
         [
@@ -202,6 +195,26 @@ const runtimeExportConventionsFallback = new Map([
         [
             'default'
         ]
+    ],
+    [
+        'development',
+        [
+            'default'
+        ]
+    ],
+    [
+        'production',
+        [
+            'default'
+        ]
+    ],
+    [
+        'browser',
+        [
+            'import',
+            'require',
+            'default'
+        ]
     ]
 ]);
 const optimizeConventions = new Set([
@@ -236,9 +249,13 @@ const tsExtensions = new Set([
 ]);
 const DEFAULT_TS_CONFIG = {
     compilerOptions: {
+        target: 'ES2022',
         module: 'ESNext',
         moduleResolution: 'bundler'
-    }
+    },
+    include: [
+        'src'
+    ]
 };
 const BINARY_TAG = '$binary';
 const PRIVATE_GLOB_PATTERN = '**/_*/**';
@@ -990,7 +1007,7 @@ function createOutputState({ entries }) {
     };
 }
 
-const memoize = (fn, cacheKey, cacheArg)=>{
+const createMemoize = (fn, cacheKey, cacheArg)=>{
     const cache = cacheArg || new Map();
     return (...args)=>{
         const key = cacheKey ? typeof cacheKey === 'function' ? cacheKey(...args) : cacheKey : JSON.stringify({
@@ -1007,8 +1024,9 @@ const memoize = (fn, cacheKey, cacheArg)=>{
 };
 const memoizeByKey = (fn)=>{
     const cache = new Map();
-    return (cacheKey)=>memoize(fn, cacheKey, cache);
+    return (cacheKey)=>createMemoize(fn, cacheKey, cache);
 };
+const memoize = (fn)=>createMemoize(fn);
 
 let hasLoggedTsWarning = false;
 function resolveTypescript(cwd) {
@@ -1036,11 +1054,14 @@ function resolveTypescript(cwd) {
     }
     return ts;
 }
-function resolveTsConfigHandler(cwd, tsconfig = 'tsconfig.json') {
-    let tsCompilerOptions = {};
+const resolveTsConfigPath = memoize((cwd, tsconfigFileName = 'tsconfig.json')=>{
     let tsConfigPath;
-    tsConfigPath = path.resolve(cwd, tsconfig);
-    if (fileExists(tsConfigPath)) {
+    tsConfigPath = path.resolve(cwd, tsconfigFileName);
+    return fileExists(tsConfigPath) ? tsConfigPath : undefined;
+});
+function resolveTsConfigHandler(cwd, tsConfigPath) {
+    let tsCompilerOptions = {};
+    if (tsConfigPath) {
         // Use the original ts handler to avoid memory leak
         const ts = resolveTypescript(cwd);
         const basePath = tsConfigPath ? path.dirname(tsConfigPath) : cwd;
@@ -1054,7 +1075,7 @@ function resolveTsConfigHandler(cwd, tsconfig = 'tsconfig.json') {
         tsConfigPath
     };
 }
-const resolveTsConfig = memoizeByKey(resolveTsConfigHandler)();
+const resolveTsConfig = memoize(resolveTsConfigHandler);
 async function convertCompilerOptions(cwd, json) {
     // Use the original ts handler to avoid memory leak
     const ts = resolveTypescript(cwd);
@@ -1289,6 +1310,9 @@ function findJsBundlePathCallback({ format, bundlePath, conditionNames }, specia
     const formatCond = format === 'cjs' ? 'require' : 'import';
     const isTypesCondName = conditionNames.has('types');
     const hasFormatCond = conditionNames.has('import') || conditionNames.has('require');
+    // Check if the format condition is matched:
+    // if there's condition existed, check if the format condition is matched;
+    // if there's no condition, just return true, assuming format doesn't matter;
     const isMatchedFormat = hasFormatCond ? conditionNames.has(formatCond) : true;
     const isMatchedConditionWithFormat = conditionNames.has(specialCondition) || !conditionNames.has('default') && hasNoSpecialCondition(conditionNames);
     const match = isMatchedConditionWithFormat && !isTypesCondName && hasBundle && isMatchedFormat;
@@ -1297,7 +1321,11 @@ function findJsBundlePathCallback({ format, bundlePath, conditionNames }, specia
         if (!fallback) {
             return false;
         } else {
-            return fallback.some((name)=>conditionNames.has(name));
+            // Match its own condition first,
+            // e.g. when import utils.js in index.js
+            // In output: index.browser.js should match util.browser.js, fallback to util.js
+            // The last guard condition is to ensure bundle condition but not types file.
+            return isMatchedFormat && (conditionNames.has(specialCondition) || fallback.some((name)=>conditionNames.has(name))) && !conditionNames.has('types');
         }
     } else {
         return match;
@@ -1325,7 +1353,7 @@ function aliasEntries({ entry: sourceFilePath, conditionNames, entries, format,
         if (dts) {
             var _exportMapEntries_find;
             // Find the type with format condition first
-            matchedBundlePath = (_exportMapEntries_find = exportMapEntries.find(findTypesFileCallback)) == null ? void 0 : _exportMapEntries_find.bundlePath;
+            matchedBundlePath = (_exportMapEntries_find = exportMapEntries.find(findTypesFileCallback)) == null ? undefined : _exportMapEntries_find.bundlePath;
             // If theres no format specific types such as import.types or require.types,
             // fallback to the general types file.
             if (!matchedBundlePath) {
@@ -1335,13 +1363,13 @@ function aliasEntries({ entry: sourceFilePath, conditionNames, entries, format,
                         ...item,
                         format: undefined
                     });
-                })) == null ? void 0 : _exportMapEntries_find1.bundlePath;
+                })) == null ? undefined : _exportMapEntries_find1.bundlePath;
             }
         } else {
             var _exportMapEntries_find2;
             matchedBundlePath = (_exportMapEntries_find2 = exportMapEntries.find((item)=>{
                 return findJsBundlePathCallback(item, specialCondition);
-            })) == null ? void 0 : _exportMapEntries_find2.bundlePath;
+            })) == null ? undefined : _exportMapEntries_find2.bundlePath;
         }
         if (matchedBundlePath) {
             if (!sourceToRelativeBundleMap.has(exportCondition.source)) sourceToRelativeBundleMap.set(exportCondition.source, matchedBundlePath);
@@ -1499,7 +1527,7 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
     const sizePlugin = pluginContext.outputState.plugin(cwd);
     // common plugins for both dts and ts assets that need to be processed
     // If it's a .d.ts file under non-ESM package or .d.cts file, use cjs types alias.
-    const aliasFormat = dts ? ((_bundleConfig_file = bundleConfig.file) == null ? void 0 : _bundleConfig_file.endsWith('.d.cts')) || ((_bundleConfig_file1 = bundleConfig.file) == null ? void 0 : _bundleConfig_file1.endsWith('.d.ts')) && !isESModulePackage(pkg.type) ? 'cjs' : 'esm' : bundleConfig.format;
+    const aliasFormat = dts ? ((_bundleConfig_file = bundleConfig.file) == null ? undefined : _bundleConfig_file.endsWith('.d.cts')) || ((_bundleConfig_file1 = bundleConfig.file) == null ? undefined : _bundleConfig_file1.endsWith('.d.ts')) && !isESModulePackage(pkg.type) ? 'cjs' : 'esm' : bundleConfig.format;
     const currentConditionNames = Object.keys(exportCondition.export)[0];
     const aliasPlugin = aliasEntries({
         entry,
@@ -1557,7 +1585,11 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
             ...swcOptions
         }),
         commonjs__default.default({
-            exclude: bundleConfig.external || null
+            exclude: bundleConfig.external || null,
+            // Deal with mixed ESM and CJS modules, such as calling require() in ESM.
+            // For relative paths, the module will be bundled;
+            // For external libraries, the module will not be bundled.
+            transformMixedEsModules: true
         })
     ]).filter(isNotNull);
     return {
@@ -1661,7 +1693,7 @@ async function buildOutputConfigs(bundleConfig, exportCondition, buildContext, d
     const { format } = bundleConfig;
     const { entries, pkg, cwd, tsOptions: { tsCompilerOptions }, pluginContext } = buildContext;
     // Add esm mark and interop helper if esm export is detected
-    const useEsModuleMark = tsCompilerOptions == null ? void 0 : tsCompilerOptions.esModuleInterop;
+    const useEsModuleMark = tsCompilerOptions == null ? undefined : tsCompilerOptions.esModuleInterop;
     const absoluteOutputFile = path.resolve(cwd, bundleConfig.file);
     const isEsmPkg = isESModulePackage(pkg.type);
     const name = filePathWithoutExtension(absoluteOutputFile);
@@ -1869,11 +1901,12 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
     // Original input file path, client path might change later
     const inputFile = cliEntryPath;
     const isFromCli = Boolean(cliEntryPath);
-    let tsConfig = resolveTsConfig(cwd, options.tsconfig);
-    let hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
+    const tsConfigPath = resolveTsConfigPath(cwd, options.tsconfig);
+    let tsConfig = resolveTsConfig(cwd, tsConfigPath);
+    let hasTsConfig = Boolean(tsConfig == null ? undefined : tsConfig.tsConfigPath);
     const defaultTsOptions = {
-        tsConfigPath: tsConfig == null ? void 0 : tsConfig.tsConfigPath,
-        tsCompilerOptions: (tsConfig == null ? void 0 : tsConfig.tsCompilerOptions) || {}
+        tsConfigPath: tsConfig == null ? undefined : tsConfig.tsConfigPath,
+        tsCompilerOptions: (tsConfig == null ? undefined : tsConfig.tsCompilerOptions) || {}
     };
     // Handle single entry file
     if (!isMultiEntries) {
@@ -1923,10 +1956,16 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
     }
     const entries = await collectEntriesFromParsedExports(cwd, parsedExportsInfo, pkg, inputFile);
     const hasTypeScriptFiles = Object.values(entries).some((entry)=>isTypescriptFile(entry.source));
+    // If there's no tsconfig, create one.
     if (hasTypeScriptFiles && !hasTsConfig) {
-        const tsConfigPath = path.resolve(cwd, 'tsconfig.json');
-        defaultTsOptions.tsConfigPath = tsConfigPath;
-        await writeDefaultTsconfig(tsConfigPath);
+        // Check if tsconfig.json exists in the project first.
+        // If not, create one with default settings.
+        // Otherwise, use the existing one.
+        const defaultTsConfigPath = path.resolve(cwd, 'tsconfig.json');
+        if (!fileExists(defaultTsConfigPath)) {
+            await writeDefaultTsconfig(defaultTsConfigPath);
+        }
+        defaultTsOptions.tsConfigPath = defaultTsConfigPath;
         hasTsConfig = true;
     }
     let browserslistConfig;
@@ -1948,14 +1987,14 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
             moduleDirectiveLayerMap: new Map()
         }
     };
-    (_options__callbacks = options._callbacks) == null ? void 0 : (_options__callbacks_onBuildStart = _options__callbacks.onBuildStart) == null ? void 0 : _options__callbacks_onBuildStart.call(_options__callbacks, buildContext);
+    (_options__callbacks = options._callbacks) == null ? undefined : (_options__callbacks_onBuildStart = _options__callbacks.onBuildStart) == null ? undefined : _options__callbacks_onBuildStart.call(_options__callbacks, buildContext);
     const generateTypes = hasTsConfig && options.dts !== false;
     const rollupJobsOptions = {
         isFromCli,
         generateTypes
     };
     const assetJobs = await createAssetRollupJobs(options, buildContext, rollupJobsOptions);
-    (_options__callbacks1 = options._callbacks) == null ? void 0 : (_options__callbacks_onBuildEnd = _options__callbacks1.onBuildEnd) == null ? void 0 : _options__callbacks_onBuildEnd.call(_options__callbacks1, assetJobs);
+    (_options__callbacks1 = options._callbacks) == null ? undefined : (_options__callbacks_onBuildEnd = _options__callbacks1.onBuildEnd) == null ? undefined : _options__callbacks_onBuildEnd.call(_options__callbacks1, assetJobs);
 }
 
 exports.bundle = bundle;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunchee",
-  "version": "6.2.0",
+  "version": "6.3.1",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",
@@ -24,7 +24,8 @@
   ],
   "prettier": {
     "semi": false,
-    "singleQuote": true
+    "singleQuote": true,
+    "trailingComma": "all"
   },
   "engines": {
     "node": ">= 18.0.0"
@@ -36,25 +37,25 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@rollup/plugin-commonjs": "^28.0.1",
+    "@rollup/plugin-commonjs": "^28.0.2",
     "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.3.0",
-    "@rollup/plugin-replace": "^6.0.1",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-wasm": "^6.2.2",
     "@rollup/pluginutils": "^5.1.3",
-    "@swc/core": "^1.9.3",
+    "@swc/core": "^1.10.7",
     "@swc/helpers": "^0.5.11",
     "clean-css": "^5.3.3",
     "glob": "^11.0.0",
-    "magic-string": "^0.30.14",
+    "magic-string": "^0.30.17",
     "ora": "^8.0.1",
     "picomatch": "^4.0.2",
     "pretty-bytes": "^5.6.0",
-    "rollup": "^4.27.4",
+    "rollup": "^4.30.1",
     "rollup-plugin-dts": "^6.1.1",
     "rollup-plugin-swc3": "^0.11.1",
     "rollup-preserve-directives": "^1.1.3",
-    "tslib": "^2.7.0",
+    "tslib": "^2.8.1",
     "yargs": "^17.7.2"
   },
   "peerDependencies": {
@@ -71,8 +72,8 @@
   "devDependencies": {
     "@huozhi/testing-package": "1.0.0",
     "@swc-node/register": "^1.10.9",
-    "@swc/jest": "^0.2.31",
-    "@swc/types": "^0.1.9",
+    "@swc/jest": "^0.2.37",
+    "@swc/types": "^0.1.17",
     "@types/clean-css": "^4.2.11",
     "@types/jest": "29.0.0",
     "@types/node": "^22.9.3",
@@ -82,14 +83,14 @@
     "bunchee": "link:./",
     "cross-env": "^7.0.3",
     "husky": "^9.0.11",
-    "jest": "29.0.1",
+    "jest": "29.7.0",
     "lint-staged": "^15.2.2",
     "next": "^15.0.4",
     "picocolors": "^1.0.0",
-    "prettier": "^3.0.0",
+    "prettier": "2.8.8",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "typescript": "^5.6.2"
+    "typescript": "^5.7.2"
   },
   "lint-staged": {
     "*.{js,jsx,ts,tsx,md,json,yml,yaml}": "prettier --write"
@@ -99,7 +100,7 @@
       "node_modules"
     ],
     "moduleNameMapper": {
-      "bunchee": "<rootDir>/src/index.ts"
+      "^bunchee$": "<rootDir>/src/index.ts"
     },
     "transform": {
       "^.+\\.(t|j)sx?$": [
@@ -108,7 +109,8 @@
     },
     "testPathIgnorePatterns": [
       "/node_modules/",
-      "<rootDir>/test/integration/.*/*src"
+      "<rootDir>/test/integration/.*/*src",
+      "<rootDir>/test/fixtures"
     ],
     "testTimeout": 60000
   },
@@ -120,6 +122,7 @@
     "docs:dev": "next dev docs",
     "docs:build": "next build docs",
     "clean": "rm -rf ./dist",
+    "new-test": "node ./scripts/new-test.js",
     "typecheck": "tsc --noEmit && tsc -p test/tsconfig.json --noEmit",
     "prepare-release": "pnpm clean && pnpm build",
     "publish-local": "pnpm prepare-release && pnpm test && pnpm publish",