i18next-cli 0.9.9 → 0.9.11

package/src/extractor/core/extractor.ts

@@ -11,6 +11,7 @@ import { createPluginContext } from '../plugin-manager'
 import { extractKeysFromComments } from '../parsers/comment-parser'
 import { ASTVisitors } from '../parsers/ast-visitors'
 import { ConsoleLogger } from '../../utils/logger'
+import { serializeTranslationFile } from '../../utils/file-utils'
 
 /**
  * Main extractor function that runs the complete key extraction and file generation process.
@@ -42,8 +43,8 @@ export async function runExtractor (
   config: I18nextToolkitConfig,
   logger: Logger = new ConsoleLogger()
 ): Promise<boolean> {
-  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)
 
   validateExtractorConfig(config)
 
@@ -59,8 +60,13 @@ export async function runExtractor (
     for (const result of results) {
       if (result.updated) {
         anyFileUpdated = true
+        const fileContent = serializeTranslationFile(
+          result.newTranslations,
+          config.extract.outputFormat,
+          config.extract.indentation
+        )
         await mkdir(dirname(result.path), { recursive: true })
-        await writeFile(result.path, JSON.stringify(result.newTranslations, null, 2))
+        await writeFile(result.path, fileContent)
         logger.info(chalk.green(`Updated: ${result.path}`))
       }
     }
@@ -180,10 +186,10 @@ function traverseEveryNode (node: any, plugins: any[], pluginContext: PluginCont
  * ```
  */
 export async function extract (config: I18nextToolkitConfig) {
-  if (!config.extract.primaryLanguage) config.extract.primaryLanguage = config.locales[0]
-  if (!config.extract.secondaryLanguages) config.extract.secondaryLanguages = config.locales.filter((l: string) => l !== config?.extract?.primaryLanguage)
-  if (!config.extract.functions) config.extract.functions = ['t']
-  if (!config.extract.transComponents) config.extract.transComponents = ['Trans']
+  config.extract.primaryLanguage ||= config.locales[0] || 'en'
+  config.extract.secondaryLanguages ||= config.locales.filter((l: string) => l !== config?.extract?.primaryLanguage)
+  config.extract.functions ||= ['t']
+  config.extract.transComponents ||= ['Trans']
   const { allKeys, objectKeys } = await findKeys(config)
   return getTranslations(allKeys, objectKeys, config)
 }

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

@@ -118,7 +118,10 @@ export class ASTVisitors {
       const child = node[key]
       if (Array.isArray(child)) {
         for (const item of child) {
-          if (item && typeof item === 'object' && item.type) {
+          // Be less strict: if it's a non-null object, walk it.
+          // This allows traversal into nodes that might not have a `.type` property
+          // but still contain other valid AST nodes.
+          if (item && typeof item === 'object') {
             this.walk(item)
           }
         }
@@ -337,7 +340,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
@@ -376,7 +379,6 @@ export class ASTVisitors {
         options = arg3
       }
     }
-
     const defaultValueFromOptions = options ? this.getObjectPropValue(options, 'defaultValue') : undefined
     const finalDefaultValue = (typeof defaultValueFromOptions === 'string' ? defaultValueFromOptions : defaultValue)
 
@@ -386,7 +388,7 @@ export class ASTVisitors {
       let ns: string | undefined
 
       // Determine namespace (explicit ns > scope ns > ns:key > default)
-      if (options?.type === 'ObjectExpression') {
+      if (options) {
         const nsVal = this.getObjectPropValue(options, 'ns')
         if (typeof nsVal === 'string') ns = nsVal
       }
@@ -406,13 +408,11 @@ export class ASTVisitors {
         finalKey = `${scopeInfo.keyPrefix}${keySeparator}${key}`
       }
 
-      // 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 ? (finalDefaultValue || key) : key
 
       // Handle plurals, context, and returnObjects
-      if (options?.type === 'ObjectExpression') {
+      if (options) {
         const contextProp = this.getObjectProperty(options, 'context')
 
         // 1. Handle Dynamic Context (Ternary) first
@@ -440,8 +440,8 @@ export class ASTVisitors {
 
         // 3. Handle Plurals
         if (this.getObjectPropValue(options, 'count') !== undefined) {
-          this.handlePluralKeys(finalKey, dv, ns)
-          continue // This key is fully handled
+          this.handlePluralKeys(finalKey, ns, options)
+          continue
         }
 
         // 4. Handle returnObjects
@@ -464,27 +464,82 @@ export class ASTVisitors {
    * for each category (e.g., 'item_one', 'item_other').
    *
    * @param key - Base key name for pluralization
-   * @param defaultValue - Default value to use for all plural forms
    * @param ns - Namespace for the keys
+   * @param options - object expression options
    *
    * @private
    */
-  private handlePluralKeys (key: string, defaultValue: string | undefined, ns: string | undefined): void {
+  private handlePluralKeys (key: string, ns: string | undefined, options: ObjectExpression): void {
     try {
-      const pluralCategories = new Intl.PluralRules(this.config.extract?.primaryLanguage).resolvedOptions().pluralCategories
+      const isOrdinal = this.getObjectPropValue(options, 'ordinal') === true
+      const type = isOrdinal ? 'ordinal' : 'cardinal'
+
+      const pluralCategories = new Intl.PluralRules(this.config.extract?.primaryLanguage, { type }).resolvedOptions().pluralCategories
       const pluralSeparator = this.config.extract.pluralSeparator ?? '_'
 
+      const defaultValue = this.getObjectPropValue(options, 'defaultValue')
+      const defaultValueOther = this.getObjectPropValue(options, 'defaultValue_other')
+
+      for (const category of pluralCategories) {
+        // Construct the specific defaultValue key, e.g., `defaultValue_ordinal_one` or `defaultValue_one`
+        const specificDefaultKey = isOrdinal ? `defaultValue_ordinal_${category}` : `defaultValue_${category}`
+        const specificDefault = this.getObjectPropValue(options, specificDefaultKey)
+
+        let finalDefaultValue: string | undefined
+
+        if (typeof specificDefault === 'string') {
+          finalDefaultValue = specificDefault
+        } else if (category === 'one' && typeof defaultValue === 'string') {
+          // 'one' specifically falls back to the main `defaultValue` prop
+          finalDefaultValue = defaultValue
+        } else if (typeof defaultValueOther === 'string') {
+          // All other categories fall back to `defaultValue_other`
+          finalDefaultValue = defaultValueOther
+        } else if (typeof defaultValue === 'string') {
+          // If all else fails, use the main `defaultValue` as a last resort
+          finalDefaultValue = defaultValue
+        } else {
+          finalDefaultValue = key // Fallback to the key itself
+        }
+
+        // Construct the final key, e.g., `key_ordinal_one` or `key_one`
+        const finalKey = isOrdinal
+          ? `${key}${pluralSeparator}ordinal${pluralSeparator}${category}`
+          : `${key}${pluralSeparator}${category}`
+
+        this.pluginContext.addKey({
+          key: finalKey,
+          ns,
+          defaultValue: finalDefaultValue,
+          hasCount: true,
+        })
+      }
+    } catch (e) {
+      this.logger.warn(`Could not determine plural rules for language "${this.config.extract?.primaryLanguage}". Falling back to simple key extraction.`)
+      // Fallback to a simple key if Intl API fails
+      const defaultValue = this.getObjectPropValue(options, 'defaultValue')
+      this.pluginContext.addKey({ key, ns, defaultValue: typeof defaultValue === 'string' ? defaultValue : key })
+    }
+  }
+
+  /**
+   * Generates simple plural keys, typically for a <Trans> component.
+   */
+  private handleSimplePluralKeys (key: string, defaultValue: string | undefined, ns: string | undefined): void {
+    try {
+      const pluralCategories = new Intl.PluralRules(this.config.extract?.primaryLanguage).resolvedOptions().pluralCategories
+      const pluralSeparator = this.config.extract.pluralSeparator ?? '_'
       for (const category of pluralCategories) {
         this.pluginContext.addKey({
           key: `${key}${pluralSeparator}${category}`,
           ns,
           defaultValue,
-          hasCount: true
+          hasCount: true,
         })
       }
     } catch (e) {
-      this.logger.warn(`Could not determine plural rules for language "${this.config.extract?.primaryLanguage}". Falling back to simple key extraction.`)
-      this.pluginContext.addKey({ key, defaultValue, ns })
+      this.logger.warn(`Could not determine plural rules for language "${this.config.extract?.primaryLanguage}".`)
+      this.pluginContext.addKey({ key, ns, defaultValue })
     }
   }
 
@@ -544,7 +599,7 @@ export class ASTVisitors {
             this.pluginContext.addKey(extractedKey)
           }
         } else if (extractedKey.hasCount) {
-          this.handlePluralKeys(extractedKey.key, extractedKey.defaultValue, extractedKey.ns)
+          this.handleSimplePluralKeys(extractedKey.key, extractedKey.defaultValue, extractedKey.ns)
         } else {
           this.pluginContext.addKey(extractedKey)
         }

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')}`)
 }

package/src/types.ts

@@ -83,6 +83,24 @@ export interface I18nextToolkitConfig {
 
     /** Secondary languages that get empty values initially */
     secondaryLanguages?: string[];
+
+    /**
+     * The format of the output translation files.
+     * 'json': Standard JSON file (default)
+     * 'js': JavaScript file with ES Module syntax (export default)
+     * 'js-esm': JavaScript file with ES Module syntax (export default)
+     * 'js-cjs': JavaScript file with CommonJS syntax (module.exports)
+     * 'ts': TypeScript file with ES Module syntax and `as const` for type safety
+     */
+    outputFormat?: 'json' | 'js' | 'js-esm' | 'js-esm' | 'js-cjs' | 'ts';
+
+    /**
+     * If true, all namespaces will be merged into a single file per language.
+     * The `output` path should not contain the `{{namespace}}` placeholder.
+     * Example output: `locales/en.js`
+     * (default: false)
+     */
+    mergeNamespaces?: boolean;
   };
 
   /** Configuration options for TypeScript type generation */