@difizen/libro-language-client 0.1.18

package/src/common/codeLens.ts

@@ -0,0 +1,188 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import { Emitter as EventEmitter } from '@difizen/mana-common';
+import type {
+  ClientCapabilities,
+  CancellationToken,
+  ServerCapabilities,
+  DocumentSelector,
+  CodeLensOptions,
+  CodeLensRegistrationOptions,
+} from '@difizen/vscode-languageserver-protocol';
+import {
+  CodeLensRequest,
+  CodeLensRefreshRequest,
+  CodeLensResolveRequest,
+} from '@difizen/vscode-languageserver-protocol';
+import type {
+  Disposable,
+  TextDocument,
+  ProviderResult,
+  CodeLensProvider,
+  CodeLens as VCodeLens,
+} from 'vscode';
+
+import type { FeatureClient } from './features.js';
+import { TextDocumentLanguageFeature, ensure } from './features.js';
+import * as UUID from './utils/uuid.js';
+import { languages as Languages } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export interface ProvideCodeLensesSignature {
+  (
+    this: void,
+    document: TextDocument,
+    token: CancellationToken,
+  ): ProviderResult<VCodeLens[]>;
+}
+
+export interface ResolveCodeLensSignature {
+  (
+    this: void,
+    codeLens: VCodeLens,
+    token: CancellationToken,
+  ): ProviderResult<VCodeLens>;
+}
+
+export interface CodeLensMiddleware {
+  provideCodeLenses?: (
+    this: void,
+    document: TextDocument,
+    token: CancellationToken,
+    next: ProvideCodeLensesSignature,
+  ) => ProviderResult<VCodeLens[]>;
+  resolveCodeLens?: (
+    this: void,
+    codeLens: VCodeLens,
+    token: CancellationToken,
+    next: ResolveCodeLensSignature,
+  ) => ProviderResult<VCodeLens>;
+}
+
+export type CodeLensProviderShape = {
+  provider?: CodeLensProvider;
+  onDidChangeCodeLensEmitter: EventEmitter<void>;
+};
+
+export class CodeLensFeature extends TextDocumentLanguageFeature<
+  CodeLensOptions,
+  CodeLensRegistrationOptions,
+  CodeLensProviderShape,
+  CodeLensMiddleware
+> {
+  constructor(client: FeatureClient<CodeLensMiddleware>) {
+    super(client, CodeLensRequest.type);
+  }
+
+  public fillClientCapabilities(capabilities: ClientCapabilities): void {
+    ensure(ensure(capabilities, 'textDocument')!, 'codeLens')!.dynamicRegistration =
+      true;
+    ensure(ensure(capabilities, 'workspace')!, 'codeLens')!.refreshSupport = true;
+  }
+
+  public initialize(
+    capabilities: ServerCapabilities,
+    documentSelector: DocumentSelector,
+  ): void {
+    const client = this._client;
+    client.onRequest(CodeLensRefreshRequest.type, async () => {
+      for (const provider of this.getAllProviders()) {
+        provider.onDidChangeCodeLensEmitter.fire();
+      }
+    });
+    const options = this.getRegistrationOptions(
+      documentSelector,
+      capabilities.codeLensProvider,
+    );
+    if (!options) {
+      return;
+    }
+    this.register({ id: UUID.generateUuid(), registerOptions: options });
+  }
+
+  protected registerLanguageProvider(
+    options: CodeLensRegistrationOptions,
+  ): [Disposable, CodeLensProviderShape] {
+    const selector = options.documentSelector!;
+    const eventEmitter: EventEmitter<void> = new EventEmitter<void>();
+    const provider: CodeLensProvider = {
+      onDidChangeCodeLenses: eventEmitter.event,
+      provideCodeLenses: (document, token) => {
+        const client = this._client;
+        const provideCodeLenses: ProvideCodeLensesSignature = (document, token) => {
+          return client
+            .sendRequest(
+              CodeLensRequest.type,
+              client.code2ProtocolConverter.asCodeLensParams(document),
+              token,
+            )
+            .then(
+              (result) => {
+                if (token.isCancellationRequested) {
+                  return null;
+                }
+                return client.protocol2CodeConverter.asCodeLenses(result, token);
+              },
+              (error) => {
+                return client.handleFailedRequest(
+                  CodeLensRequest.type,
+                  token,
+                  error,
+                  null,
+                );
+              },
+            );
+        };
+        const middleware = client.middleware;
+        return middleware.provideCodeLenses
+          ? middleware.provideCodeLenses(document, token, provideCodeLenses)
+          : provideCodeLenses(document, token);
+      },
+      resolveCodeLens: options.resolveProvider
+        ? (
+            codeLens: VCodeLens,
+            token: CancellationToken,
+          ): ProviderResult<VCodeLens> => {
+            const client = this._client;
+            const resolveCodeLens: ResolveCodeLensSignature = (codeLens, token) => {
+              return client
+                .sendRequest(
+                  CodeLensResolveRequest.type,
+                  client.code2ProtocolConverter.asCodeLens(codeLens),
+                  token,
+                )
+                .then(
+                  (result) => {
+                    if (token.isCancellationRequested) {
+                      return codeLens;
+                    }
+                    return client.protocol2CodeConverter.asCodeLens(result);
+                  },
+                  (error) => {
+                    return client.handleFailedRequest(
+                      CodeLensResolveRequest.type,
+                      token,
+                      error,
+                      codeLens,
+                    );
+                  },
+                );
+            };
+            const middleware = client.middleware;
+            return middleware.resolveCodeLens
+              ? middleware.resolveCodeLens(codeLens, token, resolveCodeLens)
+              : resolveCodeLens(codeLens, token);
+          }
+        : undefined,
+    };
+    return [
+      Languages.registerCodeLensProvider(
+        this._client.protocol2CodeConverter.asDocumentSelector(selector),
+        provider,
+      ),
+      { provider, onDidChangeCodeLensEmitter: eventEmitter },
+    ];
+  }
+}

package/src/common/colorProvider.ts

@@ -0,0 +1,192 @@
+/* --------------------------------------------------------------------------------------------
+ * 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,
+  DocumentColorRegistrationOptions,
+  DocumentColorOptions,
+} from '@difizen/vscode-languageserver-protocol';
+import {
+  DocumentColorRequest,
+  ColorPresentationRequest,
+} from '@difizen/vscode-languageserver-protocol';
+import type {
+  Disposable,
+  TextDocument,
+  ProviderResult,
+  Range as VRange,
+  Color as VColor,
+  ColorPresentation as VColorPresentation,
+  ColorInformation as VColorInformation,
+  DocumentColorProvider,
+} from 'vscode';
+
+import type { FeatureClient } from './features.js';
+import { TextDocumentLanguageFeature, ensure } from './features.js';
+import { languages as Languages } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export interface ProvideDocumentColorsSignature {
+  (
+    document: TextDocument,
+    token: CancellationToken,
+  ): ProviderResult<VColorInformation[]>;
+}
+
+export interface ProvideColorPresentationSignature {
+  (
+    color: VColor,
+    context: { document: TextDocument; range: VRange },
+    token: CancellationToken,
+  ): ProviderResult<VColorPresentation[]>;
+}
+
+export interface ColorProviderMiddleware {
+  provideDocumentColors?: (
+    this: void,
+    document: TextDocument,
+    token: CancellationToken,
+    next: ProvideDocumentColorsSignature,
+  ) => ProviderResult<VColorInformation[]>;
+  provideColorPresentations?: (
+    this: void,
+    color: VColor,
+    context: { document: TextDocument; range: VRange },
+    token: CancellationToken,
+    next: ProvideColorPresentationSignature,
+  ) => ProviderResult<VColorPresentation[]>;
+}
+
+export class ColorProviderFeature extends TextDocumentLanguageFeature<
+  boolean | DocumentColorOptions,
+  DocumentColorRegistrationOptions,
+  DocumentColorProvider,
+  ColorProviderMiddleware
+> {
+  constructor(client: FeatureClient<ColorProviderMiddleware>) {
+    super(client, DocumentColorRequest.type);
+  }
+
+  public fillClientCapabilities(capabilities: ClientCapabilities): void {
+    ensure(
+      ensure(capabilities, 'textDocument')!,
+      'colorProvider',
+    )!.dynamicRegistration = true;
+  }
+
+  public initialize(
+    capabilities: ServerCapabilities,
+    documentSelector: DocumentSelector,
+  ): void {
+    const [id, options] = this.getRegistration(
+      documentSelector,
+      capabilities.colorProvider,
+    );
+    if (!id || !options) {
+      return;
+    }
+    this.register({ id: id, registerOptions: options });
+  }
+
+  protected registerLanguageProvider(
+    options: DocumentColorRegistrationOptions,
+  ): [Disposable, DocumentColorProvider] {
+    const selector = options.documentSelector!;
+    const provider: DocumentColorProvider = {
+      provideColorPresentations: (color, context, token) => {
+        const client = this._client;
+        const provideColorPresentations: ProvideColorPresentationSignature = (
+          color,
+          context,
+          token,
+        ) => {
+          const requestParams = {
+            color,
+            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
+              context.document,
+            ),
+            range: client.code2ProtocolConverter.asRange(context.range),
+          };
+          return client
+            .sendRequest(ColorPresentationRequest.type, requestParams, token)
+            .then(
+              (result) => {
+                if (token.isCancellationRequested) {
+                  return null;
+                }
+                return this._client.protocol2CodeConverter.asColorPresentations(
+                  result,
+                  token,
+                );
+              },
+              (error: any) => {
+                return client.handleFailedRequest(
+                  ColorPresentationRequest.type,
+                  token,
+                  error,
+                  null,
+                );
+              },
+            );
+        };
+        const middleware = client.middleware;
+        return middleware.provideColorPresentations
+          ? middleware.provideColorPresentations(
+              color,
+              context,
+              token,
+              provideColorPresentations,
+            )
+          : provideColorPresentations(color, context, token);
+      },
+      provideDocumentColors: (document, token) => {
+        const client = this._client;
+        const provideDocumentColors: ProvideDocumentColorsSignature = (
+          document,
+          token,
+        ) => {
+          const requestParams = {
+            textDocument:
+              client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+          };
+          return client
+            .sendRequest(DocumentColorRequest.type, requestParams, token)
+            .then(
+              (result) => {
+                if (token.isCancellationRequested) {
+                  return null;
+                }
+                return this._client.protocol2CodeConverter.asColorInformations(
+                  result,
+                  token,
+                );
+              },
+              (error: any) => {
+                return client.handleFailedRequest(
+                  DocumentColorRequest.type,
+                  token,
+                  error,
+                  null,
+                );
+              },
+            );
+        };
+        const middleware = client.middleware;
+        return middleware.provideDocumentColors
+          ? middleware.provideDocumentColors(document, token, provideDocumentColors)
+          : provideDocumentColors(document, token);
+      },
+    };
+    return [
+      Languages.registerColorProvider(
+        this._client.protocol2CodeConverter.asDocumentSelector(selector),
+        provider,
+      ),
+      provider,
+    ];
+  }
+}

package/src/common/completion.ts

@@ -0,0 +1,281 @@
+/* --------------------------------------------------------------------------------------------
+ * 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,
+  CompletionOptions,
+  CompletionRegistrationOptions,
+  DocumentSelector,
+  ServerCapabilities,
+} from '@difizen/vscode-languageserver-protocol';
+import {
+  CompletionItemKind,
+  CompletionItemTag,
+  CompletionRequest,
+  CompletionResolveRequest,
+  InsertTextMode,
+  MarkupKind,
+} from '@difizen/vscode-languageserver-protocol';
+import type {
+  TextDocument,
+  Disposable,
+  Position as VPosition,
+  CompletionContext as VCompletionContext,
+  CancellationToken,
+  ProviderResult,
+  CompletionItem as VCompletionItem,
+  CompletionList as VCompletionList,
+  CompletionItemProvider,
+} 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';
+
+const SupportedCompletionItemKinds: CompletionItemKind[] = [
+  CompletionItemKind.Text,
+  CompletionItemKind.Method,
+  CompletionItemKind.Function,
+  CompletionItemKind.Constructor,
+  CompletionItemKind.Field,
+  CompletionItemKind.Variable,
+  CompletionItemKind.Class,
+  CompletionItemKind.Interface,
+  CompletionItemKind.Module,
+  CompletionItemKind.Property,
+  CompletionItemKind.Unit,
+  CompletionItemKind.Value,
+  CompletionItemKind.Enum,
+  CompletionItemKind.Keyword,
+  CompletionItemKind.Snippet,
+  CompletionItemKind.Color,
+  CompletionItemKind.File,
+  CompletionItemKind.Reference,
+  CompletionItemKind.Folder,
+  CompletionItemKind.EnumMember,
+  CompletionItemKind.Constant,
+  CompletionItemKind.Struct,
+  CompletionItemKind.Event,
+  CompletionItemKind.Operator,
+  CompletionItemKind.TypeParameter,
+];
+
+export interface ProvideCompletionItemsSignature {
+  (
+    this: void,
+    document: TextDocument,
+    position: VPosition,
+    context: VCompletionContext,
+    token: CancellationToken,
+  ): ProviderResult<VCompletionItem[] | VCompletionList>;
+}
+
+export interface ResolveCompletionItemSignature {
+  (
+    this: void,
+    item: VCompletionItem,
+    token: CancellationToken,
+  ): ProviderResult<VCompletionItem>;
+}
+
+export interface CompletionMiddleware {
+  provideCompletionItem?: (
+    this: void,
+    document: TextDocument,
+    position: VPosition,
+    context: VCompletionContext,
+    token: CancellationToken,
+    next: ProvideCompletionItemsSignature,
+  ) => ProviderResult<VCompletionItem[] | VCompletionList>;
+  resolveCompletionItem?: (
+    this: void,
+    item: VCompletionItem,
+    token: CancellationToken,
+    next: ResolveCompletionItemSignature,
+  ) => ProviderResult<VCompletionItem>;
+}
+
+export class CompletionItemFeature extends TextDocumentLanguageFeature<
+  CompletionOptions,
+  CompletionRegistrationOptions,
+  CompletionItemProvider,
+  CompletionMiddleware
+> {
+  private labelDetailsSupport: Map<string, boolean>;
+
+  constructor(client: FeatureClient<CompletionMiddleware>) {
+    super(client, CompletionRequest.type);
+    this.labelDetailsSupport = new Map();
+  }
+
+  public fillClientCapabilities(capabilities: ClientCapabilities): void {
+    const completion = ensure(ensure(capabilities, 'textDocument')!, 'completion')!;
+    completion.dynamicRegistration = true;
+    completion.contextSupport = true;
+    completion.completionItem = {
+      snippetSupport: true,
+      commitCharactersSupport: true,
+      documentationFormat: [MarkupKind.Markdown, MarkupKind.PlainText],
+      deprecatedSupport: true,
+      preselectSupport: true,
+      tagSupport: { valueSet: [CompletionItemTag.Deprecated] },
+      insertReplaceSupport: true,
+      resolveSupport: {
+        properties: ['documentation', 'detail', 'additionalTextEdits'],
+      },
+      insertTextModeSupport: {
+        valueSet: [InsertTextMode.asIs, InsertTextMode.adjustIndentation],
+      },
+      labelDetailsSupport: true,
+    };
+    completion.insertTextMode = InsertTextMode.adjustIndentation;
+    completion.completionItemKind = { valueSet: SupportedCompletionItemKinds };
+    completion.completionList = {
+      itemDefaults: [
+        'commitCharacters',
+        'editRange',
+        'insertTextFormat',
+        'insertTextMode',
+        'data',
+      ],
+    };
+  }
+
+  public initialize(
+    capabilities: ServerCapabilities,
+    documentSelector: DocumentSelector,
+  ): void {
+    const options = this.getRegistrationOptions(
+      documentSelector,
+      capabilities.completionProvider,
+    );
+    if (!options) {
+      return;
+    }
+
+    this.register({
+      id: UUID.generateUuid(),
+      registerOptions: options,
+    });
+  }
+
+  protected registerLanguageProvider(
+    options: CompletionRegistrationOptions,
+    id: string,
+  ): [Disposable, CompletionItemProvider] {
+    this.labelDetailsSupport.set(id, !!options.completionItem?.labelDetailsSupport);
+    const triggerCharacters = options.triggerCharacters ?? [];
+    const defaultCommitCharacters = options.allCommitCharacters;
+    const selector = options.documentSelector!;
+    const provider: CompletionItemProvider = {
+      provideCompletionItems: (
+        document: TextDocument,
+        position: VPosition,
+        token: CancellationToken,
+        context: VCompletionContext,
+      ): ProviderResult<VCompletionList | VCompletionItem[]> => {
+        const client = this._client;
+        const middleware = this._client.middleware;
+        const provideCompletionItems: ProvideCompletionItemsSignature = (
+          document,
+          position,
+          context,
+          token,
+        ) => {
+          return client
+            .sendRequest(
+              CompletionRequest.type,
+              client.code2ProtocolConverter.asCompletionParams(
+                document,
+                position,
+                context,
+              ),
+              token,
+            )
+            .then(
+              (result) => {
+                if (token.isCancellationRequested) {
+                  return null;
+                }
+                return client.protocol2CodeConverter.asCompletionResult(
+                  result,
+                  defaultCommitCharacters,
+                  token,
+                );
+              },
+              (error) => {
+                return client.handleFailedRequest(
+                  CompletionRequest.type,
+                  token,
+                  error,
+                  null,
+                );
+              },
+            );
+        };
+        return middleware.provideCompletionItem
+          ? middleware.provideCompletionItem(
+              document,
+              position,
+              context,
+              token,
+              provideCompletionItems,
+            )
+          : provideCompletionItems(document, position, context, token);
+      },
+      resolveCompletionItem: options.resolveProvider
+        ? (
+            item: VCompletionItem,
+            token: CancellationToken,
+          ): ProviderResult<VCompletionItem> => {
+            const client = this._client;
+            const middleware = this._client.middleware;
+            const resolveCompletionItem: ResolveCompletionItemSignature = (
+              item,
+              token,
+            ) => {
+              return client
+                .sendRequest(
+                  CompletionResolveRequest.type,
+                  client.code2ProtocolConverter.asCompletionItem(
+                    item,
+                    !!this.labelDetailsSupport.get(id),
+                  ),
+                  token,
+                )
+                .then(
+                  (result) => {
+                    if (token.isCancellationRequested) {
+                      return null;
+                    }
+                    return client.protocol2CodeConverter.asCompletionItem(result);
+                  },
+                  (error) => {
+                    return client.handleFailedRequest(
+                      CompletionResolveRequest.type,
+                      token,
+                      error,
+                      item,
+                    );
+                  },
+                );
+            };
+            return middleware.resolveCompletionItem
+              ? middleware.resolveCompletionItem(item, token, resolveCompletionItem)
+              : resolveCompletionItem(item, token);
+          }
+        : undefined,
+    };
+    return [
+      Languages.registerCompletionItemProvider(
+        this._client.protocol2CodeConverter.asDocumentSelector(selector),
+        provider,
+        ...triggerCharacters,
+      ),
+      provider,
+    ];
+  }
+}