i18next-cli 1.39.4 → 1.39.6

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.4'); // This string is replaced with the actual version at build time by rollup
+    .version('1.39.6'); // 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

@@ -2,9 +2,9 @@
 
 var glob = require('glob');
 var promises = require('node:fs/promises');
+var node_path = require('node:path');
 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');
@@ -64,9 +64,13 @@ async function runRenameKey(config, oldKey, newKey, options = {}, logger$1 = new
             error: 'Target key already exists in translation files'
         };
     }
+    // Build a quick map of which namespaces contain which keys (union across locales).
+    // This allows us to decide, per-call, whether an explicit `{ ns: 'x' }` refers to
+    // the namespace we're renaming, and whether that namespace actually contains the key.
+    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);
+    const sourceResults = await updateSourceFiles(oldParts, newParts, config, dryRun, logger$1, namespaceKeyMap);
     // Update translation files
     const translationResults = await updateTranslationFiles(oldParts, newParts, config, dryRun, logger$1);
     const totalChanges = sourceResults.reduce((sum, r) => sum + r.changes, 0);
@@ -107,13 +111,15 @@ function parseKeyWithNamespace(key, config) {
         return {
             namespace: ns,
             key: rest.join(nsSeparator),
-            fullKey: key
+            fullKey: key,
+            explicitNamespace: true
         };
     }
     return {
         namespace: config.extract.defaultNS || 'translation',
         key,
-        fullKey: key
+        fullKey: key,
+        explicitNamespace: false
     };
 }
 function validateKeys(oldKey, newKey, config) {
@@ -149,7 +155,54 @@ async function checkConflicts(newParts, config) {
     }
     return conflicts;
 }
-async function updateSourceFiles(oldParts, newParts, config, dryRun, logger) {
+async function buildNamespaceKeyMap(config) {
+    // Map namespace -> set of flattened keys present in that namespace (union across locales)
+    const map = new Map();
+    // config.extract.output may be either a string template or a function(language, namespace) => string.
+    // Produce a string we can turn into a glob pattern. For functions, call with wildcard values.
+    const rawOutput = config.extract.output;
+    const outputTemplate = typeof rawOutput === 'function'
+        ? rawOutput('*', '*') // produce a path with wildcards we can glob
+        : String(rawOutput);
+    // make a glob pattern by replacing placeholders with *
+    const pat = outputTemplate
+        .replace(/\{\{language\}\}/g, '*')
+        .replace(/\{\{namespace\}\}/g, '*');
+    // glob expects unix-style
+    const files = await glob.glob([pat.replace(/\\/g, '/')], { nodir: true });
+    const keySeparator = config.extract.keySeparator ?? '.';
+    for (const f of files) {
+        try {
+            const translations = await fileUtils.loadTranslationFile(node_path.resolve(process.cwd(), f));
+            if (!translations)
+                continue;
+            // derive namespace name from filename: basename without extension (platform-safe)
+            const base = node_path.basename(f);
+            const ns = base.replace(/\.[^.]+$/, ''); // remove extension
+            const set = map.get(ns) ?? new Set();
+            // flatten keys recursively
+            const collect = (obj, prefix = '') => {
+                if (typeof obj !== 'object' || obj === null) {
+                    // only add non-empty prefix (avoid adding '')
+                    if (prefix)
+                        set.add(prefix);
+                    return;
+                }
+                for (const k of Object.keys(obj)) {
+                    const next = prefix ? `${prefix}${keySeparator}${k}` : k;
+                    collect(obj[k], next);
+                }
+            };
+            collect(translations, '');
+            map.set(ns, set);
+        }
+        catch {
+            // ignore unreadable files
+        }
+    }
+    return map;
+}
+async function updateSourceFiles(oldParts, newParts, config, dryRun, logger, namespaceKeyMap) {
     const defaultIgnore = ['node_modules/**'];
     const userIgnore = Array.isArray(config.extract.ignore)
         ? config.extract.ignore
@@ -167,7 +220,7 @@ async function updateSourceFiles(oldParts, newParts, config, dryRun, logger) {
     const results = [];
     for (const file of sourceFiles) {
         const code = await promises.readFile(file, 'utf-8');
-        const { newCode, changes } = await replaceKeyInSource(code, oldParts, newParts, config);
+        const { newCode, changes } = await replaceKeyInSource(code, oldParts, newParts, config, namespaceKeyMap);
         if (changes > 0) {
             if (!dryRun) {
                 await promises.writeFile(file, newCode, 'utf-8');
@@ -181,11 +234,11 @@ async function updateSourceFiles(oldParts, newParts, config, dryRun, logger) {
     }
     return results;
 }
-async function replaceKeyInSource(code, oldParts, newParts, config) {
+async function replaceKeyInSource(code, oldParts, newParts, config, namespaceKeyMap) {
     // Simpler and robust regex-based replacement that covers tests' patterns
-    return replaceKeyWithRegex(code, oldParts, newParts, config);
+    return replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap);
 }
-function replaceKeyWithRegex(code, oldParts, newParts, config) {
+function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap) {
     let changes = 0;
     let newCode = code;
     const nsSeparator = config.extract.nsSeparator ?? ':';
@@ -200,87 +253,54 @@ function replaceKeyWithRegex(code, oldParts, newParts, config) {
         // exact function name (may include dot like 'i18n.t' or 'translate')
         return `\\b${escapeRegex(fnPattern)}`;
     };
+    // Helper: check whether the old key exists in a given namespace (from the prebuilt map)
+    const hasKeyInNamespace = (ns) => {
+        if (!ns)
+            return false;
+        const set = namespaceKeyMap.get(ns);
+        return !!(set && set.has(oldParts.key));
+    };
     // Replace exact string-key usages inside function calls: fn('key') or fn(`key`) or fn("key")
     for (const fnPattern of configuredFunctions) {
         const prefix = fnPrefixToRegex(fnPattern);
-        // Match fullKey first (namespace-prefixed in source)
-        if (oldParts.fullKey) {
-            const regexFull = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g');
-            newCode = newCode.replace(regexFull, (match, q) => {
-                changes++;
-                const replacementKey = (oldParts.fullKey.includes(nsSeparator || ':') ? newParts.fullKey : newParts.key);
-                // preserve surrounding characters up to the opening quote
-                return match.replace(oldParts.fullKey, replacementKey);
-            });
-        }
-        // Then match bare key (no namespace in source)
-        const regexKey = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.key)}\\1`, 'g');
-        newCode = newCode.replace(regexKey, (match) => {
-            changes++;
-            const replacementKey = newParts.key;
-            return match.replace(new RegExp(escapeRegex(oldParts.key)), replacementKey);
-        });
-        // Then match bare key (no namespace in source)
-        // If moving from defaultNS to another, and call is t('key') with no options, add ns option
-        const regexKeyWithParen = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.key)}\\1\\s*\\)`, 'g');
-        newCode = newCode.replace(regexKeyWithParen, (match, quote) => {
-            if (oldParts.namespace && newParts.namespace &&
-                oldParts.namespace !== newParts.namespace &&
-                config.extract.defaultNS === oldParts.namespace) {
-                changes++;
-                return match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1\\s*\\)`), `${quote}${newParts.key}${quote}, { ns: '${newParts.namespace}' })`);
-            }
-            else if (oldParts.namespace && newParts.namespace &&
-                oldParts.namespace !== newParts.namespace &&
-                config.extract.defaultNS === newParts.namespace) {
-                // If moving from a namespaced key to defaultNS, update t('key', { ns: 'oldNs' }) to t('key')
-                // Remove the ns option if it matches the defaultNS
-                // This is handled below in the ns option replacement
-                // But also handle t('key', { ns: 'defaultNS' }) -> t('key')
-                // See below for explicit ns option removal
-                // No action here, handled below
-                return match;
-            }
-            else {
-                changes++;
-                const replacementKey = newParts.key;
-                return match.replace(new RegExp(escapeRegex(oldParts.key)), replacementKey);
-            }
-        });
-        // Remove ns option if moving to defaultNS
+        // 1) If moving TO the defaultNS, remove the explicit ns option and update key in one go:
+        //    t('key', { ns: 'oldNs', ... }) -> t('newKey') (or t('newKey', { otherProps }) if other props exist)
+        // Only do this if the old key actually exists in the old namespace
         if (oldParts.namespace && newParts.namespace &&
             oldParts.namespace !== newParts.namespace &&
-            config.extract.defaultNS === newParts.namespace) {
+            config.extract.defaultNS === newParts.namespace &&
+            hasKeyInNamespace(oldParts.namespace)) {
             // t('key', { ns: 'oldNs' }) -> t('key')
             const nsRegexToDefault = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.key)}\\1\\s*,\\s*\\{([^}]*)\\bns\\s*:\\s*(['"\`])${escapeRegex(oldParts.namespace)}\\3([^}]*)\\}\\s*\\)`, 'g');
             newCode = newCode.replace(nsRegexToDefault, (match, keyQ, beforeNs, nsQ, afterNs) => {
                 changes++;
                 // Build remaining object props (everything except the ns property)
                 const obj = (beforeNs + afterNs).replace(/,?\s*$/, '').replace(/^\s*,?/, '').trim();
-                // Start by replacing the key string itself, preserving the original quote style
+                // Replace the key string itself, preserving the original quote style
                 let updated = match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1`), `${keyQ}${newParts.key}${keyQ}`);
                 if (obj) {
-                    // If other properties remain, replace the whole object content with the cleaned props
+                    // If other properties remain, keep them
                     updated = updated.replace(/\{\s*([^}]*)\s*\}/, `{${obj}}`);
                 }
                 else {
-                    // No other props — remove the whole options object (", { ... }") leaving "fn('key')"
+                    // No other props — remove the options object entirely
                     updated = updated.replace(/\s*,\s*\{[^}]*\}\s*\)/, ')');
                 }
                 return updated;
             });
         }
-        // Handle ns option in options object: fn('key', { ns: 'oldNs', ... })
-        if (oldParts.namespace && newParts.namespace && oldParts.namespace !== newParts.namespace) {
-            // We want to change only when key matches and ns value equals oldParts.namespace
+        // 2) Update ns option value when moving across namespaces (when options are present)
+        // Only attempt to update the ns option if the old namespace actually contains the key.
+        if (oldParts.namespace && newParts.namespace && oldParts.namespace !== newParts.namespace && hasKeyInNamespace(oldParts.namespace)) {
+            // case where key is bare (e.g. t('key', { ns: 'oldNs', ... }))
             const nsRegexFullKey = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.key)}\\1\\s*,\\s*\\{([^}]*)\\bns\\s*:\\s*(['"\`])${escapeRegex(oldParts.namespace)}\\3([^}]*)\\}\\s*\\)`, 'g');
-            newCode = newCode.replace(nsRegexFullKey, (match, keyQ, beforeNs, nsQ, afterNs) => {
+            newCode = newCode.replace(nsRegexFullKey, (match) => {
                 changes++;
                 // replace ns value
                 return match.replace(new RegExp(`(\\bns\\s*:\\s*['"\`])${escapeRegex(oldParts.namespace ?? '')}(['"\`])`), `$1${newParts.namespace ?? ''}$2`);
             });
-            // same but if the call used fullKey (ns included inside key string), still update ns option if present
-            if (oldParts.fullKey) {
+            // case where fullKey was used inside the string (e.g. t('ns:key', { ns: 'oldNs' }))
+            if (oldParts.fullKey && oldParts.explicitNamespace) {
                 const nsRegexFull = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.fullKey)}\\1\\s*,\\s*\\{([^}]*)\\bns\\s*:\\s*(['"\`])${escapeRegex(oldParts.namespace)}\\3([^}]*)\\}\\s*\\)`, 'g');
                 newCode = newCode.replace(nsRegexFull, (match) => {
                     changes++;
@@ -288,46 +308,73 @@ function replaceKeyWithRegex(code, oldParts, newParts, config) {
                 });
             }
         }
-    }
-    // Selector API: dot-notation: fn(($) => $.old.key)
-    for (const fnPattern of configuredFunctions) {
-        const prefix = fnPrefixToRegex(fnPattern);
-        // match forms like: prefix( $ => $.old.key )
-        // capture the arrow param name and the rest
-        // We'll attempt to match the param and the dotted property chain equal to oldParts.key (exact)
-        const dotRegex = new RegExp(`${prefix}\\s*\\(\\s*\\(?\\s*([a-zA-Z_$][\\w$]*)\\s*\\)?\\s*=>\\s*\\1\\.${escapeRegex(oldParts.key)}\\s*\\)`, 'g');
-        newCode = newCode.replace(dotRegex, (match, param) => {
-            changes++;
-            // Determine replacement (if source used namespace in key it would be fullKey, but in selector dot-notation it's always key form)
-            const replacementKey = newParts.key;
-            return match.replace(`.${oldParts.key}`, `.${replacementKey}`);
-        });
-        // Bracket notation: fn(($) => $["Old Key"]) etc.
-        const bracketRegex = new RegExp(`${prefix}\\s*\\(\\s*\\(?\\s*([a-zA-Z_$][\\w$]*)\\s*\\)?\\s*=>\\s*\\1\\s*\\[\\s*(['"\`])${escapeRegex(oldParts.key)}\\2\\s*\\]\\s*\\)`, 'g');
-        newCode = newCode.replace(bracketRegex, (match, param, quote) => {
-            changes++;
-            const replacementKey = newParts.key;
-            // If replacementKey is a valid identifier, convert to dot-notation, otherwise keep bracket form with preserved quote style
-            if (/^[A-Za-z_$][\w$]*$/.test(replacementKey)) {
-                return match.replace(new RegExp(`\\[\\s*['"\`]${escapeRegex(oldParts.key)}['"\`]\\s*\\]`), `.${replacementKey}`);
-            }
-            else {
-                return match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1`), `$1${replacementKey}$1`);
-            }
-        });
-    }
-    // JSX i18nKey attribute (handles all quote types)
-    const jsxPatterns = [
-        { orig: oldParts.fullKey, regex: new RegExp(`i18nKey=(['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g') },
-        { orig: oldParts.key, regex: new RegExp(`i18nKey=(['"\`])${escapeRegex(oldParts.key)}\\1`, 'g') }
-    ];
-    for (const p of jsxPatterns) {
-        newCode = newCode.replace(p.regex, (match, q) => {
-            changes++;
-            const nsSepStr = nsSeparator === false ? ':' : nsSeparator;
-            const replacement = (p.orig === oldParts.fullKey && oldParts.fullKey.includes(nsSepStr)) ? newParts.fullKey : newParts.key;
-            return `i18nKey=${q}${replacement}${q}`;
-        });
+        // 3) Replace occurrences where the call uses the fullKey inside the string (e.g. t('ns:key'))
+        if (oldParts.fullKey && oldParts.explicitNamespace) {
+            const regexFull = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g');
+            newCode = newCode.replace(regexFull, (match) => {
+                changes++;
+                const replacementKey = (oldParts.fullKey.includes(nsSeparator || ':') ? newParts.fullKey : newParts.key);
+                return match.replace(oldParts.fullKey, replacementKey);
+            });
+        }
+        // 4) Handle selector / arrow and bracket forms (these are always "key form" so safe to replace)
+        // Selector API: dot-notation: fn(($) => $.old.key)
+        {
+            const dotRegex = new RegExp(`${prefix}\\s*\\(\\s*\\(?\\s*([a-zA-Z_$][\\w$]*)\\s*\\)?\\s*=>\\s*\\1\\.${escapeRegex(oldParts.key)}\\s*\\)`, 'g');
+            newCode = newCode.replace(dotRegex, (match) => {
+                changes++;
+                const replacementKey = newParts.key;
+                return match.replace(`.${oldParts.key}`, `.${replacementKey}`);
+            });
+            const bracketRegex = new RegExp(`${prefix}\\s*\\(\\s*\\(?\\s*([a-zA-Z_$][\\w$]*)\\s*\\)?\\s*=>\\s*\\1\\s*\\[\\s*(['"\`])${escapeRegex(oldParts.key)}\\2\\s*\\]\\s*\\)`, 'g');
+            newCode = newCode.replace(bracketRegex, (match) => {
+                changes++;
+                const replacementKey = newParts.key;
+                if (/^[A-Za-z_$][\w$]*$/.test(replacementKey)) {
+                    return match.replace(new RegExp(`\\[\\s*['"\`]${escapeRegex(oldParts.key)}['"\`]\\s*\\]`), `.${replacementKey}`);
+                }
+                else {
+                    return match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1`), `$1${replacementKey}$1`);
+                }
+            });
+        }
+        // 5) Replace bare calls WITHOUT an options object: fn('key') -> fn('newKey')
+        //    We purposely only match when the string is directly followed by the closing paren (no comma/options).
+        {
+            const regexKeyNoOptions = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.key)}\\1\\s*\\)`, 'g');
+            newCode = newCode.replace(regexKeyNoOptions, (match, q) => {
+                changes++;
+                const replacementKey = newParts.key;
+                return match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1`), `${q}${replacementKey}${q}`);
+            });
+        }
+        // 6) Handle the case where we have fn('key', /*no ns*/ { otherProps }) and we are moving
+        //    from defaultNS to another namespace: add ns when appropriate.
+        // This block is only relevant when moving FROM defaultNS (add ns option). Only perform it
+        // if the old key exists in the old namespace (if we tracked one).
+        if (oldParts.namespace && newParts.namespace &&
+            oldParts.namespace !== newParts.namespace &&
+            config.extract.defaultNS === oldParts.namespace &&
+            hasKeyInNamespace(oldParts.namespace)) {
+            const regexKeyWithParen = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.key)}\\1\\s*\\)`, 'g');
+            newCode = newCode.replace(regexKeyWithParen, (match, quote) => {
+                changes++;
+                return match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1\\s*\\)`), `${quote}${newParts.key}${quote}, { ns: '${newParts.namespace}' })`);
+            });
+        }
+        // 7) JSX i18nKey attribute (handles both fullKey and key)
+        const jsxPatterns = [
+            { orig: oldParts.fullKey, regex: new RegExp(`i18nKey=(['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g') },
+            { orig: oldParts.key, regex: new RegExp(`i18nKey=(['"\`])${escapeRegex(oldParts.key)}\\1`, 'g') }
+        ];
+        for (const p of jsxPatterns) {
+            newCode = newCode.replace(p.regex, (match, q) => {
+                changes++;
+                const nsSepStr = nsSeparator === false ? ':' : nsSeparator;
+                const replacement = (p.orig === oldParts.fullKey && oldParts.fullKey.includes(nsSepStr)) ? newParts.fullKey : newParts.key;
+                return `i18nKey=${q}${replacement}${q}`;
+            });
+        }
     }
     return { newCode, changes };
 }

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.4'); // This string is replaced with the actual version at build time by rollup
+    .version('1.39.6'); // 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

@@ -1,8 +1,8 @@
 import { glob } from 'glob';
 import { readFile, writeFile } from 'node:fs/promises';
+import { resolve, basename } from 'node:path';
 import { ConsoleLogger } from './utils/logger.js';
 import { getOutputPath, loadTranslationFile, serializeTranslationFile } from './utils/file-utils.js';
-import { resolve } from 'node:path';
 import { getNestedValue, setNestedValue } from './utils/nested-object.js';
 import { shouldShowFunnel, recordFunnelShown } from './utils/funnel-msg-tracker.js';
 import chalk from 'chalk';
@@ -62,9 +62,13 @@ async function runRenameKey(config, oldKey, newKey, options = {}, logger = new C
             error: 'Target key already exists in translation files'
         };
     }
+    // Build a quick map of which namespaces contain which keys (union across locales).
+    // This allows us to decide, per-call, whether an explicit `{ ns: 'x' }` refers to
+    // the namespace we're renaming, and whether that namespace actually contains the key.
+    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);
+    const sourceResults = await updateSourceFiles(oldParts, newParts, config, dryRun, logger, namespaceKeyMap);
     // Update translation files
     const translationResults = await updateTranslationFiles(oldParts, newParts, config, dryRun, logger);
     const totalChanges = sourceResults.reduce((sum, r) => sum + r.changes, 0);
@@ -105,13 +109,15 @@ function parseKeyWithNamespace(key, config) {
         return {
             namespace: ns,
             key: rest.join(nsSeparator),
-            fullKey: key
+            fullKey: key,
+            explicitNamespace: true
         };
     }
     return {
         namespace: config.extract.defaultNS || 'translation',
         key,
-        fullKey: key
+        fullKey: key,
+        explicitNamespace: false
     };
 }
 function validateKeys(oldKey, newKey, config) {
@@ -147,7 +153,54 @@ async function checkConflicts(newParts, config) {
     }
     return conflicts;
 }
-async function updateSourceFiles(oldParts, newParts, config, dryRun, logger) {
+async function buildNamespaceKeyMap(config) {
+    // Map namespace -> set of flattened keys present in that namespace (union across locales)
+    const map = new Map();
+    // config.extract.output may be either a string template or a function(language, namespace) => string.
+    // Produce a string we can turn into a glob pattern. For functions, call with wildcard values.
+    const rawOutput = config.extract.output;
+    const outputTemplate = typeof rawOutput === 'function'
+        ? rawOutput('*', '*') // produce a path with wildcards we can glob
+        : String(rawOutput);
+    // make a glob pattern by replacing placeholders with *
+    const pat = outputTemplate
+        .replace(/\{\{language\}\}/g, '*')
+        .replace(/\{\{namespace\}\}/g, '*');
+    // glob expects unix-style
+    const files = await glob([pat.replace(/\\/g, '/')], { nodir: true });
+    const keySeparator = config.extract.keySeparator ?? '.';
+    for (const f of files) {
+        try {
+            const translations = await loadTranslationFile(resolve(process.cwd(), f));
+            if (!translations)
+                continue;
+            // derive namespace name from filename: basename without extension (platform-safe)
+            const base = basename(f);
+            const ns = base.replace(/\.[^.]+$/, ''); // remove extension
+            const set = map.get(ns) ?? new Set();
+            // flatten keys recursively
+            const collect = (obj, prefix = '') => {
+                if (typeof obj !== 'object' || obj === null) {
+                    // only add non-empty prefix (avoid adding '')
+                    if (prefix)
+                        set.add(prefix);
+                    return;
+                }
+                for (const k of Object.keys(obj)) {
+                    const next = prefix ? `${prefix}${keySeparator}${k}` : k;
+                    collect(obj[k], next);
+                }
+            };
+            collect(translations, '');
+            map.set(ns, set);
+        }
+        catch {
+            // ignore unreadable files
+        }
+    }
+    return map;
+}
+async function updateSourceFiles(oldParts, newParts, config, dryRun, logger, namespaceKeyMap) {
     const defaultIgnore = ['node_modules/**'];
     const userIgnore = Array.isArray(config.extract.ignore)
         ? config.extract.ignore
@@ -165,7 +218,7 @@ async function updateSourceFiles(oldParts, newParts, config, dryRun, logger) {
     const results = [];
     for (const file of sourceFiles) {
         const code = await readFile(file, 'utf-8');
-        const { newCode, changes } = await replaceKeyInSource(code, oldParts, newParts, config);
+        const { newCode, changes } = await replaceKeyInSource(code, oldParts, newParts, config, namespaceKeyMap);
         if (changes > 0) {
             if (!dryRun) {
                 await writeFile(file, newCode, 'utf-8');
@@ -179,11 +232,11 @@ async function updateSourceFiles(oldParts, newParts, config, dryRun, logger) {
     }
     return results;
 }
-async function replaceKeyInSource(code, oldParts, newParts, config) {
+async function replaceKeyInSource(code, oldParts, newParts, config, namespaceKeyMap) {
     // Simpler and robust regex-based replacement that covers tests' patterns
-    return replaceKeyWithRegex(code, oldParts, newParts, config);
+    return replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap);
 }
-function replaceKeyWithRegex(code, oldParts, newParts, config) {
+function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap) {
     let changes = 0;
     let newCode = code;
     const nsSeparator = config.extract.nsSeparator ?? ':';
@@ -198,87 +251,54 @@ function replaceKeyWithRegex(code, oldParts, newParts, config) {
         // exact function name (may include dot like 'i18n.t' or 'translate')
         return `\\b${escapeRegex(fnPattern)}`;
     };
+    // Helper: check whether the old key exists in a given namespace (from the prebuilt map)
+    const hasKeyInNamespace = (ns) => {
+        if (!ns)
+            return false;
+        const set = namespaceKeyMap.get(ns);
+        return !!(set && set.has(oldParts.key));
+    };
     // Replace exact string-key usages inside function calls: fn('key') or fn(`key`) or fn("key")
     for (const fnPattern of configuredFunctions) {
         const prefix = fnPrefixToRegex(fnPattern);
-        // Match fullKey first (namespace-prefixed in source)
-        if (oldParts.fullKey) {
-            const regexFull = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g');
-            newCode = newCode.replace(regexFull, (match, q) => {
-                changes++;
-                const replacementKey = (oldParts.fullKey.includes(nsSeparator || ':') ? newParts.fullKey : newParts.key);
-                // preserve surrounding characters up to the opening quote
-                return match.replace(oldParts.fullKey, replacementKey);
-            });
-        }
-        // Then match bare key (no namespace in source)
-        const regexKey = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.key)}\\1`, 'g');
-        newCode = newCode.replace(regexKey, (match) => {
-            changes++;
-            const replacementKey = newParts.key;
-            return match.replace(new RegExp(escapeRegex(oldParts.key)), replacementKey);
-        });
-        // Then match bare key (no namespace in source)
-        // If moving from defaultNS to another, and call is t('key') with no options, add ns option
-        const regexKeyWithParen = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.key)}\\1\\s*\\)`, 'g');
-        newCode = newCode.replace(regexKeyWithParen, (match, quote) => {
-            if (oldParts.namespace && newParts.namespace &&
-                oldParts.namespace !== newParts.namespace &&
-                config.extract.defaultNS === oldParts.namespace) {
-                changes++;
-                return match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1\\s*\\)`), `${quote}${newParts.key}${quote}, { ns: '${newParts.namespace}' })`);
-            }
-            else if (oldParts.namespace && newParts.namespace &&
-                oldParts.namespace !== newParts.namespace &&
-                config.extract.defaultNS === newParts.namespace) {
-                // If moving from a namespaced key to defaultNS, update t('key', { ns: 'oldNs' }) to t('key')
-                // Remove the ns option if it matches the defaultNS
-                // This is handled below in the ns option replacement
-                // But also handle t('key', { ns: 'defaultNS' }) -> t('key')
-                // See below for explicit ns option removal
-                // No action here, handled below
-                return match;
-            }
-            else {
-                changes++;
-                const replacementKey = newParts.key;
-                return match.replace(new RegExp(escapeRegex(oldParts.key)), replacementKey);
-            }
-        });
-        // Remove ns option if moving to defaultNS
+        // 1) If moving TO the defaultNS, remove the explicit ns option and update key in one go:
+        //    t('key', { ns: 'oldNs', ... }) -> t('newKey') (or t('newKey', { otherProps }) if other props exist)
+        // Only do this if the old key actually exists in the old namespace
         if (oldParts.namespace && newParts.namespace &&
             oldParts.namespace !== newParts.namespace &&
-            config.extract.defaultNS === newParts.namespace) {
+            config.extract.defaultNS === newParts.namespace &&
+            hasKeyInNamespace(oldParts.namespace)) {
             // t('key', { ns: 'oldNs' }) -> t('key')
             const nsRegexToDefault = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.key)}\\1\\s*,\\s*\\{([^}]*)\\bns\\s*:\\s*(['"\`])${escapeRegex(oldParts.namespace)}\\3([^}]*)\\}\\s*\\)`, 'g');
             newCode = newCode.replace(nsRegexToDefault, (match, keyQ, beforeNs, nsQ, afterNs) => {
                 changes++;
                 // Build remaining object props (everything except the ns property)
                 const obj = (beforeNs + afterNs).replace(/,?\s*$/, '').replace(/^\s*,?/, '').trim();
-                // Start by replacing the key string itself, preserving the original quote style
+                // Replace the key string itself, preserving the original quote style
                 let updated = match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1`), `${keyQ}${newParts.key}${keyQ}`);
                 if (obj) {
-                    // If other properties remain, replace the whole object content with the cleaned props
+                    // If other properties remain, keep them
                     updated = updated.replace(/\{\s*([^}]*)\s*\}/, `{${obj}}`);
                 }
                 else {
-                    // No other props — remove the whole options object (", { ... }") leaving "fn('key')"
+                    // No other props — remove the options object entirely
                     updated = updated.replace(/\s*,\s*\{[^}]*\}\s*\)/, ')');
                 }
                 return updated;
             });
         }
-        // Handle ns option in options object: fn('key', { ns: 'oldNs', ... })
-        if (oldParts.namespace && newParts.namespace && oldParts.namespace !== newParts.namespace) {
-            // We want to change only when key matches and ns value equals oldParts.namespace
+        // 2) Update ns option value when moving across namespaces (when options are present)
+        // Only attempt to update the ns option if the old namespace actually contains the key.
+        if (oldParts.namespace && newParts.namespace && oldParts.namespace !== newParts.namespace && hasKeyInNamespace(oldParts.namespace)) {
+            // case where key is bare (e.g. t('key', { ns: 'oldNs', ... }))
             const nsRegexFullKey = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.key)}\\1\\s*,\\s*\\{([^}]*)\\bns\\s*:\\s*(['"\`])${escapeRegex(oldParts.namespace)}\\3([^}]*)\\}\\s*\\)`, 'g');
-            newCode = newCode.replace(nsRegexFullKey, (match, keyQ, beforeNs, nsQ, afterNs) => {
+            newCode = newCode.replace(nsRegexFullKey, (match) => {
                 changes++;
                 // replace ns value
                 return match.replace(new RegExp(`(\\bns\\s*:\\s*['"\`])${escapeRegex(oldParts.namespace ?? '')}(['"\`])`), `$1${newParts.namespace ?? ''}$2`);
             });
-            // same but if the call used fullKey (ns included inside key string), still update ns option if present
-            if (oldParts.fullKey) {
+            // case where fullKey was used inside the string (e.g. t('ns:key', { ns: 'oldNs' }))
+            if (oldParts.fullKey && oldParts.explicitNamespace) {
                 const nsRegexFull = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.fullKey)}\\1\\s*,\\s*\\{([^}]*)\\bns\\s*:\\s*(['"\`])${escapeRegex(oldParts.namespace)}\\3([^}]*)\\}\\s*\\)`, 'g');
                 newCode = newCode.replace(nsRegexFull, (match) => {
                     changes++;
@@ -286,46 +306,73 @@ function replaceKeyWithRegex(code, oldParts, newParts, config) {
                 });
             }
         }
-    }
-    // Selector API: dot-notation: fn(($) => $.old.key)
-    for (const fnPattern of configuredFunctions) {
-        const prefix = fnPrefixToRegex(fnPattern);
-        // match forms like: prefix( $ => $.old.key )
-        // capture the arrow param name and the rest
-        // We'll attempt to match the param and the dotted property chain equal to oldParts.key (exact)
-        const dotRegex = new RegExp(`${prefix}\\s*\\(\\s*\\(?\\s*([a-zA-Z_$][\\w$]*)\\s*\\)?\\s*=>\\s*\\1\\.${escapeRegex(oldParts.key)}\\s*\\)`, 'g');
-        newCode = newCode.replace(dotRegex, (match, param) => {
-            changes++;
-            // Determine replacement (if source used namespace in key it would be fullKey, but in selector dot-notation it's always key form)
-            const replacementKey = newParts.key;
-            return match.replace(`.${oldParts.key}`, `.${replacementKey}`);
-        });
-        // Bracket notation: fn(($) => $["Old Key"]) etc.
-        const bracketRegex = new RegExp(`${prefix}\\s*\\(\\s*\\(?\\s*([a-zA-Z_$][\\w$]*)\\s*\\)?\\s*=>\\s*\\1\\s*\\[\\s*(['"\`])${escapeRegex(oldParts.key)}\\2\\s*\\]\\s*\\)`, 'g');
-        newCode = newCode.replace(bracketRegex, (match, param, quote) => {
-            changes++;
-            const replacementKey = newParts.key;
-            // If replacementKey is a valid identifier, convert to dot-notation, otherwise keep bracket form with preserved quote style
-            if (/^[A-Za-z_$][\w$]*$/.test(replacementKey)) {
-                return match.replace(new RegExp(`\\[\\s*['"\`]${escapeRegex(oldParts.key)}['"\`]\\s*\\]`), `.${replacementKey}`);
-            }
-            else {
-                return match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1`), `$1${replacementKey}$1`);
-            }
-        });
-    }
-    // JSX i18nKey attribute (handles all quote types)
-    const jsxPatterns = [
-        { orig: oldParts.fullKey, regex: new RegExp(`i18nKey=(['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g') },
-        { orig: oldParts.key, regex: new RegExp(`i18nKey=(['"\`])${escapeRegex(oldParts.key)}\\1`, 'g') }
-    ];
-    for (const p of jsxPatterns) {
-        newCode = newCode.replace(p.regex, (match, q) => {
-            changes++;
-            const nsSepStr = nsSeparator === false ? ':' : nsSeparator;
-            const replacement = (p.orig === oldParts.fullKey && oldParts.fullKey.includes(nsSepStr)) ? newParts.fullKey : newParts.key;
-            return `i18nKey=${q}${replacement}${q}`;
-        });
+        // 3) Replace occurrences where the call uses the fullKey inside the string (e.g. t('ns:key'))
+        if (oldParts.fullKey && oldParts.explicitNamespace) {
+            const regexFull = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g');
+            newCode = newCode.replace(regexFull, (match) => {
+                changes++;
+                const replacementKey = (oldParts.fullKey.includes(nsSeparator || ':') ? newParts.fullKey : newParts.key);
+                return match.replace(oldParts.fullKey, replacementKey);
+            });
+        }
+        // 4) Handle selector / arrow and bracket forms (these are always "key form" so safe to replace)
+        // Selector API: dot-notation: fn(($) => $.old.key)
+        {
+            const dotRegex = new RegExp(`${prefix}\\s*\\(\\s*\\(?\\s*([a-zA-Z_$][\\w$]*)\\s*\\)?\\s*=>\\s*\\1\\.${escapeRegex(oldParts.key)}\\s*\\)`, 'g');
+            newCode = newCode.replace(dotRegex, (match) => {
+                changes++;
+                const replacementKey = newParts.key;
+                return match.replace(`.${oldParts.key}`, `.${replacementKey}`);
+            });
+            const bracketRegex = new RegExp(`${prefix}\\s*\\(\\s*\\(?\\s*([a-zA-Z_$][\\w$]*)\\s*\\)?\\s*=>\\s*\\1\\s*\\[\\s*(['"\`])${escapeRegex(oldParts.key)}\\2\\s*\\]\\s*\\)`, 'g');
+            newCode = newCode.replace(bracketRegex, (match) => {
+                changes++;
+                const replacementKey = newParts.key;
+                if (/^[A-Za-z_$][\w$]*$/.test(replacementKey)) {
+                    return match.replace(new RegExp(`\\[\\s*['"\`]${escapeRegex(oldParts.key)}['"\`]\\s*\\]`), `.${replacementKey}`);
+                }
+                else {
+                    return match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1`), `$1${replacementKey}$1`);
+                }
+            });
+        }
+        // 5) Replace bare calls WITHOUT an options object: fn('key') -> fn('newKey')
+        //    We purposely only match when the string is directly followed by the closing paren (no comma/options).
+        {
+            const regexKeyNoOptions = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.key)}\\1\\s*\\)`, 'g');
+            newCode = newCode.replace(regexKeyNoOptions, (match, q) => {
+                changes++;
+                const replacementKey = newParts.key;
+                return match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1`), `${q}${replacementKey}${q}`);
+            });
+        }
+        // 6) Handle the case where we have fn('key', /*no ns*/ { otherProps }) and we are moving
+        //    from defaultNS to another namespace: add ns when appropriate.
+        // This block is only relevant when moving FROM defaultNS (add ns option). Only perform it
+        // if the old key exists in the old namespace (if we tracked one).
+        if (oldParts.namespace && newParts.namespace &&
+            oldParts.namespace !== newParts.namespace &&
+            config.extract.defaultNS === oldParts.namespace &&
+            hasKeyInNamespace(oldParts.namespace)) {
+            const regexKeyWithParen = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.key)}\\1\\s*\\)`, 'g');
+            newCode = newCode.replace(regexKeyWithParen, (match, quote) => {
+                changes++;
+                return match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1\\s*\\)`), `${quote}${newParts.key}${quote}, { ns: '${newParts.namespace}' })`);
+            });
+        }
+        // 7) JSX i18nKey attribute (handles both fullKey and key)
+        const jsxPatterns = [
+            { orig: oldParts.fullKey, regex: new RegExp(`i18nKey=(['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g') },
+            { orig: oldParts.key, regex: new RegExp(`i18nKey=(['"\`])${escapeRegex(oldParts.key)}\\1`, 'g') }
+        ];
+        for (const p of jsxPatterns) {
+            newCode = newCode.replace(p.regex, (match, q) => {
+                changes++;
+                const nsSepStr = nsSeparator === false ? ':' : nsSeparator;
+                const replacement = (p.orig === oldParts.fullKey && oldParts.fullKey.includes(nsSepStr)) ? newParts.fullKey : newParts.key;
+                return `i18nKey=${q}${replacement}${q}`;
+            });
+        }
     }
     return { newCode, changes };
 }

package/package.json

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

package/types/rename-key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rename-key.d.ts","sourceRoot":"","sources":["../src/rename-key.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAQ5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,OAAO,CAAA;CACZ,EACN,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC,eAAe,CAAC,CAwD1B"}
+{"version":3,"file":"rename-key.d.ts","sourceRoot":"","sources":["../src/rename-key.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAO5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,OAAO,CAAA;CACZ,EACN,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC,eAAe,CAAC,CA6D1B"}