i18next-cli 1.33.5 → 1.34.1

package/dist/cjs/rename-key.js

@@ -1 +1,354 @@
-"use strict";var e=require("glob"),t=require("node:fs/promises"),n=require("./utils/logger.js"),r=require("./utils/file-utils.js"),o=require("node:path"),s=require("./utils/nested-object.js"),a=require("./utils/funnel-msg-tracker.js"),i=require("chalk");function c(e,t){const n=t.extract.nsSeparator??":";if(n&&e.includes(n)){const[t,...r]=e.split(n);return{namespace:t,key:r.join(n),fullKey:e}}return{namespace:t.extract.defaultNS||"translation",key:e,fullKey:e}}async function l(e,t,n,r){return function(e,t,n,r){let o=0,s=e;const a=r.extract.nsSeparator??":",i=e=>a&&e.includes(String(a))?n.fullKey:n.key,c=r.extract.functions||["t","*.t"],l=[];for(const e of c)if(e.startsWith("*.")){const n=u(e.substring(1));l.push({pattern:new RegExp(`\\w+${n}\\((['"\`])${u(t.fullKey)}\\1`,"g"),original:t.fullKey}),l.push({pattern:new RegExp(`\\w+${n}\\((['"\`])${u(t.key)}\\1`,"g"),original:t.key})}else{const n=u(e);l.push({pattern:new RegExp(`\\b${n}\\((['"\`])${u(t.fullKey)}\\1`,"g"),original:t.fullKey}),l.push({pattern:new RegExp(`\\b${n}\\((['"\`])${u(t.key)}\\1`,"g"),original:t.key})}for(const{pattern:e,original:t}of l)if(e.test(s)){const n=i(t);s=s.replace(e,(e,t)=>{o++;const r=e.match(/^(\w+(?:\.\w+)*)\(/);return r?`${r[1]}(${t}${n}${t}`:e})}for(const e of c){let n;if(e.startsWith("*.")){n=`\\w+${u(e.substring(1))}`}else n=u(e);for(const e of[t.fullKey,t.key]){const t=new RegExp(`(\\b${n}\\(\\s*\\(?\\s*([a-zA-Z_$][\\w$]*)\\s*\\)?\\s*=>\\s*)\\2\\.${u(e)}(\\s*\\))`,"g");if(t.test(s)){const n=i(e);s=s.replace(t,(e,t,r,s)=>(o++,`${t}${r}.${n}${s}`))}const r=new RegExp(`(\\b${n}\\(\\s*\\(?\\s*([a-zA-Z_$][\\w$]*)\\s*\\)?\\s*=>\\s*)\\2\\[\\s*(['"\`])${u(e)}\\3\\s*\\](\\s*\\))`,"g");if(r.test(s)){const t=i(e),n=e=>/^[A-Za-z_$][\w$]*$/.test(e);s=s.replace(r,(e,r,s,a,i)=>(o++,n(t)?`${r}${s}.${t}${i}`:`${r}${s}[${a}${t}${a}]${i}`))}}}const f=[{pattern:new RegExp(`i18nKey=(['"\`])${u(t.fullKey)}\\1`,"g"),original:t.fullKey},{pattern:new RegExp(`i18nKey=(['"\`])${u(t.key)}\\1`,"g"),original:t.key}];for(const{pattern:e,original:t}of f)if(e.test(s)){const n=i(t);s=s.replace(e,(e,t)=>(o++,`i18nKey=${t}${n}${t}`))}return{newCode:s,changes:o}}(e,t,n,r)}function u(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function f(e,t,n){if(!1===n)return void delete e[t];const r=t.split(String(n));let o=e;for(let e=0;e<r.length-1;e++){if(!o[r[e]])return;o=o[r[e]]}delete o[r[r.length-1]]}exports.runRenameKey=async function(u,g,p,y={},$=new n.ConsoleLogger){const{dryRun:d=!1}=y,w=function(e,t){if(!e||!e.trim())return{valid:!1,error:"Old key cannot be empty"};if(!t||!t.trim())return{valid:!1,error:"New key cannot be empty"};if(e===t)return{valid:!1,error:"Old and new keys are identical"};return{valid:!0}}(g,p);if(!w.valid)return{success:!1,sourceFiles:[],translationFiles:[],error:w.error};const h=c(g,u),m=c(p,u),x=await async function(e,t){const n=[];for(const a of t.locales){const i=r.getOutputPath(t.extract.output,a,e.namespace),c=o.resolve(process.cwd(),i);try{const o=await r.loadTranslationFile(c);if(o){const r=t.extract.keySeparator??".";void 0!==s.getNestedValue(o,e.key,r)&&n.push(`${a}:${e.fullKey}`)}}catch{}}return n}(m,u);if(x.length>0)return{success:!1,sourceFiles:[],translationFiles:[],conflicts:x,error:"Target key already exists in translation files"};$.info(`🔍 Scanning for usages of "${g}"...`);const k=await async function(n,r,o,s,a){const i=["node_modules/**"],c=Array.isArray(o.extract.ignore)?o.extract.ignore:o.extract.ignore?[o.extract.ignore]:[],u=Array.isArray(o.extract.input)?o.extract.input:[o.extract.input],f=u.map(e=>e.replace(/\\/g,"/")),g=await e.glob(f,{ignore:[...i,...c],cwd:process.cwd()}),p=[];for(const e of g){const i=await t.readFile(e,"utf-8"),{newCode:c,changes:u}=await l(i,n,r,o);u>0&&(s||await t.writeFile(e,c,"utf-8"),p.push({path:e,changes:u}),a.info(`   ${s?"(dry-run) ":""}✓ ${e} (${u} ${1===u?"change":"changes"})`))}p.length>0&&a.info(`\n📝 Source file changes: ${p.length} file${1===p.length?"":"s"}`);return p}(h,m,u,d,$),b=await async function(e,n,a,i,c){const l=[],u=a.extract.keySeparator??".";for(const g of a.locales){const p=r.getOutputPath(a.extract.output,g,e.namespace),y=o.resolve(process.cwd(),p);try{const o=await r.loadTranslationFile(y);if(!o)continue;const g=s.getNestedValue(o,e.key,u);if(void 0===g)continue;if(f(o,e.key,u),s.setNestedValue(o,n.key,g,u),!i){const e=r.serializeTranslationFile(o,a.extract.outputFormat,a.extract.indentation);await t.writeFile(y,e,"utf-8")}l.push({path:y,updated:!0}),c.info(`   ${i?"(dry-run) ":""}✓ ${y}`)}catch(e){}}l.length>0&&c.info(`\n📦 Translation file updates: ${l.length} file${1===l.length?"":"s"}`);return l}(h,m,u,d,$),F=k.reduce((e,t)=>e+t.changes,0);return!d&&F>0?($.info("\n✨ Successfully renamed key!"),$.info(`   Old: "${g}"`),$.info(`   New: "${p}"`),await async function(){if(!await a.shouldShowFunnel("rename-key"))return;return console.log(i.yellow.bold("\n💡 Tip: Managing translations across multiple projects?")),console.log("   With locize, you can rename, move, and copy translation keys directly"),console.log("   in the web interface—no CLI needed. Perfect for collaboration with"),console.log("   translators and managing complex refactoring across namespaces."),console.log(`   Learn more: ${i.cyan("https://www.locize.com/docs/how-can-a-segment-key-be-copied-moved-or-renamed")}`),a.recordFunnelShown("rename-key")}()):0===F&&$.info(`\n⚠️  No usages found for "${g}"`),{success:!0,sourceFiles:k,translationFiles:b}};
+'use strict';
+
+var glob = require('glob');
+var promises = require('node:fs/promises');
+var logger = require('./utils/logger.js');
+var fileUtils = require('./utils/file-utils.js');
+var node_path = require('node:path');
+var nestedObject = require('./utils/nested-object.js');
+var funnelMsgTracker = require('./utils/funnel-msg-tracker.js');
+var chalk = require('chalk');
+
+/**
+ * Renames a translation key across all source files and translation files.
+ *
+ * This function performs a comprehensive key rename operation:
+ * 1. Validates the old and new key names
+ * 2. Checks for conflicts in translation files
+ * 3. Updates all occurrences in source code (AST-based)
+ * 4. Updates all translation files for all locales
+ * 5. Preserves the original translation values
+ *
+ * @param config - The i18next toolkit configuration
+ * @param oldKey - The current key to rename (may include namespace prefix)
+ * @param newKey - The new key name (may include namespace prefix)
+ * @param options - Rename options (dry-run mode, etc.)
+ * @param logger - Logger instance for output
+ * @returns Result object with update status and file lists
+ *
+ * @example
+ * ```typescript
+ * // Basic rename
+ * const result = await runRenameKey(config, 'old.key', 'new.key')
+ *
+ * // With namespace
+ * const result = await runRenameKey(config, 'common:button.submit', 'common:button.save')
+ *
+ * // Dry run to preview changes
+ * const result = await runRenameKey(config, 'old.key', 'new.key', { dryRun: true })
+ * ```
+ */
+async function runRenameKey(config, oldKey, newKey, options = {}, logger$1 = new logger.ConsoleLogger()) {
+    const { dryRun = false } = options;
+    // Validate keys
+    const validation = validateKeys(oldKey, newKey);
+    if (!validation.valid) {
+        return {
+            success: false,
+            sourceFiles: [],
+            translationFiles: [],
+            error: validation.error
+        };
+    }
+    // Parse namespace from keys
+    const oldParts = parseKeyWithNamespace(oldKey, config);
+    const newParts = parseKeyWithNamespace(newKey, config);
+    // Check for conflicts in translation files
+    const conflicts = await checkConflicts(newParts, config);
+    if (conflicts.length > 0) {
+        return {
+            success: false,
+            sourceFiles: [],
+            translationFiles: [],
+            conflicts,
+            error: 'Target key already exists in translation files'
+        };
+    }
+    logger$1.info(`🔍 Scanning for usages of "${oldKey}"...`);
+    // Find and update source files
+    const sourceResults = await updateSourceFiles(oldParts, newParts, config, dryRun, logger$1);
+    // Update translation files
+    const translationResults = await updateTranslationFiles(oldParts, newParts, config, dryRun, logger$1);
+    const totalChanges = sourceResults.reduce((sum, r) => sum + r.changes, 0);
+    if (!dryRun && totalChanges > 0) {
+        logger$1.info('\n✨ Successfully renamed key!');
+        logger$1.info(`   Old: "${oldKey}"`);
+        logger$1.info(`   New: "${newKey}"`);
+        // Show locize funnel after successful rename
+        await printLocizeFunnel();
+    }
+    else if (totalChanges === 0) {
+        logger$1.info(`\n⚠️  No usages found for "${oldKey}"`);
+    }
+    return {
+        success: true,
+        sourceFiles: sourceResults,
+        translationFiles: translationResults
+    };
+}
+/**
+ * Prints a promotional message for the locize rename/move workflow.
+ * This message is shown after a successful key rename operation.
+ */
+async function printLocizeFunnel() {
+    if (!(await funnelMsgTracker.shouldShowFunnel('rename-key')))
+        return;
+    console.log(chalk.yellow.bold('\n💡 Tip: Managing translations across multiple projects?'));
+    console.log('   With locize, you can rename, move, and copy translation keys directly');
+    console.log('   in the web interface—no CLI needed. Perfect for collaboration with');
+    console.log('   translators and managing complex refactoring across namespaces.');
+    console.log(`   Learn more: ${chalk.cyan('https://www.locize.com/docs/how-can-a-segment-key-be-copied-moved-or-renamed')}`);
+    return funnelMsgTracker.recordFunnelShown('rename-key');
+}
+function parseKeyWithNamespace(key, config) {
+    const nsSeparator = config.extract.nsSeparator ?? ':';
+    if (nsSeparator && key.includes(nsSeparator)) {
+        const [ns, ...rest] = key.split(nsSeparator);
+        return {
+            namespace: ns,
+            key: rest.join(nsSeparator),
+            fullKey: key
+        };
+    }
+    return {
+        namespace: config.extract.defaultNS || 'translation',
+        key,
+        fullKey: key
+    };
+}
+function validateKeys(oldKey, newKey, config) {
+    if (!oldKey || !oldKey.trim()) {
+        return { valid: false, error: 'Old key cannot be empty' };
+    }
+    if (!newKey || !newKey.trim()) {
+        return { valid: false, error: 'New key cannot be empty' };
+    }
+    if (oldKey === newKey) {
+        return { valid: false, error: 'Old and new keys are identical' };
+    }
+    return { valid: true };
+}
+async function checkConflicts(newParts, config) {
+    const conflicts = [];
+    for (const locale of config.locales) {
+        const outputPath = fileUtils.getOutputPath(config.extract.output, locale, newParts.namespace);
+        const fullPath = node_path.resolve(process.cwd(), outputPath);
+        try {
+            const existingTranslations = await fileUtils.loadTranslationFile(fullPath);
+            if (existingTranslations) {
+                const keySeparator = config.extract.keySeparator ?? '.';
+                const value = nestedObject.getNestedValue(existingTranslations, newParts.key, keySeparator);
+                if (value !== undefined) {
+                    conflicts.push(`${locale}:${newParts.fullKey}`);
+                }
+            }
+        }
+        catch {
+            // File doesn't exist, no conflict
+        }
+    }
+    return conflicts;
+}
+async function updateSourceFiles(oldParts, newParts, config, dryRun, logger) {
+    const defaultIgnore = ['node_modules/**'];
+    const userIgnore = Array.isArray(config.extract.ignore)
+        ? config.extract.ignore
+        : config.extract.ignore ? [config.extract.ignore] : [];
+    // Normalize input patterns for cross-platform compatibility
+    const inputPatterns = Array.isArray(config.extract.input)
+        ? config.extract.input
+        : [config.extract.input];
+    const normalizedPatterns = inputPatterns.map(pattern => pattern.replace(/\\/g, '/'));
+    const sourceFiles = await glob.glob(normalizedPatterns, {
+        ignore: [...defaultIgnore, ...userIgnore],
+        cwd: process.cwd()
+    });
+    const results = [];
+    for (const file of sourceFiles) {
+        const code = await promises.readFile(file, 'utf-8');
+        const { newCode, changes } = await replaceKeyInSource(code, oldParts, newParts, config);
+        if (changes > 0) {
+            if (!dryRun) {
+                await promises.writeFile(file, newCode, 'utf-8');
+            }
+            results.push({ path: file, changes });
+            logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${file} (${changes} ${changes === 1 ? 'change' : 'changes'})`);
+        }
+    }
+    if (results.length > 0) {
+        logger.info(`\n📝 Source file changes: ${results.length} file${results.length === 1 ? '' : 's'}`);
+    }
+    return results;
+}
+async function replaceKeyInSource(code, oldParts, newParts, config) {
+    // Use regex-based replacement which is more reliable than AST manipulation
+    return replaceKeyWithRegex(code, oldParts, newParts, config);
+}
+function replaceKeyWithRegex(code, oldParts, newParts, config) {
+    let changes = 0;
+    let newCode = code;
+    const nsSeparator = config.extract.nsSeparator ?? ':';
+    // Helper to determine which key form to use in replacement
+    const getReplacementKey = (originalKey) => {
+        const hasNamespace = nsSeparator && originalKey.includes(String(nsSeparator));
+        return hasNamespace ? newParts.fullKey : newParts.key;
+    };
+    // Pattern 1: Function calls - respect configured functions
+    const configuredFunctions = config.extract.functions || ['t', '*.t'];
+    const functionPatterns = [];
+    for (const fnPattern of configuredFunctions) {
+        if (fnPattern.startsWith('*.')) {
+            // Wildcard pattern like '*.t' - match any prefix
+            const suffix = fnPattern.substring(1); // '.t'
+            const escapedSuffix = escapeRegex(suffix);
+            // Match: anyIdentifier.t('key')
+            functionPatterns.push({
+                pattern: new RegExp(`\\w+${escapedSuffix}\\((['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g'),
+                original: oldParts.fullKey
+            });
+            functionPatterns.push({
+                pattern: new RegExp(`\\w+${escapedSuffix}\\((['"\`])${escapeRegex(oldParts.key)}\\1`, 'g'),
+                original: oldParts.key
+            });
+        }
+        else {
+            // Exact function name
+            const escapedFn = escapeRegex(fnPattern);
+            functionPatterns.push({
+                pattern: new RegExp(`\\b${escapedFn}\\((['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g'),
+                original: oldParts.fullKey
+            });
+            functionPatterns.push({
+                pattern: new RegExp(`\\b${escapedFn}\\((['"\`])${escapeRegex(oldParts.key)}\\1`, 'g'),
+                original: oldParts.key
+            });
+        }
+    }
+    for (const { pattern, original } of functionPatterns) {
+        if (pattern.test(newCode)) {
+            const replacement = getReplacementKey(original);
+            newCode = newCode.replace(pattern, (match, quote) => {
+                changes++;
+                // Preserve the function name part, only replace the key
+                const functionNameMatch = match.match(/^(\w+(?:\.\w+)*)\(/);
+                if (functionNameMatch) {
+                    return `${functionNameMatch[1]}(${quote}${replacement}${quote}`;
+                }
+                return match;
+            });
+        }
+    }
+    // Pattern 2: Selector API arrow functions (e.g. t(($) => $.old.key) or i18n.t($ => $.old.key))
+    // Respect configured function names (including wildcard patterns)
+    for (const fnPattern of configuredFunctions) {
+        // Build a regex prefix for the function invocation (handles wildcard '*.t' -> '\w+\.t')
+        let patternPrefix;
+        if (fnPattern.startsWith('*.')) {
+            const suffix = fnPattern.substring(1); // '.t'
+            patternPrefix = `\\w+${escapeRegex(suffix)}`;
+        }
+        else {
+            patternPrefix = escapeRegex(fnPattern);
+        }
+        // Try matching both the plain key and the ns-prefixed fullKey used in selector access
+        for (const original of [oldParts.fullKey, oldParts.key]) {
+            // Match dot-notation selector forms like:
+            // t(($) => $.old.key)
+            // i18n.t($ => $.old.key.nested)
+            const selectorDotRegex = new RegExp(`(\\b${patternPrefix}\\(\\s*\\(?\\s*([a-zA-Z_$][\\w$]*)\\s*\\)?\\s*=>\\s*)\\2\\.${escapeRegex(original)}(\\s*\\))`, 'g');
+            if (selectorDotRegex.test(newCode)) {
+                const replacementKey = getReplacementKey(original);
+                newCode = newCode.replace(selectorDotRegex, (match, prefix, param, suffix) => {
+                    changes++;
+                    // Replace property chain with dot-notation replacement
+                    return `${prefix}${param}.${replacementKey}${suffix}`;
+                });
+            }
+            // Match bracket-notation selector forms like:
+            // t(($) => $["Old Key"])
+            const selectorBracketRegex = new RegExp(`(\\b${patternPrefix}\\(\\s*\\(?\\s*([a-zA-Z_$][\\w$]*)\\s*\\)?\\s*=>\\s*)\\2\\[\\s*(['"\`])${escapeRegex(original)}\\3\\s*\\](\\s*\\))`, 'g');
+            if (selectorBracketRegex.test(newCode)) {
+                const replacementKey = getReplacementKey(original);
+                const isIdentifier = (s) => /^[A-Za-z_$][\w$]*$/.test(s);
+                newCode = newCode.replace(selectorBracketRegex, (match, prefix, param, quote, suffix) => {
+                    changes++;
+                    // If the replacement is a valid identifier, convert to dot-notation, otherwise keep bracket-notation
+                    if (isIdentifier(replacementKey)) {
+                        return `${prefix}${param}.${replacementKey}${suffix}`;
+                    }
+                    return `${prefix}${param}[${quote}${replacementKey}${quote}]${suffix}`;
+                });
+            }
+        }
+    }
+    // Pattern 3: JSX i18nKey attribute - respect configured transComponents
+    // const transComponents = config.extract.transComponents || ['Trans']
+    // Create a pattern that matches i18nKey on any of the configured components
+    // This is a simplified approach - for more complex cases, consider AST-based replacement
+    const i18nKeyPatterns = [
+        { pattern: new RegExp(`i18nKey=(['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g'), original: oldParts.fullKey },
+        { pattern: new RegExp(`i18nKey=(['"\`])${escapeRegex(oldParts.key)}\\1`, 'g'), original: oldParts.key }
+    ];
+    for (const { pattern, original } of i18nKeyPatterns) {
+        if (pattern.test(newCode)) {
+            const replacement = getReplacementKey(original);
+            newCode = newCode.replace(pattern, (match, quote) => {
+                changes++;
+                return `i18nKey=${quote}${replacement}${quote}`;
+            });
+        }
+    }
+    return { newCode, changes };
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+async function updateTranslationFiles(oldParts, newParts, config, dryRun, logger) {
+    const results = [];
+    const keySeparator = config.extract.keySeparator ?? '.';
+    for (const locale of config.locales) {
+        const outputPath = fileUtils.getOutputPath(config.extract.output, locale, oldParts.namespace);
+        const fullPath = node_path.resolve(process.cwd(), outputPath);
+        try {
+            const translations = await fileUtils.loadTranslationFile(fullPath);
+            if (!translations)
+                continue;
+            const oldValue = nestedObject.getNestedValue(translations, oldParts.key, keySeparator);
+            if (oldValue === undefined)
+                continue;
+            // Remove old key
+            deleteNestedValue(translations, oldParts.key, keySeparator);
+            // Add new key with same value
+            nestedObject.setNestedValue(translations, newParts.key, oldValue, keySeparator);
+            if (!dryRun) {
+                const content = fileUtils.serializeTranslationFile(translations, config.extract.outputFormat, config.extract.indentation);
+                await promises.writeFile(fullPath, content, 'utf-8');
+            }
+            results.push({ path: fullPath, updated: true });
+            logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${fullPath}`);
+        }
+        catch (error) {
+            // File doesn't exist or couldn't be processed
+        }
+    }
+    if (results.length > 0) {
+        logger.info(`\n📦 Translation file updates: ${results.length} file${results.length === 1 ? '' : 's'}`);
+    }
+    return results;
+}
+function deleteNestedValue(obj, path, separator) {
+    if (separator === false) {
+        delete obj[path];
+        return;
+    }
+    const keys = path.split(String(separator));
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        if (!current[keys[i]])
+            return;
+        current = current[keys[i]];
+    }
+    delete current[keys[keys.length - 1]];
+}
+
+exports.runRenameKey = runRenameKey;