eslint-plugin-intlayer 9.3.1

package/dist/esm/utils/templates.mjs

@@ -0,0 +1,145 @@
+//#region src/utils/templates.ts
+/**
+* Element node types whose text content is never user-facing copy, regardless
+* of the `ignoreElements` option (which matches on tag name, and these carry
+* none in some parsers).
+*/
+const NON_CONTENT_ELEMENT_TYPES = /* @__PURE__ */ new Set(["SvelteScriptElement", "SvelteStyleElement"]);
+/** Element node types, per parser, that carry a tag name. */
+const ELEMENT_TYPES = /* @__PURE__ */ new Set([
+	"VElement",
+	"SvelteElement",
+	"Element",
+	"JSXElement",
+	"JSXOpeningElement"
+]);
+/**
+* Read the tag name off an element node, normalising the three shapes parsers
+* use: a plain string (Vue, Angular), a `SvelteName` node (Svelte), and a JSX
+* name node.
+*
+* @param element - An element node.
+*/
+const readElementName = (element) => {
+	const name = element["name"];
+	if (typeof name === "string") return name;
+	if (name && typeof name === "object") {
+		const nameNode = name;
+		if (typeof nameNode["name"] === "string") return nameNode["name"];
+	}
+	const openingElement = element["openingElement"];
+	if (openingElement) return readElementName(openingElement);
+	return null;
+};
+/**
+* Walk up to the nearest enclosing element and return its tag name, or the
+* sentinel `false` when the text sits inside a `<script>`/`<style>` block that
+* should never be reported.
+*
+* @param node - The text or attribute node to start from.
+*/
+const resolveEnclosingElement = (node) => {
+	let current = node?.parent;
+	while (current) {
+		if (NON_CONTENT_ELEMENT_TYPES.has(current.type)) return false;
+		if (ELEMENT_TYPES.has(current.type)) return readElementName(current);
+		current = current.parent;
+	}
+	return null;
+};
+/**
+* Report a finding unless it sits inside a non-content element.
+*
+* @param report - The rule's reporter.
+* @param node - Node to report on.
+* @param text - The literal text.
+* @param attributeName - Attribute name, or `null` for element text.
+*/
+const reportWithElement = (report, node, text, attributeName) => {
+	const elementName = resolveEnclosingElement(node);
+	if (elementName === false) return;
+	report({
+		node,
+		text,
+		attributeName,
+		elementName
+	});
+};
+/**
+* Visitors covering every non-JSX template language Intlayer supports.
+*
+* JSX (React, Preact, Solid, Astro, Lit templates compiled through JSX) is
+* handled by the rule itself, since `JSXText`/`JSXAttribute` also need the
+* non-template code paths.
+*
+* @param report - Called for each literal text node found.
+*/
+const createTemplateVisitor = (report) => ({
+	VText: (node) => {
+		const astNode = node;
+		reportWithElement(report, astNode, astNode["value"], null);
+	},
+	VAttribute: (node) => {
+		const astNode = node;
+		if (astNode["directive"] === true) return;
+		const key = astNode["key"];
+		const value = astNode["value"];
+		const attributeName = key?.["name"];
+		const text = value?.["value"];
+		if (typeof attributeName !== "string" || typeof text !== "string") return;
+		reportWithElement(report, astNode, text, attributeName);
+	},
+	SvelteText: (node) => {
+		const astNode = node;
+		reportWithElement(report, astNode, astNode["value"], null);
+	},
+	SvelteAttribute: (node) => {
+		const astNode = node;
+		const attributeName = astNode["key"]?.["name"];
+		if (typeof attributeName !== "string") return;
+		const parts = astNode["value"];
+		if (parts?.length !== 1) return;
+		const part = parts[0];
+		if (part?.type !== "SvelteLiteral") return;
+		const text = part["value"];
+		if (typeof text !== "string") return;
+		reportWithElement(report, astNode, text, attributeName);
+	},
+	Text: (node) => {
+		const astNode = node;
+		const text = astNode["value"];
+		if (typeof text !== "string") return;
+		reportWithElement(report, astNode, text, null);
+	},
+	TextAttribute: (node) => {
+		const astNode = node;
+		const attributeName = astNode["name"];
+		const text = astNode["value"];
+		if (typeof attributeName !== "string" || typeof text !== "string") return;
+		reportWithElement(report, astNode, text, attributeName);
+	}
+});
+/**
+* Combine a script visitor and a template visitor into the single object the
+* active parser expects.
+*
+* Vue keeps its template in a side AST reachable only through
+* `defineTemplateBodyVisitor`; every other parser puts markup in the main AST,
+* where a merged visitor object is enough.
+*
+* @param parserServices - `context.sourceCode.parserServices`.
+* @param scriptVisitor - Handlers for ordinary script nodes.
+* @param templateVisitor - Handlers for markup nodes.
+*/
+const combineVisitors = (parserServices, scriptVisitor, templateVisitor) => {
+	const services = parserServices;
+	if (typeof services?.defineTemplateBodyVisitor === "function") return services.defineTemplateBodyVisitor(templateVisitor, scriptVisitor);
+	return {
+		...scriptVisitor,
+		...templateVisitor
+	};
+};
+
+//#endregion
+export { combineVisitors, createTemplateVisitor, resolveEnclosingElement };
+//# sourceMappingURL=templates.mjs.map

package/dist/esm/utils/templates.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.mjs","names":[],"sources":["../../../src/utils/templates.ts"],"sourcesContent":["import type { AstNode, AstNodeWithParent } from './ast';\n\n/**\n * Template-language support for text-coverage rules.\n *\n * Intlayer ships integrations for React, Vue, Svelte, Angular, Astro, Solid,\n * Preact and Lit, and each ecosystem's ESLint parser models markup differently:\n *\n * | Framework | Parser                          | Text node   | Attribute node  | Lives in        |\n * | --------- | ------------------------------- | ----------- | --------------- | --------------- |\n * | React/JSX | espree, typescript-eslint       | `JSXText`   | `JSXAttribute`  | main AST        |\n * | Astro     | astro-eslint-parser             | `JSXText`   | `JSXAttribute`  | main AST        |\n * | Svelte    | svelte-eslint-parser            | `SvelteText`| `SvelteAttribute`| main AST       |\n * | Angular   | @angular-eslint/template-parser | `Text`      | `TextAttribute` | main AST        |\n * | Vue       | vue-eslint-parser               | `VText`     | `VAttribute`    | `templateBody`  |\n *\n * Vue is the only one that hides its template behind\n * `parserServices.defineTemplateBodyVisitor`; every other parser exposes markup\n * in the AST a normal visitor already walks. Node type names do not collide\n * across parsers, so one merged visitor is safe to hand to any of them — a\n * Svelte file simply never emits a `VText`.\n */\n\n/** One piece of literal text found in markup. */\nexport type TemplateTextFinding = {\n  /** Node to report on. */\n  node: AstNode;\n  /** The literal text. */\n  text: string;\n  /** Attribute name when the text is an attribute value, else `null`. */\n  attributeName: string | null;\n  /** Tag name of the enclosing element, when resolvable. */\n  elementName: string | null;\n};\n\n/** Callback invoked for every literal text node the visitors find. */\nexport type TemplateTextReporter = (finding: TemplateTextFinding) => void;\n\n/** A visitor object as returned from a rule's `create`. */\nexport type TemplateVisitor = Record<string, (node: never) => void>;\n\n/**\n * Element node types whose text content is never user-facing copy, regardless\n * of the `ignoreElements` option (which matches on tag name, and these carry\n * none in some parsers).\n */\nconst NON_CONTENT_ELEMENT_TYPES = new Set([\n  'SvelteScriptElement',\n  'SvelteStyleElement',\n]);\n\n/** Element node types, per parser, that carry a tag name. */\nconst ELEMENT_TYPES = new Set([\n  'VElement',\n  'SvelteElement',\n  'Element',\n  'JSXElement',\n  'JSXOpeningElement',\n]);\n\n/**\n * Read the tag name off an element node, normalising the three shapes parsers\n * use: a plain string (Vue, Angular), a `SvelteName` node (Svelte), and a JSX\n * name node.\n *\n * @param element - An element node.\n */\nconst readElementName = (element: AstNode): string | null => {\n  const name = element['name'];\n\n  if (typeof name === 'string') return name;\n\n  if (name && typeof name === 'object') {\n    const nameNode = name as AstNode;\n\n    if (typeof nameNode['name'] === 'string') return nameNode['name'];\n  }\n\n  // JSXElement holds its name on the opening element.\n  const openingElement = element['openingElement'] as AstNode | undefined;\n\n  if (openingElement) return readElementName(openingElement);\n\n  return null;\n};\n\n/**\n * Walk up to the nearest enclosing element and return its tag name, or the\n * sentinel `false` when the text sits inside a `<script>`/`<style>` block that\n * should never be reported.\n *\n * @param node - The text or attribute node to start from.\n */\nexport const resolveEnclosingElement = (\n  node: AstNodeWithParent | undefined\n): string | null | false => {\n  let current = node?.parent;\n\n  while (current) {\n    if (NON_CONTENT_ELEMENT_TYPES.has(current.type)) return false;\n\n    if (ELEMENT_TYPES.has(current.type)) return readElementName(current);\n\n    current = current.parent;\n  }\n\n  return null;\n};\n\n/**\n * Report a finding unless it sits inside a non-content element.\n *\n * @param report - The rule's reporter.\n * @param node - Node to report on.\n * @param text - The literal text.\n * @param attributeName - Attribute name, or `null` for element text.\n */\nconst reportWithElement = (\n  report: TemplateTextReporter,\n  node: AstNodeWithParent,\n  text: string,\n  attributeName: string | null\n): void => {\n  const elementName = resolveEnclosingElement(node);\n\n  if (elementName === false) return;\n\n  report({ node, text, attributeName, elementName });\n};\n\n/**\n * Visitors covering every non-JSX template language Intlayer supports.\n *\n * JSX (React, Preact, Solid, Astro, Lit templates compiled through JSX) is\n * handled by the rule itself, since `JSXText`/`JSXAttribute` also need the\n * non-template code paths.\n *\n * @param report - Called for each literal text node found.\n */\nexport const createTemplateVisitor = (\n  report: TemplateTextReporter\n): TemplateVisitor => ({\n  // ── Vue ────────────────────────────────────────────────────────────────\n  VText: (node: never) => {\n    const astNode = node as AstNodeWithParent;\n\n    reportWithElement(report, astNode, astNode['value'] as string, null);\n  },\n\n  VAttribute: (node: never) => {\n    const astNode = node as AstNodeWithParent;\n\n    // Directives (`:title`, `v-bind:title`) hold an expression, not literal text.\n    if (astNode['directive'] === true) return;\n\n    const key = astNode['key'] as AstNode | undefined;\n    const value = astNode['value'] as AstNode | undefined;\n    const attributeName = key?.['name'];\n    const text = value?.['value'];\n\n    if (typeof attributeName !== 'string' || typeof text !== 'string') return;\n\n    reportWithElement(report, astNode, text, attributeName);\n  },\n\n  // ── Svelte ─────────────────────────────────────────────────────────────\n  SvelteText: (node: never) => {\n    const astNode = node as AstNodeWithParent;\n\n    reportWithElement(report, astNode, astNode['value'] as string, null);\n  },\n\n  SvelteAttribute: (node: never) => {\n    const astNode = node as AstNodeWithParent;\n    const key = astNode['key'] as AstNode | undefined;\n    const attributeName = key?.['name'];\n\n    if (typeof attributeName !== 'string') return;\n\n    // The value is a list of parts; a single literal part means a static value,\n    // anything else interpolates and is not raw copy.\n    const parts = astNode['value'] as AstNode[] | undefined;\n\n    if (parts?.length !== 1) return;\n\n    const part = parts[0];\n\n    if (part?.type !== 'SvelteLiteral') return;\n\n    const text = part['value'];\n\n    if (typeof text !== 'string') return;\n\n    reportWithElement(report, astNode, text, attributeName);\n  },\n\n  // ── Angular ────────────────────────────────────────────────────────────\n  Text: (node: never) => {\n    const astNode = node as AstNodeWithParent;\n    const text = astNode['value'];\n\n    if (typeof text !== 'string') return;\n\n    reportWithElement(report, astNode, text, null);\n  },\n\n  TextAttribute: (node: never) => {\n    const astNode = node as AstNodeWithParent;\n    const attributeName = astNode['name'];\n    const text = astNode['value'];\n\n    if (typeof attributeName !== 'string' || typeof text !== 'string') return;\n\n    reportWithElement(report, astNode, text, attributeName);\n  },\n});\n\n/** Parser services that expose a Vue template body. */\ntype VueParserServices = {\n  defineTemplateBodyVisitor?: (\n    templateVisitor: TemplateVisitor,\n    scriptVisitor: TemplateVisitor\n  ) => TemplateVisitor;\n};\n\n/**\n * Combine a script visitor and a template visitor into the single object the\n * active parser expects.\n *\n * Vue keeps its template in a side AST reachable only through\n * `defineTemplateBodyVisitor`; every other parser puts markup in the main AST,\n * where a merged visitor object is enough.\n *\n * @param parserServices - `context.sourceCode.parserServices`.\n * @param scriptVisitor - Handlers for ordinary script nodes.\n * @param templateVisitor - Handlers for markup nodes.\n */\nexport const combineVisitors = (\n  parserServices: unknown,\n  scriptVisitor: TemplateVisitor,\n  templateVisitor: TemplateVisitor\n): TemplateVisitor => {\n  const services = parserServices as VueParserServices | undefined;\n\n  if (typeof services?.defineTemplateBodyVisitor === 'function') {\n    return services.defineTemplateBodyVisitor(templateVisitor, scriptVisitor);\n  }\n\n  return { ...scriptVisitor, ...templateVisitor };\n};\n"],"mappings":";;;;;;AA8CA,MAAM,4CAA4B,IAAI,IAAI,CACxC,uBACA,oBACF,CAAC;;AAGD,MAAM,gCAAgB,IAAI,IAAI;CAC5B;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;;;AASD,MAAM,mBAAmB,YAAoC;CAC3D,MAAM,OAAO,QAAQ;CAErB,IAAI,OAAO,SAAS,UAAU,OAAO;CAErC,IAAI,QAAQ,OAAO,SAAS,UAAU;EACpC,MAAM,WAAW;EAEjB,IAAI,OAAO,SAAS,YAAY,UAAU,OAAO,SAAS;CAC5D;CAGA,MAAM,iBAAiB,QAAQ;CAE/B,IAAI,gBAAgB,OAAO,gBAAgB,cAAc;CAEzD,OAAO;AACT;;;;;;;;AASA,MAAa,2BACX,SAC0B;CAC1B,IAAI,UAAU,MAAM;CAEpB,OAAO,SAAS;EACd,IAAI,0BAA0B,IAAI,QAAQ,IAAI,GAAG,OAAO;EAExD,IAAI,cAAc,IAAI,QAAQ,IAAI,GAAG,OAAO,gBAAgB,OAAO;EAEnE,UAAU,QAAQ;CACpB;CAEA,OAAO;AACT;;;;;;;;;AAUA,MAAM,qBACJ,QACA,MACA,MACA,kBACS;CACT,MAAM,cAAc,wBAAwB,IAAI;CAEhD,IAAI,gBAAgB,OAAO;CAE3B,OAAO;EAAE;EAAM;EAAM;EAAe;CAAY,CAAC;AACnD;;;;;;;;;;AAWA,MAAa,yBACX,YACqB;CAErB,QAAQ,SAAgB;EACtB,MAAM,UAAU;EAEhB,kBAAkB,QAAQ,SAAS,QAAQ,UAAoB,IAAI;CACrE;CAEA,aAAa,SAAgB;EAC3B,MAAM,UAAU;EAGhB,IAAI,QAAQ,iBAAiB,MAAM;EAEnC,MAAM,MAAM,QAAQ;EACpB,MAAM,QAAQ,QAAQ;EACtB,MAAM,gBAAgB,MAAM;EAC5B,MAAM,OAAO,QAAQ;EAErB,IAAI,OAAO,kBAAkB,YAAY,OAAO,SAAS,UAAU;EAEnE,kBAAkB,QAAQ,SAAS,MAAM,aAAa;CACxD;CAGA,aAAa,SAAgB;EAC3B,MAAM,UAAU;EAEhB,kBAAkB,QAAQ,SAAS,QAAQ,UAAoB,IAAI;CACrE;CAEA,kBAAkB,SAAgB;EAChC,MAAM,UAAU;EAEhB,MAAM,gBADM,QAAQ,MACK,GAAG;EAE5B,IAAI,OAAO,kBAAkB,UAAU;EAIvC,MAAM,QAAQ,QAAQ;EAEtB,IAAI,OAAO,WAAW,GAAG;EAEzB,MAAM,OAAO,MAAM;EAEnB,IAAI,MAAM,SAAS,iBAAiB;EAEpC,MAAM,OAAO,KAAK;EAElB,IAAI,OAAO,SAAS,UAAU;EAE9B,kBAAkB,QAAQ,SAAS,MAAM,aAAa;CACxD;CAGA,OAAO,SAAgB;EACrB,MAAM,UAAU;EAChB,MAAM,OAAO,QAAQ;EAErB,IAAI,OAAO,SAAS,UAAU;EAE9B,kBAAkB,QAAQ,SAAS,MAAM,IAAI;CAC/C;CAEA,gBAAgB,SAAgB;EAC9B,MAAM,UAAU;EAChB,MAAM,gBAAgB,QAAQ;EAC9B,MAAM,OAAO,QAAQ;EAErB,IAAI,OAAO,kBAAkB,YAAY,OAAO,SAAS,UAAU;EAEnE,kBAAkB,QAAQ,SAAS,MAAM,aAAa;CACxD;AACF;;;;;;;;;;;;;AAsBA,MAAa,mBACX,gBACA,eACA,oBACoB;CACpB,MAAM,WAAW;CAEjB,IAAI,OAAO,UAAU,8BAA8B,YACjD,OAAO,SAAS,0BAA0B,iBAAiB,aAAa;CAG1E,OAAO;EAAE,GAAG;EAAe,GAAG;CAAgB;AAChD"}

package/dist/types/index.d.ts

@@ -0,0 +1,67 @@
+import { IntlayerRule } from "./utils/createRule.js";
+import { NoRawTextOptions } from "./rules/noRawText.js";
+import "./index.js";
+import { ESLint, Linter } from "eslint";
+//#region src/index.d.ts
+/**
+ * Every rule this plugin ships, keyed by the name used in configuration.
+ *
+ * The rules split into two families:
+ * - **Coverage** (`no-raw-text`) — user-facing copy that never reached a
+ *   dictionary. Nothing else in the toolchain reports it.
+ * - **Compiler contract** (`static-dictionary-key`, `no-dynamic-field-access`)
+ *   — call shapes that type-check and run, but that the Babel/SWC passes cannot
+ *   analyse, so they silently lose the optimize pass or read a purged field.
+ *
+ * Deliberately absent: unknown dictionary keys, unknown field paths and missing
+ * required locales. The generated `__DictionaryRegistry` module augmentation
+ * already makes all three compile errors, and `@intlayer/lsp` reports the first
+ * as an editor diagnostic — a third report would only add noise.
+ */
+declare const rules: {
+  'no-raw-text': IntlayerRule<[NoRawTextOptions?], "rawText" | "rawAttribute" | "rawStringLiteral">;
+  'static-dictionary-key': IntlayerRule<[], "dynamicKey" | "dynamicTemplateKey" | "dynamicJsxKey">;
+  'no-dynamic-field-access': IntlayerRule<[], "dynamicField" | "dynamicMessageId">;
+  'enforce-adapter-import': IntlayerRule<[], "useAdapterImport">;
+};
+/** Rule names this plugin exposes. */
+type IntlayerRuleName = keyof typeof rules;
+declare const meta: {
+  name: string;
+  version: string;
+};
+/** The flat configs this plugin ships. */
+type IntlayerConfigName = 'recommended' | 'strict' | 'contract-only';
+/**
+ * Flat configs, for `eslint.config.js`:
+ *
+ * ```js
+ * import intlayer from 'eslint-plugin-intlayer';
+ *
+ * export default [intlayer.configs.recommended];
+ * ```
+ *
+ * - `recommended` — the compiler-contract rules as errors, plus `no-raw-text`
+ *   as a warning so an existing codebase is not blocked on day one.
+ * - `strict` — everything as an error, including string literals outside JSX.
+ * - `contract-only` — just the rules that protect the build output; use this
+ *   when translation coverage is tracked by `intlayer test` instead.
+ *
+ * `enforce-adapter-import` is opt-in: importing from the original package is
+ * perfectly valid once the bundler alias is set up, so a project that has done
+ * that should not be nagged. Only `strict` turns it on.
+ */
+declare const configs: Record<IntlayerConfigName, Linter.Config>;
+/** The plugin object, as consumed by `eslint.config.js`. */
+type IntlayerPlugin = ESLint.Plugin & {
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: typeof rules;
+  configs: Record<IntlayerConfigName, Linter.Config>;
+};
+declare const intlayerPlugin: IntlayerPlugin;
+//#endregion
+export { IntlayerConfigName, IntlayerPlugin, IntlayerRuleName, type NoRawTextOptions, configs, intlayerPlugin as default, meta, rules };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAwBa;+BAAA;;;;;;KAQD,gCAAgC;cAEtC;EAAQ;EAAc;;;KAQhB;;;;;;;;;;;;;;;;;;;;cAyCC,SAAS,OAAO,oBAAoB,OAAO;;KAiC5C,iBAAiB,OAAO;EAClC;IAAQ;IAAc;;EACtB,cAAc;EACd,SAAS,OAAO,oBAAoB,OAAO;;cAGvC,gBAAgB"}

package/dist/types/rules/enforceAdapterImport.d.ts

@@ -0,0 +1,6 @@
+import { IntlayerRule } from "../utils/createRule.js";
+//#region src/rules/enforceAdapterImport.d.ts
+declare const enforceAdapterImport: IntlayerRule<[], "useAdapterImport">;
+//#endregion
+export { enforceAdapterImport };
+//# sourceMappingURL=enforceAdapterImport.d.ts.map

package/dist/types/rules/enforceAdapterImport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforceAdapterImport.d.ts","names":[],"sources":["../../../src/rules/enforceAdapterImport.ts"],"mappings":";;cAuDa,sBAAA"}

package/dist/types/rules/noDynamicFieldAccess.d.ts

@@ -0,0 +1,7 @@
+import { IntlayerRule } from "../utils/createRule.js";
+//#region src/rules/noDynamicFieldAccess.d.ts
+type MessageIds = 'dynamicField' | 'dynamicMessageId';
+declare const noDynamicFieldAccess: IntlayerRule<[], MessageIds>;
+//#endregion
+export { noDynamicFieldAccess };
+//# sourceMappingURL=noDynamicFieldAccess.d.ts.map

package/dist/types/rules/noDynamicFieldAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noDynamicFieldAccess.d.ts","names":[],"sources":["../../../src/rules/noDynamicFieldAccess.ts"],"mappings":";;KAcK;cAiFQ,sBAAoB,iBAAA"}

package/dist/types/rules/noRawText.d.ts

@@ -0,0 +1,25 @@
+import { IntlayerRule } from "../utils/createRule.js";
+//#region src/rules/noRawText.d.ts
+type NoRawTextOptions = {
+  /**
+   * JSX attributes whose string value is user-facing copy.
+   * Defaults to the compiler's own list, so the linter flags exactly what
+   * `intlayer extract` would rewrite.
+   */
+  attributes?: string[];
+  /** JSX elements whose children are never translatable. */
+  ignoreElements?: string[];
+  /** Regular-expression sources for text that should never be reported. */
+  ignorePatterns?: string[];
+  /**
+   * Also report string literals outside JSX (function arguments, object values,
+   * …). Off by default: outside JSX the false-positive rate is much higher, and
+   * the compiler's own extractor is the better first pass.
+   */
+  includeStringLiterals?: boolean;
+};
+type MessageIds = 'rawText' | 'rawAttribute' | 'rawStringLiteral';
+declare const noRawText: IntlayerRule<[NoRawTextOptions?], MessageIds>;
+//#endregion
+export { NoRawTextOptions, noRawText };
+//# sourceMappingURL=noRawText.d.ts.map

package/dist/types/rules/noRawText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noRawText.d.ts","names":[],"sources":["../../../src/rules/noRawText.ts"],"mappings":";;KAwBY;;;;;;EAMV;;EAEA;;EAEA;;;;;;EAMA;;KAGG;cAsEQ,WAAS,cAAA,oBAAA"}

package/dist/types/rules/staticDictionaryKey.d.ts

@@ -0,0 +1,7 @@
+import { IntlayerRule } from "../utils/createRule.js";
+//#region src/rules/staticDictionaryKey.d.ts
+type MessageIds = 'dynamicKey' | 'dynamicTemplateKey' | 'dynamicJsxKey';
+declare const staticDictionaryKey: IntlayerRule<[], MessageIds>;
+//#endregion
+export { staticDictionaryKey };
+//# sourceMappingURL=staticDictionaryKey.d.ts.map

package/dist/types/rules/staticDictionaryKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staticDictionaryKey.d.ts","names":[],"sources":["../../../src/rules/staticDictionaryKey.ts"],"mappings":";;KAkBK;cAsBQ,qBAAmB,iBAAA"}

package/dist/types/utils/ast.d.ts

@@ -0,0 +1,105 @@
+import { Node } from "/Users/aymericpineau/Documents/intlayer_/node_modules/.bun/@types+estree@1.0.9/node_modules/@types/estree/index.js";
+//#region src/utils/ast.d.ts
+/**
+ * Minimal structural models for the nodes this plugin inspects that are not
+ * part of the ESTree spec — JSX (all parsers) and the TypeScript-only wrapper
+ * expressions emitted by `@typescript-eslint/parser`.
+ *
+ * They are declared here rather than imported from `@typescript-eslint/types`
+ * so the plugin stays parser-agnostic: the same rules run under `espree`,
+ * `@typescript-eslint/parser`, `vue-eslint-parser` and oxlint's JS plugin
+ * bridge, none of which agree on a type package.
+ */
+/** Any AST node, whatever the parser. Narrowed through the guards below. */
+type AstNode = {
+  type: string;
+  [key: string]: unknown;
+};
+/** An AST node as ESLint hands it to a visitor — always linked to its parent. */
+type AstNodeWithParent = AstNode & {
+  parent?: AstNodeWithParent;
+};
+/** `<div>Some text</div>` — the raw text between two JSX tags. */
+type JsxTextNode = AstNode & {
+  type: 'JSXText';
+  value: string;
+};
+/** `title="Some text"` on a JSX element. */
+type JsxAttributeNode = AstNode & {
+  type: 'JSXAttribute';
+  name: AstNode;
+  value: AstNode | null;
+};
+/** The opening tag of a JSX element, holding its name and attributes. */
+type JsxOpeningElementNode = AstNode & {
+  type: 'JSXOpeningElement';
+  name: AstNode;
+  attributes: AstNode[];
+};
+/**
+ * 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.
+ */
+declare const unwrapExpression: <T extends AstNode>(node: T | null | undefined) => T | 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.
+ */
+declare const getStaticStringValue: (node: AstNode | null | undefined) => string | 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.
+ */
+declare const getCalleeName: (callee: AstNode | null | undefined) => {
+  name: string;
+  isMethod: boolean;
+} | 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.
+ */
+declare const getObjectPropertyValueNode: (node: AstNode | null | undefined, propertyName: string) => AstNode | 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`.
+ */
+declare const getJsxAttributeName: (attribute: AstNode | null | undefined) => string | 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.
+ */
+declare const getJsxAttributeValueNode: (attribute: AstNode | null | undefined) => AstNode | null;
+/**
+ * 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.
+ */
+declare const getJsxElementName: (openingElement: AstNode | null | undefined) => string | null;
+/** Narrow an ESLint visitor node to the loose {@link AstNode} shape. */
+declare const toAstNode: (node: Node | AstNode) => AstNodeWithParent;
+//#endregion
+export { AstNode, AstNodeWithParent, JsxAttributeNode, JsxOpeningElementNode, JsxTextNode, getCalleeName, getJsxAttributeName, getJsxAttributeValueNode, getJsxElementName, getObjectPropertyValueNode, getStaticStringValue, toAstNode, unwrapExpression };
+//# sourceMappingURL=ast.d.ts.map

package/dist/types/utils/ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.ts","names":[],"sources":["../../../src/utils/ast.ts"],"mappings":";;;;;;;;;;;;;KAcY;EACV;GACC;;;KAIS,oBAAoB;EAC9B,SAAS;;;KAIC,cAAc;EACxB;EACA;;;KAIU,mBAAmB;EAC7B;EACA,MAAM;EACN,OAAO;;;KAIG,wBAAwB;EAClC;EACA,MAAM;EACN,YAAY;;;;;;;;cAsBD,mBAAoB,UAAU,SACzC,MAAM,yBACL;;;;;;;;;;;cAwBU,uBACX,MAAM;;;;;;;;;cAoCK,gBACX,QAAQ;EACL;EAAc;;;;;;;;;;;;cA8BN,6BACX,MAAM,4BACN,yBACC;;;;;;;cAkCU,sBACX,WAAW;;;;;;;cAeA,2BACX,WAAW,+BACV;;;;;;;cAgBU,oBACX,gBAAgB;;cAqBL,YAAa,MAAM,OAAa,YAAU"}

package/dist/types/utils/callerMatcher.d.ts

@@ -0,0 +1,58 @@
+import { AstNode } from "./ast.js";
+import { CallerDescriptor, CallerValueSource } from "@intlayer/config/callers";
+//#region src/utils/callerMatcher.d.ts
+/**
+ * Where the dictionary key of a matched call site lives, and whether it is
+ * statically knowable.
+ */
+type NamespaceResolution = {
+  /** The node holding the key, or `null` when the call omits it entirely. */
+  node: AstNode | null;
+  /** The compile-time key, or `null` when it can only be known at runtime. */
+  value: string | null;
+  /** The registry entry that described where to look. */
+  source: CallerValueSource;
+};
+/** A call expression recognised as an Intlayer content read. */
+type CallerMatch = {
+  descriptor: CallerDescriptor;
+  /** Resolved namespace, or `null` for callers that take no namespace here. */
+  namespace: NamespaceResolution | null;
+};
+/**
+ * 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.
+ */
+declare const collectImportSources: (program: AstNode) => Set<string>;
+/**
+ * The registry entries that may match inside a file, given what it imports.
+ *
+ * @param importSources - Specifiers collected by {@link collectImportSources}.
+ */
+declare const getActiveDescriptors: (importSources: ReadonlySet<string>) => CallerDescriptor[];
+/**
+ * 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}.
+ */
+declare const matchCaller: (callNode: AstNode, activeDescriptors: CallerDescriptor[]) => CallerMatch | 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}.
+ */
+declare const matchJsxCaller: (elementName: string | null, activeDescriptors: CallerDescriptor[]) => CallerDescriptor | null;
+//#endregion
+export { CallerMatch, NamespaceResolution, collectImportSources, getActiveDescriptors, matchCaller, matchJsxCaller };
+//# sourceMappingURL=callerMatcher.d.ts.map

package/dist/types/utils/callerMatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callerMatcher.d.ts","names":[],"sources":["../../../src/utils/callerMatcher.ts"],"mappings":";;;;;;;KAkBY;;EAEV,MAAM;;EAEN;;EAEA,QAAQ;;;KAIE;EACV,YAAY;;EAEZ,WAAW;;;;;;;;;;cAWA,uBAAwB,SAAS,YAAU;;;;;;cA2B3C,uBACX,eAAe,wBACd;;;;;;;;;;;cAkFU,cACX,UAAU,SACV,mBAAmB,uBAClB;;;;;;;;cAuDU,iBACX,4BACA,mBAAmB,uBAClB"}

package/dist/types/utils/createRule.d.ts

@@ -0,0 +1,23 @@
+import { JSRuleDefinition } from "eslint";
+//#region src/utils/createRule.d.ts
+/**
+ * A rule of this plugin, with its option tuple and message ids pinned so
+ * `context.options` and `context.report({ messageId })` are checked rather than
+ * inferred as `any[]` / `string`.
+ */
+type IntlayerRule<Options extends readonly unknown[] = [], MessageIds extends string = string> = JSRuleDefinition<{
+  RuleOptions: [...Options];
+  MessageIds: MessageIds;
+}>;
+/**
+ * Build a rule with the plugin's shared metadata conventions applied: a
+ * documentation anchor derived from the rule name, and `meta.schema` defaulting
+ * to "no options" so an unknown option is rejected instead of ignored.
+ *
+ * @param name - The rule name as it appears in config, e.g. `'no-raw-text'`.
+ * @param rule - The rule definition.
+ */
+declare const createRule: <Options extends readonly unknown[] = [], MessageIds extends string = string>(name: string, rule: IntlayerRule<Options, MessageIds>) => IntlayerRule<Options, MessageIds>;
+//#endregion
+export { IntlayerRule, createRule };
+//# sourceMappingURL=createRule.d.ts.map

package/dist/types/utils/createRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRule.d.ts","names":[],"sources":["../../../src/utils/createRule.ts"],"mappings":";;;;;;;KAUY,aACV,yCACA,sCACE;EACF,iBAAiB;EACjB,YAAY;;;;;;;;;;cAWD,aACX,yCACA,oCAEA,cACA,MAAM,aAAa,SAAS,gBAC3B,aAAa,SAAS"}

package/dist/types/utils/templates.d.ts

@@ -0,0 +1,71 @@
+import { AstNode, AstNodeWithParent } from "./ast.js";
+//#region src/utils/templates.d.ts
+/**
+ * Template-language support for text-coverage rules.
+ *
+ * Intlayer ships integrations for React, Vue, Svelte, Angular, Astro, Solid,
+ * Preact and Lit, and each ecosystem's ESLint parser models markup differently:
+ *
+ * | Framework | Parser                          | Text node   | Attribute node  | Lives in        |
+ * | --------- | ------------------------------- | ----------- | --------------- | --------------- |
+ * | React/JSX | espree, typescript-eslint       | `JSXText`   | `JSXAttribute`  | main AST        |
+ * | Astro     | astro-eslint-parser             | `JSXText`   | `JSXAttribute`  | main AST        |
+ * | Svelte    | svelte-eslint-parser            | `SvelteText`| `SvelteAttribute`| main AST       |
+ * | Angular   | @angular-eslint/template-parser | `Text`      | `TextAttribute` | main AST        |
+ * | Vue       | vue-eslint-parser               | `VText`     | `VAttribute`    | `templateBody`  |
+ *
+ * Vue is the only one that hides its template behind
+ * `parserServices.defineTemplateBodyVisitor`; every other parser exposes markup
+ * in the AST a normal visitor already walks. Node type names do not collide
+ * across parsers, so one merged visitor is safe to hand to any of them — a
+ * Svelte file simply never emits a `VText`.
+ */
+/** One piece of literal text found in markup. */
+type TemplateTextFinding = {
+  /** Node to report on. */
+  node: AstNode;
+  /** The literal text. */
+  text: string;
+  /** Attribute name when the text is an attribute value, else `null`. */
+  attributeName: string | null;
+  /** Tag name of the enclosing element, when resolvable. */
+  elementName: string | null;
+};
+/** Callback invoked for every literal text node the visitors find. */
+type TemplateTextReporter = (finding: TemplateTextFinding) => void;
+/** A visitor object as returned from a rule's `create`. */
+type TemplateVisitor = Record<string, (node: never) => void>;
+/**
+ * Walk up to the nearest enclosing element and return its tag name, or the
+ * sentinel `false` when the text sits inside a `<script>`/`<style>` block that
+ * should never be reported.
+ *
+ * @param node - The text or attribute node to start from.
+ */
+declare const resolveEnclosingElement: (node: AstNodeWithParent | undefined) => string | null | false;
+/**
+ * Visitors covering every non-JSX template language Intlayer supports.
+ *
+ * JSX (React, Preact, Solid, Astro, Lit templates compiled through JSX) is
+ * handled by the rule itself, since `JSXText`/`JSXAttribute` also need the
+ * non-template code paths.
+ *
+ * @param report - Called for each literal text node found.
+ */
+declare const createTemplateVisitor: (report: TemplateTextReporter) => TemplateVisitor;
+/**
+ * Combine a script visitor and a template visitor into the single object the
+ * active parser expects.
+ *
+ * Vue keeps its template in a side AST reachable only through
+ * `defineTemplateBodyVisitor`; every other parser puts markup in the main AST,
+ * where a merged visitor object is enough.
+ *
+ * @param parserServices - `context.sourceCode.parserServices`.
+ * @param scriptVisitor - Handlers for ordinary script nodes.
+ * @param templateVisitor - Handlers for markup nodes.
+ */
+declare const combineVisitors: (parserServices: unknown, scriptVisitor: TemplateVisitor, templateVisitor: TemplateVisitor) => TemplateVisitor;
+//#endregion
+export { TemplateTextFinding, TemplateTextReporter, TemplateVisitor, combineVisitors, createTemplateVisitor, resolveEnclosingElement };
+//# sourceMappingURL=templates.d.ts.map

package/dist/types/utils/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../src/utils/templates.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;KAwBY;;EAEV,MAAM;;EAEN;;EAEA;;EAEA;;;KAIU,wBAAwB,SAAS;;KAGjC,kBAAkB,gBAAgB;;;;;;;;cAsDjC,0BACX,MAAM;;;;;;;;;;cA6CK,wBACX,QAAQ,yBACP;;;;;;;;;;;;;cAgGU,kBACX,yBACA,eAAe,iBACf,iBAAiB,oBAChB"}