@adecore/lsp 0.0.1 → 0.17.0-beta.1

package/src/protocol.ts

@@ -0,0 +1,479 @@
+export interface Disposable {
+    dispose(): void;
+}
+
+export type RequestId = number | string;
+
+export interface RpcRequest {
+    jsonrpc: '2.0';
+    id: RequestId;
+    method: string;
+    params?: unknown;
+}
+
+export interface RpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: unknown;
+}
+
+export interface RpcResponse {
+    jsonrpc: '2.0';
+    id: RequestId | null;
+    result?: unknown;
+    error?: { code: number; message: string; data?: unknown };
+}
+
+export type RpcMessage = RpcRequest | RpcNotification | RpcResponse;
+
+/*
+ * What a connection speaks over. A message arrives parsed and is not validated yet, since the
+ * connection is the one that knows what a valid one looks like.
+ */
+export interface LspTransport {
+    send(message: RpcMessage): void | Promise<void>;
+    onMessage(listener: (message: unknown) => void): Disposable;
+    onClose(listener: (error?: Error) => void): Disposable;
+    close(): void | Promise<void>;
+}
+
+export interface RequestOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+
+export interface DocumentRequestOptions extends RequestOptions {
+    /* A newer request for the same feature of the same document cancels this one. On unless `false`. */
+    cancelPrevious?: boolean;
+}
+
+/* Zero-based, and a character counts UTF-16 code units. */
+export interface Position {
+    line: number;
+    character: number;
+}
+
+export interface Range {
+    start: Position;
+    end: Position;
+}
+
+export interface Location {
+    uri: string;
+    range: Range;
+}
+
+export interface LocationLink {
+    originSelectionRange?: Range;
+    targetUri: string;
+    targetRange: Range;
+    targetSelectionRange: Range;
+}
+
+export type NavigationResult = Location | Location[] | LocationLink[] | null;
+
+export interface TextEdit {
+    range: Range;
+    newText: string;
+    annotationId?: string;
+}
+
+/* One entry of `didChange`: a replacement of a range, or without a range the whole text. */
+export interface ContentChange {
+    range?: Range;
+    text: string;
+}
+
+export interface InsertReplaceEdit {
+    newText: string;
+    insert: Range;
+    replace: Range;
+}
+
+export interface MarkupContent {
+    kind: 'plaintext' | 'markdown';
+    value: string;
+}
+
+export type MarkedString = string | { language: string; value: string };
+
+export interface Command {
+    title: string;
+    command: string;
+    arguments?: unknown[];
+}
+
+export interface Diagnostic {
+    range: Range;
+    message: string;
+    severity?: 1 | 2 | 3 | 4;
+    code?: number | string;
+    codeDescription?: { href: string };
+    source?: string;
+    tags?: number[];
+    relatedInformation?: { location: Location; message: string }[];
+    data?: unknown;
+}
+
+export interface PublishDiagnosticsParams {
+    uri: string;
+    version?: number;
+    diagnostics: Diagnostic[];
+}
+
+export interface CompletionContext {
+    triggerKind: 1 | 2 | 3;
+    triggerCharacter?: string;
+}
+
+export interface CompletionItem {
+    label: string;
+    labelDetails?: { detail?: string; description?: string };
+    kind?: number;
+    tags?: number[];
+    detail?: string;
+    documentation?: string | MarkupContent;
+    deprecated?: boolean;
+    preselect?: boolean;
+    sortText?: string;
+    filterText?: string;
+    insertText?: string;
+    insertTextFormat?: 1 | 2;
+    insertTextMode?: 1 | 2;
+    textEdit?: TextEdit | InsertReplaceEdit;
+    textEditText?: string;
+    additionalTextEdits?: TextEdit[];
+    commitCharacters?: string[];
+    command?: Command;
+    data?: unknown;
+    [extension: string]: unknown;
+}
+
+export interface CompletionList {
+    isIncomplete: boolean;
+    items: CompletionItem[];
+    itemDefaults?: {
+        commitCharacters?: string[];
+        editRange?: Range | { insert: Range; replace: Range };
+        insertTextFormat?: 1 | 2;
+        insertTextMode?: 1 | 2;
+        data?: unknown;
+    };
+}
+
+export type CompletionResult = CompletionItem[] | CompletionList | null;
+
+export interface Hover {
+    contents: MarkupContent | MarkedString | MarkedString[];
+    range?: Range;
+}
+
+export interface DocumentHighlight {
+    range: Range;
+    kind?: 1 | 2 | 3;
+}
+
+export type SymbolKind = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26;
+
+export interface DocumentSymbol {
+    name: string;
+    detail?: string;
+    kind: SymbolKind;
+    tags?: 1[];
+    deprecated?: boolean;
+    range: Range;
+    selectionRange: Range;
+    children?: DocumentSymbol[];
+}
+
+export interface SymbolInformation {
+    name: string;
+    kind: SymbolKind;
+    tags?: 1[];
+    deprecated?: boolean;
+    location: Location;
+    containerName?: string;
+}
+
+export interface WorkspaceSymbol {
+    name: string;
+    kind: SymbolKind;
+    tags?: 1[];
+    containerName?: string;
+    location: Location | { uri: string };
+    data?: unknown;
+}
+
+export type DocumentSymbolResult = DocumentSymbol[] | SymbolInformation[] | null;
+export type WorkspaceSymbolResult = SymbolInformation[] | WorkspaceSymbol[] | null;
+
+export interface ParameterInformation {
+    label: string | [number, number];
+    documentation?: string | MarkupContent;
+}
+
+export interface SignatureInformation {
+    label: string;
+    documentation?: string | MarkupContent;
+    parameters?: ParameterInformation[];
+    activeParameter?: number;
+}
+
+export interface SignatureHelp {
+    signatures: SignatureInformation[];
+    activeSignature?: number;
+    activeParameter?: number;
+}
+
+export interface SignatureHelpContext {
+    triggerKind: 1 | 2 | 3;
+    triggerCharacter?: string;
+    isRetrigger: boolean;
+    activeSignatureHelp?: SignatureHelp;
+}
+
+export type PrepareRenameResult = Range | { range: Range; placeholder: string } | { defaultBehavior: boolean } | null;
+
+export interface TextDocumentEdit {
+    textDocument: { uri: string; version: number | null };
+    edits: TextEdit[];
+}
+
+export interface CreateFile {
+    kind: 'create';
+    uri: string;
+    options?: { overwrite?: boolean; ignoreIfExists?: boolean };
+    annotationId?: string;
+}
+
+export interface RenameFile {
+    kind: 'rename';
+    oldUri: string;
+    newUri: string;
+    options?: { overwrite?: boolean; ignoreIfExists?: boolean };
+    annotationId?: string;
+}
+
+export interface DeleteFile {
+    kind: 'delete';
+    uri: string;
+    options?: { recursive?: boolean; ignoreIfNotExists?: boolean };
+    annotationId?: string;
+}
+
+export interface WorkspaceEdit {
+    changes?: Record<string, TextEdit[]>;
+    documentChanges?: (TextDocumentEdit | CreateFile | RenameFile | DeleteFile)[];
+    changeAnnotations?: Record<string, { label: string; needsConfirmation?: boolean; description?: string }>;
+}
+
+/* One entry of `workspace/willRenameFiles` and `didRenameFiles`. */
+export interface FileRename {
+    oldUri: string;
+    newUri: string;
+}
+
+export interface FileOperationFilter {
+    scheme?: string;
+    pattern: { glob: string; matches?: 'file' | 'folder'; options?: { ignoreCase?: boolean } };
+}
+
+export interface ApplyWorkspaceEditParams {
+    label?: string;
+    edit: WorkspaceEdit;
+}
+
+export interface ApplyWorkspaceEditResult {
+    applied: boolean;
+    failureReason?: string;
+    failedChange?: number;
+}
+
+export interface CodeAction {
+    title: string;
+    kind?: string;
+    diagnostics?: Diagnostic[];
+    isPreferred?: boolean;
+    disabled?: { reason: string };
+    edit?: WorkspaceEdit;
+    command?: Command;
+    data?: unknown;
+    [extension: string]: unknown;
+}
+
+export interface CodeActionContext {
+    diagnostics: Diagnostic[];
+    only?: string[];
+    triggerKind?: 1 | 2;
+}
+
+export interface FormattingOptions {
+    tabSize: number;
+    insertSpaces: boolean;
+    trimTrailingWhitespace?: boolean;
+    insertFinalNewline?: boolean;
+    trimFinalNewlines?: boolean;
+    [key: string]: boolean | number | string | undefined;
+}
+
+export interface SemanticTokens {
+    resultId?: string;
+    data: number[];
+}
+
+export interface SemanticTokensDelta {
+    resultId?: string;
+    edits: { start: number; deleteCount: number; data?: number[] }[];
+}
+
+export interface SemanticTokensLegend {
+    tokenTypes: string[];
+    tokenModifiers: string[];
+}
+
+export interface InlayHintLabelPart {
+    value: string;
+    tooltip?: string | MarkupContent;
+    location?: Location;
+    command?: Command;
+}
+
+export interface InlayHint {
+    position: Position;
+    label: string | InlayHintLabelPart[];
+    kind?: 1 | 2;
+    textEdits?: TextEdit[];
+    tooltip?: string | MarkupContent;
+    paddingLeft?: boolean;
+    paddingRight?: boolean;
+    data?: unknown;
+    [extension: string]: unknown;
+}
+
+export interface FoldingRange {
+    startLine: number;
+    startCharacter?: number;
+    endLine: number;
+    endCharacter?: number;
+    kind?: string;
+    collapsedText?: string;
+}
+
+/* One link of a chain that grows from the smallest range around a position to the whole document. */
+export interface SelectionRange {
+    range: Range;
+    parent?: SelectionRange;
+}
+
+export interface CodeLens {
+    range: Range;
+    command?: Command;
+    data?: unknown;
+}
+
+export type DocumentDiagnosticReport =
+    | { kind: 'full'; resultId?: string; items: Diagnostic[]; relatedDocuments?: Record<string, DocumentDiagnosticReport> }
+    | { kind: 'unchanged'; resultId: string; relatedDocuments?: Record<string, DocumentDiagnosticReport> };
+
+export interface DocumentFilter {
+    language?: string;
+    scheme?: string;
+    pattern?: string;
+}
+
+/* What a server asks to hear about: a glob relative to the project, or one relative to a folder. `kind` is a bit set of create (1), change (2) and delete (4), all three when absent. */
+export interface FileSystemWatcher {
+    globPattern: string | { baseUri: string | WorkspaceFolder; pattern: string };
+    kind?: number;
+}
+
+export interface FileEvent {
+    uri: string;
+    type: 1 | 2 | 3;
+}
+
+export interface Registration {
+    id: string;
+    method: string;
+    registerOptions?: ProviderOptions;
+}
+
+export interface ProviderOptions {
+    documentSelector?: DocumentFilter[] | null;
+    resolveProvider?: boolean;
+    prepareProvider?: boolean;
+    triggerCharacters?: string[];
+    retriggerCharacters?: string[];
+    commands?: string[];
+    watchers?: FileSystemWatcher[];
+    codeActionKinds?: string[];
+    legend?: SemanticTokensLegend;
+    /* Of a file operation registration. */
+    filters?: FileOperationFilter[];
+    range?: boolean | object;
+    full?: boolean | { delta?: boolean };
+    [option: string]: unknown;
+}
+
+export interface TextDocumentSyncOptions {
+    openClose?: boolean;
+    change?: 0 | 1 | 2;
+    willSave?: boolean;
+    willSaveWaitUntil?: boolean;
+    save?: boolean | { includeText?: boolean };
+}
+
+export interface ServerCapabilities {
+    positionEncoding?: string;
+    textDocumentSync?: 0 | 1 | 2 | TextDocumentSyncOptions;
+    completionProvider?: ProviderOptions;
+    hoverProvider?: boolean | ProviderOptions;
+    signatureHelpProvider?: ProviderOptions;
+    definitionProvider?: boolean | ProviderOptions;
+    declarationProvider?: boolean | ProviderOptions;
+    typeDefinitionProvider?: boolean | ProviderOptions;
+    implementationProvider?: boolean | ProviderOptions;
+    referencesProvider?: boolean | ProviderOptions;
+    documentHighlightProvider?: boolean | ProviderOptions;
+    documentSymbolProvider?: boolean | ProviderOptions;
+    workspaceSymbolProvider?: boolean | ProviderOptions;
+    renameProvider?: boolean | ProviderOptions;
+    codeActionProvider?: boolean | ProviderOptions;
+    codeLensProvider?: ProviderOptions;
+    executeCommandProvider?: ProviderOptions;
+    documentFormattingProvider?: boolean | ProviderOptions;
+    documentRangeFormattingProvider?: boolean | ProviderOptions;
+    foldingRangeProvider?: boolean | ProviderOptions;
+    selectionRangeProvider?: boolean | ProviderOptions;
+    semanticTokensProvider?: ProviderOptions & { legend: SemanticTokensLegend };
+    inlayHintProvider?: boolean | ProviderOptions;
+    diagnosticProvider?: ProviderOptions;
+    [capability: string]: unknown;
+}
+
+export interface InitializeResult {
+    capabilities: ServerCapabilities;
+    serverInfo?: { name: string; version?: string };
+}
+
+export interface WorkspaceFolder {
+    uri: string;
+    name: string;
+}
+
+export interface DocumentItem {
+    uri: string;
+    languageId: string;
+    text: string;
+    version?: number;
+}
+
+export interface ConfigurationItem {
+    scopeUri?: string;
+    section?: string;
+}
+
+export interface ProgressParams {
+    token: string | number;
+    value: unknown;
+}

package/src/service.ts

@@ -0,0 +1,109 @@
+import type {
+    CodeAction,
+    CodeActionContext,
+    CodeLens,
+    Command,
+    CompletionContext,
+    CompletionItem,
+    CompletionResult,
+    ContentChange,
+    Diagnostic,
+    Disposable,
+    DocumentHighlight,
+    DocumentSymbolResult,
+    FoldingRange,
+    FormattingOptions,
+    Hover,
+    InlayHint,
+    Location,
+    NavigationResult,
+    Position,
+    PrepareRenameResult,
+    ProviderOptions,
+    Range,
+    SelectionRange,
+    SemanticTokens,
+    SemanticTokensDelta,
+    SignatureHelp,
+    SignatureHelpContext,
+    TextEdit,
+    WorkspaceEdit,
+    WorkspaceSymbolResult
+} from './protocol.ts';
+
+export interface LanguageDocument {
+    /* The `file:` URI the language servers know the file by, which `pathToFileUri` makes of a path. */
+    uri: string;
+    languageId: string;
+    text: string;
+}
+
+export interface LanguageRequestOptions {
+    signal?: AbortSignal;
+    /* Runs beside others of its feature, which a newer request would otherwise take over from; for a feature that asks many questions at once. */
+    parallel?: boolean;
+}
+
+/* What one language server reported for a document. A new report replaces the earlier one of the same `source`. */
+export interface DiagnosticsReport {
+    uri: string;
+    /* Which server, since a document of a pair (Vue and TypeScript) hears from two. */
+    source: string;
+    /* The document version the report is for; absent when the server did not say. */
+    version?: number;
+    diagnostics: Diagnostic[];
+}
+
+/*
+ * What the editor asks of the language side. Everything is in LSP shapes, so a position is a line
+ * and a UTF-16 character and a range is two of them; turning those into offsets in a text is the
+ * caller's job. A request for a text that moved on rejects with `StaleResultError`, one for a
+ * feature nothing supports with an `LspError` of code -32601, and one for a server that is not up
+ * with an `LspError` of code -32002.
+ */
+export interface LanguageService {
+    /* Opens the document, or joins it when another client already has it open; the text given then replaces what is held. */
+    openDocument(document: LanguageDocument): Promise<void>;
+    /* Applies `didChange` entries in order. Every call raises the version by one. */
+    changeDocument(uri: string, changes: readonly ContentChange[]): Promise<void>;
+    closeDocument(uri: string): Promise<void>;
+
+    /* Whether any server of the document answers `method` now, and the options it gave (trigger characters, a legend, resolve support). */
+    supports(method: string, uri: string): boolean;
+    providerOptions(method: string, uri: string): ProviderOptions | undefined;
+    /* What a document may ask changed: a server came up, registered a feature or asked for a refresh. Semantic tokens and hints are asked again. */
+    onProvidersChanged(listener: (uri: string) => void): Disposable;
+    onDiagnostics(listener: (report: DiagnosticsReport) => void): Disposable;
+
+    completion(uri: string, position: Position, context?: CompletionContext, options?: LanguageRequestOptions): Promise<CompletionResult>;
+    resolveCompletion(uri: string, item: CompletionItem, options?: LanguageRequestOptions): Promise<CompletionItem>;
+    hover(uri: string, position: Position, options?: LanguageRequestOptions): Promise<Hover | null>;
+    signatureHelp(uri: string, position: Position, context?: SignatureHelpContext, options?: LanguageRequestOptions): Promise<SignatureHelp | null>;
+    definition(uri: string, position: Position, options?: LanguageRequestOptions): Promise<NavigationResult>;
+    declaration(uri: string, position: Position, options?: LanguageRequestOptions): Promise<NavigationResult>;
+    typeDefinition(uri: string, position: Position, options?: LanguageRequestOptions): Promise<NavigationResult>;
+    implementation(uri: string, position: Position, options?: LanguageRequestOptions): Promise<NavigationResult>;
+    references(uri: string, position: Position, includeDeclaration?: boolean, options?: LanguageRequestOptions): Promise<Location[] | null>;
+    documentHighlights(uri: string, position: Position, options?: LanguageRequestOptions): Promise<DocumentHighlight[] | null>;
+    documentSymbols(uri: string, options?: LanguageRequestOptions): Promise<DocumentSymbolResult>;
+    prepareRename(uri: string, position: Position, options?: LanguageRequestOptions): Promise<PrepareRenameResult>;
+    rename(uri: string, position: Position, newName: string, options?: LanguageRequestOptions): Promise<WorkspaceEdit | null>;
+    codeActions(uri: string, range: Range, context?: CodeActionContext, options?: LanguageRequestOptions): Promise<(CodeAction | Command)[] | null>;
+    resolveCodeAction(uri: string, action: CodeAction, options?: LanguageRequestOptions): Promise<CodeAction>;
+    /* Runs a command of a code action on the server that offered it. The server may ask for edits while it runs, which the host applies. */
+    executeCommand(uri: string, command: Command, options?: LanguageRequestOptions): Promise<unknown>;
+    formatting(uri: string, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
+    rangeFormatting(uri: string, range: Range, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
+    semanticTokens(uri: string, options?: LanguageRequestOptions): Promise<SemanticTokens | null>;
+    semanticTokensDelta(uri: string, previousResultId: string, options?: LanguageRequestOptions): Promise<SemanticTokens | SemanticTokensDelta | null>;
+    semanticTokensRange(uri: string, range: Range, options?: LanguageRequestOptions): Promise<SemanticTokens | null>;
+    inlayHints(uri: string, range: Range, options?: LanguageRequestOptions): Promise<InlayHint[] | null>;
+    resolveInlayHint(uri: string, hint: InlayHint, options?: LanguageRequestOptions): Promise<InlayHint>;
+    /* The symbols of the whole project that answer to a query, asked of the server that serves the document. */
+    workspaceSymbols(uri: string, query: string, options?: LanguageRequestOptions): Promise<WorkspaceSymbolResult>;
+    foldingRanges(uri: string, options?: LanguageRequestOptions): Promise<FoldingRange[] | null>;
+    /* One chain per position, the smallest range first, each in its `parent`. */
+    selectionRanges(uri: string, positions: readonly Position[], options?: LanguageRequestOptions): Promise<SelectionRange[] | null>;
+    codeLenses(uri: string, options?: LanguageRequestOptions): Promise<CodeLens[] | null>;
+    resolveCodeLens(uri: string, lens: CodeLens, options?: LanguageRequestOptions): Promise<CodeLens>;
+}