bunchee 6.8.2 → 6.9.1

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.

package/dist/bin/cli.js

@@ -6,10 +6,10 @@ 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');
 require('module');
-var tinyglobby = require('tinyglobby');
 var prettyBytes = require('pretty-bytes');
 var nanospinner = require('nanospinner');
 
@@ -274,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;
@@ -312,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)
@@ -373,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;
@@ -397,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);
@@ -515,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');
     }
@@ -693,7 +856,7 @@ function lint$1(pkg) {
     }
 }
 
-var version = "6.8.2";
+var version = "6.9.1";
 
 async function writeDefaultTsconfig(tsConfigPath) {
     await fs.promises.writeFile(tsConfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
@@ -960,9 +1123,13 @@ function addBuildScripts(pkgJson, cwd) {
 }
 async function prepare(cwd, options) {
     const sourceFolder = path__default.default.resolve(cwd, SRC);
+    // Create src/index.ts if src folder doesn't exist
     if (!fs__default.default.existsSync(sourceFolder)) {
-        logger.error(`Source folder ${sourceFolder} does not exist. Cannot proceed to configure \`exports\` field.`);
-        process.exit(1);
+        await fsp__default.default.mkdir(sourceFolder, {
+            recursive: true
+        });
+        const indexPath = path__default.default.join(sourceFolder, 'index.ts');
+        await fsp__default.default.writeFile(indexPath, "export function index() {\n  return 'index'\n}\n", 'utf-8');
     }
     let hasPackageJson = false;
     const pkgJsonPath = path__default.default.join(cwd, 'package.json');
@@ -1202,10 +1369,10 @@ function help() {
 }
 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', {

package/dist/index.js

@@ -385,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;
@@ -437,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)
@@ -498,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;
@@ -522,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);
@@ -2203,7 +2365,7 @@ 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

package/package.json

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