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

package/src/helpers/merge-html-data.ts

@@ -0,0 +1,253 @@
+import type {
+  HTMLDataV1,
+  IAttributeData,
+  IHTMLDataProvider,
+  IReference,
+  ITagData,
+  IValueData,
+  MarkupContent,
+} from "vscode-html-languageservice";
+
+type Description = string | MarkupContent | undefined;
+type DescriptionKind = MarkupContent["kind"];
+type ValueSets = Map<string, IValueData[]>;
+
+/** Separates the documentation of two contributors. Rendered as a horizontal rule, unless the description is plain text. */
+const MARKDOWN_SEPARATOR = "\n\n---\n\n";
+const PLAINTEXT_SEPARATOR = "\n\n";
+
+/** Groups entries by key, preserving the order of first appearance. */
+function groupBy<T>(items: T[], toKey: (item: T) => string): T[][] {
+  const groups = new Map<string, T[]>();
+  const ordered: T[][] = [];
+
+  for (const item of items) {
+    const key = toKey(item);
+
+    let group = groups.get(key);
+    if (!group) {
+      group = [];
+      groups.set(key, group);
+      ordered.push(group);
+    }
+
+    group.push(item);
+  }
+
+  return ordered;
+}
+
+/** Markdown wins over plain text, so a contributor asking for rich text still gets it. Plain strings imply no preference. */
+function mergeDescriptionKind(descriptions: Exclude<Description, undefined>[]): DescriptionKind | undefined {
+  let kind: DescriptionKind | undefined;
+
+  for (const description of descriptions) {
+    if (typeof description === "string" || kind === "markdown") continue;
+    kind = description.kind;
+  }
+
+  return kind;
+}
+
+/** Concatenates every distinct description, so no contributor's documentation gets lost. */
+function mergeDescriptions(descriptions: Description[]): Description {
+  const defined = descriptions.filter(description => description !== undefined);
+
+  // nothing to merge, keep the original as-is
+  if (defined.length <= 1) return defined[0];
+
+  const parts: string[] = [];
+  const seen = new Set<string>();
+
+  for (const description of defined) {
+    const text = (typeof description === "string" ? description : description.value).trim();
+    if (!text || seen.has(text)) continue;
+
+    seen.add(text);
+    parts.push(text);
+  }
+
+  if (parts.length === 0) return undefined;
+
+  const kind = mergeDescriptionKind(defined);
+  const value = parts.join(kind === "plaintext" ? PLAINTEXT_SEPARATOR : MARKDOWN_SEPARATOR);
+
+  return kind ? { kind, value } : value;
+}
+
+function mergeReferences(references: (IReference[] | undefined)[]): IReference[] | undefined {
+  const merged: IReference[] = [];
+  const seen = new Set<string>();
+
+  for (const list of references) {
+    const entries = list ?? [];
+
+    for (const reference of entries) {
+      const key = `${reference.name} ${reference.url}`;
+      if (seen.has(key)) continue;
+
+      seen.add(key);
+      merged.push(reference);
+    }
+  }
+
+  return merged.length > 0 ? merged : undefined;
+}
+
+function mergeBrowsers(browsers: (string[] | undefined)[]): string[] | undefined {
+  const merged = new Set<string>();
+
+  for (const list of browsers) {
+    const entries = list ?? [];
+
+    for (const browser of entries) {
+      merged.add(browser);
+    }
+  }
+
+  return merged.size > 0 ? [...merged] : undefined;
+}
+
+/** The values an attribute contributes, with its `valueSet` reference expanded. */
+function resolveValues(attribute: IAttributeData, valueSets: ValueSets): IValueData[] {
+  const values = attribute.values ?? [];
+  if (!attribute.valueSet) return values;
+
+  return [...(valueSets.get(attribute.valueSet) ?? []), ...values];
+}
+
+/** Merges entries sharing the same value name into one. Unlike tags and attributes, value names are case-sensitive. */
+function mergeValues(values: IValueData[]): IValueData[] {
+  return groupBy(values, value => value.name).map(group => {
+    if (group.length === 1) return group[0];
+
+    return {
+      name: group[0].name,
+      description: mergeDescriptions(group.map(value => value.description)),
+      references: mergeReferences(group.map(value => value.references)),
+      browsers: mergeBrowsers(group.map(value => value.browsers)),
+      status: group.find(value => value.status)?.status,
+    };
+  });
+}
+
+/**
+ * Merges entries sharing the same attribute name into one, combining their descriptions, values, references and browser support.
+ *
+ * `valueSet` references are expanded into the merged `values`, so attributes contributed by different plugins can each bring
+ * their own value set and still end up with a single, complete value list.
+ */
+function mergeAttributes(attributes: IAttributeData[], valueSets: ValueSets): IAttributeData[] {
+  return groupBy(attributes, attribute => attribute.name.toLowerCase()).map(group => {
+    // nothing to merge and no value set to expand, keep the original as-is
+    if (group.length === 1 && !group[0].valueSet) return group[0];
+
+    const values = mergeValues(group.flatMap(attribute => resolveValues(attribute, valueSets)));
+
+    return {
+      name: group[0].name,
+      description: mergeDescriptions(group.map(attribute => attribute.description)),
+      // `valueSet` is dropped on purpose: every referenced set is now expanded into `values`
+      values: values.length > 0 ? values : undefined,
+      references: mergeReferences(group.map(attribute => attribute.references)),
+      browsers: mergeBrowsers(group.map(attribute => attribute.browsers)),
+      status: group.find(attribute => attribute.status)?.status,
+    };
+  });
+}
+
+/** Merges entries sharing the same tag name into one, including their attributes. */
+function mergeTags(tags: ITagData[], valueSets: ValueSets): ITagData[] {
+  return groupBy(tags, tag => tag.name.toLowerCase()).map(group => {
+    const attributes = mergeAttributes(
+      group.flatMap(tag => tag.attributes ?? []),
+      valueSets
+    );
+
+    if (group.length === 1) return { ...group[0], attributes };
+
+    return {
+      name: group[0].name,
+      description: mergeDescriptions(group.map(tag => tag.description)),
+      attributes,
+      references: mergeReferences(group.map(tag => tag.references)),
+      browsers: mergeBrowsers(group.map(tag => tag.browsers)),
+      status: group.find(tag => tag.status)?.status,
+      void: group.some(tag => tag.void),
+    };
+  });
+}
+
+/** Value sets sharing a name are merged, so an attribute referencing one gets the values of every contributor. */
+function collectValueSets(htmlData: HTMLDataV1[]): ValueSets {
+  const valueSets: ValueSets = new Map();
+  const collected = htmlData.flatMap(data => data.valueSets ?? []);
+
+  for (const valueSet of collected) {
+    const existing = valueSets.get(valueSet.name);
+    valueSets.set(valueSet.name, existing ? mergeValues([...existing, ...valueSet.values]) : valueSet.values);
+  }
+
+  return valueSets;
+}
+
+/**
+ * Builds a single data provider out of every collected `HTMLDataV1`, merging tags, attributes and values that share the same name
+ * instead of reporting them once per contributor.
+ */
+export function createMergedHtmlDataProvider(id: string, htmlData: HTMLDataV1[]): IHTMLDataProvider {
+  const valueSets = collectValueSets(htmlData);
+
+  // the language service asks for tags on every parse, and for attributes on every completion/hover, so merging happens once here
+  const tags = mergeTags(
+    htmlData.flatMap(data => data.tags ?? []),
+    valueSets
+  );
+
+  const globalAttributes = mergeAttributes(
+    htmlData.flatMap(data => data.globalAttributes ?? []),
+    valueSets
+  );
+
+  const tagsByName = new Map(tags.map(tag => [tag.name.toLowerCase(), tag]));
+  const attributesByTag = new Map<string, IAttributeData[]>();
+
+  function provideAttributes(tag: string): IAttributeData[] {
+    const key = tag.toLowerCase();
+
+    const cached = attributesByTag.get(key);
+    if (cached) return cached;
+
+    // an unknown tag only sees the global attributes, which are merged already
+    const tagAttributes = tagsByName.get(key)?.attributes;
+    if (!tagAttributes || tagAttributes.length === 0) return globalAttributes;
+
+    const attributes = mergeAttributes([...globalAttributes, ...tagAttributes], valueSets);
+    attributesByTag.set(key, attributes);
+
+    return attributes;
+  }
+
+  return {
+    getId() {
+      return id;
+    },
+
+    isApplicable(languageId) {
+      return languageId === "html";
+    },
+
+    provideTags() {
+      return tags;
+    },
+
+    provideAttributes,
+
+    provideValues(tag, attribute) {
+      const name = attribute.toLowerCase();
+
+      // merged attributes already carry their expanded value sets
+      return provideAttributes(tag).find(a => a.name.toLowerCase() === name)?.values ?? [];
+    },
+  };
+}

package/src/html-server.ts

@@ -4,14 +4,14 @@ import * as vscodeUri from "vscode-uri";
 
 import { ConfigManager } from "./helpers/config-loader.ts";
 import { findStaticboltProjects } from "./helpers/find-projects.ts";
-import { getLanguageModes } from "./modes/language-modes.ts";
+import { getLanguageModes, isCompletionItemData } from "./modes/language-modes.ts";
 import { getFileSystemProvider } from "./requests.ts";
 import { pushAll } from "./utils/arrays.ts";
 import { getDocumentContext } from "./utils/document-context.ts";
 import { findProjectRoot } from "./utils/find-project-root.ts";
 import { runSafe } from "./utils/runner.ts";
 
-import type { CompletionItemData, LanguageModes, Settings } from "./modes/language-modes.ts";
+import type { LanguageModes } from "./modes/language-modes.ts";
 import type { FileSystemProvider } from "./requests.ts";
 import type { Connection, Disposable, InitializeParams, WorkspaceFolder } from "vscode-languageserver";
 
@@ -43,13 +43,6 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
 
   let languageModes: LanguageModes;
 
-  const documentSettings: { [key: string]: Thenable<Settings> } = {};
-
-  // remove document settings on close
-  documents.onDidClose(document => {
-    delete documentSettings[document.document.uri];
-  });
-
   connection.onInitialize((parameters: InitializeParams) => {
     if (Array.isArray(parameters.workspaceFolders)) {
       lspSearchRoots = parameters.workspaceFolders;
@@ -110,8 +103,9 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
         const config = await configManager.get(projectRoot);
         if (!config) return { 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}`,
@@ -132,7 +126,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
         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`,
@@ -156,7 +150,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
         const config = await configManager.get(projectRoot);
         if (!config) 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}`,
@@ -176,10 +170,11 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
 
         const links: vscode.DocumentLink[] = [];
 
+        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));
+            pushAll(links, await mode.findDocumentLinks(htmlDocument, documentContext, projectRoot));
           }
         }
 
@@ -194,7 +189,3 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
   // Listen on the connection
   connection.listen();
 }
-
-export function isCompletionItemData(value: Record<string, unknown>): value is CompletionItemData {
-  return value && typeof value.languageId === "string" && typeof value.uri === "string" && typeof value.offset === "number";
-}

package/src/index.ts

@@ -1,3 +1,4 @@
+import { format, stripVTControlCharacters } from "node:util";
 import * as vs from "vscode-languageserver/node";
 
 import { startServer } from "./html-server.ts";
@@ -10,8 +11,19 @@ import type { Connection, Disposable } from "vscode-languageserver/node";
 // Create a connection for the server.
 const connection: Connection = vs.createConnection();
 
-console.log = connection.console.log.bind(connection.console);
-console.error = connection.console.error.bind(connection.console);
+/**
+ * `RemoteConsole` takes a single string, but the shared logger calls `console` with several arguments and colours them with
+ * chalk. Passing the methods straight through drops everything after the first argument, and the output panel renders no ANSI —
+ * so format the arguments the way `console` would, then strip the escapes.
+ */
+function forward(write: (message: string) => void) {
+  return (...messages: unknown[]) => write(stripVTControlCharacters(format(...messages)));
+}
+
+console.log = forward(connection.console.log.bind(connection.console));
+console.info = forward(connection.console.info.bind(connection.console));
+console.warn = forward(connection.console.warn.bind(connection.console));
+console.error = forward(connection.console.error.bind(connection.console));
 
 process.on("unhandledRejection", (error: unknown) => {
   connection.console.error(formatError(`Unhandled exception`, error));

package/src/modes/embedded-support.ts

@@ -1,40 +1,41 @@
 import vscodeHtml from "vscode-html-languageservice";
 import { TextDocument } from "vscode-languageserver-textdocument";
 
-import type { LanguageService, Range } from "vscode-html-languageservice";
+import { blankRegions, findMarkdownNonHtmlRegions } from "./markdown-regions.ts";
 
-export interface LanguageRange extends Range {
-  languageId: string | undefined;
-  attributeValue?: boolean;
-}
+import type { LanguageService } from "vscode-html-languageservice";
 
 export interface HTMLDocumentRegions {
-  getEmbeddedDocument(languageId: string, shouldIgnoreAttributeValues?: boolean): TextDocument;
-  getLanguageRanges(range: Range): LanguageRange[];
+  /** The document to serve HTML features from: itself for an HTML file, a copy declared as HTML for a markdown one. */
+  getHtmlDocument(): TextDocument;
   getLanguageAtPosition(position: Position): string | undefined;
   getLanguagesInDocument(): string[];
-  getImportedScripts(): string[];
 }
 
-const CSS_STYLE_RULE = "__";
 const TokenType = vscodeHtml.TokenType;
-const Position = vscodeHtml.Position;
 type Position = vscodeHtml.Position;
 
 interface EmbeddedRegion {
   languageId: string | undefined;
   start: number;
   end: number;
-  attributeValue?: boolean;
 }
 
 export function getDocumentRegions(languageService: LanguageService, document: TextDocument): HTMLDocumentRegions {
+  const source = document.getText();
+  const isMarkdown = document.languageId === "markdown";
+
+  const markdownRegions: EmbeddedRegion[] = isMarkdown
+    ? findMarkdownNonHtmlRegions(source).map(region => ({ ...region, languageId: undefined }))
+    : [];
+
+  const htmlText = isMarkdown ? blankRegions(source, markdownRegions) : source;
+
   const regions: EmbeddedRegion[] = [];
-  const scanner = languageService.createScanner(document.getText());
+  const scanner = languageService.createScanner(htmlText);
   let lastTagName: string = "";
   let lastAttributeName: string | null = null;
   let languageIdFromType: string | undefined;
-  const importedScripts: string[] = [];
 
   let token = scanner.scan();
 
@@ -59,13 +60,7 @@ export function getDocumentRegions(languageService: LanguageService, document: T
         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";
@@ -79,12 +74,12 @@ export function getDocumentRegions(languageService: LanguageService, document: T
           if (attributeLanguageId) {
             let start = scanner.getTokenOffset();
             let end = scanner.getTokenEnd();
-            const firstChar = document.getText()[start];
+            const firstChar = htmlText[start];
             if (firstChar === "'" || firstChar === '"') {
               start++;
               end--;
             }
-            regions.push({ languageId: attributeLanguageId, start, end, attributeValue: true });
+            regions.push({ languageId: attributeLanguageId, start, end });
           }
         }
         lastAttributeName = null;
@@ -93,76 +88,43 @@ export function getDocumentRegions(languageService: LanguageService, document: T
     }
     token = scanner.scan();
   }
+
+  const allRegions = mergeRegions(regions, markdownRegions);
+  const htmlDocument = isMarkdown ? TextDocument.create(document.uri, "html", document.version, htmlText) : document;
+
   return {
-    getLanguageRanges: (range: Range) => getLanguageRanges(document, regions, range),
-    getEmbeddedDocument: (languageId: string, shouldIgnoreAttributeValues: boolean) =>
-      getEmbeddedDocument(document, regions, languageId, shouldIgnoreAttributeValues),
-    getLanguageAtPosition: (position: Position) => getLanguageAtPosition(document, regions, position),
-    getLanguagesInDocument: () => getLanguagesInDocument(document, regions),
-    getImportedScripts: () => importedScripts,
+    getLanguageAtPosition: (position: Position) => getLanguageAtPosition(document, allRegions, position),
+    getLanguagesInDocument: () => getLanguagesInDocument(allRegions),
+    getHtmlDocument: () => htmlDocument,
   };
 }
 
-function getLanguageRanges(document: TextDocument, regions: EmbeddedRegion[], range: Range): LanguageRange[] {
-  const result: LanguageRange[] = [];
-  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;
-    }
+/** 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: EmbeddedRegion[], markdown: EmbeddedRegion[]): EmbeddedRegion[] {
+  if (markdown.length === 0) return scanned;
 
-    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",
-    });
+  const merged = [...scanned, ...markdown].toSorted((a, b) => a.start - b.start || b.end - a.end);
+  const result: EmbeddedRegion[] = [];
+
+  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: TextDocument, regions: EmbeddedRegion[]): string[] {
-  const result: string[] = [];
+function getLanguagesInDocument(regions: EmbeddedRegion[]): string[] {
+  const languages = new Set(["html"]);
 
   for (const region of regions) {
-    if (!(region.languageId && !result.includes(region.languageId))) {
-      continue;
-    }
-
-    result.push(region.languageId);
-    if (result.length === 3) {
-      return result;
+    if (region.languageId) {
+      languages.add(region.languageId);
     }
   }
 
-  result.push("html");
-
-  return result;
+  return [...languages];
 }
 
 function getLanguageAtPosition(document: TextDocument, regions: EmbeddedRegion[], position: Position): string | undefined {
@@ -179,100 +141,6 @@ function getLanguageAtPosition(document: TextDocument, regions: EmbeddedRegion[]
   return "html";
 }
 
-function getEmbeddedDocument(
-  document: TextDocument,
-  contents: EmbeddedRegion[],
-  languageId: string,
-  shouldIgnoreAttributeValues: boolean
-): TextDocument {
-  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: EmbeddedRegion) {
-  if (c.attributeValue) {
-    switch (c.languageId) {
-      case "css": {
-        return CSS_STYLE_RULE + "{";
-      }
-    }
-  }
-  return "";
-}
-function getSuffix(c: EmbeddedRegion) {
-  if (c.attributeValue) {
-    switch (c.languageId) {
-      case "css": {
-        return "}";
-      }
-      case "javascript": {
-        return ";";
-      }
-    }
-  }
-  return "";
-}
-function updateContent(c: EmbeddedRegion, content: string): string {
-  if (!c.attributeValue && c.languageId === "javascript") {
-    return content.replace(`<!--`, `/* `).replace(`-->`, ` */`);
-  }
-  if (c.languageId === "css") {
-    const quoteEscape = /(&quot;|&#34;)/g;
-    return content.replace(quoteEscape, (match, _, offset: number) => {
-      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: string, start: number, end: number, oldContent: string, before: string, after: string) {
-  result += before;
-  let accumulatedWS = -before.length; // start with a negative value to account for the before string
-  for (let index = start; index < end; index++) {
-    const ch = oldContent[index];
-    if (ch === "\n" || ch === "\r") {
-      // only write new lines, skip the whitespace
-      accumulatedWS = 0;
-      result += ch;
-    } else {
-      accumulatedWS++;
-    }
-  }
-  result = append(result, " ", accumulatedWS - after.length);
-  result += after;
-  return result;
-}
-
-function append(result: string, string_: string, n: number): string {
-  while (n > 0) {
-    if (n & 1) {
-      result += string_;
-    }
-    n >>= 1;
-    string_ += string_;
-  }
-  return result;
-}
-
 function getAttributeLanguage(attributeName: string): string | null {
   const match = attributeName.match(/^(style)$|^(on\w+)$/i);
   if (!match) {