i18next-cli 0.9.8 → 0.9.10

package/src/extractor/core/translation-manager.ts

@@ -1,8 +1,7 @@
 import { TranslationResult, ExtractedKey, I18nextToolkitConfig } from '../../types'
-import { readFile } from 'node:fs/promises'
 import { resolve } from 'node:path'
 import { getNestedValue, setNestedValue, getNestedKeys } from '../../utils/nested-object'
-import { getOutputPath } from '../../utils/file-utils'
+import { getOutputPath, loadTranslationFile } from '../../utils/file-utils'
 
 /**
  * Converts a glob pattern to a regular expression for matching keys
@@ -51,13 +50,15 @@ export async function getTranslations (
   const defaultNS = config.extract.defaultNS ?? 'translation'
   const keySeparator = config.extract.keySeparator ?? '.'
   const patternsToPreserve = [...(config.extract.preservePatterns || [])]
+  const mergeNamespaces = config.extract.mergeNamespaces ?? false
   for (const key of objectKeys) {
     // Convert the object key to a glob pattern to preserve all its children
     patternsToPreserve.push(`${key}.*`)
   }
   const preservePatterns = patternsToPreserve.map(globToRegex)
-  if (!config.extract.primaryLanguage) config.extract.primaryLanguage = config.locales[0] || 'en'
-  if (!config.extract.secondaryLanguages) config.extract.secondaryLanguages = config.locales.filter((l: string) => l !== config.extract.primaryLanguage)
+  config.extract.primaryLanguage ||= config.locales[0] || 'en'
+  config.extract.secondaryLanguages ||= config.locales.filter((l: string) => l !== config?.extract?.primaryLanguage)
+  const primaryLanguage = config.extract.primaryLanguage
 
   // Group keys by namespace
   const keysByNS = new Map<string, ExtractedKey[]>()
@@ -72,21 +73,16 @@ export async function getTranslations (
   const results: TranslationResult[] = []
 
   for (const locale of config.locales) {
-    for (const [ns, nsKeys] of keysByNS.entries()) {
-      const outputPath = getOutputPath(config.extract.output, locale, ns)
+    const mergedTranslations: Record<string, any> = {}
+    const mergedExisting: Record<string, any> = {}
 
+    for (const [ns, nsKeys] of keysByNS.entries()) {
+      const outputPath = getOutputPath(config.extract.output, locale, mergeNamespaces ? undefined : ns)
       const fullPath = resolve(process.cwd(), outputPath)
 
-      let oldContent = ''
-      let existingTranslations: Record<string, any> = {}
-      try {
-        oldContent = await readFile(fullPath, 'utf-8')
-        existingTranslations = JSON.parse(oldContent)
-      } catch (e) { /* File doesn't exist, which is fine */ }
-
+      const existingTranslations = await loadTranslationFile(fullPath) || {}
       const newTranslations: Record<string, any> = {}
 
-      // 1. Preserve keys from existing translations that match patterns
       const existingKeys = getNestedKeys(existingTranslations, keySeparator)
       for (const existingKey of existingKeys) {
         if (preservePatterns.some(re => re.test(existingKey))) {
@@ -95,24 +91,45 @@ export async function getTranslations (
         }
       }
 
-      // 2. Merge in newly found keys for this namespace
       const sortedKeys = (config.extract.sort === false)
         ? nsKeys
-        : nsKeys.sort((a, b) => a.key.localeCompare(b.key))
+        : [...nsKeys].sort((a, b) => a.key.localeCompare(b.key))
+
       for (const { key, defaultValue } of sortedKeys) {
         const existingValue = getNestedValue(existingTranslations, key, keySeparator)
-        const valueToSet = existingValue ?? (locale === config.extract?.primaryLanguage ? defaultValue : '')
+        const valueToSet = existingValue ?? (locale === primaryLanguage ? defaultValue : (config.extract.defaultValue ?? ''))
         setNestedValue(newTranslations, key, valueToSet, keySeparator)
       }
 
-      const indentation = config.extract.indentation ?? 2
-      const newContent = JSON.stringify(newTranslations, null, indentation)
+      if (mergeNamespaces) {
+        mergedTranslations[ns] = newTranslations
+        if (Object.keys(existingTranslations).length > 0) {
+          mergedExisting[ns] = existingTranslations
+        }
+      } else {
+        const oldContent = existingTranslations ? JSON.stringify(existingTranslations, null, config.extract.indentation ?? 2) : ''
+        const newContent = JSON.stringify(newTranslations, null, config.extract.indentation ?? 2)
+
+        results.push({
+          path: fullPath,
+          updated: newContent !== oldContent,
+          newTranslations,
+          existingTranslations,
+        })
+      }
+    }
+
+    if (mergeNamespaces) {
+      const outputPath = getOutputPath(config.extract.output, locale)
+      const fullPath = resolve(process.cwd(), outputPath)
+      const oldContent = Object.keys(mergedExisting).length > 0 ? JSON.stringify(mergedExisting, null, config.extract.indentation ?? 2) : ''
+      const newContent = JSON.stringify(mergedTranslations, null, config.extract.indentation ?? 2)
 
       results.push({
         path: fullPath,
         updated: newContent !== oldContent,
-        newTranslations,
-        existingTranslations,
+        newTranslations: mergedTranslations,
+        existingTranslations: mergedExisting,
       })
     }
   }

package/src/extractor/parsers/ast-visitors.ts

@@ -1,4 +1,4 @@
-import type { Module, Node, CallExpression, VariableDeclarator, JSXElement, ArrowFunctionExpression, ObjectExpression } from '@swc/core'
+import type { Module, Node, CallExpression, VariableDeclarator, JSXElement, ArrowFunctionExpression, ObjectExpression, Expression } from '@swc/core'
 import type { PluginContext, I18nextToolkitConfig, Logger } from '../../types'
 import { extractFromTransComponent } from './jsx-parser'
 
@@ -337,7 +337,7 @@ export class ASTVisitors {
     if (callee.type !== 'Identifier') return
 
     const scopeInfo = this.getVarFromScope(callee.value)
-    const isFunctionToParse = (this.config.extract.functions || []).includes(callee.value) || scopeInfo !== undefined
+    const isFunctionToParse = (this.config.extract.functions || ['t']).includes(callee.value) || scopeInfo !== undefined
     if (!isFunctionToParse || node.arguments.length === 0) return
 
     const firstArg = node.arguments[0].expression
@@ -359,8 +359,26 @@ export class ASTVisitors {
 
     if (keysToProcess.length === 0) return
 
-    const options = node.arguments.length > 1 ? node.arguments[1].expression : undefined
-    const defaultValue = this.getDefaultValue(node, keysToProcess[keysToProcess.length - 1])
+    let defaultValue: string | undefined
+    let options: ObjectExpression | undefined
+
+    if (node.arguments.length > 1) {
+      const arg2 = node.arguments[1].expression
+      if (arg2.type === 'ObjectExpression') {
+        options = arg2
+      } else if (arg2.type === 'StringLiteral') {
+        defaultValue = arg2.value
+      }
+    }
+    if (node.arguments.length > 2) {
+      const arg3 = node.arguments[2].expression
+      if (arg3.type === 'ObjectExpression') {
+        options = arg3
+      }
+    }
+
+    const defaultValueFromOptions = options ? this.getObjectPropValue(options, 'defaultValue') : undefined
+    const finalDefaultValue = (typeof defaultValueFromOptions === 'string' ? defaultValueFromOptions : defaultValue)
 
     // Loop through each key found (could be one or more) and process it
     for (let i = 0; i < keysToProcess.length; i++) {
@@ -391,35 +409,50 @@ export class ASTVisitors {
       // The explicit defaultValue only applies to the LAST key in the fallback array.
       // For all preceding keys, their own key is their fallback.
       const isLastKey = i === keysToProcess.length - 1
-      const dv = isLastKey ? defaultValue : key
+      const dv = isLastKey ? (finalDefaultValue || key) : key
 
       // Handle plurals, context, and returnObjects
-      let keyHandled = false
       if (options?.type === 'ObjectExpression') {
-        // Handle context
+        const contextProp = this.getObjectProperty(options, 'context')
+
+        // 1. Handle Dynamic Context (Ternary) first
+        if (contextProp?.value?.type === 'ConditionalExpression') {
+          const contextValues = this.resolvePossibleStringValues(contextProp.value)
+          const contextSeparator = this.config.extract.contextSeparator ?? '_'
+
+          if (contextValues.length > 0) {
+            contextValues.forEach(context => {
+              this.pluginContext.addKey({ key: `${finalKey}${contextSeparator}${context}`, ns, defaultValue: dv })
+            })
+            // For dynamic context, also add the base key as a fallback
+            this.pluginContext.addKey({ key: finalKey, ns, defaultValue: dv })
+            continue // This key is fully handled, move to the next in the array
+          }
+        }
+
+        // 2. Handle Static Context
         const contextValue = this.getObjectPropValue(options, 'context')
         if (typeof contextValue === 'string' && contextValue) {
           const contextSeparator = this.config.extract.contextSeparator ?? '_'
           this.pluginContext.addKey({ key: `${finalKey}${contextSeparator}${contextValue}`, ns, defaultValue: dv })
-          keyHandled = true
+          continue // This key is fully handled
         }
 
-        // Handle plurals
-        if (!keyHandled && this.getObjectPropValue(options, 'count') !== undefined) {
+        // 3. Handle Plurals
+        if (this.getObjectPropValue(options, 'count') !== undefined) {
           this.handlePluralKeys(finalKey, dv, ns)
-          keyHandled = true
+          continue // This key is fully handled
         }
 
-        // Handle returnObjects
-        if (!keyHandled && this.getObjectPropValue(options, 'returnObjects') === true) {
+        // 4. Handle returnObjects
+        if (this.getObjectPropValue(options, 'returnObjects') === true) {
           this.objectKeys.add(finalKey)
-          // We still add the base key itself
+          // Fall through to add the base key itself
         }
       }
 
-      if (!keyHandled) {
-        this.pluginContext.addKey({ key: finalKey, ns, defaultValue: dv })
-      }
+      // 5. Default case: Add the simple key
+      this.pluginContext.addKey({ key: finalKey, ns, defaultValue: dv })
     }
   }
 
@@ -455,39 +488,6 @@ export class ASTVisitors {
     }
   }
 
-  /**
-   * Extracts default value from translation function call arguments.
-   *
-   * Supports multiple patterns:
-   * - String as second argument: `t('key', 'Default')`
-   * - Object with defaultValue: `t('key', { defaultValue: 'Default' })`
-   * - Falls back to the key itself if no default found
-   *
-   * @param node - Call expression node
-   * @param fallback - Fallback value if no default found
-   * @returns Extracted default value
-   *
-   * @private
-   */
-  private getDefaultValue (node: CallExpression, fallback: string): string {
-    if (node.arguments.length <= 1) return fallback
-
-    const secondArg = node.arguments[1].expression
-
-    if (secondArg.type === 'StringLiteral') {
-      return secondArg.value || fallback
-    }
-
-    if (secondArg.type === 'ObjectExpression') {
-      const val = this.getObjectPropValue(secondArg, 'defaultValue')
-      if (typeof val === 'string') return val || fallback
-      if (typeof val === 'number' || typeof val === 'boolean') return String(val)
-      return fallback
-    }
-
-    return fallback
-  }
-
   /**
    * Processes JSX elements to extract translation keys from Trans components.
    *
@@ -532,11 +532,20 @@ export class ASTVisitors {
           extractedKey.ns = this.config.extract.defaultNS
         }
 
-        // If the component has a `count` prop, use the plural handler
-        if (extractedKey.hasCount) {
+        if (extractedKey.contextExpression) {
+          const contextValues = this.resolvePossibleStringValues(extractedKey.contextExpression)
+          const contextSeparator = this.config.extract.contextSeparator ?? '_'
+
+          if (contextValues.length > 0) {
+            for (const context of contextValues) {
+              this.pluginContext.addKey({ key: `${extractedKey.key}${contextSeparator}${context}`, ns: extractedKey.ns, defaultValue: extractedKey.defaultValue })
+            }
+            // Add the base key as well
+            this.pluginContext.addKey(extractedKey)
+          }
+        } else if (extractedKey.hasCount) {
           this.handlePluralKeys(extractedKey.key, extractedKey.defaultValue, extractedKey.ns)
         } else {
-        // Otherwise, add the key as-is
           this.pluginContext.addKey(extractedKey)
         }
       // The duplicated addKey call has been removed.
@@ -671,4 +680,65 @@ export class ASTVisitors {
 
     return null
   }
+
+  /**
+   * Resolves an expression to one or more possible string values that can be
+   * determined statically from the AST.
+   *
+   * Supports:
+   * - StringLiteral -> single value
+   * - ConditionalExpression (ternary) -> union of consequent and alternate resolved values
+   * - The identifier `undefined` -> empty array
+   *
+   * For any other expression types (identifiers, function calls, member expressions,
+   * etc.) the value cannot be determined statically and an empty array is returned.
+   *
+   * @private
+   * @param expression - The SWC AST expression node to resolve
+   * @returns An array of possible string values that the expression may produce.
+   */
+  private resolvePossibleStringValues (expression: Expression): string[] {
+    if (expression.type === 'StringLiteral') {
+      return [expression.value]
+    }
+
+    if (expression.type === 'ConditionalExpression') { // This is a ternary operator
+      const consequentValues = this.resolvePossibleStringValues(expression.consequent)
+      const alternateValues = this.resolvePossibleStringValues(expression.alternate)
+      return [...consequentValues, ...alternateValues]
+    }
+
+    if (expression.type === 'Identifier' && expression.value === 'undefined') {
+      return [] // Handle the `undefined` case
+    }
+
+    // We can't statically determine the value of other expressions (e.g., variables, function calls)
+    return []
+  }
+
+  /**
+   * Finds and returns the full property node (KeyValueProperty) for the given
+   * property name from an ObjectExpression.
+   *
+   * Matches both identifier keys (e.g., { ns: 'value' }) and string literal keys
+   * (e.g., { 'ns': 'value' }).
+   *
+   * This helper returns the full property node rather than just its primitive
+   * value so callers can inspect expression types (ConditionalExpression, etc.).
+   *
+   * @private
+   * @param object - The SWC ObjectExpression to search
+   * @param propName - The property name to locate
+   * @returns The matching KeyValueProperty node if found, otherwise undefined.
+   */
+  private getObjectProperty (object: ObjectExpression, propName: string): any {
+    return (object.properties).find(
+      (p) =>
+        p.type === 'KeyValueProperty' &&
+        (
+          (p.key?.type === 'Identifier' && p.key.value === propName) ||
+          (p.key?.type === 'StringLiteral' && p.key.value === propName)
+        )
+    )
+  }
 }

package/src/extractor/parsers/jsx-parser.ts

@@ -55,6 +55,16 @@ export function extractFromTransComponent (node: JSXElement, config: I18nextTool
   )
   const hasCount = !!countAttr
 
+  const contextAttr = node.opening.attributes?.find(
+    (attr) =>
+      attr.type === 'JSXAttribute' &&
+      attr.name.type === 'Identifier' &&
+      attr.name.value === 'context'
+  )
+  const contextExpression = (contextAttr?.type === 'JSXAttribute' && contextAttr.value?.type === 'JSXExpressionContainer')
+    ? contextAttr.value.expression
+    : undefined
+
   let key: string
   if (i18nKeyAttr?.type === 'JSXAttribute' && i18nKeyAttr.value?.type === 'StringLiteral') {
     key = i18nKeyAttr.value.value
@@ -81,7 +91,7 @@ export function extractFromTransComponent (node: JSXElement, config: I18nextTool
     defaultValue = serializeJSXChildren(node.children, config)
   }
 
-  return { key, ns, defaultValue: defaultValue || key, hasCount }
+  return { key, ns, defaultValue: defaultValue || key, hasCount, contextExpression }
 }
 
 /**

package/src/heuristic-config.ts

@@ -1,6 +1,6 @@
 import { glob } from 'glob'
 import { readdir } from 'node:fs/promises'
-import { dirname, join } from 'node:path'
+import { dirname, join, extname } from 'node:path'
 import type { I18nextToolkitConfig } from './types'
 
 // A list of common glob patterns for the primary language ('en') or ('dev') translation files.
@@ -32,10 +32,20 @@ export async function detectConfig (): Promise<Partial<I18nextToolkitConfig> | n
     if (files.length > 0) {
       const firstFile = files[0]
       const basePath = dirname(dirname(firstFile))
+      const extension = extname(firstFile)
+
+      // Infer outputFormat from the file extension
+      let outputFormat: I18nextToolkitConfig['extract']['outputFormat'] = 'json'
+      if (extension === '.ts') {
+        outputFormat = 'ts'
+      } else if (extension === '.js') {
+        // We can't know if it's ESM or CJS, so we default to a safe choice.
+        // The tool's file loaders can handle both.
+        outputFormat = 'js'
+      }
 
       try {
         const allDirs = await readdir(basePath)
-        // CORRECTED REGEX: Now accepts 'dev' in addition to standard locale codes.
         let locales = allDirs.filter(dir => /^(dev|[a-z]{2}(-[A-Z]{2})?)$/.test(dir))
 
         if (locales.length > 0) {
@@ -57,7 +67,8 @@ export async function detectConfig (): Promise<Partial<I18nextToolkitConfig> | n
                 'pages/**/*.{js,jsx,ts,tsx}',
                 'components/**/*.{js,jsx,ts,tsx}'
               ],
-              output: join(basePath, '{{language}}', '{{namespace}}.json'),
+              output: join(basePath, '{{language}}', `{{namespace}}${extension}`),
+              outputFormat,
               primaryLanguage: locales.includes('en') ? 'en' : locales[0],
             },
           }

package/src/status.ts

@@ -1,11 +1,10 @@
 import chalk from 'chalk'
 import ora from 'ora'
 import { resolve } from 'node:path'
-import { readFile } from 'node:fs/promises'
 import { findKeys } from './extractor/core/key-finder'
 import { getNestedValue } from './utils/nested-object'
 import type { I18nextToolkitConfig, ExtractedKey } from './types'
-import { getOutputPath } from './utils/file-utils'
+import { getOutputPath, loadTranslationFile } from './utils/file-utils'
 
 /**
  * Options for configuring the status report display.
@@ -56,8 +55,8 @@ interface StatusReport {
  * @throws {Error} When unable to extract keys or read translation files
  */
 export async function runStatus (config: I18nextToolkitConfig, options: StatusOptions = {}) {
-  if (!config.extract.primaryLanguage) config.extract.primaryLanguage = config.locales[0] || 'en'
-  if (!config.extract.secondaryLanguages) config.extract.secondaryLanguages = config.locales.filter((l: string) => l !== config?.extract?.primaryLanguage)
+  config.extract.primaryLanguage ||= config.locales[0] || 'en'
+  config.extract.secondaryLanguages ||= config.locales.filter((l: string) => l !== config?.extract?.primaryLanguage)
   const spinner = ora('Analyzing project localization status...\n').start()
   try {
     const report = await generateStatusReport(config)
@@ -84,9 +83,16 @@ export async function runStatus (config: I18nextToolkitConfig, options: StatusOp
  * @throws {Error} When key extraction fails or configuration is invalid
  */
 async function generateStatusReport (config: I18nextToolkitConfig): Promise<StatusReport> {
+  config.extract.primaryLanguage ||= config.locales[0] || 'en'
+  config.extract.secondaryLanguages ||= config.locales.filter((l: string) => l !== config?.extract?.primaryLanguage)
+
   const { allKeys: allExtractedKeys } = await findKeys(config)
-  const { primaryLanguage, keySeparator = '.', defaultNS = 'translation' } = config.extract
-  const secondaryLanguages = config.locales.filter(l => l !== primaryLanguage)
+  const {
+    secondaryLanguages,
+    keySeparator = '.',
+    defaultNS = 'translation',
+    mergeNamespaces = false,
+  } = config.extract
 
   const keysByNs = new Map<string, ExtractedKey[]>()
   for (const key of allExtractedKeys.values()) {
@@ -105,17 +111,19 @@ async function generateStatusReport (config: I18nextToolkitConfig): Promise<Stat
     let totalTranslatedForLocale = 0
     const namespaces = new Map<string, any>()
 
+    const mergedTranslations = mergeNamespaces
+      ? await loadTranslationFile(resolve(process.cwd(), getOutputPath(config.extract.output, locale))) || {}
+      : null
+
     for (const [ns, keysInNs] of keysByNs.entries()) {
-      const langFilePath = getOutputPath(config.extract.output, locale, ns)
-      let translations: Record<string, any> = {}
-      try {
-        const content = await readFile(resolve(process.cwd(), langFilePath), 'utf-8')
-        translations = JSON.parse(content)
-      } catch {}
+      const translationsForNs = mergeNamespaces
+        ? mergedTranslations?.[ns] || {}
+        : await loadTranslationFile(resolve(process.cwd(), getOutputPath(config.extract.output, locale, ns))) || {}
 
       let translatedInNs = 0
       const keyDetails = keysInNs.map(({ key }) => {
-        const value = getNestedValue(translations, key, keySeparator ?? '.')
+        // Search for the key within the correct namespace object
+        const value = getNestedValue(translationsForNs, key, keySeparator ?? '.')
         const isTranslated = !!value
         if (isTranslated) translatedInNs++
         return { key, isTranslated }

package/src/syncer.ts

@@ -1,10 +1,11 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises'
-import { resolve, dirname } from 'path'
+import { writeFile, mkdir } from 'node:fs/promises'
+import { resolve, dirname, basename } from 'path'
 import chalk from 'chalk'
 import ora from 'ora'
+import { glob } from 'glob'
 import type { I18nextToolkitConfig } from './types'
 import { getNestedKeys, getNestedValue, setNestedValue } from './utils/nested-object'
-import { getOutputPath } from './utils/file-utils'
+import { getOutputPath, loadTranslationFile, serializeTranslationFile } from './utils/file-utils'
 
 /**
  * Synchronizes translation files across different locales by ensuring all secondary
@@ -38,77 +39,86 @@ import { getOutputPath } from './utils/file-utils'
  */
 export async function runSyncer (config: I18nextToolkitConfig) {
   const spinner = ora('Running i18next locale synchronizer...\n').start()
-
-  config.extract.primaryLanguage ||= config.locales[0] || 'en'
-  const { primaryLanguage } = config.extract
-  const secondaryLanguages = config.locales.filter(l => l !== primaryLanguage)
-  const keySeparator = config.extract.keySeparator ?? '.'
-
-  const logMessages: string[] = []
-  let wasAnythingSynced = false
-
-  // Assume sync operates on the default namespace for simplicity
-  const defaultNS = config.extract.defaultNS ?? 'translation'
-
-  // 1. Get all keys from the primary language file
-  const primaryPath = getOutputPath(config.extract.output, primaryLanguage, defaultNS)
-
-  const fullPrimaryPath = resolve(process.cwd(), primaryPath)
-
-  let primaryTranslations: Record<string, any>
   try {
-    const primaryContent = await readFile(fullPrimaryPath, 'utf-8')
-    primaryTranslations = JSON.parse(primaryContent)
-  } catch (e) {
-    console.error(`Primary language file not found at ${primaryPath}. Cannot sync.`)
-    return
-  }
-
-  const primaryKeys = getNestedKeys(primaryTranslations, keySeparator)
-
-  // 2. Iterate through secondary languages and sync them
-  for (const lang of secondaryLanguages) {
-    const secondaryPath = getOutputPath(config.extract.output, lang, defaultNS)
-    const fullSecondaryPath = resolve(process.cwd(), secondaryPath)
-
-    let secondaryTranslations: Record<string, any> = {}
-    let oldContent = ''
-    try {
-      oldContent = await readFile(fullSecondaryPath, 'utf-8')
-      secondaryTranslations = JSON.parse(oldContent)
-    } catch (e) { /* File doesn't exist, will be created */ }
-
-    const newSecondaryTranslations: Record<string, any> = {}
+    const primaryLanguage = config.extract.primaryLanguage || config.locales[0] || 'en'
+    const secondaryLanguages = config.locales.filter((l) => l !== primaryLanguage)
+    const {
+      output,
+      keySeparator = '.',
+      outputFormat = 'json',
+      indentation = 2,
+      defaultValue = '',
+    } = config.extract
+
+    const logMessages: string[] = []
+    let wasAnythingSynced = false
+
+    // 1. Find all namespace files for the primary language
+    const primaryNsPattern = getOutputPath(output, primaryLanguage, '*')
+    const primaryNsFiles = await glob(primaryNsPattern)
+
+    if (primaryNsFiles.length === 0) {
+      spinner.warn(`No translation files found for primary language "${primaryLanguage}". Nothing to sync.`)
+      return
+    }
 
-    // Rebuild the secondary file based on the primary file's keys
-    for (const key of primaryKeys) {
-      const existingValue = getNestedValue(secondaryTranslations, key, keySeparator)
-      // If value exists in old file, keep it. Otherwise, add as empty string.
-      const valueToSet = existingValue ?? (config.extract?.defaultValue || '')
-      setNestedValue(newSecondaryTranslations, key, valueToSet, keySeparator)
+    // 2. Loop through each primary namespace file
+    for (const primaryPath of primaryNsFiles) {
+      const ns = basename(primaryPath).split('.')[0]
+      const primaryTranslations = await loadTranslationFile(primaryPath)
+
+      if (!primaryTranslations) {
+        logMessages.push(`  ${chalk.yellow('-')} Could not read primary file: ${primaryPath}`)
+        continue
+      }
+
+      const primaryKeys = getNestedKeys(primaryTranslations, keySeparator ?? '.')
+
+      // 3. For each secondary language, sync the current namespace
+      for (const lang of secondaryLanguages) {
+        const secondaryPath = getOutputPath(output, lang, ns)
+        const fullSecondaryPath = resolve(process.cwd(), secondaryPath)
+        const existingSecondaryTranslations = await loadTranslationFile(fullSecondaryPath) || {}
+        const newSecondaryTranslations: Record<string, any> = {}
+
+        for (const key of primaryKeys) {
+          const existingValue = getNestedValue(existingSecondaryTranslations, key, keySeparator ?? '.')
+          const valueToSet = existingValue ?? defaultValue
+          setNestedValue(newSecondaryTranslations, key, valueToSet, keySeparator ?? '.')
+        }
+
+        // Use JSON.stringify for a reliable object comparison, regardless of format
+        const oldContent = JSON.stringify(existingSecondaryTranslations)
+        const newContent = JSON.stringify(newSecondaryTranslations)
+
+        if (newContent !== oldContent) {
+          wasAnythingSynced = true
+          const serializedContent = serializeTranslationFile(newSecondaryTranslations, outputFormat, indentation)
+          await mkdir(dirname(fullSecondaryPath), { recursive: true })
+          await writeFile(fullSecondaryPath, serializedContent)
+          logMessages.push(`  ${chalk.green('✓')} Synchronized: ${secondaryPath}`)
+        } else {
+          logMessages.push(`  ${chalk.gray('-')} Already in sync: ${secondaryPath}`)
+        }
+      }
     }
 
-    const indentation = config.extract.indentation ?? 2
-    const newContent = JSON.stringify(newSecondaryTranslations, null, indentation)
+    spinner.succeed(chalk.bold('Synchronization complete!'))
+    logMessages.forEach(msg => console.log(msg))
 
-    if (newContent !== oldContent) {
-      wasAnythingSynced = true
-      await mkdir(dirname(fullSecondaryPath), { recursive: true })
-      await writeFile(fullSecondaryPath, newContent)
-      logMessages.push(`  ${chalk.green('✓')} Synchronized: ${secondaryPath}`)
+    if (wasAnythingSynced) {
+      printLocizeFunnel()
     } else {
-      logMessages.push(`  ${chalk.gray('-')} Already in sync: ${secondaryPath}`)
+      console.log(chalk.green.bold('\n✅ All locales are already in sync.'))
     }
+  } catch (error) {
+    spinner.fail(chalk.red('Synchronization failed.'))
+    console.error(error)
   }
+}
 
-  spinner.succeed(chalk.bold('Synchronization complete!'))
-  logMessages.forEach(msg => console.log(msg))
-
-  if (wasAnythingSynced) {
-    console.log(chalk.green.bold('\n✅ Sync complete.'))
-    console.log(chalk.yellow('🚀 Ready to collaborate with translators? Move your files to the cloud.'))
-    console.log(`   Get started with the official TMS for i18next: ${chalk.cyan('npx i18next-cli locize-migrate')}`)
-  } else {
-    console.log(chalk.green.bold('\n✅ All locales are already in sync.'))
-  }
+function printLocizeFunnel () {
+  console.log(chalk.green.bold('\n✅ Sync complete.'))
+  console.log(chalk.yellow('🚀 Ready to collaborate with translators? Move your files to the cloud.'))
+  console.log(`   Get started with the official TMS for i18next: ${chalk.cyan('npx i18next-cli locize-migrate')}`)
 }