@vitus-labs/tools-rolldown 1.15.5 → 2.0.0

package/src/rolldown/createBuildPipeline.ts

@@ -1,218 +0,0 @@
-import { CONFIG, PKG } from '../config/index.js'
-
-const isESModuleOnly = PKG.type === 'module'
-
-const hasDifferentNativeBuild = () => {
-  return PKG['react-native'] !== PKG.module
-}
-
-const hasDifferentBrowserBuild = (type: string) => {
-  if (!PKG.browser) return false
-
-  return Object.entries(PKG.browser as Record<string, string>).some(
-    ([key, value]) => {
-      const source = key.substring(2)
-      const output = value.substring(2)
-
-      return source !== PKG[type] && source !== output
-    },
-  )
-}
-
-const BUILD_VARIANTS: Record<
-  string,
-  { format: string; env: string; platform?: string }
-> = {
-  main: {
-    format: isESModuleOnly ? 'es' : 'cjs',
-    env: 'development',
-    platform: 'universal',
-  },
-  module: {
-    format: 'es',
-    env: 'development',
-    platform: 'universal',
-  },
-  'react-native': {
-    format: 'es',
-    env: 'development',
-    platform: 'native',
-  },
-  'umd:main': { format: 'umd', env: 'development' },
-  unpkg: { format: 'umd', env: 'production' },
-}
-
-/** Check if an exports object uses subpath keys (e.g. ".", "./devtools") */
-const isSubpathExports = (obj: Record<string, any>): boolean =>
-  Object.keys(obj).some((k) => k === '.' || k.startsWith('./'))
-
-/** Resolve the source input file for a subpath export using convention:
- *  "." → "src/index.ts", "./devtools" → "src/devtools" */
-const resolveSubpathInput = (exportPath: string): string => {
-  if (exportPath === '.') return `${CONFIG.sourceDir}/index.ts`
-  const subpath = exportPath.slice(2) // strip "./"
-  return `${CONFIG.sourceDir}/${subpath}`
-}
-
-/** Extract build variants from a single export's condition object */
-const parseConditions = (
-  conditions: Record<string, any>,
-  input?: string,
-): Record<string, any>[] => {
-  const result: Record<string, any>[] = []
-  const base = input ? { input } : {}
-
-  if (conditions.import) {
-    result.push({ file: conditions.import, ...BUILD_VARIANTS.module, ...base })
-  }
-  if (conditions.require) {
-    result.push({
-      file: conditions.require,
-      format: 'cjs',
-      env: 'development',
-      platform: 'universal',
-      ...base,
-    })
-  }
-  if (conditions.node) {
-    result.push({
-      file: conditions.node,
-      ...BUILD_VARIANTS.module,
-      platform: 'node',
-      ...base,
-    })
-  }
-  if (conditions.default && !conditions.import) {
-    result.push({ file: conditions.default, ...BUILD_VARIANTS.module, ...base })
-  }
-
-  return result
-}
-
-/** Parse subpath exports object into build variants */
-const parseSubpathExports = (
-  exportsOptions: Record<string, any>,
-): Record<string, any>[] => {
-  const result: Record<string, any>[] = []
-
-  for (const [exportPath, exportConfig] of Object.entries(exportsOptions)) {
-    if (typeof exportConfig === 'string') {
-      // Skip passthrough exports (e.g. "./package.json": "./package.json")
-      if (!exportConfig.endsWith('.js') && !exportConfig.endsWith('.mjs')) {
-        continue
-      }
-      result.push({
-        file: exportConfig,
-        input: resolveSubpathInput(exportPath),
-        ...BUILD_VARIANTS.module,
-      })
-    } else if (typeof exportConfig === 'object' && exportConfig !== null) {
-      // Skip exports without build conditions (import/require/node/default)
-      if (
-        !exportConfig.import &&
-        !exportConfig.require &&
-        !exportConfig.node &&
-        !exportConfig.default
-      ) {
-        continue
-      }
-      const input = resolveSubpathInput(exportPath)
-      result.push(...parseConditions(exportConfig, input))
-    }
-  }
-
-  return result
-}
-
-const getExportsOptions = () => {
-  const exportsOptions = PKG.exports
-
-  if (!exportsOptions) return []
-
-  if (typeof exportsOptions === 'string') {
-    return [{ file: PKG.exports, ...BUILD_VARIANTS.module }]
-  }
-
-  if (typeof exportsOptions === 'object') {
-    return isSubpathExports(exportsOptions)
-      ? parseSubpathExports(exportsOptions)
-      : parseConditions(exportsOptions)
-  }
-
-  return []
-}
-
-const createBasicBuildVariants = () => {
-  let result: Record<string, any>[] = []
-
-  if (isESModuleOnly) result = [...getExportsOptions()]
-
-  Object.keys(BUILD_VARIANTS).forEach((key) => {
-    const PKGOutDir = PKG[key]
-
-    if (PKGOutDir) {
-      const hasBrowserBuild = hasDifferentBrowserBuild(key)
-      const hasNativeBuild = hasDifferentNativeBuild()
-
-      // create a helper function for adding a build variant to an array
-      const add = (props = {}) => {
-        result.push({ ...BUILD_VARIANTS[key], file: PKGOutDir, ...props })
-      }
-
-      if (key === 'react-native') {
-        // add a separate RN build only if output path differs from module path
-        if (hasNativeBuild) {
-          add()
-        }
-      } else if (hasBrowserBuild) {
-        // if has a different browser build, set default platform to node
-        // as there is going to be created a separate browser build as well
-        add({ platform: 'node' })
-      } else {
-        add()
-      }
-    }
-  })
-
-  return result
-}
-
-const createBrowserBuildVariants = () => {
-  const result: Record<string, any>[] = []
-  if (!PKG.browser) return result
-
-  Object.entries(PKG.browser as Record<string, string>).forEach(
-    ([key, value]) => {
-      const source = key.substring(2) // strip './' from the beginning of path
-      const output = value.substring(2) // strip './' from the beginning of path
-
-      Object.keys(BUILD_VARIANTS).forEach((item) => {
-        if (PKG[item] === source && source !== output) {
-          result.push({
-            ...BUILD_VARIANTS[item],
-            file: output,
-            platform: 'browser',
-          })
-        }
-      })
-    },
-  )
-
-  return result
-}
-
-const createBuildPipeline = () => {
-  if (Array.isArray(CONFIG.entries) && CONFIG.entries.length > 0) {
-    return CONFIG.entries.map((entry: Record<string, string | undefined>) => ({
-      format: entry.format || 'es',
-      env: entry.env || 'development',
-      platform: entry.platform || 'universal',
-      file: entry.file,
-      input: entry.input,
-    }))
-  }
-
-  return [...createBasicBuildVariants(), ...createBrowserBuildVariants()]
-}
-
-export default createBuildPipeline

package/src/rolldown/index.ts

@@ -1,4 +0,0 @@
-import config, { buildAllDts, buildDts } from './config.js'
-import createBuildPipeline from './createBuildPipeline.js'
-
-export { buildAllDts, buildDts, config, createBuildPipeline }

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)
-  })
-})