i18next-cli 1.47.6 → 1.47.7

package/dist/cjs/cli.js

@@ -31,7 +31,7 @@ const program = new commander.Command();
 program
     .name('i18next-cli')
     .description('A unified, high-performance i18next CLI.')
-    .version('1.47.6'); // This string is replaced with the actual version at build time by rollup
+    .version('1.47.7'); // 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/instrumenter/core/instrumenter.js

@@ -645,6 +645,12 @@ function detectJSXInterpolation(node, content, file, config, candidates) {
             else if (child.type === 'JSXExpressionContainer' && isSimpleJSXExpression(child.expression)) {
                 currentRun.push(child);
             }
+            else if (child.type === 'JSXExpressionContainer' &&
+                child.expression?.type === 'ConditionalExpression' &&
+                tryParsePluralTernary(child.expression, content)) {
+                // Plural ternary expression — include in the run for merged handling
+                currentRun.push(child);
+            }
             else {
                 // JSXElement, complex expression, etc. — break the run
                 if (currentRun.length > 0) {
@@ -661,47 +667,150 @@ function detectJSXInterpolation(node, content, file, config, candidates) {
             const hasExpr = run.some(c => c.type === 'JSXExpressionContainer');
             if (!hasText || !hasExpr || run.length < 2)
                 continue;
-            // Build the interpolated text from the run
-            const usedNames = new Set();
-            const interpolations = [];
-            let text = '';
-            let valid = true;
+            // Check if any expression container in this run is a plural ternary
+            let pluralChild = null;
+            let pluralData = null;
             for (const child of run) {
-                if (child.type === 'JSXText') {
-                    text += content.slice(child.span.start, child.span.end);
+                if (child.type === 'JSXExpressionContainer' &&
+                    child.expression?.type === 'ConditionalExpression') {
+                    const p = tryParsePluralTernary(child.expression, content);
+                    if (p) {
+                        pluralChild = child;
+                        pluralData = p;
+                        break; // only one plural ternary per run
+                    }
                 }
-                else {
-                    const info = resolveExpressionName(child.expression, content, usedNames);
-                    if (!info) {
-                        valid = false;
-                        break;
+            }
+            if (pluralChild && pluralData) {
+                // ── JSX sibling run with embedded plural ternary ──
+                const countExpr = pluralData.countExpression;
+                // Resolve names for non-count, non-plural expressions
+                const usedNames = new Set();
+                const extraInterpolations = [];
+                const exprNameMap = new Map();
+                let valid = true;
+                for (const child of run) {
+                    if (child.type === 'JSXExpressionContainer' && child !== pluralChild) {
+                        const exprText = content.slice(child.expression.span.start, child.expression.span.end);
+                        if (exprText === countExpr) {
+                            exprNameMap.set(child, 'count');
+                        }
+                        else {
+                            const info = resolveExpressionName(child.expression, content, usedNames);
+                            if (!info) {
+                                valid = false;
+                                break;
+                            }
+                            exprNameMap.set(child, info.name);
+                            extraInterpolations.push(info);
+                        }
+                    }
+                }
+                if (!valid)
+                    continue;
+                // Build merged text for each plural form
+                const forms = [
+                    ...(pluralData.zero !== undefined ? ['zero'] : []),
+                    ...(pluralData.one !== undefined ? ['one'] : []),
+                    'other'
+                ];
+                const formTexts = {};
+                for (const form of forms) {
+                    let text = '';
+                    for (const child of run) {
+                        if (child.type === 'JSXText') {
+                            text += content.slice(child.span.start, child.span.end);
+                        }
+                        else if (child === pluralChild) {
+                            const formText = form === 'zero'
+                                ? pluralData.zero
+                                : form === 'one'
+                                    ? pluralData.one
+                                    : pluralData.other;
+                            text += formText;
+                        }
+                        else {
+                            const name = exprNameMap.get(child);
+                            text += `{{${name}}}`;
+                        }
+                    }
+                    formTexts[form] = text.trim();
+                }
+                const spanStart = run[0].span.start;
+                const spanEnd = run[run.length - 1].span.end;
+                const otherText = formTexts.other;
+                if (!otherText)
+                    continue;
+                const candidate = stringDetector.detectCandidate(otherText, spanStart, spanEnd, file, content, config);
+                if (candidate) {
+                    candidate.type = 'jsx-text';
+                    candidate.content = otherText;
+                    candidate.pluralForms = {
+                        countExpression: countExpr,
+                        zero: formTexts.zero,
+                        one: formTexts.one,
+                        other: otherText
+                    };
+                    if (extraInterpolations.length > 0) {
+                        candidate.interpolations = extraInterpolations;
+                    }
+                    // Plural + JSX merge is always user-facing
+                    candidate.confidence = Math.min(1, candidate.confidence + 0.3);
+                    if (candidate.confidence >= 0.7) {
+                        // Remove individual candidates that overlap with the merged span
+                        for (let i = candidates.length - 1; i >= 0; i--) {
+                            if (candidates[i].offset >= spanStart && candidates[i].endOffset <= spanEnd) {
+                                candidates.splice(i, 1);
+                            }
+                        }
+                        candidates.push(candidate);
                     }
-                    text += `{{${info.name}}}`;
-                    interpolations.push(info);
                 }
             }
-            if (!valid)
-                continue;
-            const trimmed = text.trim();
-            if (!trimmed || interpolations.length === 0)
-                continue;
-            const spanStart = run[0].span.start;
-            const spanEnd = run[run.length - 1].span.end;
-            const candidate = stringDetector.detectCandidate(trimmed, spanStart, spanEnd, file, content, config);
-            if (candidate) {
-                candidate.type = 'jsx-text';
-                candidate.content = trimmed;
-                candidate.interpolations = interpolations;
-                // Mixed text + expressions in JSX is almost always user-facing
-                candidate.confidence = Math.min(1, candidate.confidence + 0.2);
-                if (candidate.confidence >= 0.7) {
-                    // Remove individual candidates that overlap with the merged span
-                    for (let i = candidates.length - 1; i >= 0; i--) {
-                        if (candidates[i].offset >= spanStart && candidates[i].endOffset <= spanEnd) {
-                            candidates.splice(i, 1);
+            else {
+                // ── Original JSX sibling merging (no plural) ──
+                // Build the interpolated text from the run
+                const usedNames = new Set();
+                const interpolations = [];
+                let text = '';
+                let valid = true;
+                for (const child of run) {
+                    if (child.type === 'JSXText') {
+                        text += content.slice(child.span.start, child.span.end);
+                    }
+                    else {
+                        const info = resolveExpressionName(child.expression, content, usedNames);
+                        if (!info) {
+                            valid = false;
+                            break;
                         }
+                        text += `{{${info.name}}}`;
+                        interpolations.push(info);
+                    }
+                }
+                if (!valid)
+                    continue;
+                const trimmed = text.trim();
+                if (!trimmed || interpolations.length === 0)
+                    continue;
+                const spanStart = run[0].span.start;
+                const spanEnd = run[run.length - 1].span.end;
+                const candidate = stringDetector.detectCandidate(trimmed, spanStart, spanEnd, file, content, config);
+                if (candidate) {
+                    candidate.type = 'jsx-text';
+                    candidate.content = trimmed;
+                    candidate.interpolations = interpolations;
+                    // Mixed text + expressions in JSX is almost always user-facing
+                    candidate.confidence = Math.min(1, candidate.confidence + 0.2);
+                    if (candidate.confidence >= 0.7) {
+                        // Remove individual candidates that overlap with the merged span
+                        for (let i = candidates.length - 1; i >= 0; i--) {
+                            if (candidates[i].offset >= spanStart && candidates[i].endOffset <= spanEnd) {
+                                candidates.splice(i, 1);
+                            }
+                        }
+                        candidates.push(candidate);
                     }
-                    candidates.push(candidate);
                 }
             }
         }
@@ -838,6 +947,11 @@ function detectPluralPatterns(node, content, file, config, candidates) {
             // Use the "other" form as the candidate content (with {{count}})
             const spanStart = node.span.start;
             const spanEnd = node.span.end;
+            // Skip if this ternary is already covered by a wider candidate
+            // (e.g. a JSX sibling run that merged surrounding text with this plural)
+            const alreadyHandled = candidates.some(c => c.pluralForms && c.offset <= spanStart && c.endOffset >= spanEnd);
+            if (alreadyHandled)
+                return;
             const candidate = stringDetector.detectCandidate(plural.other, spanStart, spanEnd, file, content, config);
             if (candidate) {
                 candidate.type = 'string-literal';

package/dist/cjs/instrumenter/core/transformer.js

@@ -196,6 +196,12 @@ function buildReplacement(candidate, key, useHookStyle, namespace) {
         }
         optionEntries.push(`defaultValue_other: '${escapeString(pf.other)}'`);
         optionEntries.push(`count: ${pf.countExpression}`);
+        // Add extra interpolation variables (e.g. from JSX sibling merging with plurals)
+        if (candidate.interpolations?.length) {
+            for (const interp of candidate.interpolations) {
+                optionEntries.push(interp.name === interp.expression ? interp.name : `${interp.name}: ${interp.expression}`);
+            }
+        }
         if (!useHookStyle && namespace) {
             optionEntries.push(`ns: '${namespace}'`);
         }

package/dist/cjs/linter.js

@@ -101,6 +101,34 @@ function isI18nextOptionKey(key) {
         return true;
     return false;
 }
+// ─── Ignore-comment helpers ──────────────────────────────────────────────────
+/**
+ * Regex matching the shared ignore directive used by both the instrumenter and
+ * the linter.  Supports both `-next-line` and inline variants, in line or block
+ * comment form.
+ *
+ *   // i18next-instrument-ignore-next-line   → suppresses the following line
+ *   // i18next-instrument-ignore             → suppresses the following line
+ *   { /* i18next-instrument-ignore * / }     → same, block-comment form
+ */
+const LINT_IGNORE_RE = /i18next-instrument-ignore(?:-next-line)?/;
+/**
+ * Scans `code` for ignore-directive comments and returns a Set of 1-based
+ * line numbers whose issues should be suppressed.
+ *
+ * The directive always suppresses the **next** line (line N+1), matching the
+ * behaviour of the instrumenter's `collectIgnoredLines`.
+ */
+function collectLintIgnoredLines(code) {
+    const ignored = new Set();
+    const lines = code.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        if (LINT_IGNORE_RE.test(lines[i])) {
+            ignored.add(i + 2); // 1-based: directive is on line i+1, suppressed line is i+2
+        }
+    }
+    return ignored;
+}
 // Helper to lint interpolation parameter errors in t() calls
 function lintInterpolationParams(ast, code, config, translationValues) {
     const issues = [];
@@ -168,14 +196,27 @@ function lintInterpolationParams(ast, code, config, translationValues) {
             // Support both .expression and direct node for arguments
             const arg0raw = node.arguments?.[0];
             const arg1raw = node.arguments?.[1];
+            const arg2raw = node.arguments?.[2];
             const arg0 = arg0raw?.expression ?? arg0raw;
             const arg1 = arg1raw?.expression ?? arg1raw;
-            // Only check interpolation params if the first argument is a string literal (translation key or string)
+            const arg2 = arg2raw?.expression ?? arg2raw;
+            // Only check interpolation params if the first argument is a string literal
             if (arg0?.type === 'StringLiteral') {
                 const keyOrStr = arg0.value;
+                // Detect 3-argument form: t('key', 'Default string {{foo}}', { foo })
+                // In this form arg1 is the default string and arg2 is the params object.
+                const isThreeArgForm = arg1?.type === 'StringLiteral' && arg2 !== undefined;
+                const translationArg = isThreeArgForm ? arg1 : arg0;
+                const paramsArg = isThreeArgForm ? arg2 : arg1;
+                // If a params argument exists but is NOT an object literal (e.g. it's a variable),
+                // we cannot statically determine its keys — skip the interpolation check to avoid
+                // false positives.
+                if (paramsArg && paramsArg.type !== 'ObjectExpression') {
+                    return;
+                }
                 let paramKeys = [];
-                if (arg1?.type === 'ObjectExpression') {
-                    paramKeys = arg1.properties
+                if (paramsArg?.type === 'ObjectExpression') {
+                    paramKeys = paramsArg.properties
                         .map((p) => {
                         // Standard key:value property like { name: "value" }
                         if (p.type === 'KeyValueProperty' && p.key) {
@@ -195,10 +236,17 @@ function lintInterpolationParams(ast, code, config, translationValues) {
                 }
                 if (!Array.isArray(paramKeys))
                     paramKeys = [];
-                // Resolve the actual translation string to check against:
-                // fix — if the first arg is a lookup key (no interpolation markers of its own)
-                // and we have a loaded translation map, use the translated value instead.
-                const resolvedStr = translationValues?.get(keyOrStr) ?? keyOrStr;
+                // Resolve the actual translation string:
+                // - For 3-arg form: the default string is always arg1 (use it directly)
+                // - For 2-arg / 1-arg form: if arg0 is a lookup key (no interpolation markers),
+                //   try to resolve it from the loaded translation map.
+                let resolvedStr;
+                if (isThreeArgForm) {
+                    resolvedStr = translationArg.value;
+                }
+                else {
+                    resolvedStr = translationValues?.get(keyOrStr) ?? keyOrStr;
+                }
                 const searchText = arg0.raw ?? `"${arg0.value}"`;
                 callSites.push({ translationStr: resolvedStr, searchText, paramKeys });
             }
@@ -360,6 +408,12 @@ class Linter extends node_events.EventEmitter {
                 // Collect interpolation parameter issues
                 const interpolationIssues = lintInterpolationParams(ast, code, config, translationValues);
                 let allIssues = [...hardcodedStrings, ...interpolationIssues];
+                // Filter issues suppressed by ignore-directive comments.
+                // The directive on line N suppresses all issues reported on line N+1.
+                const ignoredLines = collectLintIgnoredLines(code);
+                if (ignoredLines.size > 0) {
+                    allIssues = allIssues.filter(issue => !ignoredLines.has(issue.line));
+                }
                 allIssues = await this.runLintOnResultPipeline(file, allIssues, plugins);
                 if (allIssues.length > 0) {
                     totalIssues += allIssues.length;

package/dist/esm/cli.js

@@ -29,7 +29,7 @@ const program = new Command();
 program
     .name('i18next-cli')
     .description('A unified, high-performance i18next CLI.')
-    .version('1.47.6'); // This string is replaced with the actual version at build time by rollup
+    .version('1.47.7'); // 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/instrumenter/core/instrumenter.js

@@ -643,6 +643,12 @@ function detectJSXInterpolation(node, content, file, config, candidates) {
             else if (child.type === 'JSXExpressionContainer' && isSimpleJSXExpression(child.expression)) {
                 currentRun.push(child);
             }
+            else if (child.type === 'JSXExpressionContainer' &&
+                child.expression?.type === 'ConditionalExpression' &&
+                tryParsePluralTernary(child.expression, content)) {
+                // Plural ternary expression — include in the run for merged handling
+                currentRun.push(child);
+            }
             else {
                 // JSXElement, complex expression, etc. — break the run
                 if (currentRun.length > 0) {
@@ -659,47 +665,150 @@ function detectJSXInterpolation(node, content, file, config, candidates) {
             const hasExpr = run.some(c => c.type === 'JSXExpressionContainer');
             if (!hasText || !hasExpr || run.length < 2)
                 continue;
-            // Build the interpolated text from the run
-            const usedNames = new Set();
-            const interpolations = [];
-            let text = '';
-            let valid = true;
+            // Check if any expression container in this run is a plural ternary
+            let pluralChild = null;
+            let pluralData = null;
             for (const child of run) {
-                if (child.type === 'JSXText') {
-                    text += content.slice(child.span.start, child.span.end);
+                if (child.type === 'JSXExpressionContainer' &&
+                    child.expression?.type === 'ConditionalExpression') {
+                    const p = tryParsePluralTernary(child.expression, content);
+                    if (p) {
+                        pluralChild = child;
+                        pluralData = p;
+                        break; // only one plural ternary per run
+                    }
                 }
-                else {
-                    const info = resolveExpressionName(child.expression, content, usedNames);
-                    if (!info) {
-                        valid = false;
-                        break;
+            }
+            if (pluralChild && pluralData) {
+                // ── JSX sibling run with embedded plural ternary ──
+                const countExpr = pluralData.countExpression;
+                // Resolve names for non-count, non-plural expressions
+                const usedNames = new Set();
+                const extraInterpolations = [];
+                const exprNameMap = new Map();
+                let valid = true;
+                for (const child of run) {
+                    if (child.type === 'JSXExpressionContainer' && child !== pluralChild) {
+                        const exprText = content.slice(child.expression.span.start, child.expression.span.end);
+                        if (exprText === countExpr) {
+                            exprNameMap.set(child, 'count');
+                        }
+                        else {
+                            const info = resolveExpressionName(child.expression, content, usedNames);
+                            if (!info) {
+                                valid = false;
+                                break;
+                            }
+                            exprNameMap.set(child, info.name);
+                            extraInterpolations.push(info);
+                        }
+                    }
+                }
+                if (!valid)
+                    continue;
+                // Build merged text for each plural form
+                const forms = [
+                    ...(pluralData.zero !== undefined ? ['zero'] : []),
+                    ...(pluralData.one !== undefined ? ['one'] : []),
+                    'other'
+                ];
+                const formTexts = {};
+                for (const form of forms) {
+                    let text = '';
+                    for (const child of run) {
+                        if (child.type === 'JSXText') {
+                            text += content.slice(child.span.start, child.span.end);
+                        }
+                        else if (child === pluralChild) {
+                            const formText = form === 'zero'
+                                ? pluralData.zero
+                                : form === 'one'
+                                    ? pluralData.one
+                                    : pluralData.other;
+                            text += formText;
+                        }
+                        else {
+                            const name = exprNameMap.get(child);
+                            text += `{{${name}}}`;
+                        }
+                    }
+                    formTexts[form] = text.trim();
+                }
+                const spanStart = run[0].span.start;
+                const spanEnd = run[run.length - 1].span.end;
+                const otherText = formTexts.other;
+                if (!otherText)
+                    continue;
+                const candidate = detectCandidate(otherText, spanStart, spanEnd, file, content, config);
+                if (candidate) {
+                    candidate.type = 'jsx-text';
+                    candidate.content = otherText;
+                    candidate.pluralForms = {
+                        countExpression: countExpr,
+                        zero: formTexts.zero,
+                        one: formTexts.one,
+                        other: otherText
+                    };
+                    if (extraInterpolations.length > 0) {
+                        candidate.interpolations = extraInterpolations;
+                    }
+                    // Plural + JSX merge is always user-facing
+                    candidate.confidence = Math.min(1, candidate.confidence + 0.3);
+                    if (candidate.confidence >= 0.7) {
+                        // Remove individual candidates that overlap with the merged span
+                        for (let i = candidates.length - 1; i >= 0; i--) {
+                            if (candidates[i].offset >= spanStart && candidates[i].endOffset <= spanEnd) {
+                                candidates.splice(i, 1);
+                            }
+                        }
+                        candidates.push(candidate);
                     }
-                    text += `{{${info.name}}}`;
-                    interpolations.push(info);
                 }
             }
-            if (!valid)
-                continue;
-            const trimmed = text.trim();
-            if (!trimmed || interpolations.length === 0)
-                continue;
-            const spanStart = run[0].span.start;
-            const spanEnd = run[run.length - 1].span.end;
-            const candidate = detectCandidate(trimmed, spanStart, spanEnd, file, content, config);
-            if (candidate) {
-                candidate.type = 'jsx-text';
-                candidate.content = trimmed;
-                candidate.interpolations = interpolations;
-                // Mixed text + expressions in JSX is almost always user-facing
-                candidate.confidence = Math.min(1, candidate.confidence + 0.2);
-                if (candidate.confidence >= 0.7) {
-                    // Remove individual candidates that overlap with the merged span
-                    for (let i = candidates.length - 1; i >= 0; i--) {
-                        if (candidates[i].offset >= spanStart && candidates[i].endOffset <= spanEnd) {
-                            candidates.splice(i, 1);
+            else {
+                // ── Original JSX sibling merging (no plural) ──
+                // Build the interpolated text from the run
+                const usedNames = new Set();
+                const interpolations = [];
+                let text = '';
+                let valid = true;
+                for (const child of run) {
+                    if (child.type === 'JSXText') {
+                        text += content.slice(child.span.start, child.span.end);
+                    }
+                    else {
+                        const info = resolveExpressionName(child.expression, content, usedNames);
+                        if (!info) {
+                            valid = false;
+                            break;
                         }
+                        text += `{{${info.name}}}`;
+                        interpolations.push(info);
+                    }
+                }
+                if (!valid)
+                    continue;
+                const trimmed = text.trim();
+                if (!trimmed || interpolations.length === 0)
+                    continue;
+                const spanStart = run[0].span.start;
+                const spanEnd = run[run.length - 1].span.end;
+                const candidate = detectCandidate(trimmed, spanStart, spanEnd, file, content, config);
+                if (candidate) {
+                    candidate.type = 'jsx-text';
+                    candidate.content = trimmed;
+                    candidate.interpolations = interpolations;
+                    // Mixed text + expressions in JSX is almost always user-facing
+                    candidate.confidence = Math.min(1, candidate.confidence + 0.2);
+                    if (candidate.confidence >= 0.7) {
+                        // Remove individual candidates that overlap with the merged span
+                        for (let i = candidates.length - 1; i >= 0; i--) {
+                            if (candidates[i].offset >= spanStart && candidates[i].endOffset <= spanEnd) {
+                                candidates.splice(i, 1);
+                            }
+                        }
+                        candidates.push(candidate);
                     }
-                    candidates.push(candidate);
                 }
             }
         }
@@ -836,6 +945,11 @@ function detectPluralPatterns(node, content, file, config, candidates) {
             // Use the "other" form as the candidate content (with {{count}})
             const spanStart = node.span.start;
             const spanEnd = node.span.end;
+            // Skip if this ternary is already covered by a wider candidate
+            // (e.g. a JSX sibling run that merged surrounding text with this plural)
+            const alreadyHandled = candidates.some(c => c.pluralForms && c.offset <= spanStart && c.endOffset >= spanEnd);
+            if (alreadyHandled)
+                return;
             const candidate = detectCandidate(plural.other, spanStart, spanEnd, file, content, config);
             if (candidate) {
                 candidate.type = 'string-literal';

package/dist/esm/instrumenter/core/transformer.js

@@ -194,6 +194,12 @@ function buildReplacement(candidate, key, useHookStyle, namespace) {
         }
         optionEntries.push(`defaultValue_other: '${escapeString(pf.other)}'`);
         optionEntries.push(`count: ${pf.countExpression}`);
+        // Add extra interpolation variables (e.g. from JSX sibling merging with plurals)
+        if (candidate.interpolations?.length) {
+            for (const interp of candidate.interpolations) {
+                optionEntries.push(interp.name === interp.expression ? interp.name : `${interp.name}: ${interp.expression}`);
+            }
+        }
         if (!useHookStyle && namespace) {
             optionEntries.push(`ns: '${namespace}'`);
         }

package/dist/esm/linter.js

@@ -99,6 +99,34 @@ function isI18nextOptionKey(key) {
         return true;
     return false;
 }
+// ─── Ignore-comment helpers ──────────────────────────────────────────────────
+/**
+ * Regex matching the shared ignore directive used by both the instrumenter and
+ * the linter.  Supports both `-next-line` and inline variants, in line or block
+ * comment form.
+ *
+ *   // i18next-instrument-ignore-next-line   → suppresses the following line
+ *   // i18next-instrument-ignore             → suppresses the following line
+ *   { /* i18next-instrument-ignore * / }     → same, block-comment form
+ */
+const LINT_IGNORE_RE = /i18next-instrument-ignore(?:-next-line)?/;
+/**
+ * Scans `code` for ignore-directive comments and returns a Set of 1-based
+ * line numbers whose issues should be suppressed.
+ *
+ * The directive always suppresses the **next** line (line N+1), matching the
+ * behaviour of the instrumenter's `collectIgnoredLines`.
+ */
+function collectLintIgnoredLines(code) {
+    const ignored = new Set();
+    const lines = code.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        if (LINT_IGNORE_RE.test(lines[i])) {
+            ignored.add(i + 2); // 1-based: directive is on line i+1, suppressed line is i+2
+        }
+    }
+    return ignored;
+}
 // Helper to lint interpolation parameter errors in t() calls
 function lintInterpolationParams(ast, code, config, translationValues) {
     const issues = [];
@@ -166,14 +194,27 @@ function lintInterpolationParams(ast, code, config, translationValues) {
             // Support both .expression and direct node for arguments
             const arg0raw = node.arguments?.[0];
             const arg1raw = node.arguments?.[1];
+            const arg2raw = node.arguments?.[2];
             const arg0 = arg0raw?.expression ?? arg0raw;
             const arg1 = arg1raw?.expression ?? arg1raw;
-            // Only check interpolation params if the first argument is a string literal (translation key or string)
+            const arg2 = arg2raw?.expression ?? arg2raw;
+            // Only check interpolation params if the first argument is a string literal
             if (arg0?.type === 'StringLiteral') {
                 const keyOrStr = arg0.value;
+                // Detect 3-argument form: t('key', 'Default string {{foo}}', { foo })
+                // In this form arg1 is the default string and arg2 is the params object.
+                const isThreeArgForm = arg1?.type === 'StringLiteral' && arg2 !== undefined;
+                const translationArg = isThreeArgForm ? arg1 : arg0;
+                const paramsArg = isThreeArgForm ? arg2 : arg1;
+                // If a params argument exists but is NOT an object literal (e.g. it's a variable),
+                // we cannot statically determine its keys — skip the interpolation check to avoid
+                // false positives.
+                if (paramsArg && paramsArg.type !== 'ObjectExpression') {
+                    return;
+                }
                 let paramKeys = [];
-                if (arg1?.type === 'ObjectExpression') {
-                    paramKeys = arg1.properties
+                if (paramsArg?.type === 'ObjectExpression') {
+                    paramKeys = paramsArg.properties
                         .map((p) => {
                         // Standard key:value property like { name: "value" }
                         if (p.type === 'KeyValueProperty' && p.key) {
@@ -193,10 +234,17 @@ function lintInterpolationParams(ast, code, config, translationValues) {
                 }
                 if (!Array.isArray(paramKeys))
                     paramKeys = [];
-                // Resolve the actual translation string to check against:
-                // fix — if the first arg is a lookup key (no interpolation markers of its own)
-                // and we have a loaded translation map, use the translated value instead.
-                const resolvedStr = translationValues?.get(keyOrStr) ?? keyOrStr;
+                // Resolve the actual translation string:
+                // - For 3-arg form: the default string is always arg1 (use it directly)
+                // - For 2-arg / 1-arg form: if arg0 is a lookup key (no interpolation markers),
+                //   try to resolve it from the loaded translation map.
+                let resolvedStr;
+                if (isThreeArgForm) {
+                    resolvedStr = translationArg.value;
+                }
+                else {
+                    resolvedStr = translationValues?.get(keyOrStr) ?? keyOrStr;
+                }
                 const searchText = arg0.raw ?? `"${arg0.value}"`;
                 callSites.push({ translationStr: resolvedStr, searchText, paramKeys });
             }
@@ -358,6 +406,12 @@ class Linter extends EventEmitter {
                 // Collect interpolation parameter issues
                 const interpolationIssues = lintInterpolationParams(ast, code, config, translationValues);
                 let allIssues = [...hardcodedStrings, ...interpolationIssues];
+                // Filter issues suppressed by ignore-directive comments.
+                // The directive on line N suppresses all issues reported on line N+1.
+                const ignoredLines = collectLintIgnoredLines(code);
+                if (ignoredLines.size > 0) {
+                    allIssues = allIssues.filter(issue => !ignoredLines.has(issue.line));
+                }
                 allIssues = await this.runLintOnResultPipeline(file, allIssues, plugins);
                 if (allIssues.length > 0) {
                     totalIssues += allIssues.length;

package/package.json

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

package/types/instrumenter/core/instrumenter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrumenter.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/core/instrumenter.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,eAAe,EAA6B,sBAAsB,EAAiE,MAAM,aAAa,CAAA;AAUvN;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,oBAAoB,EAC5B,OAAO,EAAE,mBAAmB,EAC5B,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC,sBAAsB,CAAC,CA8MjC;AA81CD;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,eAAe,EAAE,EAC7B,MAAM,EAAE,oBAAoB,EAC5B,SAAS,CAAC,EAAE,MAAM,EAClB,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC,IAAI,CAAC,CAoDf"}
+{"version":3,"file":"instrumenter.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/core/instrumenter.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,eAAe,EAA6B,sBAAsB,EAAiE,MAAM,aAAa,CAAA;AAUvN;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,oBAAoB,EAC5B,OAAO,EAAE,mBAAmB,EAC5B,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC,sBAAsB,CAAC,CA8MjC;AAs9CD;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,eAAe,EAAE,EAC7B,MAAM,EAAE,oBAAoB,EAC5B,SAAS,CAAC,EAAE,MAAM,EAClB,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC,IAAI,CAAC,CAoDf"}

package/types/instrumenter/core/transformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/core/transformer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,eAAe,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAGhI,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,EAAE,OAAO,CAAA;IACjB,qBAAqB,EAAE,OAAO,CAAA;IAC9B,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,CAAA;IAC7C,6EAA6E;IAC7E,UAAU,CAAC,EAAE,iBAAiB,EAAE,CAAA;IAChC,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gFAAgF;IAChF,mBAAmB,CAAC,EAAE,kBAAkB,EAAE,CAAA;CAC3C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,eAAe,EAAE,EAC7B,OAAO,EAAE,kBAAkB,GAC1B,eAAe,CA6KjB;AAyKD;;GAEG;AACH,wBAAgB,YAAY,CAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAwB1F"}
+{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/core/transformer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,eAAe,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAGhI,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,EAAE,OAAO,CAAA;IACjB,qBAAqB,EAAE,OAAO,CAAA;IAC9B,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,CAAA;IAC7C,6EAA6E;IAC7E,UAAU,CAAC,EAAE,iBAAiB,EAAE,CAAA;IAChC,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gFAAgF;IAChF,mBAAmB,CAAC,EAAE,kBAAkB,EAAE,CAAA;CAC3C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,eAAe,EAAE,EAC7B,OAAO,EAAE,kBAAkB,GAC1B,eAAe,CA6KjB;AAiLD;;GAEG;AACH,wBAAgB,YAAY,CAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAwB1F"}

package/types/linter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linter.d.ts","sourceRoot":"","sources":["../src/linter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAK1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,EAAE,SAAS,EAA6B,MAAM,SAAS,CAAA;AAwPjG,KAAK,cAAc,GAAG;IACpB,QAAQ,EAAE;QAAC;YACT,OAAO,EAAE,MAAM,CAAC;SACjB;KAAC,CAAC;IACH,IAAI,EAAE;QAAC;YACL,OAAO,EAAE,OAAO,CAAC;YACjB,OAAO,EAAE,MAAM,CAAC;YAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;SACpC;KAAC,CAAC;IACH,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CACvB,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,MAAM,EAAiD,CAAA;AAC7F,eAAO,MAAM,6BAA6B,EAAE,MAAM,EAAqD,CAAA;AAKvG,qBAAa,MAAO,SAAQ,YAAY,CAAC,cAAc,CAAC;IACtD,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,MAAM,CAAQ;gBAET,MAAM,EAAE,oBAAoB,EAAE,MAAM,GAAE,MAA4B;IAM/E,SAAS,CAAE,KAAK,EAAE,OAAO;IAanB,GAAG;;;;;;;IA2GT,OAAO,CAAC,uBAAuB;YAOjB,qBAAqB;IAWnC,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,0BAA0B;YAUpB,qBAAqB;YAgBrB,uBAAuB;CAgBtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,SAAS,CAAE,MAAM,EAAE,oBAAoB;;;;;;GAE5D;AAED,wBAAsB,YAAY,CAChC,MAAM,EAAE,oBAAoB,EAC5B,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,iBAkCnD"}
+{"version":3,"file":"linter.d.ts","sourceRoot":"","sources":["../src/linter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAK1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,EAAE,SAAS,EAA6B,MAAM,SAAS,CAAA;AA8SjG,KAAK,cAAc,GAAG;IACpB,QAAQ,EAAE;QAAC;YACT,OAAO,EAAE,MAAM,CAAC;SACjB;KAAC,CAAC;IACH,IAAI,EAAE;QAAC;YACL,OAAO,EAAE,OAAO,CAAC;YACjB,OAAO,EAAE,MAAM,CAAC;YAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;SACpC;KAAC,CAAC;IACH,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CACvB,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,MAAM,EAAiD,CAAA;AAC7F,eAAO,MAAM,6BAA6B,EAAE,MAAM,EAAqD,CAAA;AAKvG,qBAAa,MAAO,SAAQ,YAAY,CAAC,cAAc,CAAC;IACtD,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,MAAM,CAAQ;gBAET,MAAM,EAAE,oBAAoB,EAAE,MAAM,GAAE,MAA4B;IAM/E,SAAS,CAAE,KAAK,EAAE,OAAO;IAanB,GAAG;;;;;;;IAmHT,OAAO,CAAC,uBAAuB;YAOjB,qBAAqB;IAWnC,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,0BAA0B;YAUpB,qBAAqB;YAgBrB,uBAAuB;CAgBtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,SAAS,CAAE,MAAM,EAAE,oBAAoB;;;;;;GAE5D;AAED,wBAAsB,YAAY,CAChC,MAAM,EAAE,oBAAoB,EAC5B,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,iBAkCnD"}