@difizen/libro-language-client 0.1.18

package/src/common/typeDefinition.ts

@@ -0,0 +1,146 @@
+/* --------------------------------------------------------------------------------------------
+ * 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,
+  CancellationToken,
+  ServerCapabilities,
+  DocumentSelector,
+  TypeDefinitionRegistrationOptions,
+  TypeDefinitionOptions,
+} from '@difizen/vscode-languageserver-protocol';
+import { TypeDefinitionRequest } from '@difizen/vscode-languageserver-protocol';
+import type {
+  Disposable,
+  TextDocument,
+  ProviderResult,
+  Position as VPosition,
+  Definition as VDefinition,
+  DefinitionLink as VDefinitionLink,
+  TypeDefinitionProvider,
+} from 'vscode';
+
+import type { FeatureClient } from './features.js';
+import { TextDocumentLanguageFeature, ensure } from './features.js';
+import { languages as Languages } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export interface ProvideTypeDefinitionSignature {
+  (
+    this: void,
+    document: TextDocument,
+    position: VPosition,
+    token: CancellationToken,
+  ): ProviderResult<VDefinition | VDefinitionLink[]>;
+}
+
+export interface TypeDefinitionMiddleware {
+  provideTypeDefinition?: (
+    this: void,
+    document: TextDocument,
+    position: VPosition,
+    token: CancellationToken,
+    next: ProvideTypeDefinitionSignature,
+  ) => ProviderResult<VDefinition | VDefinitionLink[]>;
+}
+
+export class TypeDefinitionFeature extends TextDocumentLanguageFeature<
+  boolean | TypeDefinitionOptions,
+  TypeDefinitionRegistrationOptions,
+  TypeDefinitionProvider,
+  TypeDefinitionMiddleware
+> {
+  constructor(client: FeatureClient<TypeDefinitionMiddleware>) {
+    super(client, TypeDefinitionRequest.type);
+  }
+
+  public fillClientCapabilities(capabilities: ClientCapabilities): void {
+    ensure(
+      ensure(capabilities, 'textDocument')!,
+      'typeDefinition',
+    )!.dynamicRegistration = true;
+    const typeDefinitionSupport = ensure(
+      ensure(capabilities, 'textDocument')!,
+      'typeDefinition',
+    )!;
+    typeDefinitionSupport.dynamicRegistration = true;
+    typeDefinitionSupport.linkSupport = true;
+  }
+
+  public initialize(
+    capabilities: ServerCapabilities,
+    documentSelector: DocumentSelector,
+  ): void {
+    const [id, options] = this.getRegistration(
+      documentSelector,
+      capabilities.typeDefinitionProvider,
+    );
+    if (!id || !options) {
+      return;
+    }
+    this.register({ id: id, registerOptions: options });
+  }
+
+  protected registerLanguageProvider(
+    options: TypeDefinitionRegistrationOptions,
+  ): [Disposable, TypeDefinitionProvider] {
+    const selector = options.documentSelector!;
+    const provider: TypeDefinitionProvider = {
+      provideTypeDefinition: (document, position, token) => {
+        const client = this._client;
+        const provideTypeDefinition: ProvideTypeDefinitionSignature = (
+          document,
+          position,
+          token,
+        ) => {
+          return client
+            .sendRequest(
+              TypeDefinitionRequest.type,
+              client.code2ProtocolConverter.asTextDocumentPositionParams(
+                document,
+                position,
+              ),
+              token,
+            )
+            .then(
+              (result) => {
+                if (token.isCancellationRequested) {
+                  return null;
+                }
+                return client.protocol2CodeConverter.asDefinitionResult(result, token);
+              },
+              (error) => {
+                return client.handleFailedRequest(
+                  TypeDefinitionRequest.type,
+                  token,
+                  error,
+                  null,
+                );
+              },
+            );
+        };
+        const middleware = client.middleware;
+        return middleware.provideTypeDefinition
+          ? middleware.provideTypeDefinition(
+              document,
+              position,
+              token,
+              provideTypeDefinition,
+            )
+          : provideTypeDefinition(document, position, token);
+      },
+    };
+    return [this.registerProvider(selector, provider), provider];
+  }
+
+  private registerProvider(
+    selector: DocumentSelector,
+    provider: TypeDefinitionProvider,
+  ): Disposable {
+    return Languages.registerTypeDefinitionProvider(
+      this._client.protocol2CodeConverter.asDocumentSelector(selector),
+      provider,
+    );
+  }
+}

package/src/common/typeHierarchy.ts

@@ -0,0 +1,248 @@
+/* --------------------------------------------------------------------------------------------
+ * 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,
+  ServerCapabilities,
+  TypeHierarchyRegistrationOptions,
+  TypeHierarchySupertypesParams,
+  TypeHierarchySubtypesParams,
+  TypeHierarchyOptions,
+} from '@difizen/vscode-languageserver-protocol';
+import {
+  TypeHierarchyPrepareRequest,
+  TypeHierarchySupertypesRequest,
+  TypeHierarchySubtypesRequest,
+} from '@difizen/vscode-languageserver-protocol';
+import type {
+  Disposable,
+  TextDocument,
+  ProviderResult,
+  Position as VPosition,
+  CancellationToken,
+  TypeHierarchyProvider as VTypeHierarchyProvider,
+  TypeHierarchyItem as VTypeHierarchyItem,
+} from 'vscode';
+
+import type { FeatureClient } from './features.js';
+import { TextDocumentLanguageFeature, ensure } from './features.js';
+import { languages as Languages } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export type PrepareTypeHierarchySignature = (
+  this: void,
+  document: TextDocument,
+  position: VPosition,
+  token: CancellationToken,
+) => ProviderResult<VTypeHierarchyItem[]>;
+
+export type TypeHierarchySupertypesSignature = (
+  this: void,
+  item: VTypeHierarchyItem,
+  token: CancellationToken,
+) => ProviderResult<VTypeHierarchyItem[]>;
+
+export type TypeHierarchySubtypesSignature = (
+  this: void,
+  item: VTypeHierarchyItem,
+  token: CancellationToken,
+) => ProviderResult<VTypeHierarchyItem[]>;
+
+/**
+ * Type hierarchy middleware
+ *
+ * @since 3.17.0
+ */
+export type TypeHierarchyMiddleware = {
+  prepareTypeHierarchy?: (
+    this: void,
+    document: TextDocument,
+    positions: VPosition,
+    token: CancellationToken,
+    next: PrepareTypeHierarchySignature,
+  ) => ProviderResult<VTypeHierarchyItem[]>;
+  provideTypeHierarchySupertypes?: (
+    this: void,
+    item: VTypeHierarchyItem,
+    token: CancellationToken,
+    next: TypeHierarchySupertypesSignature,
+  ) => ProviderResult<VTypeHierarchyItem[]>;
+  provideTypeHierarchySubtypes?: (
+    this: void,
+    item: VTypeHierarchyItem,
+    token: CancellationToken,
+    next: TypeHierarchySubtypesSignature,
+  ) => ProviderResult<VTypeHierarchyItem[]>;
+};
+
+class TypeHierarchyProvider implements VTypeHierarchyProvider {
+  private middleware: TypeHierarchyMiddleware;
+
+  constructor(private client: FeatureClient<TypeHierarchyMiddleware>) {
+    this.middleware = client.middleware;
+  }
+
+  public prepareTypeHierarchy(
+    document: TextDocument,
+    position: VPosition,
+    token: CancellationToken,
+  ): ProviderResult<VTypeHierarchyItem[]> {
+    const client = this.client;
+    const middleware = this.middleware;
+    const prepareTypeHierarchy: PrepareTypeHierarchySignature = (
+      document,
+      position,
+      token,
+    ) => {
+      const params = client.code2ProtocolConverter.asTextDocumentPositionParams(
+        document,
+        position,
+      );
+      return client.sendRequest(TypeHierarchyPrepareRequest.type, params, token).then(
+        (result) => {
+          if (token.isCancellationRequested) {
+            return null;
+          }
+          return client.protocol2CodeConverter.asTypeHierarchyItems(result, token);
+        },
+        (error) => {
+          return client.handleFailedRequest(
+            TypeHierarchyPrepareRequest.type,
+            token,
+            error,
+            null,
+          );
+        },
+      );
+    };
+    return middleware.prepareTypeHierarchy
+      ? middleware.prepareTypeHierarchy(document, position, token, prepareTypeHierarchy)
+      : prepareTypeHierarchy(document, position, token);
+  }
+
+  public provideTypeHierarchySupertypes(
+    item: VTypeHierarchyItem,
+    token: CancellationToken,
+  ): ProviderResult<VTypeHierarchyItem[]> {
+    const client = this.client;
+    const middleware = this.middleware;
+    const provideTypeHierarchySupertypes: TypeHierarchySupertypesSignature = (
+      item,
+      token,
+    ) => {
+      const params: TypeHierarchySupertypesParams = {
+        item: client.code2ProtocolConverter.asTypeHierarchyItem(item),
+      };
+      return client
+        .sendRequest(TypeHierarchySupertypesRequest.type, params, token)
+        .then(
+          (result) => {
+            if (token.isCancellationRequested) {
+              return null;
+            }
+            return client.protocol2CodeConverter.asTypeHierarchyItems(result, token);
+          },
+          (error) => {
+            return client.handleFailedRequest(
+              TypeHierarchySupertypesRequest.type,
+              token,
+              error,
+              null,
+            );
+          },
+        );
+    };
+    return middleware.provideTypeHierarchySupertypes
+      ? middleware.provideTypeHierarchySupertypes(
+          item,
+          token,
+          provideTypeHierarchySupertypes,
+        )
+      : provideTypeHierarchySupertypes(item, token);
+  }
+
+  public provideTypeHierarchySubtypes(
+    item: VTypeHierarchyItem,
+    token: CancellationToken,
+  ): ProviderResult<VTypeHierarchyItem[]> {
+    const client = this.client;
+    const middleware = this.middleware;
+    const provideTypeHierarchySubtypes: TypeHierarchySubtypesSignature = (
+      item,
+      token,
+    ) => {
+      const params: TypeHierarchySubtypesParams = {
+        item: client.code2ProtocolConverter.asTypeHierarchyItem(item),
+      };
+      return client.sendRequest(TypeHierarchySubtypesRequest.type, params, token).then(
+        (result) => {
+          if (token.isCancellationRequested) {
+            return null;
+          }
+          return client.protocol2CodeConverter.asTypeHierarchyItems(result, token);
+        },
+        (error) => {
+          return client.handleFailedRequest(
+            TypeHierarchySubtypesRequest.type,
+            token,
+            error,
+            null,
+          );
+        },
+      );
+    };
+    return middleware.provideTypeHierarchySubtypes
+      ? middleware.provideTypeHierarchySubtypes(
+          item,
+          token,
+          provideTypeHierarchySubtypes,
+        )
+      : provideTypeHierarchySubtypes(item, token);
+  }
+}
+
+export class TypeHierarchyFeature extends TextDocumentLanguageFeature<
+  boolean | TypeHierarchyOptions,
+  TypeHierarchyRegistrationOptions,
+  TypeHierarchyProvider,
+  TypeHierarchyMiddleware
+> {
+  constructor(client: FeatureClient<TypeHierarchyMiddleware>) {
+    super(client, TypeHierarchyPrepareRequest.type);
+  }
+
+  public fillClientCapabilities(capabilities: ClientCapabilities): void {
+    const capability = ensure(ensure(capabilities, 'textDocument')!, 'typeHierarchy')!;
+    capability.dynamicRegistration = true;
+  }
+
+  public initialize(
+    capabilities: ServerCapabilities,
+    documentSelector: DocumentSelector,
+  ): void {
+    const [id, options] = this.getRegistration(
+      documentSelector,
+      capabilities.typeHierarchyProvider,
+    );
+    if (!id || !options) {
+      return;
+    }
+    this.register({ id: id, registerOptions: options });
+  }
+
+  protected registerLanguageProvider(
+    options: TypeHierarchyRegistrationOptions,
+  ): [Disposable, TypeHierarchyProvider] {
+    const client = this._client;
+    const provider = new TypeHierarchyProvider(client);
+    return [
+      Languages.registerTypeHierarchyProvider(
+        client.protocol2CodeConverter.asDocumentSelector(options.documentSelector!),
+        provider,
+      ),
+      provider,
+    ];
+  }
+}