@staticbolt/lsp 1.0.0-beta.26 → 1.0.0-beta.28

package/lib/index.mjs

@@ -12,10 +12,12 @@ import * as path$1 from "node:path";
 import path, { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import vscodeHtml from "vscode-html-languageservice";
+import { markdownToMdast } from "satteri";
 import { Resolver } from "@staticbolt/core";
 
 //#region src/helpers/config-loader.ts
-const CONFIG_CANDIDATES = [".staticbolt.ts", ".staticbolt.js"];
+/** Iterated in order, so the first one that exists wins. */
+const CONFIG_CANDIDATES = /* @__PURE__ */ new Set([".staticbolt.ts", ".staticbolt.js"]);
 async function findConfigFile(workspaceRoot) {
 	for (const name of CONFIG_CANDIDATES) {
 		const full = join(workspaceRoot, name);
@@ -47,7 +49,7 @@ var ConfigLoader = class extends EventEmitter {
 		this.configPath = await findConfigFile(this.workspaceRoot);
 		if (!this.configPath) return null;
 		await this.load();
-		this.watch(this.configPath);
+		this.watch();
 		return this.current;
 	}
 	/** Stop watching and release all resources. */
@@ -69,9 +71,13 @@ var ConfigLoader = class extends EventEmitter {
 			this.emit("error", error instanceof Error ? error : new Error(String(error)));
 		}
 	}
-	watch(configPath) {
-		this.watcher = watch(configPath, { persistent: false }, (event) => {
-			if (event === "rename" || event === "change") this.scheduleReload();
+	/**
+	* The directory is watched rather than the file. A watch on the file itself is bound to the inode, so an editor saving through
+	* a temporary file and a rename leaves it watching a replaced file, and on macOS it never reports a plain write either.
+	*/
+	watch() {
+		this.watcher = watch(this.workspaceRoot, { persistent: false }, (_event, filename) => {
+			if (typeof filename === "string" && CONFIG_CANDIDATES.has(filename)) this.scheduleReload();
 		});
 		this.watcher.on("error", (error) => this.emit("error", error));
 	}
@@ -79,11 +85,9 @@ var ConfigLoader = class extends EventEmitter {
 		if (this.debounceTimer !== null) clearTimeout(this.debounceTimer);
 		this.debounceTimer = setTimeout(async () => {
 			this.debounceTimer = null;
-			if (!this.configPath) return;
-			try {
-				await access(this.configPath, constants.R_OK);
-			} catch {
-				this.emit("error", /* @__PURE__ */ new Error(`Config file was removed: ${this.configPath}`));
+			this.configPath = await findConfigFile(this.workspaceRoot);
+			if (!this.configPath) {
+				this.emit("error", /* @__PURE__ */ new Error(`Config file was removed from: ${this.workspaceRoot}`));
 				return;
 			}
 			await this.load();
@@ -247,17 +251,92 @@ function getLanguageModelCache(maxEntries, cleanupIntervalTimeInSec, parse) {
 	};
 }
 
+//#endregion
+//#region src/modes/markdown-regions.ts
+/**
+* Markdown allows raw HTML anywhere, so a ".md" file is served as HTML with the parts that can never be HTML — front matter, code
+* blocks and code spans — blanked out first. Blanking keeps every offset, so positions still point at the same place in the
+* file.
+*/
+/** None of these nest, so the regions they produce never overlap. */
+const NON_HTML_NODES = /* @__PURE__ */ new Set([
+	"code",
+	"inlineCode",
+	"yaml",
+	"toml"
+]);
+/** The regions of a markdown document that must not be treated as HTML, sorted by start offset. */
+function findMarkdownNonHtmlRegions(text) {
+	let tree;
+	try {
+		tree = markdownToMdast(text);
+	} catch (error) {
+		console.warn("[staticbolt] could not parse markdown, its whole content is handled as HTML:", error);
+		return [];
+	}
+	const regions = [];
+	const pending = [tree];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if (NON_HTML_NODES.has(node.type)) {
+			const start = node.position?.start.offset;
+			const end = node.position?.end.offset;
+			if (start !== void 0 && end !== void 0) regions.push({
+				start,
+				end
+			});
+			continue;
+		}
+		if ("children" in node) pending.push(...node.children);
+	}
+	return toUtf16Offsets(text, regions.toSorted((a, b) => a.start - b.start));
+}
+/**
+* The parser counts code points, the editor counts UTF-16 code units. The two only drift apart once a character outside the basic
+* plane, an emoji most of the time, sits before a region.
+*/
+function toUtf16Offsets(text, regions) {
+	if (!/[\uD800-\uDBFF]/.test(text)) return regions;
+	const astral = [];
+	let codePoint = 0;
+	for (const character of text) {
+		if (character.length === 2) astral.push(codePoint);
+		codePoint++;
+	}
+	const toUtf16 = (offset) => offset + astral.filter((position) => position < offset).length;
+	return regions.map((region) => ({
+		start: toUtf16(region.start),
+		end: toUtf16(region.end)
+	}));
+}
+/** Replaces every region with spaces, keeping the length of the text and its line breaks. Regions must be sorted and disjoint. */
+function blankRegions(text, regions) {
+	if (regions.length === 0) return text;
+	let result = "";
+	let cursor = 0;
+	for (const region of regions) {
+		result += text.slice(cursor, region.start) + text.slice(region.start, region.end).replaceAll(/[^\n\r]/g, " ");
+		cursor = region.end;
+	}
+	return result + text.slice(cursor);
+}
+
 //#endregion
 //#region src/modes/embedded-support.ts
 const TokenType = vscodeHtml.TokenType;
-const Position = vscodeHtml.Position;
 function getDocumentRegions(languageService, document) {
+	const source = document.getText();
+	const isMarkdown = document.languageId === "markdown";
+	const markdownRegions = isMarkdown ? findMarkdownNonHtmlRegions(source).map((region) => ({
+		...region,
+		languageId: void 0
+	})) : [];
+	const htmlText = isMarkdown ? blankRegions(source, markdownRegions) : source;
 	const regions = [];
-	const scanner = languageService.createScanner(document.getText());
+	const scanner = languageService.createScanner(htmlText);
 	let lastTagName = "";
 	let lastAttributeName = null;
 	let languageIdFromType;
-	const importedScripts = [];
 	let token = scanner.scan();
 	while (token !== TokenType.EOS) {
 		switch (token) {
@@ -284,11 +363,7 @@ function getDocumentRegions(languageService, document) {
 				lastAttributeName = scanner.getTokenText();
 				break;
 			case TokenType.AttributeValue:
-				if (lastAttributeName === "src" && lastTagName.toLowerCase() === "script") {
-					let value = scanner.getTokenText();
-					if (value[0] === "'" || value[0] === "\"") value = value.slice(1, -1);
-					importedScripts.push(value);
-				} else if (lastAttributeName === "type" && lastTagName.toLowerCase() === "script") {
+				if (lastAttributeName === "type" && lastTagName.toLowerCase() === "script") {
 					const token = scanner.getTokenText();
 					if (/["'](module|(text|application)\/(java|ecma)script|text\/babel)["']/.test(token) || token === "module") languageIdFromType = "javascript";
 					else if (/["']text\/typescript["']/.test(token)) languageIdFromType = "typescript";
@@ -298,7 +373,7 @@ function getDocumentRegions(languageService, document) {
 					if (attributeLanguageId) {
 						let start = scanner.getTokenOffset();
 						let end = scanner.getTokenEnd();
-						const firstChar = document.getText()[start];
+						const firstChar = htmlText[start];
 						if (firstChar === "'" || firstChar === "\"") {
 							start++;
 							end--;
@@ -306,8 +381,7 @@ function getDocumentRegions(languageService, document) {
 						regions.push({
 							languageId: attributeLanguageId,
 							start,
-							end,
-							attributeValue: true
+							end
 						});
 					}
 				}
@@ -315,58 +389,30 @@ function getDocumentRegions(languageService, document) {
 		}
 		token = scanner.scan();
 	}
+	const allRegions = mergeRegions(regions, markdownRegions);
+	const htmlDocument = isMarkdown ? TextDocument.create(document.uri, "html", document.version, htmlText) : document;
 	return {
-		getLanguageRanges: (range) => getLanguageRanges(document, regions, range),
-		getEmbeddedDocument: (languageId, shouldIgnoreAttributeValues) => getEmbeddedDocument(document, regions, languageId, shouldIgnoreAttributeValues),
-		getLanguageAtPosition: (position) => getLanguageAtPosition(document, regions, position),
-		getLanguagesInDocument: () => getLanguagesInDocument(document, regions),
-		getImportedScripts: () => importedScripts
+		getLanguageAtPosition: (position) => getLanguageAtPosition(document, allRegions, position),
+		getLanguagesInDocument: () => getLanguagesInDocument(allRegions),
+		getHtmlDocument: () => htmlDocument
 	};
 }
-function getLanguageRanges(document, regions, range) {
+/** The lookups below read the regions in order, so an overlap is dropped: a scanned region always wins over a markdown one. */
+function mergeRegions(scanned, markdown) {
+	if (markdown.length === 0) return scanned;
+	const merged = [...scanned, ...markdown].toSorted((a, b) => a.start - b.start || b.end - a.end);
 	const result = [];
-	let currentPos = range ? range.start : Position.create(0, 0);
-	let currentOffset = range ? document.offsetAt(range.start) : 0;
-	const endOffset = range ? document.offsetAt(range.end) : document.getText().length;
-	for (const region of regions) {
-		if (!(region.end > currentOffset && region.start < endOffset)) continue;
-		const start = Math.max(region.start, currentOffset);
-		const startPos = document.positionAt(start);
-		if (currentOffset < region.start) result.push({
-			start: currentPos,
-			end: startPos,
-			languageId: "html"
-		});
-		const end = Math.min(region.end, endOffset);
-		const endPos = document.positionAt(end);
-		if (end > region.start) result.push({
-			start: startPos,
-			end: endPos,
-			languageId: region.languageId,
-			attributeValue: region.attributeValue
-		});
-		currentOffset = end;
-		currentPos = endPos;
-	}
-	if (currentOffset < endOffset) {
-		const endPos = range ? range.end : document.positionAt(endOffset);
-		result.push({
-			start: currentPos,
-			end: endPos,
-			languageId: "html"
-		});
+	for (const region of merged) {
+		const previous = result.at(-1);
+		if (previous && region.start < previous.end) continue;
+		result.push(region);
 	}
 	return result;
 }
-function getLanguagesInDocument(_document, regions) {
-	const result = [];
-	for (const region of regions) {
-		if (!(region.languageId && !result.includes(region.languageId))) continue;
-		result.push(region.languageId);
-		if (result.length === 3) return result;
-	}
-	result.push("html");
-	return result;
+function getLanguagesInDocument(regions) {
+	const languages = /* @__PURE__ */ new Set(["html"]);
+	for (const region of regions) if (region.languageId) languages.add(region.languageId);
+	return [...languages];
 }
 function getLanguageAtPosition(document, regions, position) {
 	const offset = document.offsetAt(position);
@@ -375,66 +421,6 @@ function getLanguageAtPosition(document, regions, position) {
 	} else break;
 	return "html";
 }
-function getEmbeddedDocument(document, contents, languageId, shouldIgnoreAttributeValues) {
-	let currentPos = 0;
-	const oldContent = document.getText();
-	let result = "";
-	let lastSuffix = "";
-	for (const c of contents) {
-		if (!(c.languageId === languageId && (!shouldIgnoreAttributeValues || !c.attributeValue))) continue;
-		result = substituteWithWhitespace(result, currentPos, c.start, oldContent, lastSuffix, getPrefix(c));
-		result += updateContent(c, oldContent.slice(c.start, c.end));
-		currentPos = c.end;
-		lastSuffix = getSuffix(c);
-	}
-	result = substituteWithWhitespace(result, currentPos, oldContent.length, oldContent, lastSuffix, "");
-	return TextDocument.create(document.uri, languageId, document.version, result);
-}
-function getPrefix(c) {
-	if (c.attributeValue) switch (c.languageId) {
-		case "css": return "__{";
-	}
-	return "";
-}
-function getSuffix(c) {
-	if (c.attributeValue) switch (c.languageId) {
-		case "css": return "}";
-		case "javascript": return ";";
-	}
-	return "";
-}
-function updateContent(c, content) {
-	if (!c.attributeValue && c.languageId === "javascript") return content.replace(`<!--`, `/* `).replace(`-->`, ` */`);
-	if (c.languageId === "css") return content.replace(/(&quot;|&#34;)/g, (match, _, offset) => {
-		const spaces = " ".repeat(match.length - 1);
-		const afterChar = content[offset + match.length];
-		if (!afterChar || afterChar.includes(" ")) return `${spaces}"`;
-		return `"${spaces}`;
-	});
-	return content;
-}
-function substituteWithWhitespace(result, start, end, oldContent, before, after) {
-	result += before;
-	let accumulatedWS = -before.length;
-	for (let index = start; index < end; index++) {
-		const ch = oldContent[index];
-		if (ch === "\n" || ch === "\r") {
-			accumulatedWS = 0;
-			result += ch;
-		} else accumulatedWS++;
-	}
-	result = append(result, " ", accumulatedWS - after.length);
-	result += after;
-	return result;
-}
-function append(result, string_, n) {
-	while (n > 0) {
-		if (n & 1) result += string_;
-		n >>= 1;
-		string_ += string_;
-	}
-	return result;
-}
 function getAttributeLanguage(attributeName) {
 	const match = attributeName.match(/^(style)$|^(on\w+)$/i);
 	if (!match) return null;
@@ -672,6 +658,9 @@ function getHTMLMode(htmlLanguageService) {
 
 //#endregion
 //#region src/modes/language-modes.ts
+function isCompletionItemData(value) {
+	return value && typeof value.languageId === "string" && typeof value.uri === "string" && typeof value.offset === "number";
+}
 const FILE_PROTOCOL = "staticbolt-server";
 function getLanguageModes(clientCapabilities, requestService) {
 	const htmlLanguageService = vscodeHtml.getLanguageService({
@@ -713,20 +702,13 @@ function getLanguageModes(clientCapabilities, requestService) {
 		async updateDataProviders(dataProviders) {
 			htmlLanguageService.setDataProviders(true, dataProviders);
 		},
+		getHtmlDocument(document) {
+			return documentRegions.get(document).getHtmlDocument();
+		},
 		getModeAtPosition(document, position) {
 			const languageId = documentRegions.get(document).getLanguageAtPosition(position);
 			if (languageId) return modes[languageId];
 		},
-		getModesInRange(document, range) {
-			return documentRegions.get(document).getLanguageRanges(range).map((r) => {
-				return {
-					start: r.start,
-					end: r.end,
-					mode: r.languageId ? modes[r.languageId] : void 0,
-					attributeValue: r.attributeValue
-				};
-			});
-		},
 		getAllModesInDocument(document) {
 			const result = [];
 			for (const languageId of documentRegions.get(document).getLanguagesInDocument()) {
@@ -735,14 +717,6 @@ function getLanguageModes(clientCapabilities, requestService) {
 			}
 			return result;
 		},
-		getAllModes() {
-			const result = [];
-			for (const languageId in modes) {
-				const mode = modes[languageId];
-				if (mode) result.push(mode);
-			}
-			return result;
-		},
 		getMode(languageId) {
 			return modes[languageId];
 		},
@@ -884,10 +858,6 @@ function startServer(connection, runtime) {
 	let workspaceFolders = [];
 	let configManager;
 	let languageModes;
-	const documentSettings = {};
-	documents.onDidClose((document) => {
-		delete documentSettings[document.document.uri];
-	});
 	connection.onInitialize((parameters) => {
 		if (Array.isArray(parameters.workspaceFolders)) lspSearchRoots = parameters.workspaceFolders;
 		else {
@@ -942,8 +912,9 @@ function startServer(connection, runtime) {
 				isIncomplete: true,
 				items: []
 			};
+			const htmlDocument = languageModes.getHtmlDocument(document);
 			const documentContext = getDocumentContext(document.uri, workspaceFolders);
-			return mode.doComplete(document, textDocumentPosition.position, documentContext, configManager.lspHtmlData);
+			return mode.doComplete(htmlDocument, textDocumentPosition.position, documentContext, configManager.lspHtmlData);
 		}, null, `Error while computing completions for ${textDocumentPosition.textDocument.uri}`, token);
 	});
 	connection.onCompletionResolve((item, token) => {
@@ -954,7 +925,7 @@ function startServer(connection, runtime) {
 			if (!document) return item;
 			const mode = languageModes.getMode(data.languageId);
 			if (!mode?.doResolve) return item;
-			return mode.doResolve(document, item);
+			return mode.doResolve(languageModes.getHtmlDocument(document), item);
 		}, item, `Error while resolving completion proposal`, token);
 	});
 	connection.onHover((textDocumentPosition, token) => {
@@ -966,7 +937,7 @@ function startServer(connection, runtime) {
 			const mode = languageModes.getModeAtPosition(document, textDocumentPosition.position);
 			if (!mode?.doHover) return null;
 			if (!await configManager.get(projectRoot)) return null;
-			return mode.doHover(document, textDocumentPosition.position, configManager.lspHtmlData);
+			return mode.doHover(languageModes.getHtmlDocument(document), textDocumentPosition.position, configManager.lspHtmlData);
 		}, null, `Error while computing hover for ${textDocumentPosition.textDocument.uri}`, token);
 	});
 	connection.onDocumentLinks((documentLinkParameter, token) => {
@@ -976,16 +947,14 @@ function startServer(connection, runtime) {
 			const document = documents.get(documentLinkParameter.textDocument.uri);
 			if (!document) return [];
 			const links = [];
+			const htmlDocument = languageModes.getHtmlDocument(document);
 			const documentContext = getDocumentContext(document.uri, workspaceFolders);
-			for (const mode of languageModes.getAllModesInDocument(document)) if (mode.findDocumentLinks) pushAll(links, await mode.findDocumentLinks(document, documentContext, projectRoot));
+			for (const mode of languageModes.getAllModesInDocument(document)) if (mode.findDocumentLinks) pushAll(links, await mode.findDocumentLinks(htmlDocument, documentContext, projectRoot));
 			return links;
 		}, [], `Error while document links for ${documentLinkParameter.textDocument.uri}`, token);
 	});
 	connection.listen();
 }
-function isCompletionItemData(value) {
-	return value && typeof value.languageId === "string" && typeof value.uri === "string" && typeof value.offset === "number";
-}
 
 //#endregion
 //#region src/utils/node-fs.ts