monaco-languageclient config improvement, wrapper+languageclientwrapper improvements

packages/client/src/client.ts

@@ -0,0 +1,30 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import { BaseLanguageClient, MessageTransports, LanguageClientOptions } from 'vscode-languageclient/browser.js';
+
+export interface IConnectionProvider {
+    get(encoding: string): Promise<MessageTransports>;
+}
+
+export type MonacoLanguageClientOptions = {
+    name: string;
+    id?: string;
+    clientOptions: LanguageClientOptions;
+    connectionProvider: IConnectionProvider;
+}
+
+export class MonacoLanguageClient extends BaseLanguageClient {
+    protected readonly connectionProvider: IConnectionProvider;
+
+    constructor({ id, name, clientOptions, connectionProvider }: MonacoLanguageClientOptions) {
+        super(id ?? name.toLowerCase(), name, clientOptions);
+        this.connectionProvider = connectionProvider;
+    }
+
+    protected override createMessageTransports(encoding: string): Promise<MessageTransports> {
+        return this.connectionProvider.get(encoding);
+    }
+}

packages/wrapper/src/commonTypes.ts → packages/client/src/commonTypes.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { MonacoLanguageClient } from 'monaco-languageclient';
+import { MonacoLanguageClient } from './client.js';
 
 export type WebSocketCallOptions = {
     /** Adds handle on languageClient */
@@ -12,29 +12,45 @@ export type WebSocketCallOptions = {
     reportStatus?: boolean;
 }
 
-export type LanguageClientConfigType = 'WebSocket' | 'WebSocketUrl' | 'WorkerConfig' | 'Worker';
+export type LanguageClientRestartOptions = {
+    retries: number;
+    timeout: number;
+    keepWorker?: boolean;
+}
 
-export type WebSocketUrl = {
-    secured: boolean;
-    host: string;
-    port?: number;
-    path?: string;
+export type LanguageClientConfigType = 'WebSocket' | 'WebSocketUrl' | 'WebSocketDirect' | 'WorkerConfig' | 'Worker';
+
+export type LanguageClientConfigOptions = (WebSocketConfigOptionsDirect | WebSocketConfigOptionsParams | WebSocketConfigOptionsUrl | WorkerConfigOptions | WorkerConfigDirect) & {
+    restartOptions?: LanguageClientRestartOptions;
 }
 
-export type WebSocketConfigOptions = {
-    $type: 'WebSocket'
+export type WebSocketUrlParams = {
     secured: boolean;
     host: string;
     port?: number;
     path?: string;
     extraParams?: Record<string, string | number | Array<string | number>>;
+}
+
+export type WebSocketUrlString = {
+    url: string;
+}
+
+export type WebSocketConfigOptionsDirect = {
+    $type: 'WebSocketDirect'
+    webSocket: WebSocket
+    startOptions?: WebSocketCallOptions;
+    stopOptions?: WebSocketCallOptions;
+}
+
+export type WebSocketConfigOptionsParams = WebSocketUrlParams & {
+    $type: 'WebSocketParams'
     startOptions?: WebSocketCallOptions;
     stopOptions?: WebSocketCallOptions;
 }
 
-export type WebSocketConfigOptionsUrl = {
+export type WebSocketConfigOptionsUrl = WebSocketUrlString & {
     $type: 'WebSocketUrl'
-    url: string;
     startOptions?: WebSocketCallOptions;
     stopOptions?: WebSocketCallOptions;
 }

packages/client/src/index.ts

@@ -3,28 +3,7 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { BaseLanguageClient, MessageTransports, LanguageClientOptions } from 'vscode-languageclient/lib/common/client.js';
-
-export interface IConnectionProvider {
-    get(encoding: string): Promise<MessageTransports>;
-}
-
-export type MonacoLanguageClientOptions = {
-    name: string;
-    id?: string;
-    clientOptions: LanguageClientOptions;
-    connectionProvider: IConnectionProvider;
-}
-
-export class MonacoLanguageClient extends BaseLanguageClient {
-    protected readonly connectionProvider: IConnectionProvider;
-
-    constructor({ id, name, clientOptions, connectionProvider }: MonacoLanguageClientOptions) {
-        super(id ?? name.toLowerCase(), name, clientOptions);
-        this.connectionProvider = connectionProvider;
-    }
-
-    protected override createMessageTransports(encoding: string): Promise<MessageTransports> {
-        return this.connectionProvider.get(encoding);
-    }
-}
+export type * from './client.js';
+export * from './client.js';
+export type * from './commonTypes.js';
+export * from './commonTypes.js';

packages/client/tsconfig.src.json

@@ -4,9 +4,10 @@
     "rootDir": "src",
     "outDir": "lib",
     "declarationDir": "lib",
-    "types": [
-      "vscode"
-    ]
+    // because vscode-jsonrpc requires DedicatedWorkerGlobalScope
+    // we are required to include both DOM and WebWorker libs
+    // the only way out currently is to disable lib checking
+    "skipLibCheck": true
   },
   "include": [
     "src/**/*.ts",

packages/examples/src/bare/client.ts

@@ -13,7 +13,7 @@ import '@codingame/monaco-vscode-theme-defaults-default-extension';
 import '@codingame/monaco-vscode-json-default-extension';
 import { MonacoLanguageClient } from 'monaco-languageclient';
 import { WebSocketMessageReader, WebSocketMessageWriter, toSocket } from 'vscode-ws-jsonrpc';
-import { CloseAction, ErrorAction, MessageTransports } from 'vscode-languageclient';
+import { CloseAction, ErrorAction, MessageTransports } from 'vscode-languageclient/browser.js';
 import { useWorkerFactory } from 'monaco-editor-wrapper/workerFactory';
 
 export const configureMonacoWorkers = () => {
@@ -87,9 +87,7 @@ export const createLanguageClient = (transports: MessageTransports): MonacoLangu
         },
         // create a language client connection from the JSON RPC connection on demand
         connectionProvider: {
-            get: () => {
-                return Promise.resolve(transports);
-            }
+            get: async () => (transports)
         }
     });
 };

packages/examples/src/common/node/server-commons.ts

@@ -10,7 +10,7 @@ import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { IWebSocket, WebSocketMessageReader, WebSocketMessageWriter } from 'vscode-ws-jsonrpc';
 import { createConnection, createServerProcess, forward } from 'vscode-ws-jsonrpc/server';
-import { Message, InitializeRequest, InitializeParams } from 'vscode-languageserver';
+import { Message, InitializeRequest, InitializeParams, RequestMessage, ResponseMessage } from 'vscode-languageserver-protocol';
 import * as cp from 'child_process';
 
 export enum LanguageName {
@@ -28,6 +28,9 @@ export interface LanguageServerRunConfig {
     runCommandArgs: string[];
     wsServerOptions: ServerOptions,
     spawnOptions?: cp.SpawnOptions;
+    logMessages?: boolean;
+    requestMessageHandler?: (message: RequestMessage) => RequestMessage;
+    responseMessageHandler?: (message: ResponseMessage) => ResponseMessage;
 }
 
 /**
@@ -43,16 +46,27 @@ export const launchLanguageServer = (runconfig: LanguageServerRunConfig, socket:
     if (serverConnection) {
         forward(socketConnection, serverConnection, message => {
             if (Message.isRequest(message)) {
-                console.log(`${serverName} Server received:`);
-                console.log(message);
                 if (message.method === InitializeRequest.type.method) {
                     const initializeParams = message.params as InitializeParams;
                     initializeParams.processId = process.pid;
                 }
+
+                if (runconfig.logMessages ?? false) {
+                    console.log(`${serverName} Server received: ${message.method}`);
+                    console.log(message);
+                }
+                if (runconfig.requestMessageHandler !== undefined) {
+                    return runconfig.requestMessageHandler(message);
+                }
             }
             if (Message.isResponse(message)) {
-                console.log(`${serverName} Server sent:`);
-                console.log(message);
+                if (runconfig.logMessages ?? false) {
+                    console.log(`${serverName} Server sent:`);
+                    console.log(message);
+                }
+                if (runconfig.responseMessageHandler !== undefined) {
+                    return runconfig.responseMessageHandler(message);
+                }
             }
             return message;
         });
@@ -76,7 +90,6 @@ export const upgradeWsServer = (runconfig: LanguageServerRunConfig,
                         }
                     }),
                     onMessage: cb => webSocket.on('message', (data) => {
-                        console.log(data.toString());
                         cb(data);
                     }),
                     onError: cb => webSocket.on('error', cb),

packages/examples/src/eclipse.jdt.ls/client/main.ts

@@ -10,7 +10,7 @@ import '@codingame/monaco-vscode-java-default-extension';
 import { MonacoEditorLanguageClientWrapper, UserConfig } from 'monaco-editor-wrapper';
 import { useWorkerFactory } from 'monaco-editor-wrapper/workerFactory';
 import { RegisteredFileSystemProvider, RegisteredMemoryFile, registerFileSystemOverlay } from '@codingame/monaco-vscode-files-service-override';
-import { eclipseJdtLsConfig } from '../config';
+import { eclipseJdtLsConfig } from '../config.js';
 import helloJavaCode from '../../../resources/eclipse.jdt.ls/workspace/hello.java?raw';
 
 export const configureMonacoWorkers = () => {

packages/examples/src/langium/langium-dsl/config/extendedConfig.ts

@@ -83,7 +83,7 @@ export const setupLangiumClientExtended = async (): Promise<UserConfig> => {
                 worker: langiumWorker
             },
             connectionProvider: {
-                get: async () => ({ reader, writer }),
+                get: async () => ({ reader, writer })
             }
         }
     };

packages/examples/src/python/client/config.ts

@@ -7,24 +7,33 @@ import * as vscode from 'vscode';
 import getEditorServiceOverride from '@codingame/monaco-vscode-editor-service-override';
 import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
 import '@codingame/monaco-vscode-python-default-extension';
-import { UserConfig } from 'monaco-editor-wrapper';
+import { createUrl, UserConfig } from 'monaco-editor-wrapper';
 import { useOpenEditorStub } from 'monaco-editor-wrapper/vscode/services';
 import { MonacoLanguageClient } from 'monaco-languageclient';
+import { toSocket, WebSocketMessageReader, WebSocketMessageWriter } from 'vscode-ws-jsonrpc';
 
 export const createUserConfig = (workspaceRoot: string, code: string, codeUri: string): UserConfig => {
+    const url = createUrl({
+        secured: false,
+        host: 'localhost',
+        port: 30001,
+        path: 'pyright',
+        extraParams: {
+            authorization: 'UserAuth'
+        }
+    });
+    const webSocket = new WebSocket(url);
+    const iWebSocket = toSocket(webSocket);
+    const reader = new WebSocketMessageReader(iWebSocket);
+    const writer = new WebSocketMessageWriter(iWebSocket);
+
     return {
         languageClientConfig: {
             languageId: 'python',
             name: 'Python Language Server Example',
             options: {
-                $type: 'WebSocket',
-                host: 'localhost',
-                port: 30001,
-                path: 'pyright',
-                extraParams: {
-                    authorization: 'UserAuth'
-                },
-                secured: false,
+                $type: 'WebSocketDirect',
+                webSocket: webSocket,
                 startOptions: {
                     onCall: (languageClient?: MonacoLanguageClient) => {
                         setTimeout(() => {
@@ -46,6 +55,9 @@ export const createUserConfig = (workspaceRoot: string, code: string, codeUri: s
                     uri: vscode.Uri.parse(workspaceRoot)
                 },
             },
+            connectionProvider: {
+                get: async () => ({ reader, writer })
+            }
         },
         wrapperConfig: {
             serviceConfig: {

packages/examples/src/python/server/main.ts

@@ -35,6 +35,7 @@ export const runPythonServer = (baseDir: string, relativeDir: string) => {
                     callback(false);
                 }
             }
-        }
+        },
+        logMessages: true
     });
 };

packages/examples/src/ts/wrapperAdvanced.ts

@@ -57,7 +57,7 @@ Same again.`,
         languageId: 'json',
         name: 'wrapper42 language client',
         options: {
-            $type: 'WebSocket',
+            $type: 'WebSocketParams',
             host: 'localhost',
             port: 30000,
             path: 'sampleServer',

packages/examples/tsconfig.build.json

@@ -2,11 +2,7 @@
   "extends": "../../tsconfig.json",
   "compilerOptions": {
     "rootDir": "./build",
-    "noEmit": true,
-    // all other types are not needed here
-    "types": [
-      "node"
-    ]
+    "noEmit": true
   },
   "include": [
     "build/**/*.ts",

packages/vscode-ws-jsonrpc/tsconfig.src.json

@@ -3,9 +3,7 @@
   "compilerOptions": {
     "rootDir": "src",
     "outDir": "lib",
-    "declarationDir": "lib",
-    // no types definitions are required to undertand dependent code
-    "types": []
+    "declarationDir": "lib"
   },
   "include": [
     "src/**/*.ts",

packages/wrapper-react/test/index.test.tsx

@@ -8,7 +8,7 @@ import { render, RenderResult } from '@testing-library/react';
 import React from 'react';
 import { MonacoEditorReactComp, TextChanges } from '@typefox/monaco-editor-react';
 import { MonacoEditorLanguageClientWrapper, UserConfig } from 'monaco-editor-wrapper';
-import { updateExtendedAppPrototyp } from './helper';
+import { updateExtendedAppPrototyp } from './helper.js';
 
 describe('Test MonacoEditorReactComp', () => {
     test('rerender', async () => {

packages/wrapper-react/tsconfig.src.json

@@ -4,9 +4,10 @@
     "rootDir": "src",
     "outDir": "dist",
     "declarationDir": "dist",
-    "types": [
-      "vscode"
-    ]
+    // because vscode-jsonrpc requires DedicatedWorkerGlobalScope
+    // we are required to include both DOM and WebWorker libs
+    // the only way out currently is to disable lib checking
+    "skipLibCheck": true
   },
   "references": [{
     "path": "../wrapper/tsconfig.src.json"

packages/wrapper-react/tsconfig.test.json

@@ -2,7 +2,11 @@
   "extends": "./tsconfig.src.json",
   "compilerOptions": {
     "noEmit": true,
-    "rootDir": "test"
+    "rootDir": "test",
+    // because vscode-jsonrpc requires DedicatedWorkerGlobalScope
+    // we are required to include both DOM and WebWorker libs
+    // the only way out currently is to disable lib checking
+    "skipLibCheck": true
   },
   "references": [{
     "path": "./tsconfig.src.json"

packages/wrapper/src/index.ts

@@ -39,15 +39,6 @@ import {
     EditorAppExtended
 } from './editorAppExtended.js';
 
-import type {
-    WebSocketCallOptions,
-    LanguageClientConfigType,
-    WebSocketConfigOptions,
-    WebSocketConfigOptionsUrl,
-    WorkerConfigOptions,
-    WorkerConfigDirect
-} from './commonTypes.js';
-
 import type {
     LanguageClientConfig,
     LanguageClientError
@@ -76,12 +67,6 @@ export type {
     RegisterExtensionResult,
     RegisterLocalProcessExtensionResult,
     UserConfiguration,
-    WebSocketCallOptions,
-    LanguageClientConfigType,
-    WebSocketConfigOptions,
-    WebSocketConfigOptionsUrl,
-    WorkerConfigOptions,
-    WorkerConfigDirect,
     LanguageClientConfig,
     LanguageClientError,
     UserConfig,