eslint-plugin-intlayer 9.3.1

package/dist/cjs/rules/noDynamicFieldAccess.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"noDynamicFieldAccess.cjs","names":["getStaticStringValue","createRule","getActiveDescriptors","collectImportSources","toAstNode","matchCaller"],"sources":["../../../src/rules/noDynamicFieldAccess.ts"],"sourcesContent":["import type { Scope } from 'eslint';\nimport {\n  type AstNode,\n  type AstNodeWithParent,\n  getStaticStringValue,\n  toAstNode,\n} from '../utils/ast';\nimport {\n  collectImportSources,\n  getActiveDescriptors,\n  matchCaller,\n} from '../utils/callerMatcher';\nimport { createRule } from '../utils/createRule';\n\ntype MessageIds = 'dynamicField' | 'dynamicMessageId';\n\n/**\n * What a variable bound from a caller call holds.\n *\n * - `content`    — the dictionary content object, or a destructured subtree of\n *                  it (`useIntlayer`, `getIntlayer`).\n * - `translator` — a translation function taking a message path\n *                  (`useTranslations`, the `t` of `useTranslation`).\n */\ntype BindingKind = 'content' | 'translator';\n\n/**\n * Property name holding the translation function in a `destructured-t` result,\n * e.g. `const { t } = useTranslation('home')`.\n */\nconst TRANSLATOR_PROPERTY_NAME = 't';\n\n/**\n * True when a computed member access reads a field the compiler can still name:\n * a literal (`content['title']`, `items[0]`) or an uninterpolated template.\n *\n * @param property - The `property` node of a computed MemberExpression.\n */\nconst isStaticComputedProperty = (property: AstNode | null): boolean => {\n  if (!property) return false;\n\n  if (property.type === 'Literal') return true;\n\n  return getStaticStringValue(property) !== null;\n};\n\n/**\n * The variables a declarator binds, paired with the identifier that declared\n * each one — needed to tell `t` apart from `i18n` in a destructuring pattern.\n *\n * @param variables - Result of `sourceCode.getDeclaredVariables(declarator)`.\n * @param identifier - The declaring identifier to look up.\n */\nconst findVariableForIdentifier = (\n  variables: Scope.Variable[],\n  identifier: AstNode\n): Scope.Variable | null =>\n  variables.find((variable) =>\n    variable.identifiers.some(\n      (declared) => (declared as unknown as AstNode) === identifier\n    )\n  ) ?? null;\n\n/**\n * Locate the identifier bound to the `t` property of an object pattern,\n * honouring renames (`const { t: translate } = …`).\n *\n * @param pattern - The declarator's `id`, expected to be an ObjectPattern.\n */\nconst findTranslatorIdentifier = (pattern: AstNode): AstNode | null => {\n  if (pattern.type !== 'ObjectPattern') return null;\n\n  const properties = (pattern['properties'] as AstNode[] | undefined) ?? [];\n\n  for (const property of properties) {\n    if (property.type !== 'Property' || property['computed'] === true) continue;\n\n    const key = property['key'] as AstNode | undefined;\n    const keyName =\n      key?.type === 'Identifier'\n        ? (key['name'] as string)\n        : key?.type === 'Literal'\n          ? String(key['value'])\n          : null;\n\n    if (keyName !== TRANSLATOR_PROPERTY_NAME) continue;\n\n    const value = property['value'] as AstNode | undefined;\n\n    return value?.type === 'Identifier' ? value : null;\n  }\n\n  return null;\n};\n\nexport const noDynamicFieldAccess = createRule<[], MessageIds>(\n  'no-dynamic-field-access',\n  {\n    meta: {\n      type: 'problem',\n      docs: {\n        description:\n          'Require the field read from an Intlayer dictionary to be statically known',\n      },\n      messages: {\n        dynamicField:\n          'Computed access on Intlayer content is not statically analyzable. The purge pass strips fields it cannot see used, so this may read `undefined` at runtime — read the field by name instead.',\n        dynamicMessageId:\n          'The message path passed to `{{caller}}` must be a static string. The purge pass strips fields it cannot see used, so this may read `undefined` at runtime.',\n      },\n    },\n\n    create: (context) => {\n      const sourceCode = context.sourceCode;\n      let activeDescriptors = getActiveDescriptors(new Set());\n\n      /** Report every computed, non-static member access on a bound variable. */\n      const checkContentVariable = (variable: Scope.Variable): void => {\n        for (const reference of variable.references) {\n          const identifier =\n            reference.identifier as unknown as AstNodeWithParent;\n          const parent = identifier.parent;\n\n          if (parent?.type !== 'MemberExpression') continue;\n\n          if (parent['object'] !== identifier) continue;\n\n          if (parent['computed'] !== true) continue;\n\n          if (isStaticComputedProperty(parent['property'] as AstNode)) continue;\n\n          context.report({\n            node: parent as never,\n            messageId: 'dynamicField',\n          });\n        }\n      };\n\n      /** Report every call of a translation function with a runtime message path. */\n      const checkTranslatorVariable = (\n        variable: Scope.Variable,\n        callerName: string\n      ): void => {\n        for (const reference of variable.references) {\n          const identifier =\n            reference.identifier as unknown as AstNodeWithParent;\n          const parent = identifier.parent;\n\n          if (parent?.type !== 'CallExpression') continue;\n\n          if (parent['callee'] !== identifier) continue;\n\n          const [firstArgument] = (parent['arguments'] as AstNode[]) ?? [];\n\n          if (!firstArgument) continue;\n\n          if (getStaticStringValue(firstArgument) !== null) continue;\n\n          context.report({\n            node: firstArgument as never,\n            messageId: 'dynamicMessageId',\n            data: { caller: callerName },\n          });\n        }\n      };\n\n      return {\n        Program: (node) => {\n          activeDescriptors = getActiveDescriptors(\n            collectImportSources(toAstNode(node))\n          );\n        },\n\n        VariableDeclarator: (node) => {\n          const astNode = toAstNode(node);\n          const init = astNode['init'] as AstNode | undefined;\n\n          if (!init) return;\n\n          const match = matchCaller(init, activeDescriptors);\n\n          if (!match) return;\n\n          const { descriptor } = match;\n          const shape = descriptor.translationFunction;\n\n          const kind: BindingKind | null =\n            shape === 'content'\n              ? 'content'\n              : shape === 'return-value' || shape === 'destructured-t'\n                ? 'translator'\n                : null;\n\n          if (!kind) return;\n\n          const declaredVariables = sourceCode.getDeclaredVariables(node);\n          const id = astNode['id'] as AstNode;\n\n          if (kind === 'content') {\n            // Every variable the pattern binds is content (the root object or a\n            // destructured subtree of it), so all of them are worth checking.\n            for (const variable of declaredVariables) {\n              checkContentVariable(variable);\n            }\n\n            return;\n          }\n\n          if (shape === 'return-value') {\n            if (id.type !== 'Identifier') return;\n\n            const variable = findVariableForIdentifier(declaredVariables, id);\n\n            if (variable) {\n              checkTranslatorVariable(variable, descriptor.callerName);\n            }\n\n            return;\n          }\n\n          const translatorIdentifier = findTranslatorIdentifier(id);\n\n          if (!translatorIdentifier) return;\n\n          const variable = findVariableForIdentifier(\n            declaredVariables,\n            translatorIdentifier\n          );\n\n          if (variable) {\n            checkTranslatorVariable(variable, descriptor.callerName);\n          }\n        },\n      };\n    },\n  }\n);\n"],"mappings":"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"}

package/dist/cjs/rules/noRawText.cjs

@@ -0,0 +1,176 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils_ast = require('../utils/ast.cjs');
+const require_utils_createRule = require('../utils/createRule.cjs');
+const require_utils_templates = require('../utils/templates.cjs');
+let _intlayer_config_defaultValues = require("@intlayer/config/defaultValues");
+let _intlayer_config_extract = require("@intlayer/config/extract");
+
+//#region src/rules/noRawText.ts
+/**
+* Elements whose text is markup, code or metadata rather than user-facing copy.
+* Extracting them would be wrong, so they are skipped by default.
+*/
+const DEFAULT_IGNORED_ELEMENTS = [
+	"code",
+	"pre",
+	"script",
+	"style"
+];
+/**
+* True for a content declaration file, where raw strings are the whole point.
+*
+* @param filename - Absolute path of the linted file.
+*/
+const isContentDeclarationFile = (filename) => _intlayer_config_defaultValues.FILE_EXTENSIONS.some((extension) => filename.endsWith(extension));
+/**
+* Walk up from a JSX child or attribute to the tag name that encloses it.
+*
+* @param node - The reported node.
+*/
+const getEnclosingElementName = (node) => {
+	let current = node;
+	while (current) {
+		if (current.type === "JSXElement") return require_utils_ast.getJsxElementName(current["openingElement"]);
+		if (current.type === "JSXOpeningElement") return require_utils_ast.getJsxElementName(current);
+		current = current.parent;
+	}
+	return null;
+};
+/**
+* True when the string literal sits in a position that is structural rather
+* than user-facing: module specifiers, property keys, directives, and the
+* arguments of the Intlayer getters themselves.
+*
+* @param node - The Literal node.
+*/
+const isStructuralPosition = (node) => {
+	const parent = node.parent;
+	if (!parent) return true;
+	switch (parent.type) {
+		case "ImportDeclaration":
+		case "ImportExpression":
+		case "ExportNamedDeclaration":
+		case "ExportAllDeclaration":
+		case "JSXAttribute":
+		case "TSLiteralType":
+		case "TSEnumMember":
+		case "ExpressionStatement": return true;
+		case "Property": return parent["key"] === node && parent["computed"] !== true;
+		case "MemberExpression": return parent["property"] === node;
+		default: return false;
+	}
+};
+const noRawText = require_utils_createRule.createRule("no-raw-text", {
+	meta: {
+		type: "problem",
+		docs: { description: "Report user-facing strings that are not declared in an Intlayer dictionary" },
+		messages: {
+			rawText: "Untranslated text \"{{text}}\". Move it to a dictionary — `npx intlayer extract` can do it for this file.",
+			rawAttribute: "Untranslated `{{attribute}}` value \"{{text}}\". Move it to a dictionary — `npx intlayer extract` can do it for this file.",
+			rawStringLiteral: "Untranslated string \"{{text}}\". Move it to a dictionary — `npx intlayer extract` can do it for this file."
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				attributes: {
+					type: "array",
+					items: { type: "string" }
+				},
+				ignoreElements: {
+					type: "array",
+					items: { type: "string" }
+				},
+				ignorePatterns: {
+					type: "array",
+					items: { type: "string" }
+				},
+				includeStringLiterals: { type: "boolean" }
+			},
+			additionalProperties: false
+		}]
+	},
+	create: (context) => {
+		const filename = context.filename;
+		if (isContentDeclarationFile(filename)) return {};
+		const [options = {}] = context.options;
+		const attributes = new Set(options.attributes ?? _intlayer_config_extract.ATTRIBUTES_TO_EXTRACT);
+		const ignoredElements = new Set(options.ignoreElements ?? DEFAULT_IGNORED_ELEMENTS);
+		const ignorePatterns = (options.ignorePatterns ?? []).map((pattern) => new RegExp(pattern, "u"));
+		const includeStringLiterals = options.includeStringLiterals === true;
+		/** True when the text is copy the extractor would pick up. */
+		const isReportableText = (text) => (0, _intlayer_config_extract.shouldExtract)(text) && !ignorePatterns.some((pattern) => pattern.test(text.trim()));
+		/** Collapse whitespace so multi-line JSX text reads well in the report. */
+		const formatText = (text) => {
+			const normalized = text.replace(/\s+/gu, " ").trim();
+			return normalized.length > 40 ? `${normalized.slice(0, 40)}…` : normalized;
+		};
+		/**
+		* Handlers for the markup languages that are not JSX — Vue, Svelte and
+		* Angular templates. Reports through the same predicate and options as
+		* the JSX path so a project gets identical results whatever it is written
+		* in.
+		*/
+		const templateVisitor = require_utils_templates.createTemplateVisitor(({ node, text, attributeName, elementName }) => {
+			if (elementName && ignoredElements.has(elementName)) return;
+			if (attributeName !== null && !attributes.has(attributeName)) return;
+			if (!isReportableText(text)) return;
+			context.report({
+				node,
+				messageId: attributeName === null ? "rawText" : "rawAttribute",
+				data: {
+					text: formatText(text),
+					...attributeName === null ? {} : { attribute: attributeName }
+				}
+			});
+		});
+		return require_utils_templates.combineVisitors(context.sourceCode.parserServices, {
+			JSXText: (node) => {
+				const astNode = require_utils_ast.toAstNode(node);
+				const text = astNode["value"];
+				if (!isReportableText(text)) return;
+				const elementName = getEnclosingElementName(astNode.parent);
+				if (elementName && ignoredElements.has(elementName)) return;
+				context.report({
+					node,
+					messageId: "rawText",
+					data: { text: formatText(text) }
+				});
+			},
+			JSXAttribute: (node) => {
+				const astNode = require_utils_ast.toAstNode(node);
+				const attributeName = require_utils_ast.getJsxAttributeName(astNode);
+				if (!attributeName || !attributes.has(attributeName)) return;
+				const valueNode = require_utils_ast.getJsxAttributeValueNode(astNode);
+				const text = require_utils_ast.getStaticStringValue(valueNode);
+				if (text === null || !isReportableText(text)) return;
+				const elementName = getEnclosingElementName(astNode.parent);
+				if (elementName && ignoredElements.has(elementName)) return;
+				context.report({
+					node,
+					messageId: "rawAttribute",
+					data: {
+						attribute: attributeName,
+						text: formatText(text)
+					}
+				});
+			},
+			Literal: (node) => {
+				if (!includeStringLiterals) return;
+				const astNode = require_utils_ast.toAstNode(node);
+				if (typeof astNode["value"] !== "string") return;
+				if (isStructuralPosition(astNode)) return;
+				const text = astNode["value"];
+				if (!isReportableText(text)) return;
+				context.report({
+					node,
+					messageId: "rawStringLiteral",
+					data: { text: formatText(text) }
+				});
+			}
+		}, templateVisitor);
+	}
+});
+
+//#endregion
+exports.noRawText = noRawText;
+//# sourceMappingURL=noRawText.cjs.map

package/dist/cjs/rules/noRawText.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"noRawText.cjs","names":["FILE_EXTENSIONS","getJsxElementName","createRule","ATTRIBUTES_TO_EXTRACT","shouldExtract","createTemplateVisitor","combineVisitors","toAstNode","getJsxAttributeName","getJsxAttributeValueNode","getStaticStringValue"],"sources":["../../../src/rules/noRawText.ts"],"sourcesContent":["import { FILE_EXTENSIONS } from '@intlayer/config/defaultValues';\nimport { ATTRIBUTES_TO_EXTRACT, shouldExtract } from '@intlayer/config/extract';\nimport {\n  type AstNode,\n  type AstNodeWithParent,\n  getJsxAttributeName,\n  getJsxAttributeValueNode,\n  getJsxElementName,\n  getStaticStringValue,\n  toAstNode,\n} from '../utils/ast';\nimport { createRule } from '../utils/createRule';\nimport {\n  combineVisitors,\n  createTemplateVisitor,\n  type TemplateVisitor,\n} from '../utils/templates';\n\n/**\n * Elements whose text is markup, code or metadata rather than user-facing copy.\n * Extracting them would be wrong, so they are skipped by default.\n */\nconst DEFAULT_IGNORED_ELEMENTS = ['code', 'pre', 'script', 'style'];\n\nexport type NoRawTextOptions = {\n  /**\n   * JSX attributes whose string value is user-facing copy.\n   * Defaults to the compiler's own list, so the linter flags exactly what\n   * `intlayer extract` would rewrite.\n   */\n  attributes?: string[];\n  /** JSX elements whose children are never translatable. */\n  ignoreElements?: string[];\n  /** Regular-expression sources for text that should never be reported. */\n  ignorePatterns?: string[];\n  /**\n   * Also report string literals outside JSX (function arguments, object values,\n   * …). Off by default: outside JSX the false-positive rate is much higher, and\n   * the compiler's own extractor is the better first pass.\n   */\n  includeStringLiterals?: boolean;\n};\n\ntype MessageIds = 'rawText' | 'rawAttribute' | 'rawStringLiteral';\n\n/**\n * True for a content declaration file, where raw strings are the whole point.\n *\n * @param filename - Absolute path of the linted file.\n */\nconst isContentDeclarationFile = (filename: string): boolean =>\n  FILE_EXTENSIONS.some((extension) => filename.endsWith(extension));\n\n/**\n * Walk up from a JSX child or attribute to the tag name that encloses it.\n *\n * @param node - The reported node.\n */\nconst getEnclosingElementName = (\n  node: AstNodeWithParent | undefined\n): string | null => {\n  let current = node;\n\n  while (current) {\n    if (current.type === 'JSXElement') {\n      return getJsxElementName(current['openingElement'] as AstNode);\n    }\n\n    if (current.type === 'JSXOpeningElement') {\n      return getJsxElementName(current);\n    }\n\n    current = current.parent;\n  }\n\n  return null;\n};\n\n/**\n * True when the string literal sits in a position that is structural rather\n * than user-facing: module specifiers, property keys, directives, and the\n * arguments of the Intlayer getters themselves.\n *\n * @param node - The Literal node.\n */\nconst isStructuralPosition = (node: AstNodeWithParent): boolean => {\n  const parent = node.parent;\n\n  if (!parent) return true;\n\n  switch (parent.type) {\n    case 'ImportDeclaration':\n    case 'ImportExpression':\n    case 'ExportNamedDeclaration':\n    case 'ExportAllDeclaration':\n    case 'JSXAttribute':\n    case 'TSLiteralType':\n    case 'TSEnumMember':\n    case 'ExpressionStatement':\n      return true;\n\n    case 'Property':\n      // Keys are structural; values are not.\n      return parent['key'] === node && parent['computed'] !== true;\n\n    case 'MemberExpression':\n      return parent['property'] === node;\n\n    default:\n      return false;\n  }\n};\n\nexport const noRawText = createRule<[NoRawTextOptions?], MessageIds>(\n  'no-raw-text',\n  {\n    meta: {\n      type: 'problem',\n      docs: {\n        description:\n          'Report user-facing strings that are not declared in an Intlayer dictionary',\n      },\n      messages: {\n        rawText:\n          'Untranslated text \"{{text}}\". Move it to a dictionary — `npx intlayer extract` can do it for this file.',\n        rawAttribute:\n          'Untranslated `{{attribute}}` value \"{{text}}\". Move it to a dictionary — `npx intlayer extract` can do it for this file.',\n        rawStringLiteral:\n          'Untranslated string \"{{text}}\". Move it to a dictionary — `npx intlayer extract` can do it for this file.',\n      },\n      schema: [\n        {\n          type: 'object',\n          properties: {\n            attributes: { type: 'array', items: { type: 'string' } },\n            ignoreElements: { type: 'array', items: { type: 'string' } },\n            ignorePatterns: { type: 'array', items: { type: 'string' } },\n            includeStringLiterals: { type: 'boolean' },\n          },\n          additionalProperties: false,\n        },\n      ],\n    },\n\n    create: (context) => {\n      const filename = context.filename;\n\n      // Content declaration files hold the translations themselves.\n      if (isContentDeclarationFile(filename)) return {};\n\n      const [options = {}] = context.options;\n      const attributes = new Set<string>(\n        options.attributes ?? ATTRIBUTES_TO_EXTRACT\n      );\n      const ignoredElements = new Set<string>(\n        options.ignoreElements ?? DEFAULT_IGNORED_ELEMENTS\n      );\n      const ignorePatterns = (options.ignorePatterns ?? []).map(\n        (pattern) => new RegExp(pattern, 'u')\n      );\n      const includeStringLiterals = options.includeStringLiterals === true;\n\n      /** True when the text is copy the extractor would pick up. */\n      const isReportableText = (text: string): boolean =>\n        shouldExtract(text) &&\n        !ignorePatterns.some((pattern) => pattern.test(text.trim()));\n\n      /** Collapse whitespace so multi-line JSX text reads well in the report. */\n      const formatText = (text: string): string => {\n        const normalized = text.replace(/\\s+/gu, ' ').trim();\n\n        return normalized.length > 40\n          ? `${normalized.slice(0, 40)}…`\n          : normalized;\n      };\n\n      /**\n       * Handlers for the markup languages that are not JSX — Vue, Svelte and\n       * Angular templates. Reports through the same predicate and options as\n       * the JSX path so a project gets identical results whatever it is written\n       * in.\n       */\n      const templateVisitor = createTemplateVisitor(\n        ({ node, text, attributeName, elementName }) => {\n          if (elementName && ignoredElements.has(elementName)) return;\n\n          if (attributeName !== null && !attributes.has(attributeName)) return;\n\n          if (!isReportableText(text)) return;\n\n          context.report({\n            node: node as never,\n            messageId: attributeName === null ? 'rawText' : 'rawAttribute',\n            data: {\n              text: formatText(text),\n              ...(attributeName === null ? {} : { attribute: attributeName }),\n            },\n          });\n        }\n      );\n\n      const scriptVisitor: TemplateVisitor = {\n        JSXText: (node) => {\n          const astNode = toAstNode(node as never);\n          const text = astNode['value'] as string;\n\n          if (!isReportableText(text)) return;\n\n          const elementName = getEnclosingElementName(astNode.parent);\n\n          if (elementName && ignoredElements.has(elementName)) return;\n\n          context.report({\n            node: node as never,\n            messageId: 'rawText',\n            data: { text: formatText(text) },\n          });\n        },\n\n        JSXAttribute: (node) => {\n          const astNode = toAstNode(node as never);\n          const attributeName = getJsxAttributeName(astNode);\n\n          if (!attributeName || !attributes.has(attributeName)) return;\n\n          const valueNode = getJsxAttributeValueNode(astNode);\n          const text = getStaticStringValue(valueNode);\n\n          if (text === null || !isReportableText(text)) return;\n\n          const elementName = getEnclosingElementName(astNode.parent);\n\n          if (elementName && ignoredElements.has(elementName)) return;\n\n          context.report({\n            node: node as never,\n            messageId: 'rawAttribute',\n            data: { attribute: attributeName, text: formatText(text) },\n          });\n        },\n\n        Literal: (node) => {\n          if (!includeStringLiterals) return;\n\n          const astNode = toAstNode(node as never);\n\n          if (typeof astNode['value'] !== 'string') return;\n\n          if (isStructuralPosition(astNode)) return;\n\n          const text = astNode['value'] as string;\n\n          if (!isReportableText(text)) return;\n\n          context.report({\n            node: node as never,\n            messageId: 'rawStringLiteral',\n            data: { text: formatText(text) },\n          });\n        },\n      };\n\n      return combineVisitors(\n        context.sourceCode.parserServices,\n        scriptVisitor,\n        templateVisitor\n      );\n    },\n  }\n);\n"],"mappings":"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"}

package/dist/cjs/rules/staticDictionaryKey.cjs

@@ -0,0 +1,89 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils_ast = require('../utils/ast.cjs');
+const require_utils_createRule = require('../utils/createRule.cjs');
+const require_utils_callerMatcher = require('../utils/callerMatcher.cjs');
+
+//#region src/rules/staticDictionaryKey.ts
+/**
+* True when the call may legitimately omit its namespace — next-intl's
+* `useTranslations()` root scope derives the dictionary from each message id
+* instead, so an absent argument is not a violation.
+*
+* @param descriptor - The matched registry entry.
+*/
+const allowsMissingNamespace = (descriptor) => descriptor.allowRootScope === true;
+/**
+* Distinguish an interpolated template from any other runtime expression, so
+* the report can name the actual problem.
+*
+* @param node - The namespace node.
+*/
+const isInterpolatedTemplate = (node) => node.type === "TemplateLiteral" && (node["expressions"]?.length ?? 0) > 0;
+const staticDictionaryKey = require_utils_createRule.createRule("static-dictionary-key", {
+	meta: {
+		type: "problem",
+		docs: { description: "Require the dictionary key of an Intlayer content read to be a static string literal" },
+		messages: {
+			dynamicKey: "The dictionary key passed to `{{caller}}` must be a string literal. A computed key is invisible to the Intlayer compiler, which then skips the optimize pass and bundles every dictionary.",
+			dynamicTemplateKey: "The dictionary key passed to `{{caller}}` interpolates a value. Use a string literal — an interpolated key is invisible to the Intlayer compiler, which then skips the optimize pass and bundles every dictionary.",
+			dynamicJsxKey: "The `{{attribute}}` of `<{{caller}}>` must be a static string. A computed value is invisible to the Intlayer compiler, which then cannot resolve the dictionary at build time."
+		}
+	},
+	create: (context) => {
+		let activeDescriptors = require_utils_callerMatcher.getActiveDescriptors(/* @__PURE__ */ new Set());
+		/** Report the namespace of a matched call when it is not static. */
+		const reportDynamicNamespace = (match) => {
+			const { descriptor, namespace } = match;
+			if (!namespace) return;
+			if (namespace.source.from === "fixed") return;
+			if (!namespace.node) return;
+			if (namespace.value !== null) return;
+			context.report({
+				node: namespace.node,
+				messageId: isInterpolatedTemplate(namespace.node) ? "dynamicTemplateKey" : "dynamicKey",
+				data: { caller: descriptor.callerName }
+			});
+		};
+		return {
+			Program: (node) => {
+				activeDescriptors = require_utils_callerMatcher.getActiveDescriptors(require_utils_callerMatcher.collectImportSources(require_utils_ast.toAstNode(node)));
+			},
+			CallExpression: (node) => {
+				const match = require_utils_callerMatcher.matchCaller(require_utils_ast.toAstNode(node), activeDescriptors);
+				if (!match) return;
+				if (!match.namespace && allowsMissingNamespace(match.descriptor)) return;
+				reportDynamicNamespace(match);
+			},
+			TaggedTemplateExpression: (node) => {
+				const match = require_utils_callerMatcher.matchCaller(require_utils_ast.toAstNode(node), activeDescriptors);
+				if (match) reportDynamicNamespace(match);
+			},
+			JSXOpeningElement: (node) => {
+				const astNode = require_utils_ast.toAstNode(node);
+				const descriptor = require_utils_callerMatcher.matchJsxCaller(require_utils_ast.getJsxElementName(astNode), activeDescriptors);
+				if (!descriptor) return;
+				const attributes = astNode["attributes"] ?? [];
+				const targetAttributes = [descriptor.jsxIdAttribute, descriptor.jsxNamespaceAttribute].filter((name) => typeof name === "string");
+				for (const attribute of attributes) {
+					const attributeName = require_utils_ast.getJsxAttributeName(attribute);
+					if (!attributeName || !targetAttributes.includes(attributeName)) continue;
+					const valueNode = require_utils_ast.getJsxAttributeValueNode(attribute);
+					if (!valueNode) continue;
+					if (require_utils_ast.getStaticStringValue(valueNode) !== null) continue;
+					context.report({
+						node: attribute,
+						messageId: "dynamicJsxKey",
+						data: {
+							attribute: attributeName,
+							caller: descriptor.callerName
+						}
+					});
+				}
+			}
+		};
+	}
+});
+
+//#endregion
+exports.staticDictionaryKey = staticDictionaryKey;
+//# sourceMappingURL=staticDictionaryKey.cjs.map

package/dist/cjs/rules/staticDictionaryKey.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"staticDictionaryKey.cjs","names":["createRule","getActiveDescriptors","collectImportSources","toAstNode","matchCaller","matchJsxCaller","getJsxElementName","getJsxAttributeName","getJsxAttributeValueNode","getStaticStringValue"],"sources":["../../../src/rules/staticDictionaryKey.ts"],"sourcesContent":["import type { CallerDescriptor } from '@intlayer/config/callers';\nimport {\n  type AstNode,\n  getJsxAttributeName,\n  getJsxAttributeValueNode,\n  getJsxElementName,\n  getStaticStringValue,\n  toAstNode,\n} from '../utils/ast';\nimport {\n  type CallerMatch,\n  collectImportSources,\n  getActiveDescriptors,\n  matchCaller,\n  matchJsxCaller,\n} from '../utils/callerMatcher';\nimport { createRule } from '../utils/createRule';\n\ntype MessageIds = 'dynamicKey' | 'dynamicTemplateKey' | 'dynamicJsxKey';\n\n/**\n * True when the call may legitimately omit its namespace — next-intl's\n * `useTranslations()` root scope derives the dictionary from each message id\n * instead, so an absent argument is not a violation.\n *\n * @param descriptor - The matched registry entry.\n */\nconst allowsMissingNamespace = (descriptor: CallerDescriptor): boolean =>\n  descriptor.allowRootScope === true;\n\n/**\n * Distinguish an interpolated template from any other runtime expression, so\n * the report can name the actual problem.\n *\n * @param node - The namespace node.\n */\nconst isInterpolatedTemplate = (node: AstNode): boolean =>\n  node.type === 'TemplateLiteral' &&\n  ((node['expressions'] as unknown[] | undefined)?.length ?? 0) > 0;\n\nexport const staticDictionaryKey = createRule<[], MessageIds>(\n  'static-dictionary-key',\n  {\n    meta: {\n      type: 'problem',\n      docs: {\n        description:\n          'Require the dictionary key of an Intlayer content read to be a static string literal',\n      },\n      messages: {\n        dynamicKey:\n          'The dictionary key passed to `{{caller}}` must be a string literal. A computed key is invisible to the Intlayer compiler, which then skips the optimize pass and bundles every dictionary.',\n        dynamicTemplateKey:\n          'The dictionary key passed to `{{caller}}` interpolates a value. Use a string literal — an interpolated key is invisible to the Intlayer compiler, which then skips the optimize pass and bundles every dictionary.',\n        dynamicJsxKey:\n          'The `{{attribute}}` of `<{{caller}}>` must be a static string. A computed value is invisible to the Intlayer compiler, which then cannot resolve the dictionary at build time.',\n      },\n    },\n\n    create: (context) => {\n      let activeDescriptors = getActiveDescriptors(new Set());\n\n      /** Report the namespace of a matched call when it is not static. */\n      const reportDynamicNamespace = (match: CallerMatch): void => {\n        const { descriptor, namespace } = match;\n\n        if (!namespace) return;\n\n        // A `fixed` namespace is a compile-time constant by construction.\n        if (namespace.source.from === 'fixed') return;\n\n        if (!namespace.node) {\n          // Nothing was passed at all — only a problem for callers that require it.\n          return;\n        }\n\n        if (namespace.value !== null) return;\n\n        context.report({\n          node: namespace.node as never,\n          messageId: isInterpolatedTemplate(namespace.node)\n            ? 'dynamicTemplateKey'\n            : 'dynamicKey',\n          data: { caller: descriptor.callerName },\n        });\n      };\n\n      return {\n        Program: (node) => {\n          activeDescriptors = getActiveDescriptors(\n            collectImportSources(toAstNode(node))\n          );\n        },\n\n        CallExpression: (node) => {\n          const match = matchCaller(toAstNode(node), activeDescriptors);\n\n          if (!match) return;\n\n          if (!match.namespace && allowsMissingNamespace(match.descriptor)) {\n            return;\n          }\n\n          reportDynamicNamespace(match);\n        },\n\n        TaggedTemplateExpression: (node) => {\n          const match = matchCaller(toAstNode(node), activeDescriptors);\n\n          if (match) reportDynamicNamespace(match);\n        },\n\n        JSXOpeningElement: (node) => {\n          const astNode = toAstNode(node);\n          const descriptor = matchJsxCaller(\n            getJsxElementName(astNode),\n            activeDescriptors\n          );\n\n          if (!descriptor) return;\n\n          const attributes =\n            (astNode['attributes'] as AstNode[] | undefined) ?? [];\n\n          const targetAttributes = [\n            descriptor.jsxIdAttribute,\n            descriptor.jsxNamespaceAttribute,\n          ].filter((name): name is string => typeof name === 'string');\n\n          for (const attribute of attributes) {\n            const attributeName = getJsxAttributeName(attribute);\n\n            if (!attributeName || !targetAttributes.includes(attributeName)) {\n              continue;\n            }\n\n            const valueNode = getJsxAttributeValueNode(attribute);\n\n            if (!valueNode) continue;\n\n            if (getStaticStringValue(valueNode) !== null) continue;\n\n            context.report({\n              node: attribute as never,\n              messageId: 'dynamicJsxKey',\n              data: {\n                attribute: attributeName,\n                caller: descriptor.callerName,\n              },\n            });\n          }\n        },\n      };\n    },\n  }\n);\n"],"mappings":";;;;;;;;;;;;;AA2BA,MAAM,0BAA0B,eAC9B,WAAW,mBAAmB;;;;;;;AAQhC,MAAM,0BAA0B,SAC9B,KAAK,SAAS,sBACZ,KAAK,cAAc,EAA4B,UAAU,KAAK;AAElE,MAAa,sBAAsBA,oCACjC,yBACA;CACE,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,uFACJ;EACA,UAAU;GACR,YACE;GACF,oBACE;GACF,eACE;EACJ;CACF;CAEA,SAAS,YAAY;EACnB,IAAI,oBAAoBC,iEAAqB,IAAI,IAAI,CAAC;;EAGtD,MAAM,0BAA0B,UAA6B;GAC3D,MAAM,EAAE,YAAY,cAAc;GAElC,IAAI,CAAC,WAAW;GAGhB,IAAI,UAAU,OAAO,SAAS,SAAS;GAEvC,IAAI,CAAC,UAAU,MAEb;GAGF,IAAI,UAAU,UAAU,MAAM;GAE9B,QAAQ,OAAO;IACb,MAAM,UAAU;IAChB,WAAW,uBAAuB,UAAU,IAAI,IAC5C,uBACA;IACJ,MAAM,EAAE,QAAQ,WAAW,WAAW;GACxC,CAAC;EACH;EAEA,OAAO;GACL,UAAU,SAAS;IACjB,oBAAoBA,iDAClBC,iDAAqBC,4BAAU,IAAI,CAAC,CACtC;GACF;GAEA,iBAAiB,SAAS;IACxB,MAAM,QAAQC,wCAAYD,4BAAU,IAAI,GAAG,iBAAiB;IAE5D,IAAI,CAAC,OAAO;IAEZ,IAAI,CAAC,MAAM,aAAa,uBAAuB,MAAM,UAAU,GAC7D;IAGF,uBAAuB,KAAK;GAC9B;GAEA,2BAA2B,SAAS;IAClC,MAAM,QAAQC,wCAAYD,4BAAU,IAAI,GAAG,iBAAiB;IAE5D,IAAI,OAAO,uBAAuB,KAAK;GACzC;GAEA,oBAAoB,SAAS;IAC3B,MAAM,UAAUA,4BAAU,IAAI;IAC9B,MAAM,aAAaE,2CACjBC,oCAAkB,OAAO,GACzB,iBACF;IAEA,IAAI,CAAC,YAAY;IAEjB,MAAM,aACH,QAAQ,iBAA2C,CAAC;IAEvD,MAAM,mBAAmB,CACvB,WAAW,gBACX,WAAW,qBACb,CAAC,CAAC,QAAQ,SAAyB,OAAO,SAAS,QAAQ;IAE3D,KAAK,MAAM,aAAa,YAAY;KAClC,MAAM,gBAAgBC,sCAAoB,SAAS;KAEnD,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,SAAS,aAAa,GAC5D;KAGF,MAAM,YAAYC,2CAAyB,SAAS;KAEpD,IAAI,CAAC,WAAW;KAEhB,IAAIC,uCAAqB,SAAS,MAAM,MAAM;KAE9C,QAAQ,OAAO;MACb,MAAM;MACN,WAAW;MACX,MAAM;OACJ,WAAW;OACX,QAAQ,WAAW;MACrB;KACF,CAAC;IACH;GACF;EACF;CACF;AACF,CACF"}

package/dist/cjs/utils/ast.cjs

@@ -0,0 +1,151 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region src/utils/ast.ts
+/**
+* TypeScript wrapper expressions that carry no runtime meaning. The Intlayer
+* compiler unwraps them before reading a value, so the rules must too —
+* `useIntlayer('home' as const)` is every bit as static as `useIntlayer('home')`.
+*/
+const TRANSPARENT_EXPRESSION_TYPES = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"TSTypeAssertion",
+	"TSInstantiationExpression"
+]);
+/**
+* Strip TypeScript-only and parenthesised wrappers to reach the expression that
+* actually produces the value.
+*
+* @param node - Expression to unwrap; `null`/`undefined` passes straight through.
+*/
+const unwrapExpression = (node) => {
+	let current = node ?? null;
+	while (current && (TRANSPARENT_EXPRESSION_TYPES.has(current.type) || current.type === "ChainExpression")) current = current["expression"] ?? null;
+	return current ?? null;
+};
+/**
+* Read the compile-time string value of an expression, or `null` when the value
+* can only be known at runtime.
+*
+* Deliberately does **not** resolve identifiers, even ones bound to a string
+* constant: the Babel/SWC passes read the argument node itself, so a value that
+* needs constant folding is a value the compiler will not see.
+*
+* @param node - Expression to evaluate.
+*/
+const getStaticStringValue = (node) => {
+	const expression = unwrapExpression(node);
+	if (!expression) return null;
+	if (expression.type === "Literal") {
+		const value = expression["value"];
+		return typeof value === "string" ? value : null;
+	}
+	if (expression.type === "TemplateLiteral") {
+		const expressions = expression["expressions"];
+		const quasis = expression["quasis"];
+		if (expressions?.length !== 0 || quasis?.length !== 1) return null;
+		const cooked = (quasis[0]?.["value"])?.cooked;
+		return typeof cooked === "string" ? cooked : null;
+	}
+	return null;
+};
+/**
+* Name of the function being called, plus whether it was reached as a method.
+*
+* `matchAsMethod` descriptors (`i18n.getFixedT(…)`, `intl.formatMessage(…)`)
+* only match the member form, so the two cases must stay distinguishable.
+*
+* @param callee - The `callee` of a CallExpression.
+*/
+const getCalleeName = (callee) => {
+	const expression = unwrapExpression(callee);
+	if (!expression) return null;
+	if (expression.type === "Identifier") return {
+		name: expression["name"],
+		isMethod: false
+	};
+	if (expression.type === "MemberExpression" && !expression["computed"]) {
+		const property = expression["property"];
+		if (property?.type === "Identifier") return {
+			name: property["name"],
+			isMethod: true
+		};
+	}
+	return null;
+};
+/**
+* Read a string-valued property from an object-literal argument, e.g. the
+* `namespace` of `getTranslations({ namespace: 'home' })`.
+*
+* Returns the property's value node even when it is not static, so callers can
+* tell "absent" (`null`) from "present but dynamic" (a node, no string).
+*
+* @param node - The argument expected to be an object expression.
+* @param propertyName - Property to look up.
+*/
+const getObjectPropertyValueNode = (node, propertyName) => {
+	const expression = unwrapExpression(node);
+	if (expression?.type !== "ObjectExpression") return null;
+	const properties = expression["properties"] ?? [];
+	for (const property of properties) {
+		if (property.type !== "Property") continue;
+		const key = property["key"];
+		const computed = property["computed"] === true;
+		if ((key?.type === "Identifier" && !computed ? key["name"] : key?.type === "Literal" ? String(key["value"]) : null) === propertyName) return property["value"] ?? null;
+	}
+	return null;
+};
+/**
+* Name of a JSX attribute, or `null` for spread attributes and namespaced
+* names the plugin does not target.
+*
+* @param attribute - A member of a JSX opening element's `attributes`.
+*/
+const getJsxAttributeName = (attribute) => {
+	if (attribute?.type !== "JSXAttribute") return null;
+	const name = attribute["name"];
+	return name?.type === "JSXIdentifier" ? name["name"] : null;
+};
+/**
+* Value node of a JSX attribute, unwrapping `{'…'}` expression containers so
+* `title="Text"` and `title={'Text'}` are treated alike.
+*
+* @param attribute - A JSX attribute node.
+*/
+const getJsxAttributeValueNode = (attribute) => {
+	const value = attribute?.["value"] ?? null;
+	if (value?.type === "JSXExpressionContainer") return unwrapExpression(value["expression"] ?? null);
+	return value;
+};
+/**
+* Tag name of the JSX element an attribute or child belongs to, e.g. `'code'`
+* for `<code>`. Member and namespaced element names are joined with `.`.
+*
+* @param openingElement - A JSXOpeningElement node.
+*/
+const getJsxElementName = (openingElement) => {
+	const readName = (node) => {
+		if (!node) return null;
+		if (node.type === "JSXIdentifier") return node["name"];
+		if (node.type === "JSXMemberExpression") {
+			const object = readName(node["object"]);
+			const property = readName(node["property"]);
+			return object && property ? `${object}.${property}` : null;
+		}
+		return null;
+	};
+	return readName(openingElement?.["name"]);
+};
+/** Narrow an ESLint visitor node to the loose {@link AstNode} shape. */
+const toAstNode = (node) => node;
+
+//#endregion
+exports.getCalleeName = getCalleeName;
+exports.getJsxAttributeName = getJsxAttributeName;
+exports.getJsxAttributeValueNode = getJsxAttributeValueNode;
+exports.getJsxElementName = getJsxElementName;
+exports.getObjectPropertyValueNode = getObjectPropertyValueNode;
+exports.getStaticStringValue = getStaticStringValue;
+exports.toAstNode = toAstNode;
+exports.unwrapExpression = unwrapExpression;
+//# sourceMappingURL=ast.cjs.map

package/dist/cjs/utils/ast.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.cjs","names":[],"sources":["../../../src/utils/ast.ts"],"sourcesContent":["import type { Node as EsTreeNode } from 'estree';\n\n/**\n * Minimal structural models for the nodes this plugin inspects that are not\n * part of the ESTree spec — JSX (all parsers) and the TypeScript-only wrapper\n * expressions emitted by `@typescript-eslint/parser`.\n *\n * They are declared here rather than imported from `@typescript-eslint/types`\n * so the plugin stays parser-agnostic: the same rules run under `espree`,\n * `@typescript-eslint/parser`, `vue-eslint-parser` and oxlint's JS plugin\n * bridge, none of which agree on a type package.\n */\n\n/** Any AST node, whatever the parser. Narrowed through the guards below. */\nexport type AstNode = {\n  type: string;\n  [key: string]: unknown;\n};\n\n/** An AST node as ESLint hands it to a visitor — always linked to its parent. */\nexport type AstNodeWithParent = AstNode & {\n  parent?: AstNodeWithParent;\n};\n\n/** `<div>Some text</div>` — the raw text between two JSX tags. */\nexport type JsxTextNode = AstNode & {\n  type: 'JSXText';\n  value: string;\n};\n\n/** `title=\"Some text\"` on a JSX element. */\nexport type JsxAttributeNode = AstNode & {\n  type: 'JSXAttribute';\n  name: AstNode;\n  value: AstNode | null;\n};\n\n/** The opening tag of a JSX element, holding its name and attributes. */\nexport type JsxOpeningElementNode = AstNode & {\n  type: 'JSXOpeningElement';\n  name: AstNode;\n  attributes: AstNode[];\n};\n\n/**\n * TypeScript wrapper expressions that carry no runtime meaning. The Intlayer\n * compiler unwraps them before reading a value, so the rules must too —\n * `useIntlayer('home' as const)` is every bit as static as `useIntlayer('home')`.\n */\nconst TRANSPARENT_EXPRESSION_TYPES = new Set([\n  'TSAsExpression',\n  'TSSatisfiesExpression',\n  'TSNonNullExpression',\n  'TSTypeAssertion',\n  'TSInstantiationExpression',\n]);\n\n/**\n * Strip TypeScript-only and parenthesised wrappers to reach the expression that\n * actually produces the value.\n *\n * @param node - Expression to unwrap; `null`/`undefined` passes straight through.\n */\nexport const unwrapExpression = <T extends AstNode>(\n  node: T | null | undefined\n): T | null => {\n  let current: AstNode | null = node ?? null;\n\n  while (\n    current &&\n    (TRANSPARENT_EXPRESSION_TYPES.has(current.type) ||\n      current.type === 'ChainExpression')\n  ) {\n    current = (current['expression'] as AstNode | undefined) ?? null;\n  }\n\n  return (current as T | null) ?? null;\n};\n\n/**\n * Read the compile-time string value of an expression, or `null` when the value\n * can only be known at runtime.\n *\n * Deliberately does **not** resolve identifiers, even ones bound to a string\n * constant: the Babel/SWC passes read the argument node itself, so a value that\n * needs constant folding is a value the compiler will not see.\n *\n * @param node - Expression to evaluate.\n */\nexport const getStaticStringValue = (\n  node: AstNode | null | undefined\n): string | null => {\n  const expression = unwrapExpression(node);\n\n  if (!expression) return null;\n\n  if (expression.type === 'Literal') {\n    const value = expression['value'];\n\n    return typeof value === 'string' ? value : null;\n  }\n\n  // A template literal is static only when it interpolates nothing.\n  if (expression.type === 'TemplateLiteral') {\n    const expressions = expression['expressions'] as unknown[] | undefined;\n    const quasis = expression['quasis'] as AstNode[] | undefined;\n\n    if (expressions?.length !== 0 || quasis?.length !== 1) return null;\n\n    const cooked = (quasis[0]?.['value'] as { cooked?: string } | undefined)\n      ?.cooked;\n\n    return typeof cooked === 'string' ? cooked : null;\n  }\n\n  return null;\n};\n\n/**\n * Name of the function being called, plus whether it was reached as a method.\n *\n * `matchAsMethod` descriptors (`i18n.getFixedT(…)`, `intl.formatMessage(…)`)\n * only match the member form, so the two cases must stay distinguishable.\n *\n * @param callee - The `callee` of a CallExpression.\n */\nexport const getCalleeName = (\n  callee: AstNode | null | undefined\n): { name: string; isMethod: boolean } | null => {\n  const expression = unwrapExpression(callee);\n\n  if (!expression) return null;\n\n  if (expression.type === 'Identifier') {\n    return { name: expression['name'] as string, isMethod: false };\n  }\n\n  if (expression.type === 'MemberExpression' && !expression['computed']) {\n    const property = expression['property'] as AstNode | undefined;\n\n    if (property?.type === 'Identifier') {\n      return { name: property['name'] as string, isMethod: true };\n    }\n  }\n\n  return null;\n};\n\n/**\n * Read a string-valued property from an object-literal argument, e.g. the\n * `namespace` of `getTranslations({ namespace: 'home' })`.\n *\n * Returns the property's value node even when it is not static, so callers can\n * tell \"absent\" (`null`) from \"present but dynamic\" (a node, no string).\n *\n * @param node - The argument expected to be an object expression.\n * @param propertyName - Property to look up.\n */\nexport const getObjectPropertyValueNode = (\n  node: AstNode | null | undefined,\n  propertyName: string\n): AstNode | null => {\n  const expression = unwrapExpression(node);\n\n  if (expression?.type !== 'ObjectExpression') return null;\n\n  const properties = (expression['properties'] as AstNode[] | undefined) ?? [];\n\n  for (const property of properties) {\n    if (property.type !== 'Property') continue;\n\n    const key = property['key'] as AstNode | undefined;\n    const computed = property['computed'] === true;\n\n    const keyName =\n      key?.type === 'Identifier' && !computed\n        ? (key['name'] as string)\n        : key?.type === 'Literal'\n          ? String(key['value'])\n          : null;\n\n    if (keyName === propertyName) {\n      return (property['value'] as AstNode | undefined) ?? null;\n    }\n  }\n\n  return null;\n};\n\n/**\n * Name of a JSX attribute, or `null` for spread attributes and namespaced\n * names the plugin does not target.\n *\n * @param attribute - A member of a JSX opening element's `attributes`.\n */\nexport const getJsxAttributeName = (\n  attribute: AstNode | null | undefined\n): string | null => {\n  if (attribute?.type !== 'JSXAttribute') return null;\n\n  const name = attribute['name'] as AstNode | undefined;\n\n  return name?.type === 'JSXIdentifier' ? (name['name'] as string) : null;\n};\n\n/**\n * Value node of a JSX attribute, unwrapping `{'…'}` expression containers so\n * `title=\"Text\"` and `title={'Text'}` are treated alike.\n *\n * @param attribute - A JSX attribute node.\n */\nexport const getJsxAttributeValueNode = (\n  attribute: AstNode | null | undefined\n): AstNode | null => {\n  const value = (attribute?.['value'] as AstNode | undefined) ?? null;\n\n  if (value?.type === 'JSXExpressionContainer') {\n    return unwrapExpression((value['expression'] as AstNode) ?? null);\n  }\n\n  return value;\n};\n\n/**\n * Tag name of the JSX element an attribute or child belongs to, e.g. `'code'`\n * for `<code>`. Member and namespaced element names are joined with `.`.\n *\n * @param openingElement - A JSXOpeningElement node.\n */\nexport const getJsxElementName = (\n  openingElement: AstNode | null | undefined\n): string | null => {\n  const readName = (node: AstNode | null | undefined): string | null => {\n    if (!node) return null;\n\n    if (node.type === 'JSXIdentifier') return node['name'] as string;\n\n    if (node.type === 'JSXMemberExpression') {\n      const object = readName(node['object'] as AstNode);\n      const property = readName(node['property'] as AstNode);\n\n      return object && property ? `${object}.${property}` : null;\n    }\n\n    return null;\n  };\n\n  return readName(openingElement?.['name'] as AstNode | undefined);\n};\n\n/** Narrow an ESLint visitor node to the loose {@link AstNode} shape. */\nexport const toAstNode = (node: EsTreeNode | AstNode): AstNodeWithParent =>\n  node as unknown as AstNodeWithParent;\n"],"mappings":";;;;;;;AAiDA,MAAM,+CAA+B,IAAI,IAAI;CAC3C;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;;AAQD,MAAa,oBACX,SACa;CACb,IAAI,UAA0B,QAAQ;CAEtC,OACE,YACC,6BAA6B,IAAI,QAAQ,IAAI,KAC5C,QAAQ,SAAS,oBAEnB,UAAW,QAAQ,iBAAyC;CAG9D,OAAQ,WAAwB;AAClC;;;;;;;;;;;AAYA,MAAa,wBACX,SACkB;CAClB,MAAM,aAAa,iBAAiB,IAAI;CAExC,IAAI,CAAC,YAAY,OAAO;CAExB,IAAI,WAAW,SAAS,WAAW;EACjC,MAAM,QAAQ,WAAW;EAEzB,OAAO,OAAO,UAAU,WAAW,QAAQ;CAC7C;CAGA,IAAI,WAAW,SAAS,mBAAmB;EACzC,MAAM,cAAc,WAAW;EAC/B,MAAM,SAAS,WAAW;EAE1B,IAAI,aAAa,WAAW,KAAK,QAAQ,WAAW,GAAG,OAAO;EAE9D,MAAM,UAAU,OAAO,EAAE,GAAG,SAAQ,EAChC;EAEJ,OAAO,OAAO,WAAW,WAAW,SAAS;CAC/C;CAEA,OAAO;AACT;;;;;;;;;AAUA,MAAa,iBACX,WAC+C;CAC/C,MAAM,aAAa,iBAAiB,MAAM;CAE1C,IAAI,CAAC,YAAY,OAAO;CAExB,IAAI,WAAW,SAAS,cACtB,OAAO;EAAE,MAAM,WAAW;EAAmB,UAAU;CAAM;CAG/D,IAAI,WAAW,SAAS,sBAAsB,CAAC,WAAW,aAAa;EACrE,MAAM,WAAW,WAAW;EAE5B,IAAI,UAAU,SAAS,cACrB,OAAO;GAAE,MAAM,SAAS;GAAmB,UAAU;EAAK;CAE9D;CAEA,OAAO;AACT;;;;;;;;;;;AAYA,MAAa,8BACX,MACA,iBACmB;CACnB,MAAM,aAAa,iBAAiB,IAAI;CAExC,IAAI,YAAY,SAAS,oBAAoB,OAAO;CAEpD,MAAM,aAAc,WAAW,iBAA2C,CAAC;CAE3E,KAAK,MAAM,YAAY,YAAY;EACjC,IAAI,SAAS,SAAS,YAAY;EAElC,MAAM,MAAM,SAAS;EACrB,MAAM,WAAW,SAAS,gBAAgB;EAS1C,KANE,KAAK,SAAS,gBAAgB,CAAC,WAC1B,IAAI,UACL,KAAK,SAAS,YACZ,OAAO,IAAI,QAAQ,IACnB,UAEQ,cACd,OAAQ,SAAS,YAAoC;CAEzD;CAEA,OAAO;AACT;;;;;;;AAQA,MAAa,uBACX,cACkB;CAClB,IAAI,WAAW,SAAS,gBAAgB,OAAO;CAE/C,MAAM,OAAO,UAAU;CAEvB,OAAO,MAAM,SAAS,kBAAmB,KAAK,UAAqB;AACrE;;;;;;;AAQA,MAAa,4BACX,cACmB;CACnB,MAAM,QAAS,YAAY,YAAoC;CAE/D,IAAI,OAAO,SAAS,0BAClB,OAAO,iBAAkB,MAAM,iBAA6B,IAAI;CAGlE,OAAO;AACT;;;;;;;AAQA,MAAa,qBACX,mBACkB;CAClB,MAAM,YAAY,SAAoD;EACpE,IAAI,CAAC,MAAM,OAAO;EAElB,IAAI,KAAK,SAAS,iBAAiB,OAAO,KAAK;EAE/C,IAAI,KAAK,SAAS,uBAAuB;GACvC,MAAM,SAAS,SAAS,KAAK,SAAoB;GACjD,MAAM,WAAW,SAAS,KAAK,WAAsB;GAErD,OAAO,UAAU,WAAW,GAAG,OAAO,GAAG,aAAa;EACxD;EAEA,OAAO;CACT;CAEA,OAAO,SAAS,iBAAiB,OAA8B;AACjE;;AAGA,MAAa,aAAa,SACxB"}

package/dist/cjs/utils/callerMatcher.cjs

@@ -0,0 +1,130 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils_ast = require('./ast.cjs');
+let _intlayer_config_callers = require("@intlayer/config/callers");
+
+//#region src/utils/callerMatcher.ts
+/**
+* Module specifiers imported by a file, as they are written in source.
+*
+* `isCallerActive` gates generic caller names (lingui's `t` / `_`) on the file
+* actually importing the library, so this must be collected before matching.
+*
+* @param program - The Program node of the analysed file.
+*/
+const collectImportSources = (program) => {
+	const sources = /* @__PURE__ */ new Set();
+	const body = program["body"] ?? [];
+	for (const statement of body) {
+		if (statement.type !== "ImportDeclaration" && statement.type !== "ExportNamedDeclaration" && statement.type !== "ExportAllDeclaration") continue;
+		const value = statement["source"]?.["value"];
+		if (typeof value === "string") sources.add(value);
+	}
+	return sources;
+};
+/**
+* The registry entries that may match inside a file, given what it imports.
+*
+* @param importSources - Specifiers collected by {@link collectImportSources}.
+*/
+const getActiveDescriptors = (importSources) => _intlayer_config_callers.ALL_CALLERS.filter((descriptor) => (0, _intlayer_config_callers.isCallerActive)(descriptor, importSources));
+/**
+* Resolve one {@link CallerValueSource} against a call's arguments.
+*
+* @param source - The registry rule describing where to look.
+* @param callArguments - Arguments of the call expression.
+* @param descriptor - The caller being matched, needed to disambiguate overloads.
+*/
+const resolveNamespaceSource = (source, callArguments, descriptor) => {
+	if (source.from === "fixed") return {
+		node: null,
+		value: source.value,
+		source
+	};
+	if (source.from === "argument") {
+		const argument = callArguments[source.index] ?? null;
+		if (!argument) return null;
+		if (argument.type === "SpreadElement") return {
+			node: argument,
+			value: null,
+			source
+		};
+		if (argument.type === "ObjectExpression" && descriptor.namespaceSources.some((candidate) => candidate.from === "option" && candidate.argumentIndex === source.index)) return null;
+		return {
+			node: argument,
+			value: require_utils_ast.getStaticStringValue(argument),
+			source
+		};
+	}
+	if (source.from === "option") {
+		const optionsArgument = callArguments[source.argumentIndex] ?? null;
+		const valueNode = require_utils_ast.getObjectPropertyValueNode(optionsArgument, source.property);
+		if (!valueNode) return null;
+		return {
+			node: valueNode,
+			value: require_utils_ast.getStaticStringValue(valueNode),
+			source
+		};
+	}
+	const [firstArgument] = callArguments;
+	const messageId = require_utils_ast.getStaticStringValue(firstArgument);
+	return {
+		node: firstArgument ?? null,
+		value: messageId ? messageId.split(".")[0] ?? null : null,
+		source
+	};
+};
+/**
+* Match a call expression against the shared caller registry.
+*
+* Tries every `namespaceSources` entry in declaration order and keeps the first
+* that yields a node or a value — mirroring how `@intlayer/babel` picks an
+* overload, so the linter and the compiler agree on what a call site means.
+*
+* @param callNode - A CallExpression (or TaggedTemplateExpression) node.
+* @param activeDescriptors - Result of {@link getActiveDescriptors}.
+*/
+const matchCaller = (callNode, activeDescriptors) => {
+	const isTaggedTemplate = callNode.type === "TaggedTemplateExpression";
+	if (callNode.type !== "CallExpression" && !isTaggedTemplate) return null;
+	const callee = require_utils_ast.getCalleeName(callNode[isTaggedTemplate ? "tag" : "callee"] ?? null);
+	if (!callee) return null;
+	const callArguments = (callNode["arguments"] ?? []).map((argument) => argument.type === "SpreadElement" ? argument : require_utils_ast.unwrapExpression(argument)).filter((argument) => argument !== null);
+	for (const descriptor of activeDescriptors) {
+		if (descriptor.callerName !== callee.name) continue;
+		if (callee.isMethod && descriptor.matchAsMethod !== true) continue;
+		if (isTaggedTemplate && descriptor.matchAsTaggedTemplate !== true) continue;
+		let fallback = null;
+		for (const source of descriptor.namespaceSources) {
+			const namespace = resolveNamespaceSource(source, callArguments, descriptor);
+			if (!namespace) continue;
+			if (namespace.value !== null) return {
+				descriptor,
+				namespace
+			};
+			fallback ??= namespace;
+		}
+		return {
+			descriptor,
+			namespace: fallback
+		};
+	}
+	return null;
+};
+/**
+* Match a JSX element against the registry's JSX-shaped callers,
+* e.g. `<FormattedMessage id="home.title" />` or `<Trans ns="home" …/>`.
+*
+* @param elementName - Tag name of the element.
+* @param activeDescriptors - Result of {@link getActiveDescriptors}.
+*/
+const matchJsxCaller = (elementName, activeDescriptors) => {
+	if (!elementName) return null;
+	return activeDescriptors.find((descriptor) => descriptor.callerName === elementName && descriptor.jsxIdAttribute !== void 0) ?? null;
+};
+
+//#endregion
+exports.collectImportSources = collectImportSources;
+exports.getActiveDescriptors = getActiveDescriptors;
+exports.matchCaller = matchCaller;
+exports.matchJsxCaller = matchJsxCaller;
+//# sourceMappingURL=callerMatcher.cjs.map