bunchee 6.8.1 → 6.9.0

package/README.md

@@ -94,6 +94,21 @@ Here's a example of entry files and exports configuration:
 }
 ```
 
+#### Wildcard Exports
+
+`bunchee` supports wildcard patterns in the `exports` field to automatically generate exports for multiple files:
+
+```json5
+{
+  "exports": {
+    ".": "./dist/index.js",
+    "./features/*": "./dist/features/*.js"
+  }
+}
+```
+
+This will automatically discover files in `src/features/` and generate exports like `./features/foo`, `./features/bar`, etc. The wildcard `*` is substituted in both the export path and output path.
+
 ### Output Formats
 
 **bunchee** detects the format of each entry-point based on export condition type or the file extension. It supports the following output formats:
@@ -215,6 +230,15 @@ This will match the `bin` field in package.json as:
 
 > Note: For multiple `bin` files, the filename should match the key name in the `bin` field.
 
+### Native Addon (.node) Support
+
+`bunchee` supports bundling native Node.js addon files (`.node` binaries). When you import a `.node` file, it will be copied to the output directory and the import will be rewritten to load it at runtime.
+
+```js
+// src/index.js
+import addon from './native-addon.node'
+```
+
 ### Server Components
 
 **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.
@@ -317,19 +341,6 @@ bunchee --no-external
 
 This will include all dependencies within your output bundle.
 
-#### TypeScript-Go Compiler
-
-TypeScript-Go (`@typescript/native-preview`) is a high-performance, Go-based implementation of the TypeScript compiler that can significantly speed up type declaration file generation.
-
-To use TypeScript-Go for type generation, use the `--tsgo` flag:
-
-**Note**: This requires `@typescript/native-preview` to be installed as a dev dependency. If it's not installed, bunchee will exit with an error.
-
-```sh
-pnpm add -D bunchee @typescript/native-preview
-bunchee --tsgo
-```
-
 #### Build Successful Command
 
 A command to be executed after a build is successful can be specified using the `--success` option, which is useful for development watching mode:
@@ -378,14 +389,6 @@ Then use use the [exports field in package.json](https://nodejs.org/api/packages
 
 If you're building 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.
 
-**bunchee** supports using the TypeScript-Go compiler (`@typescript/native-preview`) for faster type generation. To enable it, use the `--tsgo` flag:
-
-```sh
-bunchee --tsgo
-```
-
-Note: This requires `@typescript/native-preview` to be installed as a dev dependency. If it's not installed, bunchee will fall back to the regular TypeScript compiler with a warning.
-
 ```json5
 {
   "files": ["dist"],
@@ -566,7 +569,6 @@ await bundle(path.resolve('./src/index.ts'), {
   cwd: process.cwd(), // string
   clean: true, // boolean
   tsconfig: 'tsconfig.json', // string
-  tsgo: false, // Boolean - use TypeScript-Go compiler for type generation
 })
 ```
 

package/dist/bin/cli.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 var path = require('path');
-var module$1 = require('module');
 var yargs = require('yargs');
 var helpers = require('yargs/helpers');
 var perf_hooks = require('perf_hooks');
 var fs = require('fs');
 var fsp = require('fs/promises');
 var require$$0 = require('tty');
+var tinyglobby = require('tinyglobby');
 var picomatch = require('picomatch');
 var index_js = require('../index.js');
-var tinyglobby = require('tinyglobby');
+require('module');
 var prettyBytes = require('pretty-bytes');
 var nanospinner = require('nanospinner');
 
@@ -146,6 +146,52 @@ const defaultColorFn = (text)=>text;
 function color(prefixColor) {
     return pc.isColorSupported ? pc[prefixColor] : defaultColorFn;
 }
+let activeSpinner = null;
+// Store original console methods
+const originalConsole = {
+    log: console.log.bind(console),
+    warn: console.warn.bind(console),
+    error: console.error.bind(console),
+    info: console.info.bind(console)
+};
+function isSpinnerActive() {
+    if (!activeSpinner) return false;
+    const isSpinning = activeSpinner.isSpinning;
+    return typeof isSpinning === 'function' ? isSpinning() : isSpinning;
+}
+/**
+ * Wrap a console method to pause spinner before logging
+ */ function wrapConsoleMethod(original) {
+    return (...args)=>{
+        if (isSpinnerActive() && activeSpinner) {
+            activeSpinner.clear();
+            original(...args);
+            activeSpinner.start();
+        } else {
+            original(...args);
+        }
+    };
+}
+/**
+ * Register a spinner so that ALL console output automatically pauses it.
+ * This intercepts console.log/warn/error/info globally.
+ * Call with `null` to unregister and restore original console methods.
+ */ function setActiveSpinner(spinner) {
+    activeSpinner = spinner;
+    if (spinner) {
+        // Patch global console methods to pause spinner
+        console.log = wrapConsoleMethod(originalConsole.log);
+        console.warn = wrapConsoleMethod(originalConsole.warn);
+        console.error = wrapConsoleMethod(originalConsole.error);
+        console.info = wrapConsoleMethod(originalConsole.info);
+    } else {
+        // Restore original console methods
+        console.log = originalConsole.log;
+        console.warn = originalConsole.warn;
+        console.error = originalConsole.error;
+        console.info = originalConsole.info;
+    }
+}
 const logger = {
     log (...arg) {
         console.log(...arg);
@@ -228,7 +274,9 @@ const getMainFieldExportType = (pkg)=>{
 };
 const isTestFile = (filename)=>/\.(test|spec)$/.test(baseNameWithoutExtension(filename));
 function joinRelativePath(...segments) {
-    let result = path__default.default.join(...segments);
+    // Normalize to forward slashes for cross-platform compatibility
+    // Export paths in package.json always use POSIX-style paths
+    let result = path__default.default.posix.join(...segments);
     // If the first segment starts with '.', ensure the result does too.
     if (segments[0] === '.' && !result.startsWith('.')) {
         result = './' + result;
@@ -266,6 +314,155 @@ function normalizePath(filePath) {
     return filePath.replace(/\\/g, '/');
 }
 
+/**
+ * Check if an export key contains a wildcard pattern
+ */ function hasWildcardPattern(exportKey) {
+    return exportKey.includes('*');
+}
+/**
+ * Replace wildcard in output path with matched subpath
+ * Example: "./dist/features/*.js" with "foo" -> "./dist/features/foo.js"
+ */ function substituteWildcardInPath(outputPath, matchedSubpath) {
+    return outputPath.replace(/\*/g, matchedSubpath);
+}
+/**
+ * Expand a wildcard export pattern by finding matching source files
+ * Returns a map of concrete export paths to their matched subpaths
+ * Example: "./features/*" with files ["foo.ts", "bar.ts"] in src/features/
+ *   -> { "./features/foo": "foo", "./features/bar": "bar" }
+ */ async function expandWildcardPattern(wildcardPattern, cwd) {
+    const expanded = new Map();
+    const sourceDir = path__default.default.join(cwd, SRC);
+    if (!fileExists(sourceDir)) {
+        return expanded;
+    }
+    // Convert wildcard pattern to glob pattern
+    // "./features/*" -> "features/*"
+    const cleanPattern = wildcardPattern.replace(/^\.\//, '');
+    // Extract the base path before the wildcard
+    // "features/*" -> "features"
+    const basePathParts = cleanPattern.split('*');
+    const basePath = basePathParts[0].replace(/\/$/, '');
+    // Build glob pattern to match files
+    // "features/*" -> "features/*.{js,ts,tsx,...}"
+    const extPattern = `{${[
+        ...availableExtensions
+    ].join(',')}}`;
+    const globPatterns = [
+        `${cleanPattern}.${extPattern}`,
+        `${cleanPattern}/index.${extPattern}`
+    ];
+    let matches = [];
+    try {
+        matches = await tinyglobby.glob(globPatterns, {
+            cwd: sourceDir,
+            ignore: [
+                PRIVATE_GLOB_PATTERN,
+                TESTS_GLOB_PATTERN
+            ],
+            expandDirectories: false
+        });
+    } catch (error) {
+        logger.warn(`Failed to expand wildcard pattern ${wildcardPattern}: ${error}`);
+        return expanded;
+    }
+    for (const match of matches){
+        // Extract the matched subpath
+        // "features/foo.ts" -> "foo"
+        // "features/bar/index.ts" -> "bar"
+        const relativePath = normalizePath(match);
+        const ext = path__default.default.extname(relativePath);
+        const withoutExt = relativePath.slice(0, -ext.length);
+        // Remove the base path to get just the matched part
+        // "features/foo" -> "foo" (when basePath is "features")
+        let matchedPart = withoutExt;
+        if (basePath && matchedPart.startsWith(basePath + '/')) {
+            matchedPart = matchedPart.slice(basePath.length + 1);
+        } else if (basePath && matchedPart === basePath) {
+            continue;
+        }
+        // Handle index files
+        let matchedSubpath;
+        if (matchedPart.endsWith('/index')) {
+            matchedSubpath = matchedPart.slice(0, -6); // Remove "/index"
+            // If there's still a path, take the last segment
+            const lastSlash = matchedSubpath.lastIndexOf('/');
+            matchedSubpath = lastSlash >= 0 ? matchedSubpath.slice(lastSlash + 1) : matchedSubpath;
+        } else {
+            // Take the first segment (what matches the *)
+            const firstSlash = matchedPart.indexOf('/');
+            matchedSubpath = firstSlash >= 0 ? matchedPart.slice(0, firstSlash) : matchedPart;
+        }
+        // Build the concrete export path
+        // "./features/*" + "foo" -> "./features/foo"
+        const concreteExportPath = basePath ? `./${basePath}/${matchedSubpath}` : `./${matchedSubpath}`;
+        expanded.set(concreteExportPath, matchedSubpath);
+    }
+    return expanded;
+}
+
+/**
+ * Process export value for wildcard patterns, substituting wildcards in output paths
+ */ async function processWildcardExportValue(exportValue, originalExportKey, currentPath, exportTypes, exportToDist, matchedSubpath) {
+    // End of searching, export value is file path.
+    // <export key>: <export value> (string)
+    if (typeof exportValue === 'string') {
+        const composedTypes = new Set(exportTypes);
+        const exportType = originalExportKey.startsWith('.') ? 'default' : originalExportKey;
+        composedTypes.add(exportType);
+        const exportInfo = exportToDist.get(mapExportFullPath(currentPath));
+        const exportCondition = Array.from(composedTypes).join('.');
+        // Substitute wildcard in output path
+        const substitutedPath = substituteWildcardInPath(exportValue, matchedSubpath);
+        if (!exportInfo) {
+            const outputConditionPair = [
+                substitutedPath,
+                exportCondition
+            ];
+            addToExportDistMap(exportToDist, currentPath, [
+                outputConditionPair
+            ]);
+        } else {
+            exportInfo.push([
+                substitutedPath,
+                exportCondition
+            ]);
+        }
+        return;
+    }
+    const exportKeys = Object.keys(exportValue);
+    for (const exportKey of exportKeys){
+        // Clone the set to avoid modifying the parent set
+        const childExports = new Set(exportTypes);
+        // Normalize child export value to a map
+        const childExportValue = exportValue[exportKey];
+        // Substitute wildcard in nested string values
+        let processedChildValue = childExportValue;
+        if (typeof childExportValue === 'string') {
+            processedChildValue = substituteWildcardInPath(childExportValue, matchedSubpath);
+        } else if (typeof childExportValue === 'object' && childExportValue !== null) {
+            // Recursively process nested objects
+            const processed = {};
+            for (const [key, value] of Object.entries(childExportValue)){
+                if (typeof value === 'string') {
+                    processed[key] = substituteWildcardInPath(value, matchedSubpath);
+                } else if (value !== null && value !== undefined) {
+                    processed[key] = value;
+                }
+            }
+            processedChildValue = processed;
+        }
+        // Visit export path: ./subpath, ./subpath2, ...
+        if (exportKey.startsWith('.')) {
+            const childPath = joinRelativePath(currentPath, exportKey);
+            await processWildcardExportValue(processedChildValue, exportKey, childPath, childExports, exportToDist, matchedSubpath);
+        } else {
+            // Visit export type: import, require, ...
+            childExports.add(exportKey);
+            await processWildcardExportValue(processedChildValue, exportKey, currentPath, childExports, exportToDist, matchedSubpath);
+        }
+    }
+}
 function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exportToDist) {
     // End of searching, export value is file path.
     // <export key>: <export value> (string)
@@ -327,7 +524,7 @@ function addToExportDistMap(exportToDist, exportPath, outputConditionPairs) {
  *  './index': { development: ..., default: ... }
  *  './index.react-server': { development: ..., default: ... }
  * }
- */ function parseExports(pkg) {
+ */ async function parseExports(pkg, cwd) {
     var _pkg_exports;
     const exportsField = (_pkg_exports = pkg.exports) != null ? _pkg_exports : {};
     var _pkg_bin;
@@ -351,6 +548,17 @@ function addToExportDistMap(exportToDist, exportPath, outputConditionPairs) {
             const exportValue = exportsField[exportKey];
             const exportTypes = new Set();
             const isExportPath = exportKey.startsWith('.');
+            // Handle wildcard patterns
+            if (isExportPath && hasWildcardPattern(exportKey) && cwd) {
+                // Expand wildcard pattern to concrete exports
+                const expanded = await expandWildcardPattern(exportKey, cwd);
+                for (const [concreteExportPath, matchedSubpath] of expanded){
+                    const childPath = joinRelativePath(currentPath, concreteExportPath);
+                    // Process the export value and substitute wildcards in output paths
+                    await processWildcardExportValue(exportValue, exportKey, childPath, exportTypes, exportToDist, matchedSubpath);
+                }
+                continue;
+            }
             const childPath = isExportPath ? joinRelativePath(currentPath, exportKey) : currentPath;
             if (!isExportPath) {
                 exportTypes.add(exportKey);
@@ -469,10 +677,11 @@ function validateFilesField(packageJson) {
     });
     return state;
 }
-function lint$1(pkg) {
+async function lint$1(cwd) {
+    const pkg = await getPackageMeta(cwd);
     const { name, main, exports } = pkg;
     const isESM = isESModulePackage(pkg.type);
-    const parsedExports = parseExports(pkg);
+    const parsedExports = await parseExports(pkg, cwd);
     if (!name) {
         logger.warn('Missing package name');
     }
@@ -647,12 +856,11 @@ function lint$1(pkg) {
     }
 }
 
-var version = "6.8.1";
+var version = "6.9.0";
 
-async function writeDefaultTsconfig(tsConfigPath, useTsGo) {
+async function writeDefaultTsconfig(tsConfigPath) {
     await fs.promises.writeFile(tsConfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
-    const compilerName = 'TypeScript';
-    logger.log(`Detected using ${compilerName} but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
+    logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
 }
 
 // ./index -> default
@@ -1151,17 +1359,16 @@ Options:
   --tsconfig             path to tsconfig file, default: tsconfig.json
   --dts-bundle           bundle type declaration files, default: false
   --success <cmd>     run command after build success
-  --tsgo                use TypeScript-Go compiler for type generation
 `;
 function help() {
     logger.log(helpMessage);
 }
 async function lint(cwd) {
     // Not package.json detected, skip package linting
-    if (!await hasPackageJson(cwd)) {
+    if (!hasPackageJson(cwd)) {
         return;
     }
-    await lint$1(await getPackageMeta(cwd));
+    await lint$1(cwd);
 }
 async function parseCliArgs(argv) {
     const args = await yargs__default.default(helpers.hideBin(argv)).option('watch', {
@@ -1229,9 +1436,6 @@ async function parseCliArgs(argv) {
     }).option('success', {
         type: 'string',
         description: 'run command after build success'
-    }).option('tsgo', {
-        type: 'boolean',
-        description: 'use TypeScript-Go compiler for type generation'
     }).command('prepare', 'auto configure package.json exports for building', (yargs)=>{
         return yargs.option('esm', {
             type: 'boolean',
@@ -1274,8 +1478,7 @@ async function parseCliArgs(argv) {
         clean: args['clean'] !== false,
         env: args['env'],
         tsconfig: args['tsconfig'],
-        onSuccess: args['success'],
-        tsgo: args['tsgo']
+        onSuccess: args['success']
     };
     // When minify is enabled, sourcemap should be enabled by default, unless explicitly opted out
     if (parsedArgs.minify && typeof args['sourcemap'] === 'undefined') {
@@ -1304,20 +1507,9 @@ async function run(args) {
         env: (env == null ? void 0 : env.split(',')) || [],
         clean,
         tsconfig,
-        onSuccess,
-        tsgo: args.tsgo
+        onSuccess
     };
     const cliEntry = source ? path__default.default.resolve(cwd, source) : '';
-    // Check if ts-go is available when requested (before any build operations)
-    if (args.tsgo) {
-        try {
-            require.resolve('@typescript/native-preview', {
-                paths: module$1.Module._nodeModulePaths(cwd)
-            });
-        } catch  {
-            exit('--tsgo flag was specified but @typescript/native-preview is not installed. Please install it as a dev dependency: pnpm add -D @typescript/native-preview');
-        }
-    }
     // lint package by default
     await lint(cwd);
     const spinnerInstance = process.stdout.isTTY ? nanospinner.createSpinner('Building...\n\n', {
@@ -1329,6 +1521,8 @@ async function run(args) {
         success: ()=>{},
         isSpinning: false
     };
+    // Register spinner with logger so logs automatically pause the spinner
+    setActiveSpinner(spinnerInstance);
     const spinner = {
         start: startSpinner,
         stop: stopSpinner
@@ -1408,6 +1602,8 @@ async function run(args) {
     } else {
         spinner.stop(`bunchee ${version} build completed`);
     }
+    // Unregister spinner from logger
+    setActiveSpinner(null);
 }
 async function main() {
     let params, error;

package/dist/index.d.ts

@@ -22,7 +22,6 @@ type BundleConfig = {
     clean?: boolean;
     tsconfig?: string;
     onSuccess?: string | (() => void | Promise<void>);
-    tsgo?: boolean;
     _callbacks?: {
         onBuildStart?: (state: any) => void;
         onBuildEnd?: (assetJobs: any) => void;

package/dist/index.js

@@ -4,8 +4,8 @@ var fsp = require('fs/promises');
 var fs = require('fs');
 var path = require('path');
 require('pretty-bytes');
-var tinyglobby = require('tinyglobby');
 var require$$0 = require('tty');
+var tinyglobby = require('tinyglobby');
 var module$1 = require('module');
 var rollup = require('rollup');
 var pluginWasm = require('@rollup/plugin-wasm');
@@ -97,6 +97,13 @@ const defaultColorFn = (text)=>text;
 function color(prefixColor) {
     return pc.isColorSupported ? pc[prefixColor] : defaultColorFn;
 }
+// Store original console methods
+({
+    log: console.log.bind(console),
+    warn: console.warn.bind(console),
+    error: console.error.bind(console),
+    info: console.info.bind(console)
+});
 const logger = {
     log (...arg) {
         console.log(...arg);
@@ -299,7 +306,7 @@ function validateEntryFiles(entryFiles) {
 
 function exit(err) {
     logger.error(err);
-    throw typeof err === 'string' ? new Error(err) : err;
+    throw new Error(err) ;
 }
 async function getPackageMeta(cwd) {
     const pkgFilePath = path__default.default.resolve(cwd, 'package.json');
@@ -378,7 +385,9 @@ const getMainFieldExportType = (pkg)=>{
 };
 const isTestFile = (filename)=>/\.(test|spec)$/.test(baseNameWithoutExtension(filename));
 function joinRelativePath(...segments) {
-    let result = path__default.default.join(...segments);
+    // Normalize to forward slashes for cross-platform compatibility
+    // Export paths in package.json always use POSIX-style paths
+    let result = path__default.default.posix.join(...segments);
     // If the first segment starts with '.', ensure the result does too.
     if (segments[0] === '.' && !result.startsWith('.')) {
         result = './' + result;
@@ -430,6 +439,155 @@ function normalizePath(filePath) {
     return filePath.replace(/\\/g, '/');
 }
 
+/**
+ * Check if an export key contains a wildcard pattern
+ */ function hasWildcardPattern(exportKey) {
+    return exportKey.includes('*');
+}
+/**
+ * Replace wildcard in output path with matched subpath
+ * Example: "./dist/features/*.js" with "foo" -> "./dist/features/foo.js"
+ */ function substituteWildcardInPath(outputPath, matchedSubpath) {
+    return outputPath.replace(/\*/g, matchedSubpath);
+}
+/**
+ * Expand a wildcard export pattern by finding matching source files
+ * Returns a map of concrete export paths to their matched subpaths
+ * Example: "./features/*" with files ["foo.ts", "bar.ts"] in src/features/
+ *   -> { "./features/foo": "foo", "./features/bar": "bar" }
+ */ async function expandWildcardPattern(wildcardPattern, cwd) {
+    const expanded = new Map();
+    const sourceDir = path__default.default.join(cwd, SRC);
+    if (!fileExists(sourceDir)) {
+        return expanded;
+    }
+    // Convert wildcard pattern to glob pattern
+    // "./features/*" -> "features/*"
+    const cleanPattern = wildcardPattern.replace(/^\.\//, '');
+    // Extract the base path before the wildcard
+    // "features/*" -> "features"
+    const basePathParts = cleanPattern.split('*');
+    const basePath = basePathParts[0].replace(/\/$/, '');
+    // Build glob pattern to match files
+    // "features/*" -> "features/*.{js,ts,tsx,...}"
+    const extPattern = `{${[
+        ...availableExtensions
+    ].join(',')}}`;
+    const globPatterns = [
+        `${cleanPattern}.${extPattern}`,
+        `${cleanPattern}/index.${extPattern}`
+    ];
+    let matches = [];
+    try {
+        matches = await tinyglobby.glob(globPatterns, {
+            cwd: sourceDir,
+            ignore: [
+                PRIVATE_GLOB_PATTERN,
+                TESTS_GLOB_PATTERN
+            ],
+            expandDirectories: false
+        });
+    } catch (error) {
+        logger.warn(`Failed to expand wildcard pattern ${wildcardPattern}: ${error}`);
+        return expanded;
+    }
+    for (const match of matches){
+        // Extract the matched subpath
+        // "features/foo.ts" -> "foo"
+        // "features/bar/index.ts" -> "bar"
+        const relativePath = normalizePath(match);
+        const ext = path__default.default.extname(relativePath);
+        const withoutExt = relativePath.slice(0, -ext.length);
+        // Remove the base path to get just the matched part
+        // "features/foo" -> "foo" (when basePath is "features")
+        let matchedPart = withoutExt;
+        if (basePath && matchedPart.startsWith(basePath + '/')) {
+            matchedPart = matchedPart.slice(basePath.length + 1);
+        } else if (basePath && matchedPart === basePath) {
+            continue;
+        }
+        // Handle index files
+        let matchedSubpath;
+        if (matchedPart.endsWith('/index')) {
+            matchedSubpath = matchedPart.slice(0, -6); // Remove "/index"
+            // If there's still a path, take the last segment
+            const lastSlash = matchedSubpath.lastIndexOf('/');
+            matchedSubpath = lastSlash >= 0 ? matchedSubpath.slice(lastSlash + 1) : matchedSubpath;
+        } else {
+            // Take the first segment (what matches the *)
+            const firstSlash = matchedPart.indexOf('/');
+            matchedSubpath = firstSlash >= 0 ? matchedPart.slice(0, firstSlash) : matchedPart;
+        }
+        // Build the concrete export path
+        // "./features/*" + "foo" -> "./features/foo"
+        const concreteExportPath = basePath ? `./${basePath}/${matchedSubpath}` : `./${matchedSubpath}`;
+        expanded.set(concreteExportPath, matchedSubpath);
+    }
+    return expanded;
+}
+
+/**
+ * Process export value for wildcard patterns, substituting wildcards in output paths
+ */ async function processWildcardExportValue(exportValue, originalExportKey, currentPath, exportTypes, exportToDist, matchedSubpath) {
+    // End of searching, export value is file path.
+    // <export key>: <export value> (string)
+    if (typeof exportValue === 'string') {
+        const composedTypes = new Set(exportTypes);
+        const exportType = originalExportKey.startsWith('.') ? 'default' : originalExportKey;
+        composedTypes.add(exportType);
+        const exportInfo = exportToDist.get(mapExportFullPath(currentPath));
+        const exportCondition = Array.from(composedTypes).join('.');
+        // Substitute wildcard in output path
+        const substitutedPath = substituteWildcardInPath(exportValue, matchedSubpath);
+        if (!exportInfo) {
+            const outputConditionPair = [
+                substitutedPath,
+                exportCondition
+            ];
+            addToExportDistMap(exportToDist, currentPath, [
+                outputConditionPair
+            ]);
+        } else {
+            exportInfo.push([
+                substitutedPath,
+                exportCondition
+            ]);
+        }
+        return;
+    }
+    const exportKeys = Object.keys(exportValue);
+    for (const exportKey of exportKeys){
+        // Clone the set to avoid modifying the parent set
+        const childExports = new Set(exportTypes);
+        // Normalize child export value to a map
+        const childExportValue = exportValue[exportKey];
+        // Substitute wildcard in nested string values
+        let processedChildValue = childExportValue;
+        if (typeof childExportValue === 'string') {
+            processedChildValue = substituteWildcardInPath(childExportValue, matchedSubpath);
+        } else if (typeof childExportValue === 'object' && childExportValue !== null) {
+            // Recursively process nested objects
+            const processed = {};
+            for (const [key, value] of Object.entries(childExportValue)){
+                if (typeof value === 'string') {
+                    processed[key] = substituteWildcardInPath(value, matchedSubpath);
+                } else if (value !== null && value !== undefined) {
+                    processed[key] = value;
+                }
+            }
+            processedChildValue = processed;
+        }
+        // Visit export path: ./subpath, ./subpath2, ...
+        if (exportKey.startsWith('.')) {
+            const childPath = joinRelativePath(currentPath, exportKey);
+            await processWildcardExportValue(processedChildValue, exportKey, childPath, childExports, exportToDist, matchedSubpath);
+        } else {
+            // Visit export type: import, require, ...
+            childExports.add(exportKey);
+            await processWildcardExportValue(processedChildValue, exportKey, currentPath, childExports, exportToDist, matchedSubpath);
+        }
+    }
+}
 function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exportToDist) {
     // End of searching, export value is file path.
     // <export key>: <export value> (string)
@@ -491,7 +649,7 @@ function addToExportDistMap(exportToDist, exportPath, outputConditionPairs) {
  *  './index': { development: ..., default: ... }
  *  './index.react-server': { development: ..., default: ... }
  * }
- */ function parseExports(pkg) {
+ */ async function parseExports(pkg, cwd) {
     var _pkg_exports;
     const exportsField = (_pkg_exports = pkg.exports) != null ? _pkg_exports : {};
     var _pkg_bin;
@@ -515,6 +673,17 @@ function addToExportDistMap(exportToDist, exportPath, outputConditionPairs) {
             const exportValue = exportsField[exportKey];
             const exportTypes = new Set();
             const isExportPath = exportKey.startsWith('.');
+            // Handle wildcard patterns
+            if (isExportPath && hasWildcardPattern(exportKey) && cwd) {
+                // Expand wildcard pattern to concrete exports
+                const expanded = await expandWildcardPattern(exportKey, cwd);
+                for (const [concreteExportPath, matchedSubpath] of expanded){
+                    const childPath = joinRelativePath(currentPath, concreteExportPath);
+                    // Process the export value and substitute wildcards in output paths
+                    await processWildcardExportValue(exportValue, exportKey, childPath, exportTypes, exportToDist, matchedSubpath);
+                }
+                continue;
+            }
             const childPath = isExportPath ? joinRelativePath(currentPath, exportKey) : currentPath;
             if (!isExportPath) {
                 exportTypes.add(exportKey);
@@ -1034,40 +1203,7 @@ const memoizeByKey = (fn)=>{
 const memoize = (fn)=>createMemoize(fn);
 
 let hasLoggedTsWarning = false;
-let hasLoggedTsGoWarning = false;
-function resolveTsGo(cwd) {
-    let tsgo;
-    const m = new module$1.Module('', undefined);
-    m.paths = module$1.Module._nodeModulePaths(cwd);
-    try {
-        // Bun does not yet support the `Module` class properly.
-        if (typeof (m == null ? void 0 : m.require) === 'undefined') {
-            const tsgoPath = require.resolve('@typescript/native-preview', {
-                paths: module$1.Module._nodeModulePaths(cwd)
-            });
-            tsgo = require(tsgoPath);
-        } else {
-            tsgo = m.require('@typescript/native-preview');
-        }
-        // ts-go exports the TypeScript API as default or named export
-        return tsgo.default || tsgo;
-    } catch (e) {
-        if (!hasLoggedTsGoWarning) {
-            hasLoggedTsGoWarning = true;
-            logger.warn('Could not load TypeScript-Go compiler. Make sure `@typescript/native-preview` is installed as a dev dependency.');
-        }
-        return null;
-    }
-}
-function resolveTypescript(cwd, useTsGo) {
-    if (useTsGo) {
-        const tsgo = resolveTsGo(cwd);
-        if (tsgo) {
-            return tsgo;
-        }
-        // Error if ts-go is requested but not available
-        exit('TypeScript-Go compiler not found. Please install @typescript/native-preview as a dev dependency: pnpm add -D @typescript/native-preview');
-    }
+function resolveTypescript(cwd) {
     let ts;
     const m = new module$1.Module('', undefined);
     m.paths = module$1.Module._nodeModulePaths(cwd);
@@ -1095,11 +1231,11 @@ const resolveTsConfigPath = memoize((cwd, tsconfigFileName = 'tsconfig.json')=>{
     tsConfigPath = path.resolve(cwd, tsconfigFileName);
     return fileExists(tsConfigPath) ? tsConfigPath : undefined;
 });
-function resolveTsConfigHandler(cwd, tsConfigPath, useTsGo) {
+function resolveTsConfigHandler(cwd, tsConfigPath) {
     let tsCompilerOptions = {};
     if (tsConfigPath) {
         // Use the original ts handler to avoid memory leak
-        const ts = resolveTypescript(cwd, useTsGo);
+        const ts = resolveTypescript(cwd);
         const basePath = tsConfigPath ? path.dirname(tsConfigPath) : cwd;
         const tsconfigJSON = ts.readConfigFile(tsConfigPath, ts.sys.readFile).config;
         tsCompilerOptions = ts.parseJsonConfigFileContent(tsconfigJSON, ts.sys, basePath).options;
@@ -1111,28 +1247,24 @@ function resolveTsConfigHandler(cwd, tsConfigPath, useTsGo) {
         tsConfigPath
     };
 }
-// Note: We can't memoize resolveTsConfigHandler directly with useTsGo parameter
-// because memoize doesn't handle optional parameters well. Instead, we'll create
-// a wrapper that handles the memoization per useTsGo value.
 const resolveTsConfigCache = new Map();
-function resolveTsConfig(cwd, tsConfigPath, useTsGo) {
-    const cacheKey = `${cwd}:${tsConfigPath || ''}:${useTsGo ? 'tsgo' : 'ts'}`;
+function resolveTsConfig(cwd, tsConfigPath) {
+    const cacheKey = `${cwd}:${tsConfigPath || ''}`;
     if (resolveTsConfigCache.has(cacheKey)) {
         return resolveTsConfigCache.get(cacheKey);
     }
-    const result = resolveTsConfigHandler(cwd, tsConfigPath, useTsGo);
+    const result = resolveTsConfigHandler(cwd, tsConfigPath);
     resolveTsConfigCache.set(cacheKey, result);
     return result;
 }
-async function convertCompilerOptions(cwd, json, useTsGo) {
+async function convertCompilerOptions(cwd, json) {
     // Use the original ts handler to avoid memory leak
-    const ts = resolveTypescript(cwd, useTsGo);
+    const ts = resolveTypescript(cwd);
     return ts.convertCompilerOptionsFromJson(json, './');
 }
-async function writeDefaultTsconfig(tsConfigPath, useTsGo) {
+async function writeDefaultTsconfig(tsConfigPath) {
     await fs.promises.writeFile(tsConfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
-    const compilerName = useTsGo ? 'TypeScript-Go' : 'TypeScript';
-    logger.log(`Detected using ${compilerName} but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
+    logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
 }
 
 /**
@@ -1640,7 +1772,7 @@ const swcMinifyOptions = {
         toplevel: true
     }
 };
-async function createDtsPlugin(tsCompilerOptions, tsConfigPath, respectExternal, cwd, useTsGo) {
+async function createDtsPlugin(tsCompilerOptions, tsConfigPath, respectExternal, cwd) {
     const enableIncrementalWithoutBuildInfo = (tsCompilerOptions == null ? void 0 : tsCompilerOptions.incremental) && !(tsCompilerOptions == null ? void 0 : tsCompilerOptions.tsBuildInfoFile);
     const incrementalOptions = enableIncrementalWithoutBuildInfo ? {
         incremental: false
@@ -1667,31 +1799,7 @@ async function createDtsPlugin(tsCompilerOptions, tsConfigPath, respectExternal,
         ...incrementalOptions,
         // error TS6379: Composite projects may not disable incremental compilation.
         ...compositeOptions
-    }, useTsGo);
-    // If useTsGo is enabled, we need to make ts-go available to rollup-plugin-dts
-    // rollup-plugin-dts uses require('typescript') internally, so we need to
-    // temporarily override the module cache to use ts-go
-    if (useTsGo) {
-        const tsgo = resolveTsGo(cwd);
-        if (tsgo) {
-            try {
-                // First, try to resolve typescript to get its path
-                const tsPath = require.resolve('typescript', {
-                    paths: module$1.Module._nodeModulePaths(cwd)
-                });
-                // Make ts-go available as 'typescript' for rollup-plugin-dts
-                // This overrides the module cache so rollup-plugin-dts will use ts-go
-                require.cache[tsPath] = {
-                    id: tsPath,
-                    exports: tsgo,
-                    loaded: true
-                };
-            } catch (e) {
-            // If typescript cannot be resolved, we can't override it
-            // rollup-plugin-dts will try to require it and may fail
-            }
-        }
-    }
+    });
     const dtsPlugin = require('rollup-plugin-dts').default({
         tsconfig: tsConfigPath,
         compilerOptions: overrideResolvedTsOptions,
@@ -1785,8 +1893,8 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
         // Each process should be unique
         // Each package build should be unique
         // Composing above factors into a unique cache key to retrieve the memoized dts plugin with tsconfigs
-        const uniqueProcessId = 'dts-plugin:' + process.pid + tsConfigPath + (buildContext.useTsGo ? ':tsgo' : '');
-        const dtsPlugin = await memoizeDtsPluginByKey(uniqueProcessId)(tsCompilerOptions, tsConfigPath, bundleConfig.dts && bundleConfig.dts.respectExternal, cwd, buildContext.useTsGo);
+        const uniqueProcessId = 'dts-plugin:' + process.pid + tsConfigPath;
+        const dtsPlugin = await memoizeDtsPluginByKey(uniqueProcessId)(tsCompilerOptions, tsConfigPath, bundleConfig.dts && bundleConfig.dts.respectExternal, cwd);
         typesPlugins.push(dtsPlugin);
     }
     const plugins = (dts ? typesPlugins : [
@@ -2257,23 +2365,14 @@ async function bundle(cliEntryPath, { cwd: _cwd, onSuccess, ...options } = {}) {
     assignDefault(options, 'minify', false);
     assignDefault(options, 'target', 'es2015');
     const pkg = await getPackageMeta(cwd);
-    const parsedExportsInfo = parseExports(pkg);
+    const parsedExportsInfo = await parseExports(pkg, cwd);
     const isMultiEntries = hasMultiEntryExport(parsedExportsInfo);
     const hasBin = Boolean(pkg.bin);
     // Original input file path, client path might change later
     const inputFile = cliEntryPath;
     const isFromCli = Boolean(cliEntryPath);
-    const useTsGo = options.tsgo === true;
-    // Check if ts-go is available when requested (before resolving tsconfig)
-    let tsgoInstance = null;
-    if (useTsGo) {
-        tsgoInstance = resolveTsGo(cwd);
-        if (!tsgoInstance) {
-            exit('--tsgo flag was specified but @typescript/native-preview is not installed. Please install it as a dev dependency: pnpm add -D @typescript/native-preview');
-        }
-    }
     const tsConfigPath = resolveTsConfigPath(cwd, options.tsconfig);
-    let tsConfig = resolveTsConfig(cwd, tsConfigPath, useTsGo);
+    let tsConfig = resolveTsConfig(cwd, tsConfigPath);
     let hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
     const defaultTsOptions = {
         tsConfigPath: tsConfig == null ? void 0 : tsConfig.tsConfigPath,
@@ -2343,7 +2442,7 @@ async function bundle(cliEntryPath, { cwd: _cwd, onSuccess, ...options } = {}) {
         // Otherwise, use the existing one.
         const defaultTsConfigPath = path.resolve(cwd, 'tsconfig.json');
         if (!fileExists(defaultTsConfigPath)) {
-            await writeDefaultTsconfig(defaultTsConfigPath, useTsGo);
+            await writeDefaultTsconfig(defaultTsConfigPath);
         }
         defaultTsOptions.tsConfigPath = defaultTsConfigPath;
         hasTsConfig = true;
@@ -2355,15 +2454,12 @@ async function bundle(cliEntryPath, { cwd: _cwd, onSuccess, ...options } = {}) {
     const outputState = createOutputState({
         entries
     });
-    // Use ts-go if it was successfully resolved earlier
-    const useTsGoInContext = Boolean(useTsGo && hasTsConfig && tsgoInstance);
     const buildContext = {
         entries,
         pkg,
         cwd,
         tsOptions: defaultTsOptions,
         useTypeScript: hasTsConfig,
-        useTsGo: useTsGoInContext,
         browserslistConfig,
         pluginContext: {
             outputState,

package/package.json

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