@adecore/lsp 0.0.1 → 0.17.0-beta.1

package/dist/protocol.d.ts

@@ -0,0 +1,470 @@
+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;
+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 {
+    cancelPrevious?: boolean;
+}
+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;
+}
+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;
+    }>;
+}
+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;
+}
+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;
+}
+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;
+    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/dist/protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/service.d.ts

@@ -0,0 +1,53 @@
+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 {
+    uri: string;
+    languageId: string;
+    text: string;
+}
+export interface LanguageRequestOptions {
+    signal?: AbortSignal;
+    parallel?: boolean;
+}
+export interface DiagnosticsReport {
+    uri: string;
+    source: string;
+    version?: number;
+    diagnostics: Diagnostic[];
+}
+export interface LanguageService {
+    openDocument(document: LanguageDocument): Promise<void>;
+    changeDocument(uri: string, changes: readonly ContentChange[]): Promise<void>;
+    closeDocument(uri: string): Promise<void>;
+    supports(method: string, uri: string): boolean;
+    providerOptions(method: string, uri: string): ProviderOptions | undefined;
+    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>;
+    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>;
+    workspaceSymbols(uri: string, query: string, options?: LanguageRequestOptions): Promise<WorkspaceSymbolResult>;
+    foldingRanges(uri: string, options?: LanguageRequestOptions): Promise<FoldingRange[] | null>;
+    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>;
+}

package/dist/service.js

@@ -0,0 +1 @@
+export {};

package/dist/session.d.ts

@@ -0,0 +1,78 @@
+import { JsonRpcConnection, type RequestHandler } from './connection.ts';
+import { LspDocument } from './document.ts';
+import { type RenamedFile } from './file-operations.ts';
+import type { ApplyWorkspaceEditParams, ApplyWorkspaceEditResult, Command, ConfigurationItem, Disposable, DocumentItem, FileEvent, FileOperationFilter, FileSystemWatcher, InitializeResult, LspTransport, ProgressParams, ProviderOptions, PublishDiagnosticsParams, RequestOptions, ServerCapabilities, TextDocumentSyncOptions, WorkspaceEdit, WorkspaceFolder, WorkspaceSymbol, WorkspaceSymbolResult } from './protocol.ts';
+export type SessionState = 'new' | 'initializing' | 'ready' | 'closing' | 'closed';
+export interface LspSessionOptions {
+    rootUri?: string | null;
+    workspaceFolders?: WorkspaceFolder[];
+    initializationOptions?: unknown;
+    configuration?: Record<string, unknown>;
+    clientInfo?: {
+        name: string;
+        version?: string;
+    };
+    timeoutMs?: number;
+    snippetSupport?: boolean;
+    onConfiguration?: (item: ConfigurationItem) => unknown | Promise<unknown>;
+    onApplyEdit?: (params: ApplyWorkspaceEditParams) => ApplyWorkspaceEditResult | Promise<ApplyWorkspaceEditResult>;
+    onShowMessage?: (params: {
+        type: number;
+        message: string;
+        actions?: {
+            title: string;
+        }[];
+    }) => {
+        title: string;
+    } | null | Promise<{
+        title: string;
+    } | null>;
+}
+export declare class LspSession {
+    readonly connection: JsonRpcConnection;
+    readonly options: LspSessionOptions;
+    serverInfo?: InitializeResult['serverInfo'];
+    private phase;
+    private initialized?;
+    private shutdownPromise?;
+    private serverCapabilities;
+    private readonly registrations;
+    private readonly documents;
+    private readonly diagnosticListeners;
+    private readonly capabilityListeners;
+    private configuration;
+    constructor(transport: LspTransport, options?: LspSessionOptions);
+    get state(): SessionState;
+    get capabilities(): Readonly<ServerCapabilities>;
+    get workspaceFolders(): WorkspaceFolder[] | null;
+    get syncOptions(): TextDocumentSyncOptions;
+    initialize(): Promise<InitializeResult>;
+    openDocument(item: DocumentItem): LspDocument;
+    getDocument(uri: string): LspDocument | undefined;
+    providerOptions(method: string, document?: Pick<DocumentItem, 'uri' | 'languageId'>): ProviderOptions | undefined;
+    supports(method: string, document?: Pick<DocumentItem, 'uri' | 'languageId'>): boolean;
+    request<T = unknown>(method: string, params?: unknown, options?: RequestOptions): Promise<T>;
+    notify(method: string, params?: unknown): Promise<void>;
+    executeCommand<T = unknown>(command: Command | string, args?: unknown[], options?: RequestOptions): Promise<T>;
+    workspaceSymbols(query: string, options?: RequestOptions): Promise<WorkspaceSymbolResult>;
+    resolveWorkspaceSymbol(symbol: WorkspaceSymbol, options?: RequestOptions): Promise<WorkspaceSymbol>;
+    setConfiguration(settings: Record<string, unknown>): Promise<void>;
+    onRequest(method: string, handler: RequestHandler): Disposable;
+    onNotification(method: string, listener: (params: unknown) => void | Promise<void>): Disposable;
+    onError(listener: (error: Error) => void): Disposable;
+    onProgress(listener: (params: ProgressParams) => void): Disposable;
+    onDiagnostics(listener: (params: PublishDiagnosticsParams) => void): Disposable;
+    watchedFiles(): FileSystemWatcher[];
+    didChangeWatchedFiles(changes: readonly FileEvent[]): Promise<void>;
+    fileOperationFilters(operation: 'willRename' | 'didRename'): FileOperationFilter[];
+    willRenameFiles(files: readonly RenamedFile[], options?: RequestOptions): Promise<WorkspaceEdit | null>;
+    didRenameFiles(files: readonly RenamedFile[]): Promise<void>;
+    onCapabilitiesChanged(listener: () => void): Disposable;
+    shutdown(): Promise<void>;
+    forgetDocument(document: LspDocument): void;
+    private assertReady;
+    private stop;
+    private readConfiguration;
+    private emitDiagnostics;
+    private emitCapabilities;
+}