eslint-plugin-intlayer 9.3.1 → 9.3.3

package/README.md

@@ -8,12 +8,12 @@ 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     |
+| 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:
@@ -36,24 +36,24 @@ Requires ESLint 9 or later (flat config).
 
 ```js
 // eslint.config.js
-import intlayer from 'eslint-plugin-intlayer';
+import intlayer from "eslint-plugin-intlayer";
 
-export default [intlayer.configs.recommended];
+export default [...intlayer.configs.recommended];
 ```
 
 Or configure rules individually:
 
 ```js
-import intlayer from 'eslint-plugin-intlayer';
+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',
+      "intlayer/no-raw-text": ["warn", { includeStringLiterals: false }],
+      "intlayer/static-dictionary-key": "error",
+      "intlayer/no-dynamic-field-access": "error",
+      "intlayer/enforce-adapter-import": "warn",
     },
   },
 ];
@@ -61,11 +61,11 @@ export default [
 
 ### 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                      |
+| Config          | `no-raw-text`              | `static-dictionary-key` | `no-dynamic-field-access` | `enforce-adapter-import` | `no-unused-content` |
+| --------------- | -------------------------- | ----------------------- | ------------------------- | ------------------------ | ------------------- |
+| `recommended`   | warn                       | error                   | error                     | off                      | off                 |
+| `strict`        | error (+ non-JSX literals) | error                   | error                     | error                    | off                 |
+| `contract-only` | off                        | error                   | error                     | off                      | 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
@@ -74,21 +74,25 @@ 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.
 
+`no-unused-content` is off in every config, `strict` included. It is the one
+rule that reads the Intlayer configuration and walks your source files from
+disk, so enabling it should be a deliberate choice.
+
 ### 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 |
+| 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
@@ -102,24 +106,24 @@ 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';
+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,
+  ...intlayer.configs.recommended,
 
   // React / Angular components / plain TS
   {
-    files: ['**/*.{ts,tsx,jsx}'],
+    files: ["**/*.{ts,tsx,jsx}"],
     languageOptions: { parser: tseslint.parser },
   },
 
   // Vue — the TS parser handles <script lang="ts">
   {
-    files: ['**/*.vue'],
+    files: ["**/*.vue"],
     languageOptions: {
       parser: vueParser,
       parserOptions: { parser: tseslint.parser },
@@ -128,7 +132,7 @@ export default [
 
   // Svelte
   {
-    files: ['**/*.svelte'],
+    files: ["**/*.svelte"],
     languageOptions: {
       parser: svelteParser,
       parserOptions: { parser: tseslint.parser },
@@ -137,7 +141,7 @@ export default [
 
   // Angular templates
   {
-    files: ['**/*.component.html'],
+    files: ["**/*.component.html"],
     languageOptions: { parser: angularTemplateParser },
   },
 ];
@@ -229,13 +233,13 @@ useIntlayer(`home-${suffix}`);
 getTranslations({ namespace: page });
 
 // ✗ — a const still is not a literal at the call site
-const key = 'home';
+const key = "home";
 useIntlayer(key);
 
 // ✓
-useIntlayer('home');
-useIntlayer('home' as const);
-getTranslations({ namespace: 'home' });
+useIntlayer("home");
+useIntlayer("home" as const);
+getTranslations({ namespace: "home" });
 ```
 
 The rule covers every caller in the shared registry — `useIntlayer`,
@@ -256,17 +260,17 @@ a missed optimization.
 
 ```ts
 // ✗
-const content = useIntlayer('home');
+const content = useIntlayer("home");
 content[fieldName];
 
-const t = useTranslations('home');
+const t = useTranslations("home");
 t(messageKey);
 
 // ✓
 content.title;
-content['title'];
+content["title"];
 content.items[0];
-t('hero.title');
+t("hero.title");
 ```
 
 Bindings are resolved through ESLint's scope analysis, so two components in the
@@ -282,17 +286,67 @@ configured; the adapter always does. Autofixable.
 
 ```ts
 // ✗
-import { useTranslation } from 'react-i18next';
-import { getTranslations } from 'next-intl/server';
+import { useTranslation } from "react-i18next";
+import { getTranslations } from "next-intl/server";
 
 // ✓
-import { useTranslation } from '@intlayer/react-i18next';
-import { getTranslations } from '@intlayer/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.
 
+### no-unused-content
+
+Off by default. Reports dictionaries and content fields that nothing in the
+project reads, plus keys declared in more than one place.
+
+```ts
+// home.content.ts
+export default {
+  key: "home", // ✗ unusedDictionary — no caller anywhere asks for "home"
+  content: {
+    title: t({ en: "Title" }),
+    hero: {
+      // ✗ unusedField — nothing reads `hero`
+      subtitle: t({ en: "Subtitle" }),
+    },
+  },
+};
+```
+
+Unlike the other rules, this one cannot answer from the file in front of it: a
+field is unused only relative to the whole project. On the first content file of
+a lint run it loads your Intlayer configuration, globs the source files it
+declares (`build.traversePattern`, `compiler.transformPattern`) and runs the
+same analyser `@intlayer/lsp` and the VS Code extension use. The result is cached
+for `cacheTtl` milliseconds.
+
+```js
+{
+  "intlayer/no-unused-content": ["warn", {
+    reportUnusedDictionaries: true,  // dictionary keys nothing references
+    reportUnusedFields: true,        // content fields nothing reads
+    reportDuplicateKeys: true,       // keys declared in more than one place
+    ignoreFields: ["^meta"],         // regexes for field paths to never report
+    baseDir: process.cwd(),          // project root the scan starts from
+    cacheTtl: 30000,                 // how long one scan is reused, in ms
+  }],
+}
+```
+
+It errs towards silence, because a false positive here deletes a translation.
+Nothing is reported when the dictionary is consumed in a way the analysis cannot
+follow — the content object passed on as a whole, a translator function bound
+from it, a declaration reached through a direct import, a `nest()` from another
+dictionary, or a field list made non-exhaustive by a spread. Single-file
+components (`.vue`, `.svelte`, `.astro`) count as using every field of the
+dictionaries they mention, since their script blocks are not parsed here.
+
+`reportDuplicateKeys` reads the unmerged dictionaries the build writes to
+`.intlayer/`, so it stays quiet until the project has been built at least once.
+
 ## How it stays in sync
 
 The plugin reads the same two shared sources as the compiler and the language

package/dist/cjs/@intlayer/config/dist/esm/extract/constants.cjs

@@ -0,0 +1,18 @@
+//#region ../@intlayer/config/dist/esm/extract/constants.mjs
+/**
+* Attributes that should be extracted as translatable strings from JSX/HTML elements.
+* This is the single source of truth shared across all Intlayer compiler packages
+* (@intlayer/babel, @intlayer/vue-compiler, @intlayer/svelte-compiler, @intlayer/engine)
+* and the `eslint-plugin-intlayer` `no-raw-text` rule.
+*/
+const ATTRIBUTES_TO_EXTRACT = [
+	"title",
+	"placeholder",
+	"alt",
+	"aria-label",
+	"label"
+];
+
+//#endregion
+exports.ATTRIBUTES_TO_EXTRACT = ATTRIBUTES_TO_EXTRACT;
+//# sourceMappingURL=constants.cjs.map

package/dist/cjs/@intlayer/config/dist/esm/extract/constants.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.cjs","names":[],"sources":["../../../../../../../../@intlayer/config/dist/esm/extract/constants.mjs"],"sourcesContent":["//#region src/extract/constants.ts\n/**\n* Attributes that should be extracted as translatable strings from JSX/HTML elements.\n* This is the single source of truth shared across all Intlayer compiler packages\n* (@intlayer/babel, @intlayer/vue-compiler, @intlayer/svelte-compiler, @intlayer/engine)\n* and the `eslint-plugin-intlayer` `no-raw-text` rule.\n*/\nconst ATTRIBUTES_TO_EXTRACT = [\n\t\"title\",\n\t\"placeholder\",\n\t\"alt\",\n\t\"aria-label\",\n\t\"label\"\n];\n\n//#endregion\nexport { ATTRIBUTES_TO_EXTRACT };\n//# sourceMappingURL=constants.mjs.map"],"mappings":";;;;;;;AAOA,MAAM,wBAAwB;CAC7B;CACA;CACA;CACA;CACA;AACD"}

package/dist/cjs/@intlayer/config/dist/esm/extract/shouldExtract.cjs

@@ -0,0 +1,37 @@
+//#region ../@intlayer/config/dist/esm/extract/shouldExtract.mjs
+/**
+* Checks whether the given text should be extracted as a translatable string.
+*
+* Filters out:
+* - Empty strings
+* - Emails
+* - Single capitalized words (likely brand/proper nouns, e.g. "Intlayer")
+* - Uncapitalized strings of 2 words or fewer (likely technical terms)
+* - Dynamic content patterns like Vue bindings (`v-`) or object patterns (`{`)
+*/
+const shouldExtract = (text) => {
+	const trimmed = text.trim();
+	if (!trimmed) return false;
+	if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(trimmed)) return false;
+	if (trimmed.startsWith("{") && !trimmed.startsWith("{{") || trimmed.startsWith("v-")) return false;
+	if (trimmed.includes("=>") || trimmed.includes(");") || trimmed.includes("(){") || trimmed.includes("==") || trimmed.includes("window.") || trimmed.startsWith("(function") || trimmed.startsWith("function(")) return false;
+	if ((trimmed.match(/[^\p{L}\p{N}\s.,!?;:'"()[\]{}–—/«»„“\p{Sc}%&*+#@^_+=<>/~]/gu) || []).length > 5) return false;
+	const wordCount = trimmed.split(/\s+/).length;
+	const cssClassTokenRegex = /^!?([a-z][a-z0-9-]*:)*[a-z][a-z0-9]*(-[a-z0-9[\].,%#/]+)*(\/[a-z0-9]+)?$/;
+	if (wordCount > 1) {
+		const tokens = trimmed.split(/\s+/);
+		if (tokens.every((token) => cssClassTokenRegex.test(token)) && tokens.some((token) => token.includes("-"))) return false;
+	}
+	const isCapitalized = /^['"([]*\p{Lu}/u.test(trimmed);
+	if (wordCount === 1 && isCapitalized) return false;
+	if (wordCount === 1) {
+		if (/[a-z]\p{Lu}/u.test(trimmed)) return false;
+		if (trimmed.includes("-") || trimmed.includes("_")) return false;
+	}
+	if (!isCapitalized && wordCount <= 2) return false;
+	return true;
+};
+
+//#endregion
+exports.shouldExtract = shouldExtract;
+//# sourceMappingURL=shouldExtract.cjs.map

package/dist/cjs/@intlayer/config/dist/esm/extract/shouldExtract.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shouldExtract.cjs","names":[],"sources":["../../../../../../../../@intlayer/config/dist/esm/extract/shouldExtract.mjs"],"sourcesContent":["//#region src/extract/shouldExtract.ts\n/**\n* Checks whether the given text should be extracted as a translatable string.\n*\n* Filters out:\n* - Empty strings\n* - Emails\n* - Single capitalized words (likely brand/proper nouns, e.g. \"Intlayer\")\n* - Uncapitalized strings of 2 words or fewer (likely technical terms)\n* - Dynamic content patterns like Vue bindings (`v-`) or object patterns (`{`)\n*/\nconst shouldExtract = (text) => {\n\tconst trimmed = text.trim();\n\tif (!trimmed) return false;\n\tif (/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(trimmed)) return false;\n\tif (trimmed.startsWith(\"{\") && !trimmed.startsWith(\"{{\") || trimmed.startsWith(\"v-\")) return false;\n\tif (trimmed.includes(\"=>\") || trimmed.includes(\");\") || trimmed.includes(\"(){\") || trimmed.includes(\"==\") || trimmed.includes(\"window.\") || trimmed.startsWith(\"(function\") || trimmed.startsWith(\"function(\")) return false;\n\tif ((trimmed.match(/[^\\p{L}\\p{N}\\s.,!?;:'\"()[\\]{}–—/«»„“\\p{Sc}%&*+#@^_+=<>/~]/gu) || []).length > 5) return false;\n\tconst wordCount = trimmed.split(/\\s+/).length;\n\tconst cssClassTokenRegex = /^!?([a-z][a-z0-9-]*:)*[a-z][a-z0-9]*(-[a-z0-9[\\].,%#/]+)*(\\/[a-z0-9]+)?$/;\n\tif (wordCount > 1) {\n\t\tconst tokens = trimmed.split(/\\s+/);\n\t\tif (tokens.every((token) => cssClassTokenRegex.test(token)) && tokens.some((token) => token.includes(\"-\"))) return false;\n\t}\n\tconst isCapitalized = /^['\"([]*\\p{Lu}/u.test(trimmed);\n\tif (wordCount === 1 && isCapitalized) return false;\n\tif (wordCount === 1) {\n\t\tif (/[a-z]\\p{Lu}/u.test(trimmed)) return false;\n\t\tif (trimmed.includes(\"-\") || trimmed.includes(\"_\")) return false;\n\t}\n\tif (!isCapitalized && wordCount <= 2) return false;\n\treturn true;\n};\n\n//#endregion\nexport { shouldExtract };\n//# sourceMappingURL=shouldExtract.mjs.map"],"mappings":";;;;;;;;;;;AAWA,MAAM,iBAAiB,SAAS;CAC/B,MAAM,UAAU,KAAK,KAAK;CAC1B,IAAI,CAAC,SAAS,OAAO;CACrB,IAAI,6BAA6B,KAAK,OAAO,GAAG,OAAO;CACvD,IAAI,QAAQ,WAAW,GAAG,KAAK,CAAC,QAAQ,WAAW,IAAI,KAAK,QAAQ,WAAW,IAAI,GAAG,OAAO;CAC7F,IAAI,QAAQ,SAAS,IAAI,KAAK,QAAQ,SAAS,IAAI,KAAK,QAAQ,SAAS,KAAK,KAAK,QAAQ,SAAS,IAAI,KAAK,QAAQ,SAAS,SAAS,KAAK,QAAQ,WAAW,WAAW,KAAK,QAAQ,WAAW,WAAW,GAAG,OAAO;CACvN,KAAK,QAAQ,MAAM,6DAA6D,KAAK,CAAC,EAAC,CAAE,SAAS,GAAG,OAAO;CAC5G,MAAM,YAAY,QAAQ,MAAM,KAAK,CAAC,CAAC;CACvC,MAAM,qBAAqB;CAC3B,IAAI,YAAY,GAAG;EAClB,MAAM,SAAS,QAAQ,MAAM,KAAK;EAClC,IAAI,OAAO,OAAO,UAAU,mBAAmB,KAAK,KAAK,CAAC,KAAK,OAAO,MAAM,UAAU,MAAM,SAAS,GAAG,CAAC,GAAG,OAAO;CACpH;CACA,MAAM,gBAAgB,kBAAkB,KAAK,OAAO;CACpD,IAAI,cAAc,KAAK,eAAe,OAAO;CAC7C,IAAI,cAAc,GAAG;EACpB,IAAI,eAAe,KAAK,OAAO,GAAG,OAAO;EACzC,IAAI,QAAQ,SAAS,GAAG,KAAK,QAAQ,SAAS,GAAG,GAAG,OAAO;CAC5D;CACA,IAAI,CAAC,iBAAiB,aAAa,GAAG,OAAO;CAC7C,OAAO;AACR"}

package/dist/cjs/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,28 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+exports.__toESM = __toESM;

package/dist/cjs/index.cjs

@@ -1,21 +1,25 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_preset = require('./preset.cjs');
 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_noUnusedContent = require('./rules/noUnusedContent.cjs');
 const require_rules_staticDictionaryKey = require('./rules/staticDictionaryKey.cjs');
-let _intlayer_config_lint = require("@intlayer/config/lint");
+const require_utils_reactVersion = require('./utils/reactVersion.cjs');
 
 //#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:
+* The rules split into three 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.
+* - **Dead content** (`no-unused-content`) — dictionaries and fields nothing
+*   reads. Off in every preset: it is the only rule that scans the whole
+*   project from disk, so enabling it is a cost the user should opt into.
 *
 * Deliberately absent: unknown dictionary keys, unknown field paths and missing
 * required locales. The generated `__DictionaryRegistry` module augmentation
@@ -26,7 +30,8 @@ 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
+	"enforce-adapter-import": require_rules_enforceAdapterImport.enforceAdapterImport,
+	"no-unused-content": require_rules_noUnusedContent.noUnusedContent
 };
 const meta = {
 	name: "eslint-plugin-intlayer",
@@ -42,18 +47,22 @@ const plugin = {
 * @param name - Config name, surfaced by `--print-config` and the config inspector.
 * @param ruleSeverities - Severity per rule name.
 */
-const createConfig = (name, ruleSeverities) => ({
+const createConfig = (name, ruleEntries) => [{
+	name: `intlayer/${name}/ignores`,
+	ignores: require_preset.GENERATED_OUTPUT_GLOBS
+}, {
 	name: `intlayer/${name}`,
-	plugins: { [PLUGIN_NAME]: plugin },
-	rules: Object.fromEntries(Object.entries(ruleSeverities).map(([ruleName, severity]) => [`${PLUGIN_NAME}/${ruleName}`, severity]))
-});
+	plugins: { [require_preset.PLUGIN_NAMESPACE]: plugin },
+	settings: { react: { version: require_utils_reactVersion.getReactVersion() } },
+	rules: Object.fromEntries(Object.entries(ruleEntries).map(([ruleName, entry]) => [`${require_preset.PLUGIN_NAMESPACE}/${ruleName}`, entry]))
+}];
 /**
 * Flat configs, for `eslint.config.js`:
 *
 * ```js
 * import intlayer from 'eslint-plugin-intlayer';
 *
-* export default [intlayer.configs.recommended];
+* export default [...intlayer]; // or [...intlayer.configs.recommended]
 * ```
 *
 * - `recommended` — the compiler-contract rules as errors, plus `no-raw-text`
@@ -65,27 +74,21 @@ const createConfig = (name, ruleSeverities) => ({
 * `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.
+*
+* `no-unused-content` is in no preset at all, `strict` included. It reads the
+* Intlayer configuration and walks the project's source files from disk, which
+* is a different order of cost from the AST-only rules and depends on build
+* output for its duplicate report — spreading a preset should never quietly
+* turn that 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"
-		}
-	},
+	recommended: createConfig("recommended", require_preset.RECOMMENDED_RULES),
+	strict: createConfig("strict", {
+		"no-raw-text": ["error", { includeStringLiterals: true }],
+		"static-dictionary-key": "error",
+		"no-dynamic-field-access": "error",
+		"enforce-adapter-import": "error"
+	}),
 	"contract-only": createConfig("contract-only", {
 		"static-dictionary-key": "error",
 		"no-dynamic-field-access": "error"
@@ -94,12 +97,21 @@ const configs = {
 const intlayerPlugin = {
 	meta,
 	rules,
-	configs
+	configs,
+	*[Symbol.iterator]() {
+		yield* configs.recommended;
+	}
 };
 
 //#endregion
+exports.GENERATED_OUTPUT_GLOBS = require_preset.GENERATED_OUTPUT_GLOBS;
+exports.PLUGIN_NAMESPACE = require_preset.PLUGIN_NAMESPACE;
+exports.PLUGIN_PACKAGE_NAME = require_preset.PLUGIN_PACKAGE_NAME;
+exports.RECOMMENDED_RULES = require_preset.RECOMMENDED_RULES;
 exports.configs = configs;
 exports.default = intlayerPlugin;
+exports.getReactVersion = require_utils_reactVersion.getReactVersion;
+exports.getRecommendedRules = require_preset.getRecommendedRules;
 exports.meta = meta;
 exports.rules = rules;
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -1 +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"}
+{"version":3,"file":"index.cjs","names":["noRawText","staticDictionaryKey","noDynamicFieldAccess","enforceAdapterImport","noUnusedContent","GENERATED_OUTPUT_GLOBS","PLUGIN_NAMESPACE","getReactVersion","RECOMMENDED_RULES"],"sources":["../../src/index.ts"],"sourcesContent":["import type { ESLint, Linter } from 'eslint';\nimport {\n  GENERATED_OUTPUT_GLOBS,\n  PLUGIN_NAMESPACE,\n  RECOMMENDED_RULES,\n} from './preset';\nimport { enforceAdapterImport } from './rules/enforceAdapterImport';\nimport { noDynamicFieldAccess } from './rules/noDynamicFieldAccess';\nimport { noRawText } from './rules/noRawText';\nimport { noUnusedContent } from './rules/noUnusedContent';\nimport { staticDictionaryKey } from './rules/staticDictionaryKey';\nimport { getReactVersion } from './utils/reactVersion';\n\n/**\n * Every rule this plugin ships, keyed by the name used in configuration.\n *\n * The rules split into three 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 * - **Dead content** (`no-unused-content`) — dictionaries and fields nothing\n *   reads. Off in every preset: it is the only rule that scans the whole\n *   project from disk, so enabling it is a cost the user should opt into.\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  'no-unused-content': noUnusedContent,\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  ruleEntries: Partial<Record<IntlayerRuleName, Linter.RuleEntry>>\n): Linter.Config[] => [\n  // A config carrying only `ignores` is a *global* ignore in flat config, so\n  // this keeps ESLint away from generated output wherever the preset is spread.\n  {\n    name: `intlayer/${name}/ignores`,\n    ignores: GENERATED_OUTPUT_GLOBS,\n  },\n  {\n    name: `intlayer/${name}`,\n    plugins: { [PLUGIN_NAMESPACE]: plugin },\n    settings: {\n      react: {\n        version: getReactVersion(),\n      },\n    },\n    rules: Object.fromEntries(\n      Object.entries(ruleEntries).map(([ruleName, entry]) => [\n        `${PLUGIN_NAMESPACE}/${ruleName}`,\n        entry,\n      ])\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]; // or [...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 *\n * `no-unused-content` is in no preset at all, `strict` included. It reads the\n * Intlayer configuration and walks the project's source files from disk, which\n * is a different order of cost from the AST-only rules and depends on build\n * output for its duplicate report — spreading a preset should never quietly\n * turn that on.\n */\nexport const configs: Record<IntlayerConfigName, Linter.Config[]> = {\n  recommended: createConfig('recommended', RECOMMENDED_RULES),\n  strict: createConfig('strict', {\n    'no-raw-text': ['error', { includeStringLiterals: true }],\n    'static-dictionary-key': 'error',\n    'no-dynamic-field-access': 'error',\n    'enforce-adapter-import': 'error',\n  }),\n  'contract-only': createConfig('contract-only', {\n    'static-dictionary-key': 'error',\n    'no-dynamic-field-access': 'error',\n  }),\n};\n\nexport {\n  GENERATED_OUTPUT_GLOBS,\n  getRecommendedRules,\n  PLUGIN_NAMESPACE,\n  PLUGIN_PACKAGE_NAME,\n  RECOMMENDED_RULES,\n} from './preset';\nexport type { NoRawTextOptions } from './rules/noRawText';\nexport type { NoUnusedContentOptions } from './rules/noUnusedContent';\nexport { getReactVersion } from './utils/reactVersion';\nexport { meta };\n\n/** The plugin object, as consumed by `eslint.config.js`. */\nexport type IntlayerPlugin = ESLint.Plugin &\n  Iterable<Linter.Config> & {\n    meta: { name: string; version: string };\n    rules: typeof rules;\n    configs: Record<IntlayerConfigName, Linter.Config[]>;\n  };\n\nconst intlayerPlugin: IntlayerPlugin = {\n  meta,\n  rules,\n  configs,\n  *[Symbol.iterator]() {\n    yield* configs.recommended;\n  },\n};\n\nexport default intlayerPlugin;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,QAAQ;CACnB,eAAeA;CACf,yBAAyBC;CACzB,2BAA2BC;CAC3B,0BAA0BC;CAC1B,qBAAqBC;AACvB;AAKA,MAAM,OAA0C;CAC9C,MAAM;CACN,SAAS;AACX;AAEA,MAAM,SAAwB;CAAE;CAAM;AAAM;;;;;;;AAW5C,MAAM,gBACJ,MACA,gBACoB,CAGpB;CACE,MAAM,YAAY,KAAK;CACvB,SAASC;AACX,GACA;CACE,MAAM,YAAY;CAClB,SAAS,GAAGC,kCAAmB,OAAO;CACtC,UAAU,EACR,OAAO,EACL,SAASC,2CAAgB,EAC3B,EACF;CACA,OAAO,OAAO,YACZ,OAAO,QAAQ,WAAW,CAAC,CAAC,KAAK,CAAC,UAAU,WAAW,CACrD,GAAGD,gCAAiB,GAAG,YACvB,KACF,CAAC,CACH;AACF,CACF;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,UAAuD;CAClE,aAAa,aAAa,eAAeE,gCAAiB;CAC1D,QAAQ,aAAa,UAAU;EAC7B,eAAe,CAAC,SAAS,EAAE,uBAAuB,KAAK,CAAC;EACxD,yBAAyB;EACzB,2BAA2B;EAC3B,0BAA0B;CAC5B,CAAC;CACD,iBAAiB,aAAa,iBAAiB;EAC7C,yBAAyB;EACzB,2BAA2B;CAC7B,CAAC;AACH;AAsBA,MAAM,iBAAiC;CACrC;CACA;CACA;CACA,EAAE,OAAO,YAAY;EACnB,OAAO,QAAQ;CACjB;AACF"}

package/dist/cjs/preset.cjs

@@ -0,0 +1,53 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region src/preset.ts
+/** npm package name of this plugin. */
+const PLUGIN_PACKAGE_NAME = "eslint-plugin-intlayer";
+/** Prefix the rules are registered under, e.g. `intlayer/no-raw-text`. */
+const PLUGIN_NAMESPACE = "intlayer";
+/**
+* Intlayer's generated output, which every preset ignores.
+*
+* `.intlayer/` holds compiled dictionaries and generated types — machine-written
+* files that are never source. Linting them is at best wasted work and at worst
+* a hard failure, since third-party rules can crash on generated shapes they
+* were never meant to see. The rest of the toolchain already excludes this
+* directory (`content.watchExclude`, the build globs), so the lint preset
+* matches.
+*/
+const GENERATED_OUTPUT_GLOBS = ["**/.intlayer/**"];
+/**
+* Rules enabled by the `recommended` preset, keyed by unprefixed rule name.
+*
+* Exported because oxlint resolves a plugin's *rules* but not its shipped
+* *configs*: `intlayer init` reads this to spell the preset out explicitly in
+* `.oxlintrc.json`. Keeping the definition next to the rules it names means
+* enabling one by default is a single-line change.
+*
+* `no-raw-text` stays a warning on purpose — pointed at an existing codebase it
+* surfaces every untranslated string at once, which should not break a build on
+* day one. `enforce-adapter-import` is deliberately absent: importing from the
+* original package is valid once the bundler alias is configured, so it is
+* opt-in through the `strict` preset. `no-unused-content` is absent from every
+* preset — it scans the project from disk, which no preset should impose.
+*/
+const RECOMMENDED_RULES = {
+	"no-raw-text": "warn",
+	"static-dictionary-key": "error",
+	"no-dynamic-field-access": "error"
+};
+/**
+* The `recommended` preset with every rule name prefixed by the plugin
+* namespace — the shape both ESLint flat config and `.oxlintrc.json` expect.
+*
+* `intlayer init` uses this to write the preset into `.oxlintrc.json`, since
+* oxlint resolves a plugin's rules but not its configs.
+*/
+const getRecommendedRules = () => Object.fromEntries(Object.entries(RECOMMENDED_RULES).map(([ruleName, entry]) => [`${PLUGIN_NAMESPACE}/${ruleName}`, entry]));
+
+//#endregion
+exports.GENERATED_OUTPUT_GLOBS = GENERATED_OUTPUT_GLOBS;
+exports.PLUGIN_NAMESPACE = PLUGIN_NAMESPACE;
+exports.PLUGIN_PACKAGE_NAME = PLUGIN_PACKAGE_NAME;
+exports.RECOMMENDED_RULES = RECOMMENDED_RULES;
+exports.getRecommendedRules = getRecommendedRules;
+//# sourceMappingURL=preset.cjs.map

package/dist/cjs/preset.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"preset.cjs","names":[],"sources":["../../src/preset.ts"],"sourcesContent":["import type { Linter } from 'eslint';\nimport type { IntlayerRuleName } from './index';\n\n/** npm package name of this plugin. */\nexport const PLUGIN_PACKAGE_NAME = 'eslint-plugin-intlayer';\n\n/** Prefix the rules are registered under, e.g. `intlayer/no-raw-text`. */\nexport const PLUGIN_NAMESPACE = 'intlayer';\n\n/**\n * Intlayer's generated output, which every preset ignores.\n *\n * `.intlayer/` holds compiled dictionaries and generated types — machine-written\n * files that are never source. Linting them is at best wasted work and at worst\n * a hard failure, since third-party rules can crash on generated shapes they\n * were never meant to see. The rest of the toolchain already excludes this\n * directory (`content.watchExclude`, the build globs), so the lint preset\n * matches.\n */\nexport const GENERATED_OUTPUT_GLOBS = ['**/.intlayer/**'];\n\n/**\n * Rules enabled by the `recommended` preset, keyed by unprefixed rule name.\n *\n * Exported because oxlint resolves a plugin's *rules* but not its shipped\n * *configs*: `intlayer init` reads this to spell the preset out explicitly in\n * `.oxlintrc.json`. Keeping the definition next to the rules it names means\n * enabling one by default is a single-line change.\n *\n * `no-raw-text` stays a warning on purpose — pointed at an existing codebase it\n * surfaces every untranslated string at once, which should not break a build on\n * day one. `enforce-adapter-import` is deliberately absent: importing from the\n * original package is valid once the bundler alias is configured, so it is\n * opt-in through the `strict` preset. `no-unused-content` is absent from every\n * preset — it scans the project from disk, which no preset should impose.\n */\nexport const RECOMMENDED_RULES: Partial<\n  Record<IntlayerRuleName, Linter.RuleEntry>\n> = {\n  'no-raw-text': 'warn',\n  'static-dictionary-key': 'error',\n  'no-dynamic-field-access': 'error',\n};\n\n/**\n * The `recommended` preset with every rule name prefixed by the plugin\n * namespace — the shape both ESLint flat config and `.oxlintrc.json` expect.\n *\n * `intlayer init` uses this to write the preset into `.oxlintrc.json`, since\n * oxlint resolves a plugin's rules but not its configs.\n */\nexport const getRecommendedRules = (): Record<string, Linter.RuleEntry> =>\n  Object.fromEntries(\n    Object.entries(RECOMMENDED_RULES).map(([ruleName, entry]) => [\n      `${PLUGIN_NAMESPACE}/${ruleName}`,\n      entry,\n    ])\n  );\n"],"mappings":";;;AAIA,MAAa,sBAAsB;;AAGnC,MAAa,mBAAmB;;;;;;;;;;;AAYhC,MAAa,yBAAyB,CAAC,iBAAiB;;;;;;;;;;;;;;;;AAiBxD,MAAa,oBAET;CACF,eAAe;CACf,yBAAyB;CACzB,2BAA2B;AAC7B;;;;;;;;AASA,MAAa,4BACX,OAAO,YACL,OAAO,QAAQ,iBAAiB,CAAC,CAAC,KAAK,CAAC,UAAU,WAAW,CAC3D,GAAG,iBAAiB,GAAG,YACvB,KACF,CAAC,CACH"}

package/dist/cjs/rules/enforceAdapterImport.cjs

@@ -6,20 +6,27 @@ 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.
+* Original third-party library specifier → the `@intlayer/*` adapter that
+* replaces it, e.g. `next-intl` → `@intlayer/next-intl`.
 *
 * 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.
 *
+* Built from `COMPAT_CALLERS` only, never `ALL_CALLERS`. Intlayer's own packages
+* are not a migration pair: `BASE_CALLERS` lists `intlayer` alongside
+* `@intlayer/core` because `getIntlayer` is importable from both, and treating
+* the scoped one as an "adapter" would tell users to rewrite ordinary
+* `from 'intlayer'` imports.
+*
 * 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) {
+	for (const descriptor of _intlayer_config_callers.COMPAT_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));