i18next-cli 1.33.5 → 1.34.1

package/dist/esm/locize.js

@@ -1 +1,265 @@
-import{execa as e}from"execa";import o from"chalk";import t from"ora";import n from"inquirer";import{sep as r,resolve as s}from"node:path";function i(e,o,t){const{locize:n={},extract:i}=o,{projectId:c,apiKey:a,version:l}=n,u=[e];if(c&&u.push("--project-id",c),a&&u.push("--api-key",a),l&&u.push("--ver",l),"sync"===e){(t.updateValues??n.updateValues)&&u.push("--update-values","true");(t.srcLngOnly??n.sourceLanguageOnly)&&u.push("--reference-language-only","true");(t.compareMtime??n.compareModificationTime)&&u.push("--compare-modification-time","true");const e=t.cdnType??n.cdnType;e&&u.push("--cdn-type",e);(t.dryRun??n.dryRun)&&u.push("--dry","true")}let p;try{if("string"==typeof i.output){const e=i.output.replace(/\\/g,"/"),o=(e.includes("/{{language}}/")?e.split("/{{language}}/")[0]:e.replace("{{language}}","")).split("/").join(r);p=s(process.cwd(),o)}else if("function"==typeof i.output)try{const e=i.output(o.extract.primaryLanguage||"en"),t=String(e).replace(/\\/g,"/"),n=t.includes("/"+(o.extract.primaryLanguage||"en")+"/")?t.split("/"+(o.extract.primaryLanguage||"en")+"/")[0]:t.replace(o.extract.primaryLanguage||"en","");p=s(process.cwd(),n.split("/").join(r))}catch{p=s(process.cwd(),".")}else p=s(process.cwd(),".")}catch{p=s(process.cwd(),".")}return u.push("--path",p),u}async function c(r,s,c={}){await async function(){try{await e("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=t(`Running 'locize ${r}'...\n`).start();let l=s;try{const t=i(r,l,c);console.log(o.cyan(`\nRunning 'locize ${t.join(" ")}'...`));const n=await e("locize",t,{stdio:"pipe"});a.succeed(o.green(`'locize ${r}' completed successfully.`)),n?.stdout&&console.log(n.stdout)}catch(t){const s=t.stderr||"";if(s.includes("missing required argument")){const t=await async function(){console.log(o.yellow("\nLocize configuration is missing or invalid. Let's set it up!"));const e=await n.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:t}=await n.prompt([{type:"confirm",name:"save",message:"Would you like to see how to save these credentials for future use?",default:!0}]);if(t){const t=`\n# Add this to your .env file (and ensure .env is in your .gitignore!)\nLOCIZE_API_KEY=${e.apiKey}\n`,n=`\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(t)),console.log(o.bold("Then, in your i18next.config.ts:")),console.log(o.green(n))}return{projectId:e.projectId,apiKey:e.apiKey,version:e.version}}();if(t){l={...l,locize:t},a.start("Retrying with new credentials...");try{const t=i(r,l,c);console.log(o.cyan(`\nRunning 'locize ${t.join(" ")}'...`));const n=await e("locize",t,{stdio:"pipe"});a.succeed(o.green("Retry successful!")),n?.stdout&&console.log(n.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(s||t.message),process.exit(1)}console.log(o.green(`\n✅ 'locize ${r}' completed successfully.`))}const a=(e,o)=>c("sync",e,o),l=(e,o)=>c("download",e,o),u=(e,o)=>c("migrate",e,o);export{l as runLocizeDownload,u as runLocizeMigrate,a as runLocizeSync};
+import { execa } from 'execa';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { sep, resolve } from '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('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(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, 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('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('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);
+
+export { runLocizeDownload, runLocizeMigrate, runLocizeSync };

package/dist/esm/migrator.js

@@ -1 +1,194 @@
-import{resolve as e}from"node:path";import{access as t,writeFile as o}from"node:fs/promises";import{pathToFileURL as n}from"node:url";import{createJiti as i}from"jiti";import{getTsConfigAliases as r}from"./config.js";const s=e(process.cwd(),"i18next.config.ts"),a=["i18next.config.ts","i18next.config.js","i18next.config.mjs","i18next.config.cjs"],c=[".js",".mjs",".cjs",".ts"];async function l(e){if(c.some(t=>e.endsWith(t)))try{return await t(e),e}catch{return null}for(const o of c){const n=`${e}${o}`;try{return await t(n),n}catch{}}return null}async function f(c){let f;if(c){if(f=await l(e(process.cwd(),c)),!f)return console.log(`No legacy config file found at or near: ${c}`),void console.log("Tried extensions: .js, .mjs, .cjs, .ts")}else if(f=await l(e(process.cwd(),"i18next-parser.config")),!f)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: ${f}...`);for(const o of a)try{const n=e(process.cwd(),o);return await t(n),void console.warn(`Warning: A new configuration file already exists at "${o}". Migration skipped to avoid overwriting.`)}catch(e){}const p=await async function(e){try{let t;if(e.endsWith(".ts")){const o=await r(),n=i(process.cwd(),{alias:o,interopDefault:!1});t=await n.import(e,{default:!0})}else{const o=n(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}}(f);if(!p)return void console.error("Could not read the legacy config file.");const u={locales:p.locales||["en"],extract:{input:p.input||"src/**/*.{js,jsx,ts,tsx}",output:(p.output||"locales/$LOCALE/$NAMESPACE.json").replace("$LOCALE","{{language}}").replace("$NAMESPACE","{{namespace}}"),defaultNS:p.defaultNamespace||"translation",keySeparator:p.keySeparator,nsSeparator:p.namespaceSeparator,contextSeparator:p.contextSeparator,functions:p.lexers?.js?.functions||["t","*.t"],transComponents:p.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 d=`\nimport { defineConfig } from 'i18next-cli';\n\nexport default defineConfig(${JSON.stringify(u,null,2)});\n`;await o(s,d.trim()),console.log("✅ Success! Migration complete."),console.log(`New configuration file created at: ${s}`),console.warn('\nPlease review the generated file and adjust paths for "types.input" if necessary.'),p.keepRemoved&&console.warn('Warning: The "keepRemoved" option is deprecated. Consider using the "preservePatterns" feature for dynamic keys.'),"v3"===p.i18nextOptions?.compatibilityJSON&&console.warn('Warning: compatibilityJSON "v3" is not supported in i18next-cli. Only i18next v4 format is supported.')}export{f as runMigrator};
+import { resolve } from 'node:path';
+import { access, writeFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import { createJiti } from 'jiti';
+import { getTsConfigAliases } from './config.js';
+
+/**
+ * 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) {
+    // 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) {
+    try {
+        let config;
+        // 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
+ * ```
+ */
+async function runMigrator(customConfigPath) {
+    let oldConfigPath;
+    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.');
+    }
+}
+
+export { runMigrator };