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

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/vitest.config.ts

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