@vitus-labs/tools-rolldown 1.15.5 → 2.1.0

package/src/scripts/build.test.ts

@@ -1,336 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const {
-  mockRolldown,
-  mockBundleWrite,
-  mockBundleClose,
-  mockReaddirSync,
-  mockCreateBuildPipeline,
-  mockRolldownConfig,
-  mockBuildAllDts,
-} = vi.hoisted(() => ({
-  mockRolldown: vi.fn(),
-  mockBundleWrite: vi.fn(),
-  mockBundleClose: vi.fn(),
-  mockReaddirSync: vi.fn(),
-  mockCreateBuildPipeline: vi.fn(),
-  mockRolldownConfig: vi.fn(),
-  mockBuildAllDts: vi.fn(),
-}))
-
-vi.mock('rolldown', () => ({ rolldown: mockRolldown }))
-vi.mock('rimraf', () => ({ rimraf: { sync: vi.fn() } }))
-vi.mock('node:fs', () => ({
-  readdirSync: mockReaddirSync,
-  renameSync: vi.fn(),
-  statSync: vi.fn(),
-  unlinkSync: vi.fn(),
-  cpSync: vi.fn(),
-  mkdirSync: vi.fn(),
-}))
-
-vi.mock('../config/index.js', () => ({
-  CONFIG: { outputDir: 'lib' },
-  PKG: { name: '@test/pkg', version: '1.0.0' },
-}))
-
-vi.mock('../rolldown/index.js', () => ({
-  createBuildPipeline: mockCreateBuildPipeline,
-  config: mockRolldownConfig,
-  buildAllDts: mockBuildAllDts,
-}))
-
-describe('build', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-
-    mockBundleWrite.mockResolvedValue(undefined)
-    mockBundleClose.mockResolvedValue(undefined)
-    mockRolldown.mockResolvedValue({
-      write: mockBundleWrite,
-      close: mockBundleClose,
-    })
-    mockReaddirSync.mockReturnValue([])
-
-    mockCreateBuildPipeline.mockReturnValue([
-      {
-        file: 'lib/index.js',
-        format: 'es',
-        env: 'development',
-        platform: 'universal',
-      },
-    ])
-    mockRolldownConfig.mockImplementation((item: any) => ({
-      input: 'src',
-      output: {
-        dir: 'lib',
-        entryFileNames: 'index.js',
-        format: item.format,
-      },
-    }))
-    mockBuildAllDts.mockReturnValue([])
-  })
-
-  it('should execute build pipeline successfully', async () => {
-    vi.resetModules()
-    const { runBuild } = await import('./build.js')
-
-    await runBuild()
-
-    expect(mockRolldown).toHaveBeenCalled()
-    expect(mockBundleWrite).toHaveBeenCalled()
-    expect(mockBundleClose).toHaveBeenCalled()
-  })
-
-  it('should generate DTS when buildAllDts returns configs', async () => {
-    mockBuildAllDts.mockReturnValue([
-      {
-        file: './lib/index.d.ts',
-        input: 'src/index.ts',
-        output: {
-          dir: 'lib',
-          entryFileNames: 'index.d.ts',
-          format: 'es',
-        },
-      },
-    ])
-
-    vi.resetModules()
-    const { runBuild } = await import('./build.js')
-    vi.clearAllMocks()
-
-    // Re-setup after clear
-    mockRolldown.mockResolvedValue({
-      write: mockBundleWrite,
-      close: mockBundleClose,
-    })
-    mockBundleWrite.mockResolvedValue(undefined)
-    mockBundleClose.mockResolvedValue(undefined)
-    mockReaddirSync.mockReturnValue([])
-    mockRolldownConfig.mockImplementation((item: any) => ({
-      input: 'src',
-      output: {
-        dir: 'lib',
-        entryFileNames: 'index.js',
-        format: item.format,
-      },
-    }))
-    mockBuildAllDts.mockReturnValue([
-      {
-        file: './lib/index.d.ts',
-        input: 'src/index.ts',
-        output: {
-          dir: 'lib',
-          entryFileNames: 'index.d.ts',
-          format: 'es',
-        },
-      },
-    ])
-    // buildDtsIsolated reads temp dir to find largest .d.ts
-    mockReaddirSync.mockReturnValue(['index.d.ts'])
-    const { statSync } = await import('node:fs')
-    vi.mocked(statSync).mockReturnValue({ size: 100 } as ReturnType<
-      typeof statSync
-    >)
-
-    await runBuild()
-
-    // main build + DTS build = 2 rolldown calls
-    expect(mockRolldown).toHaveBeenCalledTimes(2)
-  })
-
-  it('should pick largest DTS file when code-split occurs', async () => {
-    mockBuildAllDts.mockReturnValue([
-      {
-        file: './lib/index.d.ts',
-        input: 'src/index.ts',
-        output: {
-          dir: 'lib',
-          entryFileNames: 'index.d.ts',
-          format: 'es',
-        },
-      },
-    ])
-
-    vi.resetModules()
-    const { runBuild } = await import('./build.js')
-    const { statSync, renameSync, mkdirSync } = await import('node:fs')
-    vi.clearAllMocks()
-
-    // Re-setup
-    mockRolldown.mockResolvedValue({
-      write: mockBundleWrite,
-      close: mockBundleClose,
-    })
-    mockBundleWrite.mockResolvedValue(undefined)
-    mockBundleClose.mockResolvedValue(undefined)
-    mockRolldownConfig.mockImplementation((item: any) => ({
-      input: 'src',
-      output: {
-        dir: 'lib',
-        entryFileNames: 'index.js',
-        format: item.format,
-      },
-    }))
-    mockBuildAllDts.mockReturnValue([
-      {
-        file: './lib/index.d.ts',
-        input: 'src/index.ts',
-        output: {
-          dir: 'lib',
-          entryFileNames: 'index.d.ts',
-          format: 'es',
-        },
-      },
-    ])
-    // Temp dir has entry stub + larger chunk — largest should be picked
-    mockReaddirSync.mockReturnValue(['index.d.ts', 'index2.d.ts'])
-    vi.mocked(statSync).mockImplementation((p: any) => {
-      if (String(p).includes('index2'))
-        return { size: 1000 } as ReturnType<typeof statSync>
-      return { size: 10 } as ReturnType<typeof statSync>
-    })
-
-    await runBuild()
-
-    // buildDtsIsolated creates temp dir, picks largest, moves to final
-    expect(mkdirSync).toHaveBeenCalled()
-    expect(renameSync).toHaveBeenCalled()
-  })
-
-  it('should handle build failure gracefully', async () => {
-    vi.resetModules()
-    const { runBuild } = await import('./build.js')
-    vi.clearAllMocks()
-
-    const buildError = new Error('rolldown failed')
-    mockRolldown.mockRejectedValue(buildError)
-    mockReaddirSync.mockReturnValue([])
-    mockRolldownConfig.mockImplementation((item: any) => ({
-      input: 'src',
-      output: {
-        dir: 'lib',
-        entryFileNames: 'index.js',
-        format: item.format,
-      },
-    }))
-    mockBuildAllDts.mockReturnValue([])
-
-    await expect(runBuild()).rejects.toThrow('rolldown failed')
-  })
-
-  it('should handle multiple builds in sequence', async () => {
-    mockCreateBuildPipeline.mockReturnValue([
-      {
-        file: 'lib/index.js',
-        format: 'es',
-        env: 'development',
-        platform: 'universal',
-      },
-      {
-        file: 'lib/index.cjs',
-        format: 'cjs',
-        env: 'development',
-        platform: 'universal',
-      },
-    ])
-
-    vi.resetModules()
-    const { runBuild } = await import('./build.js')
-    vi.clearAllMocks()
-
-    mockRolldown.mockResolvedValue({
-      write: mockBundleWrite,
-      close: mockBundleClose,
-    })
-    mockBundleWrite.mockResolvedValue(undefined)
-    mockBundleClose.mockResolvedValue(undefined)
-    mockReaddirSync.mockReturnValue([])
-    mockRolldownConfig.mockImplementation((item: any) => ({
-      input: 'src',
-      output: {
-        dir: 'lib',
-        entryFileNames: 'index.js',
-        format: item.format,
-      },
-    }))
-    mockBuildAllDts.mockReturnValue([])
-
-    await runBuild()
-
-    expect(mockRolldownConfig).toHaveBeenCalledTimes(2)
-    expect(mockRolldown).toHaveBeenCalledTimes(2)
-  })
-
-  it('should generate multiple DTS for subpath exports', async () => {
-    mockBuildAllDts.mockReturnValue([
-      {
-        file: './lib/types/index.d.ts',
-        input: 'src/index.ts',
-        output: {
-          dir: 'lib/types',
-          entryFileNames: 'index.d.ts',
-          format: 'es',
-        },
-      },
-      {
-        file: './lib/types/devtools/index.d.ts',
-        input: 'src/devtools/index.ts',
-        output: {
-          dir: 'lib/types/devtools',
-          entryFileNames: 'index.d.ts',
-          format: 'es',
-        },
-      },
-    ])
-
-    vi.resetModules()
-    const { runBuild } = await import('./build.js')
-    const { statSync } = await import('node:fs')
-    vi.clearAllMocks()
-
-    mockRolldown.mockResolvedValue({
-      write: mockBundleWrite,
-      close: mockBundleClose,
-    })
-    mockBundleWrite.mockResolvedValue(undefined)
-    mockBundleClose.mockResolvedValue(undefined)
-    mockReaddirSync.mockReturnValue(['index.d.ts'])
-    vi.mocked(statSync).mockReturnValue({ size: 100 } as ReturnType<
-      typeof statSync
-    >)
-    mockRolldownConfig.mockImplementation((item: any) => ({
-      input: 'src',
-      output: {
-        dir: 'lib',
-        entryFileNames: 'index.js',
-        format: item.format,
-      },
-    }))
-    mockBuildAllDts.mockReturnValue([
-      {
-        file: './lib/types/index.d.ts',
-        input: 'src/index.ts',
-        output: {
-          dir: 'lib/types',
-          entryFileNames: 'index.d.ts',
-          format: 'es',
-        },
-      },
-      {
-        file: './lib/types/devtools/index.d.ts',
-        input: 'src/devtools/index.ts',
-        output: {
-          dir: 'lib/types/devtools',
-          entryFileNames: 'index.d.ts',
-          format: 'es',
-        },
-      },
-    ])
-
-    await runBuild()
-
-    // 1 main build + 2 isolated DTS builds = 3 rolldown calls
-    expect(mockRolldown).toHaveBeenCalledTimes(3)
-  })
-})

package/src/scripts/build.ts

@@ -1,172 +0,0 @@
-import { cpSync, mkdirSync, readdirSync, renameSync, statSync } from 'node:fs'
-import { join } from 'node:path'
-import chalk from 'chalk'
-import { rimraf } from 'rimraf'
-import { rolldown } from 'rolldown'
-import { CONFIG, PKG } from '../config/index.js'
-import {
-  buildAllDts,
-  createBuildPipeline,
-  config as rolldownConfig,
-} from '../rolldown/index.js'
-
-const { log } = console
-const allBuilds = createBuildPipeline()
-const allBuildsCount = allBuilds.length
-
-const FORMAT_LABEL: Record<string, string> = {
-  cjs: 'CJS',
-  es: 'ESM',
-  umd: 'UMD',
-  iife: 'IIFE',
-}
-
-const label = (text: string) => chalk.bold.bgCyan.black(` ${text} `)
-const dim = chalk.dim
-const bold = chalk.bold
-
-async function build({
-  inputOptions,
-  outputOptions,
-}: {
-  inputOptions: any
-  outputOptions: any
-}) {
-  const bundle = await rolldown(inputOptions)
-  await bundle.write(outputOptions)
-  await bundle.close()
-}
-
-const createBuilds = async () => {
-  let p = Promise.resolve()
-
-  allBuilds.forEach((item: Record<string, any>) => {
-    const { output, ...input } = rolldownConfig(item)
-    const format = FORMAT_LABEL[output.format] || output.format
-    p = p.then(() => {
-      const start = performance.now()
-
-      return build({ inputOptions: input, outputOptions: output })
-        .then(() => {
-          const duration = Math.round(performance.now() - start)
-          log(
-            `  ${chalk.green('+')} ${bold(format)} ${dim('->')} ${dim(`${output.dir}/${output.entryFileNames}`)} ${dim(`(${duration}ms)`)}`,
-          )
-        })
-        .catch((e) => {
-          log(`\n${chalk.bold.red('Build failed')}`)
-          log(chalk.gray(`  Format: ${format}`))
-          log(chalk.gray(`  File:   ${output.dir}/${output.entryFileNames}`))
-          log(e)
-          throw e
-        })
-    })
-  })
-
-  return p
-}
-
-const copyStaticFiles = () => {
-  if (!Array.isArray(CONFIG.copyFiles) || CONFIG.copyFiles.length === 0) return
-
-  log(`\n${dim('Copying')} static files...\n`)
-  for (const { from, to } of CONFIG.copyFiles as {
-    from: string
-    to: string
-  }[]) {
-    cpSync(from, to, { recursive: true })
-    log(`  ${chalk.green('+')} ${dim(from)} ${dim('->')} ${dim(to)}`)
-  }
-}
-
-/**
- * Build a single DTS entry in an isolated temp directory, then move the
- * largest .d.ts file (the real declarations) to the final output path.
- *
- * Rolldown code-splits DTS output: the entry file is a tiny re-export stub,
- * and the actual types go into a chunk. Building into a temp dir avoids
- * collisions when multiple DTS entries share the same output directory.
- */
-const buildDtsIsolated = async (
-  dtsConfig: ReturnType<typeof buildAllDts>[number],
-) => {
-  const { output, file, ...input } = dtsConfig
-  const finalDir = output.dir as string
-  const entryName = output.entryFileNames as string
-  const tempDir = join(finalDir, `__dts_tmp_${entryName.replace(/\W/g, '_')}`)
-
-  // Build into isolated temp directory
-  const tempOutput = { ...output, dir: tempDir }
-  await build({ inputOptions: input, outputOptions: tempOutput })
-
-  // Find the largest .d.ts file — that's the real declarations
-  const absTempDir = join(process.cwd(), tempDir)
-  const dtsFiles = readdirSync(absTempDir).filter((f) => f.endsWith('.d.ts'))
-
-  let bestFile = dtsFiles[0] || entryName
-  let bestSize = 0
-  for (const f of dtsFiles) {
-    const size = statSync(join(absTempDir, f)).size
-    if (size > bestSize) {
-      bestSize = size
-      bestFile = f
-    }
-  }
-
-  // Move the best file to the final location
-  const absFinalDir = join(process.cwd(), finalDir)
-  mkdirSync(absFinalDir, { recursive: true })
-  renameSync(join(absTempDir, bestFile), join(absFinalDir, entryName))
-
-  // Move sourcemap if it exists
-  const mapName = `${bestFile}.map`
-  try {
-    renameSync(join(absTempDir, mapName), join(absFinalDir, `${entryName}.map`))
-  } catch {
-    // sourcemap may not exist
-  }
-
-  // Clean up temp directory
-  rimraf.sync(absTempDir)
-}
-
-const generateDeclarations = async () => {
-  const dtsConfigs = buildAllDts()
-  if (dtsConfigs.length === 0) return
-
-  log(`\n${dim('Generating')} declarations...`)
-
-  for (const dtsFile of dtsConfigs) {
-    const tscStart = performance.now()
-    await buildDtsIsolated(dtsFile)
-
-    const tscDuration = Math.round(performance.now() - tscStart)
-    log(
-      `  ${chalk.green('+')} ${bold('DTS')} ${dim('->')} ${dim(dtsFile.file)} ${dim(`(${tscDuration}ms)`)}`,
-    )
-  }
-}
-
-const runBuild = async () => {
-  const start = performance.now()
-
-  log(
-    `\n${label('rolldown')} ${bold(PKG.name || '')} ${dim(`v${PKG.version || '0.0.0'}`)}\n`,
-  )
-
-  log(`${dim('Cleaning')} ${CONFIG.outputDir}/`)
-  rimraf.sync(`${process.cwd()}/${CONFIG.outputDir}`)
-
-  log(
-    `${dim('Building')} ${bold(String(allBuildsCount))} bundle${allBuildsCount > 1 ? 's' : ''}...\n`,
-  )
-
-  await createBuilds()
-  copyStaticFiles()
-  await generateDeclarations()
-
-  const total = Math.round(performance.now() - start)
-  log(`\n${chalk.green('Done')} ${dim(`in ${total}ms`)}\n`)
-}
-
-export { runBuild }

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "extends": "@vitus-labs/tools-typescript/lib",
-  "compilerOptions": {
-    "noEmit": false,
-    "outDir": "lib",
-    "rootDir": "src",
-    "baseUrl": ".",
-    "declarationDir": "./lib/types",
-    "paths": {
-      "~/*": ["src/*"]
-    }
-  },
-  "include": ["typings", "src"],
-  "exclude": ["node_modules", "__stories__", "lib", "**/*.test.ts"]
-}

package/vitest.config.ts

@@ -1,3 +0,0 @@
-import { createVitestConfig } from '@vitus-labs/tools-vitest'
-
-export default createVitestConfig(['src/config/baseConfig.ts'])