i18next-cli 1.39.6 → 1.39.8

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

@@ -56,13 +56,21 @@ async function runRenameKey(config, oldKey, newKey, options = {}, logger$1 = new
     // 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'
-        };
+        // If the old key doesn't exist in any translation file, treat this as a
+        // no-op (allow the command to succeed). This mirrors previous behavior
+        // where renaming a missing key doesn't fail just because the target
+        // already exists (it avoids blocking repeated/no-op renames).
+        const oldExists = await checkOldKeyExists(parseKeyWithNamespace(oldKey, config), config);
+        if (oldExists) {
+            return {
+                success: false,
+                sourceFiles: [],
+                translationFiles: [],
+                conflicts,
+                error: 'Target key already exists in translation files'
+            };
+        }
+        // otherwise: old key not present -> continue (no-op)
     }
     // 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
@@ -155,6 +163,25 @@ async function checkConflicts(newParts, config) {
     }
     return conflicts;
 }
+async function checkOldKeyExists(oldParts, config) {
+    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) {
+                const val = nestedObject.getNestedValue(translations, oldParts.key, keySeparator);
+                if (val !== undefined)
+                    return true;
+            }
+        }
+        catch {
+            // file missing — continue to next locale
+        }
+    }
+    return false;
+}
 async function buildNamespaceKeyMap(config) {
     // Map namespace -> set of flattened keys present in that namespace (union across locales)
     const map = new Map();
@@ -246,11 +273,9 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
     // Helper to create function-prefix regex fragment
     const fnPrefixToRegex = (fnPattern) => {
         if (fnPattern.startsWith('*.')) {
-            // '*.t' -> match anyIdentifier.t
             const suffix = fnPattern.slice(2);
-            return `\\b[\\w$]+\\.${escapeRegex(suffix)}`; // e.g. \b[\w$]+\.t
+            return `\\b[\\w$]+\\.${escapeRegex(suffix)}`;
         }
-        // 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)
@@ -260,55 +285,73 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
         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);
-        // 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
+        //
+        // 1) If moving TO the defaultNS, remove the explicit ns option and update key in one go.
+        //    Only if the old key exists in the old namespace.
+        //
         if (oldParts.namespace && newParts.namespace &&
             oldParts.namespace !== 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();
-                // 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, keep them
                     updated = updated.replace(/\{\s*([^}]*)\s*\}/, `{${obj}}`);
                 }
                 else {
-                    // No other props — remove the options object entirely
                     updated = updated.replace(/\s*,\s*\{[^}]*\}\s*\)/, ')');
                 }
                 return updated;
             });
         }
-        // 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', ... }))
+        //
+        // 2) Handle calls that include an options object with ns: 'oldNs'.
+        //    This covers both:
+        //      - renames *inside the same namespace* (ns stays the same, key changes),
+        //      - renames *across namespaces* (ns changes to new namespace OR removed if new default).
+        //    Only run if old namespace actually contains the key (to avoid touching unrelated ns calls).
+        //
+        if (oldParts.namespace && newParts.namespace && hasKeyInNamespace(oldParts.namespace)) {
             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) => {
+            newCode = newCode.replace(nsRegexFullKey, (match, keyQ, beforeNs, nsQ, afterNs) => {
                 changes++;
-                // replace ns value
-                return match.replace(new RegExp(`(\\bns\\s*:\\s*['"\`])${escapeRegex(oldParts.namespace ?? '')}(['"\`])`), `$1${newParts.namespace ?? ''}$2`);
+                // remaining props except ns
+                const obj = (beforeNs + afterNs).replace(/,?\s*$/, '').replace(/^\s*,?/, '').trim();
+                // start by replacing the key (preserve original quote style)
+                let updated = match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1`), `${keyQ}${newParts.key}${keyQ}`);
+                if (oldParts.namespace === newParts.namespace) {
+                    // same namespace: keep ns value untouched, but keep other props
+                    if (obj) {
+                        updated = updated.replace(/\{\s*([^}]*)\s*\}/, `{${obj}}`);
+                    }
+                }
+                else {
+                    // moving across namespaces
+                    if (config.extract.defaultNS === newParts.namespace) {
+                        // moving INTO the default namespace -> remove the ns property
+                        if (obj) {
+                            updated = updated.replace(/\{\s*([^}]*)\s*\}/, `{${obj}}`);
+                        }
+                        else {
+                            updated = updated.replace(/\s*,\s*\{[^}]*\}\s*\)/, ')');
+                        }
+                    }
+                    else {
+                        // replace ns value to new namespace
+                        updated = updated.replace(new RegExp(`(\\bns\\s*:\\s*['"\`])${escapeRegex(oldParts.namespace ?? '')}(['"\`])`), `$1${newParts.namespace ?? ''}$2`);
+                    }
+                }
+                return updated;
             });
-            // 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++;
-                    return match.replace(new RegExp(`(\\bns\\s*:\\s*['"\`])${escapeRegex(oldParts.namespace ?? '')}(['"\`])`), `$1${newParts.namespace ?? ''}$2`);
-                });
-            }
         }
-        // 3) Replace occurrences where the call uses the fullKey inside the string (e.g. t('ns:key'))
+        //
+        // 3) fullKey (explicitly namespaced string in call): only when user supplied a namespaced target
+        //
         if (oldParts.fullKey && oldParts.explicitNamespace) {
             const regexFull = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g');
             newCode = newCode.replace(regexFull, (match) => {
@@ -317,14 +360,14 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
                 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)
+        //
+        // 4) Selector / bracket forms
+        //
         {
             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}`);
+                return match.replace(`.${oldParts.key}`, `.${newParts.key}`);
             });
             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) => {
@@ -338,20 +381,11 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
                 }
             });
         }
-        // 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).
+        //
+        // 5) Special-case: moving FROM defaultNS to another namespace for bare calls.
+        //    Add ns option for bare calls. This must happen *before* the plain bare-call replacement
+        //    so the final call includes the ns option.
+        //
         if (oldParts.namespace && newParts.namespace &&
             oldParts.namespace !== newParts.namespace &&
             config.extract.defaultNS === oldParts.namespace &&
@@ -362,18 +396,41 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
                 return match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1\\s*\\)`), `${quote}${newParts.key}${quote}, { ns: '${newParts.namespace}' })`);
             });
         }
+        //
+        // 6) Bare calls without options: fn('key') -> fn('newKey')
+        //    Apply this replacement only when the old key's namespace is the
+        //    *effective* default namespace (config.extract.defaultNS ?? 'translation').
+        //    This preserves previous behaviour: default-namespace bare-calls are
+        //    considered "key form" and should be rewritten even when the translation
+        //    file exists but the specific key isn't present.
+        //
+        {
+            const effectiveDefaultNS = config.extract.defaultNS ?? 'translation';
+            if (oldParts.namespace === effectiveDefaultNS) {
+                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}`);
+                });
+            }
+        }
+        //
         // 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}`;
-            });
+        //
+        {
+            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.6'); // This string is replaced with the actual version at build time by rollup
+    .version('1.39.8'); // 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

@@ -54,13 +54,21 @@ async function runRenameKey(config, oldKey, newKey, options = {}, logger = new C
     // 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'
-        };
+        // If the old key doesn't exist in any translation file, treat this as a
+        // no-op (allow the command to succeed). This mirrors previous behavior
+        // where renaming a missing key doesn't fail just because the target
+        // already exists (it avoids blocking repeated/no-op renames).
+        const oldExists = await checkOldKeyExists(parseKeyWithNamespace(oldKey, config), config);
+        if (oldExists) {
+            return {
+                success: false,
+                sourceFiles: [],
+                translationFiles: [],
+                conflicts,
+                error: 'Target key already exists in translation files'
+            };
+        }
+        // otherwise: old key not present -> continue (no-op)
     }
     // 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
@@ -153,6 +161,25 @@ async function checkConflicts(newParts, config) {
     }
     return conflicts;
 }
+async function checkOldKeyExists(oldParts, config) {
+    const keySeparator = config.extract.keySeparator ?? '.';
+    for (const locale of config.locales) {
+        const outputPath = getOutputPath(config.extract.output, locale, oldParts.namespace);
+        const fullPath = resolve(process.cwd(), outputPath);
+        try {
+            const translations = await loadTranslationFile(fullPath);
+            if (translations) {
+                const val = getNestedValue(translations, oldParts.key, keySeparator);
+                if (val !== undefined)
+                    return true;
+            }
+        }
+        catch {
+            // file missing — continue to next locale
+        }
+    }
+    return false;
+}
 async function buildNamespaceKeyMap(config) {
     // Map namespace -> set of flattened keys present in that namespace (union across locales)
     const map = new Map();
@@ -244,11 +271,9 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
     // Helper to create function-prefix regex fragment
     const fnPrefixToRegex = (fnPattern) => {
         if (fnPattern.startsWith('*.')) {
-            // '*.t' -> match anyIdentifier.t
             const suffix = fnPattern.slice(2);
-            return `\\b[\\w$]+\\.${escapeRegex(suffix)}`; // e.g. \b[\w$]+\.t
+            return `\\b[\\w$]+\\.${escapeRegex(suffix)}`;
         }
-        // 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)
@@ -258,55 +283,73 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
         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);
-        // 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
+        //
+        // 1) If moving TO the defaultNS, remove the explicit ns option and update key in one go.
+        //    Only if the old key exists in the old namespace.
+        //
         if (oldParts.namespace && newParts.namespace &&
             oldParts.namespace !== 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();
-                // 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, keep them
                     updated = updated.replace(/\{\s*([^}]*)\s*\}/, `{${obj}}`);
                 }
                 else {
-                    // No other props — remove the options object entirely
                     updated = updated.replace(/\s*,\s*\{[^}]*\}\s*\)/, ')');
                 }
                 return updated;
             });
         }
-        // 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', ... }))
+        //
+        // 2) Handle calls that include an options object with ns: 'oldNs'.
+        //    This covers both:
+        //      - renames *inside the same namespace* (ns stays the same, key changes),
+        //      - renames *across namespaces* (ns changes to new namespace OR removed if new default).
+        //    Only run if old namespace actually contains the key (to avoid touching unrelated ns calls).
+        //
+        if (oldParts.namespace && newParts.namespace && hasKeyInNamespace(oldParts.namespace)) {
             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) => {
+            newCode = newCode.replace(nsRegexFullKey, (match, keyQ, beforeNs, nsQ, afterNs) => {
                 changes++;
-                // replace ns value
-                return match.replace(new RegExp(`(\\bns\\s*:\\s*['"\`])${escapeRegex(oldParts.namespace ?? '')}(['"\`])`), `$1${newParts.namespace ?? ''}$2`);
+                // remaining props except ns
+                const obj = (beforeNs + afterNs).replace(/,?\s*$/, '').replace(/^\s*,?/, '').trim();
+                // start by replacing the key (preserve original quote style)
+                let updated = match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1`), `${keyQ}${newParts.key}${keyQ}`);
+                if (oldParts.namespace === newParts.namespace) {
+                    // same namespace: keep ns value untouched, but keep other props
+                    if (obj) {
+                        updated = updated.replace(/\{\s*([^}]*)\s*\}/, `{${obj}}`);
+                    }
+                }
+                else {
+                    // moving across namespaces
+                    if (config.extract.defaultNS === newParts.namespace) {
+                        // moving INTO the default namespace -> remove the ns property
+                        if (obj) {
+                            updated = updated.replace(/\{\s*([^}]*)\s*\}/, `{${obj}}`);
+                        }
+                        else {
+                            updated = updated.replace(/\s*,\s*\{[^}]*\}\s*\)/, ')');
+                        }
+                    }
+                    else {
+                        // replace ns value to new namespace
+                        updated = updated.replace(new RegExp(`(\\bns\\s*:\\s*['"\`])${escapeRegex(oldParts.namespace ?? '')}(['"\`])`), `$1${newParts.namespace ?? ''}$2`);
+                    }
+                }
+                return updated;
             });
-            // 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++;
-                    return match.replace(new RegExp(`(\\bns\\s*:\\s*['"\`])${escapeRegex(oldParts.namespace ?? '')}(['"\`])`), `$1${newParts.namespace ?? ''}$2`);
-                });
-            }
         }
-        // 3) Replace occurrences where the call uses the fullKey inside the string (e.g. t('ns:key'))
+        //
+        // 3) fullKey (explicitly namespaced string in call): only when user supplied a namespaced target
+        //
         if (oldParts.fullKey && oldParts.explicitNamespace) {
             const regexFull = new RegExp(`${prefix}\\s*\\(\\s*(['"\`])${escapeRegex(oldParts.fullKey)}\\1`, 'g');
             newCode = newCode.replace(regexFull, (match) => {
@@ -315,14 +358,14 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
                 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)
+        //
+        // 4) Selector / bracket forms
+        //
         {
             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}`);
+                return match.replace(`.${oldParts.key}`, `.${newParts.key}`);
             });
             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) => {
@@ -336,20 +379,11 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
                 }
             });
         }
-        // 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).
+        //
+        // 5) Special-case: moving FROM defaultNS to another namespace for bare calls.
+        //    Add ns option for bare calls. This must happen *before* the plain bare-call replacement
+        //    so the final call includes the ns option.
+        //
         if (oldParts.namespace && newParts.namespace &&
             oldParts.namespace !== newParts.namespace &&
             config.extract.defaultNS === oldParts.namespace &&
@@ -360,18 +394,41 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
                 return match.replace(new RegExp(`(['"\`])${escapeRegex(oldParts.key)}\\1\\s*\\)`), `${quote}${newParts.key}${quote}, { ns: '${newParts.namespace}' })`);
             });
         }
+        //
+        // 6) Bare calls without options: fn('key') -> fn('newKey')
+        //    Apply this replacement only when the old key's namespace is the
+        //    *effective* default namespace (config.extract.defaultNS ?? 'translation').
+        //    This preserves previous behaviour: default-namespace bare-calls are
+        //    considered "key form" and should be rewritten even when the translation
+        //    file exists but the specific key isn't present.
+        //
+        {
+            const effectiveDefaultNS = config.extract.defaultNS ?? 'translation';
+            if (oldParts.namespace === effectiveDefaultNS) {
+                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}`);
+                });
+            }
+        }
+        //
         // 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}`;
-            });
+        //
+        {
+            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.6",
+  "version": "1.39.8",
   "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":"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"}
+{"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,CAqE1B"}