i18next-cli 1.33.5 → 1.34.1

package/dist/cjs/locize.js

@@ -1 +1,269 @@
-"use strict";var e=require("execa"),o=require("chalk"),n=require("ora"),t=require("inquirer"),r=require("node:path");function s(e,o,n){const{locize:t={},extract:s}=o,{projectId:i,apiKey:c,version:a}=t,l=[e];if(i&&l.push("--project-id",i),c&&l.push("--api-key",c),a&&l.push("--ver",a),"sync"===e){(n.updateValues??t.updateValues)&&l.push("--update-values","true");(n.srcLngOnly??t.sourceLanguageOnly)&&l.push("--reference-language-only","true");(n.compareMtime??t.compareModificationTime)&&l.push("--compare-modification-time","true");const e=n.cdnType??t.cdnType;e&&l.push("--cdn-type",e);(n.dryRun??t.dryRun)&&l.push("--dry","true")}let u;try{if("string"==typeof s.output){const e=s.output.replace(/\\/g,"/"),o=(e.includes("/{{language}}/")?e.split("/{{language}}/")[0]:e.replace("{{language}}","")).split("/").join(r.sep);u=r.resolve(process.cwd(),o)}else if("function"==typeof s.output)try{const e=s.output(o.extract.primaryLanguage||"en"),n=String(e).replace(/\\/g,"/"),t=n.includes("/"+(o.extract.primaryLanguage||"en")+"/")?n.split("/"+(o.extract.primaryLanguage||"en")+"/")[0]:n.replace(o.extract.primaryLanguage||"en","");u=r.resolve(process.cwd(),t.split("/").join(r.sep))}catch{u=r.resolve(process.cwd(),".")}else u=r.resolve(process.cwd(),".")}catch{u=r.resolve(process.cwd(),".")}return l.push("--path",u),l}async function i(r,i,c={}){await async function(){try{await e.execa("locize",["--version"])}catch(e){"ENOENT"===e.code&&(console.error(o.red("Error: `locize-cli` command not found.")),console.log(o.yellow("Please install it globally to use the locize integration:")),console.log(o.cyan("npm install -g locize-cli")),process.exit(1))}}();const a=n(`Running 'locize ${r}'...\n`).start();let l=i;try{const n=s(r,l,c);console.log(o.cyan(`\nRunning 'locize ${n.join(" ")}'...`));const t=await e.execa("locize",n,{stdio:"pipe"});a.succeed(o.green(`'locize ${r}' completed successfully.`)),t?.stdout&&console.log(t.stdout)}catch(n){const i=n.stderr||"";if(i.includes("missing required argument")){const n=await async function(){console.log(o.yellow("\nLocize configuration is missing or invalid. Let's set it up!"));const e=await t.prompt([{type:"input",name:"projectId",message:"What is your locize Project ID? (Find this in your project settings on www.locize.app)",validate:e=>!!e||"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:e=>!!e||"API Key cannot be empty."},{type:"input",name:"version",message:"What version do you want to sync with?",default:"latest"}]);if(!e.projectId)return void console.error(o.red("Project ID is required to continue."));const{save:n}=await t.prompt([{type:"confirm",name:"save",message:"Would you like to see how to save these credentials for future use?",default:!0}]);if(n){const n=`\n# Add this to your .env file (and ensure .env is in your .gitignore!)\nLOCIZE_API_KEY=${e.apiKey}\n`,t=`\n  // Add this to your i18next.config.ts file\n  locize: {\n    projectId: '${e.projectId}',\n    // For security, apiKey is best set via an environment variable\n    apiKey: process.env.LOCIZE_API_KEY,\n    version: '${e.version}',\n  },`;console.log(o.cyan("\nGreat! For the best security, we recommend using environment variables for your API key.")),console.log(o.bold("\nRecommended approach (.env file):")),console.log(o.green(n)),console.log(o.bold("Then, in your i18next.config.ts:")),console.log(o.green(t))}return{projectId:e.projectId,apiKey:e.apiKey,version:e.version}}();if(n){l={...l,locize:n},a.start("Retrying with new credentials...");try{const n=s(r,l,c);console.log(o.cyan(`\nRunning 'locize ${n.join(" ")}'...`));const t=await e.execa("locize",n,{stdio:"pipe"});a.succeed(o.green("Retry successful!")),t?.stdout&&console.log(t.stdout)}catch(e){a.fail(o.red("Error during retry.")),console.error(e.stderr||e.message),process.exit(1)}}else a.fail("Operation cancelled."),process.exit(1)}else a.fail(o.red(`Error executing 'locize ${r}'.`)),console.error(i||n.message),process.exit(1)}console.log(o.green(`\n✅ 'locize ${r}' completed successfully.`))}exports.runLocizeDownload=(e,o)=>i("download",e,o),exports.runLocizeMigrate=(e,o)=>i("migrate",e,o),exports.runLocizeSync=(e,o)=>i("sync",e,o);
+'use strict';
+
+var execa = require('execa');
+var chalk = require('chalk');
+var ora = require('ora');
+var inquirer = require('inquirer');
+var node_path = require('node:path');
+
+/**
+ * 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() {
+    try {
+        await execa.execa('locize', ['--version']);
+    }
+    catch (error) {
+        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) {
+    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, config, cliOptions) {
+    const { locize: locizeConfig = {}, extract } = config;
+    const commandArgs = [command];
+    const projectId = cliOptions.projectId ?? locizeConfig.projectId;
+    if (projectId)
+        commandArgs.push('--project-id', projectId);
+    const apiKey = cliOptions.apiKey ?? locizeConfig.apiKey;
+    if (apiKey)
+        commandArgs.push('--api-key', apiKey);
+    const version = cliOptions.version ?? locizeConfig.version;
+    if (version)
+        commandArgs.push('--ver', version);
+    const cdnType = cliOptions.cdnType ?? locizeConfig.cdnType;
+    if (cdnType)
+        commandArgs.push('--cdn-type', cdnType);
+    // 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;
+    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(node_path.sep);
+            basePath = node_path.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 = node_path.resolve(process.cwd(), baseCandidate.split('/').join(node_path.sep));
+            }
+            catch {
+                basePath = node_path.resolve(process.cwd(), '.');
+            }
+        }
+        else {
+            basePath = node_path.resolve(process.cwd(), '.');
+        }
+    }
+    catch {
+        basePath = node_path.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, config, cliOptions = {}) {
+    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.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) {
+        const stderr = error.stderr || '';
+        if (stderr.includes('missing required argument')) {
+            // 2. Auth failure, trigger interactive setup
+            const newCredentials = await interactiveCredentialSetup();
+            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.execa('locize', retryArgs, { stdio: 'pipe' });
+                    spinner.succeed(chalk.green('Retry successful!'));
+                    if (result?.stdout)
+                        console.log(result.stdout);
+                }
+                catch (retryError) {
+                    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.`));
+}
+const runLocizeSync = (config, cliOptions) => runLocizeCommand('sync', config, cliOptions);
+const runLocizeDownload = (config, cliOptions) => runLocizeCommand('download', config, cliOptions);
+const runLocizeMigrate = (config, cliOptions) => runLocizeCommand('migrate', config, cliOptions);
+
+exports.runLocizeDownload = runLocizeDownload;
+exports.runLocizeMigrate = runLocizeMigrate;
+exports.runLocizeSync = runLocizeSync;

package/dist/cjs/migrator.js

@@ -1 +1,196 @@
-"use strict";var e=require("node:path"),t=require("node:fs/promises"),n=require("node:url"),o=require("jiti"),s=require("./config.js");const r=e.resolve(process.cwd(),"i18next.config.ts"),i=["i18next.config.ts","i18next.config.js","i18next.config.mjs","i18next.config.cjs"],a=[".js",".mjs",".cjs",".ts"];async function c(e){if(a.some(t=>e.endsWith(t)))try{return await t.access(e),e}catch{return null}for(const n of a){const o=`${e}${n}`;try{return await t.access(o),o}catch{}}return null}exports.runMigrator=async function(a){let l;if(a){if(l=await c(e.resolve(process.cwd(),a)),!l)return console.log(`No legacy config file found at or near: ${a}`),void console.log("Tried extensions: .js, .mjs, .cjs, .ts")}else if(l=await c(e.resolve(process.cwd(),"i18next-parser.config")),!l)return console.log("No i18next-parser.config.* found. Nothing to migrate."),void console.log("Tried: i18next-parser.config.js, .mjs, .cjs, .ts");console.log(`Attempting to migrate legacy config from: ${l}...`);for(const n of i)try{const o=e.resolve(process.cwd(),n);return await t.access(o),void console.warn(`Warning: A new configuration file already exists at "${n}". Migration skipped to avoid overwriting.`)}catch(e){}const f=await async function(e){try{let t;if(e.endsWith(".ts")){const n=await s.getTsConfigAliases(),r=o.createJiti(process.cwd(),{alias:n,interopDefault:!1});t=await r.import(e,{default:!0})}else{const o=n.pathToFileURL(e).href;t=(await import(`${o}?t=${Date.now()}`)).default}return t}catch(t){return console.error(`Error loading legacy config from ${e}:`,t),null}}(l);if(!f)return void console.error("Could not read the legacy config file.");const u={locales:f.locales||["en"],extract:{input:f.input||"src/**/*.{js,jsx,ts,tsx}",output:(f.output||"locales/$LOCALE/$NAMESPACE.json").replace("$LOCALE","{{language}}").replace("$NAMESPACE","{{namespace}}"),defaultNS:f.defaultNamespace||"translation",keySeparator:f.keySeparator,nsSeparator:f.namespaceSeparator,contextSeparator:f.contextSeparator,functions:f.lexers?.js?.functions||["t","*.t"],transComponents:f.lexers?.js?.components||["Trans"]},types:{input:["locales/{{language}}/{{namespace}}.json"],output:"src/types/i18next.d.ts"}};u.extract.functions.includes("t")&&!u.extract.functions.includes("*.t")&&u.extract.functions.push("*.t");const p=`\nimport { defineConfig } from 'i18next-cli';\n\nexport default defineConfig(${JSON.stringify(u,null,2)});\n`;await t.writeFile(r,p.trim()),console.log("✅ Success! Migration complete."),console.log(`New configuration file created at: ${r}`),console.warn('\nPlease review the generated file and adjust paths for "types.input" if necessary.'),f.keepRemoved&&console.warn('Warning: The "keepRemoved" option is deprecated. Consider using the "preservePatterns" feature for dynamic keys.'),"v3"===f.i18nextOptions?.compatibilityJSON&&console.warn('Warning: compatibilityJSON "v3" is not supported in i18next-cli. Only i18next v4 format is supported.')};
+'use strict';
+
+var node_path = require('node:path');
+var promises = require('node:fs/promises');
+var node_url = require('node:url');
+var jiti = require('jiti');
+var config = require('./config.js');
+
+/**
+ * Path where the new configuration file will be created
+ */
+const newConfigPath = node_path.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) {
+    // If the provided path already has an extension, use it directly
+    if (LEGACY_CONFIG_EXTENSIONS.some(ext => basePath.endsWith(ext))) {
+        try {
+            await promises.access(basePath);
+            return basePath;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Try different extensions
+    for (const ext of LEGACY_CONFIG_EXTENSIONS) {
+        const fullPath = `${basePath}${ext}`;
+        try {
+            await promises.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) {
+    try {
+        let config$1;
+        // Use jiti for TypeScript files, native import for JavaScript
+        if (configPath.endsWith('.ts')) {
+            const aliases = await config.getTsConfigAliases();
+            const jiti$1 = jiti.createJiti(process.cwd(), {
+                alias: aliases,
+                interopDefault: false,
+            });
+            const configModule = await jiti$1.import(configPath, { default: true });
+            config$1 = configModule;
+        }
+        else {
+            const configUrl = node_url.pathToFileURL(configPath).href;
+            const configModule = await import(`${configUrl}?t=${Date.now()}`);
+            config$1 = configModule.default;
+        }
+        return config$1;
+    }
+    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
+ * ```
+ */
+async function runMigrator(customConfigPath) {
+    let oldConfigPath;
+    if (customConfigPath) {
+        oldConfigPath = await findLegacyConfigFile(node_path.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(node_path.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 = node_path.resolve(process.cwd(), configFile);
+            await promises.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 promises.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.');
+    }
+}
+
+exports.runMigrator = runMigrator;