@adecore/lsp 0.0.1 → 0.17.0-beta.1

package/dist/testing.js

@@ -0,0 +1,72 @@
+import { JsonRpcConnection } from './connection.js';
+import { applyContentChanges } from './edits.js';
+export { createMemoryTransportPair } from './transport.js';
+/*
+ * A language server for tests, on the far end of a transport. It answers the handshake, keeps the
+ * text of every document it was told about the way a real server does, and answers whatever a test
+ * registers with `handle`; any other request is refused as unsupported.
+ */
+export class FakeLanguageServer {
+    connection;
+    received = [];
+    documents = new Map();
+    shutdownRequested = false;
+    exited = false;
+    constructor(transport, options = {}) {
+        this.connection = new JsonRpcConnection(transport, 0);
+        transport.onMessage((message) => {
+            const { method, params, id } = message;
+            if (typeof method === 'string') {
+                this.received.push({ method, params, id });
+            }
+        });
+        this.connection.onRequest('initialize', () => options.silent
+            ? new Promise(() => undefined)
+            : { capabilities: options.capabilities ?? { textDocumentSync: 2 }, serverInfo: options.serverInfo });
+        this.connection.onRequest('shutdown', () => {
+            this.shutdownRequested = true;
+            return null;
+        });
+        this.connection.onNotification('exit', () => {
+            this.exited = true;
+        });
+        this.connection.onNotification('textDocument/didOpen', (params) => {
+            const { textDocument } = params;
+            this.documents.set(textDocument.uri, { languageId: textDocument.languageId, text: textDocument.text, version: textDocument.version });
+        });
+        this.connection.onNotification('textDocument/didChange', (params) => {
+            const { textDocument, contentChanges } = params;
+            const document = this.documents.get(textDocument.uri);
+            if (document) {
+                document.text = applyContentChanges(document.text, contentChanges);
+                document.version = textDocument.version;
+            }
+        });
+        this.connection.onNotification('textDocument/didClose', (params) => {
+            this.documents.delete(params.textDocument.uri);
+        });
+        for (const [method, handler] of Object.entries(options.handlers ?? {})) {
+            this.connection.onRequest(method, handler);
+        }
+    }
+    handle(method, handler) {
+        this.connection.onRequest(method, handler);
+    }
+    /* The params of every request or notification of `method`, in the order they came. */
+    paramsOf(method) {
+        return this.received.filter((message) => message.method === method).map((message) => message.params);
+    }
+    publishDiagnostics(uri, diagnostics, version) {
+        return this.connection.notify('textDocument/publishDiagnostics', { uri, version, diagnostics });
+    }
+    notify(method, params) {
+        return this.connection.notify(method, params);
+    }
+    request(method, params) {
+        return this.connection.request(method, params);
+    }
+    /* The process went away: the transport closes under the client. */
+    crash() {
+        return this.connection.close();
+    }
+}

package/dist/transport.d.ts

@@ -0,0 +1,27 @@
+import type { Disposable, LspTransport, RpcMessage } from './protocol.ts';
+export declare class ContentLengthDecoder {
+    private readonly maxMessageBytes;
+    private chunks;
+    private size;
+    private length;
+    constructor(maxMessageBytes?: number);
+    accept(chunk: Uint8Array): unknown[];
+}
+export declare function encodeMessage(message: RpcMessage): Uint8Array;
+export interface ByteStream {
+    write(chunk: Uint8Array): void | Promise<void>;
+    onData(listener: (chunk: Uint8Array) => void): Disposable;
+    onClose(listener: (error?: Error) => void): Disposable;
+    close(): void | Promise<void>;
+}
+export declare function createStreamTransport(stream: ByteStream, options?: {
+    maxMessageBytes?: number;
+}): LspTransport;
+export declare function createMemoryTransportPair(): [LspTransport, LspTransport];
+export interface WebSocketTransportOptions {
+    protocols?: string[];
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    createWebSocket?: (url: string, protocols?: string[]) => WebSocket;
+}
+export declare function connectWebSocket(url: string, options?: WebSocketTransportOptions): Promise<LspTransport>;

package/dist/transport.js

@@ -0,0 +1,258 @@
+const DEFAULT_MAX_MESSAGE_BYTES = 32 * 1024 * 1024;
+const MAX_HEADER_BYTES = 8192;
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+/*
+ * The listeners of a transport. A message that arrives before anyone listens is held and handed to
+ * the first listener, since a server may speak the moment its pipe opens.
+ */
+class TransportEvents {
+    closed = false;
+    messages = new Set();
+    closes = new Set();
+    backlog = [];
+    error;
+    onMessage = (listener) => {
+        this.messages.add(listener);
+        for (const message of this.backlog.splice(0)) {
+            listener(message);
+        }
+        return {
+            dispose: () => {
+                this.messages.delete(listener);
+            }
+        };
+    };
+    onClose = (listener) => {
+        this.closes.add(listener);
+        if (this.closed) {
+            listener(this.error);
+        }
+        return {
+            dispose: () => {
+                this.closes.delete(listener);
+            }
+        };
+    };
+    receive(message) {
+        if (this.closed) {
+            return;
+        }
+        if (this.messages.size === 0) {
+            this.backlog.push(message);
+            return;
+        }
+        for (const listener of this.messages) {
+            listener(message);
+        }
+    }
+    finish(error) {
+        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();
+    }
+}
+function concat(chunks, size) {
+    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;
+}
+function indexOfHeaderEnd(bytes) {
+    for (let i = 0; i + 3 < bytes.length; i++) {
+        if (bytes[i] === 13 && bytes[i + 1] === 10 && bytes[i + 2] === 13 && bytes[i + 3] === 10) {
+            return i;
+        }
+    }
+    return -1;
+}
+/* Reads `Content-Length` framed messages, the way a language server speaks over stdio. */
+export class ContentLengthDecoder {
+    maxMessageBytes;
+    chunks = [];
+    size = 0;
+    length = null;
+    constructor(maxMessageBytes = DEFAULT_MAX_MESSAGE_BYTES) {
+        this.maxMessageBytes = maxMessageBytes;
+    }
+    /* Every complete message in what has arrived so far. Throws on a frame it cannot read, after which the stream is no use. */
+    accept(chunk) {
+        this.chunks.push(chunk);
+        this.size += chunk.length;
+        const messages = [];
+        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 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))));
+            this.chunks = [buffer.subarray(this.length)];
+            this.size = buffer.length - this.length;
+            this.length = null;
+        }
+        return messages;
+    }
+}
+export function encodeMessage(message) {
+    const body = new TextEncoder().encode(JSON.stringify(message));
+    const header = new TextEncoder().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;
+}
+export function createStreamTransport(stream, options = {}) {
+    const events = new TransportEvents();
+    const decoder = new ContentLengthDecoder(options.maxMessageBytes);
+    stream.onData((chunk) => {
+        try {
+            for (const message of decoder.accept(chunk)) {
+                events.receive(message);
+            }
+        }
+        catch (error) {
+            events.finish(asError(error));
+            void Promise.resolve(stream.close()).catch(() => undefined);
+        }
+    });
+    stream.onClose((error) => events.finish(error));
+    return {
+        onMessage: events.onMessage,
+        onClose: events.onClose,
+        async send(message) {
+            if (events.closed) {
+                throw new Error('LSP stream is closed');
+            }
+            await stream.write(encodeMessage(message));
+        },
+        async close() {
+            events.finish();
+            await stream.close();
+        }
+    };
+}
+/* Two ends of one connection in memory: what one sends the other receives, as JSON and one tick later. Closing either ends both. */
+export function createMemoryTransportPair() {
+    const left = new TransportEvents();
+    const right = new TransportEvents();
+    const end = (inbox, outbox) => ({
+        onMessage: inbox.onMessage,
+        onClose: inbox.onClose,
+        send(message) {
+            if (inbox.closed || outbox.closed) {
+                throw new Error('LSP transport is closed');
+            }
+            const copy = JSON.parse(JSON.stringify(message));
+            queueMicrotask(() => outbox.receive(copy));
+        },
+        close() {
+            inbox.finish();
+            outbox.finish();
+        }
+    });
+    return [end(left, right), end(right, left)];
+}
+const MAX_SOCKET_BUFFER_BYTES = 8 * 1024 * 1024;
+/* JSON text frames over a WebSocket, which a browser can open and a daemon can serve. */
+export async function connectWebSocket(url, options = {}) {
+    if (options.signal?.aborted) {
+        throw new Error('WebSocket connection cancelled');
+    }
+    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((resolve, reject) => {
+        const timer = setTimeout(() => fail(new Error('LSP WebSocket connection timed out')), options.timeoutMs ?? 10_000);
+        const cleanup = () => {
+            clearTimeout(timer);
+            socket.removeEventListener('open', open);
+            socket.removeEventListener('error', failed);
+            socket.removeEventListener('close', closed);
+            options.signal?.removeEventListener('abort', abort);
+        };
+        const fail = (reason) => {
+            cleanup();
+            socket.close();
+            reject(reason);
+        };
+        const open = () => {
+            cleanup();
+            resolve();
+        };
+        const failed = () => fail(new Error('LSP WebSocket connection failed'));
+        const closed = () => fail(new Error('LSP WebSocket closed before opening'));
+        const abort = () => 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: events.onMessage,
+        onClose: events.onClose,
+        send(message) {
+            if (events.closed || socket.readyState !== 1) {
+                throw new Error('LSP WebSocket is closed');
+            }
+            if (socket.bufferedAmount > MAX_SOCKET_BUFFER_BYTES) {
+                throw new Error('LSP WebSocket send buffer is full');
+            }
+            socket.send(JSON.stringify(message));
+        },
+        close() {
+            events.finish();
+            socket.close(1000);
+        }
+    };
+}

package/dist/uris.d.ts

@@ -0,0 +1,2 @@
+export declare function pathToFileUri(path: string): string;
+export declare function fileUriToPath(uri: string): string | null;

package/dist/uris.js

@@ -0,0 +1,28 @@
+function isWindowsDrive(segment) {
+    return /^[A-Za-z]:$/.test(segment);
+}
+/* An absolute path, POSIX or with a Windows drive, as the `file:` URI a language server names it by. */
+export function pathToFileUri(path) {
+    const normalized = path.replaceAll('\\', '/');
+    const rooted = normalized.startsWith('/') ? normalized : `/${normalized}`;
+    const segments = rooted.split('/').map((segment, index) => (index === 1 && isWindowsDrive(segment) ? segment : encodeURIComponent(segment)));
+    return `file://${segments.join('/')}`;
+}
+/* The path behind a `file:` URI, in the form of the machine it names, or null for any other kind of URI. */
+export function fileUriToPath(uri) {
+    let url;
+    try {
+        url = new URL(uri);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== 'file:') {
+        return null;
+    }
+    const path = decodeURIComponent(url.pathname);
+    if (/^\/[A-Za-z]:/.test(path)) {
+        return path.slice(1).replaceAll('/', '\\');
+    }
+    return path;
+}

package/dist/vue.d.ts

@@ -0,0 +1,6 @@
+import type { Disposable } from './protocol.ts';
+import type { LspSession } from './session.ts';
+export declare function bridgeVueTypeScript(vue: LspSession, typescript: LspSession): Disposable;
+export type VueServer = 'vue' | 'typescript';
+export declare function isVueExpression(text: string, offset: number): boolean;
+export declare function vueServerOrder(method: string, text: string, params: unknown): [VueServer, VueServer];

package/dist/vue.js

@@ -0,0 +1,86 @@
+import { offsetAt } from './edits.js';
+/*
+ * Vue's server leaves TypeScript to a tsserver of its own project and asks for it with
+ * `tsserver/request` notifications, which this relays to the TypeScript server's
+ * `typescript.tsserverRequest` command. Attach it before the Vue session initializes, and open each
+ * `.vue` document in both sessions, TypeScript first.
+ */
+export function bridgeVueTypeScript(vue, typescript) {
+    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;
+        let body = null;
+        try {
+            const response = await typescript.executeCommand('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;
+            subscription.dispose();
+        }
+    };
+}
+/* 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, offset) {
+    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;
+}
+function paramsOffset(text, params) {
+    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);
+    }
+    catch {
+        return null;
+    }
+}
+/*
+ * Which of the two servers of a Vue document to ask first, the other being the fallback when the
+ * first does not support the method. Vue answers template markup, HTML and CSS; TypeScript answers
+ * a script and the expressions of a template, and the inlay hints of all of it.
+ */
+export function vueServerOrder(method, text, params) {
+    const offset = paramsOffset(text, params);
+    const typescriptFirst = method === 'textDocument/inlayHint' || (offset !== null && isVueExpression(text, offset));
+    return typescriptFirst ? ['typescript', 'vue'] : ['vue', 'typescript'];
+}

package/dist/watched-files.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystemWatcher } from './protocol.ts';
+export type FileChangeType = 1 | 2 | 3;
+export declare function watchesFile(watchers: readonly FileSystemWatcher[], root: string, path: string, type: FileChangeType): boolean;

package/dist/watched-files.js

@@ -0,0 +1,41 @@
+import { globMatch } from './glob.js';
+import { fileUriToPath } from './uris.js';
+/* Folders whose files a server hears about only when a pattern of its own names the folder. */
+const SPARING_FOLDERS = ['node_modules', 'vendor', '.git'];
+function relativeTo(root, path) {
+    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. `base` is undefined for a string pattern. */
+function patternOf(watcher) {
+    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, pattern: globPattern.pattern };
+}
+/*
+ * Whether a server asked to hear about this change. A string pattern is relative to the project folder
+ * (or absolute), a relative pattern to its own base. A path inside `node_modules`, `vendor` or `.git` only
+ * matches a pattern that names that folder, since `**` over a dependency tree is what a server never means.
+ */
+export function watchesFile(watchers, root, path, type) {
+    const inProject = relativeTo(root, path);
+    const segments = (inProject ?? path).split('/');
+    return watchers.some((watcher) => {
+        if (((watcher.kind ?? 7) & (1 << (type - 1))) === 0) {
+            return false;
+        }
+        const parts = patternOf(watcher);
+        if (parts === null) {
+            return false;
+        }
+        const { base, pattern } = parts;
+        const subject = pattern.startsWith('/') ? 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));
+    });
+}

package/package.json

@@ -1,11 +1,44 @@
 {
   "name": "@adecore/lsp",
-  "version": "0.0.1",
-  "description": "Placeholder for the first release.",
+  "version": "0.17.0-beta.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "source": "./src/testing.ts",
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
+    }
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "bun scripts/build.ts",
+    "test": "bun test --conditions=source"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.4.2",
+    "typescript": "^7.0.2"
+  },
   "license": "FSL-1.1-MIT",
+  "author": "Bas Milius",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/basmilius/adecore.git",
     "directory": "packages/lsp"
-  }
+  },
+  "bugs": {
+    "url": "https://github.com/basmilius/adecore/issues"
+  },
+  "homepage": "https://adecore.dev/lsp/",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "LICENSE"
+  ]
 }