create-bubbles 0.1.23 → 0.1.25

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

@@ -0,0 +1,228 @@
+import { stat } from 'node:fs/promises'
+import { dirname, isAbsolute, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+import type { I18nConfig } from './config.ts'
+
+export const CONFIG_FILE_NAMES = [
+  'i18n.config.ts',
+  'i18n.config.mts',
+  'i18n.config.js',
+  'i18n.config.mjs',
+  'i18n.config.cts',
+  'i18n.config.cjs',
+] as const
+
+export interface LoadConfigOptions {
+  readonly cwd?: string
+  readonly configPath?: string
+}
+
+export interface LoadedI18nConfig {
+  readonly configPath: string
+  readonly rootDir: string
+  readonly config: I18nConfig
+}
+
+export class ConfigNotFoundError extends Error {
+  override readonly name = 'ConfigNotFoundError'
+}
+
+export class ConfigLoadError extends Error {
+  override readonly name = 'ConfigLoadError'
+  readonly cause: unknown
+
+  constructor(message: string, cause?: unknown) {
+    super(message)
+    this.cause = cause
+  }
+}
+
+export class ConfigValidationError extends Error {
+  override readonly name = 'ConfigValidationError'
+}
+
+export async function loadConfig(options: LoadConfigOptions = {}): Promise<LoadedI18nConfig> {
+  const cwd = resolve(options.cwd ?? process.cwd())
+  const configPath =
+    options.configPath === undefined
+      ? await findConfigPath(cwd)
+      : await resolveExplicitConfigPath(options.configPath, cwd)
+
+  let importedConfig: unknown
+
+  try {
+    const module = (await import(pathToFileURL(configPath).href)) as Record<string, unknown>
+
+    if (!Object.prototype.hasOwnProperty.call(module, 'default')) {
+      throw new ConfigValidationError(
+        `Invalid i18n config at "${configPath}": the module must have a default export`,
+      )
+    }
+
+    importedConfig = module.default
+  } catch (error) {
+    if (error instanceof ConfigValidationError) {
+      throw error
+    }
+
+    throw new ConfigLoadError(`Failed to load i18n config at "${configPath}"`, error)
+  }
+
+  return {
+    configPath,
+    rootDir: dirname(configPath),
+    config: validateConfig(importedConfig, configPath),
+  }
+}
+
+export function validateConfig(value: unknown, configPath = '<config>'): I18nConfig {
+  const prefix = `Invalid i18n config at "${configPath}"`
+
+  if (!isRecord(value)) {
+    throw new ConfigValidationError(`${prefix}: the default export must be an object`)
+  }
+
+  const projects = value.projects
+  if (!isRecord(projects) || Object.keys(projects).length === 0) {
+    throw new ConfigValidationError(`${prefix}: projects must be a non-empty object`)
+  }
+
+  for (const [projectName, project] of Object.entries(projects)) {
+    if (projectName.trim() === '') {
+      throw new ConfigValidationError(`${prefix}: project names must be non-empty strings`)
+    }
+
+    const projectPath = `projects[${JSON.stringify(projectName)}]`
+    if (!isRecord(project)) {
+      throw new ConfigValidationError(`${prefix}: ${projectPath} must be an object`)
+    }
+
+    validateStringArray(project.include, `${projectPath}.include`, prefix, { nonEmpty: true })
+
+    if (project.exclude !== undefined) {
+      validateStringArray(project.exclude, `${projectPath}.exclude`, prefix)
+    }
+
+    const catalogs = project.catalogs
+    if (!isRecord(catalogs) || Object.keys(catalogs).length === 0) {
+      throw new ConfigValidationError(
+        `${prefix}: ${projectPath}.catalogs must be a non-empty object`,
+      )
+    }
+
+    for (const [locale, catalogPath] of Object.entries(catalogs)) {
+      if (locale.trim() === '') {
+        throw new ConfigValidationError(
+          `${prefix}: ${projectPath}.catalogs locale names must be non-empty strings`,
+        )
+      }
+
+      if (typeof catalogPath !== 'string' || catalogPath.trim() === '') {
+        throw new ConfigValidationError(
+          `${prefix}: ${projectPath}.catalogs[${JSON.stringify(locale)}] must be a non-empty string`,
+        )
+      }
+    }
+  }
+
+  if (value.callNames !== undefined) {
+    validateStringArray(value.callNames, 'callNames', prefix, { nonEmpty: true })
+  }
+
+  if (
+    value.report !== undefined &&
+    (typeof value.report !== 'string' || value.report.trim() === '')
+  ) {
+    throw new ConfigValidationError(`${prefix}: report must be a non-empty string`)
+  }
+
+  return value as unknown as I18nConfig
+}
+
+async function findConfigPath(cwd: string): Promise<string> {
+  let directory = cwd
+
+  while (true) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+      const candidate = resolve(directory, fileName)
+      if (await isFile(candidate)) {
+        return candidate
+      }
+    }
+
+    const parent = dirname(directory)
+    if (parent === directory) {
+      break
+    }
+    directory = parent
+  }
+
+  throw new ConfigNotFoundError(
+    `Could not find an i18n config from "${cwd}" upward. Expected one of: ${CONFIG_FILE_NAMES.join(', ')}`,
+  )
+}
+
+async function resolveExplicitConfigPath(configPath: string, cwd: string): Promise<string> {
+  if (configPath.trim() === '') {
+    throw new ConfigNotFoundError('The explicit i18n config path must be a non-empty string')
+  }
+
+  const resolvedPath = isAbsolute(configPath) ? resolve(configPath) : resolve(cwd, configPath)
+  if (!(await isFile(resolvedPath))) {
+    throw new ConfigNotFoundError(
+      `Could not find the explicit i18n config at "${resolvedPath}" (resolved from "${cwd}")`,
+    )
+  }
+
+  return resolvedPath
+}
+
+function validateStringArray(
+  value: unknown,
+  path: string,
+  prefix: string,
+  options: { readonly nonEmpty?: boolean } = {},
+): asserts value is string[] {
+  if (!Array.isArray(value)) {
+    throw new ConfigValidationError(`${prefix}: ${path} must be an array of non-empty strings`)
+  }
+
+  if (options.nonEmpty === true && value.length === 0) {
+    throw new ConfigValidationError(`${prefix}: ${path} must be a non-empty array of strings`)
+  }
+
+  for (const [index, item] of value.entries()) {
+    if (typeof item !== 'string' || item.trim() === '') {
+      throw new ConfigValidationError(`${prefix}: ${path}[${index}] must be a non-empty string`)
+    }
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return false
+  }
+
+  const prototype = Object.getPrototypeOf(value) as unknown
+  return prototype === Object.prototype || prototype === null
+}
+
+async function isFile(path: string): Promise<boolean> {
+  try {
+    return (await stat(path)).isFile()
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return false
+    }
+    throw error
+  }
+}
+
+function isMissingPathError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    'code' in error &&
+    (error.code === 'ENOENT' || error.code === 'ENOTDIR')
+  )
+}

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

@@ -0,0 +1,57 @@
+import { randomUUID } from 'node:crypto'
+import { mkdir, rename, unlink, writeFile } from 'node:fs/promises'
+import { basename, dirname, join } from 'node:path'
+
+export interface SyncFileReport {
+  project: string
+  path: string
+  locale: string
+  added: string[]
+  unused: string[]
+  deleted: string[]
+  unchangedCount: number
+}
+
+export interface SyncReport {
+  command: 'sync' | 'check'
+  clean: boolean
+  dryRun: boolean
+  files: SyncFileReport[]
+}
+
+export interface CreateSyncReportOptions {
+  command?: SyncReport['command']
+  clean?: boolean
+  dryRun?: boolean
+  files?: readonly SyncFileReport[]
+}
+
+export function createSyncReport(options: CreateSyncReportOptions = {}): SyncReport {
+  return {
+    command: options.command ?? 'sync',
+    clean: options.clean ?? false,
+    dryRun: options.dryRun ?? false,
+    files: (options.files ?? []).map((file) => ({
+      ...file,
+      added: [...file.added],
+      unused: [...file.unused],
+      deleted: [...file.deleted],
+    })),
+  }
+}
+
+export async function writeSyncReport(report: SyncReport, path: string): Promise<void> {
+  const content = `${JSON.stringify(report, undefined, 2)}\n`
+  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
+  }
+}

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

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vite-plus/test'
+
+import { scanSource } from './scanner.ts'
+
+describe('scanSource', () => {
+  it('extracts Chinese text and all three static quote styles', () => {
+    const source = ["tr('保存')", 'tr("Open")', 'tr(`用户`)'].join('\n')
+
+    expect(scanSource(source)).toEqual([
+      { key: '保存', index: 0, line: 1, column: 1 },
+      { key: 'Open', index: 9, line: 2, column: 1 },
+      { key: '用户', index: 20, line: 3, column: 1 },
+    ])
+  })
+
+  it('allows whitespace and newlines around the first argument', () => {
+    const source = ['const message = tr', '  (', "    '你好 {name}',", '    { name },', '  )'].join(
+      '\n',
+    )
+
+    expect(scanSource(source)).toEqual([{ key: '你好 {name}', index: 16, line: 1, column: 17 }])
+  })
+
+  it('decodes common escapes without evaluating source code', () => {
+    const source = String.raw`tr('It\'s\n中\t\x41\u6587\u{1F600}')`
+
+    expect(scanSource(source).map(({ key }) => key)).toEqual(["It's\n中\tA文😀"])
+  })
+
+  it('allows escaped interpolation syntax in a static template', () => {
+    const source = 'tr(`price: \\${value}`)'
+
+    expect(scanSource(source).map(({ key }) => key)).toEqual(['price: ${value}'])
+  })
+
+  it('ignores dynamic arguments, concatenation, and template interpolation', () => {
+    const source = [
+      'tr(key)',
+      'tr(getKey())',
+      "tr('a' + value)",
+      'tr(`hello ${name}`)',
+      "tr('kept')",
+    ].join('\n')
+
+    expect(scanSource(source).map(({ key }) => key)).toEqual(['kept'])
+  })
+
+  it('requires an identifier boundary around the call name', () => {
+    const source = [
+      "notr('prefix')",
+      "trailingtr('suffix')",
+      "tr2('number')",
+      "_tr('underscore')",
+      "obj.tr('method')",
+      "tr('direct')",
+    ].join('\n')
+
+    expect(scanSource(source).map(({ key }) => key)).toEqual(['method', 'direct'])
+  })
+
+  it('supports custom call names', () => {
+    const source = ["t('short')", "$t('dollar')", "tr('default')"].join('\n')
+
+    expect(scanSource(source, { callNames: ['t', '$t'] }).map(({ key }) => key)).toEqual([
+      'short',
+      'dollar',
+    ])
+  })
+
+  it('returns every occurrence and leaves deduplication to the caller', () => {
+    const source = "tr('same')\ntr('same')"
+
+    expect(scanSource(source).map(({ key }) => key)).toEqual(['same', 'same'])
+  })
+
+  it('rejects a static string followed by an unexpected token', () => {
+    const source = ["tr('plus' + value)", "tr('semicolon'; value)"].join('\n')
+
+    expect(scanSource(source)).toEqual([])
+  })
+})

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

@@ -0,0 +1,290 @@
+export interface MessageOccurrence {
+  key: string
+  index: number
+  line: number
+  column: number
+}
+
+export interface ScanOptions {
+  callNames?: readonly string[]
+}
+
+interface ParsedString {
+  value: string
+  endIndex: number
+}
+
+interface ParsedEscape {
+  value: string
+  nextIndex: number
+}
+
+const identifierContinuePattern = /[\p{ID_Continue}_$]/u
+const whitespacePattern = /\s/u
+const hexPattern = /^[\dA-Fa-f]+$/
+
+export function scanSource(source: string, options: ScanOptions = {}): MessageOccurrence[] {
+  const callNames = normalizeCallNames(options.callNames)
+  const occurrences: MessageOccurrence[] = []
+
+  if (callNames.length === 0) {
+    return occurrences
+  }
+
+  const lineStarts = collectLineStarts(source)
+
+  for (let index = 0; index < source.length; index += 1) {
+    for (const callName of callNames) {
+      if (!source.startsWith(callName, index)) {
+        continue
+      }
+
+      if (!hasIdentifierBoundaries(source, index, callName)) {
+        continue
+      }
+
+      let cursor = skipWhitespace(source, index + callName.length)
+      if (source[cursor] !== '(') {
+        continue
+      }
+
+      cursor = skipWhitespace(source, cursor + 1)
+      const quote = source[cursor]
+      if (quote !== "'" && quote !== '"' && quote !== '`') {
+        continue
+      }
+
+      const parsed = parseString(source, cursor, quote)
+      if (!parsed) {
+        continue
+      }
+
+      const nextTokenIndex = skipWhitespace(source, parsed.endIndex)
+      const nextToken = source[nextTokenIndex]
+      if (nextToken !== ',' && nextToken !== ')') {
+        continue
+      }
+
+      const position = locatePosition(lineStarts, index)
+      occurrences.push({
+        key: parsed.value,
+        index,
+        line: position.line,
+        column: position.column,
+      })
+
+      index += callName.length - 1
+      break
+    }
+  }
+
+  return occurrences
+}
+
+function normalizeCallNames(callNames: readonly string[] | undefined): string[] {
+  const names = callNames ?? ['tr']
+  return [...new Set(names.filter((name) => name.length > 0))].sort(
+    (left, right) => right.length - left.length,
+  )
+}
+
+function hasIdentifierBoundaries(source: string, index: number, callName: string): boolean {
+  const firstCharacter = callName[0]
+  const lastCharacter = callName[callName.length - 1]
+
+  if (isIdentifierContinue(firstCharacter) && isIdentifierContinue(source[index - 1])) {
+    return false
+  }
+
+  return !(
+    isIdentifierContinue(lastCharacter) && isIdentifierContinue(source[index + callName.length])
+  )
+}
+
+function isIdentifierContinue(character: string | undefined): boolean {
+  return (
+    character !== undefined &&
+    (identifierContinuePattern.test(character) ||
+      character === '\u{200C}' ||
+      character === '\u{200D}')
+  )
+}
+
+function skipWhitespace(source: string, startIndex: number): number {
+  let index = startIndex
+  while (index < source.length && whitespacePattern.test(source[index] ?? '')) {
+    index += 1
+  }
+  return index
+}
+
+function parseString(
+  source: string,
+  startIndex: number,
+  quote: "'" | '"' | '`',
+): ParsedString | undefined {
+  let value = ''
+
+  for (let index = startIndex + 1; index < source.length; ) {
+    const character = source[index]
+
+    if (character === quote) {
+      return { value, endIndex: index + 1 }
+    }
+
+    if (character === '\\') {
+      const escape = parseEscape(source, index)
+      if (!escape) {
+        return undefined
+      }
+      value += escape.value
+      index = escape.nextIndex
+      continue
+    }
+
+    if (quote === '`' && character === '$' && source[index + 1] === '{') {
+      return undefined
+    }
+
+    if (quote !== '`' && (character === '\n' || character === '\r')) {
+      return undefined
+    }
+
+    value += character
+    index += 1
+  }
+
+  return undefined
+}
+
+function parseEscape(source: string, slashIndex: number): ParsedEscape | undefined {
+  const escaped = source[slashIndex + 1]
+  if (escaped === undefined) {
+    return undefined
+  }
+
+  const simpleEscapes: Readonly<Record<string, string>> = {
+    "'": "'",
+    '"': '"',
+    '`': '`',
+    '\\': '\\',
+    $: '$',
+    b: '\b',
+    f: '\f',
+    n: '\n',
+    r: '\r',
+    t: '\t',
+    v: '\v',
+    0: '\0',
+  }
+
+  if (escaped in simpleEscapes) {
+    return {
+      value: simpleEscapes[escaped] ?? '',
+      nextIndex: slashIndex + 2,
+    }
+  }
+
+  if (escaped === '\n') {
+    return { value: '', nextIndex: slashIndex + 2 }
+  }
+
+  if (escaped === '\r') {
+    const nextIndex = source[slashIndex + 2] === '\n' ? slashIndex + 3 : slashIndex + 2
+    return { value: '', nextIndex }
+  }
+
+  if (escaped === 'x') {
+    return parseFixedHexEscape(source, slashIndex, 2, 2)
+  }
+
+  if (escaped === 'u') {
+    if (source[slashIndex + 2] === '{') {
+      return parseCodePointEscape(source, slashIndex)
+    }
+    return parseFixedHexEscape(source, slashIndex, 2, 4)
+  }
+
+  return { value: escaped, nextIndex: slashIndex + 2 }
+}
+
+function parseFixedHexEscape(
+  source: string,
+  slashIndex: number,
+  prefixLength: number,
+  digitCount: number,
+): ParsedEscape | undefined {
+  const digitsStart = slashIndex + prefixLength
+  const digits = source.slice(digitsStart, digitsStart + digitCount)
+  if (digits.length !== digitCount || !hexPattern.test(digits)) {
+    return undefined
+  }
+
+  return {
+    value: String.fromCodePoint(Number.parseInt(digits, 16)),
+    nextIndex: digitsStart + digitCount,
+  }
+}
+
+function parseCodePointEscape(source: string, slashIndex: number): ParsedEscape | undefined {
+  const digitsStart = slashIndex + 3
+  const closingBraceIndex = source.indexOf('}', digitsStart)
+  if (closingBraceIndex === -1) {
+    return undefined
+  }
+
+  const digits = source.slice(digitsStart, closingBraceIndex)
+  if (digits.length === 0 || digits.length > 6 || !hexPattern.test(digits)) {
+    return undefined
+  }
+
+  const codePoint = Number.parseInt(digits, 16)
+  if (codePoint > 0x10_ff_ff) {
+    return undefined
+  }
+
+  return {
+    value: String.fromCodePoint(codePoint),
+    nextIndex: closingBraceIndex + 1,
+  }
+}
+
+function collectLineStarts(source: string): number[] {
+  const starts = [0]
+
+  for (let index = 0; index < source.length; index += 1) {
+    if (source[index] === '\r') {
+      if (source[index + 1] === '\n') {
+        index += 1
+      }
+      starts.push(index + 1)
+    } else if (source[index] === '\n') {
+      starts.push(index + 1)
+    }
+  }
+
+  return starts
+}
+
+function locatePosition(
+  lineStarts: readonly number[],
+  index: number,
+): { line: number; column: number } {
+  let low = 0
+  let high = lineStarts.length - 1
+
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2)
+    const lineStart = lineStarts[middle] ?? 0
+
+    if (lineStart <= index) {
+      low = middle + 1
+    } else {
+      high = middle - 1
+    }
+  }
+
+  const lineIndex = Math.max(0, high)
+  const lineStart = lineStarts[lineIndex] ?? 0
+  return { line: lineIndex + 1, column: index - lineStart + 1 }
+}