@adecore/lsp 0.0.1 → 0.17.0-beta.2

package/dist/document.js

@@ -0,0 +1,282 @@
+import { ErrorCodes, LspError, StaleResultError } from './connection.js';
+import { applyContentChanges, minimalChange } from './edits.js';
+/*
+ * One open text document in one session. It owns the version: every change raises it by one, and a
+ * result that arrives for an older version is refused, so nothing computed for a text that is gone
+ * reaches the caller.
+ */
+export class LspDocument {
+    session;
+    uri;
+    languageId;
+    ready;
+    revision;
+    content;
+    closed = false;
+    synced;
+    closePromise;
+    inFlight = new Set();
+    latest = new Map();
+    resultVersions = new WeakMap();
+    constructor(session, item) {
+        // A uri that does not parse is the caller's bug, and fails here instead of inside a server.
+        new URL(item.uri);
+        this.session = session;
+        this.uri = item.uri;
+        this.languageId = item.languageId;
+        this.content = item.text;
+        this.revision = item.version ?? 1;
+        if (!Number.isSafeInteger(this.revision) || this.revision < 0) {
+            throw new LspError('Invalid document version');
+        }
+        this.ready = session.syncOptions.openClose
+            ? session.notify('textDocument/didOpen', { textDocument: { ...item, version: this.revision } })
+            : Promise.resolve();
+        this.synced = this.ready;
+        void this.ready.catch((error) => session.connection.reportError(error));
+    }
+    get version() {
+        return this.revision;
+    }
+    get text() {
+        return this.content;
+    }
+    get isClosed() {
+        return this.closed;
+    }
+    /* Sends the difference to the text as the one range that changed, or the whole text to a server that wants no ranges. */
+    updateText(text) {
+        this.assertOpen();
+        if (text === this.content) {
+            return this.synced;
+        }
+        return this.applyChanges([minimalChange(this.content, text)]);
+    }
+    /*
+     * Applies `didChange` entries in order, which a server that negotiated incremental sync gets as
+     * they are. The version goes up by one even when the text ends up the same.
+     */
+    applyChanges(changes) {
+        this.assertOpen();
+        const kind = this.session.syncOptions.change ?? 0;
+        if (!kind) {
+            return Promise.reject(new LspError('Server did not negotiate document changes', ErrorCodes.MethodNotFound));
+        }
+        let next;
+        try {
+            next = applyContentChanges(this.content, changes);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        this.content = next;
+        const version = ++this.revision;
+        this.cancelRequests();
+        const contentChanges = kind === 1 ? [{ text: next }] : changes.map((change) => ({ ...change }));
+        this.synced = this.synced.then(() => this.session.connection.notify('textDocument/didChange', { textDocument: { uri: this.uri, version }, contentChanges }));
+        void this.synced.catch((error) => this.session.connection.reportError(error));
+        return this.synced;
+    }
+    /* Call it once the file is on disk; it sends `didSave` when the server asked for it. */
+    async save() {
+        this.assertOpen();
+        const version = this.version;
+        const text = this.text;
+        await this.synced;
+        this.assertCurrent(version);
+        const save = this.session.syncOptions.save;
+        if (save) {
+            await this.session.notify('textDocument/didSave', {
+                textDocument: { uri: this.uri },
+                text: typeof save === 'object' && save.includeText ? text : undefined
+            });
+        }
+    }
+    completion(position, context, options) {
+        return this.feature('textDocument/completion', { position, context }, options);
+    }
+    resolveCompletion(item, options) {
+        return this.resolve('completionItem/resolve', item, options);
+    }
+    hover(position, options) {
+        return this.feature('textDocument/hover', { position }, options);
+    }
+    signatureHelp(position, context, options) {
+        return this.feature('textDocument/signatureHelp', { position, context }, options);
+    }
+    definition(position, options) {
+        return this.feature('textDocument/definition', { position }, options);
+    }
+    declaration(position, options) {
+        return this.feature('textDocument/declaration', { position }, options);
+    }
+    typeDefinition(position, options) {
+        return this.feature('textDocument/typeDefinition', { position }, options);
+    }
+    implementation(position, options) {
+        return this.feature('textDocument/implementation', { position }, options);
+    }
+    references(position, includeDeclaration = true, options) {
+        return this.feature('textDocument/references', { position, context: { includeDeclaration } }, options);
+    }
+    documentHighlights(position, options) {
+        return this.feature('textDocument/documentHighlight', { position }, options);
+    }
+    documentSymbols(options) {
+        return this.feature('textDocument/documentSymbol', {}, options);
+    }
+    prepareRename(position, options) {
+        return this.feature('textDocument/prepareRename', { position }, options);
+    }
+    rename(position, newName, options) {
+        return this.feature('textDocument/rename', { position, newName }, options);
+    }
+    codeActions(range, context = { diagnostics: [] }, options) {
+        return this.feature('textDocument/codeAction', { range, context }, options);
+    }
+    resolveCodeAction(action, options) {
+        return this.resolve('codeAction/resolve', action, options);
+    }
+    codeLenses(options) {
+        return this.feature('textDocument/codeLens', {}, options);
+    }
+    resolveCodeLens(lens, options) {
+        return this.resolve('codeLens/resolve', lens, options);
+    }
+    formatting(formatting, options) {
+        return this.feature('textDocument/formatting', { options: formatting }, options);
+    }
+    rangeFormatting(range, formatting, options) {
+        return this.feature('textDocument/rangeFormatting', { range, options: formatting }, options);
+    }
+    foldingRanges(options) {
+        return this.feature('textDocument/foldingRange', {}, options);
+    }
+    selectionRanges(positions, options) {
+        return this.feature('textDocument/selectionRange', { positions }, options);
+    }
+    semanticTokens(options) {
+        return this.feature('textDocument/semanticTokens/full', {}, options);
+    }
+    semanticTokensDelta(previousResultId, options) {
+        return this.feature('textDocument/semanticTokens/full/delta', { previousResultId }, options);
+    }
+    semanticTokensRange(range, options) {
+        return this.feature('textDocument/semanticTokens/range', { range }, options);
+    }
+    inlayHints(range, options) {
+        return this.feature('textDocument/inlayHint', { range }, options);
+    }
+    resolveInlayHint(hint, options) {
+        return this.resolve('inlayHint/resolve', hint, options);
+    }
+    diagnostics(previousResultId, identifier, options) {
+        return this.feature('textDocument/diagnostic', { previousResultId, identifier }, options);
+    }
+    /* Any feature by its LSP method, for a caller that gets the method from elsewhere. `params` leave out `textDocument`; a resolve method takes the item. */
+    request(method, params, options) {
+        return method.endsWith('/resolve') ? this.resolve(method, params, options) : this.feature(method, params, options);
+    }
+    /* Sends `didClose` after every change queued before it. The uri stays taken until then, so a reopen cannot overtake it. */
+    close() {
+        if (this.closePromise) {
+            return this.closePromise;
+        }
+        if (this.closed) {
+            return Promise.resolve();
+        }
+        this.closed = true;
+        this.cancelRequests();
+        this.closePromise = this.synced
+            .then(async () => {
+            if (!this.session.connection.isClosed && this.session.syncOptions.openClose) {
+                await this.session.connection.notify('textDocument/didClose', { textDocument: { uri: this.uri } });
+            }
+        })
+            .finally(() => this.session.forgetDocument(this));
+        return this.closePromise;
+    }
+    /* The connection is gone, so there is nobody to tell. */
+    disconnect() {
+        this.closed = true;
+        this.cancelRequests();
+        this.session.forgetDocument(this);
+    }
+    feature(method, params, options) {
+        return this.perform(method, { ...params, textDocument: { uri: this.uri } }, options);
+    }
+    resolve(method, item, options) {
+        const version = this.resultVersions.get(item);
+        if (version !== undefined && version !== this.version) {
+            return Promise.reject(new StaleResultError(this.uri));
+        }
+        return this.perform(method, item, options);
+    }
+    async perform(method, params, options = {}) {
+        this.assertOpen();
+        if (!this.session.supports(method, this)) {
+            throw new LspError(`Server does not support ${method}`, ErrorCodes.MethodNotFound);
+        }
+        const version = this.version;
+        const controller = new AbortController();
+        if (options.cancelPrevious !== false) {
+            this.latest.get(method)?.abort();
+        }
+        this.latest.set(method, controller);
+        this.inFlight.add(controller);
+        const abort = () => controller.abort();
+        options.signal?.addEventListener('abort', abort, { once: true });
+        if (options.signal?.aborted) {
+            abort();
+        }
+        try {
+            await this.synced;
+            this.assertCurrent(version);
+            const result = await this.session.request(method, params, { signal: controller.signal, timeoutMs: options.timeoutMs });
+            this.assertCurrent(version);
+            this.remember(result, version);
+            return result;
+        }
+        catch (error) {
+            this.assertCurrent(version);
+            throw error;
+        }
+        finally {
+            options.signal?.removeEventListener('abort', abort);
+            this.inFlight.delete(controller);
+            if (this.latest.get(method) === controller) {
+                this.latest.delete(method);
+            }
+        }
+    }
+    /* A completion item, code action or hint resolves only against the version it was produced for. */
+    remember(result, version) {
+        if (!result || typeof result !== 'object') {
+            return;
+        }
+        this.resultVersions.set(result, version);
+        if (Array.isArray(result)) {
+            for (const item of result) {
+                this.remember(item, version);
+            }
+        }
+        else if ('items' in result) {
+            this.remember(result.items, version);
+        }
+    }
+    assertOpen() {
+        if (this.closed) {
+            throw new LspError(`Document is closed: ${this.uri}`);
+        }
+    }
+    assertCurrent(version) {
+        if (this.closed || this.version !== version) {
+            throw new StaleResultError(this.uri);
+        }
+    }
+    cancelRequests() {
+        for (const controller of this.inFlight) {
+            controller.abort();
+        }
+    }
+}

package/dist/edits.d.ts

@@ -0,0 +1,18 @@
+import type { ContentChange, Position, TextEdit, WorkspaceEdit } from './protocol.ts';
+export interface DocumentSnapshot {
+    text: string;
+    version: number | null;
+}
+export interface PlannedDocumentEdit {
+    uri: string;
+    version: number | null;
+    before: string;
+    text: string;
+}
+export declare function offsetAt(text: string, position: Position): number;
+export declare function positionAt(text: string, offset: number): Position;
+export declare function endPosition(text: string): Position;
+export declare function applyTextEdits(text: string, edits: readonly TextEdit[]): string;
+export declare function applyContentChanges(text: string, changes: readonly ContentChange[]): string;
+export declare function minimalChange(before: string, after: string): ContentChange;
+export declare function planWorkspaceEdit(edit: WorkspaceEdit, snapshots: ReadonlyMap<string, DocumentSnapshot>): PlannedDocumentEdit[];

package/dist/edits.js

@@ -0,0 +1,161 @@
+import { ErrorCodes, LspError } from './connection.js';
+/* A line ends at `\n`, `\r\n` or a lone `\r`, which is how the protocol counts lines. */
+export function offsetAt(text, position) {
+    if (!Number.isInteger(position.line) || !Number.isInteger(position.character) || position.line < 0 || position.character < 0) {
+        throw new LspError('Invalid edit position');
+    }
+    let line = 0;
+    let offset = 0;
+    while (line < position.line && offset < text.length) {
+        const char = text.charCodeAt(offset++);
+        if (char === 13) {
+            if (text.charCodeAt(offset) === 10) {
+                offset++;
+            }
+            line++;
+        }
+        else if (char === 10) {
+            line++;
+        }
+    }
+    if (line !== position.line) {
+        throw new LspError('Edit line is outside the document');
+    }
+    let end = offset;
+    while (end < text.length && text[end] !== '\r' && text[end] !== '\n') {
+        end++;
+    }
+    if (offset + position.character > end) {
+        throw new LspError('Edit character is outside the line');
+    }
+    return offset + position.character;
+}
+export function positionAt(text, offset) {
+    if (!Number.isInteger(offset) || offset < 0 || offset > text.length) {
+        throw new LspError('Offset is outside the document');
+    }
+    let line = 0;
+    let lineStart = 0;
+    let i = 0;
+    while (i < offset) {
+        const code = text.charCodeAt(i);
+        if (code === 13 && text.charCodeAt(i + 1) === 10) {
+            if (i + 2 > offset) {
+                break;
+            }
+            i += 2;
+            line++;
+            lineStart = i;
+        }
+        else if (code === 13 || code === 10) {
+            i++;
+            line++;
+            lineStart = i;
+        }
+        else {
+            i++;
+        }
+    }
+    return { line, character: offset - lineStart };
+}
+/* The position after the last character. */
+export function endPosition(text) {
+    return positionAt(text, text.length);
+}
+/* Edits are simultaneous and in the coordinates of `text`; two inserts at one place keep their order. */
+export function applyTextEdits(text, edits) {
+    const spans = edits
+        .map((edit, index) => ({
+        start: offsetAt(text, edit.range.start),
+        end: offsetAt(text, edit.range.end),
+        text: edit.newText,
+        index
+    }))
+        .sort((a, b) => a.start - b.start || a.index - b.index);
+    let cursor = 0;
+    const parts = [];
+    for (const span of spans) {
+        if (span.end < span.start) {
+            throw new LspError('Edit range is reversed');
+        }
+        if (span.start < cursor) {
+            throw new LspError('Workspace edits overlap');
+        }
+        parts.push(text.slice(cursor, span.start), span.text);
+        cursor = span.end;
+    }
+    parts.push(text.slice(cursor));
+    return parts.join('');
+}
+/* `didChange` entries apply one after the other, each in the coordinates the one before left. */
+export function applyContentChanges(text, changes) {
+    let result = text;
+    for (const change of changes) {
+        if (!change.range) {
+            result = change.text;
+            continue;
+        }
+        const start = offsetAt(result, change.range.start);
+        const end = offsetAt(result, change.range.end);
+        if (end < start) {
+            throw new LspError('Change range is reversed');
+        }
+        result = result.slice(0, start) + change.text + result.slice(end);
+    }
+    return result;
+}
+function isHighSurrogate(code) {
+    return code >= 0xd800 && code <= 0xdbff;
+}
+function isLowSurrogate(code) {
+    return code >= 0xdc00 && code <= 0xdfff;
+}
+/*
+ * The one change that turns `before` into `after`: what is left once the shared start and end are
+ * taken off. A range never starts or ends inside a surrogate pair or a CRLF, which no position can
+ * name.
+ */
+export function minimalChange(before, after) {
+    const shortest = Math.min(before.length, after.length);
+    let start = 0;
+    while (start < shortest && before.charCodeAt(start) === after.charCodeAt(start)) {
+        start++;
+    }
+    if (start > 0 && (isHighSurrogate(before.charCodeAt(start - 1)) || (before[start - 1] === '\r' && before[start] === '\n'))) {
+        start--;
+    }
+    let end = 0;
+    while (end < shortest - start && before.charCodeAt(before.length - 1 - end) === after.charCodeAt(after.length - 1 - end)) {
+        end++;
+    }
+    if (end > 0 &&
+        (isLowSurrogate(before.charCodeAt(before.length - end)) || (before[before.length - end] === '\n' && before[before.length - end - 1] === '\r'))) {
+        end--;
+    }
+    return {
+        range: { start: positionAt(before, start), end: positionAt(before, before.length - end) },
+        text: after.slice(start, after.length - end)
+    };
+}
+/* Plans text edits in memory. A create, rename or delete needs the host's own handling and is refused. */
+export function planWorkspaceEdit(edit, snapshots) {
+    const planned = new Map();
+    const changes = edit.documentChanges ?? Object.entries(edit.changes ?? {}).map(([uri, edits]) => ({ textDocument: { uri, version: null }, edits }));
+    for (const change of changes) {
+        if ('kind' in change) {
+            throw new LspError(`A host file-operation handler is required for ${change.kind}`);
+        }
+        const { uri, version } = change.textDocument;
+        const snapshot = snapshots.get(uri);
+        if (!snapshot) {
+            throw new LspError(`Missing workspace snapshot: ${uri}`);
+        }
+        if (version !== null && snapshot.version !== version) {
+            throw new LspError(`Workspace edit version mismatch: ${uri}`, ErrorCodes.ContentModified);
+        }
+        const before = planned.get(uri)?.text ?? snapshot.text;
+        const text = applyTextEdits(before, change.edits);
+        planned.set(uri, { uri, version: snapshot.version, before: snapshot.text, text });
+    }
+    return [...planned.values()];
+}

package/dist/file-operations.d.ts

@@ -0,0 +1,5 @@
+import type { FileOperationFilter, FileRename } from './protocol.ts';
+export interface RenamedFile extends FileRename {
+    directory: boolean;
+}
+export declare function renamesTaken(filters: readonly FileOperationFilter[], files: readonly RenamedFile[]): FileRename[];

package/dist/file-operations.js

@@ -0,0 +1,23 @@
+import { globMatch } from './glob.js';
+function filterTakes(filter, file) {
+    const { matches, glob, options } = filter.pattern;
+    if (matches !== undefined && (matches === 'folder') !== file.directory) {
+        return false;
+    }
+    let url;
+    try {
+        url = new URL(file.oldUri);
+    }
+    catch {
+        return false;
+    }
+    if (filter.scheme !== undefined && filter.scheme !== url.protocol.slice(0, -1)) {
+        return false;
+    }
+    const path = decodeURIComponent(url.pathname);
+    return options?.ignoreCase === true ? globMatch(path.toLowerCase(), glob.toLowerCase()) : globMatch(path, glob);
+}
+/* The renames a server asked to hear about, by the filters it registered. A rename is matched on the place it leaves. */
+export function renamesTaken(filters, files) {
+    return files.filter((file) => filters.some((filter) => filterTakes(filter, file))).map(({ oldUri, newUri }) => ({ oldUri, newUri }));
+}

package/dist/glob.d.ts

@@ -0,0 +1 @@
+export declare function globMatch(path: string, pattern: string): boolean;

package/dist/glob.js

@@ -0,0 +1,67 @@
+const compiled = new Map();
+function escapeRegex(char) {
+    return char.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function compileGlob(pattern) {
+    let expression = '';
+    let depth = 0;
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        if (char === '*') {
+            if (pattern[i + 1] === '*') {
+                i++;
+                if (pattern[i + 1] === '/') {
+                    expression += '(?:.*/)?';
+                    i++;
+                }
+                else {
+                    expression += '.*';
+                }
+            }
+            else {
+                expression += '[^/]*';
+            }
+        }
+        else if (char === '?') {
+            expression += '[^/]';
+        }
+        else if (char === '[') {
+            const close = pattern.indexOf(']', i + 2);
+            if (close === -1) {
+                expression += '\\[';
+            }
+            else {
+                const body = pattern.slice(i + 1, close);
+                expression += `[${body.startsWith('!') ? `^${body.slice(1)}` : body}]`;
+                i = close;
+            }
+        }
+        else if (char === '{') {
+            depth++;
+            expression += '(?:';
+        }
+        else if (char === '}' && depth > 0) {
+            depth--;
+            expression += ')';
+        }
+        else if (char === ',' && depth > 0) {
+            expression += '|';
+        }
+        else {
+            expression += escapeRegex(char);
+        }
+    }
+    try {
+        return new RegExp(`^${expression}$`);
+    }
+    catch {
+        return null;
+    }
+}
+/* The glob of the protocol: `*`, `**`, `?`, `[a-z]`, `[!a-z]` and `{a,b}`. */
+export function globMatch(path, pattern) {
+    if (!compiled.has(pattern)) {
+        compiled.set(pattern, compileGlob(pattern));
+    }
+    return compiled.get(pattern)?.test(path) ?? false;
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { ErrorCodes, JsonRpcConnection, LspError, StaleResultError, type RequestHandler } from './connection.ts';
+export { LspDocument } from './document.ts';
+export { applyContentChanges, applyTextEdits, endPosition, minimalChange, offsetAt, planWorkspaceEdit, positionAt, type DocumentSnapshot, type PlannedDocumentEdit } from './edits.ts';
+export { renamesTaken, type RenamedFile } from './file-operations.ts';
+export { watchesFile, type FileChangeType } from './watched-files.ts';
+export { LspSession, type LspSessionOptions, type SessionState } from './session.ts';
+export type { DiagnosticsReport, LanguageDocument, LanguageRequestOptions, LanguageService } from './service.ts';
+export { ContentLengthDecoder, connectWebSocket, createMemoryTransportPair, createStreamTransport, encodeMessage, type ByteStream, type WebSocketTransportOptions } from './transport.ts';
+export { globMatch } from './glob.ts';
+export { fileUriToPath, pathToFileUri } from './uris.ts';
+export { bridgeVueTypeScript, isVueExpression, vueServerOrder, type VueServer } from './vue.ts';
+export type * from './protocol.ts';

package/dist/index.js

@@ -0,0 +1,10 @@
+export { ErrorCodes, JsonRpcConnection, LspError, StaleResultError } from './connection.js';
+export { LspDocument } from './document.js';
+export { applyContentChanges, applyTextEdits, endPosition, minimalChange, offsetAt, planWorkspaceEdit, positionAt } from './edits.js';
+export { renamesTaken } from './file-operations.js';
+export { watchesFile } from './watched-files.js';
+export { LspSession } from './session.js';
+export { ContentLengthDecoder, connectWebSocket, createMemoryTransportPair, createStreamTransport, encodeMessage } from './transport.js';
+export { globMatch } from './glob.js';
+export { fileUriToPath, pathToFileUri } from './uris.js';
+export { bridgeVueTypeScript, isVueExpression, vueServerOrder } from './vue.js';