@adecore/lsp 0.42.0 → 0.44.0

package/src/protocol.ts

@@ -40,6 +40,13 @@ export interface LspTransport {
 export interface RequestOptions {
     signal?: AbortSignal;
     timeoutMs?: number;
+    /*
+     * Asks the server to stream the result: each part arrives here before the answer, which then holds only what
+     * is left, often nothing. The caller joins the parts, since how depends on the method. Needs object params.
+     */
+    onPartialResult?: (value: unknown) => void;
+    /* Asks the server to report the progress of the work under a token of the client. Needs object params. */
+    onWorkDoneProgress?: (progress: WorkDoneProgress) => void;
 }
 
 export interface DocumentRequestOptions extends RequestOptions {
@@ -452,6 +459,12 @@ export interface ProviderOptions {
     filters?: FileOperationFilter[];
     range?: boolean | object;
     full?: boolean | { delta?: boolean };
+    /* Of a formatting registration: the server formats several ranges in one request. */
+    rangesSupport?: boolean;
+    /* Of a diagnostic registration: the server answers `workspace/diagnostic`. */
+    workspaceDiagnostics?: boolean;
+    /* Of a `workspace/textDocumentContent` registration. */
+    schemes?: string[];
     [option: string]: unknown;
 }
 
@@ -489,7 +502,20 @@ export interface ServerCapabilities {
     inlayHintProvider?: boolean | ProviderOptions;
     callHierarchyProvider?: boolean | ProviderOptions;
     documentOnTypeFormattingProvider?: ProviderOptions;
-    diagnosticProvider?: ProviderOptions;
+    diagnosticProvider?: ProviderOptions & { interFileDependencies?: boolean; workspaceDiagnostics?: boolean };
+    documentLinkProvider?: ProviderOptions;
+    colorProvider?: boolean | ProviderOptions;
+    linkedEditingRangeProvider?: boolean | ProviderOptions;
+    monikerProvider?: boolean | ProviderOptions;
+    typeHierarchyProvider?: boolean | ProviderOptions;
+    inlineValueProvider?: boolean | ProviderOptions;
+    inlineCompletionProvider?: boolean | ProviderOptions;
+    notebookDocumentSync?: NotebookDocumentSyncOptions;
+    workspace?: {
+        workspaceFolders?: { supported?: boolean; changeNotifications?: boolean | string };
+        fileOperations?: Partial<Record<FileOperation, { filters: FileOperationFilter[] }>>;
+        textDocumentContent?: { schemes: string[] };
+    };
     [capability: string]: unknown;
 }
 
@@ -519,3 +545,201 @@ export interface ProgressParams {
     token: string | number;
     value: unknown;
 }
+
+export type ProgressToken = string | number;
+
+/* The values of `$/progress` for a work-done token: a begin, any number of reports, and an end. */
+export type WorkDoneProgress =
+    | { kind: 'begin'; title: string; cancellable?: boolean; message?: string; percentage?: number }
+    | { kind: 'report'; cancellable?: boolean; message?: string; percentage?: number }
+    | { kind: 'end'; message?: string };
+
+export type TraceValue = 'off' | 'messages' | 'verbose';
+
+export interface LogTraceParams {
+    message: string;
+    verbose?: string;
+}
+
+/* 1 error, 2 warning, 3 info, 4 log, 5 debug (3.18). */
+export type MessageType = 1 | 2 | 3 | 4 | 5;
+
+export interface ShowMessageParams {
+    type: MessageType;
+    message: string;
+}
+
+export interface MessageActionItem {
+    title: string;
+    [property: string]: unknown;
+}
+
+export interface ShowMessageRequestParams extends ShowMessageParams {
+    actions?: MessageActionItem[];
+}
+
+export interface LogMessageParams {
+    type: MessageType;
+    message: string;
+}
+
+/* A document or a web address a server asks to have shown; `external` opens it outside the editor. */
+export interface ShowDocumentParams {
+    uri: string;
+    external?: boolean;
+    takeFocus?: boolean;
+    selection?: Range;
+}
+
+export interface ShowDocumentResult {
+    success: boolean;
+}
+
+export interface WorkspaceFoldersChangeEvent {
+    added: WorkspaceFolder[];
+    removed: WorkspaceFolder[];
+}
+
+/* 1 when a person saved, 2 after a delay, 3 when the editor lost focus. */
+export type TextDocumentSaveReason = 1 | 2 | 3;
+
+export interface DocumentLink {
+    range: Range;
+    target?: string;
+    tooltip?: string;
+    data?: unknown;
+}
+
+/* Each part from 0 to 1. */
+export interface Color {
+    red: number;
+    green: number;
+    blue: number;
+    alpha: number;
+}
+
+export interface ColorInformation {
+    range: Range;
+    color: Color;
+}
+
+/* One way to write a color: its label is what the picker shows, `textEdit` what replaces the color in the text. */
+export interface ColorPresentation {
+    label: string;
+    textEdit?: TextEdit;
+    additionalTextEdits?: TextEdit[];
+}
+
+/* Ranges that are edited together, such as the names of a start and an end tag; `wordPattern` limits what they may become. */
+export interface LinkedEditingRanges {
+    ranges: Range[];
+    wordPattern?: string;
+}
+
+export type UniquenessLevel = 'document' | 'project' | 'group' | 'scheme' | 'global';
+export type MonikerKind = 'import' | 'export' | 'local';
+
+export interface Moniker {
+    scheme: string;
+    identifier: string;
+    unique: UniquenessLevel;
+    kind?: MonikerKind;
+}
+
+/* A class, interface or other type whose super and sub types are traced; `data` goes back to the server untouched. */
+export interface TypeHierarchyItem {
+    name: string;
+    kind: SymbolKind;
+    tags?: 1[];
+    detail?: string;
+    uri: string;
+    range: Range;
+    selectionRange: Range;
+    data?: unknown;
+}
+
+/* Where a debugger stopped, which a server reads inline values for. */
+export interface InlineValueContext {
+    frameId: number;
+    stoppedLocation: Range;
+}
+
+export type InlineValue =
+    | { range: Range; text: string }
+    | { range: Range; variableName?: string; caseSensitiveLookup: boolean }
+    | { range: Range; expression?: string };
+
+/* 1 when a person asked, 2 while typing. */
+export interface InlineCompletionContext {
+    triggerKind: 1 | 2;
+    selectedCompletionInfo?: { range: Range; text: string };
+}
+
+export interface InlineCompletionItem {
+    insertText: string | { kind: 'snippet'; value: string };
+    filterText?: string;
+    range?: Range;
+    command?: Command;
+}
+
+export type InlineCompletionResult = InlineCompletionItem[] | { items: InlineCompletionItem[] } | null;
+
+export type WorkspaceDocumentDiagnosticReport =
+    | { kind: 'full'; uri: string; version: number | null; resultId?: string; items: Diagnostic[] }
+    | { kind: 'unchanged'; uri: string; version: number | null; resultId: string };
+
+export interface WorkspaceDiagnosticReport {
+    items: WorkspaceDocumentDiagnosticReport[];
+}
+
+/* What the client last heard for a document, so the server can answer `unchanged`. */
+export interface PreviousResultId {
+    uri: string;
+    value: string;
+}
+
+export interface TextDocumentContentResult {
+    text: string;
+}
+
+export interface NotebookCell {
+    /* 1 markup, 2 code. */
+    kind: 1 | 2;
+    document: string;
+    metadata?: Record<string, unknown>;
+    executionSummary?: { executionOrder: number; success?: boolean };
+}
+
+export interface NotebookDocument {
+    uri: string;
+    notebookType: string;
+    version: number;
+    metadata?: Record<string, unknown>;
+    cells: NotebookCell[];
+}
+
+export interface NotebookCellArrayChange {
+    start: number;
+    deleteCount: number;
+    cells?: NotebookCell[];
+}
+
+export interface NotebookDocumentChangeEvent {
+    metadata?: Record<string, unknown>;
+    cells?: {
+        structure?: { array: NotebookCellArrayChange; didOpen?: DocumentItem[]; didClose?: { uri: string }[] };
+        data?: NotebookCell[];
+        textContent?: { document: { uri: string; version: number }; changes: ContentChange[] }[];
+    };
+}
+
+export interface NotebookDocumentFilter {
+    notebookType?: string;
+    scheme?: string;
+    pattern?: string;
+}
+
+export interface NotebookDocumentSyncOptions {
+    notebookSelector: { notebook?: string | NotebookDocumentFilter; cells?: { language: string }[] }[];
+    save?: boolean;
+}

package/src/service.ts

@@ -5,6 +5,9 @@ import type {
     CodeAction,
     CodeActionContext,
     CodeLens,
+    Color,
+    ColorInformation,
+    ColorPresentation,
     Command,
     CompletionContext,
     CompletionItem,
@@ -13,23 +16,37 @@ import type {
     Diagnostic,
     Disposable,
     DocumentHighlight,
+    DocumentLink,
     DocumentSymbolResult,
     FoldingRange,
     FormattingOptions,
     Hover,
     InlayHint,
+    InlineCompletionContext,
+    InlineCompletionResult,
+    InlineValue,
+    InlineValueContext,
+    LinkedEditingRanges,
     Location,
+    MessageType,
+    Moniker,
     NavigationResult,
     Position,
     PrepareRenameResult,
+    PreviousResultId,
     ProviderOptions,
     Range,
     SelectionRange,
     SemanticTokens,
     SemanticTokensDelta,
+    ShowDocumentParams,
+    ShowDocumentResult,
     SignatureHelp,
     SignatureHelpContext,
+    TextDocumentSaveReason,
     TextEdit,
+    TypeHierarchyItem,
+    WorkspaceDiagnosticReport,
     WorkspaceEdit,
     WorkspaceSymbolResult
 } from './protocol.ts';
@@ -128,4 +145,42 @@ export interface LanguageService {
     didDeleteFiles?(files: readonly DeletedFile[]): Promise<void>;
     codeLenses(uri: string, options?: LanguageRequestOptions): Promise<CodeLens[] | null>;
     resolveCodeLens(uri: string, lens: CodeLens, options?: LanguageRequestOptions): Promise<CodeLens>;
+
+    /*
+     * The methods below are optional so a service from before them still fits; `supports(method, uri)` says
+     * whether a server answers each. They follow the LSP methods their names point at.
+     */
+    documentLinks?(uri: string, options?: LanguageRequestOptions): Promise<DocumentLink[] | null>;
+    resolveDocumentLink?(uri: string, link: DocumentLink, options?: LanguageRequestOptions): Promise<DocumentLink>;
+    documentColors?(uri: string, options?: LanguageRequestOptions): Promise<ColorInformation[] | null>;
+    colorPresentations?(uri: string, color: Color, range: Range, options?: LanguageRequestOptions): Promise<ColorPresentation[] | null>;
+    linkedEditingRanges?(uri: string, position: Position, options?: LanguageRequestOptions): Promise<LinkedEditingRanges | null>;
+    monikers?(uri: string, position: Position, options?: LanguageRequestOptions): Promise<Moniker[] | null>;
+    prepareTypeHierarchy?(uri: string, position: Position, options?: LanguageRequestOptions): Promise<TypeHierarchyItem[] | null>;
+    /* `uri` is the document the hierarchy was prepared in, which names the server to ask. */
+    supertypes?(uri: string, item: TypeHierarchyItem, options?: LanguageRequestOptions): Promise<TypeHierarchyItem[] | null>;
+    subtypes?(uri: string, item: TypeHierarchyItem, options?: LanguageRequestOptions): Promise<TypeHierarchyItem[] | null>;
+    inlineValues?(uri: string, range: Range, context: InlineValueContext, options?: LanguageRequestOptions): Promise<InlineValue[] | null>;
+    inlineCompletions?(uri: string, position: Position, context: InlineCompletionContext, options?: LanguageRequestOptions): Promise<InlineCompletionResult>;
+    rangesFormatting?(uri: string, ranges: readonly Range[], formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
+    /* Tells the servers a save is coming; `willSaveWaitUntil` answers the edits they want in the text first, null when none asked. */
+    willSave?(uri: string, reason?: TextDocumentSaveReason): Promise<void>;
+    willSaveWaitUntil?(uri: string, reason?: TextDocumentSaveReason, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
+    /* The diagnostics of every file the server of `uri` knows, the answer for each document a full or an unchanged report. */
+    workspaceDiagnostics?(uri: string, previousResultIds?: readonly PreviousResultId[], options?: LanguageRequestOptions): Promise<WorkspaceDiagnosticReport>;
+    /* The text of a document of a scheme a server owns, such as a decompiled class; null when no server serves the scheme. */
+    textDocumentContent?(uri: string, options?: LanguageRequestOptions): Promise<string | null>;
+    /* What the servers want a person to read or have logged (`window/showMessage`, `window/logMessage`). */
+    onServerMessage?(listener: (message: ServerMessage) => void): Disposable;
+    /* Answers `window/showDocument`: the handler shows the document or web address and says whether it did. One handler at a time. */
+    onShowDocument?(handler: (params: ShowDocumentParams) => Promise<ShowDocumentResult>): Disposable;
+}
+
+/* A message of a server: one to show a person, or a line for its log. */
+export interface ServerMessage {
+    readonly kind: 'show' | 'log';
+    readonly type: MessageType;
+    readonly message: string;
+    /* The server that sent it, as the service names servers. */
+    readonly source?: string;
 }