i18next-cli 1.24.12 → 1.24.14

package/src/locize.ts

@@ -1,263 +0,0 @@
-import { execa } from 'execa'
-import chalk from 'chalk'
-import ora from 'ora'
-import inquirer from 'inquirer'
-import { resolve, sep } from 'node:path'
-import type { I18nextToolkitConfig } from './types'
-
-/**
- * Verifies that the locize-cli tool is installed and accessible.
- *
- * @throws Exits the process with error code 1 if locize-cli is not found
- *
- * @example
- * ```typescript
- * await checkLocizeCliExists()
- * // Continues execution if locize-cli is available
- * // Otherwise exits with installation instructions
- * ```
- */
-async function checkLocizeCliExists (): Promise<void> {
-  try {
-    await execa('locize', ['--version'])
-  } catch (error: any) {
-    if (error.code === 'ENOENT') {
-      console.error(chalk.red('Error: `locize-cli` command not found.'))
-      console.log(chalk.yellow('Please install it globally to use the locize integration:'))
-      console.log(chalk.cyan('npm install -g locize-cli'))
-      process.exit(1)
-    }
-  }
-}
-
-/**
- * Interactive setup wizard for configuring Locize credentials.
- *
- * This function guides users through setting up their Locize integration when
- * configuration is missing or invalid. It:
- * 1. Prompts for Project ID, API Key, and version
- * 2. Validates required fields
- * 3. Temporarily sets credentials for the current run
- * 4. Provides security recommendations for storing credentials
- * 5. Shows code examples for proper configuration
- *
- * @param config - Configuration object to update with new credentials
- * @returns Promise resolving to the Locize configuration or undefined if setup was cancelled
- *
- * @example
- * ```typescript
- * const locizeConfig = await interactiveCredentialSetup(config)
- * if (locizeConfig) {
- *   // Proceed with sync using the new credentials
- * }
- * ```
- */
-async function interactiveCredentialSetup (config: I18nextToolkitConfig): Promise<{ projectId?: string, apiKey?: string, version?: string } | undefined> {
-  console.log(chalk.yellow('\nLocize configuration is missing or invalid. Let\'s set it up!'))
-
-  const answers = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'projectId',
-      message: 'What is your locize Project ID? (Find this in your project settings on www.locize.app)',
-      validate: input => !!input || 'Project ID cannot be empty.',
-    },
-    {
-      type: 'password',
-      name: 'apiKey',
-      message: 'What is your locize API key? (Create or use one in your project settings > "API Keys")',
-      validate: input => !!input || 'API Key cannot be empty.',
-    },
-    {
-      type: 'input',
-      name: 'version',
-      message: 'What version do you want to sync with?',
-      default: 'latest',
-    },
-  ])
-
-  if (!answers.projectId) {
-    console.error(chalk.red('Project ID is required to continue.'))
-    return undefined
-  }
-
-  const { save } = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'save',
-    message: 'Would you like to see how to save these credentials for future use?',
-    default: true,
-  }])
-
-  if (save) {
-    const envSnippet = `
-# Add this to your .env file (and ensure .env is in your .gitignore!)
-LOCIZE_API_KEY=${answers.apiKey}
-`
-    const configSnippet = `
-  // Add this to your i18next.config.ts file
-  locize: {
-    projectId: '${answers.projectId}',
-    // For security, apiKey is best set via an environment variable
-    apiKey: process.env.LOCIZE_API_KEY,
-    version: '${answers.version}',
-  },`
-
-    console.log(chalk.cyan('\nGreat! For the best security, we recommend using environment variables for your API key.'))
-    console.log(chalk.bold('\nRecommended approach (.env file):'))
-    console.log(chalk.green(envSnippet))
-    console.log(chalk.bold('Then, in your i18next.config.ts:'))
-    console.log(chalk.green(configSnippet))
-  }
-
-  return {
-    projectId: answers.projectId,
-    apiKey: answers.apiKey,
-    version: answers.version,
-  }
-}
-
-/**
- * Helper function to build the array of arguments for the execa call.
- * This ensures the logic is consistent for both the initial run and the retry.
- */
-function buildArgs (command: string, config: I18nextToolkitConfig, cliOptions: any): string[] {
-  const { locize: locizeConfig = {}, extract } = config
-  const { projectId, apiKey, version } = locizeConfig
-
-  const commandArgs: string[] = [command]
-
-  if (projectId) commandArgs.push('--project-id', projectId)
-  if (apiKey) commandArgs.push('--api-key', apiKey)
-  if (version) commandArgs.push('--ver', version)
-  // TODO: there might be more configurable locize-cli options in future
-
-  // Pass-through options from the CLI
-  if (command === 'sync') {
-    const updateValues = cliOptions.updateValues ?? locizeConfig.updateValues
-    if (updateValues) commandArgs.push('--update-values', 'true')
-    const srcLngOnly = cliOptions.srcLngOnly ?? locizeConfig.sourceLanguageOnly
-    if (srcLngOnly) commandArgs.push('--reference-language-only', 'true')
-    const compareMtime = cliOptions.compareMtime ?? locizeConfig.compareModificationTime
-    if (compareMtime) commandArgs.push('--compare-modification-time', 'true')
-    const dryRun = cliOptions.dryRun ?? locizeConfig.dryRun
-    if (dryRun) commandArgs.push('--dry', 'true')
-  }
-
-  // Derive a sensible base path for locize from the configured output.
-  // If output is a string template we can strip the language placeholder.
-  // If output is a function we cannot reliably infer the base; fall back to cwd.
-  let basePath: string
-  try {
-    if (typeof extract.output === 'string') {
-      const outputNormalized = extract.output.replace(/\\/g, '/')
-      const baseCandidate = outputNormalized.includes('/{{language}}/')
-        ? outputNormalized.split('/{{language}}/')[0]
-        : outputNormalized.replace('{{language}}', '')
-      const baseCandidateWithSep = baseCandidate.split('/').join(sep)
-      basePath = resolve(process.cwd(), baseCandidateWithSep)
-    } else if (typeof extract.output === 'function') {
-      // Try calling the function with the primary language to get an example path,
-      // then strip the language folder if present. If that fails, fallback to cwd.
-      try {
-        const sample = extract.output(config.extract.primaryLanguage || 'en')
-        const sampleNormalized = String(sample).replace(/\\/g, '/')
-        const baseCandidate = sampleNormalized.includes('/' + (config.extract.primaryLanguage || 'en') + '/')
-          ? sampleNormalized.split('/' + (config.extract.primaryLanguage || 'en') + '/')[0]
-          : sampleNormalized.replace(config.extract.primaryLanguage || 'en', '')
-        basePath = resolve(process.cwd(), baseCandidate.split('/').join(sep))
-      } catch {
-        basePath = resolve(process.cwd(), '.')
-      }
-    } else {
-      basePath = resolve(process.cwd(), '.')
-    }
-  } catch {
-    basePath = resolve(process.cwd(), '.')
-  }
-
-  commandArgs.push('--path', basePath)
-
-  return commandArgs
-}
-
-/**
- * Executes a locize-cli command with proper error handling and credential management.
- *
- * This is the core function that:
- * 1. Validates that locize-cli is installed
- * 2. Builds command arguments from configuration and CLI options
- * 3. Executes the locize command with proper credential handling
- * 4. Provides interactive credential setup on authentication errors
- * 5. Handles retries with new credentials
- * 6. Reports success or failure with appropriate exit codes
- *
- * @param command - The locize command to execute ('sync', 'download', or 'migrate')
- * @param config - The toolkit configuration with locize settings
- * @param cliOptions - Additional options passed from CLI arguments
- *
- * @example
- * ```typescript
- * // Sync local files to Locize
- * await runLocizeCommand('sync', config, { updateValues: true })
- *
- * // Download translations from Locize
- * await runLocizeCommand('download', config)
- *
- * // Migrate local files to a new Locize project
- * await runLocizeCommand('migrate', config)
- * ```
- */
-async function runLocizeCommand (command: 'sync' | 'download' | 'migrate', config: I18nextToolkitConfig, cliOptions: any = {}) {
-  await checkLocizeCliExists()
-
-  const spinner = ora(`Running 'locize ${command}'...\n`).start()
-
-  let effectiveConfig = config
-
-  try {
-    // 1. First attempt
-    const initialArgs = buildArgs(command, effectiveConfig, cliOptions)
-    console.log(chalk.cyan(`\nRunning 'locize ${initialArgs.join(' ')}'...`))
-    const result = await execa('locize', initialArgs, { stdio: 'pipe' })
-
-    spinner.succeed(chalk.green(`'locize ${command}' completed successfully.`))
-    if (result?.stdout) console.log(result.stdout) // Print captured output on success
-  } catch (error: any) {
-    const stderr = error.stderr || ''
-    if (stderr.includes('missing required argument')) {
-      // 2. Auth failure, trigger interactive setup
-      const newCredentials = await interactiveCredentialSetup(effectiveConfig)
-      if (newCredentials) {
-        effectiveConfig = { ...effectiveConfig, locize: newCredentials }
-
-        spinner.start('Retrying with new credentials...')
-        try {
-          // 3. Retry attempt, rebuilding args with the NOW-UPDATED currentConfig object
-          const retryArgs = buildArgs(command, effectiveConfig, cliOptions)
-          console.log(chalk.cyan(`\nRunning 'locize ${retryArgs.join(' ')}'...`))
-          const result = await execa('locize', retryArgs, { stdio: 'pipe' })
-
-          spinner.succeed(chalk.green('Retry successful!'))
-          if (result?.stdout) console.log(result.stdout)
-        } catch (retryError: any) {
-          spinner.fail(chalk.red('Error during retry.'))
-          console.error(retryError.stderr || retryError.message)
-          process.exit(1)
-        }
-      } else {
-        spinner.fail('Operation cancelled.')
-        process.exit(1) // User aborted the prompt
-      }
-    } else {
-      // Handle other errors
-      spinner.fail(chalk.red(`Error executing 'locize ${command}'.`))
-      console.error(stderr || error.message)
-      process.exit(1)
-    }
-  }
-  console.log(chalk.green(`\n✅ 'locize ${command}' completed successfully.`))
-}
-
-export const runLocizeSync = (config: I18nextToolkitConfig, cliOptions?: any) => runLocizeCommand('sync', config, cliOptions)
-export const runLocizeDownload = (config: I18nextToolkitConfig, cliOptions?: any) => runLocizeCommand('download', config, cliOptions)
-export const runLocizeMigrate = (config: I18nextToolkitConfig, cliOptions?: any) => runLocizeCommand('migrate', config, cliOptions)

package/src/migrator.ts

@@ -1,208 +0,0 @@
-import { resolve } from 'node:path'
-import { writeFile, access } from 'node:fs/promises'
-import { pathToFileURL } from 'node:url'
-import { createJiti } from 'jiti'
-import { getTsConfigAliases } from './config'
-
-/**
- * Path where the new configuration file will be created
- */
-const newConfigPath = resolve(process.cwd(), 'i18next.config.ts')
-
-/**
- * List of possible new configuration file names that would prevent migration
- */
-const POSSIBLE_NEW_CONFIGS = [
-  'i18next.config.ts',
-  'i18next.config.js',
-  'i18next.config.mjs',
-  'i18next.config.cjs',
-]
-
-/**
- * List of supported legacy configuration file extensions
- */
-const LEGACY_CONFIG_EXTENSIONS = ['.js', '.mjs', '.cjs', '.ts']
-
-/**
- * Helper function to find a legacy config file with various extensions
- */
-async function findLegacyConfigFile (basePath: string): Promise<string | null> {
-  // If the provided path already has an extension, use it directly
-  if (LEGACY_CONFIG_EXTENSIONS.some(ext => basePath.endsWith(ext))) {
-    try {
-      await access(basePath)
-      return basePath
-    } catch {
-      return null
-    }
-  }
-
-  // Try different extensions
-  for (const ext of LEGACY_CONFIG_EXTENSIONS) {
-    const fullPath = `${basePath}${ext}`
-    try {
-      await access(fullPath)
-      return fullPath
-    } catch {
-      // Continue to next extension
-    }
-  }
-
-  return null
-}
-
-/**
- * Loads a legacy config file using the appropriate loader (jiti for TS, dynamic import for JS/MJS/CJS)
- */
-async function loadLegacyConfig (configPath: string): Promise<any> {
-  try {
-    let config: any
-
-    // Use jiti for TypeScript files, native import for JavaScript
-    if (configPath.endsWith('.ts')) {
-      const aliases = await getTsConfigAliases()
-      const jiti = createJiti(process.cwd(), {
-        alias: aliases,
-        interopDefault: false,
-      })
-
-      const configModule = await jiti.import(configPath, { default: true })
-      config = configModule
-    } else {
-      const configUrl = pathToFileURL(configPath).href
-      const configModule = await import(`${configUrl}?t=${Date.now()}`)
-      config = configModule.default
-    }
-
-    return config
-  } catch (error) {
-    console.error(`Error loading legacy config from ${configPath}:`, error)
-    return null
-  }
-}
-
-/**
- * Migrates a legacy i18next-parser configuration file to the new
- * i18next-cli configuration format.
- *
- * This function:
- * 1. Checks if a legacy config file exists (supports .js, .mjs, .cjs, .ts)
- * 2. Prevents migration if any new config file already exists
- * 3. Dynamically imports the old configuration using appropriate loader
- * 4. Maps old configuration properties to new format:
- *    - `$LOCALE` → `{{language}}`
- *    - `$NAMESPACE` → `{{namespace}}`
- *    - Maps lexer functions and components
- *    - Creates sensible defaults for new features
- * 5. Generates a new TypeScript configuration file
- * 6. Provides warnings for deprecated features
- *
- * @param customConfigPath - Optional custom path to the legacy config file
- *
- * @example
- * ```bash
- * # Migrate default config
- * npx i18next-cli migrate-config
- *
- * # Migrate custom config with extension
- * npx i18next-cli migrate-config i18next-parser.config.mjs
- *
- * # Migrate custom config without extension (will try .js, .mjs, .cjs, .ts)
- * npx i18next-cli migrate-config my-custom-config
- * ```
- */
-export async function runMigrator (customConfigPath?: string) {
-  let oldConfigPath: string | null
-
-  if (customConfigPath) {
-    oldConfigPath = await findLegacyConfigFile(resolve(process.cwd(), customConfigPath))
-    if (!oldConfigPath) {
-      console.log(`No legacy config file found at or near: ${customConfigPath}`)
-      console.log('Tried extensions: .js, .mjs, .cjs, .ts')
-      return
-    }
-  } else {
-    // Default behavior: look for i18next-parser.config.* files
-    oldConfigPath = await findLegacyConfigFile(resolve(process.cwd(), 'i18next-parser.config'))
-    if (!oldConfigPath) {
-      console.log('No i18next-parser.config.* found. Nothing to migrate.')
-      console.log('Tried: i18next-parser.config.js, .mjs, .cjs, .ts')
-      return
-    }
-  }
-
-  console.log(`Attempting to migrate legacy config from: ${oldConfigPath}...`)
-
-  // Check if ANY new config file already exists
-  for (const configFile of POSSIBLE_NEW_CONFIGS) {
-    try {
-      const fullPath = resolve(process.cwd(), configFile)
-      await access(fullPath)
-      console.warn(`Warning: A new configuration file already exists at "${configFile}". Migration skipped to avoid overwriting.`)
-      return
-    } catch (e) {
-      // File doesn't exist, which is good
-    }
-  }
-
-  // Load the legacy config using the appropriate loader
-  const oldConfig = await loadLegacyConfig(oldConfigPath)
-
-  if (!oldConfig) {
-    console.error('Could not read the legacy config file.')
-    return
-  }
-
-  // --- Start Migration Logic ---
-  const newConfig = {
-    locales: oldConfig.locales || ['en'],
-    extract: {
-      input: oldConfig.input || 'src/**/*.{js,jsx,ts,tsx}',
-      output: (oldConfig.output || 'locales/$LOCALE/$NAMESPACE.json')
-        .replace('$LOCALE', '{{language}}')
-        .replace('$NAMESPACE', '{{namespace}}'),
-      defaultNS: oldConfig.defaultNamespace || 'translation',
-      keySeparator: oldConfig.keySeparator,
-      nsSeparator: oldConfig.namespaceSeparator,
-      contextSeparator: oldConfig.contextSeparator,
-      // A simple mapping for functions
-      functions: oldConfig.lexers?.js?.functions || ['t', '*.t'],
-      transComponents: oldConfig.lexers?.js?.components || ['Trans'],
-    },
-    types: {
-      input: ['locales/{{language}}/{{namespace}}.json'], // Sensible default
-      output: 'src/types/i18next.d.ts', // Sensible default
-    },
-  }
-
-  // Make the migration smarter: if 't' is a function, also add the '*.t' wildcard
-  // to provide better out-of-the-box support for common patterns like `i18n.t`.
-  if (newConfig.extract.functions.includes('t') && !newConfig.extract.functions.includes('*.t')) {
-    newConfig.extract.functions.push('*.t')
-  }
-  // --- End Migration Logic ---
-
-  // Generate the new file content as a string
-  const newConfigFileContent = `
-import { defineConfig } from 'i18next-cli';
-
-export default defineConfig(${JSON.stringify(newConfig, null, 2)});
-`
-
-  await writeFile(newConfigPath, newConfigFileContent.trim())
-
-  console.log('✅ Success! Migration complete.')
-  console.log(`New configuration file created at: ${newConfigPath}`)
-  console.warn('\nPlease review the generated file and adjust paths for "types.input" if necessary.')
-
-  // Warning for deprecated features
-  if (oldConfig.keepRemoved) {
-    console.warn('Warning: The "keepRemoved" option is deprecated. Consider using the "preservePatterns" feature for dynamic keys.')
-  }
-
-  // Warning for compatibilityJSON v3
-  if (oldConfig.i18nextOptions?.compatibilityJSON === 'v3') {
-    console.warn('Warning: compatibilityJSON "v3" is not supported in i18next-cli. Only i18next v4 format is supported.')
-  }
-}