bunchee 6.7.0 → 6.8.1

package/README.md

@@ -323,10 +323,6 @@ TypeScript-Go (`@typescript/native-preview`) is a high-performance, Go-based imp
 
 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

package/dist/bin/cli.js

@@ -1,5 +1,6 @@
 #!/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');
@@ -8,7 +9,6 @@ var fsp = require('fs/promises');
 var require$$0 = require('tty');
 var picomatch = require('picomatch');
 var index_js = require('../index.js');
-require('module');
 var tinyglobby = require('tinyglobby');
 var prettyBytes = require('pretty-bytes');
 var nanospinner = require('nanospinner');
@@ -647,7 +647,7 @@ function lint$1(pkg) {
     }
 }
 
-var version = "6.7.0";
+var version = "6.8.1";
 
 async function writeDefaultTsconfig(tsConfigPath, useTsGo) {
     await fs.promises.writeFile(tsConfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
@@ -827,7 +827,7 @@ const normalizeBaseNameToExportName = (name)=>{
     const baseName = stripeBinaryTag(name);
     return /^\.\/index(\.|$)/.test(baseName) ? '.' : posixRelativify(baseName);
 };
-function createExportCondition(exportName, sourceFile, moduleType) {
+function createExportCondition(exportName, sourceFile, moduleType, esmOnly = false) {
     const isTsSourceFile = isTypescriptFile(sourceFile);
     let cjsExtension = 'js';
     let esmExtension = 'mjs';
@@ -839,23 +839,31 @@ function createExportCondition(exportName, sourceFile, moduleType) {
         exportName = 'index';
     }
     if (isTsSourceFile) {
+        const importCondition = {
+            types: getDistPath('es', `${exportName}.${dtsExtensionsMap[esmExtension]}`),
+            default: getDistPath('es', `${exportName}.${esmExtension}`)
+        };
+        if (esmOnly) {
+            return importCondition;
+        }
         return {
-            import: {
-                types: getDistPath('es', `${exportName}.${dtsExtensionsMap[esmExtension]}`),
-                default: getDistPath('es', `${exportName}.${esmExtension}`)
-            },
+            import: importCondition,
             require: {
                 types: getDistPath('cjs', `${exportName}.${dtsExtensionsMap[cjsExtension]}`),
                 default: getDistPath('cjs', `${exportName}.${cjsExtension}`)
             }
         };
     }
+    const importPath = getDistPath(`${exportName}.${esmExtension}`);
+    if (esmOnly) {
+        return importPath;
+    }
     return {
-        import: getDistPath(`${exportName}.mjs`),
+        import: importPath,
         require: getDistPath(`${exportName}.${cjsExtension}`)
     };
 }
-function createExportConditionPair(exportName, sourceFile, moduleType) {
+function createExportConditionPair(exportName, sourceFile, moduleType, esmOnly = false) {
     // <exportName>.<specialCondition>
     let specialCondition;
     const specialConditionName = getSpecialExportTypeFromComposedExportPath(exportName);
@@ -873,13 +881,39 @@ function createExportConditionPair(exportName, sourceFile, moduleType) {
             specialCondition
         ];
     }
-    const exportCond = createExportCondition(exportName, sourceFile, moduleType);
+    const exportCond = createExportCondition(exportName, sourceFile, moduleType, esmOnly);
     return [
         normalizedExportPath,
         exportCond
     ];
 }
-async function prepare(cwd) {
+function detectPackageManager(cwd) {
+    if (fs__default.default.existsSync(path__default.default.join(cwd, 'pnpm-lock.yaml'))) {
+        return 'pnpm';
+    }
+    if (fs__default.default.existsSync(path__default.default.join(cwd, 'yarn.lock'))) {
+        return 'yarn';
+    }
+    if (fs__default.default.existsSync(path__default.default.join(cwd, 'package-lock.json'))) {
+        return 'npm';
+    }
+    // Default to npm if no lock file found
+    return 'npm';
+}
+function addBuildScripts(pkgJson, cwd) {
+    if (!pkgJson.scripts) {
+        pkgJson.scripts = {};
+    }
+    const packageManager = detectPackageManager(cwd);
+    const buildCmd = packageManager === 'pnpm' ? 'pnpm build' : `${packageManager} run build`;
+    if (!pkgJson.scripts.build) {
+        pkgJson.scripts.build = 'bunchee';
+    }
+    if (!pkgJson.scripts.prepublishOnly) {
+        pkgJson.scripts.prepublishOnly = buildCmd;
+    }
+}
+async function prepare(cwd, options) {
     const sourceFolder = path__default.default.resolve(cwd, SRC);
     if (!fs__default.default.existsSync(sourceFolder)) {
         logger.error(`Source folder ${sourceFolder} does not exist. Cannot proceed to configure \`exports\` field.`);
@@ -921,7 +955,8 @@ async function prepare(cwd) {
         }
     }
     // Configure as ESM package by default if there's no package.json
-    if (!hasPackageJson) {
+    // OR if --esm flag is explicitly set
+    if (!hasPackageJson || (options == null ? void 0 : options.esm)) {
         pkgJson.type = 'module';
     }
     if (bins.size > 0) {
@@ -951,24 +986,40 @@ async function prepare(cwd) {
             }
         }
         const pkgExports = {};
+        const esmOnly = (options == null ? void 0 : options.esm) === true;
         for (const [exportName, sourceFilesMap] of exportsEntries.entries()){
             for (const sourceFile of Object.values(sourceFilesMap)){
-                const [normalizedExportPath, conditions] = createExportConditionPair(exportName, sourceFile, pkgJson.type);
-                pkgExports[normalizedExportPath] = {
-                    ...conditions,
-                    ...pkgExports[normalizedExportPath]
-                };
+                const [normalizedExportPath, conditions] = createExportConditionPair(exportName, sourceFile, pkgJson.type, esmOnly);
+                // When esmOnly is true, conditions is either a string or an object with types/default (no import/require)
+                // When esmOnly is false, conditions is an object with import/require
+                if (esmOnly || typeof conditions === 'string' || typeof conditions === 'object' && conditions !== null && !('import' in conditions || 'require' in conditions)) {
+                    pkgExports[normalizedExportPath] = conditions;
+                } else {
+                    pkgExports[normalizedExportPath] = {
+                        ...conditions,
+                        ...pkgExports[normalizedExportPath]
+                    };
+                }
             }
         }
         // Configure node10 module resolution
         if (exportsEntries.has('./index')) {
             const isESM = pkgJson.type === 'module';
             const mainExport = pkgExports['.'];
-            const mainCondition = isESM ? 'import' : 'require';
-            pkgJson.main = isUsingTs ? mainExport[mainCondition].default : mainExport[mainCondition];
-            pkgJson.module = isUsingTs ? mainExport.import.default : mainExport.import;
-            if (isUsingTs) {
-                pkgJson.types = mainExport[mainCondition].types;
+            if (esmOnly) {
+                // When esmOnly is true, mainExport is either a string or an object with types/default
+                pkgJson.main = isUsingTs ? typeof mainExport === 'object' ? mainExport.default : mainExport : typeof mainExport === 'string' ? mainExport : mainExport.default;
+                pkgJson.module = isUsingTs ? typeof mainExport === 'object' ? mainExport.default : mainExport : typeof mainExport === 'string' ? mainExport : mainExport.default;
+                if (isUsingTs && typeof mainExport === 'object') {
+                    pkgJson.types = mainExport.types;
+                }
+            } else {
+                const mainCondition = isESM ? 'import' : 'require';
+                pkgJson.main = isUsingTs ? mainExport[mainCondition].default : mainExport[mainCondition];
+                pkgJson.module = isUsingTs ? mainExport.import.default : mainExport.import;
+                if (isUsingTs) {
+                    pkgJson.types = mainExport[mainCondition].types;
+                }
             }
         }
         // Assign the properties by order: files, main, module, types, exports
@@ -988,6 +1039,10 @@ async function prepare(cwd) {
             }
         }
     }
+    // Additional setup when --esm flag is set
+    if (options == null ? void 0 : options.esm) {
+        addBuildScripts(pkgJson, cwd);
+    }
     await fsp__default.default.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + '\n');
     logger.info('Configured `exports` in package.json');
 }
@@ -1177,8 +1232,15 @@ async function parseCliArgs(argv) {
     }).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('prepare', 'auto configure package.json exports for building', (yargs)=>{
+        return yargs.option('esm', {
+            type: 'boolean',
+            description: 'configure package as ESM (sets type: "module")'
+        });
+    }, (argv)=>{
+        return prepare(argv.cwd || process.cwd(), {
+            esm: argv.esm
+        });
     }).command('lint', 'lint package.json', ()=>{}, (argv)=>{
         return lint(argv.cwd || process.cwd());
     }).version(version).help('help', 'output usage information').showHelpOnFail(true).parse();
@@ -1250,9 +1312,7 @@ async function run(args) {
     if (args.tsgo) {
         try {
             require.resolve('@typescript/native-preview', {
-                paths: [
-                    cwd
-                ]
+                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');

package/dist/index.d.ts

@@ -37,6 +37,7 @@ type PackageMetadata = {
     files?: string[];
     type?: 'commonjs' | 'module';
     dependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
     peerDependencies?: Record<string, string>;
     peerDependenciesMeta?: Record<string, Record<string, string>>;
     exports?: string | Record<string, ExportCondition>;

package/dist/index.js

@@ -1043,9 +1043,7 @@ function resolveTsGo(cwd) {
         // 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
-                ]
+                paths: module$1.Module._nodeModulePaths(cwd)
             });
             tsgo = require(tsgoPath);
         } else {
@@ -1077,9 +1075,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 {
@@ -1375,6 +1371,89 @@ function rawContent({ exclude }) {
     };
 }
 
+const NATIVE_ADDON_SUFFIX = '\0native-addon:';
+/**
+ * Plugin to handle native Node.js addon (.node) files.
+ * Copies the binary to the output directory and rewrites import paths.
+ */ function nativeAddon() {
+    // Map from virtual module id to original absolute path
+    const nativeAddonMap = new Map();
+    return {
+        name: 'native-addon',
+        resolveId (source, importer) {
+            // Check if this is a .node file import
+            if (!source.endsWith('.node')) {
+                return null;
+            }
+            // Resolve the absolute path of the .node file
+            let absolutePath;
+            if (path__default.default.isAbsolute(source)) {
+                absolutePath = source;
+            } else if (importer) {
+                absolutePath = path__default.default.resolve(path__default.default.dirname(importer), source);
+            } else {
+                return null;
+            }
+            // Create a virtual module id for this native addon
+            const virtualId = NATIVE_ADDON_SUFFIX + absolutePath;
+            // Track the mapping
+            nativeAddonMap.set(virtualId, absolutePath);
+            return virtualId;
+        },
+        async load (id) {
+            if (!id.startsWith(NATIVE_ADDON_SUFFIX)) {
+                return null;
+            }
+            const absolutePath = nativeAddonMap.get(id);
+            if (!absolutePath) {
+                return null;
+            }
+            // Get the filename for the output
+            const fileName = path__default.default.basename(absolutePath);
+            // Return code that will require the binary from the same directory
+            // Using __dirname to get the directory of the output file at runtime
+            return {
+                code: `
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+
+const nativeAddon = require(join(__dirname, ${JSON.stringify(fileName)}));
+export default nativeAddon;
+`,
+                map: null,
+                meta: {
+                    nativeAddon: {
+                        absolutePath,
+                        fileName
+                    }
+                }
+            };
+        },
+        async generateBundle () {
+            // Copy all tracked native addon files to the output directory
+            for (const [_, absolutePath] of nativeAddonMap){
+                const fileName = path__default.default.basename(absolutePath);
+                try {
+                    const fileContent = await fsp.readFile(absolutePath);
+                    // Emit the binary file as an asset
+                    this.emitFile({
+                        type: 'asset',
+                        fileName,
+                        source: fileContent
+                    });
+                } catch (error) {
+                    this.error(`[bunchee] Failed to read native addon file: ${absolutePath}`);
+                }
+            }
+        }
+    };
+}
+
 function hasNoSpecialCondition(conditionNames) {
     return [
         ...conditionNames
@@ -1505,6 +1584,51 @@ const prependShebang = (entry)=>({
         }
     });
 
+function hasSwcHelpersDeclared(pkg) {
+    var _pkg_dependencies, _pkg_peerDependencies, _pkg_optionalDependencies;
+    return Boolean(((_pkg_dependencies = pkg.dependencies) == null ? void 0 : _pkg_dependencies['@swc/helpers']) || ((_pkg_peerDependencies = pkg.peerDependencies) == null ? void 0 : _pkg_peerDependencies['@swc/helpers']) || ((_pkg_optionalDependencies = pkg.optionalDependencies) == null ? void 0 : _pkg_optionalDependencies['@swc/helpers']));
+}
+function isSwcHelpersInstalled(cwd) {
+    try {
+        // Use Node's resolver (supports pnpm/yarn PnP) and resolve from the user's project.
+        const req = module$1.createRequire(path__default.default.join(cwd, 'package.json'));
+        req.resolve('@swc/helpers/package.json');
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function chunkUsesSwcHelpers(chunk) {
+    const allImports = chunk.imports.concat(chunk.dynamicImports);
+    return allImports.some((id)=>id === '@swc/helpers' || id.startsWith('@swc/helpers/'));
+}
+function swcHelpersWarningPlugin({ cwd, pkg }) {
+    let hasWarned = false;
+    const swcHelpersImportFiles = new Set();
+    return {
+        name: 'bunchee:swc-helpers-warning',
+        writeBundle (options, bundle) {
+            if (hasWarned) return;
+            const outputDir = options.dir || path__default.default.dirname(options.file);
+            for (const [fileName, item] of Object.entries(bundle)){
+                if (item.type !== 'chunk') continue;
+                if (!chunkUsesSwcHelpers(item)) continue;
+                swcHelpersImportFiles.add(path__default.default.relative(cwd, path__default.default.join(outputDir, fileName)));
+            }
+            if (swcHelpersImportFiles.size === 0) return;
+            if (isSwcHelpersInstalled(cwd)) return;
+            hasWarned = true;
+            const exampleFiles = Array.from(swcHelpersImportFiles).slice(0, 3).join(', ');
+            const declaredHint = hasSwcHelpersDeclared(pkg) ? '' : ' (and add it to your dependencies)';
+            logger.warn([
+                `Your build output imports "@swc/helpers" due to transform, but it isn't installed in this project.`,
+                `Install it as a runtime dependency${declaredHint} (e.g. "pnpm add @swc/helpers").`,
+                exampleFiles ? `Detected in: ${exampleFiles}` : ''
+            ].filter(Boolean).join('\n'));
+        }
+    };
+}
+
 const swcMinifyOptions = {
     compress: {
         directives: false
@@ -1553,9 +1677,7 @@ async function createDtsPlugin(tsCompilerOptions, tsConfigPath, respectExternal,
             try {
                 // First, try to resolve typescript to get its path
                 const tsPath = require.resolve('typescript', {
-                    paths: [
-                        cwd
-                    ]
+                    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
@@ -1677,6 +1799,7 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
         rawContent({
             exclude: /node_modules/
         }),
+        nativeAddon(),
         isBinEntry && prependShebang(entry),
         replace__default.default({
             values: inlineDefinedValues,
@@ -1701,6 +1824,11 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
             // For relative paths, the module will be bundled;
             // For external libraries, the module will not be bundled.
             transformMixedEsModules: true
+        }),
+        // If SWC emits @swc/helpers imports, warn when it's not installed.
+        swcHelpersWarningPlugin({
+            cwd,
+            pkg
         })
     ]).filter(isNotNull);
     return {
@@ -1742,6 +1870,62 @@ function getModuleLayer(moduleMeta) {
     const moduleLayer = directives[0];
     return moduleLayer ? hashTo3Char(moduleLayer) : undefined;
 }
+/**
+ * Get the effective layer of a module by walking up the importer chain.
+ * A module inherits the layer of its importer if it doesn't have its own layer.
+ */ function getEffectiveModuleLayer(id, getModuleInfo, visited = new Set()) {
+    if (visited.has(id)) {
+        return undefined;
+    }
+    visited.add(id);
+    const moduleInfo = getModuleInfo(id);
+    if (!moduleInfo) {
+        return undefined;
+    }
+    // If this module has its own layer, return it
+    const ownLayer = getModuleLayer(moduleInfo.meta);
+    if (ownLayer) {
+        return ownLayer;
+    }
+    // Otherwise, inherit layer from importers
+    for (const importerId of moduleInfo.importers){
+        const importerLayer = getEffectiveModuleLayer(importerId, getModuleInfo, visited);
+        if (importerLayer) {
+            return importerLayer;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if a module is imported by modules with different boundary layers.
+ * Returns the set of unique layers if there are multiple, otherwise undefined.
+ */ function getImporterLayers(id, getModuleInfo) {
+    const moduleInfo = getModuleInfo(id);
+    if (!moduleInfo) {
+        return new Set();
+    }
+    const layers = new Set();
+    for (const importerId of moduleInfo.importers){
+        const importerInfo = getModuleInfo(importerId);
+        if (!importerInfo) {
+            continue;
+        }
+        // Get the importer's own layer first
+        const importerOwnLayer = getModuleLayer(importerInfo.meta);
+        if (importerOwnLayer) {
+            layers.add(importerOwnLayer);
+        } else {
+            // If the importer doesn't have a layer, get its effective layer
+            const effectiveLayer = getEffectiveModuleLayer(importerId, getModuleInfo, new Set([
+                id
+            ]));
+            if (effectiveLayer) {
+                layers.add(effectiveLayer);
+            }
+        }
+    }
+    return layers;
+}
 // dependencyGraphMap: Map<subModuleId, Set<entryParentId>>
 function createSplitChunks(dependencyGraphMap, entryFiles) {
     // If there's existing chunk being splitted, and contains a layer { <id>: <chunkGroup> }
@@ -1778,6 +1962,24 @@ function createSplitChunks(dependencyGraphMap, entryFiles) {
                 }
             }
         }
+        // Check if this module (without its own directive) is imported by multiple boundaries.
+        // If so, split it into a separate shared chunk to prevent boundary crossing issues.
+        if (!moduleLayer && !isEntry) {
+            const importerLayers = getImporterLayers(id, ctx.getModuleInfo);
+            // If this module is imported by modules with different layers (e.g., both client and server),
+            // split it into a separate chunk that can be safely imported by both boundaries.
+            if (importerLayers.size > 1) {
+                if (splitChunksGroupMap.has(id)) {
+                    return splitChunksGroupMap.get(id);
+                }
+                const chunkName = path__default.default.basename(id, path__default.default.extname(id));
+                // Create a unique suffix based on all the layers that import this module
+                const layersSuffix = Array.from(importerLayers).sort().join('-');
+                const chunkGroup = `${chunkName}-${hashTo3Char(layersSuffix)}`;
+                splitChunksGroupMap.set(id, chunkGroup);
+                return chunkGroup;
+            }
+        }
         // If current module has a layer, and it's not an entry
         if (moduleLayer && !isEntry) {
             // If the module is imported by the entry:

package/package.json

@@ -1,10 +1,29 @@
 {
   "name": "bunchee",
-  "version": "6.7.0",
+  "version": "6.8.1",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "scripts": {
+    "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",
+    "site": "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",
+    "prepublishOnly": "pnpm prepare-release && chmod +x ./dist/bin/cli.js",
+    "run-ts": "cross-env SWC_NODE_IGNORE_DYNAMIC=1 node -r @swc-node/register",
+    "ts-bunchee": "pnpm run-ts ./src/bin/index.ts",
+    "build-dir": "pnpm ts-bunchee --cwd",
+    "build": "pnpm run-ts ./src/bin/index.ts --runtime node",
+    "format": "prettier --write .",
+    "prepare": "husky"
+  },
   "type": "commonjs",
   "keywords": [
     "bundler",
@@ -101,21 +120,5 @@
   "lint-staged": {
     "*.{js,jsx,ts,tsx,md,json,yml,yaml}": "prettier --write"
   },
-  "scripts": {
-    "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",
-    "site": "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",
-    "run-ts": "cross-env SWC_NODE_IGNORE_DYNAMIC=1 node -r @swc-node/register",
-    "ts-bunchee": "pnpm run-ts ./src/bin/index.ts",
-    "build-dir": "pnpm ts-bunchee --cwd",
-    "build": "pnpm run-ts ./src/bin/index.ts --runtime node",
-    "format": "prettier --write ."
-  }
-}
+  "packageManager": "pnpm@9.4.0"
+}