@dialexjs/language-server 0.7.2 → 0.9.2

package/dist/server.mjs

@@ -1,30 +1,10 @@
-import { addMissingKeys, addUnknownKey, buildHover, buildModel, completionContextAt, completionEntries, definitionFor, discoverProjects, findBindings, findReferenceAt, modelForFile } from "./features.mjs";
+import { a as completionEntries, f as findBindings, i as completionContextAt, m as modelForFile, n as addMissingKeys, o as definitionFor, p as buildModel, r as addUnknownKey, s as buildHover, t as discoverProjects, u as findReferenceAt } from "./features-Bpcwl0Es.mjs";
+import { analyzeProject, clearGitignore, createAnalysisCache, generateDictionaries, readStaticConfig, renderGenerated, startGenerateWatcher } from "@dialexjs/cli/api";
+import { TextDocument } from "vscode-languageserver-textdocument";
 import { CodeActionKind, CompletionItemKind, DiagnosticSeverity, DiagnosticTag, DidChangeWatchedFilesNotification, FileChangeType, TextDocumentSyncKind, TextDocuments } from "vscode-languageserver/node.js";
 import fs from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { analyzeProject, clearGitignore, createAnalysisCache, generateDictionaries, readStaticConfig, renderGenerated, startGenerateWatcher } from "@dialexjs/cli/api";
-import { TextDocument } from "vscode-languageserver-textdocument";
-//#region src/server.ts
-const DEFAULT_SETTINGS = {
-	enable: true,
-	unusedKeys: false,
-	autoGenerate: true
-};
-/** Files whose creation or removal can change the set of Dialex projects or what is scanned. */
-const WATCHED_GLOBS = [
-	"**/*.content.ts",
-	"**/dialex.config.*",
-	"**/i18n.config.*",
-	"**/.gitignore"
-];
-function severityOf(issue) {
-	if (issue.code === "unused-key" || issue.code === "unused-dictionary") return DiagnosticSeverity.Hint;
-	switch (issue.level) {
-		case "error": return DiagnosticSeverity.Error;
-		case "warning": return DiagnosticSeverity.Warning;
-		default: return DiagnosticSeverity.Information;
-	}
-}
+//#region src/server/convert.ts
 const COMPLETION_KINDS = {
 	dictionary: CompletionItemKind.Module,
 	group: CompletionItemKind.Folder,
@@ -47,6 +27,28 @@ function replaceAll(text, newText) {
 		newText
 	};
 }
+const uriToPath = (uri) => uri.startsWith("file:") ? fileURLToPath(uri) : void 0;
+/** One line of an open document, without its line break. */
+const lineOf = (document, line) => document.getText({
+	start: {
+		line,
+		character: 0
+	},
+	end: {
+		line: line + 1,
+		character: 0
+	}
+}).replace(/\r?\n$/, "");
+//#endregion
+//#region src/server/diagnostics.ts
+function severityOf(issue) {
+	if (issue.code === "unused-key" || issue.code === "unused-dictionary") return DiagnosticSeverity.Hint;
+	switch (issue.level) {
+		case "error": return DiagnosticSeverity.Error;
+		case "warning": return DiagnosticSeverity.Warning;
+		default: return DiagnosticSeverity.Information;
+	}
+}
 function toDiagnostic(issue) {
 	const severity = severityOf(issue);
 	return {
@@ -83,53 +85,15 @@ function toDiagnostic(issue) {
 		}
 	};
 }
-const uriToPath = (uri) => uri.startsWith("file:") ? fileURLToPath(uri) : void 0;
 /**
-* Wires Dialex's editor features to an LSP connection. Nothing in the project is executed:
-* dictionaries and configs are read from the syntax tree (`runtime: false`).
+* Publishes the issues of every project, one list per file, and an explicit empty list for
+* files that had problems before and have none now.
 */
-function createServer(connection) {
-	const documents = new TextDocuments(TextDocument);
-	const cache = createAnalysisCache();
-	const states = /* @__PURE__ */ new Map();
-	const projectCache = /* @__PURE__ */ new Map();
-	let folders = [];
-	let canConfigure = false;
-	let settings = { ...DEFAULT_SETTINGS };
+function createPublisher(connection) {
 	let published = /* @__PURE__ */ new Set();
-	let timer;
-	let generateTimer;
-	/** True when the client sends file events itself; otherwise the server watches the disk. */
-	let clientWatches = false;
-	const watchers = /* @__PURE__ */ new Map();
-	const projectsIn = (folder) => {
-		let projects = projectCache.get(folder);
-		if (!projects) {
-			projects = discoverProjects(folder);
-			projectCache.set(folder, projects);
-		}
-		return projects;
-	};
-	const forgetLayout = () => {
-		projectCache.clear();
-		clearGitignore(cache);
-	};
-	async function loadSettings() {
-		settings = { ...DEFAULT_SETTINGS };
-		if (!canConfigure) return;
-		try {
-			const value = await connection.workspace.getConfiguration("dialex");
-			if (value && typeof value === "object") {
-				if (typeof value.enable === "boolean") settings.enable = value.enable;
-				if (typeof value.unusedKeys === "boolean") settings.unusedKeys = value.unusedKeys;
-				if (typeof value.autoGenerate === "boolean") settings.autoGenerate = value.autoGenerate;
-				if (typeof value.configPath === "string" && value.configPath) settings.configPath = value.configPath;
-			}
-		} catch {}
-	}
-	function publish() {
+	return (issues) => {
 		const byFile = /* @__PURE__ */ new Map();
-		for (const { issues } of states.values()) for (const issue of issues) {
+		for (const issue of issues) {
 			const list = byFile.get(issue.file) ?? [];
 			list.push(toDiagnostic(issue));
 			byFile.set(issue.file, list);
@@ -148,13 +112,20 @@ function createServer(connection) {
 			diagnostics: []
 		});
 		published = next;
-	}
+	};
+}
+//#endregion
+//#region src/server/generation.ts
+/** Keeps the generated files of the projects that have them current, and watches the disk. */
+function createGeneration(context) {
+	const { connection } = context;
+	const watchers = /* @__PURE__ */ new Map();
 	/** The projects whose generated file exists; the others do not use one. */
 	function generatedProjects() {
 		const found = [];
-		for (const folder of folders) for (const { root } of projectsIn(folder)) {
+		for (const folder of context.folders()) for (const { root } of context.projectsIn(folder)) {
 			const options = {
-				config: settings.configPath,
+				config: context.settings().configPath,
 				static: true
 			};
 			try {
@@ -173,6 +144,7 @@ function createServer(connection) {
 	* tree, so no project code runs.
 	*/
 	async function regenerate() {
+		const settings = context.settings();
 		if (!settings.autoGenerate || !settings.enable) return;
 		for (const { root, options } of generatedProjects()) try {
 			const { outputPath } = renderGenerated(root, options);
@@ -186,7 +158,8 @@ function createServer(connection) {
 	/** Without client file events, watch each project that has a generated file ourselves. */
 	async function syncWatchers() {
 		const wanted = /* @__PURE__ */ new Map();
-		if (!clientWatches && settings.autoGenerate && settings.enable) for (const { root, options } of generatedProjects()) wanted.set(root, options);
+		const settings = context.settings();
+		if (!context.clientWatches() && settings.autoGenerate && settings.enable) for (const { root, options } of generatedProjects()) wanted.set(root, options);
 		for (const [root, watcher] of watchers) if (!wanted.has(root)) {
 			watchers.delete(root);
 			await watcher.close();
@@ -195,13 +168,232 @@ function createServer(connection) {
 			if (watchers.has(root)) continue;
 			try {
 				watchers.set(root, startGenerateWatcher(root, options, () => {
-					regenerate().then(() => schedule());
+					regenerate().then(() => context.afterWatchRegenerate());
 				}, 250, (message) => connection.console.info(`[${root}] ${message}`)));
 			} catch (error) {
 				connection.console.error(`[${root}] could not watch: ${error.message}`);
 			}
 		}
 	}
+	async function dispose() {
+		await Promise.all([...watchers.values()].map((watcher) => watcher.close()));
+		watchers.clear();
+	}
+	return {
+		regenerate,
+		syncWatchers,
+		dispose
+	};
+}
+//#endregion
+//#region src/server/handlers.ts
+const hoverHandler = (ctx) => (params) => {
+	const document = ctx.documents.get(params.textDocument.uri);
+	const file = uriToPath(params.textDocument.uri);
+	const model = document && file ? ctx.modelFor(file) : void 0;
+	if (!document || !model) return null;
+	const ref = findReferenceAt(lineOf(document, params.position.line), params.position.character, findBindings(document.getText()));
+	const markdown = ref ? buildHover(model, ref) : void 0;
+	if (!ref || !markdown) return null;
+	return {
+		contents: {
+			kind: "markdown",
+			value: markdown
+		},
+		range: {
+			start: {
+				line: params.position.line,
+				character: ref.start
+			},
+			end: {
+				line: params.position.line,
+				character: ref.end
+			}
+		}
+	};
+};
+const definitionHandler = (ctx) => (params) => {
+	const document = ctx.documents.get(params.textDocument.uri);
+	const file = uriToPath(params.textDocument.uri);
+	const model = document && file ? ctx.modelFor(file) : void 0;
+	if (!document || !model) return null;
+	const ref = findReferenceAt(lineOf(document, params.position.line), params.position.character, findBindings(document.getText()));
+	const target = ref ? definitionFor(model, ref) : void 0;
+	if (!target) return null;
+	return {
+		uri: pathToFileURL(target.file).href,
+		range: {
+			start: {
+				line: target.range.start.line,
+				character: target.range.start.column
+			},
+			end: {
+				line: target.range.end.line,
+				character: target.range.end.column
+			}
+		}
+	};
+};
+const completionHandler = (ctx) => (params) => {
+	const document = ctx.documents.get(params.textDocument.uri);
+	const file = uriToPath(params.textDocument.uri);
+	const model = document && file ? ctx.modelFor(file) : void 0;
+	if (!document || !model) return [];
+	const before = lineOf(document, params.position.line).slice(0, params.position.character);
+	const context = completionContextAt(before, findBindings(document.getText()));
+	if (!context) return [];
+	const range = {
+		start: {
+			line: params.position.line,
+			character: params.position.character - context.length
+		},
+		end: params.position
+	};
+	return completionEntries(model, context).map((entry) => ({
+		label: entry.label,
+		kind: COMPLETION_KINDS[entry.kind],
+		detail: entry.detail,
+		documentation: entry.documentation,
+		filterText: entry.label,
+		textEdit: {
+			range,
+			newText: entry.insertText
+		}
+	}));
+};
+const codeActionHandler = (ctx) => (params) => {
+	const file = uriToPath(params.textDocument.uri);
+	const document = ctx.documents.get(params.textDocument.uri);
+	if (!file || !document || !ctx.enabled()) return [];
+	const actions = [];
+	const text = document.getText();
+	const model = ctx.modelFor(file);
+	for (const diagnostic of params.context.diagnostics) {
+		const data = diagnostic.data;
+		if (diagnostic.source !== "dialex" || !data?.path) continue;
+		if (data.code === "missing-key" && data.locale) {
+			const updated = addMissingKeys(file, text, [{
+				locale: data.locale,
+				path: data.path,
+				sourceLocale: data.sourceLocale
+			}]);
+			if (!updated) continue;
+			actions.push({
+				title: `Add "${data.path.join(".")}" to ${data.locale} (marked [TODO])`,
+				kind: CodeActionKind.QuickFix,
+				diagnostics: [diagnostic],
+				isPreferred: true,
+				edit: { changes: { [params.textDocument.uri]: [replaceAll(text, updated)] } }
+			});
+		}
+		if (data.code === "unknown-path" && data.dictionary) {
+			const dictionary = model?.dictionaries.get(data.dictionary);
+			if (!dictionary) continue;
+			const dictionaryUri = pathToFileURL(dictionary.file).href;
+			const open = ctx.documents.get(dictionaryUri);
+			let dictionaryText;
+			try {
+				dictionaryText = open ? open.getText() : fs.readFileSync(dictionary.file, "utf-8");
+			} catch {
+				continue;
+			}
+			const updated = addUnknownKey(dictionary.file, dictionaryText, data.path);
+			if (!updated) continue;
+			actions.push({
+				title: `Add "${data.path.join(".")}" to the "${dictionary.name}" dictionary`,
+				kind: CodeActionKind.QuickFix,
+				diagnostics: [diagnostic],
+				edit: { changes: { [dictionaryUri]: [replaceAll(dictionaryText, updated)] } }
+			});
+		}
+	}
+	const missing = ctx.issues().filter((issue) => issue.file === file && issue.code === "missing-key").filter((issue) => issue.locale && issue.path).map((issue) => ({
+		locale: issue.locale,
+		path: issue.path,
+		sourceLocale: issue.sourceLocale
+	}));
+	if (missing.length > 1) {
+		const updated = addMissingKeys(file, text, missing);
+		if (updated) actions.push({
+			title: `Add all ${missing.length} missing keys (marked [TODO])`,
+			kind: CodeActionKind.QuickFix,
+			edit: { changes: { [params.textDocument.uri]: [replaceAll(text, updated)] } }
+		});
+	}
+	return actions;
+};
+//#endregion
+//#region src/server/settings.ts
+const DEFAULT_SETTINGS = {
+	enable: true,
+	diagnostics: true,
+	unusedKeys: false,
+	autoGenerate: true
+};
+/** Files whose creation or removal can change the set of Dialex projects or what is scanned. */
+const WATCHED_GLOBS = [
+	"**/*.content.ts",
+	"**/dialex.config.*",
+	"**/i18n.config.*",
+	"**/.gitignore"
+];
+/** Copies the values the client sent for the `dialex` section onto `settings`. */
+function applyClientSettings(settings, value) {
+	const sent = value;
+	if (sent && typeof sent === "object") {
+		if (typeof sent.enable === "boolean") settings.enable = sent.enable;
+		if (typeof sent.diagnostics === "boolean") settings.diagnostics = sent.diagnostics;
+		if (typeof sent.unusedKeys === "boolean") settings.unusedKeys = sent.unusedKeys;
+		if (typeof sent.autoGenerate === "boolean") settings.autoGenerate = sent.autoGenerate;
+		if (typeof sent.configPath === "string" && sent.configPath) settings.configPath = sent.configPath;
+	}
+}
+//#endregion
+//#region src/server.ts
+/**
+* Wires Dialex's editor features to an LSP connection. Nothing in the project is executed:
+* dictionaries and configs are read from the syntax tree (`runtime: false`).
+*/
+function createServer(connection) {
+	const documents = new TextDocuments(TextDocument);
+	const cache = createAnalysisCache();
+	const states = /* @__PURE__ */ new Map();
+	const projectCache = /* @__PURE__ */ new Map();
+	const publish = createPublisher(connection);
+	let folders = [];
+	let canConfigure = false;
+	let settings = { ...DEFAULT_SETTINGS };
+	let timer;
+	let generateTimer;
+	/** True when the client sends file events itself; otherwise the server watches the disk. */
+	let clientWatches = false;
+	const projectsIn = (folder) => {
+		let projects = projectCache.get(folder);
+		if (!projects) {
+			projects = discoverProjects(folder);
+			projectCache.set(folder, projects);
+		}
+		return projects;
+	};
+	const forgetLayout = () => {
+		projectCache.clear();
+		clearGitignore(cache);
+	};
+	const generation = createGeneration({
+		connection,
+		folders: () => folders,
+		projectsIn,
+		settings: () => settings,
+		clientWatches: () => clientWatches,
+		afterWatchRegenerate: () => schedule()
+	});
+	async function loadSettings() {
+		settings = { ...DEFAULT_SETTINGS };
+		if (!canConfigure) return;
+		try {
+			applyClientSettings(settings, await connection.workspace.getConfiguration("dialex"));
+		} catch {}
+	}
 	async function refresh() {
 		await loadSettings();
 		states.clear();
@@ -223,8 +415,8 @@ function createServer(connection) {
 		} catch (error) {
 			connection.console.error(`[${root}] analysis failed: ${error.message}`);
 		}
-		publish();
-		await syncWatchers();
+		publish(settings.diagnostics ? allIssues() : []);
+		await generation.syncWatchers();
 	}
 	function schedule() {
 		if (timer) clearTimeout(timer);
@@ -232,7 +424,7 @@ function createServer(connection) {
 	}
 	function scheduleGenerate() {
 		if (generateTimer) clearTimeout(generateTimer);
-		generateTimer = setTimeout(() => void regenerate(), 250);
+		generateTimer = setTimeout(() => void generation.regenerate(), 250);
 	}
 	connection.onInitialize((params) => {
 		folders = (params.workspaceFolders ?? []).map((folder) => uriToPath(folder.uri)).filter((path) => path !== void 0);
@@ -285,162 +477,27 @@ function createServer(connection) {
 	connection.onShutdown(() => dispose());
 	/** The project model for a file, unless the features are turned off. */
 	const modelFor = (file) => settings.enable ? modelForFile([...states.values()].map((state) => state.model), file) : void 0;
-	/** One line of an open document, without its line break. */
-	const lineOf = (document, line) => document.getText({
-		start: {
-			line,
-			character: 0
-		},
-		end: {
-			line: line + 1,
-			character: 0
-		}
-	}).replace(/\r?\n$/, "");
-	connection.onHover((params) => {
-		const document = documents.get(params.textDocument.uri);
-		const file = uriToPath(params.textDocument.uri);
-		const model = document && file ? modelFor(file) : void 0;
-		if (!document || !model) return null;
-		const ref = findReferenceAt(lineOf(document, params.position.line), params.position.character, findBindings(document.getText()));
-		const markdown = ref ? buildHover(model, ref) : void 0;
-		if (!ref || !markdown) return null;
-		return {
-			contents: {
-				kind: "markdown",
-				value: markdown
-			},
-			range: {
-				start: {
-					line: params.position.line,
-					character: ref.start
-				},
-				end: {
-					line: params.position.line,
-					character: ref.end
-				}
-			}
-		};
-	});
-	connection.onDefinition((params) => {
-		const document = documents.get(params.textDocument.uri);
-		const file = uriToPath(params.textDocument.uri);
-		const model = document && file ? modelFor(file) : void 0;
-		if (!document || !model) return null;
-		const ref = findReferenceAt(lineOf(document, params.position.line), params.position.character, findBindings(document.getText()));
-		const target = ref ? definitionFor(model, ref) : void 0;
-		if (!target) return null;
-		return {
-			uri: pathToFileURL(target.file).href,
-			range: {
-				start: {
-					line: target.range.start.line,
-					character: target.range.start.column
-				},
-				end: {
-					line: target.range.end.line,
-					character: target.range.end.column
-				}
-			}
-		};
-	});
-	connection.onCompletion((params) => {
-		const document = documents.get(params.textDocument.uri);
-		const file = uriToPath(params.textDocument.uri);
-		const model = document && file ? modelFor(file) : void 0;
-		if (!document || !model) return [];
-		const before = lineOf(document, params.position.line).slice(0, params.position.character);
-		const context = completionContextAt(before, findBindings(document.getText()));
-		if (!context) return [];
-		const range = {
-			start: {
-				line: params.position.line,
-				character: params.position.character - context.length
-			},
-			end: params.position
-		};
-		return completionEntries(model, context).map((entry) => ({
-			label: entry.label,
-			kind: COMPLETION_KINDS[entry.kind],
-			detail: entry.detail,
-			documentation: entry.documentation,
-			filterText: entry.label,
-			textEdit: {
-				range,
-				newText: entry.insertText
-			}
-		}));
-	});
-	connection.onCodeAction((params) => {
-		const file = uriToPath(params.textDocument.uri);
-		const document = documents.get(params.textDocument.uri);
-		if (!file || !document || !settings.enable) return [];
-		const actions = [];
-		const text = document.getText();
-		const model = modelFor(file);
-		for (const diagnostic of params.context.diagnostics) {
-			const data = diagnostic.data;
-			if (diagnostic.source !== "dialex" || !data?.path) continue;
-			if (data.code === "missing-key" && data.locale) {
-				const updated = addMissingKeys(file, text, [{
-					locale: data.locale,
-					path: data.path,
-					sourceLocale: data.sourceLocale
-				}]);
-				if (!updated) continue;
-				actions.push({
-					title: `Add "${data.path.join(".")}" to ${data.locale} (marked [TODO])`,
-					kind: CodeActionKind.QuickFix,
-					diagnostics: [diagnostic],
-					isPreferred: true,
-					edit: { changes: { [params.textDocument.uri]: [replaceAll(text, updated)] } }
-				});
-			}
-			if (data.code === "unknown-path" && data.dictionary) {
-				const dictionary = model?.dictionaries.get(data.dictionary);
-				if (!dictionary) continue;
-				const dictionaryUri = pathToFileURL(dictionary.file).href;
-				const open = documents.get(dictionaryUri);
-				let dictionaryText;
-				try {
-					dictionaryText = open ? open.getText() : fs.readFileSync(dictionary.file, "utf-8");
-				} catch {
-					continue;
-				}
-				const updated = addUnknownKey(dictionary.file, dictionaryText, data.path);
-				if (!updated) continue;
-				actions.push({
-					title: `Add "${data.path.join(".")}" to the "${dictionary.name}" dictionary`,
-					kind: CodeActionKind.QuickFix,
-					diagnostics: [diagnostic],
-					edit: { changes: { [dictionaryUri]: [replaceAll(dictionaryText, updated)] } }
-				});
-			}
-		}
-		const missing = [...states.values()].flatMap((state) => state.issues).filter((issue) => issue.file === file && issue.code === "missing-key").filter((issue) => issue.locale && issue.path).map((issue) => ({
-			locale: issue.locale,
-			path: issue.path,
-			sourceLocale: issue.sourceLocale
-		}));
-		if (missing.length > 1) {
-			const updated = addMissingKeys(file, text, missing);
-			if (updated) actions.push({
-				title: `Add all ${missing.length} missing keys (marked [TODO])`,
-				kind: CodeActionKind.QuickFix,
-				edit: { changes: { [params.textDocument.uri]: [replaceAll(text, updated)] } }
-			});
-		}
-		return actions;
-	});
+	/** The issues of every project, in project order. */
+	const allIssues = () => [...states.values()].flatMap((state) => state.issues);
+	const handlers = {
+		documents,
+		modelFor,
+		issues: allIssues,
+		enabled: () => settings.enable
+	};
+	connection.onHover(hoverHandler(handlers));
+	connection.onDefinition(definitionHandler(handlers));
+	connection.onCompletion(completionHandler(handlers));
+	connection.onCodeAction(codeActionHandler(handlers));
 	documents.listen(connection);
 	async function dispose() {
 		if (timer) clearTimeout(timer);
 		if (generateTimer) clearTimeout(generateTimer);
-		await Promise.all([...watchers.values()].map((watcher) => watcher.close()));
-		watchers.clear();
+		await generation.dispose();
 	}
 	return {
 		refresh,
-		regenerate,
+		regenerate: generation.regenerate,
 		dispose
 	};
 }