bunchee 5.2.0-beta.0 → 5.2.0

package/dist/bin/cli.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 var path = require('path');
 var arg = require('arg');
+var perf_hooks = require('perf_hooks');
 var fs = require('fs');
 var fsp = require('fs/promises');
 var require$$0 = require('tty');
-var bunchee = require('bunchee');
+var index_js = require('../index.js');
 require('module');
+var prettyBytes = require('pretty-bytes');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -14,6 +16,7 @@ var arg__default = /*#__PURE__*/_interopDefault(arg);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var fsp__default = /*#__PURE__*/_interopDefault(fsp);
 var require$$0__default = /*#__PURE__*/_interopDefault(require$$0);
+var prettyBytes__default = /*#__PURE__*/_interopDefault(prettyBytes);
 
 const availableExtensions = new Set([
     'js',
@@ -130,13 +133,6 @@ const logger = {
         console.log(color('green')('✓'), ...arg);
     }
 };
-function paint(prefix, prefixColor, ...arg) {
-    if (pc.isColorSupported) {
-        console.log(pc[prefixColor](prefix), ...arg);
-    } else {
-        console.log(prefix, ...arg);
-    }
-}
 
 function exit(err) {
     logger.error(err);
@@ -474,7 +470,7 @@ function lint$1(pkg) {
     }
 }
 
-var version = "5.2.0-beta.0";
+var version = "5.2.0";
 
 function relativify(path) {
     return path.startsWith('.') ? path : `./${path}`;
@@ -847,6 +843,64 @@ async function prepare(cwd) {
     logger.info('Configured `exports` in package.json');
 }
 
+function isTypeFile(filename) {
+    return filename.endsWith('.d.ts') || filename.endsWith('.d.mts') || filename.endsWith('.d.cts');
+}
+function normalizeExportName(exportName) {
+    const isBinary = isBinExportPath(exportName);
+    let result = exportName;
+    if (isBinary) {
+        result = (exportName.replace(new RegExp(`^\\${BINARY_TAG}\\/?`), '') || '.') + ' (bin)';
+    } else {
+        const normalizedExportPath = normalizeExportPath(exportName);
+        const specialConditionName = getSpecialExportTypeFromComposedExportPath(exportName);
+        result = normalizedExportPath + (specialConditionName !== 'default' ? ` (${specialConditionName})` : '');
+    }
+    return result;
+}
+function logOutputState(stats) {
+    if (stats.size === 0) {
+        logger.warn('No build info can be logged');
+        return;
+    }
+    const allFileNameLengths = Array.from(stats.values()).flat(1).map(([filename])=>filename.length);
+    const maxFilenameLength = Math.max(...allFileNameLengths);
+    const statsArray = [
+        ...stats.entries()
+    ].sort(([a], [b])=>{
+        const comp = normalizeExportPath(a).length - normalizeExportPath(b).length;
+        return comp === 0 ? a.localeCompare(b) : comp;
+    });
+    const maxLengthOfExportName = Math.max(...statsArray.map(([exportName])=>normalizeExportName(exportName).length));
+    console.log(pc.underline('Exports'), ' '.repeat(Math.max(maxLengthOfExportName - 'Exports'.length, 0)), pc.underline('File'), ' '.repeat(Math.max(maxFilenameLength - 'File'.length, 0)), pc.underline('Size'));
+    statsArray.forEach(([exportName, filesList])=>{
+        // sort by file type, first js files then types, js/mjs/cjs are prioritized than .d.ts/.d.mts/.d.cts
+        filesList.sort(([a], [b])=>{
+            const aIsType = isTypeFile(a);
+            const bIsType = isTypeFile(b);
+            if (aIsType && bIsType) {
+                return 0;
+            }
+            if (aIsType) {
+                return 1;
+            }
+            if (bIsType) {
+                return -1;
+            }
+            return 0;
+        }).forEach((item, index)=>{
+            const [filename, , size] = item;
+            const normalizedExportName = normalizeExportName(exportName);
+            const prefix = index === 0 ? normalizedExportName : ' '.repeat(normalizedExportName.length);
+            const filenamePadding = ' '.repeat(Math.max(maxLengthOfExportName, 'Exports'.length) - normalizedExportName.length);
+            const isType = isTypeFile(filename);
+            const sizePadding = ' '.repeat(Math.max(maxFilenameLength, 'File'.length) - filename.length);
+            const prettiedSize = prettyBytes__default.default(size);
+            console.log(prefix, filenamePadding, `${pc[isType ? 'dim' : 'bold'](filename)}`, sizePadding, prettiedSize);
+        });
+    });
+}
+
 const helpMessage = `
 Usage: bunchee [options]
 
@@ -963,23 +1017,76 @@ async function run(args) {
     const cliEntry = source ? path__default.default.resolve(cwd, source) : '';
     // lint package
     await lint(cwd);
+    const { default: ora } = await import('ora');
+    const spinner = ora({
+        text: 'Building...\n\n',
+        color: 'green'
+    });
+    function stopSpinner(text) {
+        if (spinner.isSpinning) {
+            spinner.clear();
+            console.log();
+            if (text) {
+                spinner.stopAndPersist({
+                    symbol: '✔',
+                    text
+                });
+            } else {
+                spinner.stop();
+            }
+        }
+    }
+    let initialBuildContext;
+    function onBuildStart(buildContext) {
+        initialBuildContext = buildContext;
+        spinner.start();
+    }
+    function onBuildEnd(assetJobs) {
+        // Stop spinner before logging output files and sizes on build end
+        if (watch) {
+            stopSpinner('');
+            logWatcherBuildTime(assetJobs);
+        } else {
+            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 ? void 0 : initialBuildContext.pluginContext.outputState;
+            if (outputState) {
+                logOutputState(outputState.getSizeStats());
+            }
+        }
+    }
+    let buildError;
+    bundleConfig._callbacks = {
+        onBuildStart,
+        onBuildEnd
+    };
+    if (watch) {
+        logger.log(`Watching project ${cwd}...`);
+    }
     try {
-        await bunchee.bundle(cliEntry, bundleConfig);
+        await index_js.bundle(cliEntry, bundleConfig);
     } catch (err) {
         if (err.name === 'NOT_EXISTED') {
+            buildError = {
+                digest: 'bunchee:not-existed',
+                error: err
+            };
+        }
+        if ((buildError == null ? void 0 : buildError.digest) === 'bunchee:not-existed') {
             help();
-            return exit(err);
+        } else {
+            if (watch) {
+                logError(err);
+            } else {
+                throw err;
+            }
         }
-        throw err;
     }
     // watching mode
-    if (watch) {
-        logger.log(`Watching project ${cwd}...`);
-        return;
+    if (!watch) {
+        stopSpinner(`bunchee ${version} build completed`);
     }
-    // build mode
-    logger.log();
-    paint('✓', 'green', `bunchee ${version} build completed`);
 }
 async function main() {
     let params, error;
@@ -994,4 +1101,46 @@ async function main() {
     }
     await run(params);
 }
+function logWatcherBuildTime(result) {
+    let watcherCounter = 0;
+    let startTime = 0;
+    result.map((watcher)=>{
+        function start() {
+            if (watcherCounter === 0) startTime = perf_hooks.performance.now();
+            watcherCounter++;
+        }
+        function end() {
+            watcherCounter--;
+            if (watcherCounter === 0) {
+                logger.info(`Built in ${(perf_hooks.performance.now() - startTime).toFixed(2)}ms`);
+            }
+        }
+        watcher.on('event', (event)=>{
+            switch(event.code){
+                case 'ERROR':
+                    {
+                        logError(event.error);
+                        break;
+                    }
+                case 'START':
+                    {
+                        start();
+                        break;
+                    }
+                case 'END':
+                    {
+                        end();
+                        break;
+                    }
+            }
+        });
+    });
+}
+function logError(error) {
+    if (!error) return;
+    // logging source code in format
+    if (error.frame) {
+        process.stderr.write(error.frame + '\n');
+    }
+}
 main().catch(exit);

package/dist/index.d.ts

@@ -19,6 +19,10 @@ type BundleConfig = {
     pkg?: PackageMetadata;
     clean?: boolean;
     tsconfig?: string;
+    _callbacks?: {
+        onBuildStart?: (state: any) => void;
+        onBuildEnd?: (assetJobs: any) => void;
+    };
 };
 type PackageMetadata = {
     name?: string;
@@ -34,6 +38,6 @@ type PackageMetadata = {
     typings?: string;
 };
 
-declare function bundle(cliEntryPath: string, { cwd: _cwd, ...options }?: BundleConfig): Promise<any>;
+declare function bundle(cliEntryPath: string, { cwd: _cwd, ...options }?: BundleConfig): Promise<void>;
 
 export { type BundleConfig, bundle };