@adecore/lsp 0.39.0 → 0.40.0

package/src/transport.ts

@@ -17,9 +17,11 @@ class TransportEvents {
 
     onMessage(listener: (message: unknown) => void): Disposable {
         this.messages.add(listener);
+
         for (const message of this.backlog.splice(0)) {
             listener(message);
         }
+
         return {
             dispose: () => {
                 this.messages.delete(listener);
@@ -29,9 +31,11 @@ class TransportEvents {
 
     onClose(listener: (error?: Error) => void): Disposable {
         this.closes.add(listener);
+
         if (this.closed) {
             listener(this.error);
         }
+
         return {
             dispose: () => {
                 this.closes.delete(listener);
@@ -43,10 +47,13 @@ class TransportEvents {
         if (this.closed) {
             return;
         }
+
         if (this.messages.size === 0) {
             this.backlog.push(message);
+
             return;
         }
+
         for (const listener of this.messages) {
             listener(message);
         }
@@ -56,12 +63,15 @@ class TransportEvents {
         if (this.closed) {
             return;
         }
+
         this.closed = true;
         this.error = error;
         this.backlog = [];
+
         for (const listener of this.closes) {
             listener(error);
         }
+
         this.closes.clear();
         this.messages.clear();
     }
@@ -71,12 +81,15 @@ function concat(chunks: readonly Uint8Array[], size: number): Uint8Array {
     if (chunks.length === 1) {
         return chunks[0];
     }
+
     const joined = new Uint8Array(size);
     let offset = 0;
+
     for (const chunk of chunks) {
         joined.set(chunk, offset);
         offset += chunk.length;
     }
+
     return joined;
 }
 
@@ -89,12 +102,14 @@ function indexOfHeaderEnd(bytes: Uint8Array): number {
             return i;
         }
     }
+
     return -1;
 }
 
 /* Reads `Content-Length` framed messages, the way a language server speaks over stdio. */
 export class ContentLengthDecoder {
     private readonly maxMessageBytes: number;
+    private readonly utf8 = new TextDecoder();
     private chunks: Uint8Array[] = [];
     private size = 0;
     private length: number | null = null;
@@ -108,49 +123,64 @@ export class ContentLengthDecoder {
         this.chunks.push(chunk);
         this.size += chunk.length;
         const messages: unknown[] = [];
+
         while (true) {
             if (this.length === null) {
                 const buffer = concat(this.chunks, this.size);
                 this.chunks = [buffer];
                 const boundary = indexOfHeaderEnd(buffer);
+
                 if (boundary < 0) {
                     if (buffer.length > MAX_HEADER_BYTES) {
                         throw new Error('LSP header is too large');
                     }
+
                     break;
                 }
-                const header = new TextDecoder().decode(buffer.subarray(0, boundary));
+
+                const header = this.utf8.decode(buffer.subarray(0, boundary));
                 const match = /^Content-Length:\s*(\d+)\s*$/im.exec(header);
+
                 if (!match || boundary > MAX_HEADER_BYTES) {
                     throw new Error('Invalid LSP Content-Length header');
                 }
+
                 const length = Number(match[1]);
+
                 if (!length || length > this.maxMessageBytes) {
                     throw new Error('LSP message is too large');
                 }
+
                 this.length = length;
                 this.chunks = [buffer.subarray(boundary + 4)];
                 this.size = buffer.length - boundary - 4;
             }
+
             if (this.size < this.length) {
                 break;
             }
+
             const buffer = concat(this.chunks, this.size);
-            messages.push(JSON.parse(new TextDecoder().decode(buffer.subarray(0, this.length))));
+            messages.push(JSON.parse(this.utf8.decode(buffer.subarray(0, this.length))));
             this.chunks = [buffer.subarray(this.length)];
             this.size = buffer.length - this.length;
             this.length = null;
         }
+
         return messages;
     }
 }
 
+let utf8: TextEncoder | undefined;
+
 export function encodeMessage(message: RpcMessage): Uint8Array {
-    const body = new TextEncoder().encode(JSON.stringify(message));
-    const header = new TextEncoder().encode(`Content-Length: ${body.length}\r\n\r\n`);
+    utf8 ??= new TextEncoder();
+    const body = utf8.encode(JSON.stringify(message));
+    const header = utf8.encode(`Content-Length: ${body.length}\r\n\r\n`);
     const framed = new Uint8Array(header.length + body.length);
     framed.set(header, 0);
     framed.set(body, header.length);
+
     return framed;
 }
 
@@ -166,6 +196,7 @@ export interface ByteStream {
 export function createStreamTransport(stream: ByteStream, options: { maxMessageBytes?: number } = {}): LspTransport {
     const events = new TransportEvents();
     const decoder = new ContentLengthDecoder(options.maxMessageBytes);
+
     stream.onData((chunk) => {
         try {
             for (const message of decoder.accept(chunk)) {
@@ -176,7 +207,9 @@ export function createStreamTransport(stream: ByteStream, options: { maxMessageB
             void Promise.resolve(stream.close()).catch(() => undefined);
         }
     });
+
     stream.onClose((error) => events.finish(error));
+
     return {
         onMessage: (listener) => events.onMessage(listener),
         onClose: (listener) => events.onClose(listener),
@@ -184,6 +217,7 @@ export function createStreamTransport(stream: ByteStream, options: { maxMessageB
             if (events.closed) {
                 throw new Error('LSP stream is closed');
             }
+
             await stream.write(encodeMessage(message));
         },
         async close() {
@@ -197,6 +231,7 @@ export function createStreamTransport(stream: ByteStream, options: { maxMessageB
 export function createMemoryTransportPair(): [LspTransport, LspTransport] {
     const left = new TransportEvents();
     const right = new TransportEvents();
+
     const end = (inbox: TransportEvents, outbox: TransportEvents): LspTransport => ({
         onMessage: (listener) => inbox.onMessage(listener),
         onClose: (listener) => inbox.onClose(listener),
@@ -204,6 +239,7 @@ export function createMemoryTransportPair(): [LspTransport, LspTransport] {
             if (inbox.closed || outbox.closed) {
                 throw new Error('LSP transport is closed');
             }
+
             const copy: unknown = JSON.parse(JSON.stringify(message));
             queueMicrotask(() => outbox.receive(copy));
         },
@@ -212,6 +248,7 @@ export function createMemoryTransportPair(): [LspTransport, LspTransport] {
             outbox.finish();
         }
     });
+
     return [end(left, right), end(right, left)];
 }
 
@@ -232,24 +269,30 @@ export async function connectWebSocket(url: string, options: WebSocketTransportO
     if (options.signal?.aborted) {
         throw new Error('WebSocket connection cancelled');
     }
+
     const timeoutMs = options.timeoutMs ?? 10_000;
     const socket = options.createWebSocket ? options.createWebSocket(url, options.protocols) : new WebSocket(url, options.protocols);
     const events = new TransportEvents();
+
     socket.addEventListener('message', (event) => {
         try {
             if (typeof event.data !== 'string') {
                 throw new Error('LSP WebSocket expects JSON text frames');
             }
+
             events.receive(JSON.parse(event.data));
         } catch (error) {
             events.finish(asError(error));
             socket.close(1003, 'Invalid JSON message');
         }
     });
+
     socket.addEventListener('close', (event) => events.finish(event.code === 1000 ? undefined : new Error(`LSP WebSocket closed (${event.code})`)));
     socket.addEventListener('error', () => events.finish(new Error('LSP WebSocket failed')));
+
     await new Promise<void>((resolve, reject) => {
         const timer = setTimeout(() => fail(new Error('LSP WebSocket connection timed out')), timeoutMs);
+
         const cleanup = (): void => {
             clearTimeout(timer);
             socket.removeEventListener('open', open);
@@ -257,37 +300,48 @@ export async function connectWebSocket(url: string, options: WebSocketTransportO
             socket.removeEventListener('close', closed);
             options.signal?.removeEventListener('abort', abort);
         };
+
         const fail = (reason: Error): void => {
             cleanup();
             socket.close();
             reject(reason);
         };
+
         const open = (): void => {
             cleanup();
             resolve();
         };
+
         const failed = (): void => fail(new Error('LSP WebSocket connection failed'));
+
         const closed = (): void => fail(new Error('LSP WebSocket closed before opening'));
+
         const abort = (): void => fail(new Error('LSP WebSocket connection cancelled'));
+
         socket.addEventListener('open', open, { once: true });
         socket.addEventListener('error', failed, { once: true });
         socket.addEventListener('close', closed, { once: true });
         options.signal?.addEventListener('abort', abort, { once: true });
     });
+
     return {
         onMessage: (listener) => events.onMessage(listener),
         onClose: (listener) => events.onClose(listener),
         async send(message) {
             const deadline = Date.now() + timeoutMs;
+
             while (!events.closed && socket.readyState === 1 && socket.bufferedAmount > MAX_SOCKET_BUFFER_BYTES) {
                 if (Date.now() >= deadline) {
                     throw new Error('LSP WebSocket send buffer is full');
                 }
+
                 await new Promise((resolve) => setTimeout(resolve, DRAIN_POLL_MS));
             }
+
             if (events.closed || socket.readyState !== 1) {
                 throw new Error('LSP WebSocket is closed');
             }
+
             socket.send(JSON.stringify(message));
         },
         close() {

package/src/uris.ts

@@ -2,17 +2,25 @@ function isWindowsDrive(segment: string): boolean {
     return /^[A-Za-z]:$/.test(segment);
 }
 
+/* A path with a drive or a UNC share. A backslash separates only in such a path; in a POSIX one it is part of a name. */
+export function isWindowsPath(path: string): boolean {
+    return /^[A-Za-z]:[\\/]/.test(path) || path.startsWith('\\\\');
+}
+
 /* An absolute path, POSIX, with a Windows drive or UNC, as the `file:` URI a language server names it by. */
 export function pathToFileUri(path: string): string {
-    // A backslash separates only in a Windows path; in a POSIX one it is part of a name.
-    const windows = /^[A-Za-z]:[\\/]/.test(path) || path.startsWith('\\\\');
+    const windows = isWindowsPath(path);
     const normalized = windows ? path.replaceAll('\\', '/') : path;
+
     if (windows && normalized.startsWith('//')) {
         const [host = '', ...segments] = normalized.slice(2).split('/');
+
         return `file://${encodeURIComponent(host)}/${segments.map(encodeURIComponent).join('/')}`;
     }
+
     const rooted = normalized.startsWith('/') ? normalized : `/${normalized}`;
     const segments = rooted.split('/').map((segment, index) => (index === 1 && isWindowsDrive(segment) ? segment : encodeURIComponent(segment)));
+
     return `file://${segments.join('/')}`;
 }
 
@@ -20,22 +28,27 @@ export function pathToFileUri(path: string): string {
 export function fileUriToPath(uri: string): string | null {
     let url: URL;
     let path: string;
+
     try {
         url = new URL(uri);
         path = decodeURIComponent(url.pathname);
     } catch {
         return null;
     }
+
     if (url.protocol !== 'file:') {
         return null;
     }
+
     // A server in the URI names a UNC share, which only Windows reads as a path.
     if (url.hostname !== '' && url.hostname !== 'localhost') {
         return `\\\\${url.hostname}${path.replaceAll('/', '\\')}`;
     }
+
     if (/^\/[A-Za-z]:/.test(path)) {
         return path.slice(1).replaceAll('/', '\\');
     }
+
     return path;
 }
 
@@ -45,8 +58,10 @@ export function fileUriToPath(uri: string): string | null {
  */
 export function fileUriKey(uri: string): string {
     const path = fileUriToPath(uri);
+
     if (path === null || !/^[A-Za-z]:\\/.test(path)) {
         return uri;
     }
+
     return pathToFileUri(`${path[0]!.toUpperCase()}${path.slice(1)}`);
 }

package/src/vue.ts

@@ -10,30 +10,37 @@ import type { LspSession } from './session.ts';
  */
 export function bridgeVueTypeScript(vue: LspSession, typescript: LspSession): Disposable {
     let disposed = false;
+
     const subscription = vue.onNotification('tsserver/request', async (params) => {
         // vscode-jsonrpc encodes this single positional argument as an outer array.
         const positional = Array.isArray(params) && params.length === 1 && Array.isArray(params[0]);
         const tuple = positional ? params[0] : params;
+
         if (!Array.isArray(tuple) || tuple.length !== 3) {
             throw new Error('Invalid Vue tsserver/request notification');
         }
+
         const [id, command, args] = tuple as [number, string, unknown];
         let body: unknown = null;
+
         try {
             const response = await typescript.executeCommand<{ body?: unknown }>('typescript.tsserverRequest', [
                 command,
                 args,
                 { isAsync: false, lowPriority: true }
             ]);
+
             body = response?.body ?? null;
         } catch (error) {
             vue.connection.reportError(error);
         }
+
         // Vue keeps the request pending until it gets an answer, a null one included.
         if (!disposed && !vue.connection.isClosed) {
             await vue.connection.notify('tsserver/response', positional ? [[id, body]] : [id, body]);
         }
     });
+
     return {
         dispose() {
             disposed = true;
@@ -47,17 +54,21 @@ export type VueServer = 'vue' | 'typescript';
 /* A `<script>` body, or the expression of an interpolation or a `v-` / `:` / `@` attribute: the places TypeScript knows more than Vue does. */
 export function isVueExpression(text: string, offset: number): boolean {
     const script = /<script\b[^>]*>[\s\S]*?<\/script\s*>/gi;
+
     for (let match = script.exec(text); match; match = script.exec(text)) {
         if (offset > match.index + match[0].indexOf('>') && offset < match.index + match[0].lastIndexOf('</')) {
             return true;
         }
     }
+
     const expressions = /\{\{[\s\S]*?\}\}|(?:[:@][\w.:-]+|v-[\w.:-]+)\s*=\s*(?:"[^"]*"|'[^']*')/g;
+
     for (let match = expressions.exec(text); match; match = expressions.exec(text)) {
         if (offset >= match.index && offset <= match.index + match[0].length) {
             return true;
         }
     }
+
     return false;
 }
 
@@ -65,15 +76,18 @@ function paramsOffset(text: string, params: unknown): number | null {
     if (!params || typeof params !== 'object') {
         return null;
     }
+
     const position =
         'position' in params
             ? params.position
             : 'range' in params && params.range && typeof params.range === 'object' && 'start' in params.range
               ? params.range.start
               : null;
+
     if (!position || typeof position !== 'object') {
         return null;
     }
+
     try {
         return offsetAt(text, position as { line: number; character: number });
     } catch {
@@ -89,5 +103,6 @@ function paramsOffset(text: string, params: unknown): number | null {
 export function vueServerOrder(method: string, text: string, params: unknown): [VueServer, VueServer] {
     const offset = paramsOffset(text, params);
     const typescriptFirst = method === 'textDocument/inlayHint' || (offset !== null && isVueExpression(text, offset));
+
     return typescriptFirst ? ['typescript', 'vue'] : ['vue', 'typescript'];
 }

package/src/watched-files.ts

@@ -1,6 +1,6 @@
 import { globMatch } from './glob.ts';
 import type { FileSystemWatcher } from './protocol.ts';
-import { fileUriToPath } from './uris.ts';
+import { fileUriToPath, isWindowsPath } from './uris.ts';
 
 /* A change of a file as the protocol numbers it: created, changed, deleted. */
 export type FileChangeType = 1 | 2 | 3;
@@ -12,25 +12,31 @@ const SPARING_FOLDERS = ['node_modules', 'vendor', '.git'];
 
 /* A Windows path with forward slashes and its drive in capitals, so it compares with a pattern and a root however it was written. A POSIX path is left alone, a backslash being part of a name there. */
 function slashed(path: string): string {
-    if (!/^[A-Za-z]:[\\/]/.test(path) && !path.startsWith('\\\\')) {
+    if (!isWindowsPath(path)) {
         return path;
     }
+
     const forward = path.replaceAll('\\', '/');
+
     return /^[a-z]:/.test(forward) ? `${forward[0]!.toUpperCase()}${forward.slice(1)}` : forward;
 }
 
 function relativeTo(root: string, path: string): string | null {
     const prefix = root.endsWith('/') ? root : `${root}/`;
+
     return path.startsWith(prefix) ? path.slice(prefix.length) : null;
 }
 
 /* A pattern with the folder it is relative to, or null for a relative pattern whose base is no folder of this machine. */
 function patternOf(watcher: FileSystemWatcher): { base: string | undefined; pattern: string } | null {
     const { globPattern } = watcher;
+
     if (typeof globPattern === 'string') {
         return { base: undefined, pattern: globPattern };
     }
+
     const base = fileUriToPath(typeof globPattern.baseUri === 'string' ? globPattern.baseUri : globPattern.baseUri.uri);
+
     return base === null ? null : { base: slashed(base), pattern: globPattern.pattern };
 }
 
@@ -43,19 +49,25 @@ export function watchesFile(watchers: readonly FileSystemWatcher[], root: string
     const path = slashed(changed);
     const inProject = relativeTo(slashed(root), path);
     const segments = (inProject ?? path).split('/');
+
     return watchers.some((watcher) => {
         if (((watcher.kind ?? EVERY_CHANGE) & (1 << (type - 1))) === 0) {
             return false;
         }
+
         const parts = patternOf(watcher);
+
         if (parts === null) {
             return false;
         }
+
         const { base, pattern } = parts;
         const subject = pattern.startsWith('/') || /^[A-Za-z]:\//.test(pattern) ? path : base === undefined ? inProject : relativeTo(base, path);
+
         if (subject === null || !globMatch(subject, pattern)) {
             return false;
         }
+
         return SPARING_FOLDERS.every((folder) => !segments.includes(folder) || pattern.includes(folder));
     });
 }