@staticbolt/lsp 1.0.0-beta.12

package/src/requests.ts

@@ -0,0 +1,72 @@
+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.toString());
+      return result;
+    },
+
+    readDirectory(uri: string): Promise<[string, FileType][]> {
+      if (fileFs && uri.startsWith("file:")) {
+        return fileFs.readDirectory(uri);
+      }
+
+      return connection.sendRequest(FsReadDirectoryRequest.type, uri.toString());
+    },
+  };
+}

package/src/utils/arrays.ts

@@ -0,0 +1,72 @@
+export function pushAll<T>(to: T[], from: T[]) {
+  if (from) {
+    for (const item of from) {
+      to.push(item);
+    }
+  }
+}
+
+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

@@ -0,0 +1,44 @@
+import * as vscodeUri from "vscode-uri";
+
+import { endsWith, startsWith } 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 (!endsWith(folderURI, "/")) {
+        folderURI = folderURI + "/";
+      }
+
+      if (startsWith(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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,79 @@
+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];
+              } else if (stat.isDirectory()) {
+                return [stat.name, FileType.Directory];
+              } else if (stat.isFile()) {
+                return [stat.name, FileType.File];
+              } else {
+                return [stat.name, FileType.Unknown];
+              }
+            })
+          );
+        });
+      });
+    },
+  };
+}

package/src/utils/runner.ts

@@ -0,0 +1,56 @@
+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).toString()}`;
+  }
+
+  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

@@ -0,0 +1,76 @@
+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 startsWith(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 endsWith(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 = 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;
+}