@difizen/libro-language-client 0.1.18

package/src/common/documentHighlight.ts

@@ -0,0 +1,140 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type {
+  ClientCapabilities,
+  DocumentHighlightOptions,
+  DocumentHighlightRegistrationOptions,
+  DocumentSelector,
+  ServerCapabilities,
+  TextDocumentRegistrationOptions,
+} from '@difizen/vscode-languageserver-protocol';
+import { DocumentHighlightRequest } from '@difizen/vscode-languageserver-protocol';
+import type {
+  TextDocument,
+  Disposable,
+  Position as VPosition,
+  CancellationToken,
+  ProviderResult,
+  DocumentHighlightProvider,
+  DocumentHighlight as VDocumentHighlight,
+} from 'vscode';
+
+import type { FeatureClient } from './features.js';
+import { ensure, TextDocumentLanguageFeature } from './features.js';
+import * as UUID from './utils/uuid.js';
+import { languages as Languages } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export interface ProvideDocumentHighlightsSignature {
+  (
+    this: void,
+    document: TextDocument,
+    position: VPosition,
+    token: CancellationToken,
+  ): ProviderResult<VDocumentHighlight[]>;
+}
+
+export interface DocumentHighlightMiddleware {
+  provideDocumentHighlights?: (
+    this: void,
+    document: TextDocument,
+    position: VPosition,
+    token: CancellationToken,
+    next: ProvideDocumentHighlightsSignature,
+  ) => ProviderResult<VDocumentHighlight[]>;
+}
+
+export class DocumentHighlightFeature extends TextDocumentLanguageFeature<
+  boolean | DocumentHighlightOptions,
+  DocumentHighlightRegistrationOptions,
+  DocumentHighlightProvider,
+  DocumentHighlightMiddleware
+> {
+  constructor(client: FeatureClient<DocumentHighlightMiddleware>) {
+    super(client, DocumentHighlightRequest.type);
+  }
+
+  public fillClientCapabilities(capabilities: ClientCapabilities): void {
+    ensure(
+      ensure(capabilities, 'textDocument')!,
+      'documentHighlight',
+    )!.dynamicRegistration = true;
+  }
+
+  public initialize(
+    capabilities: ServerCapabilities,
+    documentSelector: DocumentSelector,
+  ): void {
+    const options = this.getRegistrationOptions(
+      documentSelector,
+      capabilities.documentHighlightProvider,
+    );
+    if (!options) {
+      return;
+    }
+    this.register({ id: UUID.generateUuid(), registerOptions: options });
+  }
+
+  protected registerLanguageProvider(
+    options: TextDocumentRegistrationOptions,
+  ): [Disposable, DocumentHighlightProvider] {
+    const selector = options.documentSelector!;
+    const provider: DocumentHighlightProvider = {
+      provideDocumentHighlights: (document, position, token) => {
+        const client = this._client;
+        const _provideDocumentHighlights: ProvideDocumentHighlightsSignature = (
+          document,
+          position,
+          token,
+        ) => {
+          return client
+            .sendRequest(
+              DocumentHighlightRequest.type,
+              client.code2ProtocolConverter.asTextDocumentPositionParams(
+                document,
+                position,
+              ),
+              token,
+            )
+            .then(
+              (result) => {
+                if (token.isCancellationRequested) {
+                  return null;
+                }
+                return client.protocol2CodeConverter.asDocumentHighlights(
+                  result,
+                  token,
+                );
+              },
+              (error) => {
+                return client.handleFailedRequest(
+                  DocumentHighlightRequest.type,
+                  token,
+                  error,
+                  null,
+                );
+              },
+            );
+        };
+        const middleware = client.middleware;
+        return middleware.provideDocumentHighlights
+          ? middleware.provideDocumentHighlights(
+              document,
+              position,
+              token,
+              _provideDocumentHighlights,
+            )
+          : _provideDocumentHighlights(document, position, token);
+      },
+    };
+    return [
+      Languages.registerDocumentHighlightProvider(
+        this._client.protocol2CodeConverter.asDocumentSelector(selector),
+        provider,
+      ),
+      provider,
+    ];
+  }
+}

package/src/common/documentLink.ts

@@ -0,0 +1,180 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type {
+  ClientCapabilities,
+  DocumentLinkOptions,
+  DocumentLinkRegistrationOptions,
+  DocumentSelector,
+  ResponseError,
+  ServerCapabilities,
+} from '@difizen/vscode-languageserver-protocol';
+import {
+  DocumentLinkRequest,
+  DocumentLinkResolveRequest,
+} from '@difizen/vscode-languageserver-protocol';
+import type {
+  TextDocument,
+  Disposable,
+  CancellationToken,
+  ProviderResult,
+  DocumentLinkProvider,
+  DocumentLink as VDocumentLink,
+} from 'vscode';
+
+import type { FeatureClient } from './features.js';
+import { ensure, TextDocumentLanguageFeature } from './features.js';
+import * as UUID from './utils/uuid.js';
+import { languages as Languages } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export interface ProvideDocumentLinksSignature {
+  (
+    this: void,
+    document: TextDocument,
+    token: CancellationToken,
+  ): ProviderResult<VDocumentLink[]>;
+}
+
+export interface ResolveDocumentLinkSignature {
+  (
+    this: void,
+    link: VDocumentLink,
+    token: CancellationToken,
+  ): ProviderResult<VDocumentLink>;
+}
+
+export interface DocumentLinkMiddleware {
+  provideDocumentLinks?: (
+    this: void,
+    document: TextDocument,
+    token: CancellationToken,
+    next: ProvideDocumentLinksSignature,
+  ) => ProviderResult<VDocumentLink[]>;
+  resolveDocumentLink?: (
+    this: void,
+    link: VDocumentLink,
+    token: CancellationToken,
+    next: ResolveDocumentLinkSignature,
+  ) => ProviderResult<VDocumentLink>;
+}
+
+export class DocumentLinkFeature extends TextDocumentLanguageFeature<
+  DocumentLinkOptions,
+  DocumentLinkRegistrationOptions,
+  DocumentLinkProvider,
+  DocumentLinkMiddleware
+> {
+  constructor(client: FeatureClient<DocumentLinkMiddleware>) {
+    super(client, DocumentLinkRequest.type);
+  }
+
+  public fillClientCapabilities(capabilities: ClientCapabilities): void {
+    const documentLinkCapabilities = ensure(
+      ensure(capabilities, 'textDocument')!,
+      'documentLink',
+    )!;
+    documentLinkCapabilities.dynamicRegistration = true;
+    documentLinkCapabilities.tooltipSupport = true;
+  }
+
+  public initialize(
+    capabilities: ServerCapabilities,
+    documentSelector: DocumentSelector,
+  ): void {
+    const options = this.getRegistrationOptions(
+      documentSelector,
+      capabilities.documentLinkProvider,
+    );
+    if (!options) {
+      return;
+    }
+    this.register({ id: UUID.generateUuid(), registerOptions: options });
+  }
+
+  protected registerLanguageProvider(
+    options: DocumentLinkRegistrationOptions,
+  ): [Disposable, DocumentLinkProvider] {
+    const selector = options.documentSelector!;
+    const provider: DocumentLinkProvider = {
+      provideDocumentLinks: (
+        document: TextDocument,
+        token: CancellationToken,
+      ): ProviderResult<VDocumentLink[]> => {
+        const client = this._client;
+        const provideDocumentLinks: ProvideDocumentLinksSignature = (
+          document,
+          token,
+        ) => {
+          return client
+            .sendRequest(
+              DocumentLinkRequest.type,
+              client.code2ProtocolConverter.asDocumentLinkParams(document),
+              token,
+            )
+            .then(
+              (result) => {
+                if (token.isCancellationRequested) {
+                  return null;
+                }
+                return client.protocol2CodeConverter.asDocumentLinks(result, token);
+              },
+              (error: ResponseError<void>) => {
+                return client.handleFailedRequest(
+                  DocumentLinkRequest.type,
+                  token,
+                  error,
+                  null,
+                );
+              },
+            );
+        };
+        const middleware = client.middleware;
+        return middleware.provideDocumentLinks
+          ? middleware.provideDocumentLinks(document, token, provideDocumentLinks)
+          : provideDocumentLinks(document, token);
+      },
+      resolveDocumentLink: options.resolveProvider
+        ? (link, token) => {
+            const client = this._client;
+            const resolveDocumentLink: ResolveDocumentLinkSignature = (link, token) => {
+              return client
+                .sendRequest(
+                  DocumentLinkResolveRequest.type,
+                  client.code2ProtocolConverter.asDocumentLink(link),
+                  token,
+                )
+                .then(
+                  (result) => {
+                    if (token.isCancellationRequested) {
+                      return link;
+                    }
+                    return client.protocol2CodeConverter.asDocumentLink(result);
+                  },
+                  (error: ResponseError<void>) => {
+                    return client.handleFailedRequest(
+                      DocumentLinkResolveRequest.type,
+                      token,
+                      error,
+                      link,
+                    );
+                  },
+                );
+            };
+            const middleware = client.middleware;
+            return middleware.resolveDocumentLink
+              ? middleware.resolveDocumentLink(link, token, resolveDocumentLink)
+              : resolveDocumentLink(link, token);
+          }
+        : undefined,
+    };
+    return [
+      Languages.registerDocumentLinkProvider(
+        this._client.protocol2CodeConverter.asDocumentSelector(selector),
+        provider,
+      ),
+      provider,
+    ];
+  }
+}

package/src/common/documentSymbol.ts

@@ -0,0 +1,186 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type {
+  ClientCapabilities,
+  DocumentSelector,
+  DocumentSymbolOptions,
+  DocumentSymbolRegistrationOptions,
+  ServerCapabilities,
+  SymbolInformation,
+} from '@difizen/vscode-languageserver-protocol';
+import {
+  DocumentSymbol,
+  DocumentSymbolRequest,
+  SymbolKind,
+  SymbolTag,
+} from '@difizen/vscode-languageserver-protocol';
+import type {
+  TextDocument,
+  Disposable,
+  CancellationToken,
+  ProviderResult,
+  DocumentSymbolProvider,
+  DocumentSymbolProviderMetadata,
+  SymbolInformation as VSymbolInformation,
+  DocumentSymbol as VDocumentSymbol,
+} from 'vscode';
+
+import type { FeatureClient } from './features.js';
+import { ensure, TextDocumentLanguageFeature } from './features.js';
+import * as UUID from './utils/uuid.js';
+import { languages as Languages } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export const SupportedSymbolKinds: SymbolKind[] = [
+  SymbolKind.File,
+  SymbolKind.Module,
+  SymbolKind.Namespace,
+  SymbolKind.Package,
+  SymbolKind.Class,
+  SymbolKind.Method,
+  SymbolKind.Property,
+  SymbolKind.Field,
+  SymbolKind.Constructor,
+  SymbolKind.Enum,
+  SymbolKind.Interface,
+  SymbolKind.Function,
+  SymbolKind.Variable,
+  SymbolKind.Constant,
+  SymbolKind.String,
+  SymbolKind.Number,
+  SymbolKind.Boolean,
+  SymbolKind.Array,
+  SymbolKind.Object,
+  SymbolKind.Key,
+  SymbolKind.Null,
+  SymbolKind.EnumMember,
+  SymbolKind.Struct,
+  SymbolKind.Event,
+  SymbolKind.Operator,
+  SymbolKind.TypeParameter,
+];
+
+export const SupportedSymbolTags: SymbolTag[] = [SymbolTag.Deprecated];
+
+export interface ProvideDocumentSymbolsSignature {
+  (
+    this: void,
+    document: TextDocument,
+    token: CancellationToken,
+  ): ProviderResult<VSymbolInformation[] | VDocumentSymbol[]>;
+}
+
+export interface DocumentSymbolMiddleware {
+  provideDocumentSymbols?: (
+    this: void,
+    document: TextDocument,
+    token: CancellationToken,
+    next: ProvideDocumentSymbolsSignature,
+  ) => ProviderResult<VSymbolInformation[] | VDocumentSymbol[]>;
+}
+
+export class DocumentSymbolFeature extends TextDocumentLanguageFeature<
+  boolean | DocumentSymbolOptions,
+  DocumentSymbolRegistrationOptions,
+  DocumentSymbolProvider,
+  DocumentSymbolMiddleware
+> {
+  constructor(client: FeatureClient<DocumentSymbolMiddleware>) {
+    super(client, DocumentSymbolRequest.type);
+  }
+
+  public fillClientCapabilities(capabilities: ClientCapabilities): void {
+    const symbolCapabilities = ensure(
+      ensure(capabilities, 'textDocument')!,
+      'documentSymbol',
+    )!;
+    symbolCapabilities.dynamicRegistration = true;
+    symbolCapabilities.symbolKind = {
+      valueSet: SupportedSymbolKinds,
+    };
+    symbolCapabilities.hierarchicalDocumentSymbolSupport = true;
+    symbolCapabilities.tagSupport = {
+      valueSet: SupportedSymbolTags,
+    };
+    symbolCapabilities.labelSupport = true;
+  }
+
+  public initialize(
+    capabilities: ServerCapabilities,
+    documentSelector: DocumentSelector,
+  ): void {
+    const options = this.getRegistrationOptions(
+      documentSelector,
+      capabilities.documentSymbolProvider,
+    );
+    if (!options) {
+      return;
+    }
+    this.register({ id: UUID.generateUuid(), registerOptions: options });
+  }
+
+  protected registerLanguageProvider(
+    options: DocumentSymbolRegistrationOptions,
+  ): [Disposable, DocumentSymbolProvider] {
+    const selector = options.documentSelector!;
+    const provider: DocumentSymbolProvider = {
+      provideDocumentSymbols: (document, token) => {
+        const client = this._client;
+        const _provideDocumentSymbols: ProvideDocumentSymbolsSignature = async (
+          document,
+          token,
+        ) => {
+          try {
+            const data = await client.sendRequest(
+              DocumentSymbolRequest.type,
+              client.code2ProtocolConverter.asDocumentSymbolParams(document),
+              token,
+            );
+            if (token.isCancellationRequested || data === undefined || data === null) {
+              return null;
+            }
+            if (data.length === 0) {
+              return [];
+            } else {
+              const first = data[0];
+              if (DocumentSymbol.is(first)) {
+                return await client.protocol2CodeConverter.asDocumentSymbols(
+                  data as DocumentSymbol[],
+                  token,
+                );
+              } else {
+                return await client.protocol2CodeConverter.asSymbolInformations(
+                  data as SymbolInformation[],
+                  token,
+                );
+              }
+            }
+          } catch (error) {
+            return client.handleFailedRequest(
+              DocumentSymbolRequest.type,
+              token,
+              error,
+              null,
+            );
+          }
+        };
+        const middleware = client.middleware;
+        return middleware.provideDocumentSymbols
+          ? middleware.provideDocumentSymbols(document, token, _provideDocumentSymbols)
+          : _provideDocumentSymbols(document, token);
+      },
+    };
+    const metaData: DocumentSymbolProviderMetadata | undefined =
+      options.label !== undefined ? { label: options.label } : undefined;
+    return [
+      Languages.registerDocumentSymbolProvider(
+        this._client.protocol2CodeConverter.asDocumentSelector(selector),
+        provider,
+        metaData,
+      ),
+      provider,
+    ];
+  }
+}

package/src/common/executeCommand.ts

@@ -0,0 +1,129 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type { Disposable, ProviderResult } from 'vscode';
+import type {
+  ClientCapabilities,
+  ServerCapabilities,
+  ExecuteCommandRegistrationOptions,
+  RegistrationType,
+  ExecuteCommandParams,
+} from '@difizen/vscode-languageserver-protocol';
+import { ExecuteCommandRequest } from '@difizen/vscode-languageserver-protocol';
+
+import type {
+  FeatureClient,
+  DynamicFeature,
+  FeatureState,
+  RegistrationData,
+} from './features.js';
+import { ensure } from './features.js';
+import * as UUID from './utils/uuid.js';
+import { commands as Commands } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export interface ExecuteCommandSignature {
+  (this: void, command: string, args: any[]): ProviderResult<any>;
+}
+
+export interface ExecuteCommandMiddleware {
+  executeCommand?: (
+    this: void,
+    command: string,
+    args: any[],
+    next: ExecuteCommandSignature,
+  ) => ProviderResult<any>;
+}
+
+export class ExecuteCommandFeature
+  implements DynamicFeature<ExecuteCommandRegistrationOptions>
+{
+  private readonly _client: FeatureClient<ExecuteCommandMiddleware>;
+  private readonly _commands: Map<string, Disposable[]>;
+
+  constructor(client: FeatureClient<ExecuteCommandMiddleware>) {
+    this._client = client;
+    this._commands = new Map();
+  }
+
+  public getState(): FeatureState {
+    return {
+      kind: 'workspace',
+      id: this.registrationType.method,
+      registrations: this._commands.size > 0,
+    };
+  }
+
+  public get registrationType(): RegistrationType<ExecuteCommandRegistrationOptions> {
+    return ExecuteCommandRequest.type;
+  }
+
+  public fillClientCapabilities(capabilities: ClientCapabilities): void {
+    ensure(ensure(capabilities, 'workspace')!, 'executeCommand')!.dynamicRegistration =
+      true;
+  }
+
+  public initialize(capabilities: ServerCapabilities): void {
+    if (!capabilities.executeCommandProvider) {
+      return;
+    }
+    this.register({
+      id: UUID.generateUuid(),
+      registerOptions: Object.assign({}, capabilities.executeCommandProvider),
+    });
+  }
+
+  public register(data: RegistrationData<ExecuteCommandRegistrationOptions>): void {
+    const client = this._client;
+    const middleware = client.middleware;
+    const executeCommand: ExecuteCommandSignature = (
+      command: string,
+      args: any[],
+    ): any => {
+      const params: ExecuteCommandParams = {
+        command,
+        arguments: args,
+      };
+      return client
+        .sendRequest(ExecuteCommandRequest.type, params)
+        .then(undefined, (error) => {
+          return client.handleFailedRequest(
+            ExecuteCommandRequest.type,
+            undefined,
+            error,
+            undefined,
+          );
+        });
+    };
+
+    if (data.registerOptions.commands) {
+      const disposables: Disposable[] = [];
+      for (const command of data.registerOptions.commands) {
+        disposables.push(
+          Commands.registerCommand(command, (...args: any[]) => {
+            return middleware.executeCommand
+              ? middleware.executeCommand(command, args, executeCommand)
+              : executeCommand(command, args);
+          }),
+        );
+      }
+      this._commands.set(data.id, disposables);
+    }
+  }
+
+  public unregister(id: string): void {
+    const disposables = this._commands.get(id);
+    if (disposables) {
+      this._commands.delete(id);
+      disposables.forEach((disposable) => disposable.dispose());
+    }
+  }
+
+  public clear(): void {
+    this._commands.forEach((value) => {
+      value.forEach((disposable) => disposable.dispose());
+    });
+    this._commands.clear();
+  }
+}