feat: add name option

Author: sxzz

src/features/entry.ts

@@ -1,13 +1,13 @@
 import path from 'node:path'
-import { blue } from 'ansis'
 import { glob } from 'tinyglobby'
 import { lowestCommonAncestor } from '../utils/fs'
-import { logger } from '../utils/logger'
+import { generateColor, logger, prettyName } from '../utils/logger'
 import type { Options } from '../options'
 
 export async function resolveEntry(
   entry: Options['entry'],
   cwd: string,
+  name?: string,
 ): Promise<Record<string, string>> {
   if (!entry || Object.keys(entry).length === 0) {
     // TODO auto find entry
@@ -20,7 +20,8 @@ export async function resolveEntry(
     throw new Error(`Cannot find entry: ${JSON.stringify(entry)}`)
   }
   logger.info(
-    `entry: ${blue(entries.map((entry) => path.relative(cwd, entry)).join(', '))}`,
+    prettyName(name),
+    `entry: ${generateColor(name)(entries.map((entry) => path.relative(cwd, entry)).join(', '))}`,
   )
   return entryMap
 }

src/features/report.ts

@@ -6,8 +6,7 @@ import { bold, dim, green } from 'ansis'
 import Debug from 'debug'
 import { formatBytes } from '../utils/format'
 import { noop } from '../utils/general'
-import { logger } from '../utils/logger'
-import { prettyFormat } from '../utils/package'
+import { logger, prettyFormat, prettyName } from '../utils/logger'
 import type { OutputAsset, OutputChunk, Plugin } from 'rolldown'
 
 const debug = Debug('tsdown:report')
@@ -24,8 +23,8 @@ interface SizeInfo {
   gzip: number
   brotli: number
   rawText: string
-  gzipText: string
-  brotliText: string
+  gzipText?: string
+  brotliText?: string
 }
 
 export interface ReportOptions {
@@ -48,6 +47,8 @@ export function ReportPlugin(
   options: ReportOptions,
   cwd: string,
   cjsDts?: boolean,
+  name?: string,
+  isMultiFormat?: boolean,
 ): Plugin {
   return {
     name: 'tsdown:report',
@@ -74,17 +75,21 @@ export function ReportPlugin(
         ...sizes.map((size) => size.rawText.length),
       )
       const gzipTextLength = Math.max(
-        ...sizes.map((size) => size.gzipText.length),
+        ...sizes.map((size) =>
+          size.gzipText == null ? 0 : size.gzipText.length,
+        ),
       )
       const brotliTextLength = Math.max(
-        ...sizes.map((size) => size.brotliText.length),
+        ...sizes.map((size) =>
+          size.brotliText == null ? 0 : size.brotliText.length,
+        ),
       )
 
       let totalRaw = 0
       for (const size of sizes) {
         size.rawText = size.rawText.padStart(rawTextLength)
-        size.gzipText = size.gzipText.padStart(gzipTextLength)
-        size.brotliText = size.brotliText.padStart(brotliTextLength)
+        size.gzipText = size.gzipText?.padStart(gzipTextLength)
+        size.brotliText = size.brotliText?.padStart(brotliTextLength)
         totalRaw += size.raw
       }
 
@@ -98,23 +103,33 @@ export function ReportPlugin(
         return b.raw - a.raw
       })
 
-      const formatLabel = prettyFormat(cjsDts ? 'cjs' : outputOptions.format)
+      const nameLabel = prettyName(name)
+      const formatLabel =
+        isMultiFormat && prettyFormat(cjsDts ? 'cjs' : outputOptions.format)
 
       for (const size of sizes) {
         const filenameColor = size.dts ? green : noop
 
         logger.info(
+          nameLabel,
           formatLabel,
           dim(`${outDir}/`) +
             filenameColor((size.isEntry ? bold : noop)(size.filename)),
           ` `.repeat(filenameLength - size.filename.length),
-          dim`${size.rawText} │ gzip: ${size.gzipText}`,
-          options.brotli ? dim` │ brotli: ${size.brotliText}` : '',
+          dim(size.rawText),
+          size.gzipText && dim`│ gzip: ${size.gzipText}`,
+          options.brotli &&
+            size.brotliText &&
+            dim`│ brotli: ${size.brotliText}`,
         )
       }
 
       const totalSizeText = formatBytes(totalRaw)
-      logger.info(formatLabel, `${sizes.length} files, total: ${totalSizeText}`)
+      logger.info(
+        nameLabel,
+        formatLabel,
+        `${sizes.length} files, total: ${totalSizeText}`,
+      )
     },
   }
 }
@@ -149,7 +164,7 @@ async function calcSize(
     dts: RE_DTS.test(chunk.fileName),
     isEntry: chunk.type === 'chunk' && chunk.isEntry,
     raw,
-    rawText: formatBytes(raw),
+    rawText: formatBytes(raw)!,
     gzip,
     gzipText: formatBytes(gzip),
     brotli,

src/features/shebang.ts

@@ -2,13 +2,16 @@ import { chmod } from 'node:fs/promises'
 import path from 'node:path'
 import { underline } from 'ansis'
 import { fsExists } from '../utils/fs'
-import { logger } from '../utils/logger'
-import { prettyFormat } from '../utils/package'
+import { logger, prettyFormat, prettyName } from '../utils/logger'
 import type { Plugin } from 'rolldown'
 
 const RE_SHEBANG = /^#!.*/
 
-export function ShebangPlugin(cwd: string): Plugin {
+export function ShebangPlugin(
+  cwd: string,
+  name?: string,
+  isMultiFormat?: boolean,
+): Plugin {
   return {
     name: 'tsdown:shebang',
     async writeBundle(options, bundle) {
@@ -22,7 +25,8 @@ export function ShebangPlugin(cwd: string): Plugin {
         )
         if (await fsExists(filepath)) {
           logger.info(
-            prettyFormat(options.format),
+            prettyName(name),
+            isMultiFormat && prettyFormat(options.format),
             `Granting execute permission to ${underline(path.relative(cwd, filepath))}`,
           )
           await chmod(filepath, 0o755)

src/features/target.ts

@@ -1,12 +1,12 @@
-import { blue } from 'ansis'
 import minVersion from 'semver/ranges/min-version.js'
 import { resolveComma, toArray } from '../utils/general'
-import { logger } from '../utils/logger'
+import { generateColor, logger, prettyName } from '../utils/logger'
 import type { PackageJson } from 'pkg-types'
 
 export function resolveTarget(
   target: string | string[] | false | undefined,
   pkg?: PackageJson,
+  name?: string,
 ): string[] | undefined {
   if (target === false) return
   if (target == null) {
@@ -20,7 +20,8 @@ export function resolveTarget(
   const targets = resolveComma(toArray(target))
   if (targets.length)
     logger.info(
-      `target${targets.length > 1 ? 's' : ''}: ${blue(targets.join(', '))}`,
+      prettyName(name),
+      `target${targets.length > 1 ? 's' : ''}: ${generateColor(name)(targets.join(', '))}`,
     )
 
   return targets

src/features/tsconfig.ts

@@ -1,8 +1,8 @@
 import path from 'node:path'
-import { blue, underline } from 'ansis'
+import { blue } from 'ansis'
 import { up as findUp } from 'empathic/find'
 import { fsStat } from '../utils/fs'
-import { logger } from '../utils/logger'
+import { generateColor, logger, prettyName } from '../utils/logger'
 import type { Options } from '../options'
 
 export function findTsconfig(
@@ -15,6 +15,7 @@ export function findTsconfig(
 export async function resolveTsconfig(
   tsconfig: Options['tsconfig'],
   cwd: string,
+  name?: string,
 ): Promise<string | false> {
   const original = tsconfig
 
@@ -43,7 +44,10 @@ export async function resolveTsconfig(
     }
 
     if (tsconfig) {
-      logger.info(`Using tsconfig: ${underline(path.relative(cwd, tsconfig))}`)
+      logger.info(
+        prettyName(name),
+        `tsconfig: ${generateColor(name)(path.relative(cwd, tsconfig))}`,
+      )
     }
   }
 

src/index.ts

@@ -32,7 +32,6 @@ import {
 } from './options'
 import { ShebangPlugin } from './plugins'
 import { logger } from './utils/logger'
-import { prettyFormat } from './utils/package'
 import type { Options as DtsOptions } from 'rolldown-plugin-dts'
 
 const debug = Debug('tsdown:main')
@@ -62,6 +61,7 @@ export async function build(userOptions: Options = {}): Promise<void> {
     return (cleanPromise = cleanOutDir(configs))
   }
 
+  logger.info('Build start')
   const rebuilds = await Promise.all(
     configs.map((options) => buildSingle(options, clean)),
   )
@@ -124,17 +124,21 @@ export async function buildSingle(
     await Promise.all(
       formats.map(async (format) => {
         try {
-          const formatLabel = prettyFormat(format)
-          logger.info(formatLabel, 'Build start')
-
-          const buildOptions = await getBuildOptions(config, format)
+          const isMultiFormat = formats.length > 1
+          const buildOptions = await getBuildOptions(
+            config,
+            format,
+            isMultiFormat,
+          )
           await hooks.callHook('build:before', {
             ...context,
             buildOptions,
           })
           await rolldownBuild(buildOptions)
           if (format === 'cjs' && dts) {
-            await rolldownBuild(await getBuildOptions(config, format, true))
+            await rolldownBuild(
+              await getBuildOptions(config, format, true, isMultiFormat),
+            )
           }
         } catch (error) {
           if (watch) {
@@ -180,6 +184,7 @@ async function getBuildOptions(
   config: ResolvedOptions,
   format: NormalizedFormat,
   cjsDts?: boolean,
+  isMultiFormat?: boolean,
 ): Promise<BuildOptions> {
   const {
     entry,
@@ -202,6 +207,7 @@ async function getBuildOptions(
     env,
     removeNodeProtocol,
     loader,
+    name,
   } = config
 
   const plugins: RolldownPluginOption = []
@@ -240,11 +246,11 @@ async function getBuildOptions(
         }),
       )
     }
-    plugins.push(ShebangPlugin(cwd))
+    plugins.push(ShebangPlugin(cwd, name, isMultiFormat))
   }
 
   if (report && !logger.silent) {
-    plugins.push(ReportPlugin(report, cwd, cjsDts))
+    plugins.push(ReportPlugin(report, cwd, cjsDts, name, isMultiFormat))
   }
 
   if (target) {

src/options/index.ts

@@ -151,6 +151,12 @@ export interface Options {
   /** @default false */
   shims?: boolean
 
+  /**
+   * The name to show in CLI output. This is useful for monorepos or workspaces.
+   * Defaults to the package name from `package.json`.
+   */
+  name?: string
+
   /**
    * Use a fixed extension for output files.
    * The extension will always be `.cjs` or `.mjs`.
@@ -330,6 +336,7 @@ export type ResolvedOptions = Omit<
       | 'removeNodeProtocol'
       | 'copy'
       | 'loader'
+      | 'name'
     >,
     {
       format: NormalizedFormat[]
@@ -452,19 +459,21 @@ async function resolveConfig(
     publicDir,
     hash,
     cwd = process.cwd(),
+    name,
   } = userConfig
 
   outDir = path.resolve(cwd, outDir)
   clean = resolveClean(clean, outDir, cwd)
 
   const pkg = await readPackageJson(cwd)
-  entry = await resolveEntry(entry, cwd)
+  name ||= pkg?.name
+  entry = await resolveEntry(entry, cwd, name)
   if (dts == null) {
     dts = !!(pkg?.types || pkg?.typings)
   }
-  target = resolveTarget(target, pkg)
+  target = resolveTarget(target, pkg, name)
+  tsconfig = await resolveTsconfig(tsconfig, cwd, name)
 
-  tsconfig = await resolveTsconfig(tsconfig, cwd)
   if (publint === true) publint = {}
 
   if (publicDir) {
@@ -532,6 +541,7 @@ async function resolveConfig(
     pkg,
     copy: publicDir || copy,
     hash: hash ?? true,
+    name,
   }
 
   return config

src/utils/format.ts

@@ -1,7 +1,5 @@
-export function formatBytes(bytes: number): string {
-  if (bytes === Infinity) {
-    return 'too large'
-  }
+export function formatBytes(bytes: number): string | undefined {
+  if (bytes === Infinity) return undefined
   const numberFormatter = new Intl.NumberFormat('en', {
     maximumFractionDigits: 2,
     minimumFractionDigits: 2,