@vitus-labs/tools-rolldown 1.5.2-alpha.4 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitus-labs/tools-rolldown",
-  "version": "1.5.2-alpha.4+45b8634",
+  "version": "1.6.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -30,23 +30,24 @@
   },
   "scripts": {
     "prepublish": "bun run build",
-    "build": "tsc"
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@vitus-labs/tools-core": "1.5.2-alpha.4+45b8634",
+    "@vitus-labs/tools-core": "1.6.0",
     "chalk": "^5.6.2",
     "rimraf": "^6.1.2",
     "rolldown": "^1.0.0-rc.3",
-    "rolldown-plugin-dts": "^0.13.4",
+    "rolldown-plugin-dts": "^0.22.1",
     "rollup-plugin-filesize": "^10.0.0",
-    "rollup-plugin-visualizer": "^5.14.0"
+    "rollup-plugin-visualizer": "^6.0.5"
   },
   "devDependencies": {
-    "@vitus-labs/tools-typescript": "1.5.2-alpha.4+45b8634",
+    "@vitus-labs/tools-typescript": "1.6.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "45b863472eafa888f12f8f56d347dd20b72cd4f9"
+  "gitHead": "cb7b3bfa4e5730ecb95b3c886d23074a3ce9e85f"
 }

package/src/config/baseConfig.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest'
+import config from './baseConfig.js'
+
+describe('baseConfig', () => {
+  it('should have correct source and output directories', () => {
+    expect(config.sourceDir).toBe('src')
+    expect(config.outputDir).toBe('lib')
+    expect(config.typesDir).toBe('lib/types')
+  })
+
+  it('should have typescript enabled by default', () => {
+    expect(config.typescript).toBe(true)
+  })
+
+  it('should have replaceGlobals enabled', () => {
+    expect(config.replaceGlobals).toBe(true)
+  })
+
+  it('should define file extensions', () => {
+    expect(config.extensions).toContain('.ts')
+    expect(config.extensions).toContain('.tsx')
+    expect(config.extensions).toContain('.js')
+    expect(config.extensions).toContain('.json')
+  })
+
+  it('should have visualise config', () => {
+    expect(config.visualise).toEqual({
+      template: 'network',
+      gzipSize: true,
+      outputDir: 'analysis',
+    })
+  })
+
+  it('should have filesize enabled', () => {
+    expect(config.filesize).toBe(true)
+  })
+
+  it('should have default globals', () => {
+    expect(config.globals).toHaveProperty('react', 'React')
+  })
+
+  it('should have external dependencies', () => {
+    expect(config.external).toContain('react/jsx-runtime')
+  })
+
+  it('should have exclude patterns', () => {
+    expect(config.exclude).toContain('node_modules/**')
+    expect(config.exclude).toContain('**/__tests__/**')
+  })
+})

package/src/rolldown/config.test.ts

@@ -0,0 +1,348 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('rolldown-plugin-dts', () => ({
+  dts: vi.fn(() => [{ name: 'mock-dts' }]),
+}))
+vi.mock('rollup-plugin-filesize', () => ({
+  default: vi.fn(() => ({ name: 'mock-filesize' })),
+}))
+vi.mock('rollup-plugin-visualizer', () => ({
+  visualizer: vi.fn(() => ({ name: 'mock-visualizer' })),
+}))
+vi.mock('@vitus-labs/tools-core', () => ({
+  swapGlobals: (globals: Record<string, string>) =>
+    Object.fromEntries(Object.entries(globals).map(([k, v]) => [v, k])),
+}))
+
+const { mockConfig, mockPKG } = vi.hoisted(() => ({
+  mockConfig: {
+    sourceDir: 'src',
+    outputDir: 'lib',
+    typesDir: 'lib/types',
+    extensions: ['.ts', '.tsx', '.js'],
+    typescript: true,
+    replaceGlobals: true,
+    visualise: { template: 'network', gzipSize: true, outputDir: 'analysis' },
+    filesize: true,
+    external: ['react/jsx-runtime'],
+    globals: { react: 'React' },
+  } as Record<string, any>,
+  mockPKG: {
+    name: '@test/pkg',
+    version: '1.0.0',
+    bundleName: 'testPkg',
+    externalDependencies: ['react'],
+    exports: { types: './lib/index.d.ts', import: './lib/index.js' },
+  } as Record<string, any>,
+}))
+
+vi.mock('../config/index.js', () => ({
+  CONFIG: mockConfig,
+  PKG: mockPKG,
+  PLATFORMS: ['browser', 'node', 'web', 'native'],
+}))
+
+import rolldownConfig, { buildDts } from './config.js'
+
+const defaultConfig = { ...mockConfig }
+const defaultPKG = { ...mockPKG }
+
+describe('rolldownConfig', () => {
+  beforeEach(() => {
+    Object.assign(mockConfig, defaultConfig)
+    Object.assign(mockPKG, defaultPKG)
+  })
+
+  it('should create a valid ES module build config', () => {
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.input).toBe('src')
+    expect(config.output.format).toBe('es')
+    expect(config.output.sourcemap).toBe(true)
+    expect(config.output.esModule).toBe(true)
+    expect(config.external).toContain('react')
+    expect(config.external).toContain('react/jsx-runtime')
+  })
+
+  it('should set platform to node for node builds', () => {
+    const config = rolldownConfig({
+      file: 'lib/index.cjs',
+      format: 'cjs',
+      env: 'development',
+      platform: 'node',
+    })
+
+    expect(config.platform).toBe('node')
+    expect(config.output.exports).toBe('named')
+  })
+
+  it('should set platform to browser for browser builds', () => {
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'browser',
+    })
+
+    expect(config.platform).toBe('browser')
+  })
+
+  it('should set platform to neutral for unknown platforms', () => {
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.platform).toBe('neutral')
+  })
+
+  it('should add platform-specific extensions for known platforms', () => {
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'browser',
+    })
+
+    expect(config.resolve.extensions).toContain('.browser.ts')
+    expect(config.resolve.extensions).toContain('.ts')
+  })
+
+  it('should not add platform extensions for unknown platforms', () => {
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.resolve.extensions).not.toContain('.universal.ts')
+    expect(config.resolve.extensions).toContain('.ts')
+  })
+
+  it('should set name for UMD format', () => {
+    const config = rolldownConfig({
+      file: 'lib/index.umd.js',
+      format: 'umd',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.output.name).toBe('testPkg')
+    expect(config.output.exports).toBe('named')
+  })
+
+  it('should add define options with replaceGlobals', () => {
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'node',
+    })
+
+    expect(config.transform?.define?.__VERSION__).toBe('"1.0.0"')
+    expect(config.transform?.define?.__NODE__).toBe('true')
+  })
+
+  it('should add process.env.NODE_ENV for production builds', () => {
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'production',
+      platform: 'universal',
+    })
+
+    expect(config.transform?.define?.['process.env.NODE_ENV']).toBe(
+      '"production"',
+    )
+    expect(config.output.minify).toBe(true)
+  })
+
+  it('should not minify development builds', () => {
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.output.minify).toBe(false)
+  })
+
+  it('should skip define options when replaceGlobals is false', () => {
+    mockConfig.replaceGlobals = false
+
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.transform).toBeUndefined()
+  })
+
+  it('should skip visualizer when visualise is false', () => {
+    mockConfig.visualise = false
+
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    const hasVisualizer = config.plugins.some(
+      (p: any) => p?.name === 'mock-visualizer',
+    )
+    expect(hasVisualizer).toBe(false)
+  })
+
+  it('should skip filesize when filesize is false', () => {
+    mockConfig.filesize = false
+
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    const hasFilesize = config.plugins.some(
+      (p: any) => p?.name === 'mock-filesize',
+    )
+    expect(hasFilesize).toBe(false)
+  })
+
+  it('should set tsconfig when typescript is enabled', () => {
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.tsconfig).toBe('tsconfig.json')
+  })
+
+  it('should skip tsconfig when typescript is disabled', () => {
+    mockConfig.typescript = false
+
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.tsconfig).toBeUndefined()
+  })
+
+  it('should swap globals in output', () => {
+    const config = rolldownConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.output.globals).toEqual({ React: 'react' })
+  })
+
+  it('should set correct dir and entryFileNames from file path', () => {
+    const config = rolldownConfig({
+      file: 'lib/esm/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.output.dir).toBe('lib/esm')
+    expect(config.output.entryFileNames).toBe('index.js')
+  })
+
+  it('should handle file path without slash', () => {
+    const config = rolldownConfig({
+      file: 'bundle.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.output.dir).toBe('.')
+    expect(config.output.entryFileNames).toBe('bundle.js')
+  })
+})
+
+describe('buildDts', () => {
+  beforeEach(() => {
+    Object.assign(mockConfig, defaultConfig)
+    Object.assign(mockPKG, defaultPKG)
+  })
+
+  it('should return DTS config when typescript and types are available', () => {
+    const result = buildDts()
+
+    expect(result).not.toBeNull()
+    expect(result?.file).toBe('./lib/index.d.ts')
+    expect(result?.input).toBe('src/index.ts')
+    expect(result?.tsconfig).toBe('tsconfig.json')
+    expect(result?.output.format).toBe('es')
+  })
+
+  it('should return null when typescript is disabled', () => {
+    mockConfig.typescript = false
+
+    expect(buildDts()).toBeNull()
+  })
+
+  it('should return null when no types path exists', () => {
+    mockPKG.exports = { import: './lib/index.js' }
+    delete mockPKG.types
+    delete mockPKG.typings
+
+    expect(buildDts()).toBeNull()
+  })
+
+  it('should use PKG.types as fallback', () => {
+    mockPKG.exports = {}
+    mockPKG.types = './lib/types.d.ts'
+
+    const result = buildDts()
+
+    expect(result?.file).toBe('./lib/types.d.ts')
+  })
+
+  it('should use PKG.typings as final fallback', () => {
+    mockPKG.exports = {}
+    delete mockPKG.types
+    mockPKG.typings = './lib/typings.d.ts'
+
+    const result = buildDts()
+
+    expect(result?.file).toBe('./lib/typings.d.ts')
+  })
+
+  it('should include external dependencies', () => {
+    const result = buildDts()
+
+    expect(result?.external).toContain('react')
+    expect(result?.external).toContain('react/jsx-runtime')
+  })
+
+  it('should handle types path without slash', () => {
+    mockPKG.exports = { types: 'index.d.ts' }
+
+    const result = buildDts()
+
+    expect(result?.output.dir).toBe('.')
+    expect(result?.output.entryFileNames).toBe('index.d.ts')
+  })
+})

package/src/rolldown/createBuildPipeline.test.ts

@@ -0,0 +1,230 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockPKG } = vi.hoisted(() => ({
+  mockPKG: {
+    type: 'commonjs',
+    name: '@test/pkg',
+    main: 'lib/index.cjs',
+    module: 'lib/index.js',
+    exports: { import: './lib/index.js', require: './lib/index.cjs' },
+  } as Record<string, any>,
+}))
+
+vi.mock('../config/index.js', () => ({
+  PKG: mockPKG,
+  CONFIG: {},
+  PLATFORMS: ['browser', 'node', 'web', 'native'],
+}))
+
+describe('createBuildPipeline', () => {
+  const defaultPKG = { ...mockPKG }
+
+  beforeEach(() => {
+    Object.assign(mockPKG, defaultPKG)
+    // Remove any extra keys added by specific tests
+    for (const key of Object.keys(mockPKG)) {
+      if (!(key in defaultPKG)) delete mockPKG[key]
+    }
+  })
+
+  describe('with CJS package', () => {
+    let createBuildPipeline: () => any[]
+
+    beforeEach(async () => {
+      vi.resetModules()
+      mockPKG.type = 'commonjs'
+      const mod = await import('./createBuildPipeline.js')
+      createBuildPipeline = mod.default
+    })
+
+    it('should create builds from package.json fields', () => {
+      const builds = createBuildPipeline()
+
+      expect(builds.length).toBeGreaterThan(0)
+      const mainBuild = builds.find((b) => b.file === 'lib/index.cjs')
+      expect(mainBuild).toBeDefined()
+      expect(mainBuild.format).toBe('cjs')
+    })
+
+    it('should include module build as ES format', () => {
+      const builds = createBuildPipeline()
+
+      const moduleBuild = builds.find((b) => b.file === 'lib/index.js')
+      expect(moduleBuild).toBeDefined()
+      expect(moduleBuild.format).toBe('es')
+    })
+  })
+
+  describe('with ES module package', () => {
+    let createBuildPipeline: () => any[]
+
+    beforeEach(async () => {
+      vi.resetModules()
+      mockPKG.type = 'module'
+      const mod = await import('./createBuildPipeline.js')
+      createBuildPipeline = mod.default
+    })
+
+    it('should use ES format for main build', () => {
+      const builds = createBuildPipeline()
+
+      const mainBuild = builds.find((b) => b.file === 'lib/index.cjs')
+      if (mainBuild) {
+        expect(mainBuild.format).toBe('es')
+      }
+    })
+
+    it('should include exports options', () => {
+      const builds = createBuildPipeline()
+
+      expect(builds.length).toBeGreaterThan(0)
+    })
+  })
+
+  describe('with string exports', () => {
+    let createBuildPipeline: () => any[]
+
+    beforeEach(async () => {
+      vi.resetModules()
+      mockPKG.type = 'module'
+      mockPKG.exports = './lib/index.js'
+      const mod = await import('./createBuildPipeline.js')
+      createBuildPipeline = mod.default
+    })
+
+    it('should handle string exports', () => {
+      const builds = createBuildPipeline()
+
+      const exportBuild = builds.find((b) => b.file === './lib/index.js')
+      expect(exportBuild).toBeDefined()
+      expect(exportBuild.format).toBe('es')
+    })
+  })
+
+  describe('with object exports having node field', () => {
+    let createBuildPipeline: () => any[]
+
+    beforeEach(async () => {
+      vi.resetModules()
+      mockPKG.type = 'module'
+      mockPKG.exports = {
+        import: './lib/index.js',
+        require: './lib/index.cjs',
+        node: './lib/node.js',
+        default: './lib/default.js',
+      }
+      const mod = await import('./createBuildPipeline.js')
+      createBuildPipeline = mod.default
+    })
+
+    it('should include node and default exports', () => {
+      const builds = createBuildPipeline()
+
+      const nodeBuild = builds.find((b) => b.file === './lib/node.js')
+      expect(nodeBuild).toBeDefined()
+      expect(nodeBuild.platform).toBe('node')
+
+      const defaultBuild = builds.find((b) => b.file === './lib/default.js')
+      expect(defaultBuild).toBeDefined()
+    })
+  })
+
+  describe('with no exports', () => {
+    let createBuildPipeline: () => any[]
+
+    beforeEach(async () => {
+      vi.resetModules()
+      mockPKG.type = 'module'
+      delete mockPKG.exports
+      const mod = await import('./createBuildPipeline.js')
+      createBuildPipeline = mod.default
+    })
+
+    it('should return builds based on main/module fields only', () => {
+      const builds = createBuildPipeline()
+
+      expect(builds.length).toBeGreaterThan(0)
+    })
+  })
+
+  describe('with react-native build', () => {
+    let createBuildPipeline: () => any[]
+
+    beforeEach(async () => {
+      vi.resetModules()
+      mockPKG.type = 'commonjs'
+      mockPKG['react-native'] = 'lib/native.js'
+      mockPKG.module = 'lib/index.js'
+      const mod = await import('./createBuildPipeline.js')
+      createBuildPipeline = mod.default
+    })
+
+    it('should add native build when path differs from module', () => {
+      const builds = createBuildPipeline()
+
+      const nativeBuild = builds.find((b) => b.platform === 'native')
+      expect(nativeBuild).toBeDefined()
+      expect(nativeBuild.file).toBe('lib/native.js')
+    })
+  })
+
+  describe('with browser-specific builds', () => {
+    let createBuildPipeline: () => any[]
+
+    beforeEach(async () => {
+      vi.resetModules()
+      mockPKG.type = 'commonjs'
+      mockPKG.main = 'lib/index.cjs'
+      mockPKG.module = 'lib/index.js'
+      // browser remaps module output — hasDifferentBrowserBuild('main') returns true
+      // because source ('lib/index.js') !== PKG['main'] ('lib/index.cjs')
+      mockPKG.browser = {
+        './lib/index.js': './lib/browser.js',
+      }
+      const mod = await import('./createBuildPipeline.js')
+      createBuildPipeline = mod.default
+    })
+
+    it('should create browser-specific build variants', () => {
+      const builds = createBuildPipeline()
+
+      const browserBuild = builds.find((b) => b.platform === 'browser')
+      expect(browserBuild).toBeDefined()
+      expect(browserBuild.file).toBe('lib/browser.js')
+    })
+
+    it('should set node platform for main build when browser variant exists', () => {
+      const builds = createBuildPipeline()
+
+      const nodeBuild = builds.find(
+        (b) => b.file === 'lib/index.cjs' && b.platform === 'node',
+      )
+      expect(nodeBuild).toBeDefined()
+    })
+  })
+
+  describe('with UMD builds', () => {
+    let createBuildPipeline: () => any[]
+
+    beforeEach(async () => {
+      vi.resetModules()
+      mockPKG.type = 'commonjs'
+      mockPKG['umd:main'] = 'lib/index.umd.js'
+      mockPKG.unpkg = 'lib/index.umd.min.js'
+      const mod = await import('./createBuildPipeline.js')
+      createBuildPipeline = mod.default
+    })
+
+    it('should include UMD build variants', () => {
+      const builds = createBuildPipeline()
+
+      const umdDev = builds.find((b) => b.file === 'lib/index.umd.js')
+      expect(umdDev).toBeDefined()
+      expect(umdDev.format).toBe('umd')
+
+      const umdProd = builds.find((b) => b.file === 'lib/index.umd.min.js')
+      expect(umdProd).toBeDefined()
+      expect(umdProd.env).toBe('production')
+    })
+  })
+})

package/src/scripts/build.test.ts

@@ -0,0 +1,246 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const {
+  mockRolldown,
+  mockBundleWrite,
+  mockBundleClose,
+  mockReaddirSync,
+  mockCreateBuildPipeline,
+  mockRolldownConfig,
+  mockBuildDts,
+} = vi.hoisted(() => ({
+  mockRolldown: vi.fn(),
+  mockBundleWrite: vi.fn(),
+  mockBundleClose: vi.fn(),
+  mockReaddirSync: vi.fn(),
+  mockCreateBuildPipeline: vi.fn(),
+  mockRolldownConfig: vi.fn(),
+  mockBuildDts: 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(),
+}))
+
+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,
+  buildDts: mockBuildDts,
+}))
+
+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,
+      },
+    }))
+    mockBuildDts.mockReturnValue(null)
+  })
+
+  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 buildDts returns config', async () => {
+    mockBuildDts.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,
+      },
+    }))
+    mockBuildDts.mockReturnValue({
+      file: './lib/index.d.ts',
+      input: 'src/index.ts',
+      output: {
+        dir: 'lib',
+        entryFileNames: 'index.d.ts',
+        format: 'es',
+      },
+    })
+
+    await runBuild()
+
+    // main build + DTS build = 2 rolldown calls
+    expect(mockRolldown).toHaveBeenCalledTimes(2)
+  })
+
+  it('should handle DTS chunk consolidation', async () => {
+    mockBuildDts.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, unlinkSync, renameSync } = 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,
+      },
+    }))
+    mockBuildDts.mockReturnValue({
+      file: './lib/index.d.ts',
+      input: 'src/index.ts',
+      output: {
+        dir: 'lib',
+        entryFileNames: 'index.d.ts',
+        format: 'es',
+      },
+    })
+    mockReaddirSync.mockReturnValue(['chunk-abc.d.ts'])
+    vi.mocked(statSync).mockImplementation((p: any) => {
+      if (String(p).includes('chunk'))
+        return { size: 1000 } as ReturnType<typeof statSync>
+      return { size: 10 } as ReturnType<typeof statSync>
+    })
+
+    await runBuild()
+
+    expect(unlinkSync).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,
+      },
+    }))
+    mockBuildDts.mockReturnValue(null)
+
+    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,
+      },
+    }))
+    mockBuildDts.mockReturnValue(null)
+
+    await runBuild()
+
+    expect(mockRolldownConfig).toHaveBeenCalledTimes(2)
+    expect(mockRolldown).toHaveBeenCalledTimes(2)
+  })
+})

package/tsconfig.json

@@ -11,5 +11,5 @@
     }
   },
   "include": ["typings", "src"],
-  "exclude": ["node_modules", "__stories__", "lib"]
+  "exclude": ["node_modules", "__stories__", "lib", "**/*.test.ts"]
 }

package/vitest.config.ts

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