i18next-cli 1.24.13 → 1.24.14

package/src/status.ts

@@ -1,380 +0,0 @@
-import chalk from 'chalk'
-import ora from 'ora'
-import { resolve } from 'node:path'
-import { findKeys } from './extractor/core/key-finder'
-import { getNestedValue } from './utils/nested-object'
-import type { I18nextToolkitConfig, ExtractedKey } from './types'
-import { getOutputPath, loadTranslationFile } from './utils/file-utils'
-import { shouldShowFunnel, recordFunnelShown } from './utils/funnel-msg-tracker'
-
-/**
- * Options for configuring the status report display.
- */
-interface StatusOptions {
-  /** Locale code to display detailed information for a specific language */
-  detail?: string;
-  /** Namespace to filter the report by */
-  namespace?: string;
-}
-
-/**
- * Structured report containing all translation status data.
- */
-interface StatusReport {
-  /** Total number of extracted keys across all namespaces */
-  totalBaseKeys: number;
-  /** Map of namespace names to their extracted keys */
-  keysByNs: Map<string, ExtractedKey[]>;
-  /** Map of locale codes to their translation status data */
-  locales: Map<string, {
-    /** Total number of extracted keys per locale */
-    totalKeys: number;
-    /** Total number of translated keys for this locale */
-    totalTranslated: number;
-    /** Map of namespace names to their translation details for this locale */
-    namespaces: Map<string, {
-      /** Total number of keys in this namespace */
-      totalKeys: number;
-      /** Number of translated keys in this namespace */
-      translatedKeys: number;
-      /** Detailed status for each key in this namespace */
-      keyDetails: Array<{ key: string; isTranslated: boolean }>;
-    }>;
-  }>;
-}
-
-/**
- * Runs a health check on the project's i18next translations and displays a status report.
- *
- * This command provides a high-level overview of the localization status by:
- * 1. Extracting all keys from the source code using the core extractor.
- * 2. Reading all existing translation files for each locale.
- * 3. Calculating the translation completeness for each secondary language against the primary.
- * 4. Displaying a formatted report with key counts, locales, and progress bars.
- * 5. Serving as a value-driven funnel to introduce the locize commercial service.
- *
- * @param config - The i18next toolkit configuration object.
- * @param options - Options object, may contain a `detail` property with a locale string.
- * @throws {Error} When unable to extract keys or read translation files
- */
-export async function runStatus (config: I18nextToolkitConfig, options: StatusOptions = {}) {
-  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)
-    spinner.succeed('Analysis complete.')
-    await displayStatusReport(report, config, options)
-  } catch (error) {
-    spinner.fail('Failed to generate status report.')
-    console.error(error)
-  }
-}
-
-/**
- * Gathers all translation data and compiles it into a structured report.
- *
- * This function:
- * - Extracts all keys from source code using the configured extractor
- * - Groups keys by namespace
- * - Reads translation files for each secondary language
- * - Compares extracted keys against existing translations
- * - Compiles translation statistics for each locale and namespace
- *
- * @param config - The i18next toolkit configuration object
- * @returns Promise that resolves to a complete status report
- * @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 { secondaryLanguages, keySeparator = '.', defaultNS = 'translation', mergeNamespaces = false, pluralSeparator = '_' } = config.extract
-
-  const keysByNs = new Map<string, ExtractedKey[]>()
-  for (const key of allExtractedKeys.values()) {
-    const ns = key.ns || defaultNS || 'translation'
-    if (!keysByNs.has(ns)) keysByNs.set(ns, [])
-    keysByNs.get(ns)!.push(key)
-  }
-
-  const report: StatusReport = {
-    totalBaseKeys: allExtractedKeys.size,
-    keysByNs,
-    locales: new Map(),
-  }
-
-  for (const locale of secondaryLanguages) {
-    let totalTranslatedForLocale = 0
-    let totalKeysForLocale = 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 translationsForNs = mergeNamespaces
-        ? mergedTranslations?.[ns] || {}
-        : await loadTranslationFile(resolve(process.cwd(), getOutputPath(config.extract.output, locale, ns))) || {}
-
-      let translatedInNs = 0
-      let totalInNs = 0
-      const keyDetails: Array<{ key: string; isTranslated: boolean }> = []
-
-      // Get the plural categories for THIS specific locale
-      const getLocalePluralCategories = (locale: string, isOrdinal: boolean): string[] => {
-        try {
-          const type = isOrdinal ? 'ordinal' : 'cardinal'
-          const pluralRules = new Intl.PluralRules(locale, { type })
-          return pluralRules.resolvedOptions().pluralCategories
-        } catch (e) {
-          // Fallback to English if locale is invalid
-          const fallbackRules = new Intl.PluralRules('en', { type: isOrdinal ? 'ordinal' : 'cardinal' })
-          return fallbackRules.resolvedOptions().pluralCategories
-        }
-      }
-
-      for (const { key: baseKey, hasCount, isOrdinal, isExpandedPlural } of keysInNs) {
-        if (hasCount) {
-          if (isExpandedPlural) {
-            // This is an already-expanded plural variant key (e.g., key_one, key_other)
-            // Check if this specific variant is needed for the target locale
-            const keyParts = baseKey.split(pluralSeparator)
-            const lastPart = keyParts[keyParts.length - 1]
-
-            // Determine if this is an ordinal or cardinal plural
-            const isOrdinalVariant = keyParts.length >= 2 && keyParts[keyParts.length - 2] === 'ordinal'
-            const category = isOrdinalVariant ? keyParts[keyParts.length - 1] : lastPart
-
-            // Get the plural categories for this locale
-            const localePluralCategories = getLocalePluralCategories(locale, isOrdinalVariant)
-
-            // Only count this key if it's a plural form used by this locale
-            if (localePluralCategories.includes(category)) {
-              totalInNs++
-              const value = getNestedValue(translationsForNs, baseKey, keySeparator ?? '.')
-              const isTranslated = !!value
-              if (isTranslated) translatedInNs++
-              keyDetails.push({ key: baseKey, isTranslated })
-            }
-          } else {
-            // This is a base plural key without expanded variants
-            // Expand it according to THIS locale's plural rules
-            const localePluralCategories = getLocalePluralCategories(locale, isOrdinal || false)
-
-            for (const category of localePluralCategories) {
-              totalInNs++
-              const pluralKey = isOrdinal
-                ? `${baseKey}${pluralSeparator}ordinal${pluralSeparator}${category}`
-                : `${baseKey}${pluralSeparator}${category}`
-              const value = getNestedValue(translationsForNs, pluralKey, keySeparator ?? '.')
-              const isTranslated = !!value
-              if (isTranslated) translatedInNs++
-              keyDetails.push({ key: pluralKey, isTranslated })
-            }
-          }
-        } else {
-          // It's a simple key
-          totalInNs++
-          const value = getNestedValue(translationsForNs, baseKey, keySeparator ?? '.')
-          const isTranslated = !!value
-          if (isTranslated) translatedInNs++
-          keyDetails.push({ key: baseKey, isTranslated })
-        }
-      }
-
-      namespaces.set(ns, { totalKeys: totalInNs, translatedKeys: translatedInNs, keyDetails })
-      totalTranslatedForLocale += translatedInNs
-      totalKeysForLocale += totalInNs
-    }
-    report.locales.set(locale, { totalKeys: totalKeysForLocale, totalTranslated: totalTranslatedForLocale, namespaces })
-  }
-  return report
-}
-
-/**
- * Main display router that calls the appropriate display function based on options.
- *
- * Routes to one of three display modes:
- * - Detailed locale report: Shows per-key status for a specific locale
- * - Namespace summary: Shows translation progress for all locales in a specific namespace
- * - Overall summary: Shows high-level statistics across all locales and namespaces
- *
- * @param report - The generated status report data
- * @param config - The i18next toolkit configuration object
- * @param options - Display options determining which report type to show
- */
-async function displayStatusReport (report: StatusReport, config: I18nextToolkitConfig, options: StatusOptions) {
-  if (options.detail) {
-    await displayDetailedLocaleReport(report, config, options.detail, options.namespace)
-  } else if (options.namespace) {
-    await displayNamespaceSummaryReport(report, config, options.namespace)
-  } else {
-    await displayOverallSummaryReport(report, config)
-  }
-}
-
-/**
- * Displays the detailed, grouped report for a single locale.
- *
- * Shows:
- * - Overall progress for the locale
- * - Progress for each namespace (or filtered namespace)
- * - Individual key status (translated/missing) with visual indicators
- * - Summary message with total missing translations
- *
- * @param report - The generated status report data
- * @param config - The i18next toolkit configuration object
- * @param locale - The locale code to display details for
- * @param namespaceFilter - Optional namespace to filter the display
- */
-async function displayDetailedLocaleReport (report: StatusReport, config: I18nextToolkitConfig, locale: string, namespaceFilter?: string) {
-  if (locale === config.extract.primaryLanguage) {
-    console.log(chalk.yellow(`Locale "${locale}" is the primary language. All keys are considered present.`))
-    return
-  }
-  if (!config.locales.includes(locale)) {
-    console.error(chalk.red(`Error: Locale "${locale}" is not defined in your configuration.`))
-    return
-  }
-
-  const localeData = report.locales.get(locale)
-
-  if (!localeData) {
-    console.error(chalk.red(`Error: Locale "${locale}" is not a valid secondary language.`))
-    return
-  }
-
-  console.log(chalk.bold(`\nKey Status for "${chalk.cyan(locale)}":`))
-
-  const totalKeysForLocale = Array.from(report.keysByNs.values()).flat().length
-  printProgressBar('Overall', localeData.totalTranslated, localeData.totalKeys)
-
-  const namespacesToDisplay = namespaceFilter ? [namespaceFilter] : Array.from(localeData.namespaces.keys()).sort()
-
-  for (const ns of namespacesToDisplay) {
-    const nsData = localeData.namespaces.get(ns)
-    if (!nsData) continue
-
-    console.log(chalk.cyan.bold(`\nNamespace: ${ns}`))
-    printProgressBar('Namespace Progress', nsData.translatedKeys, nsData.totalKeys)
-
-    nsData.keyDetails.forEach(({ key, isTranslated }) => {
-      const icon = isTranslated ? chalk.green('✓') : chalk.red('✗')
-      console.log(`  ${icon} ${key}`)
-    })
-  }
-
-  const missingCount = totalKeysForLocale - localeData.totalTranslated
-  if (missingCount > 0) {
-    console.log(chalk.yellow.bold(`\nSummary: Found ${missingCount} missing translations for "${locale}".`))
-  } else {
-    console.log(chalk.green.bold(`\nSummary: 🎉 All keys are translated for "${locale}".`))
-  }
-
-  await printLocizeFunnel()
-}
-
-/**
- * Displays a summary report filtered by a single namespace.
- *
- * Shows translation progress for the specified namespace across all secondary locales,
- * including percentage completion and translated/total key counts.
- *
- * @param report - The generated status report data
- * @param config - The i18next toolkit configuration object
- * @param namespace - The namespace to display summary for
- */
-async function displayNamespaceSummaryReport (report: StatusReport, config: I18nextToolkitConfig, namespace: string) {
-  const nsData = report.keysByNs.get(namespace)
-  if (!nsData) {
-    console.error(chalk.red(`Error: Namespace "${namespace}" was not found in your source code.`))
-    return
-  }
-
-  console.log(chalk.cyan.bold(`\nStatus for Namespace: "${namespace}"`))
-  console.log('------------------------')
-
-  for (const [locale, localeData] of report.locales.entries()) {
-    const nsLocaleData = localeData.namespaces.get(namespace)
-    if (nsLocaleData) {
-      const percentage = nsLocaleData.totalKeys > 0 ? Math.round((nsLocaleData.translatedKeys / nsLocaleData.totalKeys) * 100) : 100
-      const bar = generateProgressBarText(percentage)
-      console.log(`- ${locale}: ${bar} ${percentage}% (${nsLocaleData.translatedKeys}/${nsLocaleData.totalKeys} keys)`)
-    }
-  }
-
-  await printLocizeFunnel()
-}
-
-/**
- * Displays the default, high-level summary report for all locales.
- *
- * Shows:
- * - Project overview (total keys, locales, primary language)
- * - Translation progress for each secondary locale with progress bars
- * - Promotional message for locize service
- *
- * @param report - The generated status report data
- * @param config - The i18next toolkit configuration object
- */
-async function displayOverallSummaryReport (report: StatusReport, config: I18nextToolkitConfig) {
-  const { primaryLanguage } = config.extract
-
-  console.log(chalk.cyan.bold('\ni18next Project Status'))
-  console.log('------------------------')
-  console.log(`🔑 Keys Found:         ${chalk.bold(report.totalBaseKeys)}`)
-  console.log(`📚 Namespaces Found:   ${chalk.bold(report.keysByNs.size)}`)
-  console.log(`🌍 Locales:            ${chalk.bold(config.locales.join(', '))}`)
-  console.log(`✅ Primary Language:   ${chalk.bold(primaryLanguage)}`)
-  console.log('\nTranslation Progress:')
-
-  for (const [locale, localeData] of report.locales.entries()) {
-    const percentage = localeData.totalKeys > 0 ? Math.round((localeData.totalTranslated / localeData.totalKeys) * 100) : 100
-    const bar = generateProgressBarText(percentage)
-    console.log(`- ${locale}: ${bar} ${percentage}% (${localeData.totalTranslated}/${localeData.totalKeys} keys)`)
-  }
-
-  await printLocizeFunnel()
-}
-
-/**
- * Prints a formatted progress bar with label, percentage, and counts.
- *
- * @param label - The label to display before the progress bar
- * @param current - The current count (translated keys)
- * @param total - The total count (all keys)
- */
-function printProgressBar (label: string, current: number, total: number) {
-  const percentage = total > 0 ? Math.round((current / total) * 100) : 100
-  const bar = generateProgressBarText(percentage)
-  console.log(`${chalk.bold(label)}: ${bar} ${percentage}% (${current}/${total})`)
-}
-
-/**
- * Generates a visual progress bar string based on percentage completion.
- *
- * Creates a 20-character progress bar using filled (■) and empty (□) squares,
- * with the filled portion colored green.
- *
- * @param percentage - The completion percentage (0-100)
- * @returns A formatted progress bar string with colors
- */
-function generateProgressBarText (percentage: number): string {
-  const totalBars = 20
-  const filledBars = Math.floor((percentage / 100) * totalBars)
-  const emptyBars = totalBars - filledBars
-  return `[${chalk.green(''.padStart(filledBars, '■'))}${''.padStart(emptyBars, '□')}]`
-}
-
-async function printLocizeFunnel () {
-  if (!(await shouldShowFunnel('status'))) return
-
-  console.log(chalk.yellow.bold('\n✨ Take your localization to the next level!'))
-  console.log('Manage translations with your team in the cloud with locize => https://www.locize.com/docs/getting-started')
-  console.log(`Run ${chalk.cyan('npx i18next-cli locize-migrate')} to get started.`)
-
-  return recordFunnelShown('status')
-}

package/src/syncer.ts

@@ -1,133 +0,0 @@
-import chalk from 'chalk'
-import { glob } from 'glob'
-import { mkdir, writeFile } from 'node:fs/promises'
-import { basename, dirname, resolve } from 'node:path'
-import ora from 'ora'
-import type { I18nextToolkitConfig } from './types'
-import { resolveDefaultValue } from './utils/default-value'
-import { getOutputPath, loadTranslationFile, serializeTranslationFile } from './utils/file-utils'
-import { recordFunnelShown, shouldShowFunnel } from './utils/funnel-msg-tracker'
-import { getNestedKeys, getNestedValue, setNestedValue } from './utils/nested-object'
-
-/**
- * Synchronizes translation files across different locales by ensuring all secondary
- * language files contain the same keys as the primary language file.
- *
- * This function:
- * 1. Reads the primary language translation file
- * 2. Extracts all translation keys from the primary file
- * 3. For each secondary language:
- *    - Preserves existing translations
- *    - Adds missing keys with empty values or configured default
- *    - Removes keys that no longer exist in primary
- * 4. Only writes files that have changes
- *
- * @param config - The i18next toolkit configuration object
- *
- * @example
- * ```typescript
- * // Configuration
- * const config = {
- *   locales: ['en', 'de', 'fr'],
- *   extract: {
- *     output: 'locales/{{language}}/{{namespace}}.json',
- *     defaultNS: 'translation'
- *     defaultValue: '[MISSING]'
- *   }
- * }
- *
- * await runSyncer(config)
- * ```
- */
-export async function runSyncer (config: I18nextToolkitConfig) {
-  const spinner = ora('Running i18next locale synchronizer...\n').start()
-  try {
-    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
-    }
-
-    // 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 primaryValue = getNestedValue(primaryTranslations, key, keySeparator ?? '.')
-          const existingValue = getNestedValue(existingSecondaryTranslations, key, keySeparator ?? '.')
-
-          // Use the resolved default value if no existing value
-          const valueToSet = existingValue ?? resolveDefaultValue(defaultValue, key, ns, lang, primaryValue)
-          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}`)
-        }
-      }
-    }
-
-    spinner.succeed(chalk.bold('Synchronization complete!'))
-    logMessages.forEach(msg => console.log(msg))
-
-    if (wasAnythingSynced) {
-      await printLocizeFunnel()
-    } else {
-      console.log(chalk.green.bold('\n✅ All locales are already in sync.'))
-    }
-  } catch (error) {
-    spinner.fail(chalk.red('Synchronization failed.'))
-    console.error(error)
-  }
-}
-
-async function printLocizeFunnel () {
-  if (!(await shouldShowFunnel('syncer'))) return
-
-  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')}`)
-
-  return recordFunnelShown('syncer')
-}

package/src/types-generator.ts

@@ -1,139 +0,0 @@
-import { mergeResourcesAsInterface } from 'i18next-resources-for-ts'
-import { glob } from 'glob'
-import ora from 'ora'
-import chalk from 'chalk'
-import { mkdir, readFile, writeFile, access } from 'node:fs/promises'
-import { basename, extname, resolve, dirname, join, relative } from 'node:path'
-import type { I18nextToolkitConfig } from './types'
-import { getOutputPath } from './utils/file-utils'
-
-/**
- * Represents a translation resource with its namespace name and content
- */
-interface Resource {
-  /** The namespace name (filename without extension) */
-  name: string;
-  /** The parsed JSON resources object */
-  resources: object;
-}
-
-/**
- * Generates TypeScript type definitions for i18next translations.
- *
- * This function:
- * 1. Reads translation files based on the input glob patterns
- * 2. Generates TypeScript interfaces using i18next-resources-for-ts
- * 3. Creates separate resources.d.ts and main i18next.d.ts files
- * 4. Handles namespace detection from filenames
- * 5. Supports type-safe selector API when enabled
- *
- * @param config - The i18next toolkit configuration object
- *
- * @example
- * ```typescript
- * // Configuration
- * const config = {
- *   types: {
- *     input: ['locales/en/*.json'],
- *     output: 'src/types/i18next.d.ts',
- *     enableSelector: true
- *   }
- * }
- *
- * await runTypesGenerator(config)
- * ```
- */
-export async function runTypesGenerator (config: I18nextToolkitConfig) {
-  const spinner = ora('Generating TypeScript types for translations...\n').start()
-
-  try {
-    config.extract.primaryLanguage ||= config.locales[0] || 'en'
-    let defaultTypesInputPath = config.extract.output || `locales/${config.extract.primaryLanguage}/*.json`
-    defaultTypesInputPath = getOutputPath(defaultTypesInputPath, config.extract.primaryLanguage || 'en', '*')
-
-    if (!config.types) config.types = { input: defaultTypesInputPath, output: 'src/@types/i18next.d.ts' }
-    if (config.types.input === undefined) config.types.input = defaultTypesInputPath
-    if (!config.types.output) config.types.output = 'src/@types/i18next.d.ts'
-    if (!config.types.resourcesFile) config.types.resourcesFile = join(dirname(config.types?.output), 'resources.d.ts')
-
-    if (!config.types?.input || config.types?.input.length < 0) {
-      console.log('No input defined!')
-      return
-    }
-
-    const resourceFiles = await glob(config.types?.input || [], {
-      cwd: process.cwd(),
-    })
-
-    const resources: Resource[] = []
-
-    for (const file of resourceFiles) {
-      const namespace = basename(file, extname(file))
-      const content = await readFile(file, 'utf-8')
-      const parsedContent = JSON.parse(content)
-
-      // If mergeNamespaces is used, a single file can contain multiple namespaces
-      // (e.g. { "translation": { ... }, "common": { ... } } in a per-language file).
-      // In that case, expose each top-level key as a namespace entry so the type
-      // generator will produce top-level namespace interfaces (not a language wrapper).
-      if (config.extract?.mergeNamespaces && parsedContent && typeof parsedContent === 'object') {
-        const keys = Object.keys(parsedContent)
-        const allObjects = keys.length > 0 && keys.every(k => parsedContent[k] && typeof parsedContent[k] === 'object')
-        if (allObjects) {
-          for (const nsName of keys) {
-            resources.push({ name: nsName, resources: parsedContent[nsName] })
-          }
-          continue
-        }
-      }
-
-      resources.push({ name: namespace, resources: parsedContent })
-    }
-
-    const logMessages: string[] = []
-
-    const enableSelector = config.types?.enableSelector || false
-    const indentation = config.types?.indentation ?? config.extract.indentation ?? 2
-    const interfaceDefinition = `// This file is automatically generated by i18next-cli. Do not edit manually.
-${mergeResourcesAsInterface(resources, { optimize: !!enableSelector, indentation })}`
-
-    const outputPath = resolve(process.cwd(), config.types?.output || '')
-    const resourcesOutputPath = resolve(process.cwd(), config.types.resourcesFile)
-    await mkdir(dirname(resourcesOutputPath), { recursive: true })
-    await writeFile(resourcesOutputPath, interfaceDefinition)
-    logMessages.push(`  ${chalk.green('✓')} Resources interface written to ${config.types.resourcesFile}`)
-
-    let outputPathExists
-    try {
-      await access(outputPath)
-      outputPathExists = true
-    } catch (e) {
-      outputPathExists = false
-    }
-
-    if (!outputPathExists) {
-    // The main output file will now import from the resources file
-      const importPath = relative(dirname(outputPath), resourcesOutputPath)
-        .replace(/\\/g, '/').replace(/\.d\.ts$/, '') // Make it a valid module path
-
-      const fileContent = `// This file is automatically generated by i18next-cli. Do not edit manually.
-import Resources from './${importPath}';
-
-declare module 'i18next' {
-  interface CustomTypeOptions {
-    enableSelector: ${typeof enableSelector === 'string' ? `"${enableSelector}"` : enableSelector};
-    defaultNS: '${config.extract.defaultNS || 'translation'}';
-    resources: Resources;
-  }
-}`
-      await mkdir(dirname(outputPath), { recursive: true })
-      await writeFile(outputPath, fileContent)
-      logMessages.push(`  ${chalk.green('✓')} TypeScript definitions written to ${config.types.output || ''}`)
-    }
-    spinner.succeed(chalk.bold('TypeScript definitions generated successfully.'))
-    logMessages.forEach(msg => console.log(msg))
-  } catch (error) {
-    spinner.fail(chalk.red('Failed to generate TypeScript definitions.'))
-    console.error(error)
-  }
-}