i18n-lens-language-server 0.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 yizixu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,219 @@
+# I18n Lens for Zed
+
+Zed extension plus Language Server for Vue, TypeScript, TSX, JavaScript and JSX. It shows the real translation text behind i18n keys while editing.
+
+## Features
+
+- Inline translation display via LSP inlay hints
+- Detect `$t`/`t`/`tc`/`$tc`/`i18n.t` calls, `v-t="'key'"`, `v-t="{ path: 'key' }"`, `<i18n-t keypath="key">` (Vue I18n), `<Trans i18nKey="key">` (react-i18next), and `formatMessage({ id: "key" })` (react-intl)
+- Hover: show all locale values for a key
+- Diagnostics: report keys missing from every locale file as errors and keys missing from some locales as warnings
+- Completion: suggest existing i18n keys with default locale text
+- Definition: jump from a source key to its locale definition; when several locales define the key, pick which language file to open
+
+## Inline translations
+
+When inlay hints are enabled in Zed, code like this:
+
+```ts
+t("order.pay_now")
+```
+
+will show the default locale translation inline after the key string, for example:
+
+```ts
+t("order.pay_now")  立即支付
+```
+
+The inline hint uses `defaultLocale` from `.zed/i18nlensrc.json`, falling back to `zh-CN`. Missing keys are not shown inline because diagnostics already report them.
+
+Long translations are truncated inline to keep the editor readable. Hover still shows the full locale table.
+
+## Hover
+
+Hovering over an i18n key shows every loaded locale value in a read-only table.
+
+To open a specific language file, use Go to Definition (Ctrl/Cmd+click or F12) on the key. When the key exists in more than one locale, the editor offers each language's file — default locale first — so you can jump straight to the one you want instead of only the default locale.
+
+## Diagnostics
+
+Diagnostics refresh automatically when loaded locale files or locale directories change, so editing translation files should update warnings/errors without restarting the extension.
+
+Diagnostics distinguish between two missing-key cases:
+
+- If a key is missing from every loaded locale, it is reported as an error.
+- If a key exists in at least one locale but is missing from other locales, it is reported as a warning listing the missing locale names.
+
+For example, if `order.pay_now` exists in `zh-CN` but is missing from `en-US`, the warning message is:
+
+```text
+Missing i18n key "order.pay_now" in locales: en-US
+```
+
+## Project configuration
+
+You can add `.zed/i18nlensrc.json` under your project root to override the defaults:
+
+```json
+{
+  "defaultLocale": "zh-CN",
+  "localeDirs": ["src/locales", "src/i18n", "locales", "i18n"],
+  "inlayHints": {
+    "enabled": true,
+    "maxLength": 24
+  },
+  "packages": [
+    {
+      "root": "apps/web",
+      "defaultLocale": "zh-CN",
+      "localeDirs": ["src/locales"]
+    },
+    {
+      "root": "packages/admin",
+      "defaultLocale": "en-US",
+      "localeDirs": ["src/i18n"]
+    }
+  ]
+}
+```
+
+A template is available in this repository:
+
+```text
+.zed/i18nlensrc.example.json
+```
+
+Supported options:
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `defaultLocale` | string | `zh-CN` | Locale used for completion details and inline translation hints. Supports exact names such as `en-US`, case-insensitive matching, `_`/`-` normalization, and language aliases such as `en` matching `en-US`. |
+| `localeDirs` | string[] | `src/locales`, `src/i18n`, `locales`, `i18n` | Workspace-relative directories to scan for locale files. |
+| `inlayHints.enabled` | boolean | `true` | Enables or disables inline translation hints from this language server. |
+| `inlayHints.maxLength` | number | `24` | Maximum inline hint label length before truncation. |
+| `packages` | array | `[]` | Optional monorepo package contexts. Each item needs a workspace-relative `root` and can override `defaultLocale`, `localeDirs`, and `inlayHints`. The language server picks the longest package root matching the currently edited file. |
+
+Invalid or missing config values fall back to defaults. If `.zed/i18nlensrc.json` contains invalid JSON, the language server logs a warning and continues with default config.
+
+Configuration changes are watched automatically. After saving `.zed/i18nlensrc.json`, the language server reloads config, rebuilds the locale cache, refreshes diagnostics, and asks the editor to refresh inlay hints. You should not need to rebuild or reload the Zed extension just to apply config changes.
+
+## Locale discovery
+
+In a single-project workspace, `localeDirs` are resolved relative to the workspace root. The language server currently reads JSON files from:
+
+- `src/locales/*.json`
+- `src/i18n/*.json`
+- `locales/*.json`
+- `i18n/*.json`
+
+Locale name comes from filename, for example `zh-CN.json` or `en-US.json`.
+
+It also supports locale directories such as:
+
+```text
+src/locales/zh-CN/common.json
+src/locales/en-US/common.json
+```
+
+A file named `common.json` contributes keys with the `common.` prefix. A file named `index.json` contributes keys without an `index.` prefix.
+
+## Monorepo workspaces
+
+For pnpm/turborepo and other monorepos, put `.zed/i18nlensrc.json` under the workspace root and add `packages` entries:
+
+```json
+{
+  "defaultLocale": "zh-CN",
+  "packages": [
+    {
+      "root": "apps/web",
+      "localeDirs": ["src/locales"]
+    },
+    {
+      "root": "packages/admin",
+      "defaultLocale": "en-US",
+      "localeDirs": ["src/i18n"]
+    }
+  ]
+}
+```
+
+When a document is opened, I18n Lens selects the package whose `root` is the longest path prefix of that document. `localeDirs` inside a package are resolved relative to that package root, so `apps/web/src/locales` and `packages/admin/src/i18n` are indexed independently. Package entries inherit root-level `defaultLocale`, `localeDirs`, and `inlayHints` unless they override them.
+
+## Local development
+
+Install dependencies:
+
+```bash
+npm install
+```
+
+Run tests:
+
+```bash
+npm test
+```
+
+The language server is published to npm as
+[`i18n-lens-language-server`](https://www.npmjs.com/package/i18n-lens-language-server).
+A Zed extension must not ship its language server, so the Rust shell installs
+that npm package into its work directory at runtime via the Zed Extension API
+(`npm_install_package`), the same pattern the official Node-based extensions use.
+
+Check the Zed extension adapter:
+
+```bash
+cargo check --target wasm32-wasip1
+```
+
+On this Windows setup, if `cargo` is not visible inside Git Bash / WSL, use:
+
+```bash
+"$HOME/.cargo/bin/cargo.exe" check --target wasm32-wasip1
+```
+
+## Test in Zed
+
+1. Open Zed.
+2. Run `Install Dev Extension` from the command palette.
+3. Select this project root, for example the local `zed-i18n-lens` repository directory.
+4. Open a Vue/TS/JS project with locale JSON files.
+5. Test hover, completion, diagnostics, definition, and inlay hints.
+
+If inline translations do not appear, check whether inlay hints are enabled in Zed settings.
+
+### Iterating on the language server
+
+The published npm version can lag behind your working tree. To test local `server/*.js` changes without publishing, pack the current tree and install it into the Zed work directory, then restart the server:
+
+```powershell
+./scripts/deploy-local.ps1
+```
+
+It runs `npm pack`, installs the tarball into `%LOCALAPPDATA%\Zed\extensions\work\i18n-lens\node_modules\i18n-lens-language-server` (the same layout Zed produces), then prompts you to run **restart language server** from the Zed command palette.
+
+> To exercise the real install path instead, delete `%LOCALAPPDATA%\Zed\extensions\work\i18n-lens\node_modules` and restart the server — Zed will reinstall the published npm package.
+
+## Releasing
+
+The version is single-sourced across `Cargo.toml`, `extension.toml`, and
+`package.json` (they must all match — the release workflow enforces this). To
+cut a release:
+
+1. Bump `version` in `Cargo.toml`, `extension.toml`, and `package.json`.
+2. Tag and push:
+
+   ```bash
+   git tag v<version>   # e.g. v0.7.0
+   git push origin v<version>
+   ```
+
+   The `.github/workflows/release.yml` workflow then verifies the versions
+   match, runs the tests, and publishes the language server to npm as
+   `i18n-lens-language-server`. This requires an `NPM_TOKEN` repository secret
+   with publish rights.
+
+   To publish manually instead: `npm publish --access public`.
+3. Submit/update the extension in `zed-industries/extensions` (bump the
+   `version` in its `extensions.toml` to match) so Zed picks up the new
+   extension version, which installs the new npm package.

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "i18n-lens-language-server",
+  "version": "0.8.0",
+  "type": "module",
+  "description": "Language server for configurable i18n inlay hints, hover, completion, diagnostics, and definition in Vue/TS/TSX/JS.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yizixu/zed-i18n-lens.git"
+  },
+  "main": "server/index.js",
+  "bin": {
+    "i18n-lens-language-server": "./server/index.js"
+  },
+  "files": [
+    "server/*.js"
+  ],
+  "scripts": {
+    "test": "node --test tests/*.test.js",
+    "start": "node server/index.js"
+  },
+  "dependencies": {
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12"
+  }
+}

package/server/core.js

@@ -0,0 +1,473 @@
+export const DEFAULT_CONFIG = Object.freeze({
+  defaultLocale: 'zh-CN',
+  localeDirs: Object.freeze(['src/locales', 'src/i18n', 'locales', 'i18n']),
+  inlayHints: Object.freeze({ enabled: true, maxLength: 24 }),
+  packages: Object.freeze([]),
+});
+
+export const CONFIG_RELATIVE_PATH = '.zed/i18nlensrc.json';
+
+export function resolveConfigPath(workspaceRoot) {
+  return joinFsPath(normalizeFsPath(workspaceRoot), CONFIG_RELATIVE_PATH);
+}
+
+export function normalizeI18nLensConfig(raw = {}) {
+  const base = normalizeProjectConfig(raw, DEFAULT_CONFIG);
+  const packages = Array.isArray(raw.packages)
+    ? raw.packages
+      .map((pkg) => normalizePackageConfig(pkg, base))
+      .filter(Boolean)
+    : [];
+
+  return { ...base, packages };
+}
+
+function normalizeProjectConfig(raw = {}, defaults = DEFAULT_CONFIG) {
+  const defaultLocale = typeof raw.defaultLocale === 'string' && raw.defaultLocale.trim()
+    ? raw.defaultLocale.trim()
+    : defaults.defaultLocale;
+
+  const localeDirs = Array.isArray(raw.localeDirs)
+    ? raw.localeDirs.filter((dir) => typeof dir === 'string' && dir.trim()).map((dir) => normalizeRelativePath(dir.trim()))
+    : [];
+
+  const defaultInlayHints = defaults.inlayHints || DEFAULT_CONFIG.inlayHints;
+  const rawInlayHints = raw.inlayHints && typeof raw.inlayHints === 'object' ? raw.inlayHints : {};
+  const enabled = typeof rawInlayHints.enabled === 'boolean' ? rawInlayHints.enabled : defaultInlayHints.enabled;
+  const maxLength = Number.isInteger(rawInlayHints.maxLength) && rawInlayHints.maxLength > 0
+    ? rawInlayHints.maxLength
+    : defaultInlayHints.maxLength;
+
+  return {
+    defaultLocale,
+    localeDirs: localeDirs.length > 0 ? localeDirs : [...defaults.localeDirs],
+    inlayHints: { enabled, maxLength },
+  };
+}
+
+function normalizePackageConfig(raw, inherited) {
+  if (!raw || typeof raw !== 'object') return undefined;
+  const root = typeof raw.root === 'string' && raw.root.trim()
+    ? normalizeRelativePath(raw.root.trim())
+    : undefined;
+  if (!root) return undefined;
+  return { root, ...normalizeProjectConfig(raw, inherited) };
+}
+
+function normalizeRelativePath(value) {
+  return value.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/g, '');
+}
+
+export function resolveProjectContext(filePath, workspaceRoot, config) {
+  const normalizedWorkspaceRoot = normalizeFsPath(workspaceRoot);
+  const normalizedFilePath = normalizeFsPath(filePath);
+  const candidates = [
+    { root: normalizedWorkspaceRoot, config: withoutPackages(config) },
+    ...((config?.packages || []).map((pkg) => ({
+      root: normalizeFsPath(joinFsPath(normalizedWorkspaceRoot, pkg.root)),
+      config: withoutPackages(pkg),
+    }))),
+  ];
+
+  return candidates
+    .filter((candidate) => isPathInside(normalizedFilePath, candidate.root))
+    .sort((a, b) => b.root.length - a.root.length)[0] || candidates[0];
+}
+
+function withoutPackages(config) {
+  const { packages: _packages, ...rest } = config || normalizeI18nLensConfig();
+  return rest;
+}
+
+function normalizeFsPath(value) {
+  return String(value || '').replace(/\\/g, '/').replace(/\/+$/g, '');
+}
+
+function joinFsPath(root, relative) {
+  return root + '/' + normalizeRelativePath(relative || '');
+}
+
+function isPathInside(filePath, root) {
+  return filePath === root || filePath.startsWith(root + '/');
+}
+
+
+export function didWatchedFileChange(previous, current) {
+  return previous?.mtimeMs !== current?.mtimeMs;
+}
+
+export function flattenLocale(value, prefix = '', out = {}) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return out;
+  for (const [key, child] of Object.entries(value)) {
+    const fullKey = prefix ? prefix + '.' + key : key;
+    if (child && typeof child === 'object' && !Array.isArray(child)) flattenLocale(child, fullKey, out);
+    else out[fullKey] = String(child);
+  }
+  return out;
+}
+
+export function getValueByKey(obj, key) {
+  return key.split('.').reduce((acc, part) => (acc && Object.prototype.hasOwnProperty.call(acc, part) ? acc[part] : undefined), obj);
+}
+
+function offsetToPosition(text, offset) {
+  const before = text.slice(0, offset);
+  const lines = before.split('\n');
+  return { line: lines.length - 1, character: lines[lines.length - 1].length };
+}
+
+function makeRange(text, start, end) {
+  return { start: offsetToPosition(text, start), end: offsetToPosition(text, end) };
+}
+
+export function extractI18nKeys(text) {
+  const found = [];
+  const patterns = [
+    // t/$t/tc/$tc/i18n.t/i18n.tc(...) — function calls, incl. Vue I18n plural tc
+    /(?:\x24tc?|\btc?|\bi18n\.tc?)\(\s*(['"])([A-Za-z0-9_.:-]+)\1/g,
+    // react-intl: formatMessage({ id: "key" }) (id may not be the first prop)
+    /\bformatMessage\s*\(\s*\{[^}]*?\bid\s*:\s*(['"])([A-Za-z0-9_.:-]+)\1/g,
+    // <i18n-t keypath="key"> (Vue I18n) and <Trans i18nKey="key"> (react-i18next)
+    /\b(?:keypath|i18nKey)\s*=\s*(['"])([A-Za-z0-9_.:-]+)\1/g,
+    /\bv-t\s*=\s*"'([A-Za-z0-9_.:-]+)'"/g,
+    /\bv-t\s*=\s*"\s*\{\s*path\s*:\s*(['"])([A-Za-z0-9_.:-]+)\1/g,
+  ];
+  for (const re of patterns) {
+    let match;
+    while ((match = re.exec(text))) {
+      const key = match[2] || match[1];
+      const keyOffsetInMatch = match[0].indexOf(key);
+      const start = match.index + keyOffsetInMatch;
+      const end = start + key.length;
+      found.push({ key, range: makeRange(text, start, end), startOffset: start, endOffset: end });
+    }
+  }
+  found.sort((a, b) => a.startOffset - b.startOffset);
+  return found;
+}
+
+export function keyAtPosition(text, position) {
+  const offset = positionToOffset(text, position);
+  return extractI18nKeys(text).find((item) => item.startOffset <= offset && offset <= item.endOffset);
+}
+
+export function positionToOffset(text, position) {
+  const lines = text.split('\n');
+  let offset = 0;
+  for (let i = 0; i < position.line; i++) offset += (lines[i] || '').length + 1;
+  return offset + position.character;
+}
+
+
+export function collectLocaleWatchPaths(localeCache, localeDirs = []) {
+  const paths = new Set(localeDirs.filter(Boolean));
+  for (const locale of Object.values(localeCache || {})) {
+    if (locale.path) paths.add(locale.path);
+    for (const file of locale.files || []) paths.add(file);
+  }
+  return [...paths].sort();
+}
+
+export function findLocaleKeyTarget(locale, key, localeTexts = {}) {
+  if (!locale || !Object.prototype.hasOwnProperty.call(locale.flat || {}, key)) return undefined;
+  const files = Array.isArray(locale.files) && locale.files.length
+    ? locale.files
+    : (locale.path ? [locale.path] : []);
+  const candidates = files
+    .map((filePath) => ({ filePath, lookupKey: lookupKeyForLocaleFile(locale, filePath, key) }))
+    .sort((a, b) => Number(a.lookupKey === key) - Number(b.lookupKey === key));
+
+  for (const candidate of candidates) {
+    const text = localeTexts[candidate.filePath];
+    if (!text) continue;
+    const position = /\.json$/i.test(candidate.filePath)
+      ? findJsonKeyLocation(text, candidate.lookupKey)
+      : findLocaleKeyLocation(text, candidate.lookupKey);
+    if (position) return { filePath: candidate.filePath, position };
+  }
+
+  const fallback = candidates[0];
+  return fallback ? { filePath: fallback.filePath } : undefined;
+}
+
+function lookupKeyForLocaleFile(locale, filePath, key) {
+  const isNestedLocaleFile = normalizeFsPath(locale.path) !== normalizeFsPath(filePath);
+  const stem = fileStem(filePath);
+  if (isNestedLocaleFile && stem && stem !== 'index' && key.startsWith(stem + '.')) return key.slice(stem.length + 1);
+  return key;
+}
+
+function fileStem(filePath) {
+  const fileName = String(filePath || '').replace(/\\/g, '/').split('/').at(-1) || '';
+  return fileName.replace(/\.[^.]+$/, '');
+}
+
+export function buildHoverMarkdown(key, locales) {
+  const names = Object.keys(locales).sort();
+  if (names.length === 0) return '**' + key + '**\n\nNo locale JSON files found.';
+  const lines = ['**' + key + '**', '', '| Locale | Text |', '|---|---|'];
+  for (const name of names) {
+    const value = locales[name].flat[key];
+    lines.push('| ' + escapeMd(name) + ' | ' + escapeMd(value ?? 'Missing') + ' |');
+  }
+  return lines.join('\n');
+}
+
+function escapeMd(value) {
+  return String(value).replace(/\|/g, '\\|').replace(/\n/g, '<br>');
+}
+
+export function getDiagnostics(text, locales) {
+  const localeEntries = Object.entries(locales);
+  if (localeEntries.length === 0) return [];
+
+  return extractI18nKeys(text)
+    .map((item) => {
+      const missingLocales = localeEntries
+        .filter(([, locale]) => !Object.prototype.hasOwnProperty.call(locale.flat, item.key))
+        .map(([name]) => name)
+        .sort();
+
+      if (missingLocales.length === 0) return undefined;
+      const missingInAllLocales = missingLocales.length === localeEntries.length;
+      return {
+        severity: missingInAllLocales ? 1 : 2,
+        range: item.range,
+        message: missingInAllLocales
+          ? 'Missing i18n key: ' + item.key
+          : 'Missing i18n key "' + item.key + '" in locales: ' + missingLocales.join(', '),
+        source: 'i18n-lens',
+        data: { key: item.key, missingLocales, missingInAllLocales },
+      };
+    })
+    .filter(Boolean);
+}
+
+export function resolvePreferredLocale(locales, defaultLocale) {
+  if (!locales || Object.keys(locales).length === 0) return undefined;
+  if (locales[defaultLocale]) return locales[defaultLocale];
+
+  const requested = normalizeLocaleName(defaultLocale);
+  const entries = Object.entries(locales);
+  const exactNormalized = entries.find(([name]) => normalizeLocaleName(name) === requested);
+  if (exactNormalized) return exactNormalized[1];
+
+  const requestedLanguage = requested.split('-')[0];
+  const languageMatch = entries.find(([name]) => {
+    const candidate = normalizeLocaleName(name);
+    const candidateLanguage = candidate.split('-')[0];
+    return candidateLanguage && requestedLanguage && candidateLanguage === requestedLanguage;
+  });
+  return languageMatch?.[1] || entries[0][1];
+}
+
+function normalizeLocaleName(name) {
+  return String(name || '').trim().replace(/_/g, '-').toLowerCase();
+}
+
+export function getCompletions(prefix, locales, defaultLocale) {
+  const keys = new Set();
+  for (const locale of Object.values(locales)) for (const key of Object.keys(locale.flat)) keys.add(key);
+  const preferred = resolvePreferredLocale(locales, defaultLocale);
+  return [...keys]
+    .filter((key) => key.startsWith(prefix))
+    .sort()
+    .map((key) => ({ label: key, kind: 12, detail: preferred?.flat[key] || undefined, insertText: key }));
+}
+
+
+export function getDefinitionLocaleOrder(locales, defaultLocale) {
+  const localeList = Object.values(locales || {});
+  const preferred = resolvePreferredLocale(locales, defaultLocale);
+  if (!preferred) return localeList;
+  return [preferred, ...localeList.filter((locale) => locale !== preferred)];
+}
+
+// Every locale that defines the key, with the default locale first, so
+// Go to Definition can return one LSP Location per language file.
+export function collectLocaleKeyTargets(locales, key, localeTexts = {}, defaultLocale) {
+  return getDefinitionLocaleOrder(locales, defaultLocale)
+    .map((locale) => findLocaleKeyTarget(locale, key, localeTexts))
+    .filter((target) => target?.position);
+}
+
+export function getCompletionPrefix(text, position) {
+  const offset = positionToOffset(text, position);
+  const before = text.slice(0, offset);
+  const patterns = [
+    /(?:\x24tc?|\btc?|\bi18n\.tc?)\(\s*['"]([A-Za-z0-9_.:-]*)$/,
+    /\bformatMessage\s*\(\s*\{[^}]*?\bid\s*:\s*['"]([A-Za-z0-9_.:-]*)$/,
+    /\b(?:keypath|i18nKey)\s*=\s*['"]([A-Za-z0-9_.:-]*)$/,
+    /v-t\s*=\s*"'([A-Za-z0-9_.:-]*)$/,
+  ];
+  for (const re of patterns) {
+    const match = before.match(re);
+    if (match) return match[1];
+  }
+  return '';
+}
+
+export function findJsonKeyLocation(jsonText, key) {
+  const parts = key.split('.');
+  let cursor = 0;
+  for (const part of parts) {
+    const re = new RegExp('"' + escapeRegExp(part) + '"\\s*:', 'g');
+    re.lastIndex = cursor;
+    const match = re.exec(jsonText);
+    if (!match) return undefined;
+    cursor = match.index + match[0].length;
+    if (part === parts[parts.length - 1]) return offsetToPosition(jsonText, match.index);
+  }
+  return undefined;
+}
+
+
+export function parseTsLocaleModule(text, fileName = 'index.ts') {
+  const result = {};
+  const stem = fileName.replace(/\.[cm]?[tj]sx?$/i, '');
+  const exportObject = extractObjectAfter(text, /export\s+default\s*/g);
+  if (exportObject) {
+    Object.assign(result, flattenJsObjectLiteral(exportObject, stem === 'index' ? '' : stem));
+  }
+
+  if (stem === 'index') {
+    const constRe = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*\{/g;
+    let match;
+    while ((match = constRe.exec(text))) {
+      const objectStart = text.indexOf('{', match.index);
+      const objectText = readBalanced(text, objectStart);
+      if (objectText) Object.assign(result, flattenJsObjectLiteral(objectText, match[1]));
+    }
+  }
+  return result;
+}
+
+function extractObjectAfter(text, re) {
+  const match = re.exec(text);
+  if (!match) return undefined;
+  const start = text.indexOf('{', match.index + match[0].length);
+  if (start === -1) return undefined;
+  return readBalanced(text, start);
+}
+
+function readBalanced(text, start) {
+  let depth = 0;
+  let quote = '';
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (ch === '\\') escaped = true;
+      else if (ch === quote) quote = '';
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === '`') { quote = ch; continue; }
+    if (ch === '{') depth++;
+    else if (ch === '}') {
+      depth--;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return undefined;
+}
+
+function flattenJsObjectLiteral(objectText, prefix = '', out = {}) {
+  const body = objectText.replace(/^\s*\{/, '').replace(/\}\s*$/, '');
+  let i = 0;
+  while (i < body.length) {
+    while (i < body.length && /[\s,;]/.test(body[i])) i++;
+    if (body.startsWith('//', i)) { const end = body.indexOf('\n', i); i = end === -1 ? body.length : end + 1; continue; }
+    if (body.startsWith('/*', i)) { const end = body.indexOf('*/', i + 2); i = end === -1 ? body.length : end + 2; continue; }
+    const keyMatch = body.slice(i).match(/^(?:['"]([^'"]+)['"]|([A-Za-z_$][\w$-]*))\s*:/);
+    if (!keyMatch) { i++; continue; }
+    const key = keyMatch[1] || keyMatch[2];
+    i += keyMatch[0].length;
+    while (i < body.length && /\s/.test(body[i])) i++;
+    const fullKey = prefix ? prefix + '.' + key : key;
+    if (body[i] === '{') {
+      const nested = readBalanced(body, i);
+      if (!nested) break;
+      flattenJsObjectLiteral(nested, fullKey, out);
+      i += nested.length;
+      continue;
+    }
+    const value = readJsValue(body, i);
+    if (value) {
+      if (value.kind === 'string') out[fullKey] = value.value;
+      i = value.end;
+    } else i++;
+  }
+  return out;
+}
+
+function readJsValue(text, start) {
+  const quote = text[start];
+  if (quote !== '"' && quote !== "'" && quote !== '`') return undefined;
+  let value = '';
+  let escaped = false;
+  for (let i = start + 1; i < text.length; i++) {
+    const ch = text[i];
+    if (escaped) { value += ch; escaped = false; continue; }
+    if (ch === '\\') { escaped = true; continue; }
+    if (ch === quote) return { kind: 'string', value, end: i + 1 };
+    value += ch;
+  }
+  return undefined;
+}
+
+export function findLocaleKeyLocation(text, key) {
+  const parts = key.split('.');
+  const last = parts[parts.length - 1];
+  const re = new RegExp('(?:["\\\']' + escapeRegExp(last) + '["\\\']|' + escapeRegExp(last) + ')\\s*:', 'g');
+  const match = re.exec(text);
+  return match ? offsetToPosition(text, match.index) : undefined;
+}
+
+
+export function getInlayHints(text, range, locales, defaultLocale, options = {}) {
+  if (options.enabled === false) return [];
+  const maxLength = options.maxLength ?? DEFAULT_CONFIG.inlayHints.maxLength;
+  const preferred = resolvePreferredLocale(locales, defaultLocale);
+  if (!preferred) return [];
+
+  return extractI18nKeys(text)
+    .filter((item) => isPositionInRange(item.range.start, range))
+    .map((item) => {
+      const value = preferred.flat[item.key];
+      if (value === undefined) return undefined;
+      return {
+        position: inlayPositionAfterKeyLiteral(text, item),
+        label: truncateInlayText(value, maxLength),
+        paddingLeft: true,
+        tooltip: value,
+      };
+    })
+    .filter(Boolean);
+}
+
+function inlayPositionAfterKeyLiteral(text, item) {
+  const next = text[item.endOffset];
+  const offset = (next === '"' || next === "'") ? item.endOffset + 1 : item.endOffset;
+  return offsetToPosition(text, offset);
+}
+
+function isPositionInRange(position, range) {
+  if (!range) return true;
+  return comparePosition(position, range.start) >= 0 && comparePosition(position, range.end) <= 0;
+}
+
+function comparePosition(a, b) {
+  if (a.line !== b.line) return a.line - b.line;
+  return a.character - b.character;
+}
+
+function truncateInlayText(value, maxLength) {
+  const text = String(value).replace(/\s+/g, ' ').trim();
+  if (text.length <= maxLength) return text;
+  return text.slice(0, Math.max(0, maxLength - 1)) + '…';
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^()|[\]\{}]/g, '\\$&');
+}

package/server/index.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { createConnection, TextDocuments, ProposedFeatures, TextDocumentSyncKind, MarkupKind } from 'vscode-languageserver/node.js';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import {
+  flattenLocale,
+  buildHoverMarkdown,
+  getDiagnostics,
+  getCompletions,
+  getCompletionPrefix,
+  keyAtPosition,
+  parseTsLocaleModule,
+  collectLocaleKeyTargets,
+  getInlayHints,
+  normalizeI18nLensConfig,
+  resolveConfigPath,
+  CONFIG_RELATIVE_PATH,
+  didWatchedFileChange,
+  collectLocaleWatchPaths,
+  resolveProjectContext,
+} from './core.js';
+
+const connection = createConnection(ProposedFeatures.all);
+const documents = new TextDocuments(TextDocument);
+let workspaceRoot = process.cwd();
+let config = normalizeI18nLensConfig();
+let watchedConfigPath;
+const watchedLocalePaths = new Set();
+let reloadTimer;
+let configMtimeMs;
+let localeCacheByContext = new Map();
+const configWatchIntervalMs = 1000;
+const localeWatchIntervalMs = 1000;
+const reloadDebounceMs = 100;
+
+connection.onInitialize((params) => {
+  workspaceRoot = params.workspaceFolders?.[0]?.uri ? fileURLToPath(params.workspaceFolders[0].uri) : (params.rootUri ? fileURLToPath(params.rootUri) : process.cwd());
+  loadConfig();
+  watchConfigFile();
+  return { capabilities: { textDocumentSync: TextDocumentSyncKind.Incremental, hoverProvider: true, completionProvider: { triggerCharacters: ['.', '"', "'"] }, definitionProvider: true, inlayHintProvider: true } };
+});
+
+connection.onInitialized(() => {
+  // After (re)start the editor does not always re-request inlay hints for
+  // already-open documents, so features only appeared after the first edit.
+  // Proactively reload config/locales and ask the editor to refresh.
+  scheduleProjectReload();
+});
+
+documents.onDidOpen((event) => {
+  validate(event.document);
+  // A freshly started server may receive the inlay-hint request before the
+  // locale cache is ready; prompt the editor to re-request once it is.
+  refreshInlayHints();
+});
+documents.onDidChangeContent((event) => validate(event.document));
+documents.onDidSave(() => scheduleProjectReload());
+
+connection.onHover((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  if (!doc) return null;
+  const item = keyAtPosition(doc.getText(), params.position);
+  if (!item) return null;
+  const context = getProjectContext(params.textDocument.uri);
+  const { locales } = loadLocalesForContext(context);
+  return {
+    contents: { kind: MarkupKind.Markdown, value: buildHoverMarkdown(item.key, locales) },
+    range: item.range,
+  };
+});
+
+connection.onCompletion((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  const context = getProjectContext(params.textDocument.uri);
+  const { locales } = loadLocalesForContext(context);
+  const prefix = doc ? getCompletionPrefix(doc.getText(), params.position) : '';
+  return getCompletions(prefix, locales, context.config.defaultLocale);
+});
+
+connection.languages.inlayHint.on((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  if (!doc) return [];
+  const context = getProjectContext(params.textDocument.uri);
+  const { locales } = loadLocalesForContext(context);
+  return getInlayHints(doc.getText(), params.range, locales, context.config.defaultLocale, context.config.inlayHints);
+});
+
+connection.onDefinition((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  if (!doc) return null;
+  const item = keyAtPosition(doc.getText(), params.position);
+  if (!item) return null;
+  const context = getProjectContext(params.textDocument.uri);
+  const { locales, localeTexts } = loadLocalesForContext(context);
+  const keyTokenLength = item.key.split('.').at(-1).length + 2;
+  const locations = collectLocaleKeyTargets(locales, item.key, localeTexts, context.config.defaultLocale)
+    .map(({ filePath, position }) => ({
+      uri: pathToFileURL(filePath).toString(),
+      range: { start: position, end: { line: position.line, character: position.character + keyTokenLength } },
+    }));
+  return locations.length ? locations : null;
+});
+
+function getProjectContext(uri) {
+  loadConfigIfChanged();
+  const filePath = uri ? fileURLToPath(uri) : workspaceRoot;
+  return resolveProjectContext(filePath, workspaceRoot, config);
+}
+
+function watchConfigFile() {
+  const configPath = resolveConfigPath(workspaceRoot);
+  if (watchedConfigPath === configPath) return;
+  if (watchedConfigPath) fs.unwatchFile(watchedConfigPath);
+  watchedConfigPath = configPath;
+  fs.watchFile(configPath, { interval: configWatchIntervalMs }, (current, previous) => {
+    if (didWatchedFileChange(previous, current)) scheduleProjectReload();
+  });
+}
+
+function watchLocalePaths() {
+  const nextPaths = new Set();
+  const contexts = getAllConfiguredContexts();
+  for (const context of contexts) {
+    const configuredDirs = context.config.localeDirs
+      .map((dir) => path.join(context.root, dir))
+      .filter((dir) => fs.existsSync(dir));
+    const loaded = loadLocalesForContext(context);
+    for (const watchPath of collectLocaleWatchPaths(loaded.locales, configuredDirs)) nextPaths.add(watchPath);
+  }
+
+  for (const watchedPath of watchedLocalePaths) {
+    if (nextPaths.has(watchedPath)) continue;
+    fs.unwatchFile(watchedPath);
+    watchedLocalePaths.delete(watchedPath);
+  }
+
+  for (const watchedPath of nextPaths) {
+    if (watchedLocalePaths.has(watchedPath)) continue;
+    watchedLocalePaths.add(watchedPath);
+    fs.watchFile(watchedPath, { interval: localeWatchIntervalMs }, (current, previous) => {
+      if (didWatchedFileChange(previous, current)) scheduleProjectReload();
+    });
+  }
+}
+
+function scheduleProjectReload() {
+  clearTimeout(reloadTimer);
+  reloadTimer = setTimeout(() => {
+    loadConfig();
+    localeCacheByContext = new Map();
+    watchLocalePaths();
+    refreshOpenDocuments();
+    refreshInlayHints();
+  }, reloadDebounceMs);
+}
+
+function refreshOpenDocuments() {
+  for (const doc of documents.all()) validate(doc);
+}
+
+function refreshInlayHints() {
+  try {
+    connection.languages.inlayHint.refresh?.();
+  } catch (error) {
+    connection.console.warn('Failed to refresh inlay hints: ' + error.message);
+  }
+}
+
+function loadConfigIfChanged() {
+  const configPath = resolveConfigPath(workspaceRoot);
+  const nextMtimeMs = fs.existsSync(configPath) ? fs.statSync(configPath).mtimeMs : 0;
+  if (configMtimeMs === nextMtimeMs) return;
+  loadConfig();
+  localeCacheByContext = new Map();
+}
+
+function loadConfig() {
+  const configPath = resolveConfigPath(workspaceRoot);
+  configMtimeMs = fs.existsSync(configPath) ? fs.statSync(configPath).mtimeMs : 0;
+  if (!configMtimeMs) {
+    config = normalizeI18nLensConfig();
+    return;
+  }
+  try {
+    config = normalizeI18nLensConfig(JSON.parse(fs.readFileSync(configPath, 'utf8')));
+  } catch (error) {
+    connection.console.warn('Failed to load ' + CONFIG_RELATIVE_PATH + ': ' + error.message);
+    config = normalizeI18nLensConfig();
+  }
+}
+
+function validate(document) {
+  if (!isSourceFile(document.uri)) return;
+  const context = getProjectContext(document.uri);
+  const { locales } = loadLocalesForContext(context);
+  connection.sendDiagnostics({ uri: document.uri, diagnostics: getDiagnostics(document.getText(), locales) });
+}
+function isSourceFile(uri) { return /\.(vue|tsx?|jsx?)$/i.test(uri); }
+
+function getAllConfiguredContexts() {
+  loadConfigIfChanged();
+  return [resolveProjectContext(workspaceRoot, workspaceRoot, config), ...config.packages.map((pkg) => ({
+    root: path.resolve(workspaceRoot, pkg.root),
+    config: pkg,
+  }))];
+}
+
+function loadLocalesForContext(context) {
+  const cacheKey = context.root + '\0' + JSON.stringify({
+    defaultLocale: context.config.defaultLocale,
+    localeDirs: context.config.localeDirs,
+    inlayHints: context.config.inlayHints,
+  });
+  const cached = localeCacheByContext.get(cacheKey);
+  if (cached) return cached;
+
+  const locales = {};
+  const localeTexts = {};
+  for (const dir of context.config.localeDirs) {
+    const fullDir = path.join(context.root, dir);
+    if (!fs.existsSync(fullDir)) continue;
+    loadLocaleFiles(fullDir, locales, localeTexts);
+    for (const entry of fs.readdirSync(fullDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) loadLocaleDirectory(path.join(fullDir, entry.name), entry.name, locales, localeTexts);
+    }
+  }
+  const loaded = { locales, localeTexts };
+  localeCacheByContext.set(cacheKey, loaded);
+  return loaded;
+}
+
+function loadLocaleDirectory(localeDir, localeName, next, localeTexts) {
+  next[localeName] ||= { path: localeDir, flat: {}, files: [] };
+  for (const file of fs.readdirSync(localeDir)) {
+    const fullPath = path.join(localeDir, file);
+    if (fs.statSync(fullPath).isDirectory()) continue;
+    try {
+      const text = fs.readFileSync(fullPath, 'utf8');
+      if (file.endsWith('.json')) Object.assign(next[localeName].flat, prefixByFile(file, flattenLocale(JSON.parse(text))));
+      else if (/\.[cm]?[tj]s$/i.test(file)) Object.assign(next[localeName].flat, parseTsLocaleModule(text, file));
+      else continue;
+      next[localeName].files.push(fullPath);
+      localeTexts[fullPath] = text;
+    } catch (error) { connection.console.warn('Failed to load locale file ' + fullPath + ': ' + error.message); }
+  }
+}
+
+function loadLocaleFiles(fullDir, next, localeTexts) {
+  for (const file of fs.readdirSync(fullDir)) {
+    const fullPath = path.join(fullDir, file);
+    if (fs.statSync(fullPath).isDirectory()) continue;
+    try {
+      const text = fs.readFileSync(fullPath, 'utf8');
+      if (file.endsWith('.json')) {
+        const name = path.basename(file, '.json');
+        next[name] = { path: fullPath, flat: flattenLocale(JSON.parse(text)), files: [fullPath] };
+        localeTexts[fullPath] = text;
+      }
+    } catch (error) { connection.console.warn('Failed to load locale file ' + fullPath + ': ' + error.message); }
+  }
+}
+
+function prefixByFile(file, flat) {
+  const stem = path.basename(file, path.extname(file));
+  if (stem === 'index') return flat;
+  return Object.fromEntries(Object.entries(flat).map(([key, value]) => [stem + '.' + key, value]));
+}
+
+documents.listen(connection);
+connection.listen();