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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitus-labs/tools-rollup",
-  "version": "1.5.2-alpha.4+45b8634",
+  "version": "1.6.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -30,38 +30,39 @@
   },
   "scripts": {
     "prepublish": "bun run build",
-    "build": "tsc"
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@microsoft/api-extractor": "^7.55.2",
+    "@microsoft/api-extractor": "^7.56.3",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.3.0",
-    "@types/node": "^25.0.3",
-    "@vitus-labs/tools-core": "1.5.2-alpha.4+45b8634",
+    "@types/node": "^25.2.1",
+    "@vitus-labs/tools-core": "1.6.0",
     "chalk": "^5.6.2",
-    "find-up": "^7.0.0",
-    "lodash-es": "^4.17.22",
+    "find-up": "^8.0.0",
+    "lodash-es": "^4.17.23",
     "rimraf": "^6.1.2",
-    "rollup": "^4.55.1",
+    "rollup": "^4.57.1",
     "rollup-plugin-api-extractor": "^0.2.5",
     "rollup-plugin-filesize": "^10.0.0",
     "rollup-plugin-tsconfig-paths": "^1.5.2",
     "rollup-plugin-typescript-paths": "^1.5.0",
     "rollup-plugin-typescript2": "^0.36.0",
-    "rollup-plugin-visualizer": "^5.14.0",
+    "rollup-plugin-visualizer": "^6.0.5",
     "ts-patch": "^3.3.0",
     "tslib": "^2.8.1",
     "typescript-transform-paths": "^3.5.6"
   },
   "devDependencies": {
     "@types/lodash-es": "^4.17.12",
-    "@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/rollup/config.test.ts

@@ -0,0 +1,308 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const {
+  mockNodeResolve,
+  mockReplace,
+  mockTerser,
+  mockTypescript,
+  mockApiExtractor,
+  mockFilesize,
+  mockVisualizer,
+  mockConfig,
+  mockPKG,
+} = vi.hoisted(() => ({
+  mockNodeResolve: vi.fn(() => ({ name: 'mock-resolve' })),
+  mockReplace: vi.fn(() => ({ name: 'mock-replace' })),
+  mockTerser: vi.fn(() => ({ name: 'mock-terser' })),
+  mockTypescript: vi.fn(() => ({ name: 'mock-typescript' })),
+  mockApiExtractor: vi.fn(() => ({ name: 'mock-api-extractor' })),
+  mockFilesize: vi.fn(() => ({ name: 'mock-filesize' })),
+  mockVisualizer: vi.fn(() => ({ name: 'mock-visualizer' })),
+  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,
+    include: ['src'],
+    exclude: ['node_modules/**'],
+    external: ['react/jsx-runtime'],
+    globals: { react: 'React' },
+  } as Record<string, any>,
+  mockPKG: {
+    name: '@test/pkg',
+    version: '1.0.0',
+    bundleName: 'testPkg',
+    externalDependencies: ['react'],
+  } as Record<string, any>,
+}))
+
+vi.mock('@rollup/plugin-node-resolve', () => ({
+  nodeResolve: mockNodeResolve,
+}))
+vi.mock('@rollup/plugin-replace', () => ({ default: mockReplace }))
+vi.mock('@rollup/plugin-terser', () => ({ default: mockTerser }))
+vi.mock('rollup-plugin-typescript2', () => ({ default: mockTypescript }))
+vi.mock('rollup-plugin-api-extractor', () => ({
+  apiExtractor: mockApiExtractor,
+}))
+vi.mock('rollup-plugin-filesize', () => ({ default: mockFilesize }))
+vi.mock('rollup-plugin-visualizer', () => ({ visualizer: mockVisualizer }))
+
+vi.mock('node:module', () => ({
+  createRequire: vi.fn(() => vi.fn(() => ({}))),
+}))
+
+vi.mock('@vitus-labs/tools-core', () => ({
+  swapGlobals: (globals: Record<string, string>) =>
+    Object.fromEntries(Object.entries(globals).map(([k, v]) => [v, k])),
+}))
+
+vi.mock('../config/index.js', () => ({
+  CONFIG: mockConfig,
+  PKG: mockPKG,
+  PLATFORMS: ['browser', 'node', 'web', 'native'],
+}))
+
+import rollupConfig from './config.js'
+
+const defaultConfig = { ...mockConfig }
+const defaultPKG = { ...mockPKG }
+
+describe('rollupConfig', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    Object.assign(mockConfig, defaultConfig)
+    Object.assign(mockPKG, defaultPKG)
+  })
+
+  it('should create a valid ES module build config', () => {
+    const config = rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.input).toBe('src')
+    expect(config.output.file).toBe('lib/index.js')
+    expect(config.output.format).toBe('es')
+    expect(config.output.sourcemap).toBe(true)
+    expect(config.external).toContain('react')
+    expect(config.external).toContain('react/jsx-runtime')
+  })
+
+  it('should set named exports for CJS format', () => {
+    const config = rollupConfig({
+      file: 'lib/index.cjs',
+      format: 'cjs',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.output.exports).toBe('named')
+  })
+
+  it('should set name for UMD format', () => {
+    const config = rollupConfig({
+      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 not set name for ES format', () => {
+    const config = rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.output.name).toBeUndefined()
+    expect(config.output.exports).toBeUndefined()
+  })
+
+  it('should add platform-specific extensions for known platforms', () => {
+    rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'browser',
+    })
+
+    expect(mockNodeResolve).toHaveBeenCalledWith(
+      expect.objectContaining({
+        browser: true,
+        extensions: expect.arrayContaining(['.browser.ts']),
+      }),
+    )
+  })
+
+  it('should not add platform extensions for unknown platforms', () => {
+    rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(mockNodeResolve).toHaveBeenCalledWith(
+      expect.objectContaining({
+        browser: false,
+        extensions: expect.not.arrayContaining(['.universal.ts']),
+      }),
+    )
+  })
+
+  it('should add typescript plugin when enabled', () => {
+    rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(mockTypescript).toHaveBeenCalled()
+  })
+
+  it('should add apiExtractor when typesFilePath is provided', () => {
+    rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+      typesFilePath: './lib/index.d.ts',
+    })
+
+    expect(mockApiExtractor).toHaveBeenCalled()
+  })
+
+  it('should add replace plugin when replaceGlobals is true', () => {
+    rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'node',
+    })
+
+    expect(mockReplace).toHaveBeenCalledWith(
+      expect.objectContaining({
+        preventAssignment: true,
+        values: expect.objectContaining({
+          __VERSION__: '"1.0.0"',
+          __NODE__: 'true',
+        }),
+      }),
+    )
+  })
+
+  it('should add process.env.NODE_ENV for production', () => {
+    rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'production',
+      platform: 'universal',
+    })
+
+    expect(mockReplace).toHaveBeenCalledWith(
+      expect.objectContaining({
+        values: expect.objectContaining({
+          'process.env.NODE_ENV': '"production"',
+        }),
+      }),
+    )
+  })
+
+  it('should add terser for production builds', () => {
+    rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'production',
+      platform: 'universal',
+    })
+
+    expect(mockTerser).toHaveBeenCalled()
+  })
+
+  it('should not add terser for development builds', () => {
+    rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(mockTerser).not.toHaveBeenCalled()
+  })
+
+  it('should skip replace plugin when replaceGlobals is false', () => {
+    mockConfig.replaceGlobals = false
+
+    rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(mockReplace).not.toHaveBeenCalled()
+  })
+
+  it('should skip typescript plugin when disabled', () => {
+    mockConfig.typescript = false
+
+    rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(mockTypescript).not.toHaveBeenCalled()
+  })
+
+  it('should skip visualizer when visualise is false', () => {
+    mockConfig.visualise = false
+
+    rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(mockVisualizer).not.toHaveBeenCalled()
+  })
+
+  it('should skip filesize when disabled', () => {
+    mockConfig.filesize = false
+
+    rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(mockFilesize).not.toHaveBeenCalled()
+  })
+
+  it('should swap globals in output', () => {
+    const config = rollupConfig({
+      file: 'lib/index.js',
+      format: 'es',
+      env: 'development',
+      platform: 'universal',
+    })
+
+    expect(config.output.globals).toEqual({ React: 'react' })
+  })
+})

package/src/rollup/createBuildPipeline.test.ts

@@ -0,0 +1,214 @@
+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',
+      types: './lib/index.d.ts',
+    },
+  } as Record<string, any>,
+}))
+
+vi.mock('../config/index.js', () => ({
+  PKG: mockPKG,
+  CONFIG: {},
+  PLATFORMS: ['browser', 'node', 'web', 'native'],
+}))
+
+describe('createBuildPipeline', () => {
+  const defaultPKG = { ...mockPKG, exports: { ...mockPKG.exports } }
+
+  beforeEach(() => {
+    Object.assign(mockPKG, defaultPKG)
+    mockPKG.exports = { ...defaultPKG.exports }
+    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')
+    })
+
+    it('should add typesFilePath to the first build', () => {
+      const builds = createBuildPipeline()
+
+      expect(builds[0].typesFilePath).toBe('./lib/index.d.ts')
+    })
+  })
+
+  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 for ES module packages', () => {
+      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 and default fields', () => {
+    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',
+        types: './lib/index.d.ts',
+      }
+      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'
+      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()
+    })
+  })
+})

package/src/scripts/build.test.ts

@@ -0,0 +1,107 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const {
+  mockRollup,
+  mockBundleWrite,
+  mockCreateBuildPipeline,
+  mockRollupConfig,
+} = vi.hoisted(() => ({
+  mockRollup: vi.fn(),
+  mockBundleWrite: vi.fn(),
+  mockCreateBuildPipeline: vi.fn(),
+  mockRollupConfig: vi.fn(),
+}))
+
+vi.mock('rollup', () => ({ rollup: mockRollup }))
+vi.mock('rimraf', () => ({ rimraf: { sync: vi.fn() } }))
+
+vi.mock('../config/index.js', () => ({
+  CONFIG: { outputDir: 'lib' },
+}))
+
+vi.mock('../rollup/index.js', () => ({
+  createBuildPipeline: mockCreateBuildPipeline,
+  config: mockRollupConfig,
+}))
+
+describe('build', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    mockBundleWrite.mockResolvedValue(undefined)
+    mockRollup.mockResolvedValue({ write: mockBundleWrite })
+
+    mockCreateBuildPipeline.mockReturnValue([
+      {
+        file: 'lib/index.js',
+        format: 'es',
+        env: 'development',
+        platform: 'universal',
+      },
+    ])
+    mockRollupConfig.mockImplementation((item: any) => ({
+      input: 'src',
+      output: { file: item.file, format: item.format },
+    }))
+  })
+
+  it('should execute build pipeline successfully', async () => {
+    vi.resetModules()
+    const { runBuild } = await import('./build.js')
+
+    await runBuild()
+
+    expect(mockRollup).toHaveBeenCalled()
+    expect(mockBundleWrite).toHaveBeenCalled()
+  })
+
+  it('should handle build failure gracefully', async () => {
+    const buildError = new Error('rollup failed')
+    mockRollup.mockRejectedValue(buildError)
+
+    vi.resetModules()
+    const { runBuild } = await import('./build.js')
+    vi.clearAllMocks()
+
+    mockRollup.mockRejectedValue(buildError)
+    mockRollupConfig.mockImplementation((item: any) => ({
+      input: 'src',
+      output: { file: item.file, format: item.format },
+    }))
+
+    await expect(runBuild()).rejects.toThrow('rollup 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()
+
+    // Re-setup after clear
+    mockRollup.mockResolvedValue({ write: mockBundleWrite })
+    mockBundleWrite.mockResolvedValue(undefined)
+    mockRollupConfig.mockImplementation((item: any) => ({
+      input: 'src',
+      output: { file: item.file, format: item.format },
+    }))
+
+    await runBuild()
+
+    expect(mockRollupConfig).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'])