bunchee 6.3.4 → 6.5.0

package/README.md

@@ -282,7 +282,7 @@ This convention keeps shared modules private while enabling efficient bundling a
 
 ### CLI
 
-#### CLI Options
+#### Options
 
 `bunchee` CLI provides few options to create different bundles or generating types. Call `bunchee --help` to see the help information in the terminal.
 
@@ -317,6 +317,14 @@ bunchee --no-external
 
 This will include all dependencies within your output bundle.
 
+#### 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:
+
+```sh
+bunchee --watch --success "node ./dist/index.js"
+```
+
 #### Prepare Package
 
 ```sh

package/dist/bin/cli.js

@@ -281,7 +281,7 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
             ];
             addToExportDistMap(exportToDist, currentPath, [
                 outputConditionPair
-            ], runtimeExportConventions.has(exportType) ? exportType : undefined);
+            ]);
         } else {
             exportInfo.push([
                 exportValue,
@@ -308,9 +308,8 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
     }
 }
 const mapExportFullPath = (exportPath)=>exportPath === '.' ? './index' : exportPath;
-function addToExportDistMap(exportToDist, exportPath, outputConditionPairs, specialExportType) {
+function addToExportDistMap(exportToDist, exportPath, outputConditionPairs) {
     const fullPath = mapExportFullPath(exportPath);
-    // + (specialExportType ? '.' + specialExportType : '')
     const existingExportInfo = exportToDist.get(fullPath);
     if (!existingExportInfo) {
         exportToDist.set(fullPath, outputConditionPairs);
@@ -647,7 +646,7 @@ function lint$1(pkg) {
     }
 }
 
-var version = "6.3.4";
+var version = "6.5.0";
 
 async function writeDefaultTsconfig(tsConfigPath) {
     await fs.promises.writeFile(tsConfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
@@ -974,14 +973,17 @@ async function prepare(cwd) {
             } else {
                 // Update existing exports
                 Object.keys(pkgExports).forEach((exportName)=>{
-                    if (pkgJson.exports[exportName]) {
-                        pkgJson.exports[exportName] = pkgExports[exportName];
-                    }
+                    pkgJson.exports[exportName] = {
+                        // Apply the new export conditions
+                        ...pkgJson.exports[exportName],
+                        // Keep the existing export conditions
+                        ...pkgJson.exports[exportName]
+                    };
                 });
             }
         }
     }
-    await fsp__default.default.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+    await fsp__default.default.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + '\n');
     logger.info('Configured `exports` in package.json');
 }
 
@@ -1082,10 +1084,11 @@ Options:
   --runtime <runtime>    build runtime (nodejs, browser). default: browser
   --env <env>            inlined process env variables, separate by comma. default: NODE_ENV
   --cwd <cwd>            specify current working directory
-  --sourcemap            enable sourcemap generation, default: false
+  --sourcemap            enable sourcemap generation
   --no-dts               do not generate types, default: undefined
   --tsconfig             path to tsconfig file, default: tsconfig.json
   --dts-bundle           bundle type declaration files, default: false
+  --success <cmd>     run command after build success
 `;
 function help() {
     logger.log(helpMessage);
@@ -1141,7 +1144,7 @@ async function parseCliArgs(argv) {
         description: 'js features target: swc target es versions'
     }).option('sourcemap', {
         type: 'boolean',
-        default: false,
+        default: undefined,
         description: 'enable sourcemap generation'
     }).option('env', {
         type: 'string',
@@ -1160,6 +1163,9 @@ async function parseCliArgs(argv) {
     }).option('prepare', {
         type: 'boolean',
         description: 'auto setup package.json for building'
+    }).option('success', {
+        type: 'string',
+        description: 'run command after build success'
     }).command('prepare', 'auto configure package.json exports for building', ()=>{}, (argv)=>{
         return prepare(argv.cwd || process.cwd());
     }).command('lint', 'lint package.json', ()=>{}, (argv)=>{
@@ -1194,13 +1200,18 @@ async function parseCliArgs(argv) {
         external: args['external'] === false ? null : args['external'],
         clean: args['clean'] !== false,
         env: args['env'],
-        tsconfig: args['tsconfig']
+        tsconfig: args['tsconfig'],
+        onSuccess: args['success']
     };
+    // When minify is enabled, sourcemap should be enabled by default, unless explicitly opted out
+    if (parsedArgs.minify && typeof args['sourcemap'] === 'undefined') {
+        parsedArgs.sourcemap = true;
+    }
     return parsedArgs;
 }
 async function run(args) {
     var _args_external;
-    const { source, format, watch, minify, sourcemap, target, runtime, dts, dtsBundle, env, clean, tsconfig } = args;
+    const { source, format, watch, minify, sourcemap, target, runtime, dts, dtsBundle, env, clean, tsconfig, onSuccess } = args;
     const cwd = args.cwd || process.cwd();
     const file = args.file ? path__default.default.resolve(cwd, args.file) : undefined;
     const bundleConfig = {
@@ -1212,13 +1223,14 @@ async function run(args) {
         cwd,
         target,
         runtime,
-        external: args.external === null ? null : ((_args_external = args.external) == null ? undefined : _args_external.split(',')) || [],
+        external: args.external === null ? null : ((_args_external = args.external) == null ? void 0 : _args_external.split(',')) || [],
         watch: !!watch,
         minify: !!minify,
         sourcemap: sourcemap === false ? false : true,
-        env: (env == null ? undefined : env.split(',')) || [],
+        env: (env == null ? void 0 : env.split(',')) || [],
         clean,
-        tsconfig
+        tsconfig,
+        onSuccess
     };
     const cliEntry = source ? path__default.default.resolve(cwd, source) : '';
     // lint package by default
@@ -1270,7 +1282,7 @@ async function run(args) {
             if (assetJobs.length === 0) {
                 logger.warn('The "src" directory does not contain any entry files. ' + 'For proper usage, please refer to the following link: ' + 'https://github.com/huozhi/bunchee#usage');
             }
-            const outputState = initialBuildContext == null ? undefined : initialBuildContext.pluginContext.outputState;
+            const outputState = initialBuildContext == null ? void 0 : initialBuildContext.pluginContext.outputState;
             if (outputState) {
                 logOutputState(outputState.getSizeStats());
             }
@@ -1297,7 +1309,7 @@ async function run(args) {
                 error: err
             };
         }
-        if ((buildError == null ? undefined : buildError.digest) === 'bunchee:not-existed') {
+        if ((buildError == null ? void 0 : buildError.digest) === 'bunchee:not-existed') {
             help();
         } else {
             if (watch) {

package/dist/index.d.ts

@@ -21,6 +21,7 @@ type BundleConfig = {
     pkg?: PackageMetadata;
     clean?: boolean;
     tsconfig?: string;
+    onSuccess?: string | (() => void | Promise<void>);
     _callbacks?: {
         onBuildStart?: (state: any) => void;
         onBuildEnd?: (assetJobs: any) => void;
@@ -44,6 +45,6 @@ type PackageMetadata = {
 };
 type BrowserslistConfig = string | string[] | Record<string, string>;
 
-declare function bundle(cliEntryPath: string, { cwd: _cwd, ...options }?: BundleConfig): Promise<void>;
+declare function bundle(cliEntryPath: string, { cwd: _cwd, onSuccess, ...options }?: BundleConfig): Promise<void>;
 
 export { type BundleConfig, bundle };

package/dist/index.js

@@ -18,6 +18,7 @@ var preserveDirectives = require('rollup-preserve-directives');
 var MagicString = require('magic-string');
 var CleanCSS = require('clean-css');
 var pluginutils = require('@rollup/pluginutils');
+var child_process = require('child_process');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -445,7 +446,7 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
             ];
             addToExportDistMap(exportToDist, currentPath, [
                 outputConditionPair
-            ], runtimeExportConventions.has(exportType) ? exportType : undefined);
+            ]);
         } else {
             exportInfo.push([
                 exportValue,
@@ -472,9 +473,8 @@ function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exp
     }
 }
 const mapExportFullPath = (exportPath)=>exportPath === '.' ? './index' : exportPath;
-function addToExportDistMap(exportToDist, exportPath, outputConditionPairs, specialExportType) {
+function addToExportDistMap(exportToDist, exportPath, outputConditionPairs) {
     const fullPath = mapExportFullPath(exportPath);
-    // + (specialExportType ? '.' + specialExportType : '')
     const existingExportInfo = exportToDist.get(fullPath);
     if (!existingExportInfo) {
         exportToDist.set(fullPath, outputConditionPairs);
@@ -679,6 +679,7 @@ async function collectEntriesFromParsedExports(cwd, parsedExportsInfo, pkg, sour
                 continue;
             }
             if (!entries[entryExportPath]) {
+                // Create a new entry
                 entries[entryExportPath] = {
                     source: sourceFile,
                     name: normalizedExportPath,
@@ -896,7 +897,6 @@ async function collectSourceEntriesByExportPath(sourceFolderPath, originalSubpat
         const sourceFileAbsolutePath = path__default.default.join(sourceFolderPath, file);
         const exportPath = sourceFilenameToExportFullPath(file);
         const isEsmPkg = isESModulePackage(pkg.type);
-        // const specialItems: [string, string][] = []
         const specialExportType = getSpecialExportTypeFromSourcePath(file);
         const normalizedExportPath = stripSpecialCondition(exportPath);
         const isSpecialExport = specialExportType !== 'default';
@@ -1222,17 +1222,7 @@ function __insertCSS(code) {
         create (code) {
             return `__insertCSS(${JSON.stringify(code)});`;
         }
-    },
-    cssAssertionImport: {
-        global: '',
-        create (code) {
-            return `\
-const sheet = new CSSStyleSheet()
-sheet.replaceSync(${JSON.stringify(code)})
-export default sheet`;
-        }
-    }
-};
+    }};
 const cleanCssInstance = new CleanCSS__default.default({});
 function minify(code) {
     return cleanCssInstance.minify(code).styles;
@@ -1308,7 +1298,7 @@ function hasNoSpecialCondition(conditionNames) {
         ...conditionNames
     ].every((name)=>!specialExportConventions.has(name));
 }
-function findJsBundlePathCallback({ format, bundlePath, conditionNames }, specialCondition) {
+function findJsBundlePathCallback({ format, bundlePath, conditionNames }, specialCondition, isESMPkg) {
     const hasBundle = bundlePath != null;
     const formatCond = format === 'cjs' ? 'require' : 'import';
     const isTypesCondName = conditionNames.has('types');
@@ -1316,9 +1306,14 @@ function findJsBundlePathCallback({ format, bundlePath, conditionNames }, specia
     // Check if the format condition is matched:
     // if there's condition existed, check if the format condition is matched;
     // if there's no condition, just return true, assuming format doesn't matter;
+    const bundleFormat = bundlePath.endsWith('.mjs') ? 'esm' : bundlePath.endsWith('.cjs') ? 'cjs' : isESMPkg ? 'esm' : 'cjs';
+    // If there's only default condition, and the format is matched
+    const isDefaultOnlyCondition = conditionNames.size === 1 && conditionNames.has('default') ? bundleFormat === format : true;
     const isMatchedFormat = hasFormatCond ? conditionNames.has(formatCond) : true;
-    const isMatchedConditionWithFormat = conditionNames.has(specialCondition) || !conditionNames.has('default') && hasNoSpecialCondition(conditionNames);
-    const match = isMatchedConditionWithFormat && !isTypesCondName && hasBundle && isMatchedFormat;
+    const isMatchedConditionWithFormat = // Has matched special condition
+    specialCondition !== 'default' && conditionNames.has(specialCondition) || // Match normal condition
+    hasNoSpecialCondition(conditionNames);
+    const match = isMatchedConditionWithFormat && !isTypesCondName && hasBundle && isMatchedFormat && isDefaultOnlyCondition;
     if (!match) {
         const fallback = runtimeExportConventionsFallback.get(specialCondition);
         if (!fallback) {
@@ -1328,7 +1323,7 @@ function findJsBundlePathCallback({ format, bundlePath, conditionNames }, specia
             // e.g. when import utils.js in index.js
             // In output: index.browser.js should match util.browser.js, fallback to util.js
             // The last guard condition is to ensure bundle condition but not types file.
-            return isMatchedFormat && (conditionNames.has(specialCondition) || fallback.some((name)=>conditionNames.has(name))) && !conditionNames.has('types');
+            return isMatchedFormat && !isTypesCondName && (specialCondition !== 'default' && conditionNames.has(specialCondition) || fallback.some((name)=>conditionNames.has(name)));
         }
     } else {
         return match;
@@ -1341,22 +1336,27 @@ function findTypesFileCallback({ format, bundlePath, conditionNames }) {
     return isTypesCondName && hasCondition && (formatCond ? conditionNames.has(formatCond) : true);
 }
 // Alias entry key to dist bundle path
-function aliasEntries({ entry: sourceFilePath, conditionNames, entries, format, dts, cwd }) {
+function aliasEntries({ entry: sourceFilePath, exportCondition, entries, isESMPkg, format, dts, cwd }) {
+    const currentConditionNames = new Set(Object.keys(exportCondition.export)[0].split('.'));
     // <imported source file path>: <relative path to source's bundle>
     const sourceToRelativeBundleMap = new Map();
-    const specialCondition = getSpecialExportTypeFromConditionNames(conditionNames);
+    let specialCondition = getSpecialExportTypeFromConditionNames(currentConditionNames);
     for (const [, exportCondition] of Object.entries(entries)){
         const exportDistMaps = exportCondition.export;
-        const exportMapEntries = Object.entries(exportDistMaps).map(([composedKey, bundlePath])=>({
-                conditionNames: new Set(composedKey.split('.')),
+        const exportMapEntries = Object.entries(exportDistMaps).map(([composedKey, bundlePath])=>{
+            const conditionNames = new Set(composedKey.split('.'));
+            return {
+                conditionNames,
                 bundlePath,
-                format
-            }));
+                format,
+                isDefaultCondition: conditionNames.size === 1 && conditionNames.has('default')
+            };
+        });
         let matchedBundlePath;
         if (dts) {
             var _exportMapEntries_find;
             // Find the type with format condition first
-            matchedBundlePath = (_exportMapEntries_find = exportMapEntries.find(findTypesFileCallback)) == null ? undefined : _exportMapEntries_find.bundlePath;
+            matchedBundlePath = (_exportMapEntries_find = exportMapEntries.find(findTypesFileCallback)) == null ? void 0 : _exportMapEntries_find.bundlePath;
             // If theres no format specific types such as import.types or require.types,
             // fallback to the general types file.
             if (!matchedBundlePath) {
@@ -1366,22 +1366,13 @@ function aliasEntries({ entry: sourceFilePath, conditionNames, entries, format,
                         ...item,
                         format: undefined
                     });
-                })) == null ? undefined : _exportMapEntries_find1.bundlePath;
+                })) == null ? void 0 : _exportMapEntries_find1.bundlePath;
             }
         } else {
-            var _exportMapEntries_sort_find;
-            matchedBundlePath = (_exportMapEntries_sort_find = exportMapEntries.sort(// always put special condition after the general condition (default, cjs, esm)
-            (a, b)=>{
-                if (a.conditionNames.has(specialCondition)) {
-                    return -1;
-                }
-                if (b.conditionNames.has(specialCondition)) {
-                    return 1;
-                }
-                return 0;
-            }).find((item)=>{
-                return findJsBundlePathCallback(item, specialCondition);
-            })) == null ? undefined : _exportMapEntries_sort_find.bundlePath;
+            var _exportMapEntries_find2;
+            matchedBundlePath = (_exportMapEntries_find2 = exportMapEntries.find((item)=>{
+                return findJsBundlePathCallback(item, specialCondition, isESMPkg);
+            })) == null ? void 0 : _exportMapEntries_find2.bundlePath;
         }
         if (matchedBundlePath) {
             if (!sourceToRelativeBundleMap.has(exportCondition.source)) sourceToRelativeBundleMap.set(exportCondition.source, matchedBundlePath);
@@ -1444,11 +1435,11 @@ const swcMinifyOptions = {
     }
 };
 async function createDtsPlugin(tsCompilerOptions, tsConfigPath, respectExternal, cwd) {
-    const enableIncrementalWithoutBuildInfo = tsCompilerOptions.incremental && !tsCompilerOptions.tsBuildInfoFile;
+    const enableIncrementalWithoutBuildInfo = (tsCompilerOptions == null ? void 0 : tsCompilerOptions.incremental) && !(tsCompilerOptions == null ? void 0 : tsCompilerOptions.tsBuildInfoFile);
     const incrementalOptions = enableIncrementalWithoutBuildInfo ? {
         incremental: false
     } : undefined;
-    const compositeOptions = tsCompilerOptions.composite ? {
+    const compositeOptions = (tsCompilerOptions == null ? void 0 : tsCompilerOptions.composite) ? {
         composite: false
     } : undefined;
     const { options: overrideResolvedTsOptions } = await convertCompilerOptions(cwd, {
@@ -1463,7 +1454,7 @@ async function createDtsPlugin(tsCompilerOptions, tsConfigPath, respectExternal,
         // resolving types from <reference> from node_modules
         preserveSymlinks: false,
         target: 'ESNext',
-        ...!tsCompilerOptions.jsx ? {
+        ...!(tsCompilerOptions == null ? void 0 : tsCompilerOptions.jsx) ? {
             jsx: 'react-jsx'
         } : undefined,
         // error TS5074: Option '--incremental' can only be specified using tsconfig, emitting to single
@@ -1501,7 +1492,7 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
     const inlineDefinedValues = getDefinedInlineVariables(bundleConfig.env || [], exportCondition);
     const { useTypeScript } = buildContext;
     const { runtime, target: jscTarget, minify: shouldMinify } = bundleConfig;
-    const hasSpecifiedTsTarget = Boolean(tsCompilerOptions.target && tsConfigPath);
+    const hasSpecifiedTsTarget = Boolean((tsCompilerOptions == null ? void 0 : tsCompilerOptions.target) && tsConfigPath);
     const swcParserConfig = {
         syntax: useTypeScript ? 'typescript' : 'ecmascript',
         [useTypeScript ? 'tsx' : 'jsx']: true,
@@ -1516,7 +1507,7 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
                 target: jscTarget
             },
             loose: true,
-            externalHelpers: false,
+            externalHelpers: true,
             parser: swcParserConfig,
             transform: {
                 decoratorVersion: '2022-03'
@@ -1540,13 +1531,13 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
     const sizePlugin = pluginContext.outputState.plugin(cwd);
     // common plugins for both dts and ts assets that need to be processed
     // If it's a .d.ts file under non-ESM package or .d.cts file, use cjs types alias.
-    const aliasFormat = dts ? ((_bundleConfig_file = bundleConfig.file) == null ? undefined : _bundleConfig_file.endsWith('.d.cts')) || ((_bundleConfig_file1 = bundleConfig.file) == null ? undefined : _bundleConfig_file1.endsWith('.d.ts')) && !isESModulePackage(pkg.type) ? 'cjs' : 'esm' : bundleConfig.format;
-    const currentConditionNames = Object.keys(exportCondition.export)[0];
+    const aliasFormat = dts ? ((_bundleConfig_file = bundleConfig.file) == null ? void 0 : _bundleConfig_file.endsWith('.d.cts')) || ((_bundleConfig_file1 = bundleConfig.file) == null ? void 0 : _bundleConfig_file1.endsWith('.d.ts')) && !isESModulePackage(pkg.type) ? 'cjs' : 'esm' : bundleConfig.format;
     const aliasPlugin = aliasEntries({
         entry,
         entries,
         format: aliasFormat,
-        conditionNames: new Set(currentConditionNames.split('.')),
+        isESMPkg: isESModulePackage(pkg.type),
+        exportCondition,
         dts,
         cwd
     });
@@ -1629,18 +1620,31 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
     };
 }
 
+const hashTo3Char = memoize((input)=>{
+    let hash = 0;
+    for(let i = 0; i < input.length; i++){
+        hash = (hash << 5) - hash + input.charCodeAt(i) // Simple hash shift
+        ;
+    }
+    return (hash >>> 0).toString(36).slice(0, 3) // Base36 + trim to 3 chars
+    ;
+});
 function getModuleLayer(moduleMeta) {
     const directives = (moduleMeta.preserveDirectives || {
         directives: []
     }).directives.map((d)=>d.replace(/^use /, '')).filter((d)=>d !== 'strict');
     const moduleLayer = directives[0];
-    return moduleLayer;
+    return moduleLayer ? hashTo3Char(moduleLayer) : undefined;
 }
 // dependencyGraphMap: Map<subModuleId, Set<entryParentId>>
 function createSplitChunks(dependencyGraphMap, entryFiles) {
     // If there's existing chunk being splitted, and contains a layer { <id>: <chunkGroup> }
     const splitChunksGroupMap = new Map();
     return function splitChunks(id, ctx) {
+        if (/[\\/]node_modules[\\/]\@swc[\\/]helper/.test(id)) {
+            return 'cc' // common chunk
+            ;
+        }
         const moduleInfo = ctx.getModuleInfo(id);
         if (!moduleInfo) {
             return;
@@ -1693,7 +1697,8 @@ function createSplitChunks(dependencyGraphMap, entryFiles) {
                     return;
                 }
                 const chunkName = path__default.default.basename(id, path__default.default.extname(id));
-                const chunkGroup = `${chunkName}-${moduleLayer}`;
+                const layerSuffix = hashTo3Char(moduleLayer);
+                const chunkGroup = `${chunkName}-${layerSuffix}`;
                 splitChunksGroupMap.set(id, chunkGroup);
                 return chunkGroup;
             }
@@ -1706,7 +1711,7 @@ async function buildOutputConfigs(bundleConfig, exportCondition, buildContext, d
     const { format } = bundleConfig;
     const { entries, pkg, cwd, tsOptions: { tsCompilerOptions }, pluginContext } = buildContext;
     // Add esm mark and interop helper if esm export is detected
-    const useEsModuleMark = tsCompilerOptions == null ? undefined : tsCompilerOptions.esModuleInterop;
+    const useEsModuleMark = tsCompilerOptions == null ? void 0 : tsCompilerOptions.esModuleInterop;
     const absoluteOutputFile = path.resolve(cwd, bundleConfig.file);
     const isEsmPkg = isESModulePackage(pkg.type);
     const name = filePathWithoutExtension(absoluteOutputFile);
@@ -1916,7 +1921,7 @@ function hasMultiEntryExport(exportPaths) {
     const exportKeys = Object.keys(exportPaths).filter((key)=>key !== './package.json');
     return exportKeys.length > 0 && exportKeys.every((name)=>name.startsWith('.'));
 }
-async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
+async function bundle(cliEntryPath, { cwd: _cwd, onSuccess, ...options } = {}) {
     var _options__callbacks_onBuildStart, _options__callbacks;
     const cwd = path.resolve(process.cwd(), _cwd || '');
     assignDefault(options, 'format', 'esm');
@@ -1931,10 +1936,10 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
     const isFromCli = Boolean(cliEntryPath);
     const tsConfigPath = resolveTsConfigPath(cwd, options.tsconfig);
     let tsConfig = resolveTsConfig(cwd, tsConfigPath);
-    let hasTsConfig = Boolean(tsConfig == null ? undefined : tsConfig.tsConfigPath);
+    let hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
     const defaultTsOptions = {
-        tsConfigPath: tsConfig == null ? undefined : tsConfig.tsConfigPath,
-        tsCompilerOptions: (tsConfig == null ? undefined : tsConfig.tsCompilerOptions) || {}
+        tsConfigPath: tsConfig == null ? void 0 : tsConfig.tsConfigPath,
+        tsCompilerOptions: tsConfig == null ? void 0 : tsConfig.tsCompilerOptions
     };
     // Handle single entry file
     if (!isMultiEntries) {
@@ -2015,7 +2020,7 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
             moduleDirectiveLayerMap: new Map()
         }
     };
-    (_options__callbacks = options._callbacks) == null ? undefined : (_options__callbacks_onBuildStart = _options__callbacks.onBuildStart) == null ? undefined : _options__callbacks_onBuildStart.call(_options__callbacks, buildContext);
+    (_options__callbacks = options._callbacks) == null ? void 0 : (_options__callbacks_onBuildStart = _options__callbacks.onBuildStart) == null ? void 0 : _options__callbacks_onBuildStart.call(_options__callbacks, buildContext);
     const generateTypes = hasTsConfig && options.dts !== false;
     const rollupJobsOptions = {
         isFromCli,
@@ -2025,9 +2030,26 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
         var _options__callbacks_onBuildEnd, _options__callbacks1;
         const assetJobs = await createAssetRollupJobs(options, buildContext, rollupJobsOptions);
         (_options__callbacks1 = options._callbacks) == null ? void 0 : (_options__callbacks_onBuildEnd = _options__callbacks1.onBuildEnd) == null ? void 0 : _options__callbacks_onBuildEnd.call(_options__callbacks1, assetJobs);
+        // Finished building successfully
+        if (onSuccess) {
+            if (typeof onSuccess === 'string') {
+                const successProg = child_process.spawn(onSuccess, {
+                    shell: true,
+                    stdio: 'inherit',
+                    cwd
+                });
+                successProg.on('exit', (code)=>{
+                    if (code) {
+                        process.exitCode = code;
+                    }
+                });
+            } else {
+                await onSuccess();
+            }
+        }
     } catch (error) {
         var _options__callbacks_onBuildError, _options__callbacks2;
-        (_options__callbacks2 = options._callbacks) == null ? undefined : (_options__callbacks_onBuildError = _options__callbacks2.onBuildError) == null ? undefined : _options__callbacks_onBuildError.call(_options__callbacks2, error);
+        (_options__callbacks2 = options._callbacks) == null ? void 0 : (_options__callbacks_onBuildError = _options__callbacks2.onBuildError) == null ? void 0 : _options__callbacks_onBuildError.call(_options__callbacks2, error);
         return Promise.reject(error);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunchee",
-  "version": "6.3.4",
+  "version": "6.5.0",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",
@@ -42,16 +42,16 @@
     "@rollup/plugin-node-resolve": "^16.0.0",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-wasm": "^6.2.2",
-    "@rollup/pluginutils": "^5.1.3",
-    "@swc/core": "^1.10.7",
-    "@swc/helpers": "^0.5.11",
+    "@rollup/pluginutils": "^5.1.4",
+    "@swc/core": "^1.10.16",
+    "@swc/helpers": "^0.5.15",
     "clean-css": "^5.3.3",
     "fast-glob": "^3.3.3",
     "magic-string": "^0.30.17",
     "ora": "^8.0.1",
     "picomatch": "^4.0.2",
     "pretty-bytes": "^5.6.0",
-    "rollup": "^4.30.1",
+    "rollup": "^4.34.7",
     "rollup-plugin-dts": "^6.1.1",
     "rollup-plugin-swc3": "^0.11.1",
     "rollup-preserve-directives": "^1.1.3",
@@ -76,7 +76,7 @@
     "@types/clean-css": "^4.2.11",
     "@types/node": "^22.9.3",
     "@types/picomatch": "^3.0.1",
-    "@types/react": "19.0.1",
+    "@types/react": "^19.0.9",
     "@types/yargs": "^17.0.33",
     "bunchee": "link:./",
     "cross-env": "^7.0.3",