bunchee 6.8.0 → 6.8.2

package/README.md

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

@@ -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);
@@ -437,13 +483,13 @@ function validateFilesField(packageJson) {
         '*'
     ];
     const exportsField = packageJson.exports || {};
-    const resolveExportsPaths = (exports$1)=>{
+    const resolveExportsPaths = (exports)=>{
         const paths = [];
-        if (typeof exports$1 === 'string') {
-            paths.push(exports$1);
-        } else if (typeof exports$1 === 'object') {
-            for(const key in exports$1){
-                paths.push(...resolveExportsPaths(exports$1[key]));
+        if (typeof exports === 'string') {
+            paths.push(exports);
+        } else if (typeof exports === 'object') {
+            for(const key in exports){
+                paths.push(...resolveExportsPaths(exports[key]));
             }
         }
         return paths;
@@ -470,7 +516,7 @@ function validateFilesField(packageJson) {
     return state;
 }
 function lint$1(pkg) {
-    const { name, main, exports: exports$1 } = pkg;
+    const { name, main, exports } = pkg;
     const isESM = isESModulePackage(pkg.type);
     const parsedExports = parseExports(pkg);
     if (!name) {
@@ -500,12 +546,12 @@ function lint$1(pkg) {
     };
     // Validate ESM package
     if (isESM) {
-        if (exports$1) {
-            if (typeof exports$1 === 'string') {
-                if (hasCjsExtension(exports$1)) {
+        if (exports) {
+            if (typeof exports === 'string') {
+                if (hasCjsExtension(exports)) {
                     exportsState.badMainExport = true;
                 }
-            } else if (typeof exports$1 !== 'object') {
+            } else if (typeof exports !== 'object') {
                 exportsState.invalidExportsFieldType = true;
             } else {
                 parsedExports.forEach((outputPairs)=>{
@@ -548,12 +594,12 @@ function lint$1(pkg) {
         if (main && path__default.default.extname(main) === '.mjs') {
             exportsState.badMainExtension = true;
         }
-        if (exports$1) {
-            if (typeof exports$1 === 'string') {
-                if (path__default.default.extname(exports$1) === '.mjs') {
+        if (exports) {
+            if (typeof exports === 'string') {
+                if (path__default.default.extname(exports) === '.mjs') {
                     exportsState.badMainExport = true;
                 }
-            } else if (typeof exports$1 !== 'object') {
+            } else if (typeof exports !== 'object') {
                 exportsState.invalidExportsFieldType = true;
             } else {
                 parsedExports.forEach((outputPairs)=>{
@@ -647,12 +693,11 @@ function lint$1(pkg) {
     }
 }
 
-var version = "6.8.0";
+var version = "6.8.2";
 
-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,7 +1196,6 @@ 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);
@@ -1229,9 +1273,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 +1315,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,22 +1344,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: [
-                    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', {
@@ -1331,6 +1358,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
@@ -1410,6 +1439,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');
@@ -1034,42 +1041,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: [
-                    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);
@@ -1077,9 +1049,7 @@ function resolveTypescript(cwd, useTsGo) {
         // Bun does not yet support the `Module` class properly.
         if (typeof (m == null ? void 0 : m.require) === 'undefined') {
             const tsPath = require.resolve('typescript', {
-                paths: [
-                    cwd
-                ]
+                paths: module$1.Module._nodeModulePaths(cwd)
             });
             ts = require(tsPath);
         } else {
@@ -1099,11 +1069,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;
@@ -1115,28 +1085,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.`);
 }
 
 /**
@@ -1644,7 +1610,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
@@ -1671,33 +1637,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: [
-                        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,
@@ -1791,8 +1731,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 : [
@@ -2269,17 +2209,8 @@ 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, useTsGo);
+    let tsConfig = resolveTsConfig(cwd, tsConfigPath);
     let hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
     const defaultTsOptions = {
         tsConfigPath: tsConfig == null ? void 0 : tsConfig.tsConfigPath,
@@ -2349,7 +2280,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;
@@ -2361,15 +2292,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.0",
+  "version": "6.8.2",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",