i18next-cli 1.63.1 → 1.64.1

package/README.md

@@ -773,8 +773,11 @@ export default defineConfig({
     mergeNamespaces: false, 
     
     // Translation functions to detect. Defaults to ['t', '*.t'].
-    // Supports wildcards for suffixes.
-    functions: ['t', '*.t', 'i18next.t'],
+    // Supports a leading wildcard to match any object (suffix match), e.g.
+    // '*.t' matches `i18n.t` / `this._i18n.t`, and a trailing wildcard to match
+    // any method on an object (prefix match), e.g. 'tProps.*' matches
+    // `tProps.label` / `tProps.title`.
+    functions: ['t', '*.t', 'i18next.t', 'tProps.*'],
     
     // React components to analyze
     transComponents: ['Trans', 'Translation'],

package/dist/cjs/cli.js

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

@@ -394,8 +394,11 @@ function buildNewTranslationsForNs(nsKeys, existingTranslations, config, locale,
         if (shouldFilterKey(key)) {
             return false;
         }
-        if (!hasCount) {
-            // Non-plural keys are always included
+        if (!hasCount || config.extract.disablePlurals) {
+            // Non-plural keys are always included. Under `disablePlurals`, count keys
+            // are emitted as plain keys (no plural expansion) but still carry
+            // `hasCount` so `status` can recognise them — they must bypass the
+            // plural-form filtering below and always be included, exactly as before.
             return true;
         }
         // For plural keys, check if this specific plural form is needed for the target language

package/dist/cjs/extractor/parsers/call-expression-handler.js

@@ -3,6 +3,7 @@
 var pluralRules = require('../../utils/plural-rules.js');
 var nesting = require('../../utils/nesting.js');
 var astUtils = require('./ast-utils.js');
+var functionMatcher = require('../utils/function-matcher.js');
 
 // Helper to escape regex characters
 const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -72,19 +73,11 @@ class CallExpressionHandler {
         let isFunctionToParse = scopeInfo !== undefined; // A scoped variable (from useTranslation, etc.) is always parsed.
         if (!isFunctionToParse) {
             for (const pattern of configuredFunctions) {
-                if (pattern.startsWith('*.')) {
-                    // Handle wildcard suffix (e.g., '*.t' matches 'i18n.t')
-                    if (functionName.endsWith(pattern.substring(1))) {
-                        isFunctionToParse = true;
-                        break;
-                    }
-                }
-                else {
-                    // Handle exact match
-                    if (pattern === functionName) {
-                        isFunctionToParse = true;
-                        break;
-                    }
+                // Supports exact ('t', 'i18next.t'), prefix wildcards ('*.t' -> 'i18n.t')
+                // and suffix wildcards ('tProps.*' -> 'tProps.label').
+                if (functionMatcher.matchesFunctionPattern(functionName, pattern)) {
+                    isFunctionToParse = true;
+                    break;
                 }
             }
         }
@@ -344,12 +337,17 @@ class CallExpressionHandler {
                     // Check if plurals are disabled FIRST, before any plural optimization paths
                     if (this.config.extract.disablePlurals) {
                         // When plurals are disabled, treat count as a regular option (for interpolation only)
-                        // Still handle context normally
+                        // Still handle context normally. We keep `hasCount`/`isOrdinal` on the
+                        // emitted key so `status` knows it is count-driven and can accept the
+                        // file's plural variants (or the bare key) instead of demanding the
+                        // literal base key. File generation ignores these flags under
+                        // disablePlurals (see translation-manager), so output is unchanged.
+                        const countMeta = hasCount ? { hasCount: true, isOrdinal: isOrdinalByKey } : {};
                         if (keysWithContext.length > 0) {
-                            keysWithContext.forEach(this.pluginContext.addKey);
+                            keysWithContext.forEach(k => this.pluginContext.addKey({ ...k, ...countMeta }));
                         }
                         else {
-                            this.pluginContext.addKey({ key: finalKey, ns, defaultValue: dv, explicitDefault: explicitDefaultForBase });
+                            this.pluginContext.addKey({ key: finalKey, ns, defaultValue: dv, explicitDefault: explicitDefaultForBase, ...countMeta });
                         }
                         continue; // This key is fully handled
                     }

package/dist/cjs/extractor/parsers/comment-parser.js

@@ -124,14 +124,18 @@ function extractKeysFromComments(code, pluginContext, config, scopeResolver) {
                 ns = config.extract.defaultNS;
             // 5. Handle context and count combinations based on disablePlurals setting
             if (config.extract.disablePlurals) {
-                // When plurals are disabled, ignore count for key generation
+                // When plurals are disabled, ignore count for key generation. We still
+                // tag the key with `hasCount` (when a count was present) so `status` can
+                // recognise it as count-driven; file generation ignores the flag under
+                // disablePlurals (see translation-manager).
+                const countMeta = count ? { hasCount: true, isOrdinal } : {};
                 if (context) {
                     // Only generate context variants (no base key when context is static)
-                    pluginContext.addKey({ key: `${key}_${context}`, ns, defaultValue: defaultValue ?? key });
+                    pluginContext.addKey({ key: `${key}_${context}`, ns, defaultValue: defaultValue ?? key, ...countMeta });
                 }
                 else {
                     // Simple key (ignore count)
-                    pluginContext.addKey({ key, ns, defaultValue: defaultValue ?? key });
+                    pluginContext.addKey({ key, ns, defaultValue: defaultValue ?? key, ...countMeta });
                 }
             }
             else {

package/dist/cjs/extractor/parsers/jsx-handler.js

@@ -369,12 +369,16 @@ class JSXHandler {
                 else if (hasCount) {
                     // Check if plurals are disabled
                     if (this.config.extract.disablePlurals) {
-                        // When plurals are disabled, just add the base keys (no plural forms)
+                        // When plurals are disabled, just add the base keys (no plural forms).
+                        // We keep `hasCount` so `status` recognises the key as count-driven and
+                        // accepts the file's plural variants (or bare key); file generation
+                        // ignores it under disablePlurals (see translation-manager).
                         extractedKeys.forEach(extractedKey => {
                             this.pluginContext.addKey({
                                 key: extractedKey.key,
                                 ns: extractedKey.ns,
                                 defaultValue: extractedKey.defaultValue,
+                                hasCount: true,
                                 locations: extractedKey.locations
                             });
                         });

package/dist/cjs/extractor/utils/function-matcher.js

@@ -0,0 +1,36 @@
+'use strict';
+
+/**
+ * Checks whether a (possibly dotted) function name matches a configured
+ * `functions` pattern.
+ *
+ * Supported pattern forms:
+ * - Exact match: `'t'` matches `t`, `'i18next.t'` matches `i18next.t`.
+ * - Prefix wildcard: `'*.t'` matches any call ending in `.t`
+ *   (e.g. `i18n.t`, `this._i18n.t`).
+ * - Suffix wildcard: `'tProps.*'` matches any single-segment member call on the
+ *   prefix (e.g. `tProps.label`, `tProps.title`) but not deeper nesting like
+ *   `tProps.label.t`.
+ *
+ * @param functionName - The dotted callee name (e.g. `tProps.label`).
+ * @param pattern - A single configured pattern from `extract.functions`.
+ */
+function matchesFunctionPattern(functionName, pattern) {
+    if (pattern === functionName)
+        return true;
+    // Prefix wildcard, e.g. '*.t' -> matches any callee ending in '.t'
+    if (pattern.startsWith('*.')) {
+        return functionName.endsWith(pattern.slice(1));
+    }
+    // Suffix wildcard, e.g. 'tProps.*' -> matches 'tProps.<segment>'
+    if (pattern.endsWith('.*')) {
+        const prefix = pattern.slice(0, -1); // keep the trailing dot: 'tProps.'
+        if (!functionName.startsWith(prefix))
+            return false;
+        const rest = functionName.slice(prefix.length);
+        return rest.length > 0 && !rest.includes('.');
+    }
+    return false;
+}
+
+exports.matchesFunctionPattern = matchesFunctionPattern;

package/dist/cjs/linter.js

@@ -10,6 +10,7 @@ var logger = require('./utils/logger.js');
 var wrapOra = require('./utils/wrap-ora.js');
 var jsxAttributes = require('./utils/jsx-attributes.js');
 var astUtils = require('./extractor/parsers/ast-utils.js');
+var functionMatcher = require('./extractor/utils/function-matcher.js');
 
 /**
  * Loads all translation values from the primary locale's JSON files and returns
@@ -141,28 +142,58 @@ function lintInterpolationParams(ast, code, config, translationValues) {
     }
     // Modularized CallExpression handler
     function handleCallExpression(node, ancestors) {
+        // Build the full dotted callee name (e.g. 'i18n.t', 'tProps.label') as well as
+        // the bare last segment ('t', 'label') so both exact and wildcard patterns match.
         let calleeName = '';
+        let fullCalleeName = '';
         if (node.callee) {
-            if (node.callee.type === 'Identifier' && node.callee.value) {
-                calleeName = node.callee.value;
+            if (node.callee.type === 'Identifier') {
+                calleeName = node.callee.value || node.callee.name || '';
+                fullCalleeName = calleeName;
             }
-            else if (node.callee.type === 'Identifier' && node.callee.name) {
-                calleeName = node.callee.name;
-            }
-            else if (node.callee.type === 'MemberExpression' && node.callee.property?.type === 'Identifier') {
-                calleeName = node.callee.property.value || node.callee.property.name;
+            else if (node.callee.type === 'MemberExpression') {
+                const parts = [];
+                let current = node.callee;
+                let computed = false;
+                while (current?.type === 'MemberExpression') {
+                    if (current.property?.type === 'Identifier') {
+                        parts.unshift(current.property.value || current.property.name);
+                    }
+                    else {
+                        computed = true;
+                        break;
+                    }
+                    current = current.object;
+                }
+                if (!computed) {
+                    if (current?.type === 'ThisExpression') {
+                        parts.unshift('this');
+                    }
+                    else if (current?.type === 'Identifier') {
+                        parts.unshift(current.value || current.name);
+                    }
+                    else {
+                        parts.length = 0;
+                    }
+                }
+                if (node.callee.property?.type === 'Identifier') {
+                    calleeName = node.callee.property.value || node.callee.property.name;
+                }
+                fullCalleeName = parts.length ? parts.join('.') : calleeName;
             }
         }
         const fnPatterns = config.extract.functions || ['t', '*.t'];
         let matches = false;
         for (const pattern of fnPatterns) {
-            if (pattern.startsWith('*.')) {
-                if (calleeName === pattern.slice(2))
-                    matches = true;
+            if (functionMatcher.matchesFunctionPattern(fullCalleeName, pattern)) {
+                matches = true;
+                break;
             }
-            else {
-                if (calleeName === pattern)
-                    matches = true;
+            // Backwards-compatible: '*.X' also matches a call whose last segment is X
+            // (covers computed member expressions where the full chain is unavailable).
+            if (pattern.startsWith('*.') && calleeName === pattern.slice(2)) {
+                matches = true;
+                break;
             }
         }
         if (matches) {

package/dist/cjs/rename-key.js

@@ -297,6 +297,10 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
             const suffix = fnPattern.slice(2);
             return `\\b[\\w$]+\\.${escapeRegex(suffix)}`;
         }
+        if (fnPattern.endsWith('.*')) {
+            const prefix = fnPattern.slice(0, -2);
+            return `\\b${escapeRegex(prefix)}\\.[\\w$]+`;
+        }
         return `\\b${escapeRegex(fnPattern)}`;
     };
     // Helper: check whether the old key exists in a given namespace (from the prebuilt map)

package/dist/cjs/status.js

@@ -26,6 +26,53 @@ function classifyValue(value) {
         return 'empty';
     return 'translated';
 }
+/**
+ * Representative counts used to decide which CLDR plural categories a locale can
+ * actually reach in normal usage: small integers (the common case), a handful
+ * of larger integers, and common decimals (so categories that only fire for
+ * fractional display values — e.g. Polish/Russian `other` — stay required).
+ *
+ * Any category NOT produced by these counts is treated as "optional". The prime
+ * example is French `many`, which `Intl.PluralRules` only selects for values
+ * ≥ 1,000,000 — the i18next runtime can technically request it, but real apps
+ * almost never hit those values (and the runtime falls back to the base key
+ * when the variant is missing), so a missing `_many` should be a soft note
+ * rather than a hard "missing key" failure.
+ */
+const REPRESENTATIVE_COUNTS = (() => {
+    const counts = [];
+    for (let n = 0; n <= 20; n++)
+        counts.push(n);
+    counts.push(100, 101, 1000, 1001, 10000);
+    counts.push(0.5, 1.1, 1.5, 2.5, 3.5);
+    return counts;
+})();
+const optionalCategoriesCache = new Map();
+/**
+ * Returns the CLDR plural categories for a locale that are NOT reachable by any
+ * representative count (see {@link REPRESENTATIVE_COUNTS}). These are reported
+ * by `status` as optional: a missing variant is a soft note instead of a hard
+ * absence, mirroring how the i18next runtime resolves such forms.
+ */
+function getOptionalPluralCategories(locale, isOrdinal) {
+    const type = isOrdinal ? 'ordinal' : 'cardinal';
+    const cacheKey = `${locale}|${type}`;
+    const cached = optionalCategoriesCache.get(cacheKey);
+    if (cached)
+        return cached;
+    let optional;
+    try {
+        const rules = pluralRules.safePluralRules(locale, { type });
+        const all = rules.resolvedOptions().pluralCategories;
+        const reachable = new Set(REPRESENTATIVE_COUNTS.map(n => rules.select(n)));
+        optional = new Set(all.filter(c => !reachable.has(c)));
+    }
+    catch {
+        optional = new Set();
+    }
+    optionalCategoriesCache.set(cacheKey, optional);
+    return optional;
+}
 /**
  * Runs a health check on the project's i18next translations and displays a status report.
  *
@@ -222,6 +269,7 @@ async function generateStatusReport(config) {
         let totalTranslatedForLocale = 0;
         let totalEmptyForLocale = 0;
         let totalAbsentForLocale = 0;
+        let totalOptionalForLocale = 0;
         let totalKeysForLocale = 0;
         const namespaces = new Map();
         const mergedTranslations = mergeNamespaces
@@ -250,6 +298,7 @@ async function generateStatusReport(config) {
             let translatedInNs = 0;
             let emptyInNs = 0;
             let absentInNs = 0;
+            let optionalInNs = 0;
             let totalInNs = 0;
             const keyDetails = [];
             // Get the plural categories for THIS specific locale
@@ -314,37 +363,85 @@ async function generateStatusReport(config) {
                         // Only count this key if it's a plural form used by this locale
                         if (localePluralCategories.includes(category) && !processedKeys.has(baseKey)) {
                             processedKeys.add(baseKey);
-                            totalInNs++;
                             const state = resolveAndClassify(baseKey);
-                            if (state === 'translated')
-                                translatedInNs++;
-                            else if (state === 'empty')
-                                emptyInNs++;
-                            else
-                                absentInNs++;
-                            keyDetails.push({ key: baseKey, state });
+                            const optionalCategories = getOptionalPluralCategories(locale, isOrdinalVariant);
+                            // An optional category (e.g. French `_many`) is a soft note whenever
+                            // it isn't translated — whether absent or an empty placeholder that
+                            // `extract` wrote. It is never a hard failure. See #270 and
+                            // getOptionalPluralCategories.
+                            if (state !== 'translated' && optionalCategories.has(category)) {
+                                optionalInNs++;
+                                keyDetails.push({ key: baseKey, state: 'optional' });
+                            }
+                            else {
+                                totalInNs++;
+                                if (state === 'translated')
+                                    translatedInNs++;
+                                else if (state === 'empty')
+                                    emptyInNs++;
+                                else
+                                    absentInNs++;
+                                keyDetails.push({ key: baseKey, state });
+                            }
                         }
                     }
                     else {
-                        // This is a base plural key without expanded variants
-                        // Expand it according to THIS locale's plural rules
+                        // This is a base plural key without expanded variants. Mirror the
+                        // i18next runtime, where t(key, { count }) resolves `key + suffix`
+                        // and falls back to the bare `key`. A family is therefore satisfied
+                        // either by its plural variants OR by a bare key (the convention
+                        // used when `disablePlurals` is enabled and no variants are written).
                         const localePluralCategories = getLocalePluralCategories(locale, isOrdinal || false);
-                        for (const category of localePluralCategories) {
-                            const pluralKey = isOrdinal
+                        const optionalCategories = getOptionalPluralCategories(locale, isOrdinal || false);
+                        const variants = localePluralCategories.map(category => ({
+                            category,
+                            pluralKey: isOrdinal
                                 ? `${baseKey}${pluralSeparator}ordinal${pluralSeparator}${category}`
-                                : `${baseKey}${pluralSeparator}${category}`;
-                            if (processedKeys.has(pluralKey))
-                                continue;
-                            processedKeys.add(pluralKey);
+                                : `${baseKey}${pluralSeparator}${category}`,
+                        }));
+                        const anyVariantPresent = variants.some(({ pluralKey }) => resolveAndClassify(pluralKey) !== 'absent');
+                        const bareState = resolveAndClassify(baseKey);
+                        if (!anyVariantPresent && bareState !== 'absent' && !processedKeys.has(baseKey)) {
+                            // Convention (a): only the bare key exists (typical under
+                            // disablePlurals, or single-"other" languages). The runtime
+                            // resolves count via the bare key, so it satisfies the family on
+                            // its own — don't demand plural variants that were never written.
+                            processedKeys.add(baseKey);
                             totalInNs++;
-                            const state = resolveAndClassify(pluralKey);
-                            if (state === 'translated')
+                            if (bareState === 'translated')
                                 translatedInNs++;
-                            else if (state === 'empty')
+                            else if (bareState === 'empty')
                                 emptyInNs++;
                             else
                                 absentInNs++;
-                            keyDetails.push({ key: pluralKey, state });
+                            keyDetails.push({ key: baseKey, state: bareState });
+                        }
+                        else {
+                            // Convention (b): plural variants exist (or the family is missing
+                            // entirely). Evaluate each CLDR category — a missing variant is a
+                            // hard absence only when the category is required for this locale;
+                            // optional categories (e.g. French `_many`) downgrade to a soft note.
+                            for (const { category, pluralKey } of variants) {
+                                if (processedKeys.has(pluralKey))
+                                    continue;
+                                processedKeys.add(pluralKey);
+                                const state = resolveAndClassify(pluralKey);
+                                // An optional category (e.g. French `_many`) is a soft note
+                                // whenever it isn't translated — never a hard failure. See #270.
+                                if (state !== 'translated' && optionalCategories.has(category)) {
+                                    optionalInNs++;
+                                    keyDetails.push({ key: pluralKey, state: 'optional' });
+                                    continue;
+                                }
+                                totalInNs++;
+                                if (state === 'translated')
+                                    translatedInNs++;
+                                else if (state === 'empty')
+                                    emptyInNs++;
+                                else
+                                    absentInNs++;
+                                keyDetails.push({ key: pluralKey, state });
+                            }
                         }
                     }
                 }
@@ -380,10 +477,11 @@ async function generateStatusReport(config) {
                     absentInNs++;
                 keyDetails.push({ key: variantKey, state });
             }
-            namespaces.set(ns, { totalKeys: totalInNs, translatedKeys: translatedInNs, emptyKeys: emptyInNs, absentKeys: absentInNs, keyDetails });
+            namespaces.set(ns, { totalKeys: totalInNs, translatedKeys: translatedInNs, emptyKeys: emptyInNs, absentKeys: absentInNs, optionalKeys: optionalInNs, keyDetails });
             totalTranslatedForLocale += translatedInNs;
             totalEmptyForLocale += emptyInNs;
             totalAbsentForLocale += absentInNs;
+            totalOptionalForLocale += optionalInNs;
             totalKeysForLocale += totalInNs;
         }
         const localeStatus = {
@@ -391,6 +489,7 @@ async function generateStatusReport(config) {
             totalTranslated: totalTranslatedForLocale,
             totalEmpty: totalEmptyForLocale,
             totalAbsent: totalAbsentForLocale,
+            totalOptional: totalOptionalForLocale,
             namespaces,
         };
         if (isPrimary) {
@@ -482,6 +581,9 @@ async function displayDetailedLocaleReport(report, config, locale, namespaceFilt
             else if (state === 'empty') {
                 console.log(`  ${node_util.styleText('yellow', '~')} ${key}  ${node_util.styleText('yellow', '(untranslated)')}`);
             }
+            else if (state === 'optional') {
+                console.log(`  ${node_util.styleText('gray', '○')} ${key}  ${node_util.styleText('gray', '(optional plural form)')}`);
+            }
             else {
                 console.log(`  ${node_util.styleText('red', '✗')} ${key}  ${node_util.styleText('red', '(absent)')}`);
             }

package/dist/esm/cli.js

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

@@ -392,8 +392,11 @@ function buildNewTranslationsForNs(nsKeys, existingTranslations, config, locale,
         if (shouldFilterKey(key)) {
             return false;
         }
-        if (!hasCount) {
-            // Non-plural keys are always included
+        if (!hasCount || config.extract.disablePlurals) {
+            // Non-plural keys are always included. Under `disablePlurals`, count keys
+            // are emitted as plain keys (no plural expansion) but still carry
+            // `hasCount` so `status` can recognise them — they must bypass the
+            // plural-form filtering below and always be included, exactly as before.
             return true;
         }
         // For plural keys, check if this specific plural form is needed for the target language

package/dist/esm/extractor/parsers/call-expression-handler.js

@@ -1,6 +1,7 @@
 import { safePluralRules } from '../../utils/plural-rules.js';
 import { parseNestedReferences } from '../../utils/nesting.js';
 import { lineColumnFromOffset, isSimpleTemplateLiteral, getObjectPropValue, getObjectPropValueExpression } from './ast-utils.js';
+import { matchesFunctionPattern } from '../utils/function-matcher.js';
 
 // Helper to escape regex characters
 const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -70,19 +71,11 @@ class CallExpressionHandler {
         let isFunctionToParse = scopeInfo !== undefined; // A scoped variable (from useTranslation, etc.) is always parsed.
         if (!isFunctionToParse) {
             for (const pattern of configuredFunctions) {
-                if (pattern.startsWith('*.')) {
-                    // Handle wildcard suffix (e.g., '*.t' matches 'i18n.t')
-                    if (functionName.endsWith(pattern.substring(1))) {
-                        isFunctionToParse = true;
-                        break;
-                    }
-                }
-                else {
-                    // Handle exact match
-                    if (pattern === functionName) {
-                        isFunctionToParse = true;
-                        break;
-                    }
+                // Supports exact ('t', 'i18next.t'), prefix wildcards ('*.t' -> 'i18n.t')
+                // and suffix wildcards ('tProps.*' -> 'tProps.label').
+                if (matchesFunctionPattern(functionName, pattern)) {
+                    isFunctionToParse = true;
+                    break;
                 }
             }
         }
@@ -342,12 +335,17 @@ class CallExpressionHandler {
                     // Check if plurals are disabled FIRST, before any plural optimization paths
                     if (this.config.extract.disablePlurals) {
                         // When plurals are disabled, treat count as a regular option (for interpolation only)
-                        // Still handle context normally
+                        // Still handle context normally. We keep `hasCount`/`isOrdinal` on the
+                        // emitted key so `status` knows it is count-driven and can accept the
+                        // file's plural variants (or the bare key) instead of demanding the
+                        // literal base key. File generation ignores these flags under
+                        // disablePlurals (see translation-manager), so output is unchanged.
+                        const countMeta = hasCount ? { hasCount: true, isOrdinal: isOrdinalByKey } : {};
                         if (keysWithContext.length > 0) {
-                            keysWithContext.forEach(this.pluginContext.addKey);
+                            keysWithContext.forEach(k => this.pluginContext.addKey({ ...k, ...countMeta }));
                         }
                         else {
-                            this.pluginContext.addKey({ key: finalKey, ns, defaultValue: dv, explicitDefault: explicitDefaultForBase });
+                            this.pluginContext.addKey({ key: finalKey, ns, defaultValue: dv, explicitDefault: explicitDefaultForBase, ...countMeta });
                         }
                         continue; // This key is fully handled
                     }

package/dist/esm/extractor/parsers/comment-parser.js

@@ -122,14 +122,18 @@ function extractKeysFromComments(code, pluginContext, config, scopeResolver) {
                 ns = config.extract.defaultNS;
             // 5. Handle context and count combinations based on disablePlurals setting
             if (config.extract.disablePlurals) {
-                // When plurals are disabled, ignore count for key generation
+                // When plurals are disabled, ignore count for key generation. We still
+                // tag the key with `hasCount` (when a count was present) so `status` can
+                // recognise it as count-driven; file generation ignores the flag under
+                // disablePlurals (see translation-manager).
+                const countMeta = count ? { hasCount: true, isOrdinal } : {};
                 if (context) {
                     // Only generate context variants (no base key when context is static)
-                    pluginContext.addKey({ key: `${key}_${context}`, ns, defaultValue: defaultValue ?? key });
+                    pluginContext.addKey({ key: `${key}_${context}`, ns, defaultValue: defaultValue ?? key, ...countMeta });
                 }
                 else {
                     // Simple key (ignore count)
-                    pluginContext.addKey({ key, ns, defaultValue: defaultValue ?? key });
+                    pluginContext.addKey({ key, ns, defaultValue: defaultValue ?? key, ...countMeta });
                 }
             }
             else {

package/dist/esm/extractor/parsers/jsx-handler.js

@@ -367,12 +367,16 @@ class JSXHandler {
                 else if (hasCount) {
                     // Check if plurals are disabled
                     if (this.config.extract.disablePlurals) {
-                        // When plurals are disabled, just add the base keys (no plural forms)
+                        // When plurals are disabled, just add the base keys (no plural forms).
+                        // We keep `hasCount` so `status` recognises the key as count-driven and
+                        // accepts the file's plural variants (or bare key); file generation
+                        // ignores it under disablePlurals (see translation-manager).
                         extractedKeys.forEach(extractedKey => {
                             this.pluginContext.addKey({
                                 key: extractedKey.key,
                                 ns: extractedKey.ns,
                                 defaultValue: extractedKey.defaultValue,
+                                hasCount: true,
                                 locations: extractedKey.locations
                             });
                         });

package/dist/esm/extractor/utils/function-matcher.js

@@ -0,0 +1,34 @@
+/**
+ * Checks whether a (possibly dotted) function name matches a configured
+ * `functions` pattern.
+ *
+ * Supported pattern forms:
+ * - Exact match: `'t'` matches `t`, `'i18next.t'` matches `i18next.t`.
+ * - Prefix wildcard: `'*.t'` matches any call ending in `.t`
+ *   (e.g. `i18n.t`, `this._i18n.t`).
+ * - Suffix wildcard: `'tProps.*'` matches any single-segment member call on the
+ *   prefix (e.g. `tProps.label`, `tProps.title`) but not deeper nesting like
+ *   `tProps.label.t`.
+ *
+ * @param functionName - The dotted callee name (e.g. `tProps.label`).
+ * @param pattern - A single configured pattern from `extract.functions`.
+ */
+function matchesFunctionPattern(functionName, pattern) {
+    if (pattern === functionName)
+        return true;
+    // Prefix wildcard, e.g. '*.t' -> matches any callee ending in '.t'
+    if (pattern.startsWith('*.')) {
+        return functionName.endsWith(pattern.slice(1));
+    }
+    // Suffix wildcard, e.g. 'tProps.*' -> matches 'tProps.<segment>'
+    if (pattern.endsWith('.*')) {
+        const prefix = pattern.slice(0, -1); // keep the trailing dot: 'tProps.'
+        if (!functionName.startsWith(prefix))
+            return false;
+        const rest = functionName.slice(prefix.length);
+        return rest.length > 0 && !rest.includes('.');
+    }
+    return false;
+}
+
+export { matchesFunctionPattern };

package/dist/esm/linter.js

@@ -8,6 +8,7 @@ import { ConsoleLogger } from './utils/logger.js';
 import { createSpinnerLike } from './utils/wrap-ora.js';
 import { acceptedTags, translatableAttributes, ignoredTags, ignoredAttributeLowerSet } from './utils/jsx-attributes.js';
 import { findFirstTokenIndex, normalizeASTSpans, buildByteToCharMap, convertSpansToCharIndices, collectIgnoredLineRanges } from './extractor/parsers/ast-utils.js';
+import { matchesFunctionPattern } from './extractor/utils/function-matcher.js';
 
 /**
  * Loads all translation values from the primary locale's JSON files and returns
@@ -139,28 +140,58 @@ function lintInterpolationParams(ast, code, config, translationValues) {
     }
     // Modularized CallExpression handler
     function handleCallExpression(node, ancestors) {
+        // Build the full dotted callee name (e.g. 'i18n.t', 'tProps.label') as well as
+        // the bare last segment ('t', 'label') so both exact and wildcard patterns match.
         let calleeName = '';
+        let fullCalleeName = '';
         if (node.callee) {
-            if (node.callee.type === 'Identifier' && node.callee.value) {
-                calleeName = node.callee.value;
+            if (node.callee.type === 'Identifier') {
+                calleeName = node.callee.value || node.callee.name || '';
+                fullCalleeName = calleeName;
             }
-            else if (node.callee.type === 'Identifier' && node.callee.name) {
-                calleeName = node.callee.name;
-            }
-            else if (node.callee.type === 'MemberExpression' && node.callee.property?.type === 'Identifier') {
-                calleeName = node.callee.property.value || node.callee.property.name;
+            else if (node.callee.type === 'MemberExpression') {
+                const parts = [];
+                let current = node.callee;
+                let computed = false;
+                while (current?.type === 'MemberExpression') {
+                    if (current.property?.type === 'Identifier') {
+                        parts.unshift(current.property.value || current.property.name);
+                    }
+                    else {
+                        computed = true;
+                        break;
+                    }
+                    current = current.object;
+                }
+                if (!computed) {
+                    if (current?.type === 'ThisExpression') {
+                        parts.unshift('this');
+                    }
+                    else if (current?.type === 'Identifier') {
+                        parts.unshift(current.value || current.name);
+                    }
+                    else {
+                        parts.length = 0;
+                    }
+                }
+                if (node.callee.property?.type === 'Identifier') {
+                    calleeName = node.callee.property.value || node.callee.property.name;
+                }
+                fullCalleeName = parts.length ? parts.join('.') : calleeName;
             }
         }
         const fnPatterns = config.extract.functions || ['t', '*.t'];
         let matches = false;
         for (const pattern of fnPatterns) {
-            if (pattern.startsWith('*.')) {
-                if (calleeName === pattern.slice(2))
-                    matches = true;
+            if (matchesFunctionPattern(fullCalleeName, pattern)) {
+                matches = true;
+                break;
             }
-            else {
-                if (calleeName === pattern)
-                    matches = true;
+            // Backwards-compatible: '*.X' also matches a call whose last segment is X
+            // (covers computed member expressions where the full chain is unavailable).
+            if (pattern.startsWith('*.') && calleeName === pattern.slice(2)) {
+                matches = true;
+                break;
             }
         }
         if (matches) {

package/dist/esm/rename-key.js

@@ -295,6 +295,10 @@ function replaceKeyWithRegex(code, oldParts, newParts, config, namespaceKeyMap)
             const suffix = fnPattern.slice(2);
             return `\\b[\\w$]+\\.${escapeRegex(suffix)}`;
         }
+        if (fnPattern.endsWith('.*')) {
+            const prefix = fnPattern.slice(0, -2);
+            return `\\b${escapeRegex(prefix)}\\.[\\w$]+`;
+        }
         return `\\b${escapeRegex(fnPattern)}`;
     };
     // Helper: check whether the old key exists in a given namespace (from the prebuilt map)

package/dist/esm/status.js

@@ -20,6 +20,53 @@ function classifyValue(value) {
         return 'empty';
     return 'translated';
 }
+/**
+ * Representative counts used to decide which CLDR plural categories a locale can
+ * actually reach in normal usage: small integers (the common case), a handful
+ * of larger integers, and common decimals (so categories that only fire for
+ * fractional display values — e.g. Polish/Russian `other` — stay required).
+ *
+ * Any category NOT produced by these counts is treated as "optional". The prime
+ * example is French `many`, which `Intl.PluralRules` only selects for values
+ * ≥ 1,000,000 — the i18next runtime can technically request it, but real apps
+ * almost never hit those values (and the runtime falls back to the base key
+ * when the variant is missing), so a missing `_many` should be a soft note
+ * rather than a hard "missing key" failure.
+ */
+const REPRESENTATIVE_COUNTS = (() => {
+    const counts = [];
+    for (let n = 0; n <= 20; n++)
+        counts.push(n);
+    counts.push(100, 101, 1000, 1001, 10000);
+    counts.push(0.5, 1.1, 1.5, 2.5, 3.5);
+    return counts;
+})();
+const optionalCategoriesCache = new Map();
+/**
+ * Returns the CLDR plural categories for a locale that are NOT reachable by any
+ * representative count (see {@link REPRESENTATIVE_COUNTS}). These are reported
+ * by `status` as optional: a missing variant is a soft note instead of a hard
+ * absence, mirroring how the i18next runtime resolves such forms.
+ */
+function getOptionalPluralCategories(locale, isOrdinal) {
+    const type = isOrdinal ? 'ordinal' : 'cardinal';
+    const cacheKey = `${locale}|${type}`;
+    const cached = optionalCategoriesCache.get(cacheKey);
+    if (cached)
+        return cached;
+    let optional;
+    try {
+        const rules = safePluralRules(locale, { type });
+        const all = rules.resolvedOptions().pluralCategories;
+        const reachable = new Set(REPRESENTATIVE_COUNTS.map(n => rules.select(n)));
+        optional = new Set(all.filter(c => !reachable.has(c)));
+    }
+    catch {
+        optional = new Set();
+    }
+    optionalCategoriesCache.set(cacheKey, optional);
+    return optional;
+}
 /**
  * Runs a health check on the project's i18next translations and displays a status report.
  *
@@ -216,6 +263,7 @@ async function generateStatusReport(config) {
         let totalTranslatedForLocale = 0;
         let totalEmptyForLocale = 0;
         let totalAbsentForLocale = 0;
+        let totalOptionalForLocale = 0;
         let totalKeysForLocale = 0;
         const namespaces = new Map();
         const mergedTranslations = mergeNamespaces
@@ -244,6 +292,7 @@ async function generateStatusReport(config) {
             let translatedInNs = 0;
             let emptyInNs = 0;
             let absentInNs = 0;
+            let optionalInNs = 0;
             let totalInNs = 0;
             const keyDetails = [];
             // Get the plural categories for THIS specific locale
@@ -308,37 +357,85 @@ async function generateStatusReport(config) {
                         // Only count this key if it's a plural form used by this locale
                         if (localePluralCategories.includes(category) && !processedKeys.has(baseKey)) {
                             processedKeys.add(baseKey);
-                            totalInNs++;
                             const state = resolveAndClassify(baseKey);
-                            if (state === 'translated')
-                                translatedInNs++;
-                            else if (state === 'empty')
-                                emptyInNs++;
-                            else
-                                absentInNs++;
-                            keyDetails.push({ key: baseKey, state });
+                            const optionalCategories = getOptionalPluralCategories(locale, isOrdinalVariant);
+                            // An optional category (e.g. French `_many`) is a soft note whenever
+                            // it isn't translated — whether absent or an empty placeholder that
+                            // `extract` wrote. It is never a hard failure. See #270 and
+                            // getOptionalPluralCategories.
+                            if (state !== 'translated' && optionalCategories.has(category)) {
+                                optionalInNs++;
+                                keyDetails.push({ key: baseKey, state: 'optional' });
+                            }
+                            else {
+                                totalInNs++;
+                                if (state === 'translated')
+                                    translatedInNs++;
+                                else if (state === 'empty')
+                                    emptyInNs++;
+                                else
+                                    absentInNs++;
+                                keyDetails.push({ key: baseKey, state });
+                            }
                         }
                     }
                     else {
-                        // This is a base plural key without expanded variants
-                        // Expand it according to THIS locale's plural rules
+                        // This is a base plural key without expanded variants. Mirror the
+                        // i18next runtime, where t(key, { count }) resolves `key + suffix`
+                        // and falls back to the bare `key`. A family is therefore satisfied
+                        // either by its plural variants OR by a bare key (the convention
+                        // used when `disablePlurals` is enabled and no variants are written).
                         const localePluralCategories = getLocalePluralCategories(locale, isOrdinal || false);
-                        for (const category of localePluralCategories) {
-                            const pluralKey = isOrdinal
+                        const optionalCategories = getOptionalPluralCategories(locale, isOrdinal || false);
+                        const variants = localePluralCategories.map(category => ({
+                            category,
+                            pluralKey: isOrdinal
                                 ? `${baseKey}${pluralSeparator}ordinal${pluralSeparator}${category}`
-                                : `${baseKey}${pluralSeparator}${category}`;
-                            if (processedKeys.has(pluralKey))
-                                continue;
-                            processedKeys.add(pluralKey);
+                                : `${baseKey}${pluralSeparator}${category}`,
+                        }));
+                        const anyVariantPresent = variants.some(({ pluralKey }) => resolveAndClassify(pluralKey) !== 'absent');
+                        const bareState = resolveAndClassify(baseKey);
+                        if (!anyVariantPresent && bareState !== 'absent' && !processedKeys.has(baseKey)) {
+                            // Convention (a): only the bare key exists (typical under
+                            // disablePlurals, or single-"other" languages). The runtime
+                            // resolves count via the bare key, so it satisfies the family on
+                            // its own — don't demand plural variants that were never written.
+                            processedKeys.add(baseKey);
                             totalInNs++;
-                            const state = resolveAndClassify(pluralKey);
-                            if (state === 'translated')
+                            if (bareState === 'translated')
                                 translatedInNs++;
-                            else if (state === 'empty')
+                            else if (bareState === 'empty')
                                 emptyInNs++;
                             else
                                 absentInNs++;
-                            keyDetails.push({ key: pluralKey, state });
+                            keyDetails.push({ key: baseKey, state: bareState });
+                        }
+                        else {
+                            // Convention (b): plural variants exist (or the family is missing
+                            // entirely). Evaluate each CLDR category — a missing variant is a
+                            // hard absence only when the category is required for this locale;
+                            // optional categories (e.g. French `_many`) downgrade to a soft note.
+                            for (const { category, pluralKey } of variants) {
+                                if (processedKeys.has(pluralKey))
+                                    continue;
+                                processedKeys.add(pluralKey);
+                                const state = resolveAndClassify(pluralKey);
+                                // An optional category (e.g. French `_many`) is a soft note
+                                // whenever it isn't translated — never a hard failure. See #270.
+                                if (state !== 'translated' && optionalCategories.has(category)) {
+                                    optionalInNs++;
+                                    keyDetails.push({ key: pluralKey, state: 'optional' });
+                                    continue;
+                                }
+                                totalInNs++;
+                                if (state === 'translated')
+                                    translatedInNs++;
+                                else if (state === 'empty')
+                                    emptyInNs++;
+                                else
+                                    absentInNs++;
+                                keyDetails.push({ key: pluralKey, state });
+                            }
                         }
                     }
                 }
@@ -374,10 +471,11 @@ async function generateStatusReport(config) {
                     absentInNs++;
                 keyDetails.push({ key: variantKey, state });
             }
-            namespaces.set(ns, { totalKeys: totalInNs, translatedKeys: translatedInNs, emptyKeys: emptyInNs, absentKeys: absentInNs, keyDetails });
+            namespaces.set(ns, { totalKeys: totalInNs, translatedKeys: translatedInNs, emptyKeys: emptyInNs, absentKeys: absentInNs, optionalKeys: optionalInNs, keyDetails });
             totalTranslatedForLocale += translatedInNs;
             totalEmptyForLocale += emptyInNs;
             totalAbsentForLocale += absentInNs;
+            totalOptionalForLocale += optionalInNs;
             totalKeysForLocale += totalInNs;
         }
         const localeStatus = {
@@ -385,6 +483,7 @@ async function generateStatusReport(config) {
             totalTranslated: totalTranslatedForLocale,
             totalEmpty: totalEmptyForLocale,
             totalAbsent: totalAbsentForLocale,
+            totalOptional: totalOptionalForLocale,
             namespaces,
         };
         if (isPrimary) {
@@ -476,6 +575,9 @@ async function displayDetailedLocaleReport(report, config, locale, namespaceFilt
             else if (state === 'empty') {
                 console.log(`  ${styleText('yellow', '~')} ${key}  ${styleText('yellow', '(untranslated)')}`);
             }
+            else if (state === 'optional') {
+                console.log(`  ${styleText('gray', '○')} ${key}  ${styleText('gray', '(optional plural form)')}`);
+            }
             else {
                 console.log(`  ${styleText('red', '✗')} ${key}  ${styleText('red', '(absent)')}`);
             }

package/package.json

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

package/types/extractor/core/translation-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translation-manager.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/translation-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAujC9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAC/B,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EACvB,MAAM,EAAE,oBAAoB,EAC5B,EACE,uBAA+B,EAC/B,OAAe,EACf,oBAA4B,EAC5B,MAA4B,EAC7B,GAAE;IACD,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAA;CACX,GACL,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAiK9B"}
+{"version":3,"file":"translation-manager.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/translation-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AA0jC9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAC/B,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EACvB,MAAM,EAAE,oBAAoB,EAC5B,EACE,uBAA+B,EAC/B,OAAe,EACf,oBAA4B,EAC5B,MAA4B,EAC7B,GAAE;IACD,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAA;CACX,GACL,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAiK9B"}

package/types/extractor/parsers/call-expression-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"call-expression-handler.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/call-expression-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAA6C,MAAM,WAAW,CAAA;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,EAAgB,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1G,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AAa7D,qBAAa,qBAAqB;IAChC,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,kBAAkB,CAAoB;IACvC,UAAU,cAAoB;IACrC,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,iBAAiB,CAAsC;gBAG7D,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EACd,kBAAkB,EAAE,kBAAkB,EACtC,cAAc,EAAE,MAAM,MAAM,EAC5B,cAAc,EAAE,MAAM,MAAM,EAC5B,iBAAiB,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAA2B;IAW3E;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAAE,IAAI,EAAE,cAAc,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,GAAG,SAAS,GAAG,IAAI;IAgaxG;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAmBzB,OAAO,CAAC,wBAAwB;IAyEhC;;;;;;OAMG;IACH,OAAO,CAAC,4BAA4B;IAsDpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,sBAAsB;IA2B9B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,uBAAuB;IAgB/B;;;;;;;;OAQG;IACH,OAAO,CAAC,iCAAiC;IAwFzC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,gBAAgB;IAyMxB;;;;;;;;;OASG;IACH,OAAO,CAAC,eAAe;CA2BxB"}
+{"version":3,"file":"call-expression-handler.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/call-expression-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAA6C,MAAM,WAAW,CAAA;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,EAAgB,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1G,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AAc7D,qBAAa,qBAAqB;IAChC,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,kBAAkB,CAAoB;IACvC,UAAU,cAAoB;IACrC,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,iBAAiB,CAAsC;gBAG7D,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EACd,kBAAkB,EAAE,kBAAkB,EACtC,cAAc,EAAE,MAAM,MAAM,EAC5B,cAAc,EAAE,MAAM,MAAM,EAC5B,iBAAiB,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAA2B;IAW3E;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAAE,IAAI,EAAE,cAAc,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,GAAG,SAAS,GAAG,IAAI;IA8ZxG;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAmBzB,OAAO,CAAC,wBAAwB;IAyEhC;;;;;;OAMG;IACH,OAAO,CAAC,4BAA4B;IAsDpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,sBAAsB;IA2B9B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,uBAAuB;IAgB/B;;;;;;;;OAQG;IACH,OAAO,CAAC,iCAAiC;IAwFzC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,gBAAgB;IAyMxB;;;;;;;;;OASG;IACH,OAAO,CAAC,eAAe;CA2BxB"}

package/types/extractor/parsers/comment-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"comment-parser.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/comment-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAOzE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,oBAAoB,EAC5B,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,GAC1F,IAAI,CAqJN"}
+{"version":3,"file":"comment-parser.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/comment-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAOzE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,oBAAoB,EAC5B,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,GAC1F,IAAI,CAyJN"}

package/types/extractor/parsers/jsx-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsx-handler.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/jsx-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,UAAU,EAAqC,MAAM,WAAW,CAAA;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAgB,MAAM,gBAAgB,CAAA;AACvF,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AAS7D,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,kBAAkB,CAAoB;IAC9C,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,cAAc,CAAc;gBAGlC,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,kBAAkB,EAAE,kBAAkB,EACtC,cAAc,EAAE,MAAM,MAAM,EAC5B,cAAc,EAAE,MAAM,MAAM;IAS9B;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IAK3B;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,iCAAiC;IAgCzC;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;;;;;;;OAQG;IACH,gBAAgB,CAAE,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,GAAG,IAAI;IA2UjI;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,0BAA0B;IAkIlC;;;;;;;;;OASG;IACH,OAAO,CAAC,cAAc;CAevB"}
+{"version":3,"file":"jsx-handler.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/jsx-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,UAAU,EAAqC,MAAM,WAAW,CAAA;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAgB,MAAM,gBAAgB,CAAA;AACvF,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AAS7D,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,kBAAkB,CAAoB;IAC9C,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,cAAc,CAAc;gBAGlC,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,kBAAkB,EAAE,kBAAkB,EACtC,cAAc,EAAE,MAAM,MAAM,EAC5B,cAAc,EAAE,MAAM,MAAM;IAS9B;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IAK3B;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,iCAAiC;IAgCzC;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;;;;;;;OAQG;IACH,gBAAgB,CAAE,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,GAAG,IAAI;IA+UjI;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,0BAA0B;IAkIlC;;;;;;;;;OASG;IACH,OAAO,CAAC,cAAc;CAevB"}

package/types/extractor/utils/function-matcher.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Checks whether a (possibly dotted) function name matches a configured
+ * `functions` pattern.
+ *
+ * Supported pattern forms:
+ * - Exact match: `'t'` matches `t`, `'i18next.t'` matches `i18next.t`.
+ * - Prefix wildcard: `'*.t'` matches any call ending in `.t`
+ *   (e.g. `i18n.t`, `this._i18n.t`).
+ * - Suffix wildcard: `'tProps.*'` matches any single-segment member call on the
+ *   prefix (e.g. `tProps.label`, `tProps.title`) but not deeper nesting like
+ *   `tProps.label.t`.
+ *
+ * @param functionName - The dotted callee name (e.g. `tProps.label`).
+ * @param pattern - A single configured pattern from `extract.functions`.
+ */
+export declare function matchesFunctionPattern(functionName: string, pattern: string): boolean;
+/**
+ * Checks whether a function name matches any of the configured patterns.
+ *
+ * @param functionName - The dotted callee name (e.g. `tProps.label`).
+ * @param patterns - The configured `extract.functions` patterns.
+ */
+export declare function matchesAnyFunctionPattern(functionName: string, patterns: string[]): boolean;
+//# sourceMappingURL=function-matcher.d.ts.map

package/types/extractor/utils/function-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-matcher.d.ts","sourceRoot":"","sources":["../../../src/extractor/utils/function-matcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAiBtF;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAK5F"}

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;AAM1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,EAAE,SAAS,EAA6B,MAAM,YAAY,CAAA;AA+QpG,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;;;;;;;IAkIT,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;AAO1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,EAAE,SAAS,EAA6B,MAAM,YAAY,CAAA;AA8SpG,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;;;;;;;IAkIT,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"}

package/types/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAgB,MAAM,YAAY,CAAA;AAOpE;;GAEG;AACH,UAAU,aAAa;IACrB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAiED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,SAAS,CAAE,MAAM,EAAE,oBAAoB,EAAE,OAAO,GAAE,aAAkB,iBA4BzF"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAgB,MAAM,YAAY,CAAA;AAOpE;;GAEG;AACH,UAAU,aAAa;IACrB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAyHD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,SAAS,CAAE,MAAM,EAAE,oBAAoB,EAAE,OAAO,GAAE,aAAkB,iBA4BzF"}