i18next-cli 1.56.1 → 1.56.3

package/dist/cjs/cli.js

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

@@ -30,6 +30,64 @@ class JSXHandler {
             return undefined;
         return astUtils.lineColumnFromOffset(this.getCurrentCode(), node.span.start);
     }
+    /**
+     * Warns about `<Trans>Hello <b>{name}</b></Trans>` style children where a
+     * bare identifier is used as a React child. react-i18next inlines the value
+     * at runtime, producing a key like `"Hello <1>meow</1>"`, but the extractor
+     * serializes the identifier name as `"{{name}}"`. The two never match, and
+     * even when an `i18nKey` is set, the placeholder `{{name}}` cannot be
+     * interpolated without a `values={{ name }}` prop — it renders literally.
+     *
+     * We keep the existing extraction behaviour so projects that already rely on
+     * the `{{name}}` output (with a matching `values` prop) aren't broken, and
+     * instead surface a diagnostic pointing users at the runtime mismatch.
+     */
+    warnOnBareIdentifierTransChildren(node, elementName) {
+        const bareIdentifiers = [];
+        const visit = (children) => {
+            for (const child of children) {
+                if (child.type === 'JSXExpressionContainer') {
+                    const inner = this.unwrapExpression(child.expression);
+                    if (inner && inner.type === 'Identifier') {
+                        bareIdentifiers.push({ name: inner.value, span: child.span });
+                    }
+                }
+                else if (child.type === 'JSXElement') {
+                    visit(child.children);
+                }
+                else if (child.type === 'JSXFragment') {
+                    visit(child.children);
+                }
+            }
+        };
+        visit(node.children);
+        if (bareIdentifiers.length === 0)
+            return;
+        const warn = this.pluginContext?.logger?.warn?.bind(this.pluginContext.logger) ??
+            console.warn.bind(console);
+        for (const { name, span } of bareIdentifiers) {
+            const loc = astUtils.lineColumnFromOffset(this.getCurrentCode(), span.start);
+            const where = loc
+                ? `${this.getCurrentFile()}:${loc.line}:${loc.column}`
+                : this.getCurrentFile();
+            warn(`<${elementName}> child {${name}} at ${where} won't match at runtime — react-i18next inlines the value (e.g. "<1>meow</1>"), but extraction produces "<1>{{${name}}}</1>". Use {{${name}}} (double braces) with values={{ ${name} }} for interpolation, or inline the value if it isn't meant to be translated.`);
+        }
+    }
+    /**
+     * Unwraps TS type-assertion and parenthesis wrappers so we can inspect the
+     * underlying expression type (mirrors behaviour in jsx-parser).
+     */
+    unwrapExpression(expr) {
+        if (!expr)
+            return expr;
+        if (expr.type === 'TsAsExpression' || expr.type === 'TsSatisfiesExpression') {
+            return this.unwrapExpression(expr.expression);
+        }
+        if (expr.type === 'ParenthesisExpression') {
+            return this.unwrapExpression(expr.expression);
+        }
+        return expr;
+    }
     /**
      * Processes JSX elements to extract translation keys from Trans components.
      *
@@ -42,6 +100,7 @@ class JSXHandler {
     handleJSXElement(node, getScopeInfo) {
         const elementName = this.getElementName(node);
         if (elementName && (this.config.extract.transComponents || ['Trans']).includes(elementName)) {
+            this.warnOnBareIdentifierTransChildren(node, elementName);
             let extractedAttributes = null;
             try {
                 extractedAttributes = jsxParser.extractFromTransComponent(node, this.config);

package/dist/cjs/extractor/parsers/scope-manager.js

@@ -486,14 +486,37 @@ class ScopeManager {
         const args = callExpr.arguments;
         // getFixedT(lng, ns, keyPrefix)
         // We ignore the first argument (lng) for key extraction.
-        const nsArg = args[1]?.expression;
-        const keyPrefixArg = args[2]?.expression;
-        const defaultNs = (nsArg?.type === 'StringLiteral') ? nsArg.value : undefined;
-        const keyPrefix = (keyPrefixArg?.type === 'StringLiteral') ? keyPrefixArg.value : undefined;
+        const defaultNs = this.resolveStringArg(args[1]?.expression);
+        const keyPrefix = this.resolveStringArg(args[2]?.expression);
         if (defaultNs || keyPrefix) {
             this.setVarInScope(variableName, { defaultNs, keyPrefix });
         }
     }
+    /**
+     * Resolves a call argument expression to a string value by handling string
+     * literals, previously-declared local/shared constants (Identifier), member
+     * expressions referencing constant objects, and simple template literals
+     * without interpolation. Returns undefined when the expression cannot be
+     * resolved statically.
+     */
+    resolveStringArg(node) {
+        if (!node)
+            return undefined;
+        const unwrapped = ScopeManager.unwrapTsExpression(node);
+        if (unwrapped.type === 'StringLiteral')
+            return unwrapped.value;
+        if (unwrapped.type === 'Identifier')
+            return this.resolveSimpleStringIdentifier(unwrapped.value);
+        if (unwrapped.type === 'MemberExpression')
+            return this.resolveSimpleMemberExpression(unwrapped);
+        if (unwrapped.type === 'TemplateLiteral') {
+            const tpl = unwrapped;
+            if ((tpl.expressions || []).length === 0) {
+                return tpl.quasis?.[0]?.cooked ?? undefined;
+            }
+        }
+        return undefined;
+    }
     /**
      * Handles cases where a getFixedT-like function is a variable (from a custom hook)
      * and is invoked to produce a bound `t` function, e.g.:
@@ -513,10 +536,8 @@ class ScopeManager {
             return;
         const args = callExpr.arguments;
         // getFixedT(lng, ns, keyPrefix)
-        const nsArg = args[1]?.expression;
-        const keyPrefixArg = args[2]?.expression;
-        const nsFromCall = (nsArg?.type === 'StringLiteral') ? nsArg.value : undefined;
-        const keyPrefixFromCall = (keyPrefixArg?.type === 'StringLiteral') ? keyPrefixArg.value : undefined;
+        const nsFromCall = this.resolveStringArg(args[1]?.expression);
+        const keyPrefixFromCall = this.resolveStringArg(args[2]?.expression);
         // Merge: call args take precedence over source scope values
         const finalNs = nsFromCall ?? sourceScope.defaultNs;
         const finalKeyPrefix = keyPrefixFromCall ?? sourceScope.keyPrefix;

package/dist/cjs/linter.js

@@ -755,14 +755,22 @@ function findHardcodedStrings(ast, code, config) {
         }
         if (node.type === 'StringLiteral') {
             const parent = currentAncestors[currentAncestors.length - 2];
+            const grandparent = currentAncestors[currentAncestors.length - 3];
             // Determine whether this attribute is inside any ignored element (handles nested Trans etc.)
             const insideIgnored = isWithinIgnoredElement(currentAncestors);
-            if (parent?.type === 'JSXAttribute' && !insideIgnored) {
-                const rawAttrName = extractAttrName(parent.name);
+            // A StringLiteral can be an attribute value in two forms:
+            //   <tag attr="value" />       → parent is JSXAttribute
+            //   <tag attr={"value"} />     → parent is JSXExpressionContainer, grandparent is JSXAttribute
+            const attrNode = parent?.type === 'JSXAttribute'
+                ? parent
+                : (parent?.type === 'JSXExpressionContainer' && grandparent?.type === 'JSXAttribute' ? grandparent : null);
+            if (attrNode && !insideIgnored) {
+                const rawAttrName = extractAttrName(attrNode.name);
                 const attrNameLower = rawAttrName ? String(rawAttrName).toLowerCase() : null;
                 // Check tag-level acceptance if acceptedTagsSet provided: attributes should only be considered
-                // when the nearest enclosing element is accepted.
-                const parentElement = currentAncestors.slice(0, -2).reverse().find(a => a && typeof a === 'object' && (a.type === 'JSXElement' || a.type === 'JSXOpeningElement' || a.type === 'JSXSelfClosingElement'));
+                // when the nearest enclosing element is accepted. Use the ancestors above the attrNode.
+                const attrNodeIdx = currentAncestors.indexOf(attrNode);
+                const parentElement = currentAncestors.slice(0, attrNodeIdx).reverse().find(a => a && typeof a === 'object' && (a.type === 'JSXElement' || a.type === 'JSXOpeningElement' || a.type === 'JSXSelfClosingElement'));
                 if (acceptedTagsSet && parentElement) {
                     const parentName = extractJSXName(parentElement);
                     if (!parentName || !acceptedTagsSet.has(String(parentName).toLowerCase())) {
@@ -786,6 +794,21 @@ function findHardcodedStrings(ast, code, config) {
                     }
                 }
             }
+            // Hardcoded string inside a JSX expression container used as element child:
+            //   <tag>{"hello"}</tag>   → parent is JSXExpressionContainer, grandparent is JSXElement/JSXFragment
+            // Apply the same filters used for JSXText so this behaves like raw text.
+            const isJsxChildExpression = parent?.type === 'JSXExpressionContainer' &&
+                (grandparent?.type === 'JSXElement' || grandparent?.type === 'JSXFragment');
+            if (isJsxChildExpression && !insideIgnored) {
+                // Respect attribute-only mode: when acceptedAttributes is set without acceptedTags,
+                // only attribute strings are linted — skip JSX child text.
+                if (!(acceptedAttributesSet && !acceptedTagsSet)) {
+                    const text = node.value.trim();
+                    if (text && text.length > 1 && text !== '...' && !isUrlOrPath(text) && isNaN(Number(text)) && !text.startsWith('{{')) {
+                        nodesToLint.push(node);
+                    }
+                }
+            }
         }
         // Recurse into children
         for (const key of Object.keys(node)) {

package/dist/esm/cli.js

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

@@ -28,6 +28,64 @@ class JSXHandler {
             return undefined;
         return lineColumnFromOffset(this.getCurrentCode(), node.span.start);
     }
+    /**
+     * Warns about `<Trans>Hello <b>{name}</b></Trans>` style children where a
+     * bare identifier is used as a React child. react-i18next inlines the value
+     * at runtime, producing a key like `"Hello <1>meow</1>"`, but the extractor
+     * serializes the identifier name as `"{{name}}"`. The two never match, and
+     * even when an `i18nKey` is set, the placeholder `{{name}}` cannot be
+     * interpolated without a `values={{ name }}` prop — it renders literally.
+     *
+     * We keep the existing extraction behaviour so projects that already rely on
+     * the `{{name}}` output (with a matching `values` prop) aren't broken, and
+     * instead surface a diagnostic pointing users at the runtime mismatch.
+     */
+    warnOnBareIdentifierTransChildren(node, elementName) {
+        const bareIdentifiers = [];
+        const visit = (children) => {
+            for (const child of children) {
+                if (child.type === 'JSXExpressionContainer') {
+                    const inner = this.unwrapExpression(child.expression);
+                    if (inner && inner.type === 'Identifier') {
+                        bareIdentifiers.push({ name: inner.value, span: child.span });
+                    }
+                }
+                else if (child.type === 'JSXElement') {
+                    visit(child.children);
+                }
+                else if (child.type === 'JSXFragment') {
+                    visit(child.children);
+                }
+            }
+        };
+        visit(node.children);
+        if (bareIdentifiers.length === 0)
+            return;
+        const warn = this.pluginContext?.logger?.warn?.bind(this.pluginContext.logger) ??
+            console.warn.bind(console);
+        for (const { name, span } of bareIdentifiers) {
+            const loc = lineColumnFromOffset(this.getCurrentCode(), span.start);
+            const where = loc
+                ? `${this.getCurrentFile()}:${loc.line}:${loc.column}`
+                : this.getCurrentFile();
+            warn(`<${elementName}> child {${name}} at ${where} won't match at runtime — react-i18next inlines the value (e.g. "<1>meow</1>"), but extraction produces "<1>{{${name}}}</1>". Use {{${name}}} (double braces) with values={{ ${name} }} for interpolation, or inline the value if it isn't meant to be translated.`);
+        }
+    }
+    /**
+     * Unwraps TS type-assertion and parenthesis wrappers so we can inspect the
+     * underlying expression type (mirrors behaviour in jsx-parser).
+     */
+    unwrapExpression(expr) {
+        if (!expr)
+            return expr;
+        if (expr.type === 'TsAsExpression' || expr.type === 'TsSatisfiesExpression') {
+            return this.unwrapExpression(expr.expression);
+        }
+        if (expr.type === 'ParenthesisExpression') {
+            return this.unwrapExpression(expr.expression);
+        }
+        return expr;
+    }
     /**
      * Processes JSX elements to extract translation keys from Trans components.
      *
@@ -40,6 +98,7 @@ class JSXHandler {
     handleJSXElement(node, getScopeInfo) {
         const elementName = this.getElementName(node);
         if (elementName && (this.config.extract.transComponents || ['Trans']).includes(elementName)) {
+            this.warnOnBareIdentifierTransChildren(node, elementName);
             let extractedAttributes = null;
             try {
                 extractedAttributes = extractFromTransComponent(node, this.config);

package/dist/esm/extractor/parsers/scope-manager.js

@@ -484,14 +484,37 @@ class ScopeManager {
         const args = callExpr.arguments;
         // getFixedT(lng, ns, keyPrefix)
         // We ignore the first argument (lng) for key extraction.
-        const nsArg = args[1]?.expression;
-        const keyPrefixArg = args[2]?.expression;
-        const defaultNs = (nsArg?.type === 'StringLiteral') ? nsArg.value : undefined;
-        const keyPrefix = (keyPrefixArg?.type === 'StringLiteral') ? keyPrefixArg.value : undefined;
+        const defaultNs = this.resolveStringArg(args[1]?.expression);
+        const keyPrefix = this.resolveStringArg(args[2]?.expression);
         if (defaultNs || keyPrefix) {
             this.setVarInScope(variableName, { defaultNs, keyPrefix });
         }
     }
+    /**
+     * Resolves a call argument expression to a string value by handling string
+     * literals, previously-declared local/shared constants (Identifier), member
+     * expressions referencing constant objects, and simple template literals
+     * without interpolation. Returns undefined when the expression cannot be
+     * resolved statically.
+     */
+    resolveStringArg(node) {
+        if (!node)
+            return undefined;
+        const unwrapped = ScopeManager.unwrapTsExpression(node);
+        if (unwrapped.type === 'StringLiteral')
+            return unwrapped.value;
+        if (unwrapped.type === 'Identifier')
+            return this.resolveSimpleStringIdentifier(unwrapped.value);
+        if (unwrapped.type === 'MemberExpression')
+            return this.resolveSimpleMemberExpression(unwrapped);
+        if (unwrapped.type === 'TemplateLiteral') {
+            const tpl = unwrapped;
+            if ((tpl.expressions || []).length === 0) {
+                return tpl.quasis?.[0]?.cooked ?? undefined;
+            }
+        }
+        return undefined;
+    }
     /**
      * Handles cases where a getFixedT-like function is a variable (from a custom hook)
      * and is invoked to produce a bound `t` function, e.g.:
@@ -511,10 +534,8 @@ class ScopeManager {
             return;
         const args = callExpr.arguments;
         // getFixedT(lng, ns, keyPrefix)
-        const nsArg = args[1]?.expression;
-        const keyPrefixArg = args[2]?.expression;
-        const nsFromCall = (nsArg?.type === 'StringLiteral') ? nsArg.value : undefined;
-        const keyPrefixFromCall = (keyPrefixArg?.type === 'StringLiteral') ? keyPrefixArg.value : undefined;
+        const nsFromCall = this.resolveStringArg(args[1]?.expression);
+        const keyPrefixFromCall = this.resolveStringArg(args[2]?.expression);
         // Merge: call args take precedence over source scope values
         const finalNs = nsFromCall ?? sourceScope.defaultNs;
         const finalKeyPrefix = keyPrefixFromCall ?? sourceScope.keyPrefix;

package/dist/esm/linter.js

@@ -753,14 +753,22 @@ function findHardcodedStrings(ast, code, config) {
         }
         if (node.type === 'StringLiteral') {
             const parent = currentAncestors[currentAncestors.length - 2];
+            const grandparent = currentAncestors[currentAncestors.length - 3];
             // Determine whether this attribute is inside any ignored element (handles nested Trans etc.)
             const insideIgnored = isWithinIgnoredElement(currentAncestors);
-            if (parent?.type === 'JSXAttribute' && !insideIgnored) {
-                const rawAttrName = extractAttrName(parent.name);
+            // A StringLiteral can be an attribute value in two forms:
+            //   <tag attr="value" />       → parent is JSXAttribute
+            //   <tag attr={"value"} />     → parent is JSXExpressionContainer, grandparent is JSXAttribute
+            const attrNode = parent?.type === 'JSXAttribute'
+                ? parent
+                : (parent?.type === 'JSXExpressionContainer' && grandparent?.type === 'JSXAttribute' ? grandparent : null);
+            if (attrNode && !insideIgnored) {
+                const rawAttrName = extractAttrName(attrNode.name);
                 const attrNameLower = rawAttrName ? String(rawAttrName).toLowerCase() : null;
                 // Check tag-level acceptance if acceptedTagsSet provided: attributes should only be considered
-                // when the nearest enclosing element is accepted.
-                const parentElement = currentAncestors.slice(0, -2).reverse().find(a => a && typeof a === 'object' && (a.type === 'JSXElement' || a.type === 'JSXOpeningElement' || a.type === 'JSXSelfClosingElement'));
+                // when the nearest enclosing element is accepted. Use the ancestors above the attrNode.
+                const attrNodeIdx = currentAncestors.indexOf(attrNode);
+                const parentElement = currentAncestors.slice(0, attrNodeIdx).reverse().find(a => a && typeof a === 'object' && (a.type === 'JSXElement' || a.type === 'JSXOpeningElement' || a.type === 'JSXSelfClosingElement'));
                 if (acceptedTagsSet && parentElement) {
                     const parentName = extractJSXName(parentElement);
                     if (!parentName || !acceptedTagsSet.has(String(parentName).toLowerCase())) {
@@ -784,6 +792,21 @@ function findHardcodedStrings(ast, code, config) {
                     }
                 }
             }
+            // Hardcoded string inside a JSX expression container used as element child:
+            //   <tag>{"hello"}</tag>   → parent is JSXExpressionContainer, grandparent is JSXElement/JSXFragment
+            // Apply the same filters used for JSXText so this behaves like raw text.
+            const isJsxChildExpression = parent?.type === 'JSXExpressionContainer' &&
+                (grandparent?.type === 'JSXElement' || grandparent?.type === 'JSXFragment');
+            if (isJsxChildExpression && !insideIgnored) {
+                // Respect attribute-only mode: when acceptedAttributes is set without acceptedTags,
+                // only attribute strings are linted — skip JSX child text.
+                if (!(acceptedAttributesSet && !acceptedTagsSet)) {
+                    const text = node.value.trim();
+                    if (text && text.length > 1 && text !== '...' && !isUrlOrPath(text) && isNaN(Number(text)) && !text.startsWith('{{')) {
+                        nodesToLint.push(node);
+                    }
+                }
+            }
         }
         // Recurse into children
         for (const key of Object.keys(node)) {

package/package.json

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

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

@@ -14,6 +14,24 @@ export declare class JSXHandler {
      * so we can use them directly.
      */
     private getLocationFromNode;
+    /**
+     * Warns about `<Trans>Hello <b>{name}</b></Trans>` style children where a
+     * bare identifier is used as a React child. react-i18next inlines the value
+     * at runtime, producing a key like `"Hello <1>meow</1>"`, but the extractor
+     * serializes the identifier name as `"{{name}}"`. The two never match, and
+     * even when an `i18nKey` is set, the placeholder `{{name}}` cannot be
+     * interpolated without a `values={{ name }}` prop — it renders literally.
+     *
+     * We keep the existing extraction behaviour so projects that already rely on
+     * the `{{name}}` output (with a matching `values` prop) aren't broken, and
+     * instead surface a diagnostic pointing users at the runtime mismatch.
+     */
+    private warnOnBareIdentifierTransChildren;
+    /**
+     * Unwraps TS type-assertion and parenthesis wrappers so we can inspect the
+     * underlying expression type (mirrors behaviour in jsx-parser).
+     */
+    private unwrapExpression;
     /**
      * Processes JSX elements to extract translation keys from Trans components.
      *

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,EAAE,UAAU,EAAoB,MAAM,WAAW,CAAA;AAC7D,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;;;;;;;;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;IAyUjI;;;;;;;;;;;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;;;;;;;;;;;OAWG;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"}

package/types/extractor/parsers/scope-manager.d.ts

@@ -112,6 +112,14 @@ export declare class ScopeManager {
      * @param callExpr - The CallExpression node representing the getFixedT invocation
      */
     private handleGetFixedTDeclarator;
+    /**
+     * Resolves a call argument expression to a string value by handling string
+     * literals, previously-declared local/shared constants (Identifier), member
+     * expressions referencing constant objects, and simple template literals
+     * without interpolation. Returns undefined when the expression cannot be
+     * resolved statically.
+     */
+    private resolveStringArg;
     /**
      * Handles cases where a getFixedT-like function is a variable (from a custom hook)
      * and is invoked to produce a bound `t` function, e.g.:

package/types/extractor/parsers/scope-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scope-manager.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/scope-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,kBAAkB,EAMnB,MAAM,WAAW,CAAA;AAClB,OAAO,KAAK,EAAE,SAAS,EAA4B,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAG/F,qBAAa,YAAY;IACvB,OAAO,CAAC,UAAU,CAAoC;IACtD,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,KAAK,CAAqE;IAGlF,OAAO,CAAC,eAAe,CAAiC;IAGxD,OAAO,CAAC,qBAAqB,CAAiD;IAI9E,OAAO,CAAC,eAAe,CAAiC;IACxD,OAAO,CAAC,qBAAqB,CAAiD;gBAEjE,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC;IAI1D;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAcjC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,+BAA+B;IAgB9C;;;;;;OAMG;IACI,KAAK,IAAK,IAAI;IAOrB;;;OAGG;IACH,UAAU,IAAK,IAAI;IAInB;;;OAGG;IACH,SAAS,IAAK,IAAI;IAIlB;;;;;;OAMG;IACH,aAAa,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAUnD;;;;;;OAMG;IACH,eAAe,CAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAkBrD,OAAO,CAAC,uBAAuB;IAoB/B;;OAEG;IACI,6BAA6B,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIvE;;;OAGG;IACH,OAAO,CAAC,6BAA6B;IAqBrC;;;;;;;;;;OAUG;IACH,wBAAwB,CAAE,IAAI,EAAE,kBAAkB,GAAG,IAAI;IA0FzD;;;;;;;;OAQG;IACH,OAAO,CAAC,+BAA+B;IA0GvC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,8BAA8B;IAmFtC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,yBAAyB;IAoBjC;;;;;;;;;OASG;IACH,OAAO,CAAC,qCAAqC;CAuB9C"}
+{"version":3,"file":"scope-manager.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/scope-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,kBAAkB,EAMnB,MAAM,WAAW,CAAA;AAClB,OAAO,KAAK,EAAE,SAAS,EAA4B,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAG/F,qBAAa,YAAY;IACvB,OAAO,CAAC,UAAU,CAAoC;IACtD,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,KAAK,CAAqE;IAGlF,OAAO,CAAC,eAAe,CAAiC;IAGxD,OAAO,CAAC,qBAAqB,CAAiD;IAI9E,OAAO,CAAC,eAAe,CAAiC;IACxD,OAAO,CAAC,qBAAqB,CAAiD;gBAEjE,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC;IAI1D;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAcjC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,+BAA+B;IAgB9C;;;;;;OAMG;IACI,KAAK,IAAK,IAAI;IAOrB;;;OAGG;IACH,UAAU,IAAK,IAAI;IAInB;;;OAGG;IACH,SAAS,IAAK,IAAI;IAIlB;;;;;;OAMG;IACH,aAAa,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAUnD;;;;;;OAMG;IACH,eAAe,CAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAkBrD,OAAO,CAAC,uBAAuB;IAoB/B;;OAEG;IACI,6BAA6B,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIvE;;;OAGG;IACH,OAAO,CAAC,6BAA6B;IAqBrC;;;;;;;;;;OAUG;IACH,wBAAwB,CAAE,IAAI,EAAE,kBAAkB,GAAG,IAAI;IA0FzD;;;;;;;;OAQG;IACH,OAAO,CAAC,+BAA+B;IA0GvC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,8BAA8B;IAmFtC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,yBAAyB;IAiBjC;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;IAexB;;;;;;;;;OASG;IACH,OAAO,CAAC,qCAAqC;CAoB9C"}