@intlayer/lsp 8.11.4 → 9.0.0

package/dist/types/usageAnalyzer.d.ts

@@ -0,0 +1,141 @@
+import { OxcNode } from "./oxcUtils.js";
+//#region src/usageAnalyzer.d.ts
+/** How a message usage appears in source code. */
+type MessageUsageKind = "call" | "member" | "destructure" | "jsx" | "tagged-template" | "namespace";
+/**
+ * One resolved translation usage inside a source file: which dictionary and
+ * field it reads, and the text span it occupies.
+ */
+type MessageUsage = {
+  /** The intlayer dictionary key the usage reads from. */
+  dictionaryKey: string;
+  /**
+   * Path of content fields from the dictionary root. Empty for
+   * dictionary-level usages (`namespace` kind, or a bare content variable).
+   */
+  fieldPath: string[];
+  /**
+   * Spans of each `fieldPath` segment, aligned by index, when the segments
+   * are addressable in source (member chains). Used to trim the path to the
+   * segment under the cursor.
+   */
+  fieldSpans?: {
+    start: number;
+    end: number;
+  }[];
+  /** Start offset of the usage expression. */
+  start: number;
+  /** End offset of the usage expression. */
+  end: number;
+  kind: MessageUsageKind;
+  /** The caller that produced the usage, e.g. `'useTranslations'`. */
+  callerName: string;
+  /** The library the caller belongs to, e.g. `'next-intl'` or `'intlayer'`. */
+  library: string;
+  /** Module specifier the caller was imported from, when resolvable. */
+  moduleSource?: string;
+  /**
+   * `true` for `member` usages that are a bare reference to a bound variable
+   * (`{greet}` in JSX after `const { greet } = useIntlayer(…)`) — the field
+   * name itself is not spelled at the usage site. Excluded from
+   * find-references results but kept for decorations and hover.
+   */
+  isBareReference?: boolean;
+};
+/**
+ * Analyse a source file and return every resolvable translation usage:
+ * base-intlayer content access and all compat-library forms (translation
+ * functions, self calls, JSX message components, tagged templates).
+ *
+ * Pure and self-contained (oxc parse only) — shared by the LSP handlers and
+ * the VS Code extension providers/decorations.
+ *
+ * @param text - Full source text (a script: TS/TSX or an extracted SFC block).
+ * @returns Usages ordered by start offset.
+ */
+declare const collectMessageUsages: (text: string) => MessageUsage[];
+/**
+ * Resolve the dictionary key declared by a single call-expression node when
+ * it matches any registered non-self caller (`useIntlayer("key")`,
+ * `useI18n({ namespace })`, …). Used for on-the-fly checks where the full
+ * file analysis is not needed (e.g. completion context).
+ *
+ * @param callNode - A candidate CallExpression node.
+ */
+declare const matchCallNamespace: (callNode: OxcNode) => string | null;
+/**
+ * A call site declaring which dictionary a caller reads
+ * (`useIntlayer("home")`, `useI18n({ namespace: 'home' })`), with the spans
+ * needed to anchor diagnostics and cursor checks.
+ */
+type NamespaceReference = {
+  dictionaryKey: string;
+  callerName: string;
+  library: string;
+  /** Span of the whole call expression. */
+  callStart: number;
+  callEnd: number;
+  /** Span of the matched callee name (identifier or method property). */
+  calleeStart: number;
+  calleeEnd: number;
+  /** Span of the namespace argument (string literal or option value). */
+  namespaceStart: number;
+  namespaceEnd: number;
+};
+/**
+ * Collect every call site with an addressable namespace argument (positional
+ * or options property) resolving to a static string. Powers the
+ * unknown-dictionary diagnostics and `findKeyAtOffset`.
+ *
+ * Self callers (`formatMessage`, lingui `t`/`_`) don't declare a namespace at
+ * the call site and are excluded.
+ *
+ * @param text - Full source text.
+ */
+declare const collectNamespaceReferences: (text: string) => NamespaceReference[];
+/**
+ * A source variable bound to a dictionary by a caller declaration:
+ * dictionary content (or a field subtree of it) for `content` callers, or a
+ * translation function for `return-value` / `destructured-t` callers.
+ */
+type CallerVariableBinding = {
+  /** Local variable name. */
+  variableName: string;
+  /** The dictionary the variable reads from. */
+  dictionaryKey: string;
+  /**
+   * Field path from the dictionary root the variable points at (content
+   * bindings), or the key prefix applied to every call (translator bindings).
+   */
+  basePath: string[];
+  /** Whether the variable holds content or a translation function. */
+  bindingKind: "content" | "translator";
+  /** The caller that created the binding. */
+  callerName: string;
+  library: string;
+};
+/**
+ * Collect every variable bound to a dictionary in the file. Used by consumers
+ * that scan non-script regions (Vue/Angular templates) for references to
+ * those variables, or that need to know which dictionaries a file consumes.
+ *
+ * @param text - Full source text (a script: TS/TSX or an extracted SFC block).
+ */
+declare const collectCallerBindings: (text: string) => CallerVariableBinding[];
+/**
+ * Find the most specific translation usage at `offset`.
+ *
+ * For member chains the field path is trimmed to the segment under the
+ * cursor: hovering `section` in `content.section.title` yields
+ * `['section']`, not the full chain.
+ *
+ * Dictionary-level `namespace` usages are only returned when no field-level
+ * usage matches the offset.
+ *
+ * @param text - Full source text.
+ * @param offset - Cursor offset in `text`.
+ */
+declare const findMessageUsageAtOffset: (text: string, offset: number) => MessageUsage | null;
+//#endregion
+export { CallerVariableBinding, MessageUsage, MessageUsageKind, NamespaceReference, collectCallerBindings, collectMessageUsages, collectNamespaceReferences, findMessageUsageAtOffset, matchCallNamespace };
+//# sourceMappingURL=usageAnalyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usageAnalyzer.d.ts","names":[],"sources":["../../src/usageAnalyzer.ts"],"mappings":";;;KAwBY;;;;;KAkBA;;EAEV;;;;;EAKA;;;;;;EAMA;IAAe;IAAe;;;EAE9B;;EAEA;EACA,MAAM;;EAEN;;EAEA;;EAEA;;;;;;;EAOA;;;;;;;;;;;;;cA47BW,uBAAwB,iBAAe;;;;;;;;;cAkCvC,qBAAsB,UAAU;;;;;;KAgCjC;EACV;EACA;EACA;;EAEA;EACA;;EAEA;EACA;;EAEA;EACA;;;;;;;;;;;;cAwCW,6BACX,iBACC;;;;;;KA8DS;;EAEV;;EAEA;;;;;EAKA;;EAEA;;EAEA;EACA;;;;;;;;;cAUW,wBACX,iBACC;;;;;;;;;;;;;;cA0DU,2BACX,cACA,mBACC"}

package/dist/types/utils.d.ts

@@ -1,5 +1,19 @@
+import { index_d_exports } from "./callers/index.js";
+import { buildCallerWithKeyPattern, buildKeyUsagePatterns, getCallerNamesAlternation } from "./callers/patterns.js";
 import { escapeRegularExpression, findFieldRangesInFile, offsetToRange } from "./findFieldInFile.js";
 import { findKeyAtOffset } from "./findKeyAtOffset.js";
 import { findContentFieldAtOffset, findKeyInContentFile } from "./findKeyInContentFile.js";
+import { findTCallAtOffset } from "./findTCallAtOffset.js";
 import { findUsageFieldAtOffset } from "./findUsageFieldAtOffset.js";
-export { escapeRegularExpression, findContentFieldAtOffset, findFieldRangesInFile, findKeyAtOffset, findKeyInContentFile, findUsageFieldAtOffset, offsetToRange };
+import { OxcNode, buildParentMap, getFirstStringArg, getObjectPropertyNode, getObjectPropertyString, getPropertyKeyName, getStaticStringValue, getStringArgAt, isStringLiteralNode, nodeContainsOffset, nodeEnd, nodeStart, parseText, walkAst } from "./oxcUtils.js";
+import { CallerVariableBinding, MessageUsage, MessageUsageKind, NamespaceReference, collectCallerBindings, collectMessageUsages, collectNamespaceReferences, findMessageUsageAtOffset, matchCallNamespace } from "./usageAnalyzer.js";
+type ALL_CALLERS = index_d_exports.ALL_CALLERS;
+type BASE_CALLERS = index_d_exports.BASE_CALLERS;
+type CALLERS_BY_NAME = index_d_exports.CALLERS_BY_NAME;
+type COMPAT_CALLERS = index_d_exports.COMPAT_CALLERS;
+type CallerDescriptor = index_d_exports.CallerDescriptor;
+type CallerResultShape = index_d_exports.CallerResultShape;
+type CallerValueSource = index_d_exports.CallerValueSource;
+type getPositionalKeyCallerNames = index_d_exports.getPositionalKeyCallerNames;
+type isCallerActive = index_d_exports.isCallerActive;
+export { ALL_CALLERS, BASE_CALLERS, CALLERS_BY_NAME, COMPAT_CALLERS, type CallerDescriptor, type CallerResultShape, type CallerValueSource, type CallerVariableBinding, type MessageUsage, type MessageUsageKind, type NamespaceReference, type OxcNode, buildCallerWithKeyPattern, buildKeyUsagePatterns, buildParentMap, collectCallerBindings, collectMessageUsages, collectNamespaceReferences, escapeRegularExpression, findContentFieldAtOffset, findFieldRangesInFile, findKeyAtOffset, findKeyInContentFile, findMessageUsageAtOffset, findTCallAtOffset, findUsageFieldAtOffset, getCallerNamesAlternation, getFirstStringArg, getObjectPropertyNode, getObjectPropertyString, getPositionalKeyCallerNames, getPropertyKeyName, getStaticStringValue, getStringArgAt, isCallerActive, isStringLiteralNode, matchCallNamespace, nodeContainsOffset, nodeEnd, nodeStart, offsetToRange, parseText, walkAst };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/lsp",
-  "version": "8.11.4",
+  "version": "9.0.0",
   "private": false,
   "description": "Intlayer Language Server. Handle LSP to help IDE and AI agent to use Intlayer",
   "keywords": [
@@ -76,45 +76,32 @@
     "format:fix": "bun --bun biome format --write .",
     "lint": "bun --bun biome lint .",
     "lint:fix": "bun --bun biome lint --write .",
-    "manange:permissions": "bun -e \"require('fs').chmodSync('dist/esm/index.mjs', 0o755)\"",
-    "process-files": "ts-node src/transpiler/processFilesCLI.ts --dir $npm_config_dir --extension $npm_config_extension --no-node-snapshot",
     "prepublish": "cp -f ../../../README.md ./README.md",
     "publish": "bun publish || true",
-    "publish:canary": "bun publish --access public --tag canary || true",
-    "publish:latest": "bun publish --access public --tag latest || true",
-    "start": "bun start:stdio",
-    "start:client": "bun dist/esm/client/sse.mjs",
-    "start:docker": "docker run --rm -p 3000:3000 --name intlayer-mcp-app intlayer-mcp",
-    "start:inspector": "npx @modelcontextprotocol/inspector bun dist/esm/server/stdio.mjs",
-    "start:inspector:sse": "npx @modelcontextprotocol/inspector bun dist/esm/server/sse.mjs",
-    "start:sse": "bun dist/esm/server/sse.mjs",
-    "start:stdio": "bun dist/esm/server/stdio.mjs",
     "test": "bun --bun vitest run",
     "test:watch": "bun --bun vitest",
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "8.11.3",
-    "@intlayer/types": "8.11.3",
-    "@intlayer/unmerged-dictionaries-entry": "8.11.3",
-    "oxc-parser": "0.134.0",
-    "vscode-languageserver": "9.0.1",
+    "@intlayer/config": "9.0.0",
+    "@intlayer/engine": "9.0.0",
+    "@intlayer/types": "9.0.0",
+    "@intlayer/unmerged-dictionaries-entry": "9.0.0",
+    "oxc-parser": "0.138.0",
+    "vscode-languageserver": "10.1.0",
     "vscode-languageserver-textdocument": "1.0.12"
   },
   "devDependencies": {
-    "@types/node": "25.9.1",
+    "@types/node": "26.1.1",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.1",
-    "typescript": "6.0.3",
-    "vitest": "4.1.7"
+    "tsdown": "0.22.13",
+    "typescript": "7.0.2",
+    "vitest": "4.1.10"
   },
   "engines": {
     "node": ">=14.18"
-  },
-  "bug": {
-    "url": "https://github.com/aymericzip/intlayer/issues"
   }
 }