bunchee 4.4.1 → 4.4.2

package/dist/bin/cli.js

@@ -25,6 +25,13 @@ const availableExtensions = new Set([
     'cts',
     'mts'
 ]);
+const suffixedExportConventions = new Set([
+    'react-server',
+    'react-native',
+    'edge-light',
+    'development',
+    'production'
+]);
 const SRC = 'src';
 const DIST = 'dist';
 const dtsExtensionsMap = {
@@ -203,6 +210,9 @@ const getFirstExportPath = (fullExportCondition)=>{
     }
     return fullExportCondition;
 };
+const joinExportAndCondition = (exportPath, condition)=>{
+    return (exportPath === '.' ? '' : exportPath) + '.' + condition;
+};
 function findExport(exportPath, exportCondition, paths, packageType, currentPath) {
     // Skip `types` field, it cannot be the entry point
     if (exportPath === 'types') return;
@@ -215,12 +225,20 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
             };
         } else {
             const exportJsBundlePath = getFirstExportPath(fullExportCondition);
-            // exportPath is exportType, import, require, ...
-            // merge to currentPath
-            paths[currentPath] = {
-                ...paths[currentPath],
-                [exportPath]: exportJsBundlePath
-            };
+            if (suffixedExportConventions.has(exportPath)) {
+                const specialPath = joinExportAndCondition(currentPath, exportPath);
+                paths[specialPath] = {
+                    ...paths[specialPath],
+                    ...exportCondition
+                };
+            } else {
+                // exportPath is exportType, import, require, ...
+                // merge to currentPath
+                paths[currentPath] = {
+                    ...paths[currentPath],
+                    [exportPath]: exportJsBundlePath
+                };
+            }
         }
         return;
     }
@@ -233,6 +251,25 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
         } else {
             // subpath is exportType, import, require, ...
             const exportType = subpath;
+            if (typeof exportCondition[subpath] === 'object') {
+                const defaultPath = exportCondition[subpath].default;
+                if (defaultPath) {
+                    const nestedExportCondition = {
+                        [exportType]: defaultPath
+                    };
+                    findExport(exportPath, nestedExportCondition, paths, packageType, currentPath);
+                }
+                // Find special export type, such as import: { development: './dev.js', production: './prod.js' }
+                const conditionSpecialTypes = Object.keys(exportCondition[exportType]).filter((key)=>suffixedExportConventions.has(key));
+                if (conditionSpecialTypes.length > 0) {
+                    for (const conditionSpecialType of conditionSpecialTypes){
+                        const nestedExportConditionPath = {
+                            [exportType]: exportCondition[exportType][conditionSpecialType]
+                        };
+                        findExport(conditionSpecialType, nestedExportConditionPath, paths, packageType, currentPath);
+                    }
+                }
+            }
             const defaultPath = typeof exportCondition[subpath] === 'object' ? exportCondition[subpath].default : exportCondition[subpath];
             const nestedExportCondition = {
                 [exportType]: defaultPath
@@ -516,7 +553,7 @@ function lint$1(pkg) {
     }
 }
 
-var version = "4.4.1";
+var version = "4.4.2";
 
 function relativify(path) {
     return path.startsWith('.') ? path : `./${path}`;

package/dist/index.js

@@ -229,8 +229,14 @@ async function getSourcePathFromExportPath(cwd, exportPath, exportType) {
 }
 // TODO: add unit test
 // Unlike path.basename, forcedly removing extension
-function filePathWithoutExtension(file) {
-    return file ? file.replace(new RegExp(`${path__default.default.extname(file)}$`), '') : undefined;
+function filePathWithoutExtension(filePath) {
+    if (!filePath) return;
+    const lastDotIndex = filePath.lastIndexOf('.');
+    const lastSlashIndex = filePath.lastIndexOf('/');
+    if (lastDotIndex !== -1 && lastDotIndex > lastSlashIndex) {
+        return filePath.slice(0, filePath.indexOf('.', lastSlashIndex + 1));
+    }
+    return filePath;
 }
 const nonNullable = (n)=>Boolean(n);
 const hasAvailableExtension = (filename)=>availableExtensions.has(path__default.default.extname(filename).slice(1));
@@ -367,23 +373,64 @@ function rawContent({ exclude }) {
     };
 }
 
+function relativify(path) {
+    return path.startsWith('.') ? path : `./${path}`;
+}
+
 // Alias entries to import path
 // e.g.
 // For a resolved file, if it's one of the entries,
 // aliases it as export path, such as <absolute file> -> <pkg>/<export path>
-function aliasEntries({ entries }) {
+function aliasEntries({ entry, entries, entriesAlias, format, dts }) {
+    let currentDistPath = '';
+    const entryAliasWithoutSelf = {
+        ...entriesAlias,
+        [entry]: null
+    };
+    const pathToRelativeDistMap = new Map();
+    for (const [, exportCondition] of Object.entries(entries)){
+        var _Object_entries_find;
+        const { import: importCond, require: requireCond, default: defaultCond } = exportCondition.export;
+        const firstCond = (_Object_entries_find = Object.entries(exportCondition.export).find(([key, cond])=>key !== 'types' && cond != null)) == null ? void 0 : _Object_entries_find[1];
+        if (dts) {
+            const fallbackCond = defaultCond || firstCond;
+            // For cjs, use require() instead of import
+            const firstDistPath = (format === 'cjs' ? requireCond : importCond) || fallbackCond;
+            if (firstDistPath) {
+                if (entry !== exportCondition.source) {
+                    pathToRelativeDistMap.set(exportCondition.source, firstDistPath);
+                } else {
+                    currentDistPath = firstDistPath;
+                }
+            }
+        }
+    }
     return {
         name: 'alias',
         resolveId: {
             async handler (source, importer, options) {
                 const resolvedId = await this.resolve(source, importer, options);
                 if (resolvedId != null) {
-                    const aliasedId = entries[resolvedId.id];
-                    if (aliasedId != null) {
-                        return {
-                            id: aliasedId,
-                            external: true
-                        };
+                    if (dts) {
+                        // For types, generate relative path to the other type files,
+                        // this will be compatible for the node10 ts module resolution.
+                        const aliasedId = pathToRelativeDistMap.get(resolvedId.id);
+                        if (aliasedId != null && aliasedId !== currentDistPath) {
+                            const ext = path__default.default.extname(aliasedId);
+                            const filePathBase = filePathWithoutExtension(path__default.default.relative(path__default.default.dirname(currentDistPath), aliasedId));
+                            const relativePath = relativify(filePathBase + ext);
+                            return {
+                                id: relativePath,
+                                external: true
+                            };
+                        }
+                    } else {
+                        const aliasedId = entryAliasWithoutSelf[resolvedId.id];
+                        if (aliasedId != null) {
+                            return {
+                                id: aliasedId
+                            };
+                        }
                     }
                 }
                 return null;
@@ -463,6 +510,9 @@ const getFirstExportPath = (fullExportCondition)=>{
     }
     return fullExportCondition;
 };
+const joinExportAndCondition = (exportPath, condition)=>{
+    return (exportPath === '.' ? '' : exportPath) + '.' + condition;
+};
 function findExport(exportPath, exportCondition, paths, packageType, currentPath) {
     // Skip `types` field, it cannot be the entry point
     if (exportPath === 'types') return;
@@ -475,12 +525,20 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
             };
         } else {
             const exportJsBundlePath = getFirstExportPath(fullExportCondition);
-            // exportPath is exportType, import, require, ...
-            // merge to currentPath
-            paths[currentPath] = {
-                ...paths[currentPath],
-                [exportPath]: exportJsBundlePath
-            };
+            if (suffixedExportConventions.has(exportPath)) {
+                const specialPath = joinExportAndCondition(currentPath, exportPath);
+                paths[specialPath] = {
+                    ...paths[specialPath],
+                    ...exportCondition
+                };
+            } else {
+                // exportPath is exportType, import, require, ...
+                // merge to currentPath
+                paths[currentPath] = {
+                    ...paths[currentPath],
+                    [exportPath]: exportJsBundlePath
+                };
+            }
         }
         return;
     }
@@ -493,6 +551,25 @@ function findExport(exportPath, exportCondition, paths, packageType, currentPath
         } else {
             // subpath is exportType, import, require, ...
             const exportType = subpath;
+            if (typeof exportCondition[subpath] === 'object') {
+                const defaultPath = exportCondition[subpath].default;
+                if (defaultPath) {
+                    const nestedExportCondition = {
+                        [exportType]: defaultPath
+                    };
+                    findExport(exportPath, nestedExportCondition, paths, packageType, currentPath);
+                }
+                // Find special export type, such as import: { development: './dev.js', production: './prod.js' }
+                const conditionSpecialTypes = Object.keys(exportCondition[exportType]).filter((key)=>suffixedExportConventions.has(key));
+                if (conditionSpecialTypes.length > 0) {
+                    for (const conditionSpecialType of conditionSpecialTypes){
+                        const nestedExportConditionPath = {
+                            [exportType]: exportCondition[exportType][conditionSpecialType]
+                        };
+                        findExport(conditionSpecialType, nestedExportConditionPath, paths, packageType, currentPath);
+                    }
+                }
+            }
             const defaultPath = typeof exportCondition[subpath] === 'object' ? exportCondition[subpath].default : exportCondition[subpath];
             const nestedExportCondition = {
                 [exportType]: defaultPath
@@ -655,10 +732,12 @@ function isEsmExportName(name, ext) {
 }
 function isCjsExportName(pkg, exportCondition, ext) {
     const isESModule = isESModulePackage(pkg.type);
-    return !isESModule && [
+    const isCjsCondition = [
         'require',
         'main'
-    ].includes(exportCondition) && ext !== 'mjs' || ext === 'cjs';
+    ].includes(exportCondition);
+    const isNotEsmExportName = !isEsmExportName(exportCondition, ext);
+    return !isESModule && isNotEsmExportName && (ext !== 'mjs' || isCjsCondition) || ext === 'cjs';
 }
 function getExportsDistFilesOfCondition(pkg, parsedExportCondition, cwd) {
     const dist = [];
@@ -709,7 +788,7 @@ const swcMinifyOptions = {
     }
 };
 // return { 'process.env.<key>': '<value>' }
-function getBuildEnv(envs, exportConditions) {
+function getBuildEnv(envs, parsedExportCondition) {
     if (!envs.includes('NODE_ENV')) {
         envs.push('NODE_ENV');
     }
@@ -720,8 +799,10 @@ function getBuildEnv(envs, exportConditions) {
         }
         return acc;
     }, {});
+    // handle .development, .production
+    const condName = parsedExportCondition.name.startsWith('.') ? parsedExportCondition.name.slice(1) : parsedExportCondition.name;
+    const exportConditionNames = new Set(Object.keys(parsedExportCondition.export).concat(condName));
     // For development and production convention, we override the NODE_ENV value
-    const exportConditionNames = new Set(Object.keys(exportConditions));
     if (exportConditionNames.has('development')) {
         envVars['process.env.NODE_ENV'] = JSON.stringify('development');
     } else if (exportConditionNames.has('production')) {
@@ -744,15 +825,16 @@ function getBuildEnv(envs, exportConditions) {
     }
     return alias;
 }
-async function buildInputConfig(entry, options, buildContext, exportCondition, dts) {
+async function buildInputConfig(entry, bundleConfig, exportCondition, buildContext, dts) {
+    var _bundleConfig_file;
     const { entries, pkg, cwd, tsOptions: { tsConfigPath, tsCompilerOptions }, pluginContext } = buildContext;
-    const hasNoExternal = options.external === null;
-    var _options_external;
+    const hasNoExternal = bundleConfig.external === null;
+    var _bundleConfig_external;
     const externals = hasNoExternal ? [] : [
         pkg.peerDependencies,
         pkg.dependencies,
         pkg.peerDependenciesMeta
-    ].filter((n)=>Boolean(n)).map((o)=>Object.keys(o)).reduce((a, b)=>a.concat(b), []).concat((_options_external = options.external) != null ? _options_external : []);
+    ].filter((n)=>Boolean(n)).map((o)=>Object.keys(o)).reduce((a, b)=>a.concat(b), []).concat((_bundleConfig_external = bundleConfig.external) != null ? _bundleConfig_external : []);
     for (const [exportImportPath, exportCondition] of Object.entries(entries)){
         const entryFilePath = exportCondition.source;
         if (entryFilePath !== entry) {
@@ -760,9 +842,9 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
             externals.push(entryFilePath);
         }
     }
-    const envValues = getBuildEnv(options.env || [], exportCondition.export);
+    const envValues = getBuildEnv(bundleConfig.env || [], exportCondition);
     const { useTypeScript } = buildContext;
-    const { runtime, target: jscTarget, minify: shouldMinify } = options;
+    const { runtime, target: jscTarget, minify: shouldMinify } = bundleConfig;
     const hasSpecifiedTsTarget = Boolean(tsCompilerOptions.target && tsConfigPath);
     const swcParserConfig = {
         syntax: useTypeScript ? 'typescript' : 'ecmascript',
@@ -780,24 +862,25 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
             ...shouldMinify && {
                 minify: {
                     ...swcMinifyOptions,
-                    sourceMap: options.sourcemap
+                    sourceMap: bundleConfig.sourcemap
                 }
             }
         },
-        sourceMaps: options.sourcemap,
+        sourceMaps: bundleConfig.sourcemap,
         inlineSourcesContent: false,
         isModule: true
     };
     const sizePlugin = pluginContext.outputState.plugin(cwd);
     // common plugins for both dts and ts assets that need to be processed
+    const aliasFormat = dts ? ((_bundleConfig_file = bundleConfig.file) == null ? void 0 : _bundleConfig_file.endsWith('.d.cts')) ? 'cjs' : 'esm' : bundleConfig.format;
     const commonPlugins = [
         sizePlugin,
         aliasEntries({
-            entries: {
-                ...pluginContext.entriesAlias,
-                // Do not alias current alias of package
-                [entry]: null
-            }
+            entry,
+            entries,
+            entriesAlias: pluginContext.entriesAlias,
+            format: aliasFormat,
+            dts
         })
     ];
     const typesPlugins = [
@@ -866,7 +949,7 @@ async function buildInputConfig(entry, options, buildContext, exportCondition, d
             ...swcOptions
         }),
         commonjs__default.default({
-            exclude: options.external || null
+            exclude: bundleConfig.external || null
         }),
         json__default.default()
     ]).filter(isNotNull);
@@ -976,20 +1059,21 @@ function createSplitChunks(dependencyGraphMap, entryFiles) {
         return;
     };
 }
-function buildOutputConfigs(options, exportCondition, buildContext, dts) {
-    const { format } = options;
+async function buildOutputConfigs(entry, bundleConfig, exportCondition, buildContext, dts) {
+    const { format } = bundleConfig;
     const { entries, pkg, exportPaths, cwd, tsOptions: { tsCompilerOptions }, pluginContext } = buildContext;
     // Add esm mark and interop helper if esm export is detected
     const useEsModuleMark = hasEsmExport(exportPaths, tsCompilerOptions);
-    const absoluteOutputFile = path.resolve(cwd, options.file);
+    const absoluteOutputFile = path.resolve(cwd, bundleConfig.file);
     const name = filePathWithoutExtension(absoluteOutputFile);
     var _exportCondition_export_types;
-    const dtsFile = path.resolve(cwd, dts ? options.file : (_exportCondition_export_types = exportCondition.export.types) != null ? _exportCondition_export_types : getExportFileTypePath(options.file));
+    const dtsFile = path.resolve(cwd, dts ? bundleConfig.file : (_exportCondition_export_types = exportCondition.export.types) != null ? _exportCondition_export_types : getExportFileTypePath(bundleConfig.file));
     const typesDir = path.dirname(dtsFile);
     const jsDir = path.dirname(absoluteOutputFile);
     const outputFile = dts ? dtsFile : absoluteOutputFile;
     const entryFiles = new Set(Object.values(entries).map((entry)=>entry.source));
-    return {
+    const inputOptions = await buildInputConfig(entry, bundleConfig, exportCondition, buildContext, dts);
+    const outputOptions = {
         name: pkg.name || name,
         dir: dts ? typesDir : jsDir,
         format,
@@ -998,7 +1082,7 @@ function buildOutputConfigs(options, exportCondition, buildContext, dts) {
         interop: 'auto',
         freeze: false,
         strict: false,
-        sourcemap: options.sourcemap,
+        sourcemap: bundleConfig.sourcemap,
         manualChunks: createSplitChunks(pluginContext.moduleDirectiveLayerMap, entryFiles),
         chunkFileNames: '[name]-[hash].js',
         // By default in rollup, when creating multiple chunks, transitive imports of entry chunks
@@ -1006,19 +1090,24 @@ function buildOutputConfigs(options, exportCondition, buildContext, dts) {
         hoistTransitiveImports: false,
         entryFileNames: path.basename(outputFile)
     };
+    return {
+        input: inputOptions,
+        output: outputOptions
+    };
 }
 async function buildEntryConfig(bundleConfig, pluginContext, dts) {
     const configs = [];
     const { entries } = pluginContext;
     for (const exportCondition of Object.values(entries)){
-        const rollupConfig = buildConfig(bundleConfig, exportCondition, pluginContext, dts);
-        configs.push(rollupConfig);
+        const rollupConfigs = await buildConfig(bundleConfig, exportCondition, pluginContext, dts);
+        configs.push(...rollupConfigs);
     }
-    return await Promise.all(configs);
+    return configs;
 }
 async function collectEntry(// export type, e.g. react-server, edge-light those special cases required suffix
 exportType, options) {
-    const { cwd, pkg, entries, entryPath, exportCondRef, entryExport } = options;
+    const { cwd, pkg, entries, entryPath, exportCondRef, entryExport: originEntryExport } = options;
+    let entryExport = originEntryExport;
     let exportCondForType = {
         ...exportCondRef
     };
@@ -1027,8 +1116,13 @@ exportType, options) {
         exportCondForType = {
             [exportType]: exportCondRef[exportType]
         };
-    // Basic export type, pass down the exportPaths with erasing the special ones
+    } else if (exportType[0] === '.' && suffixedExportConventions.has(exportType.slice(1))) {
+        // e.g. .development, .production that has both esm and cjs export
+        exportCondForType = exportCondRef;
+        exportType = exportType.slice(1);
+        entryExport = entryExport.replace(exportType, '');
     } else {
+        // Basic export type, pass down the exportPaths with erasing the special ones
         for (const exportType of suffixedExportConventions){
             delete exportCondForType[exportType];
         }
@@ -1044,7 +1138,7 @@ exportType, options) {
     }
     const exportCondition = {
         source,
-        name: entryExport,
+        name: originEntryExport,
         export: exportCondForType
     };
     const nameWithExportPath = pkg.name ? path__default.default.join(pkg.name, exportCondition.name) : exportCondition.name;
@@ -1106,6 +1200,8 @@ exportType, options) {
             for (const exportCondType of suffixedExportConventions){
                 if (exportCond[exportCondType]) {
                     await collectEntry(exportCondType, collectEntryOptions);
+                } else if (entryExport === '.' + exportCondType) {
+                    await collectEntry(entryExport, collectEntryOptions);
                 }
             }
         }
@@ -1115,14 +1211,8 @@ exportType, options) {
 }
 async function buildConfig(bundleConfig, exportCondition, pluginContext, dts) {
     const { file } = bundleConfig;
-    const { pkg, cwd, tsOptions } = pluginContext;
-    const useTypescript = Boolean(tsOptions.tsConfigPath);
-    const options = {
-        ...bundleConfig,
-        useTypescript
-    };
+    const { pkg, cwd } = pluginContext;
     const entry = exportCondition.source;
-    const inputOptions = await buildInputConfig(entry, options, pluginContext, exportCondition, dts);
     const outputExports = getExportsDistFilesOfCondition(pkg, exportCondition, cwd);
     // If there's nothing found, give a default output
     if (outputExports.length === 0 && !pkg.bin) {
@@ -1166,26 +1256,18 @@ async function buildConfig(bundleConfig, exportCondition, pluginContext, dts) {
         bundleOptions = Array.from(uniqTypes).map((typeFile)=>{
             return {
                 resolvedFile: typeFile,
-                format: 'es'
+                format: 'esm'
             };
         });
     }
-    const outputConfigs = bundleOptions.map((bundleOption)=>{
-        return buildOutputConfigs({
+    const outputConfigs = bundleOptions.map(async (bundleOption)=>{
+        return await buildOutputConfigs(entry, {
             ...bundleConfig,
             file: bundleOption.resolvedFile,
             format: bundleOption.format
         }, exportCondition, pluginContext, dts);
     });
-    return {
-        input: inputOptions,
-        output: outputConfigs,
-        exportName: exportCondition.name || '.'
-    };
-}
-
-function relativify(path) {
-    return path.startsWith('.') ? path : `./${path}`;
+    return Promise.all(outputConfigs);
 }
 
 // Example: @foo/bar -> bar
@@ -1377,7 +1459,7 @@ function hasMultiEntryExport(exportPaths) {
 }
 async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
     const cwd = path.resolve(process.cwd(), _cwd || '');
-    assignDefault(options, 'format', 'es');
+    assignDefault(options, 'format', 'esm');
     assignDefault(options, 'minify', false);
     assignDefault(options, 'target', 'es2015');
     const pkg = await getPackageMeta(cwd);
@@ -1518,15 +1600,11 @@ function runWatch({ input, output }) {
     return watcher;
 }
 async function removeOutputDir(output) {
-    const dirs = new Set(output.map(({ dir })=>dir));
-    for (const dir of dirs){
-        if (dir) await removeDir(dir);
-    }
+    if (output.dir) await removeDir(output.dir);
 }
 function runBundle({ input, output }) {
     return rollup.rollup(input).then((bundle)=>{
-        const writeJobs = output.map((options)=>bundle.write(options));
-        return Promise.all(writeJobs);
+        return bundle.write(output);
     }, catchErrorHandler);
 }
 function logError(error) {

package/package.json

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