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

package/src/modes/html-mode.ts

@@ -1,83 +0,0 @@
-/* eslint-disable @typescript-eslint/require-await */
-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, 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(htmlData);
-
-      const htmlDocument = htmlDocuments.get(document);
-      const completionList = await htmlLanguageService.doComplete2(document, position, htmlDocument, documentContext);
-
-      for (const item of completionList.items) {
-        item.sortText = "0_" + item.label;
-      }
-
-      return completionList;
-    },
-
-    async doHover(document, position, htmlData) {
-      setHtmlDataProviders(htmlData);
-
-      return htmlLanguageService.doHover(document, position, htmlDocuments.get(document));
-    },
-
-    async onDocumentRemoved(document: TextDocument) {
-      htmlDocuments.onDocumentRemoved(document);
-    },
-
-    async findDocumentLinks(document, documentContext, projectRoot) {
-      const resolver = new Resolver(projectRoot);
-      const documentFs = vscodeUri.URI.parse(document.uri).fsPath;
-      const projectRootRelative = path.relative(projectRoot, documentFs);
-
-      const links = htmlLanguageService.findDocumentLinks(document, documentContext);
-
-      for (const link of links) {
-        if (!link.target) continue;
-
-        const linkFs = vscodeUri.URI.parse(link.target ?? "").fsPath;
-        const source = path.relative(path.dirname(documentFs), linkFs);
-
-        const resolved = resolver.resolve(source, projectRootRelative);
-        if (resolved) {
-          link.target = vscodeUri.URI.file(resolved.path).toString();
-        }
-      }
-
-      return links;
-    },
-
-    dispose() {
-      htmlDocuments.dispose();
-    },
-  };
-}

package/src/modes/language-modes.ts

@@ -1,156 +0,0 @@
-import vscodeHtml from "vscode-html-languageservice";
-
-import { getLanguageModelCache } from "../language-model-cache.ts";
-import { getDocumentRegions } from "./embedded-support.ts";
-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, 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 type CompletionItemData = {
-  languageId: string;
-  uri: string;
-  offset: number;
-};
-
-export function isCompletionItemData(value: Record<string, unknown>): value is CompletionItemData {
-  return value && typeof value.languageId === "string" && typeof value.uri === "string" && typeof value.offset === "number";
-}
-
-export interface LanguageMode {
-  getId(): string;
-  doComplete?: (
-    document: TextDocument,
-    position: Position,
-    documentContext: DocumentContext,
-    htmlData: HTMLDataV1[]
-  ) => Promise<CompletionList>;
-  doResolve?: (document: TextDocument, item: CompletionItem) => Promise<CompletionItem>;
-  doHover?: (document: TextDocument, position: Position, htmlData: HTMLDataV1[]) => Promise<Hover | null>;
-  findDocumentLinks?: (document: TextDocument, documentContext: DocumentContext, projectRoot: string) => Promise<DocumentLink[]>;
-  onDocumentRemoved(document: TextDocument): void;
-  dispose(): void;
-}
-
-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;
-  getAllModesInDocument(document: TextDocument): LanguageMode[];
-  getMode(languageId: string): LanguageMode | undefined;
-  onDocumentRemoved(document: TextDocument): void;
-  dispose(): void;
-}
-
-export const FILE_PROTOCOL = "staticbolt-server";
-
-export function getLanguageModes(clientCapabilities: ClientCapabilities, requestService: FileSystemProvider): LanguageModes {
-  const htmlLanguageService = vscodeHtml.getLanguageService({
-    clientCapabilities,
-    fileSystemProvider: requestService,
-    customDataProviders: [
-      {
-        getId() {
-          return FILE_PROTOCOL;
-        },
-        isApplicable(languageId) {
-          return languageId === "html";
-        },
-        provideValues(tag, attribute) {
-          return [{ name: `tag:${tag} attribute:${attribute}` }];
-        },
-        provideTags() {
-          return [{ name: "staticbolt", description: "# staticbolt-description", attributes: [] }];
-        },
-
-        provideAttributes(tag: string) {
-          if (tag === "staticbolt") {
-            return [
-              {
-                name: "staticbolt-attribute",
-                description: "# staticbolt-attribute-description",
-                values: [{ name: "staticbolt-attribute-value" }],
-              },
-            ];
-          }
-
-          return [{ name: "global-attribute" }];
-        },
-      },
-    ],
-    useDefaultDataProvider: false,
-  });
-
-  const documentRegions = getLanguageModelCache<HTMLDocumentRegions>(10, 60, document =>
-    getDocumentRegions(htmlLanguageService, document)
-  );
-
-  let modelCaches: LanguageModelCache<unknown>[] = [documentRegions];
-
-  let modes = Object.create(null) as { [languageId: string]: LanguageMode };
-  modes["html"] = getHTMLMode(htmlLanguageService);
-
-  return {
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async updateDataProviders(dataProviders: IHTMLDataProvider[]): Promise<void> {
-      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) {
-        return modes[languageId];
-      }
-
-      return undefined;
-    },
-
-    getAllModesInDocument(document: TextDocument): LanguageMode[] {
-      const result: LanguageMode[] = [];
-      for (const languageId of documentRegions.get(document).getLanguagesInDocument()) {
-        const mode = modes[languageId];
-        if (mode) {
-          result.push(mode);
-        }
-      }
-
-      return result;
-    },
-
-    getMode(languageId: string): LanguageMode {
-      return modes[languageId];
-    },
-
-    onDocumentRemoved(document: TextDocument) {
-      for (const mc of modelCaches) {
-        mc.onDocumentRemoved(document);
-      }
-
-      for (const mode in modes) {
-        modes[mode].onDocumentRemoved(document);
-      }
-    },
-
-    dispose(): void {
-      for (const mc of modelCaches) {
-        mc.dispose();
-      }
-
-      modelCaches = [];
-      for (const mode in modes) {
-        modes[mode].dispose();
-      }
-
-      modes = {};
-    },
-  };
-}

package/src/requests.ts

@@ -1,72 +0,0 @@
-import { RequestType } from "vscode-languageserver";
-
-import type { RuntimeEnvironment } from "./html-server.ts";
-import type { Connection } from "vscode-languageserver";
-
-// Interface
-export const FsStatRequest = { type: new RequestType<string, FileStat, unknown>("fs/stat") } as const;
-
-// Interface
-export const FsReadDirectoryRequest = { type: new RequestType<string, [string, FileType][], unknown>("fs/readDir") } as const;
-
-export const FileType = Object.freeze({
-  /** The file type is unknown. */
-  Unknown: 0,
-
-  /** A regular file. */
-  File: 1,
-
-  /** A directory. */
-  Directory: 2,
-
-  /** A symbolic link to a file. */
-  SymbolicLink: 64,
-});
-
-export type FileType = (typeof FileType)[keyof typeof FileType];
-
-export interface FileStat {
-  /** The type of the file, e.g. is a regular file, a directory, or symbolic link to a file. */
-  type: FileType;
-
-  /** The creation timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC. */
-  ctime: number;
-
-  /** The modification timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC. */
-  mtime: number;
-
-  /** The size in bytes. */
-  size: number;
-}
-
-export interface FileSystemProvider {
-  stat(uri: string): Promise<FileStat>;
-  readDirectory(uri: string): Promise<[string, FileType][]>;
-}
-
-export function getFileSystemProvider(
-  handledSchemas: string[],
-  connection: Connection,
-  runtime: RuntimeEnvironment
-): FileSystemProvider {
-  const fileFs = runtime.fileFs && handledSchemas.includes("file") ? runtime.fileFs : undefined;
-
-  return {
-    async stat(uri: string): Promise<FileStat> {
-      if (fileFs && uri.startsWith("file:")) {
-        return fileFs.stat(uri);
-      }
-
-      const result = await connection.sendRequest(FsStatRequest.type, uri);
-      return result;
-    },
-
-    readDirectory(uri: string): Promise<[string, FileType][]> {
-      if (fileFs && uri.startsWith("file:")) {
-        return fileFs.readDirectory(uri);
-      }
-
-      return connection.sendRequest(FsReadDirectoryRequest.type, uri);
-    },
-  };
-}

package/src/utils/arrays.ts

@@ -1,73 +0,0 @@
-export function pushAll<T>(to: T[], from: T[]) {
-  if (from) {
-    for (const item of from) {
-      to.push(item);
-    }
-  }
-}
-
-// eslint-disable-next-line unicorn/consistent-boolean-name
-export function contains<T>(array: T[], value: T) {
-  return array.includes(value);
-}
-
-/**
- * Like `Array#sort` but always stable. Usually runs a little slower `than Array#sort` so only use this when actually needing
- * stable sort.
- */
-export function mergeSort<T>(data: T[], compare: (a: T, b: T) => number): T[] {
-  _divideAndMerge(data, compare);
-  return data;
-}
-
-function _divideAndMerge<T>(data: T[], compare: (a: T, b: T) => number): void {
-  if (data.length <= 1) {
-    // sorted
-    return;
-  }
-  const p = Math.trunc(data.length / 2);
-  const left = data.slice(0, p);
-  const right = data.slice(p);
-
-  _divideAndMerge(left, compare);
-  _divideAndMerge(right, compare);
-
-  let leftIndex = 0;
-  let rightIndex = 0;
-  let index = 0;
-  while (leftIndex < left.length && rightIndex < right.length) {
-    const returnValue = compare(left[leftIndex], right[rightIndex]);
-    if (returnValue <= 0) {
-      // smaller_equal -> take left to preserve order
-      data[index++] = left[leftIndex++];
-    } else {
-      // greater -> take right
-      data[index++] = right[rightIndex++];
-    }
-  }
-  while (leftIndex < left.length) {
-    data[index++] = left[leftIndex++];
-  }
-  while (rightIndex < right.length) {
-    data[index++] = right[rightIndex++];
-  }
-}
-
-export function binarySearch<T>(array: T[], key: T, comparator: (op1: T, op2: T) => number): number {
-  let low = 0,
-    high = array.length - 1;
-
-  while (low <= high) {
-    const mid = Math.trunc((low + high) / 2);
-    const comp = comparator(array[mid], key);
-    if (comp < 0) {
-      low = mid + 1;
-    } else if (comp > 0) {
-      high = mid - 1;
-    } else {
-      return mid;
-    }
-  }
-
-  return -(low + 1);
-}

package/src/utils/document-context.ts

@@ -1,44 +0,0 @@
-import * as vscodeUri from "vscode-uri";
-
-import { isEndingWith, isStartingWith } from "../utils/strings.ts";
-
-import type { DocumentContext } from "vscode-css-languageservice";
-import type { WorkspaceFolder } from "vscode-languageserver";
-
-export function getDocumentContext(documentUri: string, workspaceFolders: WorkspaceFolder[]): DocumentContext {
-  function getRootFolder(): string | undefined {
-    for (const folder of workspaceFolders) {
-      let folderURI = folder.uri;
-      if (!isEndingWith(folderURI, "/")) {
-        folderURI += "/";
-      }
-
-      if (isStartingWith(documentUri, folderURI)) {
-        return folderURI;
-      }
-    }
-
-    return undefined;
-  }
-
-  return {
-    resolveReference: (reference: string, base = documentUri) => {
-      if (/^\w[\w\d+.-]*:/.test(reference)) {
-        // starts with a schema
-        return reference;
-      }
-
-      if (reference[0] === "/") {
-        // resolve absolute path against the current workspace folder
-        const folderUri = getRootFolder();
-        if (folderUri) {
-          return folderUri + reference.slice(1);
-        }
-      }
-
-      const baseUri = vscodeUri.URI.parse(base);
-      const baseUriDirectory = baseUri.path.endsWith("/") ? baseUri : vscodeUri.Utils.dirname(baseUri);
-      return vscodeUri.Utils.resolvePath(baseUriDirectory, reference).toString(true);
-    },
-  };
-}

package/src/utils/find-project-root.ts

@@ -1,24 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as vscodeUri from "vscode-uri";
-
-export function findProjectRoot(fileUri: string): string | null {
-  let directory = path.dirname(vscodeUri.URI.parse(fileUri).fsPath);
-
-  while (true) {
-    for (const config of [".staticbolt.ts", ".staticbolt.js"]) {
-      if (fs.existsSync(path.join(directory, config))) {
-        return directory;
-      }
-    }
-
-    const parent = path.dirname(directory);
-
-    // reached fs root, no config found
-    if (parent === directory) {
-      return null;
-    }
-
-    directory = parent;
-  }
-}

package/src/utils/node-fs.ts

@@ -1,77 +0,0 @@
-import * as fs from "node:fs";
-import * as vscodeUri from "vscode-uri";
-
-import type { FileSystemProvider } from "../requests.ts";
-
-const FileType = Object.freeze({
-  /** The file type is unknown. */
-  Unknown: 0,
-  /** A regular file. */
-  File: 1,
-  /** A directory. */
-  Directory: 2,
-  /** A symbolic link to a file. */
-  SymbolicLink: 64,
-});
-
-type FileType = (typeof FileType)[keyof typeof FileType];
-
-export function getNodeFileFS(): FileSystemProvider {
-  function ensureFileUri(location: string) {
-    if (!location.startsWith("file:")) {
-      throw new Error("fileSystemProvider can only handle file URLs");
-    }
-  }
-  return {
-    stat(location: string) {
-      ensureFileUri(location);
-      return new Promise((c, error_) => {
-        const uri = vscodeUri.URI.parse(location);
-        fs.stat(uri.fsPath, (error, stats) => {
-          if (error) {
-            return error.code === "ENOENT" ? c({ type: FileType.Unknown, ctime: -1, mtime: -1, size: -1 }) : error_(error);
-          }
-
-          let type: FileType = FileType.Unknown;
-          if (stats.isFile()) {
-            type = FileType.File;
-          } else if (stats.isDirectory()) {
-            type = FileType.Directory;
-          } else if (stats.isSymbolicLink()) {
-            type = FileType.SymbolicLink;
-          }
-
-          c({
-            type,
-            ctime: stats.ctime.getTime(),
-            mtime: stats.mtime.getTime(),
-            size: stats.size,
-          });
-        });
-      });
-    },
-    readDirectory(location: string) {
-      ensureFileUri(location);
-      return new Promise((c, error_) => {
-        const path = vscodeUri.URI.parse(location).fsPath;
-
-        fs.readdir(path, { withFileTypes: true }, (error, children) => {
-          if (error) {
-            return error_(error);
-          }
-          c(
-            children.map(stat => {
-              if (stat.isSymbolicLink()) {
-                return [stat.name, FileType.SymbolicLink];
-              }
-              if (stat.isDirectory()) {
-                return [stat.name, FileType.Directory];
-              }
-              return stat.isFile() ? [stat.name, FileType.File] : [stat.name, FileType.Unknown];
-            })
-          );
-        });
-      });
-    },
-  };
-}

package/src/utils/runner.ts

@@ -1,56 +0,0 @@
-import vscode from "vscode-languageserver";
-
-import type { RuntimeEnvironment } from "../html-server.ts";
-import type { CancellationToken, ResponseError } from "vscode-languageserver";
-
-export function formatError(message: string, error: unknown): string {
-  if (error instanceof Error) {
-    return `${message}: ${error.message}\n${error.stack}`;
-  }
-
-  if (typeof error === "string") {
-    return `${message}: ${error}`;
-  }
-
-  if (error) {
-    return `${message}: ${error as string}`;
-  }
-
-  return message;
-}
-
-export function runSafe<T>(
-  runtime: RuntimeEnvironment,
-  function_: () => Thenable<T>,
-  errorValue: T,
-  errorMessage: string,
-  token: CancellationToken
-): Thenable<T | ResponseError<never>> {
-  return new Promise<T | ResponseError<never>>(resolve => {
-    runtime.timer.setImmediate(() => {
-      if (token.isCancellationRequested) {
-        resolve(cancelValue());
-        return;
-      }
-      return function_().then(
-        result => {
-          if (token.isCancellationRequested) {
-            resolve(cancelValue());
-            return;
-          }
-
-          resolve(result);
-        },
-
-        error => {
-          console.error(formatError(errorMessage, error));
-          resolve(errorValue);
-        }
-      );
-    });
-  });
-}
-
-function cancelValue<E>() {
-  return new vscode.ResponseError<E>(vscode.LSPErrorCodes.RequestCancelled, "Request cancelled");
-}

package/src/utils/strings.ts

@@ -1,76 +0,0 @@
-export function getWordAtText(text: string, offset: number, wordDefinition: RegExp): { start: number; length: number } {
-  let lineStart = offset;
-  while (lineStart > 0 && !isNewlineCharacter(text.codePointAt(lineStart - 1)!)) {
-    lineStart--;
-  }
-  const offsetInLine = offset - lineStart;
-  const lineText = text.slice(lineStart);
-
-  // make a copy of the regex as to not keep the state
-  const flags = wordDefinition.ignoreCase ? "gi" : "g";
-  wordDefinition = new RegExp(wordDefinition.source, flags);
-
-  let match = wordDefinition.exec(lineText);
-  while (match && match.index + match[0].length < offsetInLine) {
-    match = wordDefinition.exec(lineText);
-  }
-  if (match && match.index <= offsetInLine) {
-    return { start: match.index + lineStart, length: match[0].length };
-  }
-
-  return { start: offset, length: 0 };
-}
-
-export function isStartingWith(haystack: string, needle: string): boolean {
-  if (haystack.length < needle.length) {
-    return false;
-  }
-
-  // eslint-disable-next-line unicorn/no-for-loop
-  for (let index = 0; index < needle.length; index++) {
-    if (haystack[index] !== needle[index]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function isEndingWith(haystack: string, needle: string): boolean {
-  const diff = haystack.length - needle.length;
-  if (diff > 0) {
-    return haystack.indexOf(needle, diff) === diff;
-  }
-
-  if (diff === 0) {
-    return haystack === needle;
-  }
-
-  return false;
-}
-
-export function repeat(value: string, count: number) {
-  let s = "";
-  while (count > 0) {
-    if ((count & 1) === 1) {
-      s += value;
-    }
-    value += value;
-    count >>>= 1;
-  }
-  return s;
-}
-
-export function isWhitespaceOnly(string_: string) {
-  return /^\s*$/.test(string_);
-}
-
-export function isEOL(content: string, offset: number) {
-  return isNewlineCharacter(content.codePointAt(offset)!);
-}
-
-const CR = "\r".codePointAt(0);
-const NL = "\n".codePointAt(0);
-export function isNewlineCharacter(charCode: number) {
-  return charCode === CR || charCode === NL;
-}