feat: 构建功能增强

Author: Sunny-117

TODO.md

@@ -19,12 +19,12 @@
 ### 🏗️ 构建功能增强
 
 - [x] **清理功能** - 构建前自动清理输出目录 (`clean`)
-- [ ] **文件复制** - 静态资源复制功能 (`copy`)
-- [ ] **文件哈希** - 输出文件名哈希支持 (`hash`)
-- [ ] **固定扩展名** - 强制使用 `.cjs`/`.mjs` 扩展名 (`fixedExtension`)
-- [ ] **自定义扩展名** - 灵活的输出文件扩展名配置 (`outExtensions`)
-- [ ] **Banner/Footer** - 文件头尾注释添加
-- [ ] **Node.js 协议处理** - `node:` 前缀的添加/移除 (`nodeProtocol`)
+- [x] **文件复制** - 静态资源复制功能 (`copy`)
+- [x] **文件哈希** - 输出文件名哈希支持 (`hash`)
+- [x] **固定扩展名** - 强制使用 `.cjs`/`.mjs` 扩展名 (`fixedExtension`)
+- [x] **自定义扩展名** - 灵活的输出文件扩展名配置 (`outExtensions`)
+- [x] **Banner/Footer** - 文件头尾注释添加
+- [x] **Node.js 协议处理** - `node:` 前缀的添加/移除 (`nodeProtocol`)
 
 ### 🔍 代码质量和分析
 

src/builders/bundle.ts

@@ -20,7 +20,11 @@ import { rolldown } from 'rolldown'
 
 import { dts } from 'rolldown-plugin-dts'
 
+import { resolveChunkAddon } from '../features/banner'
+import { copyFiles } from '../features/copy'
+import { addHashToFilename, hasHash } from '../features/hash'
 import { distSize, fmtPath, sideEffectSize } from '../utils'
+import { nodeProtocolPlugin } from './plugins/node-protocol'
 import { makeExecutable, shebangPlugin } from './plugins/shebang'
 
 /**
@@ -44,7 +48,16 @@ function formatToRolldownFormat(format: OutputFormat): ModuleFormat {
 /**
  * Get file extension for format
  */
-function getFormatExtension(format: OutputFormat, platform: Platform): string {
+function getFormatExtension(
+  format: OutputFormat,
+  platform: Platform,
+  fixedExtension = false,
+): string {
+  if (fixedExtension) {
+    // Force .cjs/.mjs extensions
+    return format === 'cjs' ? '.cjs' : '.mjs'
+  }
+
   switch (format) {
     case 'esm':
       return '.mjs' // Always use .mjs for ESM to be explicit about module type
@@ -182,7 +195,10 @@ export async function rolldownBuild(
   const baseRolldownConfig = defu(entry.rolldown, {
     cwd: ctx.pkgDir,
     input: inputs,
-    plugins: [shebangPlugin()] as Plugin[],
+    plugins: [
+      shebangPlugin(),
+      nodeProtocolPlugin(entry.nodeProtocol || false),
+    ] as Plugin[],
     platform: platform === 'node' ? 'node' : 'neutral',
     external: typeof entry.external === 'function'
       ? entry.external
@@ -213,7 +229,7 @@ export async function rolldownBuild(
 
   for (const format of formats) {
     const rolldownFormat = formatToRolldownFormat(format)
-    const extension = getFormatExtension(format, platform)
+    const extension = getFormatExtension(format, platform, entry.fixedExtension)
 
     // Create config for this format
     const formatConfig = { ...baseRolldownConfig }
@@ -256,6 +272,8 @@ export async function rolldownBuild(
       chunkFileNames: `_chunks/[name]-[hash]${extension}`,
       minify: entry.minify,
       name: entry.globalName, // For IIFE/UMD formats
+      banner: resolveChunkAddon(entry.banner, format),
+      footer: resolveChunkAddon(entry.footer, format),
     }
 
     await hooks.rolldownOutput?.(outConfig, res, ctx)
@@ -295,20 +313,42 @@ export async function rolldownBuild(
       if (chunk.fileName.endsWith('ts'))
         continue
 
+      let finalFileName = chunk.fileName
+      let finalFilePath = join(formatOutDir, chunk.fileName)
+
+      // Add hash to filename if requested
+      if (entry.hash && !hasHash(chunk.fileName)) {
+        const content = chunk.code
+        const hashedFileName = addHashToFilename(chunk.fileName, content)
+        const hashedFilePath = join(formatOutDir, hashedFileName)
+
+        // Rename the file to include hash
+        const { rename } = await import('node:fs/promises')
+        await rename(finalFilePath, hashedFilePath)
+
+        finalFileName = hashedFileName
+        finalFilePath = hashedFilePath
+      }
+
       // Store full path for logging
-      filePathMap.set(chunk.fileName, join(formatOutDir, chunk.fileName))
+      filePathMap.set(finalFileName, finalFilePath)
 
       allOutputEntries.push({
         format,
-        name: chunk.fileName,
+        name: finalFileName,
         exports: chunk.exports,
         deps: resolveDeps(chunk),
-        ...(await distSize(formatOutDir, chunk.fileName)),
-        sideEffectSize: await sideEffectSize(formatOutDir, chunk.fileName),
+        ...(await distSize(formatOutDir, finalFileName)),
+        sideEffectSize: await sideEffectSize(formatOutDir, finalFileName),
       })
     }
   }
 
+  // Copy files if specified
+  if (entry.copy) {
+    await copyFiles(ctx.pkgDir, fullOutDir, entry.copy)
+  }
+
   // Display build results
   consola.log(
     `\n${allOutputEntries

src/builders/plugins/node-protocol.ts

@@ -0,0 +1,23 @@
+import type { Plugin } from 'rolldown'
+import { transformNodeProtocol } from '../../features/node-protocol'
+
+/**
+ * Rolldown plugin for Node.js protocol handling
+ */
+export function nodeProtocolPlugin(nodeProtocol: 'strip' | boolean): Plugin {
+  if (!nodeProtocol) {
+    return {
+      name: 'node-protocol-noop',
+    }
+  }
+
+  return {
+    name: 'node-protocol',
+    renderChunk(code) {
+      return {
+        code: transformNodeProtocol(code, nodeProtocol),
+        map: null,
+      }
+    },
+  }
+}

src/builders/transform.ts

@@ -12,6 +12,11 @@ import { minify } from 'oxc-minify'
 import { parseSync } from 'oxc-parser'
 import { transform } from 'oxc-transform'
 import { glob } from 'tinyglobby'
+import { addBannerFooter, resolveChunkAddon } from '../features/banner'
+import { copyFiles } from '../features/copy'
+import { createFilename } from '../features/extensions'
+import { addHashToFilename, hasHash } from '../features/hash'
+import { transformNodeProtocol } from '../features/node-protocol'
 import { fmtPath } from '../utils'
 import { makeExecutable, SHEBANG_RE } from './plugins/shebang'
 
@@ -74,20 +79,40 @@ export async function transformDir(
           case '.ts': {
             {
               const transformed = await transformModule(entryPath, entry)
-              const entryDistPath = join(
-                entry.outDir!,
-                entryName.replace(/\.ts$/, '.mjs'),
-              )
+
+              // Determine output filename with proper extension
+              const baseName = entryName.replace(/\.ts$/, '')
+              const outputFileName = createFilename(baseName, 'esm', false, {
+                platform: entry.platform,
+                fixedExtension: entry.fixedExtension,
+                outExtensions: entry.outExtensions,
+              })
+
+              let entryDistPath = join(entry.outDir!, outputFileName)
               await mkdir(dirname(entryDistPath), { recursive: true })
               await writeFile(entryDistPath, transformed.code, 'utf8')
 
+              // Add hash to filename if requested
+              if (entry.hash && !hasHash(entryDistPath)) {
+                const hashedPath = addHashToFilename(entryDistPath, transformed.code)
+                const { rename } = await import('node:fs/promises')
+                await rename(entryDistPath, hashedPath)
+                entryDistPath = hashedPath
+              }
+
               if (SHEBANG_RE.test(transformed.code)) {
                 await makeExecutable(entryDistPath)
               }
 
               if (transformed.declaration) {
+                const dtsFileName = createFilename(baseName, 'esm', true, {
+                  platform: entry.platform,
+                  fixedExtension: entry.fixedExtension,
+                  outExtensions: entry.outExtensions,
+                })
+                const dtsPath = join(entry.outDir!, dtsFileName)
                 await writeFile(
-                  entryDistPath.replace(/\.mjs$/, '.d.mts'),
+                  dtsPath,
                   transformed.declaration,
                   'utf8',
                 )
@@ -116,6 +141,11 @@ export async function transformDir(
 
   const writtenFiles = await Promise.all(promises)
 
+  // Copy files if specified
+  if (entry.copy) {
+    await copyFiles(ctx.pkgDir, fullOutDir, entry.copy)
+  }
+
   consola.log(
     `\n${c.magenta('[transform] ')}${c.underline(`${fmtPath(entry.outDir!)}/`)}\n${writtenFiles
       .map(f => c.dim(fmtPath(f)))
@@ -172,7 +202,7 @@ async function transformModule(entryPath: string, entry: TransformEntry) {
     // Handle aliases first
     if (entry.alias) {
       for (const [alias, target] of Object.entries(entry.alias)) {
-        if (moduleId === alias || moduleId.startsWith(alias + '/')) {
+        if (moduleId === alias || moduleId.startsWith(`${alias}/`)) {
           moduleId = moduleId.replace(alias, target)
           wasAliasResolved = true
           break
@@ -256,5 +286,15 @@ async function transformModule(entryPath: string, entry: TransformEntry) {
     transformed.map = res.map
   }
 
+  // Apply banner/footer
+  const banner = resolveChunkAddon(entry.banner, 'esm') // Transform mode uses ESM
+  const footer = resolveChunkAddon(entry.footer, 'esm')
+  transformed.code = addBannerFooter(transformed.code, banner, footer)
+
+  // Apply Node.js protocol handling
+  if (entry.nodeProtocol) {
+    transformed.code = transformNodeProtocol(transformed.code, entry.nodeProtocol)
+  }
+
   return transformed
 }

src/features/banner.ts

@@ -0,0 +1,55 @@
+import type { ChunkAddon, OutputFormat } from '../types'
+
+/**
+ * Resolve banner/footer addon for specific format
+ */
+export function resolveChunkAddon(
+  addon: string | ChunkAddon | undefined,
+  format: OutputFormat,
+): string | undefined {
+  if (!addon) {
+    return undefined
+  }
+
+  if (typeof addon === 'string') {
+    return addon
+  }
+
+  // Handle format-specific addons
+  const formatKey = format === 'esm' ? 'js' : format
+  return addon[formatKey] || addon.js
+}
+
+/**
+ * Add banner to content
+ */
+export function addBanner(content: string, banner?: string): string {
+  if (!banner) {
+    return content
+  }
+  return `${banner}\n${content}`
+}
+
+/**
+ * Add footer to content
+ */
+export function addFooter(content: string, footer?: string): string {
+  if (!footer) {
+    return content
+  }
+  return `${content}\n${footer}`
+}
+
+/**
+ * Add both banner and footer to content
+ */
+export function addBannerFooter(
+  content: string,
+  banner?: string,
+  footer?: string,
+): string {
+  let result = content
+  result = addBanner(result, banner)
+  result = addFooter(result, footer)
+  return result
+}

src/features/copy.ts

@@ -0,0 +1,43 @@
+import type { CopyEntry, CopyOptions } from '../types'
+import { cp } from 'node:fs/promises'
+import { basename, resolve } from 'node:path'
+import { consola } from 'consola'
+
+/**
+ * Copy files to output directory
+ */
+export async function copyFiles(
+  cwd: string,
+  outDir: string,
+  copyOptions: CopyOptions,
+): Promise<void> {
+  if (!copyOptions || copyOptions.length === 0) {
+    return
+  }
+
+  consola.debug('📁 Copying files...')
+
+  await Promise.all(
+    copyOptions.map(async (entry) => {
+      const from = typeof entry === 'string' ? entry : entry.from
+      const to = typeof entry === 'string'
+        ? resolve(outDir, basename(from))
+        : resolve(cwd, entry.to)
+
+      const fromPath = resolve(cwd, from)
+
+      try {
+        await cp(fromPath, to, {
+          recursive: true,
+          force: true,
+        })
+        consola.debug(`  ${from} → ${to}`)
+      }
+      catch (error) {
+        consola.warn(`Failed to copy ${from} to ${to}:`, error)
+      }
+    }),
+  )
+
+  consola.debug('✅ Files copied successfully')
+}