create-bubbles 0.1.23 → 0.1.24

package/template-vp-monorepo-react-nestjs/packages/i18n/cli/src/sync.ts

@@ -0,0 +1,274 @@
+import { randomUUID } from 'node:crypto'
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises'
+import { basename, dirname, isAbsolute, join } from 'node:path'
+
+import type { SyncFileReport } from './report.ts'
+
+export interface SyncCatalogOptions {
+  project: string
+  locale: string
+  path: string
+  keys: Iterable<string>
+  clean?: boolean
+  dryRun?: boolean
+  allowEmpty?: boolean
+}
+
+export interface SyncProjectOptions {
+  project: string
+  catalogs: Readonly<Record<string, string>>
+  keys: Iterable<string>
+  clean?: boolean
+  dryRun?: boolean
+  allowEmpty?: boolean
+}
+
+export class CatalogValidationError extends Error {
+  override name = 'CatalogValidationError'
+}
+
+export class EmptyScanCleanError extends Error {
+  override name = 'EmptyScanCleanError'
+}
+
+interface CatalogFormat {
+  bom: boolean
+  eol: '\n' | '\r\n'
+  indent: string | number | undefined
+  trailingEol: boolean
+}
+
+interface CatalogState {
+  exists: boolean
+  messages: Record<string, string>
+  format: CatalogFormat
+}
+
+interface CatalogPlan {
+  path: string
+  content: string
+  shouldWrite: boolean
+  report: SyncFileReport
+}
+
+const defaultFormat: CatalogFormat = {
+  bom: false,
+  eol: '\n',
+  indent: 2,
+  trailingEol: true,
+}
+
+export async function syncCatalog(options: SyncCatalogOptions): Promise<SyncFileReport> {
+  const keys = normalizeKeys(options.keys)
+  const plan = await planCatalog(options, keys)
+
+  if (!(options.dryRun ?? false) && plan.shouldWrite) {
+    await writeAtomic(plan.path, plan.content)
+  }
+
+  return plan.report
+}
+
+export async function syncProject(options: SyncProjectOptions): Promise<SyncFileReport[]> {
+  const keys = normalizeKeys(options.keys)
+  const plans = await Promise.all(
+    Object.entries(options.catalogs).map(([locale, path]) =>
+      planCatalog(
+        {
+          ...options,
+          locale,
+          path,
+        },
+        keys,
+      ),
+    ),
+  )
+
+  if (!(options.dryRun ?? false)) {
+    await Promise.all(
+      plans.map(async (plan) => {
+        if (plan.shouldWrite) {
+          await writeAtomic(plan.path, plan.content)
+        }
+      }),
+    )
+  }
+
+  return plans.map((plan) => plan.report)
+}
+
+async function planCatalog(
+  options: SyncCatalogOptions,
+  keys: ReadonlySet<string>,
+): Promise<CatalogPlan> {
+  if (!isAbsolute(options.path)) {
+    throw new TypeError(`Catalog path must be absolute: "${options.path}"`)
+  }
+
+  const state = await readCatalog(options.path)
+  const existingKeys = Object.keys(state.messages)
+  const added = sortKeys(
+    [...keys].filter((key) => !Object.prototype.hasOwnProperty.call(state.messages, key)),
+  )
+  const stale = sortKeys(existingKeys.filter((key) => !keys.has(key)))
+  const clean = options.clean ?? false
+
+  if (clean && keys.size === 0 && existingKeys.length > 0 && !(options.allowEmpty ?? false)) {
+    throw new EmptyScanCleanError(
+      `Refusing to clean non-empty catalog "${options.path}" because the source scan found no keys. ` +
+        'Pass allowEmpty: true only when clearing the catalog is intentional.',
+    )
+  }
+
+  const deleted = clean ? stale : []
+  const unused = clean ? [] : stale
+  const retainedEntries = Object.entries(state.messages).filter(([key]) => !deleted.includes(key))
+  const nextMessages = Object.fromEntries([
+    ...retainedEntries,
+    ...added.map((key): [string, string] => [key, key]),
+  ])
+  const shouldWrite = !state.exists || added.length > 0 || deleted.length > 0
+
+  return {
+    path: options.path,
+    content: serializeCatalog(nextMessages, state.format),
+    shouldWrite,
+    report: {
+      project: options.project,
+      path: options.path,
+      locale: options.locale,
+      added,
+      unused,
+      deleted,
+      unchangedCount: existingKeys.filter((key) => keys.has(key)).length,
+    },
+  }
+}
+
+async function readCatalog(path: string): Promise<CatalogState> {
+  let source: string
+
+  try {
+    source = await readFile(path, 'utf8')
+  } catch (error) {
+    if (isNodeError(error) && error.code === 'ENOENT') {
+      return {
+        exists: false,
+        messages: {},
+        format: defaultFormat,
+      }
+    }
+
+    throw error
+  }
+
+  const format = detectFormat(source)
+  const json = format.bom ? source.slice(1) : source
+  let parsed: unknown
+
+  try {
+    parsed = JSON.parse(json)
+  } catch (error) {
+    throw new CatalogValidationError(
+      `Catalog "${path}" contains invalid JSON: ${errorMessage(error)}`,
+    )
+  }
+
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new CatalogValidationError(
+      `Catalog "${path}" must contain a flat JSON object with string values.`,
+    )
+  }
+
+  const entries = Object.entries(parsed as Record<string, unknown>)
+
+  for (const [key, value] of entries) {
+    if (typeof value !== 'string') {
+      throw new CatalogValidationError(
+        `Catalog "${path}" must contain only string values; key "${key}" is ${valueType(value)}.`,
+      )
+    }
+  }
+
+  return {
+    exists: true,
+    messages: Object.fromEntries(entries) as Record<string, string>,
+    format,
+  }
+}
+
+function detectFormat(source: string): CatalogFormat {
+  const bom = source.startsWith('\uFEFF')
+  const json = bom ? source.slice(1) : source
+  const eol = json.includes('\r\n') ? '\r\n' : '\n'
+  const indentation = json.match(/\r?\n([\t ]+)"/u)?.[1]
+  const hasLineBreak = json.includes('\n')
+
+  return {
+    bom,
+    eol,
+    indent: indentation?.slice(0, 10) ?? (hasLineBreak ? 2 : undefined),
+    trailingEol: json.endsWith('\n'),
+  }
+}
+
+function serializeCatalog(messages: Record<string, string>, format: CatalogFormat): string {
+  const serialized = JSON.stringify(messages, undefined, format.indent) ?? '{}'
+  const withEol = format.eol === '\n' ? serialized : serialized.split('\n').join(format.eol)
+  const withTrailingEol = format.trailingEol ? `${withEol}${format.eol}` : withEol
+
+  return format.bom ? `\uFEFF${withTrailingEol}` : withTrailingEol
+}
+
+async function writeAtomic(path: string, content: string): Promise<void> {
+  const directory = dirname(path)
+  const temporaryPath = join(directory, `.${basename(path)}.${process.pid}.${randomUUID()}.tmp`)
+
+  await mkdir(directory, { recursive: true })
+
+  try {
+    await writeFile(temporaryPath, content, 'utf8')
+    await rename(temporaryPath, path)
+  } catch (error) {
+    await unlink(temporaryPath).catch(() => undefined)
+    throw error
+  }
+}
+
+function normalizeKeys(keys: Iterable<string>): ReadonlySet<string> {
+  const normalized = new Set<string>()
+
+  for (const key of keys) {
+    if (typeof key !== 'string') {
+      throw new TypeError('Scanned message keys must be strings.')
+    }
+
+    normalized.add(key)
+  }
+
+  return normalized
+}
+
+function sortKeys(keys: string[]): string[] {
+  return keys.sort((left, right) => (left < right ? -1 : left > right ? 1 : 0))
+}
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return error instanceof Error && 'code' in error
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+function valueType(value: unknown): string {
+  if (value === null) {
+    return 'null'
+  }
+
+  if (Array.isArray(value)) {
+    return 'an array'
+  }
+
+  return `a ${typeof value}`
+}

package/template-vp-monorepo-react-nestjs/packages/i18n/cli/test/command.test.ts

@@ -0,0 +1,209 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { describe, expect, it } from 'vite-plus/test'
+
+import { CliUsageError, runCli } from '../src/command.ts'
+import { useTemporaryDirectory } from './temporary-directory.ts'
+
+describe('runCli', () => {
+  const temporaryDirectory = useTemporaryDirectory()
+
+  it('prints Chinese help', async () => {
+    const output: string[] = []
+
+    await expect(runCli(['--help'], { stdout: (message) => output.push(message) })).resolves.toBe(0)
+    expect(output.join('\n')).toContain('用法：')
+    expect(output.join('\n')).toContain('安全保护：')
+    expect(output.join('\n')).toContain('显示帮助信息')
+  })
+
+  it('discovers config, syncs catalogs and writes relative report paths', async () => {
+    const root = temporaryDirectory.path
+    await mkdir(join(root, 'src'), { recursive: true })
+    await mkdir(join(root, 'locales'), { recursive: true })
+    await writeFile(
+      join(root, 'src', 'app.ts'),
+      "tr('保存')\ntr (\n  `English`\n)\ntr('ignored-' + value)\n",
+      'utf8',
+    )
+    await writeFile(
+      join(root, 'locales', 'zh_CN.json'),
+      '{\n  "保存": "保存成功",\n  "旧文案": "旧翻译"\n}\n',
+      'utf8',
+    )
+    await writeConfig(root)
+
+    const output: string[] = []
+    const exitCode = await runCli(['sync'], {
+      cwd: root,
+      stdout: (message) => output.push(message),
+    })
+
+    expect(exitCode).toBe(0)
+    expect(JSON.parse(await readFile(join(root, 'locales', 'zh_CN.json'), 'utf8'))).toEqual({
+      保存: '保存成功',
+      旧文案: '旧翻译',
+      English: 'English',
+    })
+    expect(JSON.parse(await readFile(join(root, 'locales', 'en_US.json'), 'utf8'))).toEqual({
+      English: 'English',
+      保存: '保存',
+    })
+
+    const report = JSON.parse(await readFile(join(root, '.reports', 'i18n.json'), 'utf8'))
+    expect(report.command).toBe('sync')
+    expect(report.files).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ path: 'locales/zh_CN.json', unused: ['旧文案'] }),
+        expect.objectContaining({ path: 'locales/en_US.json' }),
+      ]),
+    )
+    expect(output.join('\n')).toContain('Project web: 1 source files, 2 keys.')
+  })
+
+  it('checks without writing and can fail on unused keys', async () => {
+    const root = temporaryDirectory.path
+    await mkdir(join(root, 'src'), { recursive: true })
+    await mkdir(join(root, 'locales'), { recursive: true })
+    await writeFile(join(root, 'src', 'app.ts'), "tr('new')\n", 'utf8')
+    await writeFile(join(root, 'locales', 'en_US.json'), '{"old":"Translated"}\n', 'utf8')
+    await writeFile(join(root, 'locales', 'zh_CN.json'), '{}\n', 'utf8')
+    await writeConfig(root)
+
+    const before = await readFile(join(root, 'locales', 'en_US.json'), 'utf8')
+    const exitCode = await runCli(['check', '--fail-on-stale'], {
+      cwd: join(root, 'src'),
+      stdout: () => undefined,
+    })
+
+    expect(exitCode).toBe(1)
+    expect(await readFile(join(root, 'locales', 'en_US.json'), 'utf8')).toBe(before)
+    const report = JSON.parse(await readFile(join(root, '.reports', 'i18n.json'), 'utf8'))
+    expect(report).toMatchObject({ command: 'check', dryRun: true })
+  })
+
+  it('refuses clean when include patterns match no source files', async () => {
+    const root = temporaryDirectory.path
+    await mkdir(join(root, 'locales'), { recursive: true })
+    await writeFile(join(root, 'locales', 'en_US.json'), '{"old":"Translation"}\n', 'utf8')
+    await writeFile(join(root, 'locales', 'zh_CN.json'), '{}\n', 'utf8')
+    await writeConfig(root)
+
+    await expect(
+      runCli(['sync', '--clean', '--allow-empty'], { cwd: root, stdout: () => undefined }),
+    ).rejects.toBeInstanceOf(CliUsageError)
+    expect(JSON.parse(await readFile(join(root, 'locales', 'en_US.json'), 'utf8'))).toEqual({
+      old: 'Translation',
+    })
+  })
+
+  it('validates catalog ownership across unselected projects', async () => {
+    const root = temporaryDirectory.path
+    await mkdir(join(root, 'src'), { recursive: true })
+    await mkdir(join(root, 'locales'), { recursive: true })
+    await writeFile(join(root, 'src', 'app.ts'), "tr('new')\n", 'utf8')
+    const sharedCatalog = join(root, 'locales', 'shared.json')
+    await writeFile(sharedCatalog, '{"old":"Translation"}\n', 'utf8')
+    await writeFile(
+      join(root, 'i18n.config.mjs'),
+      `export default {
+  projects: {
+    web: { include: ['src/**/*.ts'], catalogs: { en_US: 'locales/shared.json' } },
+    admin: { include: ['src/**/*.ts'], catalogs: { zh_CN: 'locales/shared.json' } }
+  }
+}\n`,
+      'utf8',
+    )
+
+    await expect(
+      runCli(['sync', '--project', 'web'], { cwd: root, stdout: () => undefined }),
+    ).rejects.toThrow('configured by both web/en_US and admin/zh_CN')
+    expect(await readFile(sharedCatalog, 'utf8')).toBe('{"old":"Translation"}\n')
+  })
+
+  it('refuses report paths that overwrite config or existing non-report files', async () => {
+    const root = temporaryDirectory.path
+    await mkdir(join(root, 'src'), { recursive: true })
+    await writeFile(join(root, 'src', 'app.ts'), "tr('new')\n", 'utf8')
+    const configPath = join(root, 'i18n.config.mjs')
+    const configSource = `export default {
+  projects: {
+    web: { include: ['src/**/*.ts'], catalogs: { en_US: 'locales/en_US.json' } }
+  },
+  report: 'i18n.config.mjs'
+}\n`
+    await writeFile(configPath, configSource, 'utf8')
+
+    await expect(runCli(['sync'], { cwd: root, stdout: () => undefined })).rejects.toThrow(
+      'Report path must not overwrite the config file',
+    )
+    expect(await readFile(configPath, 'utf8')).toBe(configSource)
+
+    const existingPath = join(root, 'notes.json')
+    const existingSource = '{"notes":"keep me"}\n'
+    await writeFile(existingPath, existingSource, 'utf8')
+    const secondConfigPath = join(root, 'other.config.mjs')
+    await writeFile(secondConfigPath, configSource.replace('i18n.config.mjs', 'notes.json'), 'utf8')
+
+    await expect(
+      runCli(['sync', '--config', secondConfigPath], {
+        cwd: root,
+        stdout: () => undefined,
+      }),
+    ).rejects.toThrow('Refusing to overwrite existing non-report file')
+    expect(await readFile(existingPath, 'utf8')).toBe(existingSource)
+  })
+
+  it('treats prototype names as unknown projects', async () => {
+    const root = temporaryDirectory.path
+    await writeConfig(root)
+
+    await expect(
+      runCli(['sync', '--project', 'toString'], { cwd: root, stdout: () => undefined }),
+    ).rejects.toThrow('Unknown project "toString"')
+  })
+
+  it('allows stale keys by default in check and fails with --fail-on-stale', async () => {
+    const root = temporaryDirectory.path
+    await mkdir(join(root, 'src'), { recursive: true })
+    await mkdir(join(root, 'locales'), { recursive: true })
+    await writeFile(join(root, 'src', 'app.ts'), "tr('used')\n", 'utf8')
+    await writeFile(join(root, 'locales', 'en_US.json'), '{"used":"Used","old":"Old"}\n', 'utf8')
+    await writeFile(join(root, 'locales', 'zh_CN.json'), '{"used":"使用","old":"旧文案"}\n', 'utf8')
+    await writeConfig(root)
+
+    await expect(runCli(['check'], { cwd: root, stdout: () => undefined })).resolves.toBe(0)
+    await expect(
+      runCli(['check', '--fail-on-stale'], { cwd: root, stdout: () => undefined }),
+    ).resolves.toBe(1)
+  })
+
+  it('rejects unsafe option combinations', async () => {
+    await expect(
+      runCli(['sync', '--allow-empty'], {
+        cwd: temporaryDirectory.path,
+        stdout: () => undefined,
+      }),
+    ).rejects.toThrow('--allow-empty requires --clean')
+  })
+})
+
+async function writeConfig(root: string): Promise<void> {
+  await writeFile(
+    join(root, 'i18n.config.mjs'),
+    `export default {
+  projects: {
+    web: {
+      include: ['src/**/*.ts'],
+      catalogs: {
+        zh_CN: 'locales/zh_CN.json',
+        en_US: 'locales/en_US.json'
+      }
+    }
+  },
+  report: '.reports/i18n.json'
+}\n`,
+    'utf8',
+  )
+}

package/template-vp-monorepo-react-nestjs/packages/i18n/cli/test/config.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vite-plus/test'
+
+import { defineConfig } from '../src/config.ts'
+
+describe('defineConfig', () => {
+  it('returns the same config object', () => {
+    const config = {
+      callNames: ['tr'],
+      projects: {
+        web: {
+          include: ['apps/web/src/**/*.ts'],
+          catalogs: { en_US: 'apps/web/src/locales/en_US.json' },
+        },
+      },
+    }
+
+    expect(defineConfig(config)).toBe(config)
+  })
+})

package/template-vp-monorepo-react-nestjs/packages/i18n/cli/test/load-config.test.ts

@@ -0,0 +1,194 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { dirname, join, resolve } from 'node:path'
+
+import { describe, expect, it } from 'vite-plus/test'
+
+import {
+  CONFIG_FILE_NAMES,
+  ConfigLoadError,
+  ConfigNotFoundError,
+  ConfigValidationError,
+  loadConfig,
+  validateConfig,
+} from '../src/load-config.ts'
+import { useTemporaryDirectory } from './temporary-directory.ts'
+
+const validConfig = {
+  callNames: ['tr'],
+  projects: {
+    web: {
+      include: ['src/**/*.{ts,tsx}'],
+      exclude: [],
+      catalogs: {
+        zh_CN: 'locales/zh_CN.json',
+      },
+    },
+  },
+  report: '.bubbles-i18n/report.json',
+}
+
+describe('loadConfig', () => {
+  const temporaryDirectory = useTemporaryDirectory()
+
+  it.each([
+    ['i18n.config.ts', createEsmConfigSource()],
+    ['i18n.config.mts', createEsmConfigSource()],
+    ['i18n.config.js', createCommonJsConfigSource()],
+    ['i18n.config.mjs', createEsmConfigSource()],
+    ['i18n.config.cts', createCommonJsConfigSource()],
+    ['i18n.config.cjs', createCommonJsConfigSource()],
+  ])('discovers %s while walking upward', async (fileName, source) => {
+    const configPath = join(temporaryDirectory.path, fileName)
+    const cwd = join(temporaryDirectory.path, 'apps', 'web', 'src')
+    await mkdir(cwd, { recursive: true })
+    await writeFile(configPath, source, 'utf8')
+
+    const loaded = await loadConfig({ cwd })
+
+    expect(loaded).toEqual({
+      configPath,
+      rootDir: temporaryDirectory.path,
+      config: validConfig,
+    })
+  })
+
+  it('uses the first candidate when multiple config formats exist in one directory', async () => {
+    const tsPath = join(temporaryDirectory.path, CONFIG_FILE_NAMES[0])
+    await writeFile(tsPath, createEsmConfigSource(), 'utf8')
+    await writeFile(
+      join(temporaryDirectory.path, 'i18n.config.mjs'),
+      'export default { projects: {} }',
+      'utf8',
+    )
+
+    const loaded = await loadConfig({ cwd: temporaryDirectory.path })
+
+    expect(loaded.configPath).toBe(tsPath)
+  })
+
+  it('resolves an explicit config path relative to cwd', async () => {
+    const cwd = join(temporaryDirectory.path, 'workspace')
+    const configPath = join(cwd, 'config', 'custom-i18n.ts')
+    await mkdir(dirname(configPath), { recursive: true })
+    await writeFile(configPath, createEsmConfigSource(), 'utf8')
+
+    const loaded = await loadConfig({ cwd, configPath: './config/custom-i18n.ts' })
+
+    expect(loaded.configPath).toBe(configPath)
+    expect(loaded.rootDir).toBe(dirname(configPath))
+    expect(loaded.config).toEqual(validConfig)
+  })
+
+  it('reports the searched directory and supported names when discovery fails', async () => {
+    await expect(loadConfig({ cwd: temporaryDirectory.path })).rejects.toThrowError(
+      ConfigNotFoundError,
+    )
+    await expect(loadConfig({ cwd: temporaryDirectory.path })).rejects.toThrow(
+      `Could not find an i18n config from "${resolve(temporaryDirectory.path)}" upward`,
+    )
+  })
+
+  it('reports the resolved path when an explicit config is missing', async () => {
+    const expectedPath = join(temporaryDirectory.path, 'missing.ts')
+
+    await expect(
+      loadConfig({ cwd: temporaryDirectory.path, configPath: './missing.ts' }),
+    ).rejects.toThrow(`Could not find the explicit i18n config at "${expectedPath}"`)
+  })
+
+  it('requires a default export', async () => {
+    const configPath = join(temporaryDirectory.path, 'i18n.config.mjs')
+    await writeFile(configPath, 'export const config = {}', 'utf8')
+
+    await expect(loadConfig({ cwd: temporaryDirectory.path })).rejects.toThrowError(
+      ConfigValidationError,
+    )
+    await expect(loadConfig({ cwd: temporaryDirectory.path })).rejects.toThrow(
+      'the module must have a default export',
+    )
+  })
+
+  it('wraps module evaluation failures with the config path and preserves the cause', async () => {
+    const configPath = join(temporaryDirectory.path, 'i18n.config.mjs')
+    await writeFile(configPath, 'throw new Error("module failed")', 'utf8')
+
+    const error = await loadConfig({ cwd: temporaryDirectory.path }).catch(
+      (caught: unknown) => caught,
+    )
+
+    expect(error).toBeInstanceOf(ConfigLoadError)
+    expect(error).toMatchObject({
+      message: `Failed to load i18n config at "${configPath}"`,
+      cause: expect.objectContaining({ message: 'module failed' }),
+    })
+  })
+})
+
+describe('validateConfig', () => {
+  it('accepts a complete config and returns the original object', () => {
+    expect(validateConfig(validConfig)).toBe(validConfig)
+  })
+
+  it.each([
+    [undefined, 'the default export must be an object'],
+    [{}, 'projects must be a non-empty object'],
+    [{ projects: {} }, 'projects must be a non-empty object'],
+    [{ projects: { web: null } }, 'projects["web"] must be an object'],
+    [
+      { projects: { web: { include: [], catalogs: { en_US: 'en.json' } } } },
+      'projects["web"].include must be a non-empty array of strings',
+    ],
+    [
+      { projects: { web: { include: [''], catalogs: { en_US: 'en.json' } } } },
+      'projects["web"].include[0] must be a non-empty string',
+    ],
+    [
+      {
+        projects: {
+          web: { include: ['src/**/*.ts'], exclude: 'dist', catalogs: { en_US: 'en.json' } },
+        },
+      },
+      'projects["web"].exclude must be an array of non-empty strings',
+    ],
+    [
+      { projects: { web: { include: ['src/**/*.ts'], catalogs: {} } } },
+      'projects["web"].catalogs must be a non-empty object',
+    ],
+    [
+      { projects: { web: { include: ['src/**/*.ts'], catalogs: { en_US: '' } } } },
+      'projects["web"].catalogs["en_US"] must be a non-empty string',
+    ],
+    [
+      {
+        callNames: [],
+        projects: { web: { include: ['src/**/*.ts'], catalogs: { en_US: 'en.json' } } },
+      },
+      'callNames must be a non-empty array of strings',
+    ],
+    [
+      {
+        callNames: [' '],
+        projects: { web: { include: ['src/**/*.ts'], catalogs: { en_US: 'en.json' } } },
+      },
+      'callNames[0] must be a non-empty string',
+    ],
+    [
+      {
+        projects: { web: { include: ['src/**/*.ts'], catalogs: { en_US: 'en.json' } } },
+        report: '',
+      },
+      'report must be a non-empty string',
+    ],
+  ])('rejects invalid config %#', (config, message) => {
+    expect(() => validateConfig(config, 'test.config.ts')).toThrowError(ConfigValidationError)
+    expect(() => validateConfig(config, 'test.config.ts')).toThrow(message)
+  })
+})
+
+function createEsmConfigSource(): string {
+  return `export default ${JSON.stringify(validConfig)}`
+}
+
+function createCommonJsConfigSource(): string {
+  return `module.exports = ${JSON.stringify(validConfig)}`
+}