eslint-plugin-intlayer 9.3.1 → 9.3.2

package/dist/esm/utils/projectUsage.mjs

@@ -0,0 +1,433 @@
+import { __require } from "../_virtual/_rolldown/runtime.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, extname, join, resolve } from "node:path";
+
+//#region src/utils/projectUsage.ts
+/** `require` resolved from this package — the fallback when the host project cannot resolve a module. */
+const packageRequire = typeof import.meta.url === "string" ? createRequire(import.meta.url) : __require;
+/**
+* Require a module from the linted project first, falling back to this
+* package's own resolution.
+*
+* Preferring the project copy keeps the analyser in step with the Intlayer
+* version the project actually builds with; the fallback covers strict
+* `node_modules` layouts (pnpm) where the plugin's own dependencies are not
+* hoisted into the project tree.
+*
+* @param moduleName - Specifier to resolve.
+* @param baseDir - Directory the project resolution starts from.
+*/
+const requireFromProject = (moduleName, baseDir) => {
+	try {
+		return createRequire(join(baseDir, "noop.js"))(moduleName);
+	} catch {}
+	try {
+		return packageRequire(moduleName);
+	} catch {
+		return null;
+	}
+};
+/**
+* Extensions the `@intlayer/lsp` analyser parses directly.
+*
+* Single-file components (`.vue`, `.svelte`, `.astro`) hold their script in a
+* markup wrapper the parser rejects, so they take the conservative path below
+* instead of being silently read as "uses nothing".
+*/
+const ANALYZABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+/** Extensions stripped when comparing an import specifier to a file path. */
+const MODULE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".vue",
+	".svelte",
+	".astro"
+];
+/**
+* Drop the module extension from a path so `./home.content` and
+* `/project/src/home.content.ts` compare equal.
+*
+* @param filePath - Absolute or relative path.
+*/
+const stripModuleExtension = (filePath) => {
+	const extension = extname(filePath);
+	return MODULE_EXTENSIONS.includes(extension) ? filePath.slice(0, -extension.length) : filePath;
+};
+/**
+* Relative import specifiers, covering the static form, dynamic `import()` and
+* `require()`. Bare specifiers are ignored: a content declaration is always
+* reached through a relative path or an alias, and alias resolution would need
+* the project's TypeScript configuration.
+*/
+const RELATIVE_IMPORT_REGEX = /(?:from|import|require)\s*\(?\s*['"](\.{1,2}\/[^'"]+)['"]/g;
+/**
+* `nest("other-dictionary")` inside a content declaration.
+*
+* Nesting is the one way a dictionary is consumed from another *content* file,
+* and content files are excluded from the usage scan — without this the nested
+* dictionary would look unreferenced.
+*/
+const NEST_CALL_REGEX = /\bnest\s*(?:<[^<>()]*>)?\s*\(\s*['"`]([^'"`]+)['"`]/g;
+/**
+* Dictionary keys passed to a caller, for the conservative fallback.
+*
+* Built from the shared caller registry so it recognises the compat adapters
+* too, and matched against files the precise analyser could not read.
+*
+* @param callerNamesAlternation - `useIntlayer|useTranslations|…`.
+*/
+const buildFallbackKeyRegex = (callerNamesAlternation) => new RegExp(`\\b(?:${callerNamesAlternation})\\b\\s*(?:<[^<>()]*>)?\\s*\\(\\s*(?:['"\`]([^'"\`]+)['"\`]|\\{[^{}]*?(?:id|namespace)\\s*:\\s*['"\`]([^'"\`]+)['"\`])`, "g");
+/**
+* Cheap pre-filter: does this file mention any caller at all?
+*
+* @param callerNamesAlternation - `useIntlayer|useTranslations|…`.
+*/
+const buildCallerMentionRegex = (callerNamesAlternation) => new RegExp(`\\b(?:${callerNamesAlternation})\\b`);
+const configurationCache = /* @__PURE__ */ new Map();
+const usageIndexCache = /* @__PURE__ */ new Map();
+/** An index that reports nothing, used whenever the scan cannot run. */
+const UNAVAILABLE_INDEX = {
+	byDictionaryKey: /* @__PURE__ */ new Map(),
+	importedModulePaths: /* @__PURE__ */ new Set(),
+	isAvailable: false
+};
+/**
+* Read a cache entry that has not outlived `cacheTtlMs`.
+*
+* @param cache - The cache to read.
+* @param cacheKey - Entry key.
+* @param cacheTtlMs - Lifetime in milliseconds; `0` disables caching entirely.
+*/
+const readCache = (cache, cacheKey, cacheTtlMs) => {
+	if (cacheTtlMs <= 0) return void 0;
+	const entry = cache.get(cacheKey);
+	if (!entry) return void 0;
+	if (Date.now() - entry.builtAt > cacheTtlMs) {
+		cache.delete(cacheKey);
+		return;
+	}
+	return entry.value;
+};
+/** Drop every cached configuration and usage index. Exposed for tests. */
+const clearProjectUsageCache = () => {
+	configurationCache.clear();
+	usageIndexCache.clear();
+};
+/**
+* Load the Intlayer configuration for a project, or `null` when it cannot be
+* read — a project without Intlayer installed must not break the lint run.
+*
+* @param baseDir - Project root, normally ESLint's working directory.
+* @param cacheTtlMs - Lifetime of the cached configuration.
+*/
+const getProjectConfiguration = (baseDir, cacheTtlMs) => {
+	const cached = readCache(configurationCache, baseDir, cacheTtlMs);
+	if (cached !== void 0) return cached;
+	const configLoader = requireFromProject("@intlayer/config/node", baseDir);
+	let configuration = null;
+	try {
+		configuration = configLoader?.getConfiguration({ baseDir }) ?? null;
+	} catch {
+		configuration = null;
+	}
+	configurationCache.set(baseDir, {
+		builtAt: Date.now(),
+		value: configuration
+	});
+	return configuration;
+};
+/**
+* Translate the configuration into the globs the scan runs, mirroring how the
+* build pipeline decides which files are project source.
+*
+* Content declarations are excluded from the source scan — a dictionary must
+* not count as its own consumer — and globbed separately for `nest()` calls.
+*
+* @param configuration - The project configuration.
+*/
+const getScanTargets = (configuration) => {
+	const { transformPattern } = configuration.compiler ?? {};
+	const compilerPatterns = transformPattern ? Array.isArray(transformPattern) ? transformPattern : [transformPattern] : [];
+	const allPatterns = [...configuration.build.traversePattern ?? [], ...compilerPatterns];
+	const contentFilePatterns = (configuration.content.fileExtensions ?? []).map((extension) => `**/*${extension}`);
+	const roots = [configuration.system.baseDir, ...configuration.content.codeDir ?? []].map((root) => resolve(root));
+	return {
+		roots: [...new Set(roots)],
+		includePatterns: allPatterns.filter((pattern) => !pattern.startsWith("!")),
+		excludePatterns: [...allPatterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1)), ...contentFilePatterns],
+		contentFilePatterns
+	};
+};
+/**
+* List the files matching `patterns` under every root, de-duplicated.
+*
+* @param glob - The lazily required `fast-glob`.
+* @param targets - Roots to walk.
+* @param patterns - Patterns to include.
+* @param excludePatterns - Patterns to skip.
+*/
+const listFiles = (glob, targets, patterns, excludePatterns) => {
+	if (patterns.length === 0) return [];
+	const files = /* @__PURE__ */ new Set();
+	for (const root of targets.roots) {
+		if (!existsSync(root)) continue;
+		try {
+			for (const file of glob.sync(patterns, {
+				cwd: root,
+				ignore: excludePatterns,
+				absolute: true,
+				dot: false,
+				followSymbolicLinks: false
+			})) files.add(file);
+		} catch {}
+	}
+	return [...files];
+};
+/**
+* The usage record for `dictionaryKey`, created on first sight.
+*
+* @param index - Index being built.
+* @param dictionaryKey - Key to look up.
+*/
+const getOrCreateUsage = (index, dictionaryKey) => {
+	const existing = index.byDictionaryKey.get(dictionaryKey);
+	if (existing) return existing;
+	const created = {
+		usedFieldPaths: /* @__PURE__ */ new Set(),
+		tracksEveryField: false
+	};
+	index.byDictionaryKey.set(dictionaryKey, created);
+	return created;
+};
+/**
+* Record a read of `fieldPath`, marking every parent prefix used as well:
+* reading `hero.title` means the `hero` object is read too.
+*
+* @param usage - The record to update.
+* @param fieldPath - Field path segments from the content root.
+*/
+const addUsedFieldPath = (usage, fieldPath) => {
+	for (let depth = 1; depth <= fieldPath.length; depth++) usage.usedFieldPaths.add(fieldPath.slice(0, depth).join("."));
+};
+/**
+* Fold one analysed file into the index.
+*
+* Mirrors the VS Code decoration's interpretation of the analyser output: a
+* bare content reference or a bound translator function means any field may be
+* read, and a dictionary referenced without any trackable binding proves only
+* that the dictionary itself is alive.
+*
+* @param index - Index being built.
+* @param usages - Message usages found in the file.
+* @param bindings - Caller bindings found in the file.
+*/
+const foldFileAnalysis = (index, usages, bindings) => {
+	const keysWithFieldUsage = /* @__PURE__ */ new Set();
+	for (const usage of usages) {
+		const record = getOrCreateUsage(index, usage.dictionaryKey);
+		if (usage.kind === "namespace") continue;
+		if (usage.fieldPath.length === 0) {
+			record.tracksEveryField = true;
+			continue;
+		}
+		keysWithFieldUsage.add(usage.dictionaryKey);
+		addUsedFieldPath(record, usage.fieldPath);
+	}
+	const keysWithBinding = /* @__PURE__ */ new Set();
+	for (const binding of bindings) {
+		const record = getOrCreateUsage(index, binding.dictionaryKey);
+		keysWithBinding.add(binding.dictionaryKey);
+		if (binding.bindingKind === "translator") {
+			record.tracksEveryField = true;
+			continue;
+		}
+		if (!keysWithFieldUsage.has(binding.dictionaryKey)) record.tracksEveryField = true;
+	}
+	for (const usage of usages) {
+		if (usage.kind !== "namespace") continue;
+		if (keysWithFieldUsage.has(usage.dictionaryKey)) continue;
+		if (keysWithBinding.has(usage.dictionaryKey)) continue;
+		getOrCreateUsage(index, usage.dictionaryKey).tracksEveryField = true;
+	}
+};
+/**
+* Fold a file the precise analyser could not read — a single-file component, or
+* anything that failed to parse — by marking every dictionary key it mentions
+* as fully used.
+*
+* @param index - Index being built.
+* @param text - File contents.
+* @param fallbackKeyRegex - Key-extraction pattern from the caller registry.
+*/
+const foldFallbackAnalysis = (index, text, fallbackKeyRegex) => {
+	fallbackKeyRegex.lastIndex = 0;
+	let match = fallbackKeyRegex.exec(text);
+	while (match) {
+		const dictionaryKey = match[1] ?? match[2];
+		if (dictionaryKey) {
+			const [rootKey] = dictionaryKey.split(".");
+			getOrCreateUsage(index, rootKey ?? dictionaryKey).tracksEveryField = true;
+		}
+		match = fallbackKeyRegex.exec(text);
+	}
+};
+/**
+* Record every module a file imports through a relative specifier.
+*
+* @param index - Index being built.
+* @param filePath - Absolute path of the importing file.
+* @param text - File contents.
+*/
+const foldImports = (index, filePath, text) => {
+	RELATIVE_IMPORT_REGEX.lastIndex = 0;
+	let match = RELATIVE_IMPORT_REGEX.exec(text);
+	while (match) {
+		const specifier = match[1];
+		if (specifier) {
+			const resolved = resolve(dirname(filePath), specifier);
+			index.importedModulePaths.add(stripModuleExtension(resolved));
+			index.importedModulePaths.add(join(resolved, "index"));
+		}
+		match = RELATIVE_IMPORT_REGEX.exec(text);
+	}
+};
+/**
+* Mark dictionaries pulled in by `nest()` from another content declaration.
+*
+* @param index - Index being built.
+* @param text - Content declaration source.
+*/
+const foldNestedDictionaries = (index, text) => {
+	NEST_CALL_REGEX.lastIndex = 0;
+	let match = NEST_CALL_REGEX.exec(text);
+	while (match) {
+		const dictionaryKey = match[1];
+		if (dictionaryKey) getOrCreateUsage(index, dictionaryKey).tracksEveryField = true;
+		match = NEST_CALL_REGEX.exec(text);
+	}
+};
+/**
+* Scan the project once and aggregate every dictionary reference it contains.
+*
+* @param baseDir - Project root, normally ESLint's working directory.
+* @param cacheTtlMs - Lifetime of the cached index.
+*/
+const getProjectUsageIndex = (baseDir, cacheTtlMs) => {
+	const cached = readCache(usageIndexCache, baseDir, cacheTtlMs);
+	if (cached) return cached;
+	const index = buildProjectUsageIndex(baseDir, cacheTtlMs);
+	usageIndexCache.set(baseDir, {
+		builtAt: Date.now(),
+		value: index
+	});
+	return index;
+};
+/**
+* The uncached body of {@link getProjectUsageIndex}.
+*
+* @param baseDir - Project root.
+* @param cacheTtlMs - Lifetime of the cached configuration.
+*/
+const buildProjectUsageIndex = (baseDir, cacheTtlMs) => {
+	const configuration = getProjectConfiguration(baseDir, cacheTtlMs);
+	if (!configuration) return UNAVAILABLE_INDEX;
+	const analyzer = requireFromProject("@intlayer/lsp/utils", baseDir);
+	const globModule = requireFromProject("fast-glob", baseDir);
+	const glob = globModule?.sync ? globModule : globModule?.default;
+	if (!analyzer || !glob) return UNAVAILABLE_INDEX;
+	const targets = getScanTargets(configuration);
+	const sourceFiles = listFiles(glob, targets, targets.includePatterns, targets.excludePatterns);
+	if (sourceFiles.length === 0) return UNAVAILABLE_INDEX;
+	const callerNamesAlternation = analyzer.getCallerNamesAlternation();
+	const callerMentionRegex = buildCallerMentionRegex(callerNamesAlternation);
+	const fallbackKeyRegex = buildFallbackKeyRegex(callerNamesAlternation);
+	const index = {
+		byDictionaryKey: /* @__PURE__ */ new Map(),
+		importedModulePaths: /* @__PURE__ */ new Set(),
+		isAvailable: true
+	};
+	for (const filePath of sourceFiles) {
+		let text;
+		try {
+			text = readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		foldImports(index, filePath, text);
+		if (!callerMentionRegex.test(text)) continue;
+		if (!ANALYZABLE_EXTENSIONS.has(extname(filePath))) {
+			foldFallbackAnalysis(index, text, fallbackKeyRegex);
+			continue;
+		}
+		const usages = analyzer.collectMessageUsages(text);
+		if (usages.length === 0) {
+			foldFallbackAnalysis(index, text, fallbackKeyRegex);
+			continue;
+		}
+		foldFileAnalysis(index, usages, analyzer.collectCallerBindings(text));
+	}
+	for (const filePath of listFiles(glob, targets, targets.contentFilePatterns, [])) try {
+		foldNestedDictionaries(index, readFileSync(filePath, "utf-8"));
+	} catch {}
+	return index;
+};
+/**
+* Other declarations of the same dictionary key, read from the unmerged
+* dictionaries the build writes to disk.
+*
+* Returns an empty list when the build output is missing — the rule then simply
+* has nothing to say about duplicates.
+*
+* @param configuration - The project configuration.
+* @param dictionaryKey - Key declared by the linted file.
+* @param currentFilePath - Absolute path of the linted file.
+*/
+const getDuplicateDeclarations = (configuration, dictionaryKey, currentFilePath) => {
+	const dictionaryPath = join(configuration.system.unmergedDictionariesDir, `${dictionaryKey}.json`);
+	if (!existsSync(dictionaryPath)) return [];
+	let entries;
+	try {
+		const parsed = JSON.parse(readFileSync(dictionaryPath, "utf-8"));
+		if (!Array.isArray(parsed)) return [];
+		entries = parsed;
+	} catch {
+		return [];
+	}
+	const duplicates = [];
+	for (const entry of entries) {
+		if (entry.location === "remote") {
+			duplicates.push({
+				filePath: "remote",
+				location: "remote"
+			});
+			continue;
+		}
+		if (!entry.filePath) continue;
+		if (resolve(configuration.system.baseDir, entry.filePath) === currentFilePath) continue;
+		duplicates.push({
+			filePath: entry.filePath,
+			location: "local"
+		});
+	}
+	return duplicates;
+};
+
+//#endregion
+export { clearProjectUsageCache, getDuplicateDeclarations, getProjectConfiguration, getProjectUsageIndex, stripModuleExtension };
+//# sourceMappingURL=projectUsage.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"projectUsage.mjs","names":[],"sources":["../../../src/utils/projectUsage.ts"],"sourcesContent":["import { existsSync, readFileSync } from 'node:fs';\nimport { createRequire } from 'node:module';\nimport { dirname, extname, join, resolve } from 'node:path';\nimport type { CallerVariableBinding, MessageUsage } from '@intlayer/lsp/utils';\n\n/**\n * Project-wide dictionary usage, shared by the `no-unused-content` rule.\n *\n * ESLint lints one file at a time and offers no end-of-run hook, so a rule that\n * needs to know whether a *declared* field is read *somewhere else* has to build\n * that knowledge itself. This module does exactly what the VS Code extension's\n * unused-content decoration does — glob the project's source files, run the\n * shared `@intlayer/lsp` analyser over each one, and aggregate the result —\n * behind a process-level cache so the scan happens once per lint run rather\n * than once per content file.\n *\n * Everything here is loaded lazily. The rule is off by default, and a plugin\n * that eagerly pulled a native parser and the config loader into every lint run\n * would tax the projects that never enable it.\n */\n\n// ── Lazily required modules ──────────────────────────────────────────────────\n\n/**\n * True when this file runs from the ESM build. `import.meta.url` is rewritten\n * to a `__filename`-based shim in the CJS build, so both branches below stay\n * correct whichever bundle the host loads.\n */\nconst isEsModule = typeof import.meta.url === 'string';\n\n/** `require` resolved from this package — the fallback when the host project cannot resolve a module. */\nconst packageRequire: NodeJS.Require = isEsModule\n  ? createRequire(import.meta.url)\n  : require;\n\n/**\n * Require a module from the linted project first, falling back to this\n * package's own resolution.\n *\n * Preferring the project copy keeps the analyser in step with the Intlayer\n * version the project actually builds with; the fallback covers strict\n * `node_modules` layouts (pnpm) where the plugin's own dependencies are not\n * hoisted into the project tree.\n *\n * @param moduleName - Specifier to resolve.\n * @param baseDir - Directory the project resolution starts from.\n */\nconst requireFromProject = <ModuleExports>(\n  moduleName: string,\n  baseDir: string\n): ModuleExports | null => {\n  try {\n    return createRequire(join(baseDir, 'noop.js'))(moduleName) as ModuleExports;\n  } catch {\n    // Not resolvable from the project — try this package's own dependencies.\n  }\n\n  try {\n    return packageRequire(moduleName) as ModuleExports;\n  } catch {\n    return null;\n  }\n};\n\n/** The subset of `@intlayer/lsp/utils` this module drives. */\ntype LspAnalyzer = {\n  collectMessageUsages: (text: string) => MessageUsage[];\n  collectCallerBindings: (text: string) => CallerVariableBinding[];\n  getCallerNamesAlternation: () => string;\n};\n\n/** The subset of `@intlayer/config/node` this module drives. */\ntype ConfigLoader = {\n  getConfiguration: (options: { baseDir: string }) => IntlayerProjectConfig;\n};\n\n/** The subset of `fast-glob` this module drives. */\ntype Glob = {\n  sync: (\n    patterns: string[],\n    options: {\n      cwd: string;\n      ignore: string[];\n      absolute: boolean;\n      dot: boolean;\n      followSymbolicLinks: boolean;\n    }\n  ) => string[];\n};\n\n/**\n * The configuration fields the scan reads.\n *\n * Declared structurally rather than imported from `@intlayer/types` so the\n * plugin keeps its single runtime dependency, and so the exact surface this\n * rule depends on stays visible in one place.\n */\nexport type IntlayerProjectConfig = {\n  content: { fileExtensions?: string[]; codeDir?: string[] };\n  build: { traversePattern?: string[] };\n  compiler?: { transformPattern?: string | string[] };\n  system: { baseDir: string; unmergedDictionariesDir: string };\n};\n\n// ── Public shapes ────────────────────────────────────────────────────────────\n\n/** How one dictionary key is consumed across the project. */\nexport type DictionaryUsage = {\n  /**\n   * Dotted content-field paths read somewhere, every parent prefix included —\n   * reading `hero.title` marks `hero` used too.\n   */\n  usedFieldPaths: Set<string>;\n  /**\n   * True when at least one reference consumes the dictionary in a way field\n   * tracking cannot follow: the content object escapes as a whole, a translator\n   * function is bound, or the referencing file could not be parsed. No field of\n   * the dictionary may be reported unused once this is set.\n   */\n  tracksEveryField: boolean;\n};\n\n/** The result of one project scan. */\nexport type ProjectUsageIndex = {\n  /** Every dictionary key referenced by the project, and how. */\n  byDictionaryKey: Map<string, DictionaryUsage>;\n  /**\n   * Extension-less absolute paths of modules imported by the scanned files. A\n   * content declaration reached through a direct import (`useDictionary(myDict)`)\n   * carries no key at the call site, so importing it at all counts as a use.\n   */\n  importedModulePaths: Set<string>;\n  /**\n   * False when the project could not be scanned — no config, no analyser, or no\n   * matching source file. Every report is suppressed in that case rather than\n   * flagging a whole project as unused.\n   */\n  isAvailable: boolean;\n};\n\n/** One other place a dictionary key is declared. */\nexport type DuplicateDeclaration = {\n  /** Path as recorded in the unmerged dictionary, or `'remote'` for CMS entries. */\n  filePath: string;\n  /** Whether the other declaration lives in the project or in the CMS. */\n  location: 'local' | 'remote';\n};\n\n// ── File extensions ──────────────────────────────────────────────────────────\n\n/**\n * Extensions the `@intlayer/lsp` analyser parses directly.\n *\n * Single-file components (`.vue`, `.svelte`, `.astro`) hold their script in a\n * markup wrapper the parser rejects, so they take the conservative path below\n * instead of being silently read as \"uses nothing\".\n */\nconst ANALYZABLE_EXTENSIONS = new Set([\n  '.ts',\n  '.tsx',\n  '.mts',\n  '.cts',\n  '.js',\n  '.jsx',\n  '.mjs',\n  '.cjs',\n]);\n\n/** Extensions stripped when comparing an import specifier to a file path. */\nconst MODULE_EXTENSIONS = [\n  '.ts',\n  '.tsx',\n  '.mts',\n  '.cts',\n  '.js',\n  '.jsx',\n  '.mjs',\n  '.cjs',\n  '.vue',\n  '.svelte',\n  '.astro',\n];\n\n/**\n * Drop the module extension from a path so `./home.content` and\n * `/project/src/home.content.ts` compare equal.\n *\n * @param filePath - Absolute or relative path.\n */\nexport const stripModuleExtension = (filePath: string): string => {\n  const extension = extname(filePath);\n\n  return MODULE_EXTENSIONS.includes(extension)\n    ? filePath.slice(0, -extension.length)\n    : filePath;\n};\n\n// ── Regular expressions ──────────────────────────────────────────────────────\n\n/**\n * Relative import specifiers, covering the static form, dynamic `import()` and\n * `require()`. Bare specifiers are ignored: a content declaration is always\n * reached through a relative path or an alias, and alias resolution would need\n * the project's TypeScript configuration.\n */\nconst RELATIVE_IMPORT_REGEX =\n  /(?:from|import|require)\\s*\\(?\\s*['\"](\\.{1,2}\\/[^'\"]+)['\"]/g;\n\n/**\n * `nest(\"other-dictionary\")` inside a content declaration.\n *\n * Nesting is the one way a dictionary is consumed from another *content* file,\n * and content files are excluded from the usage scan — without this the nested\n * dictionary would look unreferenced.\n */\nconst NEST_CALL_REGEX = /\\bnest\\s*(?:<[^<>()]*>)?\\s*\\(\\s*['\"`]([^'\"`]+)['\"`]/g;\n\n/**\n * Dictionary keys passed to a caller, for the conservative fallback.\n *\n * Built from the shared caller registry so it recognises the compat adapters\n * too, and matched against files the precise analyser could not read.\n *\n * @param callerNamesAlternation - `useIntlayer|useTranslations|…`.\n */\nconst buildFallbackKeyRegex = (callerNamesAlternation: string): RegExp =>\n  new RegExp(\n    `\\\\b(?:${callerNamesAlternation})\\\\b\\\\s*(?:<[^<>()]*>)?\\\\s*\\\\(\\\\s*(?:['\"\\`]([^'\"\\`]+)['\"\\`]|\\\\{[^{}]*?(?:id|namespace)\\\\s*:\\\\s*['\"\\`]([^'\"\\`]+)['\"\\`])`,\n    'g'\n  );\n\n/**\n * Cheap pre-filter: does this file mention any caller at all?\n *\n * @param callerNamesAlternation - `useIntlayer|useTranslations|…`.\n */\nconst buildCallerMentionRegex = (callerNamesAlternation: string): RegExp =>\n  new RegExp(`\\\\b(?:${callerNamesAlternation})\\\\b`);\n\n// ── Caches ───────────────────────────────────────────────────────────────────\n\ntype CacheEntry<Value> = { builtAt: number; value: Value };\n\nconst configurationCache = new Map<\n  string,\n  CacheEntry<IntlayerProjectConfig | null>\n>();\nconst usageIndexCache = new Map<string, CacheEntry<ProjectUsageIndex>>();\n\n/** An index that reports nothing, used whenever the scan cannot run. */\nconst UNAVAILABLE_INDEX: ProjectUsageIndex = {\n  byDictionaryKey: new Map(),\n  importedModulePaths: new Set(),\n  isAvailable: false,\n};\n\n/**\n * Read a cache entry that has not outlived `cacheTtlMs`.\n *\n * @param cache - The cache to read.\n * @param cacheKey - Entry key.\n * @param cacheTtlMs - Lifetime in milliseconds; `0` disables caching entirely.\n */\nconst readCache = <Value>(\n  cache: Map<string, CacheEntry<Value>>,\n  cacheKey: string,\n  cacheTtlMs: number\n): Value | undefined => {\n  if (cacheTtlMs <= 0) return undefined;\n\n  const entry = cache.get(cacheKey);\n\n  if (!entry) return undefined;\n\n  if (Date.now() - entry.builtAt > cacheTtlMs) {\n    cache.delete(cacheKey);\n\n    return undefined;\n  }\n\n  return entry.value;\n};\n\n/** Drop every cached configuration and usage index. Exposed for tests. */\nexport const clearProjectUsageCache = (): void => {\n  configurationCache.clear();\n  usageIndexCache.clear();\n};\n\n// ── Configuration ────────────────────────────────────────────────────────────\n\n/**\n * Load the Intlayer configuration for a project, or `null` when it cannot be\n * read — a project without Intlayer installed must not break the lint run.\n *\n * @param baseDir - Project root, normally ESLint's working directory.\n * @param cacheTtlMs - Lifetime of the cached configuration.\n */\nexport const getProjectConfiguration = (\n  baseDir: string,\n  cacheTtlMs: number\n): IntlayerProjectConfig | null => {\n  const cached = readCache(configurationCache, baseDir, cacheTtlMs);\n\n  if (cached !== undefined) return cached;\n\n  const configLoader = requireFromProject<ConfigLoader>(\n    '@intlayer/config/node',\n    baseDir\n  );\n\n  let configuration: IntlayerProjectConfig | null = null;\n\n  try {\n    configuration = configLoader?.getConfiguration({ baseDir }) ?? null;\n  } catch {\n    configuration = null;\n  }\n\n  configurationCache.set(baseDir, {\n    builtAt: Date.now(),\n    value: configuration,\n  });\n\n  return configuration;\n};\n\n// ── Scanning ─────────────────────────────────────────────────────────────────\n\n/** The glob patterns and roots one project scan walks. */\ntype ScanTargets = {\n  roots: string[];\n  includePatterns: string[];\n  excludePatterns: string[];\n  contentFilePatterns: string[];\n};\n\n/**\n * Translate the configuration into the globs the scan runs, mirroring how the\n * build pipeline decides which files are project source.\n *\n * Content declarations are excluded from the source scan — a dictionary must\n * not count as its own consumer — and globbed separately for `nest()` calls.\n *\n * @param configuration - The project configuration.\n */\nconst getScanTargets = (configuration: IntlayerProjectConfig): ScanTargets => {\n  const { transformPattern } = configuration.compiler ?? {};\n\n  const compilerPatterns = transformPattern\n    ? Array.isArray(transformPattern)\n      ? transformPattern\n      : [transformPattern]\n    : [];\n\n  const allPatterns = [\n    ...(configuration.build.traversePattern ?? []),\n    ...compilerPatterns,\n  ];\n\n  const contentFilePatterns = (configuration.content.fileExtensions ?? []).map(\n    (extension) => `**/*${extension}`\n  );\n\n  const roots = [\n    configuration.system.baseDir,\n    ...(configuration.content.codeDir ?? []),\n  ].map((root) => resolve(root));\n\n  return {\n    roots: [...new Set(roots)],\n    includePatterns: allPatterns.filter((pattern) => !pattern.startsWith('!')),\n    excludePatterns: [\n      ...allPatterns\n        .filter((pattern) => pattern.startsWith('!'))\n        .map((pattern) => pattern.slice(1)),\n      ...contentFilePatterns,\n    ],\n    contentFilePatterns,\n  };\n};\n\n/**\n * List the files matching `patterns` under every root, de-duplicated.\n *\n * @param glob - The lazily required `fast-glob`.\n * @param targets - Roots to walk.\n * @param patterns - Patterns to include.\n * @param excludePatterns - Patterns to skip.\n */\nconst listFiles = (\n  glob: Glob,\n  targets: ScanTargets,\n  patterns: string[],\n  excludePatterns: string[]\n): string[] => {\n  if (patterns.length === 0) return [];\n\n  const files = new Set<string>();\n\n  for (const root of targets.roots) {\n    if (!existsSync(root)) continue;\n\n    try {\n      for (const file of glob.sync(patterns, {\n        cwd: root,\n        ignore: excludePatterns,\n        absolute: true,\n        dot: false,\n        followSymbolicLinks: false,\n      })) {\n        files.add(file);\n      }\n    } catch {\n      // An unreadable root contributes nothing; the rest of the scan stands.\n    }\n  }\n\n  return [...files];\n};\n\n/**\n * The usage record for `dictionaryKey`, created on first sight.\n *\n * @param index - Index being built.\n * @param dictionaryKey - Key to look up.\n */\nconst getOrCreateUsage = (\n  index: ProjectUsageIndex,\n  dictionaryKey: string\n): DictionaryUsage => {\n  const existing = index.byDictionaryKey.get(dictionaryKey);\n\n  if (existing) return existing;\n\n  const created: DictionaryUsage = {\n    usedFieldPaths: new Set(),\n    tracksEveryField: false,\n  };\n\n  index.byDictionaryKey.set(dictionaryKey, created);\n\n  return created;\n};\n\n/**\n * Record a read of `fieldPath`, marking every parent prefix used as well:\n * reading `hero.title` means the `hero` object is read too.\n *\n * @param usage - The record to update.\n * @param fieldPath - Field path segments from the content root.\n */\nconst addUsedFieldPath = (\n  usage: DictionaryUsage,\n  fieldPath: string[]\n): void => {\n  for (let depth = 1; depth <= fieldPath.length; depth++) {\n    usage.usedFieldPaths.add(fieldPath.slice(0, depth).join('.'));\n  }\n};\n\n/**\n * Fold one analysed file into the index.\n *\n * Mirrors the VS Code decoration's interpretation of the analyser output: a\n * bare content reference or a bound translator function means any field may be\n * read, and a dictionary referenced without any trackable binding proves only\n * that the dictionary itself is alive.\n *\n * @param index - Index being built.\n * @param usages - Message usages found in the file.\n * @param bindings - Caller bindings found in the file.\n */\nconst foldFileAnalysis = (\n  index: ProjectUsageIndex,\n  usages: MessageUsage[],\n  bindings: CallerVariableBinding[]\n): void => {\n  const keysWithFieldUsage = new Set<string>();\n\n  for (const usage of usages) {\n    const record = getOrCreateUsage(index, usage.dictionaryKey);\n\n    if (usage.kind === 'namespace') continue;\n\n    if (usage.fieldPath.length === 0) {\n      // The content object itself is consumed — any field may be read from it.\n      record.tracksEveryField = true;\n      continue;\n    }\n\n    keysWithFieldUsage.add(usage.dictionaryKey);\n    addUsedFieldPath(record, usage.fieldPath);\n  }\n\n  const keysWithBinding = new Set<string>();\n\n  for (const binding of bindings) {\n    const record = getOrCreateUsage(index, binding.dictionaryKey);\n\n    keysWithBinding.add(binding.dictionaryKey);\n\n    // A translator function may be forwarded, called with a computed key, or\n    // used inside a template region the parser never saw.\n    if (binding.bindingKind === 'translator') {\n      record.tracksEveryField = true;\n      continue;\n    }\n\n    // A content binding whose fields were never seen being read means the reads\n    // happen somewhere this analysis cannot follow.\n    if (!keysWithFieldUsage.has(binding.dictionaryKey)) {\n      record.tracksEveryField = true;\n    }\n  }\n\n  // A dictionary this file names but neither binds nor reads a field from — a\n  // bare `useIntlayer('home')` statement — proves existence only. The test is\n  // deliberately per file: what another file did with the same key says nothing\n  // about what this one does with it.\n  for (const usage of usages) {\n    if (usage.kind !== 'namespace') continue;\n\n    if (keysWithFieldUsage.has(usage.dictionaryKey)) continue;\n\n    if (keysWithBinding.has(usage.dictionaryKey)) continue;\n\n    getOrCreateUsage(index, usage.dictionaryKey).tracksEveryField = true;\n  }\n};\n\n/**\n * Fold a file the precise analyser could not read — a single-file component, or\n * anything that failed to parse — by marking every dictionary key it mentions\n * as fully used.\n *\n * @param index - Index being built.\n * @param text - File contents.\n * @param fallbackKeyRegex - Key-extraction pattern from the caller registry.\n */\nconst foldFallbackAnalysis = (\n  index: ProjectUsageIndex,\n  text: string,\n  fallbackKeyRegex: RegExp\n): void => {\n  fallbackKeyRegex.lastIndex = 0;\n\n  let match = fallbackKeyRegex.exec(text);\n\n  while (match) {\n    const dictionaryKey = match[1] ?? match[2];\n\n    if (dictionaryKey) {\n      // `formatMessage({ id: 'home.title' })` addresses a field through the key.\n      const [rootKey] = dictionaryKey.split('.');\n\n      getOrCreateUsage(index, rootKey ?? dictionaryKey).tracksEveryField = true;\n    }\n\n    match = fallbackKeyRegex.exec(text);\n  }\n};\n\n/**\n * Record every module a file imports through a relative specifier.\n *\n * @param index - Index being built.\n * @param filePath - Absolute path of the importing file.\n * @param text - File contents.\n */\nconst foldImports = (\n  index: ProjectUsageIndex,\n  filePath: string,\n  text: string\n): void => {\n  RELATIVE_IMPORT_REGEX.lastIndex = 0;\n\n  let match = RELATIVE_IMPORT_REGEX.exec(text);\n\n  while (match) {\n    const specifier = match[1];\n\n    if (specifier) {\n      const resolved = resolve(dirname(filePath), specifier);\n\n      index.importedModulePaths.add(stripModuleExtension(resolved));\n      // `import './home'` may resolve to `./home/index.ts`.\n      index.importedModulePaths.add(join(resolved, 'index'));\n    }\n\n    match = RELATIVE_IMPORT_REGEX.exec(text);\n  }\n};\n\n/**\n * Mark dictionaries pulled in by `nest()` from another content declaration.\n *\n * @param index - Index being built.\n * @param text - Content declaration source.\n */\nconst foldNestedDictionaries = (\n  index: ProjectUsageIndex,\n  text: string\n): void => {\n  NEST_CALL_REGEX.lastIndex = 0;\n\n  let match = NEST_CALL_REGEX.exec(text);\n\n  while (match) {\n    const dictionaryKey = match[1];\n\n    if (dictionaryKey) {\n      // `nest('home', 'hero.title')` still keeps the whole subtree reachable.\n      getOrCreateUsage(index, dictionaryKey).tracksEveryField = true;\n    }\n\n    match = NEST_CALL_REGEX.exec(text);\n  }\n};\n\n/**\n * Scan the project once and aggregate every dictionary reference it contains.\n *\n * @param baseDir - Project root, normally ESLint's working directory.\n * @param cacheTtlMs - Lifetime of the cached index.\n */\nexport const getProjectUsageIndex = (\n  baseDir: string,\n  cacheTtlMs: number\n): ProjectUsageIndex => {\n  const cached = readCache(usageIndexCache, baseDir, cacheTtlMs);\n\n  if (cached) return cached;\n\n  const index = buildProjectUsageIndex(baseDir, cacheTtlMs);\n\n  usageIndexCache.set(baseDir, { builtAt: Date.now(), value: index });\n\n  return index;\n};\n\n/**\n * The uncached body of {@link getProjectUsageIndex}.\n *\n * @param baseDir - Project root.\n * @param cacheTtlMs - Lifetime of the cached configuration.\n */\nconst buildProjectUsageIndex = (\n  baseDir: string,\n  cacheTtlMs: number\n): ProjectUsageIndex => {\n  const configuration = getProjectConfiguration(baseDir, cacheTtlMs);\n\n  if (!configuration) return UNAVAILABLE_INDEX;\n\n  const analyzer = requireFromProject<LspAnalyzer>(\n    '@intlayer/lsp/utils',\n    baseDir\n  );\n  // `fast-glob` is CJS, but an interop wrapper may still hand back a namespace\n  // object whose callable module sits on `default`.\n  const globModule = requireFromProject<Glob & { default?: Glob }>(\n    'fast-glob',\n    baseDir\n  );\n  const glob = globModule?.sync ? globModule : globModule?.default;\n\n  if (!analyzer || !glob) return UNAVAILABLE_INDEX;\n\n  const targets = getScanTargets(configuration);\n  const sourceFiles = listFiles(\n    glob,\n    targets,\n    targets.includePatterns,\n    targets.excludePatterns\n  );\n\n  if (sourceFiles.length === 0) return UNAVAILABLE_INDEX;\n\n  const callerNamesAlternation = analyzer.getCallerNamesAlternation();\n  const callerMentionRegex = buildCallerMentionRegex(callerNamesAlternation);\n  const fallbackKeyRegex = buildFallbackKeyRegex(callerNamesAlternation);\n\n  const index: ProjectUsageIndex = {\n    byDictionaryKey: new Map(),\n    importedModulePaths: new Set(),\n    isAvailable: true,\n  };\n\n  for (const filePath of sourceFiles) {\n    let text: string;\n\n    try {\n      text = readFileSync(filePath, 'utf-8');\n    } catch {\n      continue; // Unreadable file — nothing to learn from it.\n    }\n\n    foldImports(index, filePath, text);\n\n    if (!callerMentionRegex.test(text)) continue;\n\n    if (!ANALYZABLE_EXTENSIONS.has(extname(filePath))) {\n      foldFallbackAnalysis(index, text, fallbackKeyRegex);\n      continue;\n    }\n\n    const usages = analyzer.collectMessageUsages(text);\n\n    if (usages.length === 0) {\n      // The file names a caller but the parser found nothing: either the parse\n      // failed or the call lives in a region the parser skipped. Stay safe.\n      foldFallbackAnalysis(index, text, fallbackKeyRegex);\n      continue;\n    }\n\n    foldFileAnalysis(index, usages, analyzer.collectCallerBindings(text));\n  }\n\n  for (const filePath of listFiles(\n    glob,\n    targets,\n    targets.contentFilePatterns,\n    []\n  )) {\n    try {\n      foldNestedDictionaries(index, readFileSync(filePath, 'utf-8'));\n    } catch {\n      // Unreadable content declaration — nothing to learn from it.\n    }\n  }\n\n  return index;\n};\n\n// ── Duplicate declarations ───────────────────────────────────────────────────\n\n/** One entry of an unmerged dictionary file, reduced to the fields read here. */\ntype UnmergedDictionaryEntry = {\n  filePath?: string;\n  location?: string;\n};\n\n/**\n * Other declarations of the same dictionary key, read from the unmerged\n * dictionaries the build writes to disk.\n *\n * Returns an empty list when the build output is missing — the rule then simply\n * has nothing to say about duplicates.\n *\n * @param configuration - The project configuration.\n * @param dictionaryKey - Key declared by the linted file.\n * @param currentFilePath - Absolute path of the linted file.\n */\nexport const getDuplicateDeclarations = (\n  configuration: IntlayerProjectConfig,\n  dictionaryKey: string,\n  currentFilePath: string\n): DuplicateDeclaration[] => {\n  const dictionaryPath = join(\n    configuration.system.unmergedDictionariesDir,\n    `${dictionaryKey}.json`\n  );\n\n  if (!existsSync(dictionaryPath)) return [];\n\n  let entries: UnmergedDictionaryEntry[];\n\n  try {\n    const parsed: unknown = JSON.parse(readFileSync(dictionaryPath, 'utf-8'));\n\n    if (!Array.isArray(parsed)) return [];\n\n    entries = parsed as UnmergedDictionaryEntry[];\n  } catch {\n    return [];\n  }\n\n  const duplicates: DuplicateDeclaration[] = [];\n\n  for (const entry of entries) {\n    if (entry.location === 'remote') {\n      duplicates.push({ filePath: 'remote', location: 'remote' });\n      continue;\n    }\n\n    if (!entry.filePath) continue;\n\n    if (\n      resolve(configuration.system.baseDir, entry.filePath) === currentFilePath\n    ) {\n      continue;\n    }\n\n    duplicates.push({ filePath: entry.filePath, location: 'local' });\n  }\n\n  return duplicates;\n};\n"],"mappings":"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"}

package/dist/esm/utils/reactVersion.mjs

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import path from "node:path";
+
+//#region src/utils/reactVersion.ts
+/**
+* Detect the installed React version for ESLint configuration.
+*
+* `eslint-plugin-react` versions <= 7.37.5 rely on `context.getFilename()` to detect
+* the React version when `settings.react.version` is set to `"detect"`.
+* Because ESLint 10 removed `context.getFilename()`, every `react/*` rule throws on load
+* when `settings.react.version` is `"detect"`.
+*
+* Specifying an explicit detected React version in `settings.react.version`
+* bypasses the broken `detectReactVersion` codepath in `eslint-plugin-react`, allowing
+* Next.js and React projects using `eslint-config-next` / `eslint-plugin-react` to work
+* seamlessly under both ESLint 9 and ESLint 10 without needing manual configuration hacks.
+*/
+const getReactVersion = (dir = process.cwd()) => {
+	try {
+		let currentDir = dir;
+		while (currentDir) {
+			const reactPkgPath = path.join(currentDir, "node_modules", "react", "package.json");
+			if (fs.existsSync(reactPkgPath)) {
+				const pkg = JSON.parse(fs.readFileSync(reactPkgPath, "utf8"));
+				if (pkg.version) return pkg.version;
+			}
+			const pkgJsonPath = path.join(currentDir, "package.json");
+			if (fs.existsSync(pkgJsonPath)) {
+				const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+				const reactDep = pkg.dependencies?.react || pkg.devDependencies?.react || pkg.peerDependencies?.react;
+				if (typeof reactDep === "string") {
+					const match = reactDep.match(/\d+(\.\d+)*/);
+					if (match) return match[0];
+				}
+			}
+			const parentDir = path.dirname(currentDir);
+			if (parentDir === currentDir) break;
+			currentDir = parentDir;
+		}
+	} catch {}
+	return "19.0";
+};
+
+//#endregion
+export { getReactVersion };
+//# sourceMappingURL=reactVersion.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reactVersion.mjs","names":[],"sources":["../../../src/utils/reactVersion.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\n\n/**\n * Detect the installed React version for ESLint configuration.\n *\n * `eslint-plugin-react` versions <= 7.37.5 rely on `context.getFilename()` to detect\n * the React version when `settings.react.version` is set to `\"detect\"`.\n * Because ESLint 10 removed `context.getFilename()`, every `react/*` rule throws on load\n * when `settings.react.version` is `\"detect\"`.\n *\n * Specifying an explicit detected React version in `settings.react.version`\n * bypasses the broken `detectReactVersion` codepath in `eslint-plugin-react`, allowing\n * Next.js and React projects using `eslint-config-next` / `eslint-plugin-react` to work\n * seamlessly under both ESLint 9 and ESLint 10 without needing manual configuration hacks.\n */\nexport const getReactVersion = (dir = process.cwd()): string => {\n  try {\n    let currentDir = dir;\n    while (currentDir) {\n      const reactPkgPath = path.join(\n        currentDir,\n        'node_modules',\n        'react',\n        'package.json'\n      );\n      if (fs.existsSync(reactPkgPath)) {\n        const pkg = JSON.parse(fs.readFileSync(reactPkgPath, 'utf8'));\n        if (pkg.version) {\n          return pkg.version;\n        }\n      }\n\n      const pkgJsonPath = path.join(currentDir, 'package.json');\n      if (fs.existsSync(pkgJsonPath)) {\n        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));\n        const reactDep =\n          pkg.dependencies?.react ||\n          pkg.devDependencies?.react ||\n          pkg.peerDependencies?.react;\n        if (typeof reactDep === 'string') {\n          const match = reactDep.match(/\\d+(\\.\\d+)*/);\n          if (match) {\n            return match[0];\n          }\n        }\n      }\n\n      const parentDir = path.dirname(currentDir);\n      if (parentDir === currentDir) break;\n      currentDir = parentDir;\n    }\n  } catch {}\n\n  return '19.0';\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,MAAa,mBAAmB,MAAM,QAAQ,IAAI,MAAc;CAC9D,IAAI;EACF,IAAI,aAAa;EACjB,OAAO,YAAY;GACjB,MAAM,eAAe,KAAK,KACxB,YACA,gBACA,SACA,cACF;GACA,IAAI,GAAG,WAAW,YAAY,GAAG;IAC/B,MAAM,MAAM,KAAK,MAAM,GAAG,aAAa,cAAc,MAAM,CAAC;IAC5D,IAAI,IAAI,SACN,OAAO,IAAI;GAEf;GAEA,MAAM,cAAc,KAAK,KAAK,YAAY,cAAc;GACxD,IAAI,GAAG,WAAW,WAAW,GAAG;IAC9B,MAAM,MAAM,KAAK,MAAM,GAAG,aAAa,aAAa,MAAM,CAAC;IAC3D,MAAM,WACJ,IAAI,cAAc,SAClB,IAAI,iBAAiB,SACrB,IAAI,kBAAkB;IACxB,IAAI,OAAO,aAAa,UAAU;KAChC,MAAM,QAAQ,SAAS,MAAM,aAAa;KAC1C,IAAI,OACF,OAAO,MAAM;IAEjB;GACF;GAEA,MAAM,YAAY,KAAK,QAAQ,UAAU;GACzC,IAAI,cAAc,YAAY;GAC9B,aAAa;EACf;CACF,QAAQ,CAAC;CAET,OAAO;AACT"}

package/dist/types/index.d.ts

@@ -1,17 +1,23 @@
 import { IntlayerRule } from "./utils/createRule.js";
+import { GENERATED_OUTPUT_GLOBS, PLUGIN_NAMESPACE, PLUGIN_PACKAGE_NAME, RECOMMENDED_RULES, getRecommendedRules } from "./preset.js";
 import { NoRawTextOptions } from "./rules/noRawText.js";
+import { NoUnusedContentOptions } from "./rules/noUnusedContent.js";
+import { getReactVersion } from "./utils/reactVersion.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:
+ * 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
@@ -23,6 +29,7 @@ declare const rules: {
   'static-dictionary-key': IntlayerRule<[], "dynamicKey" | "dynamicTemplateKey" | "dynamicJsxKey">;
   'no-dynamic-field-access': IntlayerRule<[], "dynamicField" | "dynamicMessageId">;
   'enforce-adapter-import': IntlayerRule<[], "useAdapterImport">;
+  'no-unused-content': IntlayerRule<[NoUnusedContentOptions?], "unusedDictionary" | "unusedField" | "duplicateDictionary">;
 };
 /** Rule names this plugin exposes. */
 type IntlayerRuleName = keyof typeof rules;
@@ -38,7 +45,7 @@ type IntlayerConfigName = 'recommended' | 'strict' | 'contract-only';
  * ```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`
@@ -50,18 +57,24 @@ type IntlayerConfigName = 'recommended' | 'strict' | 'contract-only';
  * `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.
  */
-declare const configs: Record<IntlayerConfigName, Linter.Config>;
+declare const configs: Record<IntlayerConfigName, Linter.Config[]>;
 /** The plugin object, as consumed by `eslint.config.js`. */
-type IntlayerPlugin = ESLint.Plugin & {
+type IntlayerPlugin = ESLint.Plugin & Iterable<Linter.Config> & {
   meta: {
     name: string;
     version: string;
   };
   rules: typeof rules;
-  configs: Record<IntlayerConfigName, Linter.Config>;
+  configs: Record<IntlayerConfigName, Linter.Config[]>;
 };
 declare const intlayerPlugin: IntlayerPlugin;
 //#endregion
-export { IntlayerConfigName, IntlayerPlugin, IntlayerRuleName, type NoRawTextOptions, configs, intlayerPlugin as default, meta, rules };
+export { GENERATED_OUTPUT_GLOBS, IntlayerConfigName, IntlayerPlugin, IntlayerRuleName, type NoRawTextOptions, type NoUnusedContentOptions, PLUGIN_NAMESPACE, PLUGIN_PACKAGE_NAME, RECOMMENDED_RULES, configs, intlayerPlugin as default, getReactVersion, getRecommendedRules, meta, rules };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cA+Ba;+BAAA;;;;;;;KASD,gCAAgC;cAEtC;EAAQ;EAAc;;;KAQhB;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DC,SAAS,OAAO,oBAAoB,OAAO;;KA2B5C,iBAAiB,OAAO,SAClC,SAAS,OAAO;EACd;IAAQ;IAAc;;EACtB,cAAc;EACd,SAAS,OAAO,oBAAoB,OAAO;;cAGzC,gBAAgB"}