@scoutello/i18n-magic 0.64.0 → 0.66.0

package/src/commands/check-missing.ts

@@ -1,162 +1,108 @@
 import type { Configuration } from "../lib/types.js"
 import {
-  getMissingKeys,
-  findExistingTranslations,
+  getKeysWithNamespaces,
+  getPureKey,
   loadLocalesFile,
-  writeLocalesFile,
-  translateKey,
 } from "../lib/utils.js"
 
-export const checkMissing = async (config: Configuration) => {
-  const {
-    loadPath,
-    savePath,
-    defaultLocale,
-    namespaces,
-    locales,
-    context,
-    openai,
-    model,
-    disableTranslationDuringScan,
-  } = config
-
-  const newKeys = await getMissingKeys(config)
+export interface MissingTranslationsReport {
+  missing: Record<string, Record<string, string[]>>
+  totalExpected: number
+  totalMissing: number
+}
 
-  if (newKeys.length === 0) {
-    console.log("✅ No missing translations found.")
-    return
+export class MissingTranslationsError extends Error {
+  constructor(public report: MissingTranslationsReport) {
+    super(`Found ${report.totalMissing} missing translation(s).`)
+    this.name = "MissingTranslationsError"
   }
+}
 
-  console.log(`\n🔍 Found ${newKeys.length} missing key(s) in default locale (${defaultLocale}):`)
-  
-  // Group keys by namespace for clearer output
-  const keysByNamespace: Record<string, string[]> = {}
-  for (const key of newKeys) {
-    for (const ns of key.namespaces) {
-      if (!keysByNamespace[ns]) {
-        keysByNamespace[ns] = []
-      }
-      keysByNamespace[ns].push(key.key)
-    }
-  }
-  
-  for (const [namespace, keys] of Object.entries(keysByNamespace)) {
-    console.log(`\n   📦 ${namespace}: ${keys.length} missing key(s)`)
-    for (const key of keys) {
-      console.log(`      - ${key}`)
+export const collectMissingTranslations = async (
+  config: Configuration,
+): Promise<MissingTranslationsReport> => {
+  const keysWithNamespaces = await getKeysWithNamespaces({
+    globPatterns: config.globPatterns,
+    defaultNamespace: config.defaultNamespace,
+  })
+  const expectedByNamespace = Object.fromEntries(
+    config.namespaces.map((namespace) => [namespace, new Set<string>()]),
+  ) as Record<string, Set<string>>
+
+  for (const { key, namespaces } of keysWithNamespaces) {
+    for (const namespace of namespaces) {
+      if (!expectedByNamespace[namespace]) continue
+
+      const pureKey = getPureKey(
+        key,
+        namespace,
+        namespace === config.defaultNamespace,
+      )
+      const expectedKey = pureKey || (!key.includes(":") ? key : null)
+      if (expectedKey !== null) expectedByNamespace[namespace].add(expectedKey)
     }
   }
 
-  // Try to auto-fill from other namespaces (like scan does)
-  const keysList = newKeys.map((k) => k.key)
-  const existingTranslationResults = await findExistingTranslations(
-    keysList,
-    namespaces,
-    defaultLocale,
-    loadPath,
+  const loadedFiles = await Promise.all(
+    config.locales.flatMap((locale) =>
+      config.namespaces.map(async (namespace) => ({
+        locale,
+        namespace,
+        translations: await loadLocalesFile(
+          config.loadPath,
+          locale,
+          namespace,
+          { silent: true },
+        ),
+      })),
+    ),
   )
 
-  const keysWithValues: Array<{
-    key: string
-    namespaces: string[]
-    value: string | null
-  }> = []
+  const missing: Record<string, Record<string, string[]>> = {}
+  let totalMissing = 0
 
-  const reusedKeys: string[] = []
-  const stillMissingKeys: string[] = []
+  for (const { locale, namespace, translations } of loadedFiles) {
+    const missingKeys = Array.from(expectedByNamespace[namespace]).filter(
+      (key) => !Object.hasOwn(translations, key),
+    )
+    if (missingKeys.length === 0) continue
 
-  for (const newKey of newKeys) {
-    const existingValue = existingTranslationResults[newKey.key]
-    
-    if (existingValue !== null) {
-      reusedKeys.push(newKey.key)
-      keysWithValues.push({
-        key: newKey.key,
-        namespaces: newKey.namespaces,
-        value: existingValue,
-      })
-    } else {
-      stillMissingKeys.push(newKey.key)
-      keysWithValues.push({
-        key: newKey.key,
-        namespaces: newKey.namespaces,
-        value: null,
-      })
-    }
+    missing[locale] ??= {}
+    missing[locale][namespace] = missingKeys.sort()
+    totalMissing += missingKeys.length
   }
 
-  // If we can auto-fill some keys, do it
-  if (reusedKeys.length > 0) {
-    console.log(`\n🔄 Auto-reusing ${reusedKeys.length} existing value(s) from other namespaces...`)
-    
-    const keysToWrite = keysWithValues.filter((k) => k.value !== null)
-    const newKeysObject = keysToWrite.reduce((prev, next) => {
-      prev[next.key] = next.value as string
-      return prev
-    }, {} as Record<string, string>)
-
-    const allLocales = disableTranslationDuringScan ? [defaultLocale] : locales
+  return {
+    missing,
+    totalExpected: Object.values(expectedByNamespace).reduce(
+      (total, keys) => total + keys.size,
+      0,
+    ),
+    totalMissing,
+  }
+}
 
-    // Batch translate for all non-default locales in parallel
-    const translationCache: Record<string, Record<string, string>> = {
-      [defaultLocale]: newKeysObject,
-    }
+const printMissingTranslationsReport = (report: MissingTranslationsReport) => {
+  if (report.totalMissing === 0) {
+    console.log("✅ No missing translations found.")
+    return
+  }
 
-    const nonDefaultLocales = allLocales.filter((l) => l !== defaultLocale)
-    if (nonDefaultLocales.length > 0 && !disableTranslationDuringScan) {
-      console.log(`   📝 Translating to ${nonDefaultLocales.length} other locale(s)...`)
-      await Promise.all(
-        nonDefaultLocales.map(async (locale) => {
-          const translatedValues = await translateKey({
-            inputLanguage: defaultLocale,
-            outputLanguage: locale,
-            context,
-            object: newKeysObject,
-            openai,
-            model,
-          })
-          translationCache[locale] = translatedValues
-        })
-      )
+  console.error(`❌ Found ${report.totalMissing} missing translation(s):`)
+  for (const [locale, namespaces] of Object.entries(report.missing)) {
+    for (const [namespace, keys] of Object.entries(namespaces)) {
+      console.error(`   ${locale}/${namespace}: ${keys.join(", ")}`)
     }
-
-    // Process all locale/namespace combinations in parallel
-    await Promise.all(
-      allLocales.flatMap((locale) =>
-        namespaces.map(async (namespace) => {
-          const existingKeys = await loadLocalesFile(loadPath, locale, namespace)
-
-          const relevantKeys = keysToWrite.filter((key) =>
-            key.namespaces?.includes(namespace),
-          )
-
-          if (relevantKeys.length === 0) {
-            return
-          }
-
-          const translatedValues = translationCache[locale]
-          for (const key of relevantKeys) {
-            existingKeys[key.key] = translatedValues[key.key]
-          }
-
-          await writeLocalesFile(savePath, locale, namespace, existingKeys)
-          console.log(`   ✅ Updated ${locale}/${namespace}.json with ${relevantKeys.length} key(s)`)
-        })
-      )
-    )
-
-    console.log(`\n✅ Successfully auto-filled ${reusedKeys.length} key(s) from existing translations.`)
   }
+}
 
-  // Now check if there are still missing keys that couldn't be auto-filled
-  if (stillMissingKeys.length > 0) {
-    console.error(`\n❌ Error: ${stillMissingKeys.length} translation(s) could not be auto-filled:`)
-    for (const key of stillMissingKeys) {
-      console.error(`   - ${key}`)
-    }
-    console.error(`\nPlease run 'i18n-magic scan' to provide values for these keys.`)
-    process.exit(1)
+export const checkMissing = async (config: Configuration) => {
+  const report = await collectMissingTranslations(config)
+  printMissingTranslationsReport(report)
+
+  if (report.totalMissing > 0) {
+    throw new MissingTranslationsError(report)
   }
 
-  console.log("\n✅ All translations are complete.")
+  return report
 }

package/src/commands/replace.ts

@@ -27,20 +27,88 @@ const getKeyToReplace = async (
   return { key: keyToReplace, namespaces }
 }
 
+export const replaceTranslationValue = async ({
+  config,
+  key,
+  value,
+  targetNamespaces,
+}: {
+  config: Configuration
+  key: string
+  value: string
+  targetNamespaces: string[]
+}) => {
+  const { loadPath, savePath, defaultLocale, locales, context, openai } = config
+  const stagedFiles = new Map<string, Record<string, string>>()
+  await Promise.all(
+    targetNamespaces.flatMap((namespace) =>
+      locales.map(async (locale) => {
+        const existingKeys = await loadLocalesFile(
+          loadPath,
+          locale,
+          namespace,
+        )
+        stagedFiles.set(JSON.stringify([locale, namespace]), {
+          ...existingKeys,
+        })
+      }),
+    ),
+  )
+
+  const translationCache: Record<string, string> = {
+    [defaultLocale]: value,
+  }
+  await Promise.all(
+    locales
+      .filter((locale) => locale !== defaultLocale)
+      .map(async (locale) => {
+        const translation = await translateKey({
+          context,
+          inputLanguage: defaultLocale,
+          outputLanguage: locale,
+          object: { [key]: value },
+          openai,
+          model: config.model,
+        })
+        translationCache[locale] = translation[key]
+      }),
+  )
+
+  for (const namespace of targetNamespaces) {
+    for (const locale of locales) {
+      const staged = stagedFiles.get(JSON.stringify([locale, namespace]))
+      if (!staged) {
+        throw new Error(
+          `Internal error: no staged snapshot for ${locale}/${namespace}.`,
+        )
+      }
+      staged[key] = translationCache[locale]
+    }
+  }
+
+  for (const namespace of targetNamespaces) {
+    for (const locale of locales) {
+      await writeLocalesFile(
+        savePath,
+        locale,
+        namespace,
+        stagedFiles.get(JSON.stringify([locale, namespace]))!,
+      )
+    }
+  }
+}
+
 export const replaceTranslation = async (
   config: Configuration,
   key?: string,
 ) => {
   const {
     loadPath,
-    savePath,
     defaultLocale,
     defaultNamespace,
     namespaces,
     locales,
     globPatterns,
-    context,
-    openai,
   } = config
 
   // Find all keys with their namespaces from the codebase
@@ -59,7 +127,7 @@ export const replaceTranslation = async (
     namespaces.map(async (namespace) => ({
       namespace,
       keys: await loadLocalesFile(loadPath, defaultLocale, namespace),
-    }))
+    })),
   )
 
   for (const { namespace, keys } of namespaceKeysResults) {
@@ -115,7 +183,7 @@ export const replaceTranslation = async (
     targetNamespaces.map(async (namespace) => {
       const keys = await loadLocalesFile(loadPath, defaultLocale, namespace)
       return { namespace, value: keys[keyToReplace] }
-    })
+    }),
   )
 
   for (const { namespace, value } of currentTranslations) {
@@ -127,44 +195,14 @@ export const replaceTranslation = async (
   }
 
   const newTranslation = await getTextInput("Enter the new translation: ")
+  await replaceTranslationValue({
+    config,
+    key: keyToReplace,
+    value: newTranslation,
+    targetNamespaces,
+  })
 
-  // Batch translate for all non-default locales first
-  const translationCache: Record<string, string> = {
-    [defaultLocale]: newTranslation,
-  }
-
-  const nonDefaultLocales = locales.filter((l) => l !== defaultLocale)
-  if (nonDefaultLocales.length > 0) {
-    await Promise.all(
-      nonDefaultLocales.map(async (locale) => {
-        const translation = await translateKey({
-          context,
-          inputLanguage: defaultLocale,
-          outputLanguage: locale,
-          object: {
-            [keyToReplace]: newTranslation,
-          },
-          openai,
-          model: config.model,
-        })
-        translationCache[locale] = translation[keyToReplace]
-      })
-    )
-  }
-
-  // Update the key in all relevant namespaces and locales in parallel
-  await Promise.all(
-    targetNamespaces.flatMap((namespace) =>
-      locales.map(async (locale) => {
-        const newValue = translationCache[locale]
-        const existingKeys = await loadLocalesFile(loadPath, locale, namespace)
-        existingKeys[keyToReplace] = newValue
-        await writeLocalesFile(savePath, locale, namespace, existingKeys)
-
-        console.log(
-          `Updated "${keyToReplace}" in ${locale} (${namespace}): "${newValue}"`,
-        )
-      })
-    )
+  console.log(
+    `Updated "${keyToReplace}" in ${targetNamespaces.length} namespace(s) and ${locales.length} locale(s).`,
   )
 }