@difizen/libro-language-client 0.1.18

package/src/common/workspaceSymbol.ts

@@ -0,0 +1,166 @@
+/* --------------------------------------------------------------------------------------------
+ * 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,
+  ServerCapabilities,
+  WorkspaceSymbolRegistrationOptions,
+} from '@difizen/vscode-languageserver-protocol';
+import {
+  WorkspaceSymbolRequest,
+  WorkspaceSymbolResolveRequest,
+} from '@difizen/vscode-languageserver-protocol';
+import type {
+  Disposable,
+  CancellationToken,
+  ProviderResult,
+  SymbolInformation as VSymbolInformation,
+  WorkspaceSymbolProvider,
+} from 'vscode';
+
+import { SupportedSymbolKinds, SupportedSymbolTags } from './documentSymbol.js';
+import type { FeatureClient } from './features.js';
+import { ensure, WorkspaceFeature } from './features.js';
+import * as UUID from './utils/uuid.js';
+import { languages as Languages } from './vscodeAdaptor/vscodeAdaptor.js';
+
+export interface ProvideWorkspaceSymbolsSignature {
+  (
+    this: void,
+    query: string,
+    token: CancellationToken,
+  ): ProviderResult<VSymbolInformation[]>;
+}
+
+export interface ResolveWorkspaceSymbolSignature {
+  (
+    this: void,
+    item: VSymbolInformation,
+    token: CancellationToken,
+  ): ProviderResult<VSymbolInformation>;
+}
+
+export interface WorkspaceSymbolMiddleware {
+  provideWorkspaceSymbols?: (
+    this: void,
+    query: string,
+    token: CancellationToken,
+    next: ProvideWorkspaceSymbolsSignature,
+  ) => ProviderResult<VSymbolInformation[]>;
+  resolveWorkspaceSymbol?: (
+    this: void,
+    item: VSymbolInformation,
+    token: CancellationToken,
+    next: ResolveWorkspaceSymbolSignature,
+  ) => ProviderResult<VSymbolInformation>;
+}
+
+export class WorkspaceSymbolFeature extends WorkspaceFeature<
+  WorkspaceSymbolRegistrationOptions,
+  WorkspaceSymbolProvider,
+  WorkspaceSymbolMiddleware
+> {
+  constructor(client: FeatureClient<WorkspaceSymbolMiddleware>) {
+    super(client, WorkspaceSymbolRequest.type);
+  }
+
+  public fillClientCapabilities(capabilities: ClientCapabilities): void {
+    const symbolCapabilities = ensure(ensure(capabilities, 'workspace')!, 'symbol')!;
+    symbolCapabilities.dynamicRegistration = true;
+    symbolCapabilities.symbolKind = {
+      valueSet: SupportedSymbolKinds,
+    };
+    symbolCapabilities.tagSupport = {
+      valueSet: SupportedSymbolTags,
+    };
+    symbolCapabilities.resolveSupport = { properties: ['location.range'] };
+  }
+
+  public initialize(capabilities: ServerCapabilities): void {
+    if (!capabilities.workspaceSymbolProvider) {
+      return;
+    }
+    this.register({
+      id: UUID.generateUuid(),
+      registerOptions:
+        capabilities.workspaceSymbolProvider === true
+          ? { workDoneProgress: false }
+          : capabilities.workspaceSymbolProvider,
+    });
+  }
+
+  protected registerLanguageProvider(
+    options: WorkspaceSymbolRegistrationOptions,
+  ): [Disposable, WorkspaceSymbolProvider] {
+    const provider: WorkspaceSymbolProvider = {
+      provideWorkspaceSymbols: (query, token) => {
+        const client = this._client;
+        const provideWorkspaceSymbols: ProvideWorkspaceSymbolsSignature = (
+          query,
+          token,
+        ) => {
+          return client.sendRequest(WorkspaceSymbolRequest.type, { query }, token).then(
+            (result) => {
+              if (token.isCancellationRequested) {
+                return null;
+              }
+              return client.protocol2CodeConverter.asSymbolInformations(result, token);
+            },
+            (error) => {
+              return client.handleFailedRequest(
+                WorkspaceSymbolRequest.type,
+                token,
+                error,
+                null,
+              );
+            },
+          );
+        };
+        const middleware = client.middleware;
+        return middleware.provideWorkspaceSymbols
+          ? middleware.provideWorkspaceSymbols(query, token, provideWorkspaceSymbols)
+          : provideWorkspaceSymbols(query, token);
+      },
+      resolveWorkspaceSymbol:
+        options.resolveProvider === true
+          ? (item, token) => {
+              const client = this._client;
+              const resolveWorkspaceSymbol: ResolveWorkspaceSymbolSignature = (
+                item,
+                token,
+              ) => {
+                return client
+                  .sendRequest(
+                    WorkspaceSymbolResolveRequest.type,
+                    client.code2ProtocolConverter.asWorkspaceSymbol(item),
+                    token,
+                  )
+                  .then(
+                    (result) => {
+                      if (token.isCancellationRequested) {
+                        return null;
+                      }
+                      return client.protocol2CodeConverter.asSymbolInformation(result);
+                    },
+                    (error) => {
+                      return client.handleFailedRequest(
+                        WorkspaceSymbolResolveRequest.type,
+                        token,
+                        error,
+                        null,
+                      );
+                    },
+                  );
+              };
+              const middleware = client.middleware;
+              return middleware.resolveWorkspaceSymbol
+                ? middleware.resolveWorkspaceSymbol(item, token, resolveWorkspaceSymbol)
+                : resolveWorkspaceSymbol(item, token);
+            }
+          : undefined,
+    };
+    return [Languages.registerWorkspaceSymbolProvider(provider), provider];
+  }
+}

package/src/constants.ts

@@ -0,0 +1 @@
+export const LibroCellURIScheme = 'libro-notebook-cell';

package/src/index.spec.ts

@@ -0,0 +1,7 @@
+import assert from 'assert';
+
+describe('libro-langauge-client', () => {
+  it('#import', () => {
+    assert(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './libro-language-client-manager.js';
+export * from './libro-language-client.js';
+export * from './module.js';
+export * from './common/api.js';
+export * from './constants.js';

package/src/libro-language-client-contribution.ts

@@ -0,0 +1,49 @@
+import { ApplicationContribution, inject, singleton } from '@difizen/mana-app';
+
+import { CloseAction, ErrorAction } from './common/api.js';
+import { LSPEnv } from './common/vscodeAdaptor/lspEnv.js';
+import { workspace } from './common/vscodeAdaptor/vscodeAdaptor.js';
+import { LibroLanguageClientManager } from './libro-language-client-manager.js';
+
+@singleton({ contrib: [ApplicationContribution] })
+export class LibroLanguageClientContribution implements ApplicationContribution {
+  @inject(LibroLanguageClientManager)
+  protected readonly libroLanguageClientManager: LibroLanguageClientManager;
+
+  @inject(LSPEnv)
+  protected readonly lspEnv: LSPEnv;
+
+  async onViewStart() {
+    // not block
+    this.startLanguageClients();
+  }
+
+  async startLanguageClients() {
+    await this.lspEnv.ready;
+    const serverIds = await this.libroLanguageClientManager.getServers();
+
+    for (const serverId of serverIds) {
+      await this.libroLanguageClientManager.getOrCreateLanguageClient(serverId, {
+        name: `${serverId} Language Client`,
+        clientOptions: {
+          // use a language id as a document selector
+          documentSelector: [{ language: 'python' }],
+          // disable the default error handler
+          errorHandler: {
+            error: () => ({ action: ErrorAction.Continue }),
+            closed: () => ({ action: CloseAction.DoNotRestart }),
+          },
+          // pyright requires a workspace folder to be present, otherwise it will not work
+          // workspaceFolder: {
+          //   index: 0,
+          //   name: 'workspace',
+          //   uri: URI.parse('/examples'), // abs path
+          // },
+          synchronize: {
+            fileEvents: [workspace.createFileSystemWatcher('**', false)],
+          },
+        },
+      });
+    }
+  }
+}

package/src/libro-language-client-manager.ts

@@ -0,0 +1,131 @@
+import { URL } from '@difizen/libro-common';
+import { PageConfig } from '@difizen/libro-kernel';
+import type { ILanguageServerManager, TSessionMap } from '@difizen/libro-lsp';
+import { ILanguageServerManagerFactory } from '@difizen/libro-lsp';
+import { singleton, inject, postConstruct, getOrigin } from '@difizen/mana-app';
+
+import type { LibroLanguageClientOptions } from './libro-language-client.js';
+import { LibroLanguageClient } from './libro-language-client.js';
+
+interface IConnectionData {
+  connection: WebSocket;
+  languageClient: LibroLanguageClient;
+}
+
+// TODO: type is not complete
+export type LSPFeatureType = 'textDocument/formatting';
+
+@singleton()
+export class LibroLanguageClientManager {
+  @inject(ILanguageServerManagerFactory)
+  protected readonly languageServerManagerFactory: ILanguageServerManagerFactory;
+
+  protected languageServerManager: ILanguageServerManager;
+
+  protected clientMap = new Map<string, IConnectionData>();
+
+  @postConstruct()
+  init() {
+    this.languageServerManager = this.languageServerManagerFactory({});
+  }
+
+  protected serverUri(languageServerId: string) {
+    const wsBase = PageConfig.getBaseUrl().replace(/^http/, 'ws');
+    return URL.join(wsBase, 'lsp', 'ws', languageServerId);
+  }
+
+  async getServers(language = 'python') {
+    await this.languageServerManager.ready;
+    const serverIds = this.languageServerManager.getMatchingServers({
+      language,
+    });
+    return serverIds;
+  }
+
+  async getServerSpecs(language = 'python') {
+    await this.languageServerManager.ready;
+    const specs = this.languageServerManager.getMatchingSpecs({
+      language,
+    });
+    return specs;
+  }
+
+  async refreshRunning() {
+    await this.languageServerManager.refreshRunning();
+  }
+
+  get sessionsChanged() {
+    return this.languageServerManager.sessionsChanged;
+  }
+
+  get sessions() {
+    const res: TSessionMap = new Map();
+    this.languageServerManager.sessions.forEach((item, key) => {
+      if (item.status === 'started') {
+        res.set(key, item);
+      }
+    });
+    return res;
+  }
+
+  async getOrCreateLanguageClient(
+    languageServerId: string,
+    options: LibroLanguageClientOptions,
+  ) {
+    if (this.clientMap.has(languageServerId)) {
+      return this.clientMap.get(languageServerId);
+    }
+    const url = this.serverUri(languageServerId);
+    const client = await this.createLanguageClient(url, options);
+    this.clientMap.set(languageServerId, client);
+    this.refreshRunning();
+    return client;
+  }
+
+  protected createLanguageClient = (
+    url: string,
+    options: LibroLanguageClientOptions,
+  ) => {
+    return LibroLanguageClient.createWebSocketLanguageClient(url, options);
+  };
+
+  async closeLanguageClient(languageServerId: string) {
+    await getOrigin(this.clientMap.get(languageServerId)?.languageClient)?.dispose();
+    getOrigin(this.clientMap.get(languageServerId)?.connection)?.close();
+    this.clientMap.delete(languageServerId);
+    this.refreshRunning();
+  }
+
+  async closeAllLanguageClient() {
+    const servers = await this.getServers();
+    await Promise.all(servers.map((server) => this.closeLanguageClient(server)));
+    this.refreshRunning();
+  }
+
+  async getFeatureStatus(
+    feature: LSPFeatureType,
+    language = 'python',
+  ): Promise<boolean> {
+    let featureEnabled = false;
+    const serverids = await this.getServers(language);
+    serverids.forEach((id) => {
+      const featureState = this.clientMap
+        .get(id)
+        ?.languageClient.getFeature(feature)
+        .getState();
+      if (featureState?.kind === 'document' && featureState.registrations === true) {
+        featureEnabled = true;
+      }
+      if (featureState?.kind === 'workspace' && featureState.registrations === true) {
+        featureEnabled = true;
+      }
+      if (featureState?.kind === 'window' && featureState.registrations === true) {
+        featureEnabled = true;
+      }
+      if (featureState?.kind === 'static') {
+        featureEnabled = true;
+      }
+    });
+    return featureEnabled;
+  }
+}

package/src/libro-language-client.ts

@@ -0,0 +1,100 @@
+import { Deferred } from '@difizen/mana-common';
+import {
+  BrowserMessageReader,
+  BrowserMessageWriter,
+} from '@difizen/vscode-languageserver-protocol/browser.js';
+import {
+  WebSocketMessageReader,
+  WebSocketMessageWriter,
+  toSocket,
+} from 'vscode-ws-jsonrpc';
+
+import type { LanguageClientOptions, MessageTransports } from './common/client.js';
+import { BaseLanguageClient } from './common/client.js';
+
+export interface IConnectionProvider {
+  get(encoding: string): Promise<MessageTransports>;
+}
+
+export interface LibroLanguageClientOptions {
+  name: string;
+  id?: string;
+  clientOptions: LanguageClientOptions;
+}
+
+export interface LibroLanguageClientFullOptions extends LibroLanguageClientOptions {
+  connectionProvider: IConnectionProvider;
+}
+
+export class LibroLanguageClient extends BaseLanguageClient {
+  static createWebSocketLanguageClient = async (
+    url: string,
+    options: LibroLanguageClientOptions,
+  ) => {
+    const deferred = new Deferred<{
+      connection: WebSocket;
+      languageClient: LibroLanguageClient;
+    }>();
+    const webSocket = new WebSocket(url);
+    webSocket.onopen = async () => {
+      const socket = toSocket(webSocket);
+      const reader = new WebSocketMessageReader(socket);
+      const writer = new WebSocketMessageWriter(socket);
+      const connectionProvider = {
+        get: () => {
+          return Promise.resolve({ reader, writer });
+        },
+      };
+      const languageClient = new LibroLanguageClient({
+        ...options,
+        connectionProvider,
+      });
+      await languageClient.start();
+      reader.onClose(() => languageClient.stop());
+      deferred.resolve({
+        connection: webSocket,
+        languageClient,
+      });
+    };
+    return deferred.promise;
+  };
+
+  static createWebWorkerLanguageClient = async (
+    url: string,
+    options: LibroLanguageClientOptions,
+  ): Promise<{ connection: Worker; languageClient: LibroLanguageClient }> => {
+    const worker = new Worker(url);
+    const reader = new BrowserMessageReader(worker);
+    const writer = new BrowserMessageWriter(worker);
+    const connectionProvider = {
+      get: () => {
+        return Promise.resolve({ reader, writer });
+      },
+    };
+    const languageClient = new LibroLanguageClient({
+      ...options,
+      connectionProvider,
+    });
+    await languageClient.start();
+    reader.onClose(() => languageClient.stop());
+    return { connection: worker, languageClient };
+  };
+
+  protected readonly connectionProvider: IConnectionProvider;
+
+  constructor({
+    id,
+    name,
+    clientOptions,
+    connectionProvider,
+  }: LibroLanguageClientFullOptions) {
+    super(id || name.toLowerCase(), name, clientOptions);
+    this.connectionProvider = connectionProvider;
+  }
+
+  protected override createMessageTransports(
+    encoding: string,
+  ): Promise<MessageTransports> {
+    return this.connectionProvider.get(encoding);
+  }
+}

package/src/module.ts

@@ -0,0 +1,19 @@
+import { LibroLSPModule } from '@difizen/libro-lsp';
+import { ManaModule } from '@difizen/mana-app';
+
+import { LibroWindow } from './common/vscodeAdaptor/libroWindow.js';
+import { LibroWorkspace } from './common/vscodeAdaptor/libroWorkspace.js';
+import { LSPEnv } from './common/vscodeAdaptor/lspEnv.js';
+import { MonacoLanguages } from './common/vscodeAdaptor/monacoLanguages.js';
+import { setupLspEnv } from './common/vscodeAdaptor/vscodeAdaptor.js';
+import { LibroLanguageClientContribution } from './libro-language-client-contribution.js';
+import { LibroLanguageClientManager } from './libro-language-client-manager.js';
+
+export const LibroLanguageClientModule = ManaModule.create()
+  .register(LibroLanguageClientManager, LibroLanguageClientContribution, LSPEnv)
+  .register(MonacoLanguages, LibroWindow, LibroWorkspace)
+  .dependOn(LibroLSPModule)
+  .preload((ctx) => {
+    setupLspEnv(ctx.container);
+    return Promise.resolve();
+  });