i18next-cli 1.39.12 → 1.40.0

package/dist/cjs/cli.js

@@ -28,7 +28,7 @@ const program = new commander.Command();
 program
     .name('i18next-cli')
     .description('A unified, high-performance i18next CLI.')
-    .version('1.39.12'); // This string is replaced with the actual version at build time by rollup
+    .version('1.40.0'); // This string is replaced with the actual version at build time by rollup
 // new: global config override option
 program.option('-c, --config <path>', 'Path to i18next-cli config file (overrides detection)');
 program

package/dist/cjs/rename-key.js

@@ -78,9 +78,9 @@ async function runRenameKey(config, oldKey, newKey, options = {}, logger$1 = new
     const namespaceKeyMap = await buildNamespaceKeyMap(config);
     logger$1.info(`🔍 Scanning for usages of "${oldKey}"...`);
     // Find and update source files
-    const sourceResults = await updateSourceFiles(oldParts, newParts, config, dryRun, logger$1, namespaceKeyMap);
+    const sourceResults = await updateSourceFiles(oldParts, newParts, config, dryRun, namespaceKeyMap, logger$1);
     // Update translation files
-    const translationResults = await updateTranslationFiles(oldParts, newParts, config, dryRun, logger$1);
+    const translationResults = await updateTranslationFiles(oldParts, newParts, config, dryRun, namespaceKeyMap, logger$1);
     const totalChanges = sourceResults.reduce((sum, r) => sum + r.changes, 0);
     if (!dryRun && totalChanges > 0) {
         logger$1.info('\n✨ Successfully renamed key!');
@@ -229,7 +229,7 @@ async function buildNamespaceKeyMap(config) {
     }
     return map;
 }
-async function updateSourceFiles(oldParts, newParts, config, dryRun, logger, namespaceKeyMap) {
+async function updateSourceFiles(oldParts, newParts, config, dryRun, namespaceKeyMap, logger) {
     const defaultIgnore = ['node_modules/**'];
     const userIgnore = Array.isArray(config.extract.ignore)
         ? config.extract.ignore
@@ -283,7 +283,26 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
         if (!ns)
             return false;
         const set = namespaceKeyMap.get(ns);
-        return !!(set && set.has(oldParts.key));
+        if (!set)
+            return false;
+        // exact key match
+        if (set.has(oldParts.key))
+            return true;
+        // nested keys using keySeparator, e.g. "key.one", "key.other"
+        const keySeparator = config.extract.keySeparator ?? '.';
+        const nestedPrefix = `${oldParts.key}${String(keySeparator)}`;
+        for (const s of set) {
+            if (s.startsWith(nestedPrefix))
+                return true;
+        }
+        // flat plural keys like "key_one", "key_other"
+        const pluralSuffixes = ['zero', 'one', 'two', 'few', 'many', 'other'];
+        const flatPluralRegex = new RegExp(`^${escapeRegex(oldParts.key)}_(${pluralSuffixes.join('|')})$`);
+        for (const s of set) {
+            if (flatPluralRegex.test(s))
+                return true;
+        }
+        return false;
     };
     for (const fnPattern of configuredFunctions) {
         const prefix = fnPrefixToRegex(fnPattern);
@@ -505,60 +524,177 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
 function escapeRegex(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-async function updateTranslationFiles(oldParts, newParts, config, dryRun, logger) {
+async function updateTranslationFiles(oldParts, newParts, config, dryRun, namespaceKeyMap, logger) {
     const results = [];
     const keySeparator = config.extract.keySeparator ?? '.';
-    for (const locale of config.locales) {
-        const oldOutputPath = fileUtils.getOutputPath(config.extract.output, locale, oldParts.namespace);
-        const oldFullPath = node_path.resolve(process.cwd(), oldOutputPath);
-        const newOutputPath = fileUtils.getOutputPath(config.extract.output, locale, newParts.namespace);
-        const newFullPath = node_path.resolve(process.cwd(), newOutputPath);
-        let oldTranslations;
-        let newTranslations;
-        try {
-            oldTranslations = await fileUtils.loadTranslationFile(oldFullPath);
+    // plural suffixes commonly used by i18next (for flat underscore style: key_one)
+    const pluralSuffixes = ['zero', 'one', 'two', 'few', 'many', 'other'];
+    // Helper: determine whether a flattened key-set indicates presence of `baseKey`.
+    const namespaceHasKey = (set, baseKey) => {
+        if (!set)
+            return false;
+        // exact key (for scalar or object)
+        if (set.has(baseKey))
+            return true;
+        // nested keys using keySeparator, e.g. "key.one", "key.other"
+        const nestedPrefix = `${baseKey}${String(keySeparator)}`;
+        for (const s of set) {
+            if (s.startsWith(nestedPrefix))
+                return true;
         }
-        catch { }
-        if (!oldTranslations)
-            continue;
-        const oldValue = nestedObject.getNestedValue(oldTranslations, oldParts.key, keySeparator);
-        if (oldValue === undefined)
-            continue;
-        if (oldParts.namespace === newParts.namespace) {
-            // Rename within the same namespace
-            deleteNestedValue(oldTranslations, oldParts.key, keySeparator);
-            nestedObject.setNestedValue(oldTranslations, newParts.key, oldValue, keySeparator);
-            if (!dryRun) {
-                const content = fileUtils.serializeTranslationFile(oldTranslations, config.extract.outputFormat, config.extract.indentation);
-                await promises.writeFile(oldFullPath, content, 'utf-8');
-            }
-            results.push({ path: oldFullPath, updated: true });
-            logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${oldFullPath}`);
+        // flat plural keys like "key_one", "key_other"
+        const flatPluralRegex = new RegExp(`^${escapeRegex(baseKey)}_(${pluralSuffixes.join('|')})$`);
+        for (const s of set) {
+            if (flatPluralRegex.test(s))
+                return true;
         }
-        else {
-            // Move across namespaces
-            // Remove from old namespace
-            deleteNestedValue(oldTranslations, oldParts.key, keySeparator);
-            if (!dryRun) {
-                const content = fileUtils.serializeTranslationFile(oldTranslations, config.extract.outputFormat, config.extract.indentation);
-                await promises.writeFile(oldFullPath, content, 'utf-8');
-            }
-            results.push({ path: oldFullPath, updated: true });
-            logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${oldFullPath}`);
-            // Add to new namespace
+        return false;
+    };
+    // Decide candidate namespaces to inspect:
+    // - If the old key was explicitly namespaced in the CLI (oldParts.explicitNamespace),
+    //   we only inspect that namespace.
+    // - Otherwise, inspect every namespace that appears to contain the key (from namespaceKeyMap).
+    const candidateNamespaces = [];
+    if (oldParts.explicitNamespace && oldParts.namespace) {
+        candidateNamespaces.push(oldParts.namespace);
+    }
+    else {
+        for (const [ns, set] of namespaceKeyMap.entries()) {
+            if (namespaceHasKey(set, oldParts.key))
+                candidateNamespaces.push(ns);
+        }
+    }
+    // if nothing found, nothing to do
+    if (candidateNamespaces.length === 0) {
+        return results;
+    }
+    // Iterate each locale and each candidate source namespace found
+    for (const locale of config.locales) {
+        for (const ns of candidateNamespaces) {
+            const oldOutputPath = fileUtils.getOutputPath(config.extract.output, locale, ns);
+            const oldFullPath = node_path.resolve(process.cwd(), oldOutputPath);
+            // When explicitly targeting a namespace in the CLI, always use that target.
+            // When not explicit, keep keys in their current namespace (don't move them).
+            const targetNamespace = (oldParts.explicitNamespace || newParts.explicitNamespace)
+                ? newParts.namespace
+                : ns;
+            const newOutputPath = fileUtils.getOutputPath(config.extract.output, locale, targetNamespace);
+            const newFullPath = node_path.resolve(process.cwd(), newOutputPath);
+            let oldTranslations;
+            let newTranslations;
             try {
-                newTranslations = await fileUtils.loadTranslationFile(newFullPath);
+                oldTranslations = await fileUtils.loadTranslationFile(oldFullPath);
             }
             catch { }
-            if (!newTranslations)
-                newTranslations = {};
-            nestedObject.setNestedValue(newTranslations, newParts.key, oldValue, keySeparator);
-            if (!dryRun) {
-                const content = fileUtils.serializeTranslationFile(newTranslations, config.extract.outputFormat, config.extract.indentation);
-                await promises.writeFile(newFullPath, content, 'utf-8');
+            if (!oldTranslations)
+                continue;
+            // 1) nested/exact path value (object or scalar) at the nested path
+            const oldValue = nestedObject.getNestedValue(oldTranslations, oldParts.key, keySeparator);
+            // 2) flat plural matches like `key_one`, `key_other`
+            const flatPluralMatches = [];
+            if (oldTranslations && typeof oldTranslations === 'object') {
+                const re = new RegExp(`^${escapeRegex(oldParts.key)}_(${pluralSuffixes.join('|')})$`);
+                for (const k of Object.keys(oldTranslations)) {
+                    const m = k.match(re);
+                    if (m)
+                        flatPluralMatches.push({ flatKey: k, suffix: m[1], value: oldTranslations[k] });
+                }
+            }
+            // nothing found for this file/namespace
+            if (oldValue === undefined && flatPluralMatches.length === 0)
+                continue;
+            //
+            // Handle flat plurals first (top-level underscore keys)
+            //
+            if (flatPluralMatches.length > 0) {
+                if (ns === targetNamespace) {
+                    // rename in-place within same file
+                    for (const m of flatPluralMatches) {
+                        delete oldTranslations[m.flatKey];
+                        const newFlatKey = `${newParts.key}_${m.suffix}`;
+                        oldTranslations[newFlatKey] = m.value;
+                    }
+                    if (!dryRun) {
+                        const content = fileUtils.serializeTranslationFile(oldTranslations, config.extract.outputFormat, config.extract.indentation);
+                        await promises.writeFile(oldFullPath, content, 'utf-8');
+                    }
+                    results.push({ path: oldFullPath, updated: true });
+                    logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${oldFullPath}`);
+                }
+                else {
+                    // move them to the new namespace file
+                    for (const m of flatPluralMatches)
+                        delete oldTranslations[m.flatKey];
+                    if (!dryRun) {
+                        const contentOld = fileUtils.serializeTranslationFile(oldTranslations, config.extract.outputFormat, config.extract.indentation);
+                        await promises.writeFile(oldFullPath, contentOld, 'utf-8');
+                    }
+                    results.push({ path: oldFullPath, updated: true });
+                    logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${oldFullPath}`);
+                    try {
+                        newTranslations = await fileUtils.loadTranslationFile(newFullPath);
+                    }
+                    catch { }
+                    if (!newTranslations)
+                        newTranslations = {};
+                    for (const m of flatPluralMatches) {
+                        const newFlatKey = `${newParts.key}_${m.suffix}`;
+                        newTranslations[newFlatKey] = m.value;
+                    }
+                    if (!dryRun) {
+                        const contentNew = fileUtils.serializeTranslationFile(newTranslations, config.extract.outputFormat, config.extract.indentation);
+                        await promises.writeFile(newFullPath, contentNew, 'utf-8');
+                    }
+                    results.push({ path: newFullPath, updated: true });
+                    logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${newFullPath}`);
+                }
+            }
+            //
+            // Handle nested/exact key
+            //
+            if (oldValue !== undefined) {
+                if (ns === targetNamespace) {
+                    // rename within same file (nested)
+                    deleteNestedValue(oldTranslations, oldParts.key, keySeparator);
+                    nestedObject.setNestedValue(oldTranslations, newParts.key, oldValue, keySeparator);
+                    if (!dryRun) {
+                        const content = fileUtils.serializeTranslationFile(oldTranslations, config.extract.outputFormat, config.extract.indentation);
+                        await promises.writeFile(oldFullPath, content, 'utf-8');
+                    }
+                    if (!results.find(r => r.path === oldFullPath)) {
+                        results.push({ path: oldFullPath, updated: true });
+                        logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${oldFullPath}`);
+                    }
+                }
+                else {
+                    // move nested value across namespaces
+                    const updatedOld = { ...oldTranslations };
+                    deleteNestedValue(updatedOld, oldParts.key, keySeparator);
+                    if (!dryRun) {
+                        const contentOld = fileUtils.serializeTranslationFile(updatedOld, config.extract.outputFormat, config.extract.indentation);
+                        await promises.writeFile(oldFullPath, contentOld, 'utf-8');
+                    }
+                    if (!results.find(r => r.path === oldFullPath)) {
+                        results.push({ path: oldFullPath, updated: true });
+                        logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${oldFullPath}`);
+                    }
+                    try {
+                        newTranslations = await fileUtils.loadTranslationFile(newFullPath);
+                    }
+                    catch { }
+                    if (!newTranslations)
+                        newTranslations = {};
+                    nestedObject.setNestedValue(newTranslations, newParts.key, oldValue, keySeparator);
+                    if (!dryRun) {
+                        const contentNew = fileUtils.serializeTranslationFile(newTranslations, config.extract.outputFormat, config.extract.indentation);
+                        await promises.writeFile(newFullPath, contentNew, 'utf-8');
+                    }
+                    if (!results.find(r => r.path === newFullPath)) {
+                        results.push({ path: newFullPath, updated: true });
+                        logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${newFullPath}`);
+                    }
+                }
             }
-            results.push({ path: newFullPath, updated: true });
-            logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${newFullPath}`);
         }
     }
     if (results.length > 0) {

package/dist/esm/cli.js

@@ -26,7 +26,7 @@ const program = new Command();
 program
     .name('i18next-cli')
     .description('A unified, high-performance i18next CLI.')
-    .version('1.39.12'); // This string is replaced with the actual version at build time by rollup
+    .version('1.40.0'); // This string is replaced with the actual version at build time by rollup
 // new: global config override option
 program.option('-c, --config <path>', 'Path to i18next-cli config file (overrides detection)');
 program

package/dist/esm/rename-key.js

@@ -76,9 +76,9 @@ async function runRenameKey(config, oldKey, newKey, options = {}, logger = new C
     const namespaceKeyMap = await buildNamespaceKeyMap(config);
     logger.info(`🔍 Scanning for usages of "${oldKey}"...`);
     // Find and update source files
-    const sourceResults = await updateSourceFiles(oldParts, newParts, config, dryRun, logger, namespaceKeyMap);
+    const sourceResults = await updateSourceFiles(oldParts, newParts, config, dryRun, namespaceKeyMap, logger);
     // Update translation files
-    const translationResults = await updateTranslationFiles(oldParts, newParts, config, dryRun, logger);
+    const translationResults = await updateTranslationFiles(oldParts, newParts, config, dryRun, namespaceKeyMap, logger);
     const totalChanges = sourceResults.reduce((sum, r) => sum + r.changes, 0);
     if (!dryRun && totalChanges > 0) {
         logger.info('\n✨ Successfully renamed key!');
@@ -227,7 +227,7 @@ async function buildNamespaceKeyMap(config) {
     }
     return map;
 }
-async function updateSourceFiles(oldParts, newParts, config, dryRun, logger, namespaceKeyMap) {
+async function updateSourceFiles(oldParts, newParts, config, dryRun, namespaceKeyMap, logger) {
     const defaultIgnore = ['node_modules/**'];
     const userIgnore = Array.isArray(config.extract.ignore)
         ? config.extract.ignore
@@ -281,7 +281,26 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
         if (!ns)
             return false;
         const set = namespaceKeyMap.get(ns);
-        return !!(set && set.has(oldParts.key));
+        if (!set)
+            return false;
+        // exact key match
+        if (set.has(oldParts.key))
+            return true;
+        // nested keys using keySeparator, e.g. "key.one", "key.other"
+        const keySeparator = config.extract.keySeparator ?? '.';
+        const nestedPrefix = `${oldParts.key}${String(keySeparator)}`;
+        for (const s of set) {
+            if (s.startsWith(nestedPrefix))
+                return true;
+        }
+        // flat plural keys like "key_one", "key_other"
+        const pluralSuffixes = ['zero', 'one', 'two', 'few', 'many', 'other'];
+        const flatPluralRegex = new RegExp(`^${escapeRegex(oldParts.key)}_(${pluralSuffixes.join('|')})$`);
+        for (const s of set) {
+            if (flatPluralRegex.test(s))
+                return true;
+        }
+        return false;
     };
     for (const fnPattern of configuredFunctions) {
         const prefix = fnPrefixToRegex(fnPattern);
@@ -503,60 +522,177 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
 function escapeRegex(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-async function updateTranslationFiles(oldParts, newParts, config, dryRun, logger) {
+async function updateTranslationFiles(oldParts, newParts, config, dryRun, namespaceKeyMap, logger) {
     const results = [];
     const keySeparator = config.extract.keySeparator ?? '.';
-    for (const locale of config.locales) {
-        const oldOutputPath = getOutputPath(config.extract.output, locale, oldParts.namespace);
-        const oldFullPath = resolve(process.cwd(), oldOutputPath);
-        const newOutputPath = getOutputPath(config.extract.output, locale, newParts.namespace);
-        const newFullPath = resolve(process.cwd(), newOutputPath);
-        let oldTranslations;
-        let newTranslations;
-        try {
-            oldTranslations = await loadTranslationFile(oldFullPath);
+    // plural suffixes commonly used by i18next (for flat underscore style: key_one)
+    const pluralSuffixes = ['zero', 'one', 'two', 'few', 'many', 'other'];
+    // Helper: determine whether a flattened key-set indicates presence of `baseKey`.
+    const namespaceHasKey = (set, baseKey) => {
+        if (!set)
+            return false;
+        // exact key (for scalar or object)
+        if (set.has(baseKey))
+            return true;
+        // nested keys using keySeparator, e.g. "key.one", "key.other"
+        const nestedPrefix = `${baseKey}${String(keySeparator)}`;
+        for (const s of set) {
+            if (s.startsWith(nestedPrefix))
+                return true;
         }
-        catch { }
-        if (!oldTranslations)
-            continue;
-        const oldValue = getNestedValue(oldTranslations, oldParts.key, keySeparator);
-        if (oldValue === undefined)
-            continue;
-        if (oldParts.namespace === newParts.namespace) {
-            // Rename within the same namespace
-            deleteNestedValue(oldTranslations, oldParts.key, keySeparator);
-            setNestedValue(oldTranslations, newParts.key, oldValue, keySeparator);
-            if (!dryRun) {
-                const content = serializeTranslationFile(oldTranslations, config.extract.outputFormat, config.extract.indentation);
-                await writeFile(oldFullPath, content, 'utf-8');
-            }
-            results.push({ path: oldFullPath, updated: true });
-            logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${oldFullPath}`);
+        // flat plural keys like "key_one", "key_other"
+        const flatPluralRegex = new RegExp(`^${escapeRegex(baseKey)}_(${pluralSuffixes.join('|')})$`);
+        for (const s of set) {
+            if (flatPluralRegex.test(s))
+                return true;
         }
-        else {
-            // Move across namespaces
-            // Remove from old namespace
-            deleteNestedValue(oldTranslations, oldParts.key, keySeparator);
-            if (!dryRun) {
-                const content = serializeTranslationFile(oldTranslations, config.extract.outputFormat, config.extract.indentation);
-                await writeFile(oldFullPath, content, 'utf-8');
-            }
-            results.push({ path: oldFullPath, updated: true });
-            logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${oldFullPath}`);
-            // Add to new namespace
+        return false;
+    };
+    // Decide candidate namespaces to inspect:
+    // - If the old key was explicitly namespaced in the CLI (oldParts.explicitNamespace),
+    //   we only inspect that namespace.
+    // - Otherwise, inspect every namespace that appears to contain the key (from namespaceKeyMap).
+    const candidateNamespaces = [];
+    if (oldParts.explicitNamespace && oldParts.namespace) {
+        candidateNamespaces.push(oldParts.namespace);
+    }
+    else {
+        for (const [ns, set] of namespaceKeyMap.entries()) {
+            if (namespaceHasKey(set, oldParts.key))
+                candidateNamespaces.push(ns);
+        }
+    }
+    // if nothing found, nothing to do
+    if (candidateNamespaces.length === 0) {
+        return results;
+    }
+    // Iterate each locale and each candidate source namespace found
+    for (const locale of config.locales) {
+        for (const ns of candidateNamespaces) {
+            const oldOutputPath = getOutputPath(config.extract.output, locale, ns);
+            const oldFullPath = resolve(process.cwd(), oldOutputPath);
+            // When explicitly targeting a namespace in the CLI, always use that target.
+            // When not explicit, keep keys in their current namespace (don't move them).
+            const targetNamespace = (oldParts.explicitNamespace || newParts.explicitNamespace)
+                ? newParts.namespace
+                : ns;
+            const newOutputPath = getOutputPath(config.extract.output, locale, targetNamespace);
+            const newFullPath = resolve(process.cwd(), newOutputPath);
+            let oldTranslations;
+            let newTranslations;
             try {
-                newTranslations = await loadTranslationFile(newFullPath);
+                oldTranslations = await loadTranslationFile(oldFullPath);
             }
             catch { }
-            if (!newTranslations)
-                newTranslations = {};
-            setNestedValue(newTranslations, newParts.key, oldValue, keySeparator);
-            if (!dryRun) {
-                const content = serializeTranslationFile(newTranslations, config.extract.outputFormat, config.extract.indentation);
-                await writeFile(newFullPath, content, 'utf-8');
+            if (!oldTranslations)
+                continue;
+            // 1) nested/exact path value (object or scalar) at the nested path
+            const oldValue = getNestedValue(oldTranslations, oldParts.key, keySeparator);
+            // 2) flat plural matches like `key_one`, `key_other`
+            const flatPluralMatches = [];
+            if (oldTranslations && typeof oldTranslations === 'object') {
+                const re = new RegExp(`^${escapeRegex(oldParts.key)}_(${pluralSuffixes.join('|')})$`);
+                for (const k of Object.keys(oldTranslations)) {
+                    const m = k.match(re);
+                    if (m)
+                        flatPluralMatches.push({ flatKey: k, suffix: m[1], value: oldTranslations[k] });
+                }
+            }
+            // nothing found for this file/namespace
+            if (oldValue === undefined && flatPluralMatches.length === 0)
+                continue;
+            //
+            // Handle flat plurals first (top-level underscore keys)
+            //
+            if (flatPluralMatches.length > 0) {
+                if (ns === targetNamespace) {
+                    // rename in-place within same file
+                    for (const m of flatPluralMatches) {
+                        delete oldTranslations[m.flatKey];
+                        const newFlatKey = `${newParts.key}_${m.suffix}`;
+                        oldTranslations[newFlatKey] = m.value;
+                    }
+                    if (!dryRun) {
+                        const content = serializeTranslationFile(oldTranslations, config.extract.outputFormat, config.extract.indentation);
+                        await writeFile(oldFullPath, content, 'utf-8');
+                    }
+                    results.push({ path: oldFullPath, updated: true });
+                    logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${oldFullPath}`);
+                }
+                else {
+                    // move them to the new namespace file
+                    for (const m of flatPluralMatches)
+                        delete oldTranslations[m.flatKey];
+                    if (!dryRun) {
+                        const contentOld = serializeTranslationFile(oldTranslations, config.extract.outputFormat, config.extract.indentation);
+                        await writeFile(oldFullPath, contentOld, 'utf-8');
+                    }
+                    results.push({ path: oldFullPath, updated: true });
+                    logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${oldFullPath}`);
+                    try {
+                        newTranslations = await loadTranslationFile(newFullPath);
+                    }
+                    catch { }
+                    if (!newTranslations)
+                        newTranslations = {};
+                    for (const m of flatPluralMatches) {
+                        const newFlatKey = `${newParts.key}_${m.suffix}`;
+                        newTranslations[newFlatKey] = m.value;
+                    }
+                    if (!dryRun) {
+                        const contentNew = serializeTranslationFile(newTranslations, config.extract.outputFormat, config.extract.indentation);
+                        await writeFile(newFullPath, contentNew, 'utf-8');
+                    }
+                    results.push({ path: newFullPath, updated: true });
+                    logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${newFullPath}`);
+                }
+            }
+            //
+            // Handle nested/exact key
+            //
+            if (oldValue !== undefined) {
+                if (ns === targetNamespace) {
+                    // rename within same file (nested)
+                    deleteNestedValue(oldTranslations, oldParts.key, keySeparator);
+                    setNestedValue(oldTranslations, newParts.key, oldValue, keySeparator);
+                    if (!dryRun) {
+                        const content = serializeTranslationFile(oldTranslations, config.extract.outputFormat, config.extract.indentation);
+                        await writeFile(oldFullPath, content, 'utf-8');
+                    }
+                    if (!results.find(r => r.path === oldFullPath)) {
+                        results.push({ path: oldFullPath, updated: true });
+                        logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${oldFullPath}`);
+                    }
+                }
+                else {
+                    // move nested value across namespaces
+                    const updatedOld = { ...oldTranslations };
+                    deleteNestedValue(updatedOld, oldParts.key, keySeparator);
+                    if (!dryRun) {
+                        const contentOld = serializeTranslationFile(updatedOld, config.extract.outputFormat, config.extract.indentation);
+                        await writeFile(oldFullPath, contentOld, 'utf-8');
+                    }
+                    if (!results.find(r => r.path === oldFullPath)) {
+                        results.push({ path: oldFullPath, updated: true });
+                        logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${oldFullPath}`);
+                    }
+                    try {
+                        newTranslations = await loadTranslationFile(newFullPath);
+                    }
+                    catch { }
+                    if (!newTranslations)
+                        newTranslations = {};
+                    setNestedValue(newTranslations, newParts.key, oldValue, keySeparator);
+                    if (!dryRun) {
+                        const contentNew = serializeTranslationFile(newTranslations, config.extract.outputFormat, config.extract.indentation);
+                        await writeFile(newFullPath, contentNew, 'utf-8');
+                    }
+                    if (!results.find(r => r.path === newFullPath)) {
+                        results.push({ path: newFullPath, updated: true });
+                        logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${newFullPath}`);
+                    }
+                }
             }
-            results.push({ path: newFullPath, updated: true });
-            logger.info(`   ${dryRun ? '(dry-run) ' : ''}✓ ${newFullPath}`);
         }
     }
     if (results.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18next-cli",
-  "version": "1.39.12",
+  "version": "1.40.0",
   "description": "A unified, high-performance i18next CLI.",
   "type": "module",
   "bin": {