bunchee 6.6.2 → 6.7.0

package/README.md

@@ -317,6 +317,23 @@ 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:
+
+```sh
+bunchee --tsgo
+```
+
+**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:
@@ -365,6 +382,14 @@ 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"],
@@ -545,6 +570,7 @@ 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

@@ -198,7 +198,7 @@ function validateEntryFiles(entryFiles) {
 
 function exit(err) {
     logger.error(err);
-    process.exit(1);
+    throw typeof err === 'string' ? new Error(err) : err;
 }
 function hasPackageJson(cwd) {
     return fileExists(path__default.default.resolve(cwd, 'package.json'));
@@ -647,11 +647,12 @@ function lint$1(pkg) {
     }
 }
 
-var version = "6.6.2";
+var version = "6.7.0";
 
-async function writeDefaultTsconfig(tsConfigPath) {
+async function writeDefaultTsconfig(tsConfigPath, useTsGo) {
     await fs.promises.writeFile(tsConfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
-    logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
+    const compilerName = 'TypeScript';
+    logger.log(`Detected using ${compilerName} but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
 }
 
 // ./index -> default
@@ -1082,7 +1083,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
-  
+
   --external <mod>       specify an external dependency, separate by comma
   --no-external          do not bundle external dependencies
   --no-clean             do not clean dist folder before building, default: false
@@ -1095,6 +1096,7 @@ 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);
@@ -1172,6 +1174,9 @@ 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', ()=>{}, (argv)=>{
         return prepare(argv.cwd || process.cwd());
     }).command('lint', 'lint package.json', ()=>{}, (argv)=>{
@@ -1207,7 +1212,8 @@ async function parseCliArgs(argv) {
         clean: args['clean'] !== false,
         env: args['env'],
         tsconfig: args['tsconfig'],
-        onSuccess: args['success']
+        onSuccess: args['success'],
+        tsgo: args['tsgo']
     };
     // When minify is enabled, sourcemap should be enabled by default, unless explicitly opted out
     if (parsedArgs.minify && typeof args['sourcemap'] === 'undefined') {
@@ -1236,9 +1242,22 @@ async function run(args) {
         env: (env == null ? void 0 : env.split(',')) || [],
         clean,
         tsconfig,
-        onSuccess
+        onSuccess,
+        tsgo: args.tsgo
     };
     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: [
+                    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', {
@@ -1389,4 +1408,7 @@ function logError(err) {
     const error = normalizeError(err);
     logger.error(error);
 }
-main().catch(exit);
+main().catch((error)=>{
+    logError(error);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -22,6 +22,7 @@ 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

@@ -299,7 +299,7 @@ function validateEntryFiles(entryFiles) {
 
 function exit(err) {
     logger.error(err);
-    process.exit(1);
+    throw typeof err === 'string' ? new Error(err) : err;
 }
 async function getPackageMeta(cwd) {
     const pkgFilePath = path__default.default.resolve(cwd, 'package.json');
@@ -1034,7 +1034,42 @@ const memoizeByKey = (fn)=>{
 const memoize = (fn)=>createMemoize(fn);
 
 let hasLoggedTsWarning = false;
-function resolveTypescript(cwd) {
+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: [
+                    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');
+    }
     let ts;
     const m = new module$1.Module('', undefined);
     m.paths = module$1.Module._nodeModulePaths(cwd);
@@ -1064,11 +1099,11 @@ const resolveTsConfigPath = memoize((cwd, tsconfigFileName = 'tsconfig.json')=>{
     tsConfigPath = path.resolve(cwd, tsconfigFileName);
     return fileExists(tsConfigPath) ? tsConfigPath : undefined;
 });
-function resolveTsConfigHandler(cwd, tsConfigPath) {
+function resolveTsConfigHandler(cwd, tsConfigPath, useTsGo) {
     let tsCompilerOptions = {};
     if (tsConfigPath) {
         // Use the original ts handler to avoid memory leak
-        const ts = resolveTypescript(cwd);
+        const ts = resolveTypescript(cwd, useTsGo);
         const basePath = tsConfigPath ? path.dirname(tsConfigPath) : cwd;
         const tsconfigJSON = ts.readConfigFile(tsConfigPath, ts.sys.readFile).config;
         tsCompilerOptions = ts.parseJsonConfigFileContent(tsconfigJSON, ts.sys, basePath).options;
@@ -1080,15 +1115,28 @@ function resolveTsConfigHandler(cwd, tsConfigPath) {
         tsConfigPath
     };
 }
-const resolveTsConfig = memoize(resolveTsConfigHandler);
-async function convertCompilerOptions(cwd, json) {
+// 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'}`;
+    if (resolveTsConfigCache.has(cacheKey)) {
+        return resolveTsConfigCache.get(cacheKey);
+    }
+    const result = resolveTsConfigHandler(cwd, tsConfigPath, useTsGo);
+    resolveTsConfigCache.set(cacheKey, result);
+    return result;
+}
+async function convertCompilerOptions(cwd, json, useTsGo) {
     // Use the original ts handler to avoid memory leak
-    const ts = resolveTypescript(cwd);
+    const ts = resolveTypescript(cwd, useTsGo);
     return ts.convertCompilerOptionsFromJson(json, './');
 }
-async function writeDefaultTsconfig(tsConfigPath) {
+async function writeDefaultTsconfig(tsConfigPath, useTsGo) {
     await fs.promises.writeFile(tsConfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
-    logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
+    const compilerName = useTsGo ? 'TypeScript-Go' : 'TypeScript';
+    logger.log(`Detected using ${compilerName} but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
 }
 
 /**
@@ -1468,7 +1516,7 @@ const swcMinifyOptions = {
         toplevel: true
     }
 };
-async function createDtsPlugin(tsCompilerOptions, tsConfigPath, respectExternal, cwd) {
+async function createDtsPlugin(tsCompilerOptions, tsConfigPath, respectExternal, cwd, useTsGo) {
     const enableIncrementalWithoutBuildInfo = (tsCompilerOptions == null ? void 0 : tsCompilerOptions.incremental) && !(tsCompilerOptions == null ? void 0 : tsCompilerOptions.tsBuildInfoFile);
     const incrementalOptions = enableIncrementalWithoutBuildInfo ? {
         incremental: false
@@ -1495,7 +1543,33 @@ 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: [
+                        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,
@@ -1589,8 +1663,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;
-        const dtsPlugin = await memoizeDtsPluginByKey(uniqueProcessId)(tsCompilerOptions, tsConfigPath, bundleConfig.dts && bundleConfig.dts.respectExternal, cwd);
+        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);
         typesPlugins.push(dtsPlugin);
     }
     const plugins = (dts ? typesPlugins : [
@@ -1987,8 +2061,17 @@ async function bundle(cliEntryPath, { cwd: _cwd, onSuccess, ...options } = {}) {
     // 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);
+    let tsConfig = resolveTsConfig(cwd, tsConfigPath, useTsGo);
     let hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
     const defaultTsOptions = {
         tsConfigPath: tsConfig == null ? void 0 : tsConfig.tsConfigPath,
@@ -2058,7 +2141,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);
+            await writeDefaultTsconfig(defaultTsConfigPath, useTsGo);
         }
         defaultTsOptions.tsConfigPath = defaultTsConfigPath;
         hasTsConfig = true;
@@ -2070,12 +2153,15 @@ 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.6.2",
+  "version": "6.7.0",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",
@@ -37,7 +37,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-replace": "^6.0.2",
@@ -51,7 +51,7 @@
     "picomatch": "^4.0.2",
     "pretty-bytes": "^5.6.0",
     "rollup": "^4.52.4",
-    "rollup-plugin-dts": "^6.2.3",
+    "rollup-plugin-dts": "^6.3.0",
     "rollup-plugin-swc3": "^0.11.1",
     "rollup-preserve-directives": "^1.1.3",
     "tinyglobby": "^0.2.14",
@@ -59,7 +59,8 @@
     "yargs": "^17.7.2"
   },
   "peerDependencies": {
-    "typescript": "^4.1 || ^5.0"
+    "typescript": "^4.1 || ^5.0",
+    "@typescript/native-preview": "*"
   },
   "peerDependenciesMeta": {
     "typescript": {
@@ -67,6 +68,9 @@
     },
     "@swc/helpers": {
       "optional": true
+    },
+    "@typescript/native-preview": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -79,16 +83,17 @@
     "@types/picomatch": "^3.0.1",
     "@types/react": "^19.0.9",
     "@types/yargs": "^17.0.33",
+    "@typescript/native-preview": "*",
     "bunchee": "link:./",
     "cross-env": "^7.0.3",
     "husky": "^9.0.11",
     "lint-staged": "^15.2.2",
-    "next": "16.0.0-canary.1",
+    "next": "16.0.10",
     "picocolors": "^1.0.0",
     "postcss": "^8.5.4",
     "prettier": "3.4.2",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
+    "react": "^19.2.1",
+    "react-dom": "^19.2.1",
     "tailwindcss": "^4.1.8",
     "typescript": "^5.9.2",
     "vitest": "^3.0.4"
@@ -100,7 +105,7 @@
     "test": "vitest run",
     "test:update": "TEST_UPDATE_SNAPSHOT=1 pnpm test",
     "test:post": "cross-env POST_BUILD=1 pnpm test test/compile.test.ts test/integration.test.ts",
-    "docs:dev": "next dev docs",
+    "site": "next dev docs",
     "docs:build": "next build docs",
     "clean": "rm -rf ./dist",
     "new-test": "node ./scripts/new-test.js",