@staticbolt/lsp 1.0.0-beta.30 → 1.0.0-beta.32

package/src/helpers/config-loader.ts

@@ -1,244 +0,0 @@
-import { EventEmitter } from "node:events";
-import { watch, type FSWatcher } from "node:fs";
-import { access, constants } from "node:fs/promises";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-
-import type { AppConfig } from "@staticbolt/core";
-import type { HTMLDataV1 } from "vscode-html-languageservice";
-import type { MarkupContent, RemoteConsole } from "vscode-languageserver";
-
-export type StaticBoltConfig = AppConfig;
-
-export interface ConfigLoaderEvents {
-  change: [config: StaticBoltConfig];
-  error: [err: Error];
-}
-
-/** Iterated in order, so the first one that exists wins. */
-const CONFIG_CANDIDATES = new Set([".staticbolt.ts", ".staticbolt.js"]);
-
-async function findConfigFile(workspaceRoot: string): Promise<string | null> {
-  for (const name of CONFIG_CANDIDATES) {
-    const full = join(workspaceRoot, name);
-
-    try {
-      await access(full, constants.R_OK);
-      return full;
-    } catch {
-      // not found or not readable — try next
-    }
-  }
-
-  return null;
-}
-
-async function importFresh(absolutePath: string): Promise<StaticBoltConfig> {
-  const url = `${pathToFileURL(absolutePath).href}?t=${Date.now()}`;
-  const module_ = (await import(url)) as { default: StaticBoltConfig };
-
-  if (!("default" in module_)) {
-    throw new Error(`Config file "${absolutePath}" has no default export. Use \`export default { … }\`.`);
-  }
-
-  return module_.default;
-}
-
-// eslint-disable-next-line unicorn/prefer-event-target
-export class ConfigLoader extends EventEmitter<ConfigLoaderEvents> {
-  private readonly workspaceRoot: string;
-  private configPath: string | null = null;
-  private watcher: FSWatcher | null = null;
-  private current: StaticBoltConfig | null = null;
-  private debounceTimer: ReturnType<typeof setTimeout> | null = null;
-  private readonly DEBOUNCE_MS = 150;
-
-  constructor(workspaceRoot: string) {
-    super();
-    this.workspaceRoot = workspaceRoot;
-  }
-
-  /** Start watching. Resolves with the initial config (or null if absent). */
-  async start(): Promise<StaticBoltConfig | null> {
-    this.configPath = await findConfigFile(this.workspaceRoot);
-
-    if (!this.configPath) {
-      return null;
-    }
-
-    await this.load();
-    this.watch();
-    return this.current;
-  }
-
-  /** Stop watching and release all resources. */
-  dispose(): void {
-    if (this.debounceTimer !== null) {
-      clearTimeout(this.debounceTimer);
-    }
-    this.watcher?.close();
-    this.watcher = null;
-  }
-
-  /** The last successfully loaded config, or null if none loaded yet. */
-  get config(): StaticBoltConfig | null {
-    return this.current;
-  }
-
-  private async load(): Promise<void> {
-    if (!this.configPath) return;
-
-    try {
-      this.current = await importFresh(this.configPath);
-      this.emit("change", this.current);
-    } catch (error) {
-      this.emit("error", error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * 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.
-   */
-  private watch(): void {
-    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));
-  }
-
-  private scheduleReload(): void {
-    if (this.debounceTimer !== null) {
-      clearTimeout(this.debounceTimer);
-    }
-
-    this.debounceTimer = setTimeout(async () => {
-      this.debounceTimer = null;
-
-      // Resolved again so that renaming ".staticbolt.ts" to ".staticbolt.js", or the other way round, is picked up.
-      this.configPath = await findConfigFile(this.workspaceRoot);
-
-      if (!this.configPath) {
-        this.emit("error", new Error(`Config file was removed from: ${this.workspaceRoot}`));
-        return;
-      }
-
-      await this.load();
-    }, this.DEBOUNCE_MS);
-  }
-}
-
-export class ConfigManager {
-  private readonly console: RemoteConsole;
-  readonly configs = new Map<string, ConfigLoader>();
-  lspHtmlData: HTMLDataV1[] = [];
-
-  constructor(console: RemoteConsole) {
-    this.console = console;
-  }
-
-  async get(workspaceRoot: string): Promise<AppConfig | null> {
-    const configLoader = this.configs.get(workspaceRoot);
-    if (configLoader) {
-      if (!configLoader.config) {
-        this.configs.delete(workspaceRoot);
-        return null;
-      }
-
-      return configLoader.config;
-    }
-
-    const newConfigLoader = new ConfigLoader(workspaceRoot);
-    this.configs.set(workspaceRoot, newConfigLoader);
-
-    newConfigLoader.on("error", error => {
-      this.console.error(`Failed to load config file: ${error.message}`);
-    });
-
-    newConfigLoader.on("change", async config => {
-      await this.collectData(config);
-    });
-
-    await newConfigLoader.start();
-
-    if (!newConfigLoader.config) {
-      return null;
-    }
-
-    return newConfigLoader.config;
-  }
-
-  dispose(): void {
-    for (const configLoader of this.configs.values()) {
-      configLoader.dispose();
-    }
-  }
-
-  private async collectData(config: StaticBoltConfig) {
-    // collected into a new array and published at the end, consumers cache on its identity
-    const collected: HTMLDataV1[] = [];
-
-    const plugins = config.plugins ?? [];
-
-    for (const pluginOrArray of plugins) {
-      const plugins = Array.isArray(pluginOrArray) ? pluginOrArray : [pluginOrArray];
-
-      for (const plugin of plugins) {
-        if (!plugin.lspHtmlData) {
-          continue;
-        }
-
-        const htmlData = await plugin.lspHtmlData();
-        if (htmlData) {
-          htmlDataInjectPluginName(htmlData, plugin.name);
-          collected.push(htmlData);
-        }
-      }
-    }
-
-    this.lspHtmlData = collected;
-  }
-}
-
-function htmlDataInjectPluginName(htmlData: HTMLDataV1, pluginName: string) {
-  const tags = htmlData.tags ?? [];
-  for (const tag of tags) {
-    tag.description = replaceDescription(tag.description, pluginName);
-
-    const attributes = tag.attributes ?? [];
-    for (const attribute of attributes) {
-      attribute.description = replaceDescription(attribute.description, pluginName);
-    }
-  }
-
-  const globalAttributes = htmlData.globalAttributes ?? [];
-  for (const attribute of globalAttributes) {
-    attribute.description = replaceDescription(attribute.description, pluginName);
-  }
-}
-
-function replaceDescription(description: string | MarkupContent | undefined, pluginName: string) {
-  const info = `_Provided by **staticbolt** \`${pluginName}\` plugin._`;
-
-  if (!description) {
-    return info;
-  }
-
-  if (typeof description === "string") {
-    if (description.includes(info)) {
-      return description;
-    }
-
-    return `${description}\n\n${info}`;
-  }
-
-  if (description.value.includes(info)) {
-    return description;
-  }
-
-  description.value = `${description.value}\n\n${info}`;
-  return description;
-}

package/src/helpers/find-projects.ts

@@ -1,23 +0,0 @@
-import { globSync } from "node:fs";
-import * as path from "node:path";
-import * as vscodeUri from "vscode-uri";
-
-import type { WorkspaceFolder } from "vscode-languageserver";
-
-export function findStaticboltProjects(searchRoots: WorkspaceFolder[]): WorkspaceFolder[] {
-  const results: WorkspaceFolder[] = [];
-
-  for (const root of searchRoots) {
-    const rootPath = vscodeUri.URI.parse(root.uri).fsPath;
-
-    const configs = globSync("**/.staticbolt.{ts,js}", { cwd: rootPath, exclude: ["**/node_modules/**", "**/.git/**"] });
-
-    for (const configPath of configs) {
-      const absDirectory = path.join(rootPath, path.dirname(configPath));
-      const projectUri = vscodeUri.URI.file(absDirectory).toString();
-      results.push({ name: path.basename(absDirectory), uri: projectUri });
-    }
-  }
-
-  return results;
-}

package/src/html-server.ts

@@ -1,191 +0,0 @@
-import * as vscode from "vscode-languageserver";
-import { TextDocument } from "vscode-languageserver-textdocument";
-import * as vscodeUri from "vscode-uri";
-
-import { ConfigManager } from "./helpers/config-loader.ts";
-import { findStaticboltProjects } from "./helpers/find-projects.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 { LanguageModes } from "./modes/language-modes.ts";
-import type { FileSystemProvider } from "./requests.ts";
-import type { Connection, Disposable, InitializeParams, WorkspaceFolder } from "vscode-languageserver";
-
-export interface RuntimeEnvironment {
-  fileFs?: FileSystemProvider;
-
-  configureHttpRequests?(proxy: string | undefined, isStrictSSL: boolean): void;
-
-  readonly timer: {
-    setImmediate(callback: (...arguments_: unknown[]) => void, ...arguments_: unknown[]): Disposable;
-    setTimeout(callback: (...arguments_: unknown[]) => void, ms: number, ...arguments_: unknown[]): Disposable;
-  };
-}
-
-export interface CustomDataRequestService {
-  getContent(uri: string): Promise<string>;
-}
-
-export function startServer(connection: Connection, runtime: RuntimeEnvironment) {
-  // Create a text document manager.
-  const documents = new vscode.TextDocuments(TextDocument);
-  // Make the text document manager listen on the connection
-  // for open, change and close text document events
-  documents.listen(connection);
-
-  let lspSearchRoots: WorkspaceFolder[] = [];
-  let workspaceFolders: WorkspaceFolder[] = [];
-  let configManager: ConfigManager;
-
-  let languageModes: LanguageModes;
-
-  connection.onInitialize((parameters: InitializeParams) => {
-    if (Array.isArray(parameters.workspaceFolders)) {
-      lspSearchRoots = parameters.workspaceFolders;
-    } else {
-      lspSearchRoots = [];
-      if (parameters.rootPath) {
-        lspSearchRoots.push({ name: "", uri: vscodeUri.URI.file(parameters.rootPath).toString() });
-      }
-    }
-
-    workspaceFolders = findStaticboltProjects(lspSearchRoots);
-    connection.console.log(
-      `[staticbolt] discovered projects:\n` + workspaceFolders.map(f => `  - [${f.name}]:  ${f.uri}`).join("\n")
-    );
-
-    const fileSystemProvider = getFileSystemProvider(["file"], connection, runtime);
-    languageModes = getLanguageModes(parameters.capabilities, fileSystemProvider);
-
-    configManager = new ConfigManager(connection.console);
-
-    documents.onDidClose(document => {
-      languageModes.onDocumentRemoved(document.document);
-    });
-
-    connection.onShutdown(() => {
-      languageModes.dispose();
-      configManager.dispose();
-    });
-
-    return {
-      capabilities: {
-        textDocumentSync: vscode.TextDocumentSyncKind.Incremental,
-        completionProvider: {
-          resolveProvider: true,
-          triggerCharacters: [".", ":", "<", '"', "=", "/"],
-        },
-        hoverProvider: true,
-        documentLinkProvider: { resolveProvider: false },
-      },
-    };
-  });
-
-  connection.onInitialized(() => {});
-
-  connection.onCompletion(async (textDocumentPosition, token) => {
-    return runSafe(
-      runtime,
-      async () => {
-        const projectRoot = findProjectRoot(textDocumentPosition.textDocument.uri);
-        if (!projectRoot) return null;
-
-        const document = documents.get(textDocumentPosition.textDocument.uri);
-        if (!document) return null;
-
-        const mode = languageModes.getModeAtPosition(document, textDocumentPosition.position);
-        if (!mode?.doComplete) return { isIncomplete: true, items: [] };
-
-        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(htmlDocument, textDocumentPosition.position, documentContext, configManager.lspHtmlData);
-      },
-      null,
-      `Error while computing completions for ${textDocumentPosition.textDocument.uri}`,
-      token
-    );
-  });
-
-  connection.onCompletionResolve((item, token) => {
-    return runSafe(
-      runtime,
-      async () => {
-        const data = item.data as Record<string, unknown>;
-        if (!isCompletionItemData(data)) return item;
-
-        const document = documents.get(data.uri);
-        if (!document) return item;
-
-        const mode = languageModes.getMode(data.languageId);
-        if (!mode?.doResolve) return item;
-
-        return mode.doResolve(languageModes.getHtmlDocument(document), item);
-      },
-      item,
-      `Error while resolving completion proposal`,
-      token
-    );
-  });
-
-  connection.onHover((textDocumentPosition, token) => {
-    return runSafe(
-      runtime,
-      async () => {
-        const projectRoot = findProjectRoot(textDocumentPosition.textDocument.uri);
-        if (!projectRoot) return null;
-
-        const document = documents.get(textDocumentPosition.textDocument.uri);
-        if (!document) return null;
-
-        const mode = languageModes.getModeAtPosition(document, textDocumentPosition.position);
-        if (!mode?.doHover) return null;
-
-        const config = await configManager.get(projectRoot);
-        if (!config) return null;
-
-        return mode.doHover(languageModes.getHtmlDocument(document), textDocumentPosition.position, configManager.lspHtmlData);
-      },
-      null,
-      `Error while computing hover for ${textDocumentPosition.textDocument.uri}`,
-      token
-    );
-  });
-
-  connection.onDocumentLinks((documentLinkParameter, token) => {
-    return runSafe(
-      runtime,
-      async () => {
-        const projectRoot = findProjectRoot(documentLinkParameter.textDocument.uri);
-        if (!projectRoot) return null;
-
-        const document = documents.get(documentLinkParameter.textDocument.uri);
-        if (!document) return [];
-
-        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(htmlDocument, documentContext, projectRoot));
-          }
-        }
-
-        return links;
-      },
-      [],
-      `Error while document links for ${documentLinkParameter.textDocument.uri}`,
-      token
-    );
-  });
-
-  // Listen on the connection
-  connection.listen();
-}

package/src/language-model-cache.ts

@@ -1,91 +0,0 @@
-import type { TextDocument } from "vscode-html-languageservice";
-
-export interface LanguageModelCache<T> {
-  get(document: TextDocument): T;
-  onDocumentRemoved(document: TextDocument): void;
-  dispose(): void;
-}
-
-export function getLanguageModelCache<T>(
-  maxEntries: number,
-  cleanupIntervalTimeInSec: number,
-  parse: (document: TextDocument) => T
-): LanguageModelCache<T> {
-  let languageModels: { [uri: string]: { version: number; languageId: string; cTime: number; languageModel: T } } = {};
-  let nModels = 0;
-
-  let cleanupInterval: NodeJS.Timeout | undefined;
-
-  if (cleanupIntervalTimeInSec > 0) {
-    cleanupInterval = setInterval(() => {
-      const cutoffTime = Date.now() - cleanupIntervalTimeInSec * 1000;
-      const uris = Object.keys(languageModels);
-
-      for (const uri of uris) {
-        const languageModelInfo = languageModels[uri];
-        if (languageModelInfo.cTime < cutoffTime) {
-          delete languageModels[uri];
-          nModels--;
-        }
-      }
-    }, cleanupIntervalTimeInSec * 1000);
-  }
-
-  return {
-    get(document: TextDocument): T {
-      const version = document.version;
-      const languageId = document.languageId;
-      const languageModelInfo = languageModels[document.uri];
-
-      if (languageModelInfo && languageModelInfo.version === version && languageModelInfo.languageId === languageId) {
-        languageModelInfo.cTime = Date.now();
-        return languageModelInfo.languageModel;
-      }
-
-      const languageModel = parse(document);
-      languageModels[document.uri] = { languageModel, version, languageId, cTime: Date.now() };
-      if (!languageModelInfo) {
-        nModels++;
-      }
-
-      if (nModels === maxEntries) {
-        let oldestTime = Number.MAX_VALUE;
-        let oldestUri = null;
-
-        for (const uri in languageModels) {
-          const languageModelInfo = languageModels[uri];
-          if (languageModelInfo.cTime < oldestTime) {
-            oldestUri = uri;
-            oldestTime = languageModelInfo.cTime;
-          }
-        }
-
-        if (oldestUri) {
-          delete languageModels[oldestUri];
-          nModels--;
-        }
-      }
-
-      return languageModel;
-    },
-
-    onDocumentRemoved(document: TextDocument) {
-      const uri = document.uri;
-      if (Object.hasOwn(languageModels, uri)) {
-        delete languageModels[uri];
-        nModels--;
-      }
-    },
-
-    dispose() {
-      if (cleanupInterval === undefined) {
-        return;
-      }
-
-      clearInterval(cleanupInterval);
-      cleanupInterval = undefined;
-      languageModels = {};
-      nModels = 0;
-    },
-  };
-}

package/src/modes/embedded-support.ts

@@ -1,150 +0,0 @@
-import vscodeHtml from "vscode-html-languageservice";
-import { TextDocument } from "vscode-languageserver-textdocument";
-
-import { blankRegions, findMarkdownNonHtmlRegions } from "./markdown-regions.ts";
-
-import type { LanguageService } from "vscode-html-languageservice";
-
-export interface HTMLDocumentRegions {
-  /** 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[];
-}
-
-const TokenType = vscodeHtml.TokenType;
-type Position = vscodeHtml.Position;
-
-interface EmbeddedRegion {
-  languageId: string | undefined;
-  start: number;
-  end: number;
-}
-
-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(htmlText);
-  let lastTagName: string = "";
-  let lastAttributeName: string | null = null;
-  let languageIdFromType: string | undefined;
-
-  let token = scanner.scan();
-
-  while (token !== TokenType.EOS) {
-    switch (token) {
-      case TokenType.StartTag: {
-        lastTagName = scanner.getTokenText();
-        lastAttributeName = null;
-        languageIdFromType = "javascript";
-        break;
-      }
-      case TokenType.Styles: {
-        regions.push({ languageId: "css", start: scanner.getTokenOffset(), end: scanner.getTokenEnd() });
-        break;
-      }
-      case TokenType.Script: {
-        regions.push({ languageId: languageIdFromType, start: scanner.getTokenOffset(), end: scanner.getTokenEnd() });
-        break;
-      }
-      case TokenType.AttributeName: {
-        lastAttributeName = scanner.getTokenText();
-        break;
-      }
-      case TokenType.AttributeValue: {
-        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";
-          } else {
-            languageIdFromType = undefined;
-          }
-        } else {
-          const attributeLanguageId = getAttributeLanguage(lastAttributeName!);
-          if (attributeLanguageId) {
-            let start = scanner.getTokenOffset();
-            let end = scanner.getTokenEnd();
-            const firstChar = htmlText[start];
-            if (firstChar === "'" || firstChar === '"') {
-              start++;
-              end--;
-            }
-            regions.push({ languageId: attributeLanguageId, start, end });
-          }
-        }
-        lastAttributeName = null;
-        break;
-      }
-    }
-    token = scanner.scan();
-  }
-
-  const allRegions = mergeRegions(regions, markdownRegions);
-  const htmlDocument = isMarkdown ? TextDocument.create(document.uri, "html", document.version, htmlText) : document;
-
-  return {
-    getLanguageAtPosition: (position: Position) => getLanguageAtPosition(document, allRegions, position),
-    getLanguagesInDocument: () => getLanguagesInDocument(allRegions),
-    getHtmlDocument: () => htmlDocument,
-  };
-}
-
-/** 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 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(regions: EmbeddedRegion[]): string[] {
-  const languages = new Set(["html"]);
-
-  for (const region of regions) {
-    if (region.languageId) {
-      languages.add(region.languageId);
-    }
-  }
-
-  return [...languages];
-}
-
-function getLanguageAtPosition(document: TextDocument, regions: EmbeddedRegion[], position: Position): string | undefined {
-  const offset = document.offsetAt(position);
-  for (const region of regions) {
-    if (region.start <= offset) {
-      if (offset <= region.end) {
-        return region.languageId;
-      }
-    } else {
-      break;
-    }
-  }
-  return "html";
-}
-
-function getAttributeLanguage(attributeName: string): string | null {
-  const match = attributeName.match(/^(style)$|^(on\w+)$/i);
-  if (!match) {
-    return null;
-  }
-  return match[1] ? "css" : "javascript";
-}