eslint-plugin-intlayer 9.3.1 → 9.3.2

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.2",
   "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.2",
+    "@intlayer/lsp": "9.3.2",
+    "fast-glob": "3.3.3"
   },
   "devDependencies": {
     "@angular-eslint/template-parser": "22.1.0",