@adecore/lsp 0.41.1 → 0.43.0

package/dist/session.js

@@ -38,7 +38,20 @@ const PROVIDERS = {
     'textDocument/prepareCallHierarchy': 'callHierarchyProvider',
     'callHierarchy/incomingCalls': 'callHierarchyProvider',
     'callHierarchy/outgoingCalls': 'callHierarchyProvider',
-    'textDocument/diagnostic': 'diagnosticProvider'
+    'textDocument/diagnostic': 'diagnosticProvider',
+    'workspace/diagnostic': 'diagnosticProvider',
+    'textDocument/documentLink': 'documentLinkProvider',
+    'documentLink/resolve': 'documentLinkProvider',
+    'textDocument/documentColor': 'colorProvider',
+    'textDocument/colorPresentation': 'colorProvider',
+    'textDocument/linkedEditingRange': 'linkedEditingRangeProvider',
+    'textDocument/moniker': 'monikerProvider',
+    'textDocument/prepareTypeHierarchy': 'typeHierarchyProvider',
+    'typeHierarchy/supertypes': 'typeHierarchyProvider',
+    'typeHierarchy/subtypes': 'typeHierarchyProvider',
+    'textDocument/inlineValue': 'inlineValueProvider',
+    'textDocument/inlineCompletion': 'inlineCompletionProvider',
+    'textDocument/rangesFormatting': 'documentRangeFormattingProvider'
 };
 /* A method whose dynamic registration is made under the name of another. */
 const REGISTRATION_METHODS = {
@@ -52,9 +65,23 @@ const REGISTRATION_METHODS = {
     'workspaceSymbol/resolve': 'workspace/symbol',
     'textDocument/semanticTokens/full': 'textDocument/semanticTokens',
     'textDocument/semanticTokens/full/delta': 'textDocument/semanticTokens',
-    'textDocument/semanticTokens/range': 'textDocument/semanticTokens'
+    'textDocument/semanticTokens/range': 'textDocument/semanticTokens',
+    'documentLink/resolve': 'textDocument/documentLink',
+    'textDocument/colorPresentation': 'textDocument/documentColor',
+    'typeHierarchy/supertypes': 'textDocument/prepareTypeHierarchy',
+    'typeHierarchy/subtypes': 'textDocument/prepareTypeHierarchy',
+    'textDocument/rangesFormatting': 'textDocument/rangeFormatting',
+    'workspace/diagnostic': 'textDocument/diagnostic'
 };
-const REFRESH_REQUESTS = ['workspace/semanticTokens/refresh', 'workspace/inlayHint/refresh', 'workspace/diagnostic/refresh', 'workspace/codeLens/refresh'];
+const REFRESH_REQUESTS = [
+    'workspace/semanticTokens/refresh',
+    'workspace/inlayHint/refresh',
+    'workspace/diagnostic/refresh',
+    'workspace/codeLens/refresh',
+    'workspace/inlineValue/refresh',
+    'workspace/foldingRange/refresh',
+    'workspace/textDocumentContent/refresh'
+];
 function matches(options, document) {
     if (options.documentSelector == null) {
         return true;
@@ -84,6 +111,12 @@ function offersMethod(method, options) {
     if (method === 'textDocument/semanticTokens/range') {
         return !!options.range;
     }
+    if (method === 'textDocument/rangesFormatting') {
+        return options.rangesSupport === true;
+    }
+    if (method === 'workspace/diagnostic') {
+        return options.workspaceDiagnostics === true;
+    }
     return true;
 }
 /* One conversation with one language server: the handshake, what it can do, and the documents open in it. */
@@ -100,6 +133,7 @@ export class LspSession {
     diagnosticListeners = new Set();
     capabilityListeners = new Set();
     configuration;
+    folders;
     constructor(transport, options = {}) {
         this.options = options;
         this.connection = new JsonRpcConnection(transport, options.timeoutMs);
@@ -122,9 +156,15 @@ export class LspSession {
             const { items } = params;
             return Promise.all(items.map((item) => (options.onConfiguration ? options.onConfiguration(item) : this.readConfiguration(item.section))));
         });
+        this.folders = options.workspaceFolders ?? (options.rootUri ? [{ uri: options.rootUri, name: 'Workspace' }] : null);
         this.connection.onRequest('workspace/workspaceFolders', () => this.workspaceFolders);
         this.connection.onRequest('workspace/applyEdit', (params) => options.onApplyEdit?.(params) ?? { applied: false, failureReason: 'No workspace edit handler is attached' });
         this.connection.onRequest('window/showMessageRequest', (params) => options.onShowMessage?.(params) ?? null);
+        this.connection.onRequest('window/showDocument', (params) => options.onShowDocument?.(params) ?? { success: false });
+        this.connection.onNotification('window/showMessage', (params) => options.onMessage?.(params));
+        this.connection.onNotification('window/logMessage', (params) => options.onLog?.(params));
+        this.connection.onNotification('$/logTrace', (params) => options.onTrace?.(params));
+        this.connection.onNotification('telemetry/event', (params) => options.onTelemetry?.(params));
         this.connection.onRequest('window/workDoneProgress/create', () => null);
         this.connection.onRequest('client/registerCapability', (params) => {
             const { registrations } = params;
@@ -157,7 +197,7 @@ export class LspSession {
         return this.serverCapabilities;
     }
     get workspaceFolders() {
-        return this.options.workspaceFolders ?? (this.options.rootUri ? [{ uri: this.options.rootUri, name: 'Workspace' }] : null);
+        return this.folders === null ? null : [...this.folders];
     }
     get syncOptions() {
         const sync = this.serverCapabilities.textDocumentSync;
@@ -178,6 +218,8 @@ export class LspSession {
                     rootUri: this.options.rootUri ?? null,
                     workspaceFolders: this.workspaceFolders,
                     clientInfo: this.options.clientInfo ?? { name: '@adecore/lsp' },
+                    locale: this.options.locale,
+                    trace: this.options.trace ?? 'off',
                     capabilities: clientCapabilities(this.options),
                     initializationOptions: this.options.initializationOptions
                 });
@@ -222,7 +264,14 @@ export class LspSession {
                 candidates.push(registration.registerOptions ?? {});
             }
         }
-        const provider = this.serverCapabilities[PROVIDERS[method]];
+        if (method === 'textDocument/willSaveWaitUntil' && this.syncOptions.willSaveWaitUntil) {
+            candidates.push({});
+        }
+        const content = this.serverCapabilities.workspace?.textDocumentContent;
+        if (method === 'workspace/textDocumentContent' && content !== undefined) {
+            candidates.push({ schemes: content.schemes });
+        }
+        const provider = PROVIDERS[method] === undefined ? undefined : this.serverCapabilities[PROVIDERS[method]];
         if (provider === true) {
             candidates.push({});
         }
@@ -260,6 +309,87 @@ export class LspSession {
         }
         return this.request('workspaceSymbol/resolve', symbol, options);
     }
+    /*
+     * The diagnostics of every file of the project, for a server that offers them. `previousResultIds` are what the
+     * client last heard per document, so the server can answer `unchanged`; `onPartialResult` streams reports while it works.
+     */
+    workspaceDiagnostics(previousResultIds = [], identifier, options) {
+        if (!this.supports('workspace/diagnostic')) {
+            return Promise.reject(new LspError('Server does not support workspace diagnostics', ErrorCodes.MethodNotFound));
+        }
+        return this.request('workspace/diagnostic', { identifier, previousResultIds: [...previousResultIds] }, options);
+    }
+    /* The text of a document of a scheme the server owns, such as a decompiled class, which is shown read-only. */
+    textDocumentContent(uri, options) {
+        const scheme = uri.slice(0, Math.max(0, uri.indexOf(':')));
+        if (!this.providerOptions('workspace/textDocumentContent')?.schemes?.includes(scheme)) {
+            return Promise.reject(new LspError(`Server does not serve documents of ${scheme}:`, ErrorCodes.MethodNotFound));
+        }
+        return this.request('workspace/textDocumentContent', { uri }, options);
+    }
+    /* Changes the trace level the server sends `$/logTrace` at. */
+    setTrace(value) {
+        return this.notify('$/setTrace', { value });
+    }
+    /* Asks the server to stop work it reported as cancellable under `token`. */
+    cancelWorkDoneProgress(token) {
+        return this.notify('window/workDoneProgress/cancel', { token });
+    }
+    /* Adds and removes folders of the workspace, and tells a server that asked to hear about it. */
+    async changeWorkspaceFolders(event) {
+        const removed = new Set(event.removed.map((folder) => fileUriKey(folder.uri)));
+        const kept = (this.folders ?? []).filter((folder) => !removed.has(fileUriKey(folder.uri)));
+        const known = new Set(kept.map((folder) => fileUriKey(folder.uri)));
+        this.folders = [...kept, ...event.added.filter((folder) => !known.has(fileUriKey(folder.uri)))];
+        const notifications = this.serverCapabilities.workspace?.workspaceFolders?.changeNotifications;
+        const registered = [...this.registrations.values()].some((registration) => registration.method === 'workspace/didChangeWorkspaceFolders');
+        if (this.phase === 'ready' && (notifications === true || typeof notifications === 'string' || registered)) {
+            await this.notify('workspace/didChangeWorkspaceFolders', { event: { added: [...event.added], removed: [...event.removed] } });
+        }
+    }
+    /* Whether the server synchronizes notebooks of this type and scheme; the `notebook*` methods do nothing for one it does not. */
+    syncsNotebook(notebook) {
+        const selectors = this.serverCapabilities.notebookDocumentSync?.notebookSelector ?? [];
+        const scheme = notebook.uri.slice(0, Math.max(0, notebook.uri.indexOf(':')));
+        return selectors.some(({ notebook: filter }) => {
+            if (filter === undefined) {
+                return true;
+            }
+            if (typeof filter === 'string') {
+                return filter === '*' || filter === notebook.notebookType;
+            }
+            return ((!filter.notebookType || filter.notebookType === notebook.notebookType) &&
+                (!filter.scheme || filter.scheme === scheme) &&
+                (!filter.pattern || globMatch(decodeURIComponent(new URL(notebook.uri).pathname), filter.pattern)));
+        });
+    }
+    /* Opens a notebook with the documents of its cells, which do not go through `openDocument`. */
+    async openNotebook(notebook, cellTextDocuments) {
+        if (this.syncsNotebook(notebook)) {
+            await this.notify('notebookDocument/didOpen', {
+                notebookDocument: notebook,
+                cellTextDocuments: cellTextDocuments.map((item) => ({ ...item, version: item.version ?? 0 }))
+            });
+        }
+    }
+    async changeNotebook(notebook, change) {
+        if (this.syncsNotebook(notebook)) {
+            await this.notify('notebookDocument/didChange', { notebookDocument: { uri: notebook.uri, version: notebook.version }, change });
+        }
+    }
+    async saveNotebook(notebook) {
+        if (this.syncsNotebook(notebook) && this.serverCapabilities.notebookDocumentSync?.save === true) {
+            await this.notify('notebookDocument/didSave', { notebookDocument: { uri: notebook.uri } });
+        }
+    }
+    async closeNotebook(notebook, cellUris) {
+        if (this.syncsNotebook(notebook)) {
+            await this.notify('notebookDocument/didClose', {
+                notebookDocument: { uri: notebook.uri },
+                cellTextDocuments: cellUris.map((uri) => ({ uri }))
+            });
+        }
+    }
     async setConfiguration(settings) {
         this.configuration = settings;
         await this.notify('workspace/didChangeConfiguration', { settings });
@@ -418,7 +548,13 @@ function clientCapabilities(options) {
     const dynamic = { dynamicRegistration: true };
     const symbolKind = { valueSet: Array.from({ length: 26 }, (_, index) => index + 1) };
     return {
-        general: { positionEncodings: ['utf-16'] },
+        general: {
+            positionEncodings: ['utf-16'],
+            staleRequestSupport: { cancel: true, retryOnContentModified: [] },
+            regularExpressions: { engine: 'ECMAScript', version: 'ES2020' },
+            markdown: { parser: 'remark', version: '15' }
+        },
+        notebookDocument: { synchronization: { dynamicRegistration: false, executionSummarySupport: true } },
         workspace: {
             applyEdit: !!options.onApplyEdit,
             workspaceEdit: { documentChanges: true, resourceOperations: [...(options.resourceOperations ?? ['create', 'rename'])], failureHandling: 'abort' },
@@ -439,11 +575,18 @@ function clientCapabilities(options) {
             semanticTokens: { refreshSupport: true },
             inlayHint: { refreshSupport: true },
             codeLens: { refreshSupport: true },
-            diagnostics: { refreshSupport: true }
+            diagnostics: { refreshSupport: true },
+            inlineValue: { refreshSupport: true },
+            foldingRange: { refreshSupport: true },
+            textDocumentContent: { dynamicRegistration: false }
+        },
+        window: {
+            workDoneProgress: true,
+            showMessage: { messageActionItem: { additionalPropertiesSupport: false } },
+            showDocument: { support: !!options.onShowDocument }
         },
-        window: { workDoneProgress: true, showMessage: { messageActionItem: { additionalPropertiesSupport: false } } },
         textDocument: {
-            synchronization: { dynamicRegistration: false, didSave: true },
+            synchronization: { dynamicRegistration: false, willSave: true, willSaveWaitUntil: true, didSave: true },
             publishDiagnostics: {
                 versionSupport: true,
                 relatedInformation: true,
@@ -455,6 +598,7 @@ function clientCapabilities(options) {
                 ...dynamic,
                 contextSupport: true,
                 insertTextMode: 1,
+                completionItemKind: { valueSet: Array.from({ length: 25 }, (_, index) => index + 1) },
                 ...(options.completionItemDefaults?.length ? { completionList: { itemDefaults: [...options.completionItemDefaults] } } : {}),
                 completionItem: {
                     snippetSupport: options.snippetSupport ?? false,
@@ -462,6 +606,7 @@ function clientCapabilities(options) {
                     commitCharactersSupport: true,
                     documentationFormat: ['markdown', 'plaintext'],
                     deprecatedSupport: true,
+                    tagSupport: { valueSet: [1] },
                     preselectSupport: true,
                     insertReplaceSupport: true,
                     labelDetailsSupport: true,
@@ -509,11 +654,23 @@ function clientCapabilities(options) {
                 },
                 resolveSupport: { properties: ['edit', 'command'] }
             },
-            codeLens: dynamic,
+            codeLens: { ...dynamic, resolveSupport: { properties: ['command'] } },
             formatting: dynamic,
-            rangeFormatting: dynamic,
+            rangeFormatting: { ...dynamic, rangesSupport: true },
             onTypeFormatting: dynamic,
-            foldingRange: { ...dynamic, lineFoldingOnly: false, foldingRange: { collapsedText: false } },
+            foldingRange: {
+                ...dynamic,
+                lineFoldingOnly: false,
+                foldingRangeKind: { valueSet: ['comment', 'imports', 'region'] },
+                foldingRange: { collapsedText: false }
+            },
+            documentLink: { ...dynamic, tooltipSupport: true },
+            colorProvider: dynamic,
+            linkedEditingRange: dynamic,
+            moniker: dynamic,
+            typeHierarchy: dynamic,
+            inlineValue: dynamic,
+            inlineCompletion: dynamic,
             selectionRange: dynamic,
             semanticTokens: {
                 ...dynamic,

package/dist/unserved.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageService } from './service.ts';
+export declare function unservedLanguageService(): LanguageService;

package/dist/unserved.js

@@ -0,0 +1,53 @@
+import { ErrorCodes, LspError } from './connection.js';
+const REQUESTS = [
+    'completion',
+    'resolveCompletion',
+    'hover',
+    'signatureHelp',
+    'definition',
+    'declaration',
+    'typeDefinition',
+    'implementation',
+    'references',
+    'documentHighlights',
+    'documentSymbols',
+    'prepareRename',
+    'rename',
+    'codeActions',
+    'resolveCodeAction',
+    'executeCommand',
+    'formatting',
+    'rangeFormatting',
+    'semanticTokens',
+    'semanticTokensDelta',
+    'semanticTokensRange',
+    'inlayHints',
+    'resolveInlayHint',
+    'workspaceSymbols',
+    'foldingRanges',
+    'selectionRanges',
+    'codeLenses',
+    'resolveCodeLens'
+];
+const NOTHING = { dispose: () => undefined };
+function refuse() {
+    return Promise.reject(new LspError('No language server serves this document', ErrorCodes.MethodNotFound));
+}
+/*
+ * A service for documents no server serves: it takes documents and answers `supports` with false, so a
+ * feature that checks first never asks, and rejects every request with an `LspError` of code -32601.
+ */
+export function unservedLanguageService() {
+    // Every request has the same refusal whatever its parameters, which the record type cannot say.
+    const requests = Object.fromEntries(REQUESTS.map((name) => [name, refuse]));
+    return {
+        ...requests,
+        openDocument: () => Promise.resolve(),
+        changeDocument: () => Promise.resolve(),
+        closeDocument: () => Promise.resolve(),
+        supports: () => false,
+        providerOptions: () => undefined,
+        onProvidersChanged: () => NOTHING,
+        onDiagnostics: () => NOTHING
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/lsp",
-  "version": "0.41.1",
+  "version": "0.43.0",
   "type": "module",
   "exports": {
     ".": {

package/src/connection.ts

@@ -1,5 +1,5 @@
 import { asError } from './as-error.ts';
-import type { Disposable, LspTransport, RequestId, RequestOptions, RpcMessage, RpcRequest } from './protocol.ts';
+import type { Disposable, LspTransport, RequestId, RequestOptions, RpcMessage, RpcRequest, WorkDoneProgress } from './protocol.ts';
 
 /* The JSON-RPC and LSP codes this package answers with. */
 export const ErrorCodes = {
@@ -89,7 +89,7 @@ export class JsonRpcConnection {
         }
 
         const id = ++this.nextId;
-
+        const progress = this.progressOf(id, params, options);
         return new Promise<T>((resolve, reject) => {
             let timer: ReturnType<typeof setTimeout> | undefined;
 
@@ -110,6 +110,7 @@ export class JsonRpcConnection {
                 cleanup: () => {
                     clearTimeout(timer);
                     options.signal?.removeEventListener('abort', abort);
+                    progress.listening?.dispose();
                 }
             });
 
@@ -120,8 +121,34 @@ export class JsonRpcConnection {
                 timer = setTimeout(() => cancel(new LspError(`LSP request timed out: ${method}`, ErrorCodes.RequestCancelled)), timeout);
             }
 
-            void this.send({ jsonrpc: '2.0', id, method, params }).catch((error) => this.settle(id, undefined, error));
+            void this.send({ jsonrpc: '2.0', id, method, params: progress.params }).catch((error) => this.settle(id, undefined, error));
+        });
+    }
+
+    /* Adds the tokens of partial results and work-done progress to the params of a request, and hears `$/progress` for them. */
+    private progressOf(id: RequestId, params: unknown, options: RequestOptions): { params: unknown; listening?: Disposable } {
+        const { onPartialResult, onWorkDoneProgress } = options;
+        if ((onPartialResult === undefined && onWorkDoneProgress === undefined) || params === null || typeof params !== 'object' || Array.isArray(params)) {
+            return { params };
+        }
+        const partialResultToken = onPartialResult === undefined ? undefined : `adecore-partial-${id}`;
+        const workDoneToken = onWorkDoneProgress === undefined ? undefined : `adecore-work-${id}`;
+        const listening = this.onNotification('$/progress', (value) => {
+            const { token, value: report } = value as { token: unknown; value: unknown };
+            if (token === partialResultToken) {
+                onPartialResult?.(report);
+            } else if (token === workDoneToken) {
+                onWorkDoneProgress?.(report as WorkDoneProgress);
+            }
         });
+        return {
+            params: {
+                ...params,
+                ...(partialResultToken === undefined ? {} : { partialResultToken }),
+                ...(workDoneToken === undefined ? {} : { workDoneToken })
+            },
+            listening
+        };
     }
 
     notify(method: string, params?: unknown): Promise<void> {

package/src/document.ts

@@ -9,6 +9,9 @@ import type {
     CodeAction,
     CodeActionContext,
     CodeLens,
+    Color,
+    ColorInformation,
+    ColorPresentation,
     Command,
     CompletionContext,
     CompletionItem,
@@ -17,13 +20,20 @@ import type {
     DocumentDiagnosticReport,
     DocumentHighlight,
     DocumentItem,
+    DocumentLink,
     DocumentRequestOptions,
     DocumentSymbolResult,
     FoldingRange,
     FormattingOptions,
     Hover,
     InlayHint,
+    InlineCompletionContext,
+    InlineCompletionResult,
+    InlineValue,
+    InlineValueContext,
+    LinkedEditingRanges,
     Location,
+    Moniker,
     NavigationResult,
     Position,
     PrepareRenameResult,
@@ -33,7 +43,9 @@ import type {
     SemanticTokensDelta,
     SignatureHelp,
     SignatureHelpContext,
+    TextDocumentSaveReason,
     TextEdit,
+    TypeHierarchyItem,
     WorkspaceEdit
 } from './protocol.ts';
 
@@ -286,6 +298,72 @@ export class LspDocument {
         return this.feature('textDocument/diagnostic', { previousResultId, identifier }, options);
     }
 
+    documentLinks(options?: DocumentRequestOptions): Promise<DocumentLink[] | null> {
+        return this.feature('textDocument/documentLink', {}, options);
+    }
+
+    resolveDocumentLink(link: DocumentLink, options?: DocumentRequestOptions): Promise<DocumentLink> {
+        return this.resolve('documentLink/resolve', link, options);
+    }
+
+    documentColors(options?: DocumentRequestOptions): Promise<ColorInformation[] | null> {
+        return this.feature('textDocument/documentColor', {}, options);
+    }
+
+    colorPresentations(color: Color, range: Range, options?: DocumentRequestOptions): Promise<ColorPresentation[] | null> {
+        return this.feature('textDocument/colorPresentation', { color, range }, options);
+    }
+
+    linkedEditingRanges(position: Position, options?: DocumentRequestOptions): Promise<LinkedEditingRanges | null> {
+        return this.feature('textDocument/linkedEditingRange', { position }, options);
+    }
+
+    monikers(position: Position, options?: DocumentRequestOptions): Promise<Moniker[] | null> {
+        return this.feature('textDocument/moniker', { position }, options);
+    }
+
+    prepareTypeHierarchy(position: Position, options?: DocumentRequestOptions): Promise<TypeHierarchyItem[] | null> {
+        return this.feature('textDocument/prepareTypeHierarchy', { position }, options);
+    }
+
+    /* Like the calls of a call hierarchy, expansions of the tree run beside each other unless `cancelPrevious` says otherwise. */
+    supertypes(item: TypeHierarchyItem, options?: DocumentRequestOptions): Promise<TypeHierarchyItem[] | null> {
+        return this.perform('typeHierarchy/supertypes', { item }, { cancelPrevious: false, ...options });
+    }
+
+    subtypes(item: TypeHierarchyItem, options?: DocumentRequestOptions): Promise<TypeHierarchyItem[] | null> {
+        return this.perform('typeHierarchy/subtypes', { item }, { cancelPrevious: false, ...options });
+    }
+
+    inlineValues(range: Range, context: InlineValueContext, options?: DocumentRequestOptions): Promise<InlineValue[] | null> {
+        return this.feature('textDocument/inlineValue', { range, context }, options);
+    }
+
+    inlineCompletions(position: Position, context: InlineCompletionContext, options?: DocumentRequestOptions): Promise<InlineCompletionResult> {
+        return this.feature('textDocument/inlineCompletion', { position, context }, options);
+    }
+
+    rangesFormatting(ranges: readonly Range[], formatting: FormattingOptions, options?: DocumentRequestOptions): Promise<TextEdit[] | null> {
+        return this.feature('textDocument/rangesFormatting', { ranges: [...ranges], options: formatting }, options);
+    }
+
+    /* Tells the server a save is coming, when it asked to hear it. */
+    async willSave(reason: TextDocumentSaveReason = 1): Promise<void> {
+        this.assertOpen();
+        if (this.session.syncOptions.willSave) {
+            await this.session.notify('textDocument/willSave', { textDocument: { uri: this.uri }, reason });
+        }
+    }
+
+    /* The edits the server wants in the text before it is saved, or null when it did not ask to be told. Apply them, then save. */
+    async willSaveWaitUntil(reason: TextDocumentSaveReason = 1, options?: DocumentRequestOptions): Promise<TextEdit[] | null> {
+        this.assertOpen();
+        if (!this.session.syncOptions.willSaveWaitUntil) {
+            return null;
+        }
+        return this.perform('textDocument/willSaveWaitUntil', { textDocument: { uri: this.uri }, reason }, 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<T = unknown>(method: string, params: object, options?: DocumentRequestOptions): Promise<T> {
         return method.endsWith('/resolve') ? (this.resolve(method, params, options) as Promise<T>) : this.feature<T>(method, params, options);
@@ -367,7 +445,14 @@ export class LspDocument {
             this.sendFullText?.();
             await this.synced;
             this.assertCurrent(version);
-            const result = await this.session.request<T>(method, params, { signal: controller.signal, timeoutMs: options.timeoutMs });
+            const { onPartialResult, onWorkDoneProgress } = options;
+            const result = await this.session.request<T>(method, params, {
+                signal: controller.signal,
+                timeoutMs: options.timeoutMs,
+                // A part for a text that moved on is as stale as the answer would be.
+                onPartialResult: onPartialResult && ((value) => this.version === version && !this.closed && onPartialResult(value)),
+                onWorkDoneProgress
+            });
             this.assertCurrent(version);
             this.remember(result, version);
 

package/src/index.ts

@@ -18,7 +18,8 @@ export { type CreatedFile, type DeletedFile, type RenamedFile } from './file-ope
 export { watchesFile, type FileChangeType } from './watched-files.ts';
 export { LspSession, type LspSessionOptions, type SessionState } from './session.ts';
 export { TextMirror } from './text-mirror.ts';
-export type { DiagnosticsReport, LanguageDocument, LanguageRequestOptions, LanguageService } from './service.ts';
+export type { DiagnosticsReport, LanguageDocument, LanguageRequestOptions, LanguageService, ServerMessage } from './service.ts';
+export { unservedLanguageService } from './unserved.ts';
 export { connectWebSocket, createStreamTransport, type ByteStream, type WebSocketTransportOptions } from './transport.ts';
 export { fileUriToPath, pathToFileUri } from './uris.ts';
 export { bridgeVueTypeScript, vueServerOrder, type VueServer } from './vue.ts';