i18n-lens-language-server 0.13.0 → 0.14.0

package/README.md

@@ -13,6 +13,7 @@ Zed extension plus Language Server for Vue, TypeScript, TSX, JavaScript and JSX.
 - Completion: suggest existing i18n keys with default locale text only inside supported i18n key positions
 - Definition: jump from a source key to its locale definition; when several locales define the key, pick which language file to open
 - References: from a locale definition or source usage, find references within the same project/package context, including open source files not yet saved to disk
+- Recursive locale directories: nested JSON, TS, and JS files map to dot-separated namespaces, with `index` files contributing to their parent namespace
 
 ## Installation
 
@@ -220,6 +221,19 @@ src/locales/ja-JP/common.json
 
 A file named `common.json` contributes keys with the `common.` prefix. A file named `index.json` contributes keys without an `index.` prefix.
 
+Locale directories are scanned recursively. Subdirectories contribute to the namespace:
+
+```text
+src/locales/en-US/system/user.json       -> system.user.*
+src/locales/en-US/system/index.json      -> system.*
+src/locales/en-US/system/forms/fields.ts -> system.forms.fields.*
+src/locales/en-US/index/index.json       -> index.*
+```
+
+Nested JSON, TS, and JS locale files support translation previews, definition, references, and unsaved buffer updates. Adding files in nested directories refreshes translations automatically. Missing-key quick fixes retain the existing namespace directory layout when the target is unambiguous and its parent directory exists.
+
+If `localeDirs` overlap, an explicitly configured nested root is excluded from its ancestor's recursive scan, regardless of configuration order or nesting depth. For example, with `["locales", "locales/modules/features"]`, `locales/modules/features/en/user.json` belongs to locale `en` with keys `user.*`, not locale `modules`. Intermediate directories without locale files are watched for new files but do not count as locales. Empty locale files still count as locales and report missing keys.
+
 Top-level TS/JS modules such as `locales/en.ts` are also loaded, without adding an `en.` prefix. Directory modules such as `locales/en/common.ts` retain the `common.` prefix; `index.ts` has no file-stem prefix. Modules are parsed statically, never executed. Their definitions support Find References and cross-language parameter diagnostics, not source-code completions or inlay hints. TS/JS key positioning remains best-effort rather than a full syntax-tree analysis.
 
 ## Monorepo workspaces

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18n-lens-language-server",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "type": "module",
   "description": "Language server for configurable i18n inlay hints, hover, completion, diagnostics, definition, and references in Vue/TS/TSX/JS.",
   "license": "MIT",

package/server/core.js

@@ -642,25 +642,22 @@ export function collectLocaleWatchPaths(localeCache, localeDirs = []) {
 
 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 range = localeKeyRange(text, candidate.lookupKey, /\.json$/i.test(candidate.filePath));
-    if (range) return { filePath: candidate.filePath, position: range.start, range };
-  }
-
-  const fallback = candidates[0];
-  return fallback ? { filePath: fallback.filePath } : undefined;
+  // Namespace specificity does not determine which file won during loading.
+  const filePath = locale.keyFiles?.[key];
+  if (!filePath) return undefined;
+  const lookupKey = lookupKeyForLocaleFile(locale, filePath, key);
+  if (lookupKey === undefined) return undefined;
+  const text = localeTexts[filePath];
+  const range = text ? localeKeyRange(text, lookupKey, /\.json$/i.test(filePath)) : undefined;
+  return range ? { filePath, position: range.start, range } : { filePath };
 }
 
 function lookupKeyForLocaleFile(locale, filePath, key) {
+  const prefix = locale.filePrefixes?.[filePath];
+  if (prefix !== undefined) {
+    if (!prefix) return key;
+    return key.startsWith(prefix + '.') ? key.slice(prefix.length + 1) : undefined;
+  }
   const isNestedLocaleFile = !locale.topLevelFiles?.includes(filePath) && normalizeFsPath(locale.path) !== normalizeFsPath(filePath);
   const stem = fileStem(filePath);
   if (isNestedLocaleFile && stem && stem !== 'index' && key.startsWith(stem + '.')) return key.slice(stem.length + 1);
@@ -771,6 +768,7 @@ export function getLocaleParamDiagnostics(locale, filePath, text, locales) {
     const consistency = getLocaleParamConsistency(key, locales);
     if (consistency.consistent) continue;
     const lookupKey = lookupKeyForLocaleFile(locale, filePath, key);
+    if (lookupKey === undefined) continue;
     const range = localeKeyRange(text, lookupKey, isJson, jsonRoot);
     if (range) diagnostics.push(paramInconsistencyDiagnostic(key, range, consistency.perLocale));
   }
@@ -921,6 +919,7 @@ export function localeKeyAtPosition(locale, filePath, text, position) {
   let lineFallbackCount = 0;
   for (const fullKey of Object.keys(locale.flat)) {
     const lookupKey = lookupKeyForLocaleFile(locale, filePath, fullKey);
+    if (lookupKey === undefined) continue;
     const range = localeKeyRange(text, lookupKey, isJson, jsonRoot);
     if (!range || range.start.line !== position.line) continue;
     if (comparePosition(position, range.start) >= 0 && comparePosition(position, range.end) < 0) return fullKey;
@@ -1086,12 +1085,13 @@ function buildNestedProperty(parts, value, indent, unit, eol) {
 }
 
 
+// File and directory namespaces are applied by the loader, not the parser.
 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));
+    Object.assign(result, flattenJsObjectLiteral(exportObject));
   }
 
   if (stem === 'index') {

package/server/index.js

@@ -220,7 +220,7 @@ function getCreateKeyActions(diagnostics, context) {
   return actions;
 }
 
-// Namespace routing follows loaded file stems. Index-owned prefixes and
+// Namespace routing follows loaded file prefixes. Index-owned prefixes and
 // overlapping layouts are not guessed; ambiguous targets disable the action.
 function planKeyInsertion(key, locale, locales, localeTexts) {
   if (!locale) return undefined;
@@ -231,10 +231,10 @@ function planKeyInsertion(key, locale, locales, localeTexts) {
   }
   if (locale.directories.length !== 1 || locale.topLevelFiles?.length) return undefined;
   const directory = locale.directories[0];
-  const targets = filesByStem(locale);
-  const namespaceFiles = [...targets.keys()].filter((stem) => stem !== 'index' && key.startsWith(stem + '.'));
+  const targets = filesByPrefix(locale);
+  const namespaceFiles = [...targets.keys()].filter((prefix) => prefix && key.startsWith(prefix + '.'));
   if (namespaceFiles.length > 1 || targets.has(key)) return undefined;
-  const indexFiles = targets.get('index') || [];
+  const indexFiles = targets.get('') || [];
   const indexFile = indexFiles.length === 1 && /\.json$/i.test(indexFiles[0]) ? indexFiles[0] : undefined;
   let indexOwnsPrefix = false;
   if (indexFiles.length) {
@@ -259,28 +259,35 @@ function planKeyInsertion(key, locale, locales, localeTexts) {
   const siblingStems = new Map();
   for (const sibling of Object.values(locales)) {
     if (sibling === locale || sibling.directories?.length !== 1 || sibling.topLevelFiles?.length) continue;
-    for (const [stem, files] of filesByStem(sibling)) {
-      if (stem === 'index' || !key.startsWith(stem + '.')) continue;
-      siblingStems.set(stem, (siblingStems.get(stem) || []).concat(files));
+    for (const [stem, files] of filesByPrefix(sibling)) {
+      if (!stem || !key.startsWith(stem + '.')) continue;
+      siblingStems.set(stem, (siblingStems.get(stem) || []).concat(files.map((file) => ({
+        file,
+        relativePath: path.relative(sibling.directories[0], file),
+      }))));
     }
   }
   if (siblingStems.size > 1) return undefined;
   if (siblingStems.size === 1) {
-    const [stem, files] = siblingStems.entries().next().value;
-    if (files.some((file) => !/\.json$/i.test(file))) return undefined;
-    return insertOrCreate(path.join(directory, stem + '.json'), key.slice(stem.length + 1));
+    const [stem, targets] = siblingStems.entries().next().value;
+    if (targets.some(({ file }) => !/\.json$/i.test(file))) return undefined;
+    const relativePaths = new Set(targets.map(({ relativePath }) => relativePath));
+    if (relativePaths.size !== 1) return undefined;
+    const targetPath = path.join(directory, [...relativePaths][0]);
+    return fs.existsSync(path.dirname(targetPath))
+      ? insertOrCreate(targetPath, key.slice(stem.length + 1)) : undefined;
   }
   return indexFile ? insertInto(indexFile, key) : undefined;
 }
 
-function filesByStem(locale) {
-  const stems = new Map();
+function filesByPrefix(locale) {
+  const prefixes = new Map();
   for (const file of locale.files || []) {
-    const stem = path.basename(file, path.extname(file));
-    if (!stems.has(stem)) stems.set(stem, []);
-    stems.get(stem).push(file);
+    const prefix = locale.filePrefixes[file];
+    if (!prefixes.has(prefix)) prefixes.set(prefix, []);
+    prefixes.get(prefix).push(file);
   }
-  return stems;
+  return prefixes;
 }
 
 function insertInto(filePath, lookupKey) {
@@ -370,7 +377,7 @@ function watchLocalePaths() {
       .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 watchPath of collectLocaleWatchPaths(loaded.locales, [...configuredDirs, ...loaded.watchDirectories])) nextPaths.add(watchPath);
   }
 
   for (const watchedPath of watchedLocalePaths) {
@@ -480,10 +487,7 @@ function localeDirOfFile(filePath) {
       const absDir = normalizeFsPathLocal(path.resolve(contextRoot, dir));
       if (!isPathInsidePath(normalized, absDir) || normalized === absDir) continue;
       const relative = normalized.slice(absDir.length + 1);
-      const depth = relative.split('/').length - 1;
-      // Only files directly under the localeDir or one level deep (the locale
-      // directory itself) are locale files, matching the loaders.
-      if (depth <= 1) return { context, dir: absDir, relative };
+      return { context, dir: absDir, relative };
     }
   }
   return undefined;
@@ -646,35 +650,52 @@ function loadLocalesForContext(context) {
 
   const locales = {};
   const localeTexts = {};
-  for (const dir of context.config.localeDirs) {
-    const fullDir = path.join(context.root, dir);
+  const watchDirectories = new Set();
+  const localeRoots = context.config.localeDirs.map((dir) => path.resolve(context.root, dir));
+  for (const fullDir of localeRoots) {
     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);
+      if (entry.isDirectory()) loadLocaleDirectory(path.join(fullDir, entry.name), entry.name, locales, localeTexts, localeRoots, watchDirectories);
     }
   }
-  const loaded = { locales, localeTexts };
+  const loaded = { locales, localeTexts, watchDirectories: [...watchDirectories] };
   localeCacheByContext.set(cacheKey, loaded);
   return loaded;
 }
 
-function loadLocaleDirectory(localeDir, localeName, next, localeTexts) {
-  next[localeName] ||= { path: localeDir, flat: {}, files: [] };
-  next[localeName].directories ||= [];
-  if (!next[localeName].directories.includes(localeDir)) next[localeName].directories.push(localeDir);
-  for (const file of fs.readdirSync(localeDir).sort()) {
+function loadLocaleDirectory(localeDir, localeName, next, localeTexts, localeRoots, watchDirectories, rootDir = localeDir) {
+  // An explicit locale root owns its subtree, independently of config order.
+  if (localeRoots.includes(localeDir)) return;
+  // Fileless directories still need watching, but must not create phantom locales.
+  watchDirectories.add(localeDir);
+  for (const entry of fs.readdirSync(localeDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    const file = entry.name;
     const fullPath = path.join(localeDir, file);
-    if (fs.statSync(fullPath).isDirectory()) continue;
+    if (entry.isDirectory()) {
+      loadLocaleDirectory(fullPath, localeName, next, localeTexts, localeRoots, watchDirectories, rootDir);
+      continue;
+    }
     if (!LOCALE_FILE_RE.test(file)) continue;
-    if (!next[localeName].files.includes(fullPath)) next[localeName].files.push(fullPath);
+    if (entry.isSymbolicLink() && fs.statSync(fullPath).isDirectory()) continue;
+    next[localeName] ||= { path: rootDir, flat: {}, keyFiles: {}, files: [] };
+    const locale = next[localeName];
+    locale.directories ||= [];
+    if (!locale.directories.includes(rootDir)) locale.directories.push(rootDir);
+    locale.filePrefixes ||= {};
+    const relativeFile = path.relative(rootDir, fullPath);
+    if (!locale.files.includes(fullPath)) locale.files.push(fullPath);
+    locale.filePrefixes[fullPath] = localeFilePrefix(relativeFile);
     try {
       const text = localeText(fullPath);
       if (text === undefined) continue;
       localeTexts[fullPath] = text;
-      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;
+      const flat = prefixByFile(relativeFile, file.endsWith('.json')
+        ? flattenLocale(JSON.parse(text)) : parseTsLocaleModule(text, file));
+      for (const [key, value] of Object.entries(flat)) {
+        locale.flat[key] = value;
+        locale.keyFiles[key] = fullPath;
+      }
     } catch (error) { connection.console.warn('Failed to load locale file ' + fullPath + ': ' + error.message); }
   }
 }
@@ -698,7 +719,9 @@ function loadLocaleFiles(fullDir, next, localeTexts) {
       const isModule = /\.[cm]?[tj]s$/i.test(file);
       if (!isJson && !isModule) continue;
       const name = file.replace(/\.(json|[cm]?[tj]s)$/i, '');
-      next[name] ||= { path: fullPath, flat: {}, files: [], topLevelFiles: [] };
+      next[name] ||= { path: fullPath, flat: {}, keyFiles: {}, files: [], topLevelFiles: [] };
+      next[name].filePrefixes ||= {};
+      next[name].filePrefixes[fullPath] = '';
       next[name].topLevelFiles ||= [];
       if (!next[name].files.includes(fullPath)) next[name].files.push(fullPath);
       if (!next[name].topLevelFiles.includes(fullPath)) next[name].topLevelFiles.push(fullPath);
@@ -706,15 +729,25 @@ function loadLocaleFiles(fullDir, next, localeTexts) {
       if (text === undefined) continue;
       localeTexts[fullPath] = text;
       const flat = isJson ? flattenLocale(JSON.parse(text)) : parseTsLocaleModule(text, 'index.ts');
-      Object.assign(next[name].flat, flat);
+      for (const [key, value] of Object.entries(flat)) {
+        next[name].flat[key] = value;
+        next[name].keyFiles[key] = fullPath;
+      }
     } 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]));
+  const prefix = localeFilePrefix(file);
+  if (!prefix) return flat;
+  return Object.fromEntries(Object.entries(flat).map(([key, value]) => [prefix + '.' + key, value]));
+}
+
+function localeFilePrefix(file) {
+  const segments = file.replace(/\\/g, '/').split('/');
+  const stem = segments.pop().replace(/\.[^.]+$/, '');
+  if (stem !== 'index') segments.push(stem);
+  return segments.join('.');
 }
 
 documents.listen(connection);