@difizen/libro-language-client 0.1.18

package/src/common/progress.ts

@@ -0,0 +1,61 @@
+/* --------------------------------------------------------------------------------------------
+ * 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,
+  WorkDoneProgressCreateParams,
+} from '@difizen/vscode-languageserver-protocol';
+import { WorkDoneProgressCreateRequest } from '@difizen/vscode-languageserver-protocol';
+
+import type { FeatureClient, FeatureState, StaticFeature } from './features.js';
+import { ProgressPart } from './progressPart.js';
+
+function ensure<T, K extends keyof T>(target: T, key: K): T[K] {
+  if (target[key] === void 0) {
+    target[key] = Object.create(null) as any;
+  }
+  return target[key];
+}
+
+export class ProgressFeature implements StaticFeature {
+  private readonly activeParts: Set<ProgressPart>;
+
+  constructor(private _client: FeatureClient<object>) {
+    this.activeParts = new Set();
+  }
+
+  getState(): FeatureState {
+    return {
+      kind: 'window',
+      id: WorkDoneProgressCreateRequest.method,
+      registrations: this.activeParts.size > 0,
+    };
+  }
+
+  public fillClientCapabilities(capabilities: ClientCapabilities): void {
+    ensure(capabilities, 'window')!.workDoneProgress = true;
+  }
+
+  public initialize(): void {
+    const client = this._client;
+
+    const deleteHandler = (part: ProgressPart) => {
+      this.activeParts.delete(part);
+    };
+
+    const createHandler = (params: WorkDoneProgressCreateParams) => {
+      this.activeParts.add(new ProgressPart(this._client, params.token, deleteHandler));
+    };
+
+    client.onRequest(WorkDoneProgressCreateRequest.type, createHandler);
+  }
+
+  public clear(): void {
+    for (const part of this.activeParts) {
+      part.done();
+    }
+    this.activeParts.clear();
+  }
+}

package/src/common/progressPart.ts

@@ -0,0 +1,151 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type {
+  ProgressToken,
+  ProgressType,
+  NotificationHandler,
+  ProtocolNotificationType,
+  WorkDoneProgressBegin,
+  WorkDoneProgressReport,
+} from '@difizen/vscode-languageserver-protocol';
+import {
+  WorkDoneProgress,
+  WorkDoneProgressCancelNotification,
+} from '@difizen/vscode-languageserver-protocol';
+import type { Progress, CancellationToken, Disposable } from 'vscode';
+
+import * as Is from './utils/is.js';
+import { window as Window, ProgressLocation } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export interface ProgressContext {
+  onProgress<P>(
+    type: ProgressType<P>,
+    token: string | number,
+    handler: NotificationHandler<P>,
+  ): Disposable;
+  sendNotification<P, RO>(type: ProtocolNotificationType<P, RO>, params?: P): void;
+}
+
+export class ProgressPart {
+  private _infinite: boolean;
+  private _reported: number;
+
+  // listener for LSP progress messages. Set in constructor.
+  private _lspProgressDisposable: Disposable | undefined;
+
+  // VS Code progress state. Set in Window.withProgress callback.
+  private _progress: Progress<{ message?: string; increment?: number }> | undefined;
+  private _cancellationToken: CancellationToken | undefined;
+  private _tokenDisposable: Disposable | undefined;
+  private _resolve: (() => void) | undefined;
+  private _reject: ((reason?: any) => void) | undefined;
+
+  public constructor(
+    private _client: ProgressContext,
+    private _token: ProgressToken,
+    done?: (part: ProgressPart) => void,
+  ) {
+    this._reported = 0;
+    this._infinite = false;
+    this._lspProgressDisposable = this._client.onProgress(
+      WorkDoneProgress.type,
+      this._token,
+      (value) => {
+        switch (value.kind) {
+          case 'begin':
+            this.begin(value);
+            break;
+          case 'report':
+            this.report(value);
+            break;
+          case 'end':
+            this.done();
+            done && done(this);
+            break;
+        }
+      },
+    );
+  }
+
+  private begin(params: WorkDoneProgressBegin): void {
+    this._infinite = params.percentage === undefined;
+
+    // the progress as already been marked as done / canceled. Ignore begin call
+    if (this._lspProgressDisposable === undefined) {
+      return;
+    }
+    // Since we don't use commands this will be a silent window progress with a hidden notification.
+    void Window.withProgress<void>(
+      {
+        location: ProgressLocation.Window,
+        cancellable: params.cancellable,
+        title: params.title,
+      },
+      async (progress, cancellationToken) => {
+        // the progress as already been marked as done / canceled. Ignore begin call
+        if (this._lspProgressDisposable === undefined) {
+          return;
+        }
+        this._progress = progress;
+        this._cancellationToken = cancellationToken;
+        this._tokenDisposable = this._cancellationToken.onCancellationRequested(() => {
+          this._client.sendNotification(WorkDoneProgressCancelNotification.type, {
+            token: this._token,
+          });
+        });
+        this.report(params);
+        return new Promise<void>((resolve, reject) => {
+          this._resolve = resolve;
+          this._reject = reject;
+        });
+      },
+    );
+  }
+
+  private report(params: WorkDoneProgressReport | WorkDoneProgressBegin): void {
+    if (this._infinite && Is.string(params.message)) {
+      this._progress !== undefined &&
+        this._progress.report({ message: params.message });
+    } else if (Is.number(params.percentage)) {
+      const percentage = Math.max(0, Math.min(params.percentage, 100));
+      const delta = Math.max(0, percentage - this._reported);
+      this._reported += delta;
+      this._progress !== undefined &&
+        this._progress.report({ message: params.message, increment: delta });
+    }
+  }
+
+  public cancel(): void {
+    this.cleanup();
+    if (this._reject !== undefined) {
+      this._reject();
+      this._resolve = undefined;
+      this._reject = undefined;
+    }
+  }
+
+  public done(): void {
+    this.cleanup();
+    if (this._resolve !== undefined) {
+      this._resolve();
+      this._resolve = undefined;
+      this._reject = undefined;
+    }
+  }
+
+  private cleanup(): void {
+    if (this._lspProgressDisposable !== undefined) {
+      this._lspProgressDisposable.dispose();
+      this._lspProgressDisposable = undefined;
+    }
+    if (this._tokenDisposable !== undefined) {
+      this._tokenDisposable.dispose();
+      this._tokenDisposable = undefined;
+    }
+    this._progress = undefined;
+    this._cancellationToken = undefined;
+  }
+}

package/src/common/protocolCallHierarchyItem.ts

@@ -0,0 +1,29 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type { LSPAny } from '@difizen/vscode-languageserver-protocol';
+import type { SymbolKind, Uri } from 'vscode';
+
+import type { Range } from './vscodeAdaptor/vscodeAdaptor.js';
+import { CallHierarchyItem } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export default class ProtocolCallHierarchyItem extends CallHierarchyItem {
+  public data?: LSPAny;
+
+  constructor(
+    kind: SymbolKind,
+    name: string,
+    detail: string,
+    uri: Uri,
+    range: Range,
+    selectionRange: Range,
+    data?: LSPAny,
+  ) {
+    super(kind, name, detail, uri, range, selectionRange);
+    if (data !== undefined) {
+      this.data = data;
+    }
+  }
+}

package/src/common/protocolCodeAction.ts

@@ -0,0 +1,17 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type { LSPAny } from '@difizen/vscode-languageserver-protocol';
+
+import { CodeAction } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export default class ProtocolCodeAction extends CodeAction {
+  public readonly data: LSPAny | undefined;
+
+  constructor(title: string, data: LSPAny | undefined) {
+    super(title);
+    this.data = data;
+  }
+}

package/src/common/protocolCodeLens.ts

@@ -0,0 +1,15 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type { Range } from './vscodeAdaptor/vscodeAdaptor.js';
+import { CodeLens } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export default class ProtocolCodeLens extends CodeLens {
+  public data: any;
+
+  constructor(range: Range) {
+    super(range);
+  }
+}

package/src/common/protocolCompletionItem.ts

@@ -0,0 +1,22 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type * as proto from '@difizen/vscode-languageserver-protocol';
+
+import type { CompletionItemLabel } from './vscodeAdaptor/vscodeAdaptor.js';
+import { CompletionItem } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export default class ProtocolCompletionItem extends CompletionItem {
+  public data: any;
+  public fromEdit: boolean | undefined;
+  public documentationFormat: string | undefined;
+  public originalItemKind: proto.CompletionItemKind | undefined;
+  public deprecated: boolean | undefined;
+  public insertTextMode: proto.InsertTextMode | undefined;
+
+  constructor(label: string | CompletionItemLabel) {
+    super(label);
+  }
+}