@staticbolt/lsp 1.0.0-beta.25 → 1.0.0-beta.27

package/src/modes/html-mode.ts

@@ -3,22 +3,36 @@ import path from "node:path";
 import { Resolver } from "@staticbolt/core";
 import * as vscodeUri from "vscode-uri";
 
+import { createMergedHtmlDataProvider } from "../helpers/merge-html-data.ts";
 import { getLanguageModelCache } from "../language-model-cache.ts";
 import { FILE_PROTOCOL } from "./language-modes.ts";
 
 import type { LanguageMode } from "./language-modes.ts";
-import type { HTMLDataV1, HTMLDocument, LanguageService, TextDocument } from "vscode-html-languageservice";
+import type { HTMLDataV1, HTMLDocument, IHTMLDataProvider, LanguageService, TextDocument } from "vscode-html-languageservice";
 
 export function getHTMLMode(htmlLanguageService: LanguageService): LanguageMode {
   const htmlDocuments = getLanguageModelCache<HTMLDocument>(10, 60, document => htmlLanguageService.parseHTMLDocument(document));
 
+  // the merged provider is rebuilt only when the collected html data actually changes
+  let lastHtmlData: HTMLDataV1[] | undefined;
+  let lastProvider: IHTMLDataProvider | undefined;
+
+  function setHtmlDataProviders(htmlData: HTMLDataV1[]) {
+    if (!lastProvider || lastHtmlData !== htmlData) {
+      lastHtmlData = htmlData;
+      lastProvider = createMergedHtmlDataProvider(FILE_PROTOCOL, htmlData);
+    }
+
+    htmlLanguageService.setDataProviders(false, [lastProvider]);
+  }
+
   return {
     getId() {
       return "html";
     },
 
     async doComplete(document, position, documentContext, htmlData) {
-      setHtmlDataProviders(htmlLanguageService, htmlData);
+      setHtmlDataProviders(htmlData);
 
       const htmlDocument = htmlDocuments.get(document);
       const completionList = await htmlLanguageService.doComplete2(document, position, htmlDocument, documentContext);
@@ -31,7 +45,7 @@ export function getHTMLMode(htmlLanguageService: LanguageService): LanguageMode
     },
 
     async doHover(document, position, htmlData) {
-      setHtmlDataProviders(htmlLanguageService, htmlData);
+      setHtmlDataProviders(htmlData);
 
       return htmlLanguageService.doHover(document, position, htmlDocuments.get(document));
     },
@@ -67,33 +81,3 @@ export function getHTMLMode(htmlLanguageService: LanguageService): LanguageMode
     },
   };
 }
-
-function setHtmlDataProviders(htmlLanguageService: LanguageService, htmlData: HTMLDataV1[]) {
-  htmlLanguageService.setDataProviders(false, [
-    {
-      getId() {
-        return FILE_PROTOCOL;
-      },
-      isApplicable(languageId) {
-        return languageId === "html";
-      },
-      provideValues(tag, attribute) {
-        const tags = htmlData.flatMap(data => data.tags?.filter(t => t.name === tag) ?? []);
-        const attributes = tags.flatMap(t => t.attributes?.filter(a => a.name === attribute) ?? []);
-        const globalAttributes = htmlData.flatMap(data => data.globalAttributes?.filter(a => a.name === attribute) ?? []);
-        const values = [...globalAttributes, ...attributes].flatMap(a => a.values ?? []);
-        return values;
-      },
-      provideTags() {
-        const tags = htmlData.flatMap(data => data.tags ?? []);
-        return tags;
-      },
-      provideAttributes(tag: string) {
-        const tags = htmlData.flatMap(data => data.tags?.filter(t => t.name === tag) ?? []);
-        const globalAttributes = htmlData.flatMap(data => data.globalAttributes ?? []);
-        const attributes = tags.flatMap(t => t.attributes ?? []);
-        return [...globalAttributes, ...attributes];
-      },
-    },
-  ]);
-}

package/src/modes/language-modes.ts

@@ -7,44 +7,10 @@ import { getHTMLMode } from "./html-mode.ts";
 import type { LanguageModelCache } from "../language-model-cache.ts";
 import type { FileSystemProvider } from "../requests.ts";
 import type { HTMLDocumentRegions } from "./embedded-support.ts";
-import type {
-  ClientCapabilities,
-  CompletionConfiguration,
-  DocumentContext,
-  HoverSettings,
-  HTMLDataV1,
-  IHTMLDataProvider,
-} from "vscode-html-languageservice";
-import type {
-  CompletionItem,
-  CompletionList,
-  DocumentLink,
-  Hover,
-  Position,
-  Range,
-  WorkspaceFolder,
-} from "vscode-languageserver";
+import type { ClientCapabilities, DocumentContext, HTMLDataV1, IHTMLDataProvider } from "vscode-html-languageservice";
+import type { CompletionItem, CompletionList, DocumentLink, Hover, Position } from "vscode-languageserver";
 import type { TextDocument } from "vscode-languageserver-textdocument";
 
-export interface Settings {
-  hover?: HoverSettings;
-  autoClosingTags?: boolean;
-  completion?: CompletionConfiguration;
-  suggest?: CompletionConfiguration;
-}
-
-export interface Workspace {
-  readonly settings: Settings;
-  readonly folders: WorkspaceFolder[];
-}
-
-export interface SemanticTokenData {
-  start: Position;
-  length: number;
-  typeIdx: number;
-  modifierSet: number;
-}
-
 export type CompletionItemData = {
   languageId: string;
   uri: string;
@@ -72,20 +38,15 @@ export interface LanguageMode {
 
 export interface LanguageModes {
   updateDataProviders(dataProviders: IHTMLDataProvider[]): void;
+  /** The document to hand to the HTML mode: itself for an HTML file, a copy holding only the raw HTML for a markdown one. */
+  getHtmlDocument(document: TextDocument): TextDocument;
   getModeAtPosition(document: TextDocument, position: Position): LanguageMode | undefined;
-  getModesInRange(document: TextDocument, range: Range): LanguageModeRange[];
-  getAllModes(): LanguageMode[];
   getAllModesInDocument(document: TextDocument): LanguageMode[];
   getMode(languageId: string): LanguageMode | undefined;
   onDocumentRemoved(document: TextDocument): void;
   dispose(): void;
 }
 
-export interface LanguageModeRange extends Range {
-  mode: LanguageMode | undefined;
-  attributeValue?: boolean;
-}
-
 export const FILE_PROTOCOL = "staticbolt-server";
 
 export function getLanguageModes(clientCapabilities: ClientCapabilities, requestService: FileSystemProvider): LanguageModes {
@@ -140,6 +101,10 @@ export function getLanguageModes(clientCapabilities: ClientCapabilities, request
       htmlLanguageService.setDataProviders(true, dataProviders);
     },
 
+    getHtmlDocument(document: TextDocument): TextDocument {
+      return documentRegions.get(document).getHtmlDocument();
+    },
+
     getModeAtPosition(document: TextDocument, position: Position): LanguageMode | undefined {
       const languageId = documentRegions.get(document).getLanguageAtPosition(position);
       if (languageId) {
@@ -149,20 +114,6 @@ export function getLanguageModes(clientCapabilities: ClientCapabilities, request
       return undefined;
     },
 
-    getModesInRange(document: TextDocument, range: Range): LanguageModeRange[] {
-      return documentRegions
-        .get(document)
-        .getLanguageRanges(range)
-        .map((r): LanguageModeRange => {
-          return {
-            start: r.start,
-            end: r.end,
-            mode: r.languageId ? modes[r.languageId] : undefined,
-            attributeValue: r.attributeValue,
-          };
-        });
-    },
-
     getAllModesInDocument(document: TextDocument): LanguageMode[] {
       const result: LanguageMode[] = [];
       for (const languageId of documentRegions.get(document).getLanguagesInDocument()) {
@@ -175,18 +126,6 @@ export function getLanguageModes(clientCapabilities: ClientCapabilities, request
       return result;
     },
 
-    getAllModes(): LanguageMode[] {
-      const result = [];
-      for (const languageId in modes) {
-        const mode = modes[languageId];
-        if (mode) {
-          result.push(mode);
-        }
-      }
-
-      return result;
-    },
-
     getMode(languageId: string): LanguageMode {
       return modes[languageId];
     },

package/src/modes/markdown-regions.ts

@@ -0,0 +1,92 @@
+/**
+ * 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.
+ */
+import { markdownToMdast } from "satteri";
+
+import type { MdastNode } from "satteri";
+
+export interface TextRegion {
+  start: number;
+  end: number;
+}
+
+/** None of these nest, so the regions they produce never overlap. */
+const NON_HTML_NODES = new Set(["code", "inlineCode", "yaml", "toml"]);
+
+/** The regions of a markdown document that must not be treated as HTML, sorted by start offset. */
+export function findMarkdownNonHtmlRegions(text: string): TextRegion[] {
+  let tree: MdastNode;
+
+  try {
+    tree = markdownToMdast(text);
+  } catch (error) {
+    console.warn("[staticbolt] could not parse markdown, its whole content is handled as HTML:", error);
+    return [];
+  }
+
+  const regions: TextRegion[] = [];
+  const pending: MdastNode[] = [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 !== undefined && end !== undefined) {
+        regions.push({ start, end });
+      }
+
+      continue;
+    }
+
+    if ("children" in node) {
+      pending.push(...node.children);
+    }
+  }
+
+  const sorted = regions.toSorted((a, b) => a.start - b.start);
+
+  return toUtf16Offsets(text, sorted);
+}
+
+/**
+ * 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: string, regions: TextRegion[]): TextRegion[] {
+  if (!/[\uD800-\uDBFF]/.test(text)) return regions;
+
+  const astral: number[] = [];
+  let codePoint = 0;
+
+  for (const character of text) {
+    if (character.length === 2) {
+      astral.push(codePoint);
+    }
+
+    codePoint++;
+  }
+
+  const toUtf16 = (offset: number) => 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. */
+export function blankRegions(text: string, regions: readonly TextRegion[]): string {
+  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);
+}