eslint-plugin-intlayer 9.3.1 → 9.3.3

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

@@ -0,0 +1,33 @@
+import { IntlayerRule } from "../utils/createRule.js";
+//#region src/rules/noUnusedContent.d.ts
+type NoUnusedContentOptions = {
+  /** Report a dictionary whose key is never referenced anywhere. Default: `true`. */
+  reportUnusedDictionaries?: boolean;
+  /** Report a content field that is never read anywhere. Default: `true`. */
+  reportUnusedFields?: boolean;
+  /**
+   * Report a dictionary key that is also declared elsewhere. Needs the unmerged
+   * dictionaries on disk, so it stays silent until the project has been built.
+   * Default: `true`.
+   */
+  reportDuplicateKeys?: boolean;
+  /** Regular-expression sources for field paths that are never reported. */
+  ignoreFields?: string[];
+  /**
+   * Project root the scan starts from. Defaults to ESLint's working directory,
+   * which is the right answer unless one lint run spans several Intlayer
+   * projects in a monorepo.
+   */
+  baseDir?: string;
+  /**
+   * How long one project scan is reused, in milliseconds. Lower it when linting
+   * from a long-lived editor server and you want edits reflected sooner; `0`
+   * rescans on every file. Default: `30000`.
+   */
+  cacheTtl?: number;
+};
+type MessageIds = 'unusedDictionary' | 'unusedField' | 'duplicateDictionary';
+declare const noUnusedContent: IntlayerRule<[NoUnusedContentOptions?], MessageIds>;
+//#endregion
+export { NoUnusedContentOptions, noUnusedContent };
+//# sourceMappingURL=noUnusedContent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"noUnusedContent.d.ts","names":[],"sources":["../../../src/rules/noUnusedContent.ts"],"mappings":";;KAmBY;;EAEV;;EAEA;;;;;;EAMA;;EAEA;;;;;;EAMA;;;;;;EAMA;;KAGG;cAsDQ,iBAAe,cAAA,0BAAA"}

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

@@ -1,4 +1,4 @@
-import { Node } from "/Users/aymericpineau/Documents/intlayer_/node_modules/.bun/@types+estree@1.0.9/node_modules/@types/estree/index.js";
+import { Node } from "../node_modules/.bun/@types_estree@1.0.9/node_modules/@types/estree/index.js";
 //#region src/utils/ast.d.ts
 /**
  * Minimal structural models for the nodes this plugin inspects that are not

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

@@ -0,0 +1,42 @@
+import { AstNode } from "./ast.js";
+//#region src/utils/contentDeclaration.d.ts
+/**
+ * Reading an Intlayer content declaration out of the file being linted.
+ *
+ * A declaration is any object literal carrying both a `key` and a `content`
+ * property — the same shape the VS Code extension looks for, which covers
+ * `export default { … }`, `const dictionary = { … } satisfies Dictionary` and
+ * every variant in between without caring how the object reaches the export.
+ */
+/** One field declared inside a dictionary's `content`. */
+type DeclaredField = {
+  /** Dotted path from the content root, e.g. `hero.title`. */
+  path: string;
+  /** The property key node, so a report points at the field name. */
+  keyNode: AstNode;
+};
+/** A dictionary declaration found in the linted file. */
+type ContentDeclaration = {
+  /** The static dictionary key. */
+  dictionaryKey: string;
+  /** The node holding the key, for reporting a fully unused dictionary. */
+  keyNode: AstNode;
+  /** Every field declared under `content`, depth-first. */
+  fields: DeclaredField[];
+  /**
+   * True when the content object holds a spread or a computed key, so the field
+   * list is not exhaustive. No field may be reported unused in that case — the
+   * missing entries could be exactly the ones being read.
+   */
+  isPartiallyEnumerated: boolean;
+};
+/**
+ * Read the dictionary declaration an object literal represents, or `null` when
+ * it is not one.
+ *
+ * @param objectExpression - Any `ObjectExpression` node from the linted file.
+ */
+declare const readContentDeclaration: (objectExpression: AstNode) => ContentDeclaration | null;
+//#endregion
+export { ContentDeclaration, DeclaredField, readContentDeclaration };
+//# sourceMappingURL=contentDeclaration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contentDeclaration.d.ts","names":[],"sources":["../../../src/utils/contentDeclaration.ts"],"mappings":";;;;;;;;;;;KAaY;;EAEV;;EAEA,SAAS;;;KAIC;;EAEV;;EAEA,SAAS;;EAET,QAAQ;;;;;;EAMR;;;;;;;;cA+GW,yBACX,kBAAkB,YACjB"}

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

@@ -0,0 +1,102 @@
+//#region src/utils/projectUsage.d.ts
+/**
+ * The configuration fields the scan reads.
+ *
+ * Declared structurally rather than imported from `@intlayer/types` so the
+ * plugin keeps its single runtime dependency, and so the exact surface this
+ * rule depends on stays visible in one place.
+ */
+type IntlayerProjectConfig = {
+  content: {
+    fileExtensions?: string[];
+    codeDir?: string[];
+  };
+  build: {
+    traversePattern?: string[];
+  };
+  compiler?: {
+    transformPattern?: string | string[];
+  };
+  system: {
+    baseDir: string;
+    unmergedDictionariesDir: string;
+  };
+};
+/** How one dictionary key is consumed across the project. */
+type DictionaryUsage = {
+  /**
+   * Dotted content-field paths read somewhere, every parent prefix included —
+   * reading `hero.title` marks `hero` used too.
+   */
+  usedFieldPaths: Set<string>;
+  /**
+   * True when at least one reference consumes the dictionary in a way field
+   * tracking cannot follow: the content object escapes as a whole, a translator
+   * function is bound, or the referencing file could not be parsed. No field of
+   * the dictionary may be reported unused once this is set.
+   */
+  tracksEveryField: boolean;
+};
+/** The result of one project scan. */
+type ProjectUsageIndex = {
+  /** Every dictionary key referenced by the project, and how. */
+  byDictionaryKey: Map<string, DictionaryUsage>;
+  /**
+   * Extension-less absolute paths of modules imported by the scanned files. A
+   * content declaration reached through a direct import (`useDictionary(myDict)`)
+   * carries no key at the call site, so importing it at all counts as a use.
+   */
+  importedModulePaths: Set<string>;
+  /**
+   * False when the project could not be scanned — no config, no analyser, or no
+   * matching source file. Every report is suppressed in that case rather than
+   * flagging a whole project as unused.
+   */
+  isAvailable: boolean;
+};
+/** One other place a dictionary key is declared. */
+type DuplicateDeclaration = {
+  /** Path as recorded in the unmerged dictionary, or `'remote'` for CMS entries. */
+  filePath: string;
+  /** Whether the other declaration lives in the project or in the CMS. */
+  location: 'local' | 'remote';
+};
+/**
+ * Drop the module extension from a path so `./home.content` and
+ * `/project/src/home.content.ts` compare equal.
+ *
+ * @param filePath - Absolute or relative path.
+ */
+declare const stripModuleExtension: (filePath: string) => string;
+/** Drop every cached configuration and usage index. Exposed for tests. */
+declare const clearProjectUsageCache: () => void;
+/**
+ * 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.
+ */
+declare const getProjectConfiguration: (baseDir: string, cacheTtlMs: number) => IntlayerProjectConfig | null;
+/**
+ * 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.
+ */
+declare const getProjectUsageIndex: (baseDir: string, cacheTtlMs: number) => ProjectUsageIndex;
+/**
+ * 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.
+ */
+declare const getDuplicateDeclarations: (configuration: IntlayerProjectConfig, dictionaryKey: string, currentFilePath: string) => DuplicateDeclaration[];
+//#endregion
+export { DictionaryUsage, DuplicateDeclaration, IntlayerProjectConfig, ProjectUsageIndex, clearProjectUsageCache, getDuplicateDeclarations, getProjectConfiguration, getProjectUsageIndex, stripModuleExtension };
+//# sourceMappingURL=projectUsage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"projectUsage.d.ts","names":[],"sources":["../../../src/utils/projectUsage.ts"],"mappings":";;;;;;;;KAiGY;EACV;IAAW;IAA2B;;EACtC;IAAS;;EACT;IAAa;;EACb;IAAU;IAAiB;;;;KAMjB;;;;;EAKV,gBAAgB;;;;;;;EAOhB;;;KAIU;;EAEV,iBAAiB,YAAY;;;;;;EAM7B,qBAAqB;;;;;;EAMrB;;;KAIU;;EAEV;;EAEA;;;;;;;;cA4CW,uBAAwB;;cA+FxB;;;;;;;;cAcA,0BACX,iBACA,uBACC;;;;;;;cAqUU,uBACX,iBACA,uBACC;;;;;;;;;;;;cA6HU,2BACX,eAAe,uBACf,uBACA,4BACC"}

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

@@ -0,0 +1,18 @@
+//#region src/utils/reactVersion.d.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.
+ */
+declare const getReactVersion: (dir?: string) => string;
+//#endregion
+export { getReactVersion };
+//# sourceMappingURL=reactVersion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reactVersion.d.ts","names":[],"sources":["../../../src/utils/reactVersion.ts"],"mappings":";;;;;;;;;;;;;;cAgBa,kBAAmB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-intlayer",
-  "version": "9.3.1",
+  "version": "9.3.3",
   "private": false,
   "description": "ESLint (and oxlint) plugin for Intlayer. Catches untranslated strings and the dynamic call shapes the Intlayer compiler cannot optimize.",
   "keywords": [
@@ -76,7 +76,9 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.3.1"
+    "@intlayer/config": "9.3.3",
+    "@intlayer/lsp": "9.3.3",
+    "fast-glob": "3.3.3"
   },
   "devDependencies": {
     "@angular-eslint/template-parser": "22.1.0",
@@ -93,7 +95,7 @@
     "tsdown": "0.22.14",
     "typescript": "6.0.3",
     "typescript-eslint": "8.67.0",
-    "vitest": "4.1.10",
+    "vitest": "4.1.11",
     "vue-eslint-parser": "10.4.1"
   },
   "peerDependencies": {