eslint-plugin-intlayer 9.3.1

package/README.md

@@ -0,0 +1,310 @@
+<!-- markdownlint-disable MD024 -->
+
+# eslint-plugin-intlayer
+
+ESLint rules for [Intlayer](https://intlayer.org) projects.
+
+The plugin is deliberately small. Intlayer already reports most i18n mistakes
+through other layers, and a rule that duplicates one of them only produces the
+same squiggle three times:
+
+| Mistake                           | Already reported by                                              |
+| --------------------------------- | ---------------------------------------------------------------- |
+| Unknown dictionary key            | TypeScript (`__DictionaryRegistry`) **and** `@intlayer/lsp`        |
+| Unknown field path                | TypeScript (`__DictionaryRegistry`)                                |
+| Missing required locale           | TypeScript (`StrictModeLocaleMap`) **and** `intlayer test`         |
+| Unused dictionary                 | `intlayer test`, and the VS Code extension's inline decoration     |
+
+What is left are the two things neither the type system nor the language server
+can see, and that is exactly what this plugin covers:
+
+1. **Coverage** — user-facing copy that never made it into a dictionary.
+   Types cannot know a string is meant for a human.
+2. **The compiler contract** — call shapes that type-check and run, but that
+   the Babel/SWC passes cannot analyse. These silently lose the optimize pass,
+   or read a field the purge pass has stripped.
+
+## Installation
+
+```bash
+npm install --save-dev eslint-plugin-intlayer
+```
+
+Requires ESLint 9 or later (flat config).
+
+## Usage
+
+```js
+// eslint.config.js
+import intlayer from 'eslint-plugin-intlayer';
+
+export default [intlayer.configs.recommended];
+```
+
+Or configure rules individually:
+
+```js
+import intlayer from 'eslint-plugin-intlayer';
+
+export default [
+  {
+    plugins: { intlayer },
+    rules: {
+      'intlayer/no-raw-text': ['warn', { includeStringLiterals: false }],
+      'intlayer/static-dictionary-key': 'error',
+      'intlayer/no-dynamic-field-access': 'error',
+      'intlayer/enforce-adapter-import': 'warn',
+    },
+  },
+];
+```
+
+### Configs
+
+| Config          | `no-raw-text` | `static-dictionary-key` | `no-dynamic-field-access` | `enforce-adapter-import` |
+| --------------- | ------------- | ----------------------- | ------------------------- | ------------------------ |
+| `recommended`   | warn          | error                   | error                     | off                      |
+| `strict`        | error (+ non-JSX literals) | error      | error                     | error                    |
+| `contract-only` | off           | error                   | error                     | off                      |
+
+`recommended` keeps `no-raw-text` at `warn` on purpose: pointing it at an
+existing codebase surfaces every untranslated string at once, which should not
+block a build on day one.
+
+Use `contract-only` when translation coverage is already tracked by
+`intlayer test` in CI and you only want the rules that protect the build output.
+
+### Frameworks
+
+Every rule works across all of Intlayer's integrations. The rules are
+parser-agnostic; what differs is the parser ESLint needs to read each file type,
+which you configure once:
+
+| Framework                     | Files                    | Parser                            | Text coverage | Contract rules |
+| ----------------------------- | ------------------------ | --------------------------------- | ------------- | -------------- |
+| React, Preact, Solid, Lit     | `.jsx` `.tsx`            | `typescript-eslint`               | ✅            | ✅             |
+| Next.js                       | `.jsx` `.tsx`            | `typescript-eslint`               | ✅            | ✅             |
+| Vue, Nuxt                     | `.vue`                   | `vue-eslint-parser`               | ✅ template   | ✅ `<script>`  |
+| Svelte, SvelteKit             | `.svelte`                | `svelte-eslint-parser`            | ✅ markup     | ✅ `<script>`  |
+| Angular                       | `.ts`                    | `typescript-eslint`               | ✅            | ✅             |
+| Angular templates             | `.component.html`        | `@angular-eslint/template-parser` | ✅            | n/a (no JS)    |
+| Astro                         | `.astro`                 | `astro-eslint-parser`             | ✅            | ✅ frontmatter |
+
+`no-raw-text` understands each ecosystem's markup natively — Vue's `VText` /
+`VAttribute` (reached through `defineTemplateBodyVisitor`), Svelte's
+`SvelteText` / `SvelteAttribute`, Angular's `Text` / `TextAttribute`, and JSX's
+`JSXText` / `JSXAttribute` — so a `<code>` block is skipped and a `placeholder`
+is reported the same way in all of them. Vue directives (`:title="expr"`) and
+Svelte interpolations are expressions, not copy, and are never reported.
+
+The compiler-contract rules read the `<script>` block, which every one of these
+parsers exposes as an ordinary ESTree program.
+
+```js
+// eslint.config.js
+import intlayer from 'eslint-plugin-intlayer';
+import tseslint from 'typescript-eslint';
+import vueParser from 'vue-eslint-parser';
+import svelteParser from 'svelte-eslint-parser';
+import angularTemplateParser from '@angular-eslint/template-parser';
+
+export default [
+  intlayer.configs.recommended,
+
+  // React / Angular components / plain TS
+  {
+    files: ['**/*.{ts,tsx,jsx}'],
+    languageOptions: { parser: tseslint.parser },
+  },
+
+  // Vue — the TS parser handles <script lang="ts">
+  {
+    files: ['**/*.vue'],
+    languageOptions: {
+      parser: vueParser,
+      parserOptions: { parser: tseslint.parser },
+    },
+  },
+
+  // Svelte
+  {
+    files: ['**/*.svelte'],
+    languageOptions: {
+      parser: svelteParser,
+      parserOptions: { parser: tseslint.parser },
+    },
+  },
+
+  // Angular templates
+  {
+    files: ['**/*.component.html'],
+    languageOptions: { parser: angularTemplateParser },
+  },
+];
+```
+
+Install only the parsers your project needs — they are peer-optional, and the
+plugin never imports them.
+
+**Known limitation.** In Vue and Angular templates, an expression such as
+`{{ content[key] }}` is not checked by `no-dynamic-field-access`: the binding is
+declared in the script block and used in a separate template AST, so the two
+cannot be linked without type information. Dynamic reads written in the script
+block are caught normally. `static-dictionary-key` is unaffected, because a
+dictionary key is always passed in the script.
+
+### With oxlint
+
+Every rule targets the ESLint v9 API and none needs type information, so they
+load in oxlint as-is:
+
+```json
+{
+  "jsPlugins": ["eslint-plugin-intlayer"],
+  "rules": {
+    "intlayer/static-dictionary-key": "error",
+    "intlayer/no-dynamic-field-access": "error"
+  }
+}
+```
+
+Two caveats: oxlint's JS plugin support is still alpha, and it does not support
+custom parsers — so `.vue`, `.svelte`, `.astro` and Angular templates are not
+linted there. Use oxlint for the JS/TS/JSX files and keep ESLint for the rest.
+
+## Rules
+
+### no-raw-text
+
+Reports user-facing strings that are not declared in a dictionary.
+
+The predicate is `shouldExtract` from `@intlayer/config/extract` — the very same
+heuristic `intlayer extract` uses — so what this rule reports is exactly what the
+extractor would rewrite. Brand names, CSS class strings, technical identifiers
+and code-shaped strings are filtered out.
+
+```jsx
+// ✗
+<h1>Welcome to our documentation</h1>
+<input placeholder="Enter your email address" />
+
+// ✓
+const { title } = useIntlayer('home');
+<h1>{title}</h1>
+```
+
+Content declaration files (`*.content.ts`, and every extension in the project's
+`content.fileExtensions`) are skipped — the copy lives there by definition.
+
+The fix is usually not manual: run `npx intlayer extract` on the file.
+
+**Options**
+
+```ts
+{
+  /** JSX attributes whose value is copy. Default: title, placeholder, alt, aria-label, label. */
+  attributes?: string[];
+  /** Elements whose children are never copy. Default: code, pre, script, style. */
+  ignoreElements?: string[];
+  /** Regular-expression sources for text to never report. */
+  ignorePatterns?: string[];
+  /** Also report string literals outside JSX. Default: false. */
+  includeStringLiterals?: boolean;
+}
+```
+
+### static-dictionary-key
+
+Requires the dictionary key of a content read to be a static string literal.
+
+`babel-plugin-intlayer-optimize` (and its SWC equivalent) rewrites a call only
+when it can read the key off the argument node. A computed key is left
+untouched — no error, no warning, just a build that quietly stops tree-shaking
+and bundles every dictionary.
+
+```ts
+// ✗ — invisible to the compiler
+useIntlayer(dictionaryKey);
+useIntlayer(`home-${suffix}`);
+getTranslations({ namespace: page });
+
+// ✗ — a const still is not a literal at the call site
+const key = 'home';
+useIntlayer(key);
+
+// ✓
+useIntlayer('home');
+useIntlayer('home' as const);
+getTranslations({ namespace: 'home' });
+```
+
+The rule covers every caller in the shared registry — `useIntlayer`,
+`getIntlayer`, and each compat adapter (`useTranslation`, `useTranslations`,
+`formatMessage`, `<FormattedMessage id>`, `<Trans i18nKey>`, …) — because a
+dynamic key breaks usage analysis for all of them.
+
+Callers that legitimately take no namespace (next-intl's root-scope
+`useTranslations()`) are not reported.
+
+### no-dynamic-field-access
+
+Requires the field read from a dictionary to be statically known.
+
+The purge pass strips fields it cannot see used. A computed access is a field it
+cannot see, so the read may return `undefined` at runtime — a real bug, not just
+a missed optimization.
+
+```ts
+// ✗
+const content = useIntlayer('home');
+content[fieldName];
+
+const t = useTranslations('home');
+t(messageKey);
+
+// ✓
+content.title;
+content['title'];
+content.items[0];
+t('hero.title');
+```
+
+Bindings are resolved through ESLint's scope analysis, so two components in the
+same file that bind the same variable name to different dictionaries are tracked
+independently.
+
+### enforce-adapter-import
+
+Prefers the `@intlayer/*` compat adapter over the original package specifier.
+
+The original specifier only resolves to Intlayer when the bundler alias is
+configured; the adapter always does. Autofixable.
+
+```ts
+// ✗
+import { useTranslation } from 'react-i18next';
+import { getTranslations } from 'next-intl/server';
+
+// ✓
+import { useTranslation } from '@intlayer/react-i18next';
+import { getTranslations } from '@intlayer/next-intl/server';
+```
+
+The mapping is derived from `@intlayer/config/callers`, so a library added to
+the shared registry is covered here automatically.
+
+## How it stays in sync
+
+The plugin reads the same two shared sources as the compiler and the language
+server, rather than re-encoding what an Intlayer call looks like:
+
+- `@intlayer/config/callers` — the caller registry consumed by `@intlayer/babel`,
+  `@intlayer/swc`, `@intlayer/lsp` and every compat bundler plugin.
+- `@intlayer/config/extract` — the `shouldExtract` heuristic and the extractable
+  attribute list used by `intlayer extract`.
+
+Adding a compat library to the registry therefore extends the rules for free.
+
+## License
+
+Apache-2.0

package/dist/cjs/index.cjs

@@ -0,0 +1,105 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_rules_enforceAdapterImport = require('./rules/enforceAdapterImport.cjs');
+const require_rules_noDynamicFieldAccess = require('./rules/noDynamicFieldAccess.cjs');
+const require_rules_noRawText = require('./rules/noRawText.cjs');
+const require_rules_staticDictionaryKey = require('./rules/staticDictionaryKey.cjs');
+let _intlayer_config_lint = require("@intlayer/config/lint");
+
+//#region src/index.ts
+const PLUGIN_NAME = "intlayer";
+/**
+* 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.
+*/
+const rules = {
+	"no-raw-text": require_rules_noRawText.noRawText,
+	"static-dictionary-key": require_rules_staticDictionaryKey.staticDictionaryKey,
+	"no-dynamic-field-access": require_rules_noDynamicFieldAccess.noDynamicFieldAccess,
+	"enforce-adapter-import": require_rules_enforceAdapterImport.enforceAdapterImport
+};
+const meta = {
+	name: "eslint-plugin-intlayer",
+	version: "9.3.1"
+};
+const plugin = {
+	meta,
+	rules
+};
+/**
+* Build a flat config enabling the given rules under the `intlayer/` prefix.
+*
+* @param name - Config name, surfaced by `--print-config` and the config inspector.
+* @param ruleSeverities - Severity per rule name.
+*/
+const createConfig = (name, ruleSeverities) => ({
+	name: `intlayer/${name}`,
+	plugins: { [PLUGIN_NAME]: plugin },
+	rules: Object.fromEntries(Object.entries(ruleSeverities).map(([ruleName, severity]) => [`${PLUGIN_NAME}/${ruleName}`, severity]))
+});
+/**
+* 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.
+*/
+const configs = {
+	recommended: {
+		name: `${PLUGIN_NAME}/recommended`,
+		plugins: { [PLUGIN_NAME]: plugin },
+		rules: (0, _intlayer_config_lint.getRecommendedLintRules)()
+	},
+	strict: {
+		...createConfig("strict", {
+			"no-raw-text": "error",
+			"static-dictionary-key": "error",
+			"no-dynamic-field-access": "error",
+			"enforce-adapter-import": "error"
+		}),
+		rules: {
+			"intlayer/no-raw-text": ["error", { includeStringLiterals: true }],
+			"intlayer/static-dictionary-key": "error",
+			"intlayer/no-dynamic-field-access": "error",
+			"intlayer/enforce-adapter-import": "error"
+		}
+	},
+	"contract-only": createConfig("contract-only", {
+		"static-dictionary-key": "error",
+		"no-dynamic-field-access": "error"
+	})
+};
+const intlayerPlugin = {
+	meta,
+	rules,
+	configs
+};
+
+//#endregion
+exports.configs = configs;
+exports.default = intlayerPlugin;
+exports.meta = meta;
+exports.rules = rules;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["noRawText","staticDictionaryKey","noDynamicFieldAccess","enforceAdapterImport","getRecommendedLintRules"],"sources":["../../src/index.ts"],"sourcesContent":["import { getRecommendedLintRules } from '@intlayer/config/lint';\nimport type { ESLint, Linter } from 'eslint';\nimport { enforceAdapterImport } from './rules/enforceAdapterImport';\nimport { noDynamicFieldAccess } from './rules/noDynamicFieldAccess';\nimport { noRawText } from './rules/noRawText';\nimport { staticDictionaryKey } from './rules/staticDictionaryKey';\n\nconst PLUGIN_NAME = 'intlayer';\n\n/**\n * Every rule this plugin ships, keyed by the name used in configuration.\n *\n * The rules split into two families:\n * - **Coverage** (`no-raw-text`) — user-facing copy that never reached a\n *   dictionary. Nothing else in the toolchain reports it.\n * - **Compiler contract** (`static-dictionary-key`, `no-dynamic-field-access`)\n *   — call shapes that type-check and run, but that the Babel/SWC passes cannot\n *   analyse, so they silently lose the optimize pass or read a purged field.\n *\n * Deliberately absent: unknown dictionary keys, unknown field paths and missing\n * required locales. The generated `__DictionaryRegistry` module augmentation\n * already makes all three compile errors, and `@intlayer/lsp` reports the first\n * as an editor diagnostic — a third report would only add noise.\n */\nexport const rules = {\n  'no-raw-text': noRawText,\n  'static-dictionary-key': staticDictionaryKey,\n  'no-dynamic-field-access': noDynamicFieldAccess,\n  'enforce-adapter-import': enforceAdapterImport,\n} satisfies ESLint.Plugin['rules'];\n\n/** Rule names this plugin exposes. */\nexport type IntlayerRuleName = keyof typeof rules;\n\nconst meta: { name: string; version: string } = {\n  name: 'eslint-plugin-intlayer',\n  version: '9.3.1',\n};\n\nconst plugin: ESLint.Plugin = { meta, rules };\n\n/** The flat configs this plugin ships. */\nexport type IntlayerConfigName = 'recommended' | 'strict' | 'contract-only';\n\n/**\n * Build a flat config enabling the given rules under the `intlayer/` prefix.\n *\n * @param name - Config name, surfaced by `--print-config` and the config inspector.\n * @param ruleSeverities - Severity per rule name.\n */\nconst createConfig = (\n  name: string,\n  ruleSeverities: Partial<Record<IntlayerRuleName, Linter.RuleSeverity>>\n): Linter.Config => ({\n  name: `intlayer/${name}`,\n  plugins: { [PLUGIN_NAME]: plugin },\n  rules: Object.fromEntries(\n    Object.entries(ruleSeverities).map(([ruleName, severity]) => [\n      `${PLUGIN_NAME}/${ruleName}`,\n      severity,\n    ])\n  ),\n});\n\n/**\n * Flat configs, for `eslint.config.js`:\n *\n * ```js\n * import intlayer from 'eslint-plugin-intlayer';\n *\n * export default [intlayer.configs.recommended];\n * ```\n *\n * - `recommended` — the compiler-contract rules as errors, plus `no-raw-text`\n *   as a warning so an existing codebase is not blocked on day one.\n * - `strict` — everything as an error, including string literals outside JSX.\n * - `contract-only` — just the rules that protect the build output; use this\n *   when translation coverage is tracked by `intlayer test` instead.\n *\n * `enforce-adapter-import` is opt-in: importing from the original package is\n * perfectly valid once the bundler alias is set up, so a project that has done\n * that should not be nagged. Only `strict` turns it on.\n */\nexport const configs: Record<IntlayerConfigName, Linter.Config> = {\n  // Built from the shared preset in `@intlayer/config/lint`, which `intlayer\n  // init` also writes into `.oxlintrc.json` — oxlint resolves a plugin's rules\n  // but not its configs, so the two must not drift.\n  recommended: {\n    name: `${PLUGIN_NAME}/recommended`,\n    plugins: { [PLUGIN_NAME]: plugin },\n    rules: getRecommendedLintRules() as Linter.Config['rules'],\n  },\n  strict: {\n    ...createConfig('strict', {\n      'no-raw-text': 'error',\n      'static-dictionary-key': 'error',\n      'no-dynamic-field-access': 'error',\n      'enforce-adapter-import': 'error',\n    }),\n    rules: {\n      'intlayer/no-raw-text': ['error', { includeStringLiterals: true }],\n      'intlayer/static-dictionary-key': 'error',\n      'intlayer/no-dynamic-field-access': 'error',\n      'intlayer/enforce-adapter-import': 'error',\n    },\n  },\n  'contract-only': createConfig('contract-only', {\n    'static-dictionary-key': 'error',\n    'no-dynamic-field-access': 'error',\n  }),\n};\n\nexport type { NoRawTextOptions } from './rules/noRawText';\nexport { meta };\n\n/** The plugin object, as consumed by `eslint.config.js`. */\nexport type IntlayerPlugin = ESLint.Plugin & {\n  meta: { name: string; version: string };\n  rules: typeof rules;\n  configs: Record<IntlayerConfigName, Linter.Config>;\n};\n\nconst intlayerPlugin: IntlayerPlugin = { meta, rules, configs };\n\nexport default intlayerPlugin;\n"],"mappings":";;;;;;;;AAOA,MAAM,cAAc;;;;;;;;;;;;;;;;AAiBpB,MAAa,QAAQ;CACnB,eAAeA;CACf,yBAAyBC;CACzB,2BAA2BC;CAC3B,0BAA0BC;AAC5B;AAKA,MAAM,OAA0C;CAC9C,MAAM;CACN,SAAS;AACX;AAEA,MAAM,SAAwB;CAAE;CAAM;AAAM;;;;;;;AAW5C,MAAM,gBACJ,MACA,oBACmB;CACnB,MAAM,YAAY;CAClB,SAAS,GAAG,cAAc,OAAO;CACjC,OAAO,OAAO,YACZ,OAAO,QAAQ,cAAc,CAAC,CAAC,KAAK,CAAC,UAAU,cAAc,CAC3D,GAAG,YAAY,GAAG,YAClB,QACF,CAAC,CACH;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,UAAqD;CAIhE,aAAa;EACX,MAAM,GAAG,YAAY;EACrB,SAAS,GAAG,cAAc,OAAO;EACjC,WAAOC,+CAAwB;CACjC;CACA,QAAQ;EACN,GAAG,aAAa,UAAU;GACxB,eAAe;GACf,yBAAyB;GACzB,2BAA2B;GAC3B,0BAA0B;EAC5B,CAAC;EACD,OAAO;GACL,wBAAwB,CAAC,SAAS,EAAE,uBAAuB,KAAK,CAAC;GACjE,kCAAkC;GAClC,oCAAoC;GACpC,mCAAmC;EACrC;CACF;CACA,iBAAiB,aAAa,iBAAiB;EAC7C,yBAAyB;EACzB,2BAA2B;CAC7B,CAAC;AACH;AAYA,MAAM,iBAAiC;CAAE;CAAM;CAAO;AAAQ"}

package/dist/cjs/rules/enforceAdapterImport.cjs

@@ -0,0 +1,81 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils_ast = require('../utils/ast.cjs');
+const require_utils_createRule = require('../utils/createRule.cjs');
+let _intlayer_config_callers = require("@intlayer/config/callers");
+
+//#region src/rules/enforceAdapterImport.ts
+const ADAPTER_SCOPE = "@intlayer/";
+/**
+* Original library specifier → the `@intlayer/*` adapter that replaces it.
+*
+* Derived from the shared registry rather than hard-coded: every compat
+* descriptor lists both its original specifiers and their adapter equivalents in
+* `importSources`, so a library added to `@intlayer/config/callers` is covered
+* here for free.
+*
+* Sub-paths line up by position within a descriptor — `next-intl/server` and
+* `@intlayer/next-intl/server` are listed together — so the mapping is built by
+* matching each original against the adapter that ends with the same tail.
+*/
+const buildAdapterMap = () => {
+	const adapterBySpecifier = /* @__PURE__ */ new Map();
+	for (const descriptor of _intlayer_config_callers.ALL_CALLERS) {
+		const adapters = descriptor.importSources.filter((source) => source.startsWith(ADAPTER_SCOPE));
+		if (adapters.length === 0) continue;
+		const originals = descriptor.importSources.filter((source) => !source.startsWith(ADAPTER_SCOPE));
+		for (const original of originals) {
+			const adapter = adapters.find((candidate) => candidate === `${ADAPTER_SCOPE}${original}`) ?? adapters.find((candidate) => candidate.endsWith(`/${original}`)) ?? adapters[0];
+			if (adapter && !adapterBySpecifier.has(original)) adapterBySpecifier.set(original, adapter);
+		}
+	}
+	return adapterBySpecifier;
+};
+const ADAPTER_BY_SPECIFIER = buildAdapterMap();
+const enforceAdapterImport = require_utils_createRule.createRule("enforce-adapter-import", {
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Import compat-library APIs from their `@intlayer/*` adapter rather than the original package" },
+		messages: { useAdapterImport: "Import from `{{adapter}}` instead of `{{original}}`. The original specifier only resolves to Intlayer when the bundler alias is configured; the adapter always does." }
+	},
+	create: (context) => {
+		/** Report and rewrite a module specifier that has an adapter equivalent. */
+		const checkSource = (node) => {
+			if (!node) return;
+			const original = node["value"];
+			if (typeof original !== "string") return;
+			const adapter = ADAPTER_BY_SPECIFIER.get(original);
+			if (!adapter) return;
+			context.report({
+				node,
+				messageId: "useAdapterImport",
+				data: {
+					adapter,
+					original
+				},
+				fix: (fixer) => {
+					const quote = (node["raw"] ?? `'${original}'`).startsWith("\"") ? "\"" : "'";
+					return fixer.replaceText(node, `${quote}${adapter}${quote}`);
+				}
+			});
+		};
+		return {
+			ImportDeclaration: (node) => {
+				checkSource(require_utils_ast.toAstNode(node)["source"]);
+			},
+			ExportNamedDeclaration: (node) => {
+				checkSource(require_utils_ast.toAstNode(node)["source"]);
+			},
+			ExportAllDeclaration: (node) => {
+				checkSource(require_utils_ast.toAstNode(node)["source"]);
+			},
+			ImportExpression: (node) => {
+				checkSource(require_utils_ast.toAstNode(node)["source"]);
+			}
+		};
+	}
+});
+
+//#endregion
+exports.enforceAdapterImport = enforceAdapterImport;
+//# sourceMappingURL=enforceAdapterImport.cjs.map

package/dist/cjs/rules/enforceAdapterImport.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforceAdapterImport.cjs","names":["ALL_CALLERS","createRule","toAstNode"],"sources":["../../../src/rules/enforceAdapterImport.ts"],"sourcesContent":["import { ALL_CALLERS } from '@intlayer/config/callers';\nimport { type AstNode, toAstNode } from '../utils/ast';\nimport { createRule } from '../utils/createRule';\n\ntype MessageIds = 'useAdapterImport';\n\nconst ADAPTER_SCOPE = '@intlayer/';\n\n/**\n * Original library specifier → the `@intlayer/*` adapter that replaces it.\n *\n * Derived from the shared registry rather than hard-coded: every compat\n * descriptor lists both its original specifiers and their adapter equivalents in\n * `importSources`, so a library added to `@intlayer/config/callers` is covered\n * here for free.\n *\n * Sub-paths line up by position within a descriptor — `next-intl/server` and\n * `@intlayer/next-intl/server` are listed together — so the mapping is built by\n * matching each original against the adapter that ends with the same tail.\n */\nconst buildAdapterMap = (): Map<string, string> => {\n  const adapterBySpecifier = new Map<string, string>();\n\n  for (const descriptor of ALL_CALLERS) {\n    const adapters = descriptor.importSources.filter((source) =>\n      source.startsWith(ADAPTER_SCOPE)\n    );\n\n    if (adapters.length === 0) continue;\n\n    const originals = descriptor.importSources.filter(\n      (source) => !source.startsWith(ADAPTER_SCOPE)\n    );\n\n    for (const original of originals) {\n      // `next-intl/server` → prefer `@intlayer/next-intl/server` over\n      // `@intlayer/next-intl`, so match on the longest shared suffix.\n      const adapter =\n        adapters.find(\n          (candidate) => candidate === `${ADAPTER_SCOPE}${original}`\n        ) ??\n        adapters.find((candidate) => candidate.endsWith(`/${original}`)) ??\n        adapters[0];\n\n      if (adapter && !adapterBySpecifier.has(original)) {\n        adapterBySpecifier.set(original, adapter);\n      }\n    }\n  }\n\n  return adapterBySpecifier;\n};\n\nconst ADAPTER_BY_SPECIFIER = buildAdapterMap();\n\nexport const enforceAdapterImport = createRule<[], MessageIds>(\n  'enforce-adapter-import',\n  {\n    meta: {\n      type: 'suggestion',\n      fixable: 'code',\n      docs: {\n        description:\n          'Import compat-library APIs from their `@intlayer/*` adapter rather than the original package',\n      },\n      messages: {\n        useAdapterImport:\n          'Import from `{{adapter}}` instead of `{{original}}`. The original specifier only resolves to Intlayer when the bundler alias is configured; the adapter always does.',\n      },\n    },\n\n    create: (context) => {\n      /** Report and rewrite a module specifier that has an adapter equivalent. */\n      const checkSource = (node: AstNode | null | undefined): void => {\n        if (!node) return;\n\n        const original = node['value'];\n\n        if (typeof original !== 'string') return;\n\n        const adapter = ADAPTER_BY_SPECIFIER.get(original);\n\n        if (!adapter) return;\n\n        context.report({\n          node: node as never,\n          messageId: 'useAdapterImport',\n          data: { adapter, original },\n          fix: (fixer) => {\n            const raw = (node['raw'] as string | undefined) ?? `'${original}'`;\n            const quote = raw.startsWith('\"') ? '\"' : \"'\";\n\n            return fixer.replaceText(\n              node as never,\n              `${quote}${adapter}${quote}`\n            );\n          },\n        });\n      };\n\n      return {\n        ImportDeclaration: (node) => {\n          checkSource(toAstNode(node)['source'] as AstNode);\n        },\n\n        ExportNamedDeclaration: (node) => {\n          checkSource(toAstNode(node)['source'] as AstNode);\n        },\n\n        ExportAllDeclaration: (node) => {\n          checkSource(toAstNode(node)['source'] as AstNode);\n        },\n\n        ImportExpression: (node) => {\n          checkSource(toAstNode(node)['source'] as AstNode);\n        },\n      };\n    },\n  }\n);\n"],"mappings":";;;;;;AAMA,MAAM,gBAAgB;;;;;;;;;;;;;AActB,MAAM,wBAA6C;CACjD,MAAM,qCAAqB,IAAI,IAAoB;CAEnD,KAAK,MAAM,cAAcA,sCAAa;EACpC,MAAM,WAAW,WAAW,cAAc,QAAQ,WAChD,OAAO,WAAW,aAAa,CACjC;EAEA,IAAI,SAAS,WAAW,GAAG;EAE3B,MAAM,YAAY,WAAW,cAAc,QACxC,WAAW,CAAC,OAAO,WAAW,aAAa,CAC9C;EAEA,KAAK,MAAM,YAAY,WAAW;GAGhC,MAAM,UACJ,SAAS,MACN,cAAc,cAAc,GAAG,gBAAgB,UAClD,KACA,SAAS,MAAM,cAAc,UAAU,SAAS,IAAI,UAAU,CAAC,KAC/D,SAAS;GAEX,IAAI,WAAW,CAAC,mBAAmB,IAAI,QAAQ,GAC7C,mBAAmB,IAAI,UAAU,OAAO;EAE5C;CACF;CAEA,OAAO;AACT;AAEA,MAAM,uBAAuB,gBAAgB;AAE7C,MAAa,uBAAuBC,oCAClC,0BACA;CACE,MAAM;EACJ,MAAM;EACN,SAAS;EACT,MAAM,EACJ,aACE,+FACJ;EACA,UAAU,EACR,kBACE,uKACJ;CACF;CAEA,SAAS,YAAY;;EAEnB,MAAM,eAAe,SAA2C;GAC9D,IAAI,CAAC,MAAM;GAEX,MAAM,WAAW,KAAK;GAEtB,IAAI,OAAO,aAAa,UAAU;GAElC,MAAM,UAAU,qBAAqB,IAAI,QAAQ;GAEjD,IAAI,CAAC,SAAS;GAEd,QAAQ,OAAO;IACP;IACN,WAAW;IACX,MAAM;KAAE;KAAS;IAAS;IAC1B,MAAM,UAAU;KAEd,MAAM,SADO,KAAK,UAAiC,IAAI,SAAS,GAC/C,CAAC,WAAW,IAAG,IAAI,OAAM;KAE1C,OAAO,MAAM,YACX,MACA,GAAG,QAAQ,UAAU,OACvB;IACF;GACF,CAAC;EACH;EAEA,OAAO;GACL,oBAAoB,SAAS;IAC3B,YAAYC,4BAAU,IAAI,CAAC,CAAC,SAAoB;GAClD;GAEA,yBAAyB,SAAS;IAChC,YAAYA,4BAAU,IAAI,CAAC,CAAC,SAAoB;GAClD;GAEA,uBAAuB,SAAS;IAC9B,YAAYA,4BAAU,IAAI,CAAC,CAAC,SAAoB;GAClD;GAEA,mBAAmB,SAAS;IAC1B,YAAYA,4BAAU,IAAI,CAAC,CAAC,SAAoB;GAClD;EACF;CACF;AACF,CACF"}

package/dist/cjs/rules/noDynamicFieldAccess.cjs

@@ -0,0 +1,130 @@
+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/noDynamicFieldAccess.ts
+/**
+* Property name holding the translation function in a `destructured-t` result,
+* e.g. `const { t } = useTranslation('home')`.
+*/
+const TRANSLATOR_PROPERTY_NAME = "t";
+/**
+* True when a computed member access reads a field the compiler can still name:
+* a literal (`content['title']`, `items[0]`) or an uninterpolated template.
+*
+* @param property - The `property` node of a computed MemberExpression.
+*/
+const isStaticComputedProperty = (property) => {
+	if (!property) return false;
+	if (property.type === "Literal") return true;
+	return require_utils_ast.getStaticStringValue(property) !== null;
+};
+/**
+* The variables a declarator binds, paired with the identifier that declared
+* each one — needed to tell `t` apart from `i18n` in a destructuring pattern.
+*
+* @param variables - Result of `sourceCode.getDeclaredVariables(declarator)`.
+* @param identifier - The declaring identifier to look up.
+*/
+const findVariableForIdentifier = (variables, identifier) => variables.find((variable) => variable.identifiers.some((declared) => declared === identifier)) ?? null;
+/**
+* Locate the identifier bound to the `t` property of an object pattern,
+* honouring renames (`const { t: translate } = …`).
+*
+* @param pattern - The declarator's `id`, expected to be an ObjectPattern.
+*/
+const findTranslatorIdentifier = (pattern) => {
+	if (pattern.type !== "ObjectPattern") return null;
+	const properties = pattern["properties"] ?? [];
+	for (const property of properties) {
+		if (property.type !== "Property" || property["computed"] === true) continue;
+		const key = property["key"];
+		if ((key?.type === "Identifier" ? key["name"] : key?.type === "Literal" ? String(key["value"]) : null) !== TRANSLATOR_PROPERTY_NAME) continue;
+		const value = property["value"];
+		return value?.type === "Identifier" ? value : null;
+	}
+	return null;
+};
+const noDynamicFieldAccess = require_utils_createRule.createRule("no-dynamic-field-access", {
+	meta: {
+		type: "problem",
+		docs: { description: "Require the field read from an Intlayer dictionary to be statically known" },
+		messages: {
+			dynamicField: "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.",
+			dynamicMessageId: "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."
+		}
+	},
+	create: (context) => {
+		const sourceCode = context.sourceCode;
+		let activeDescriptors = require_utils_callerMatcher.getActiveDescriptors(/* @__PURE__ */ new Set());
+		/** Report every computed, non-static member access on a bound variable. */
+		const checkContentVariable = (variable) => {
+			for (const reference of variable.references) {
+				const identifier = reference.identifier;
+				const parent = identifier.parent;
+				if (parent?.type !== "MemberExpression") continue;
+				if (parent["object"] !== identifier) continue;
+				if (parent["computed"] !== true) continue;
+				if (isStaticComputedProperty(parent["property"])) continue;
+				context.report({
+					node: parent,
+					messageId: "dynamicField"
+				});
+			}
+		};
+		/** Report every call of a translation function with a runtime message path. */
+		const checkTranslatorVariable = (variable, callerName) => {
+			for (const reference of variable.references) {
+				const identifier = reference.identifier;
+				const parent = identifier.parent;
+				if (parent?.type !== "CallExpression") continue;
+				if (parent["callee"] !== identifier) continue;
+				const [firstArgument] = parent["arguments"] ?? [];
+				if (!firstArgument) continue;
+				if (require_utils_ast.getStaticStringValue(firstArgument) !== null) continue;
+				context.report({
+					node: firstArgument,
+					messageId: "dynamicMessageId",
+					data: { caller: callerName }
+				});
+			}
+		};
+		return {
+			Program: (node) => {
+				activeDescriptors = require_utils_callerMatcher.getActiveDescriptors(require_utils_callerMatcher.collectImportSources(require_utils_ast.toAstNode(node)));
+			},
+			VariableDeclarator: (node) => {
+				const astNode = require_utils_ast.toAstNode(node);
+				const init = astNode["init"];
+				if (!init) return;
+				const match = require_utils_callerMatcher.matchCaller(init, activeDescriptors);
+				if (!match) return;
+				const { descriptor } = match;
+				const shape = descriptor.translationFunction;
+				const kind = shape === "content" ? "content" : shape === "return-value" || shape === "destructured-t" ? "translator" : null;
+				if (!kind) return;
+				const declaredVariables = sourceCode.getDeclaredVariables(node);
+				const id = astNode["id"];
+				if (kind === "content") {
+					for (const variable of declaredVariables) checkContentVariable(variable);
+					return;
+				}
+				if (shape === "return-value") {
+					if (id.type !== "Identifier") return;
+					const variable = findVariableForIdentifier(declaredVariables, id);
+					if (variable) checkTranslatorVariable(variable, descriptor.callerName);
+					return;
+				}
+				const translatorIdentifier = findTranslatorIdentifier(id);
+				if (!translatorIdentifier) return;
+				const variable = findVariableForIdentifier(declaredVariables, translatorIdentifier);
+				if (variable) checkTranslatorVariable(variable, descriptor.callerName);
+			}
+		};
+	}
+});
+
+//#endregion
+exports.noDynamicFieldAccess = noDynamicFieldAccess;
+//# sourceMappingURL=noDynamicFieldAccess.cjs.map