monaco-languageclient-examples 2025.6.3 → 2025.8.1

package/src/bare/client.ts

@@ -3,22 +3,22 @@
  * Licensed under the MIT License. See License.txt in the project root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { LogLevel } from '@codingame/monaco-vscode-api';
 import * as monaco from '@codingame/monaco-vscode-editor-api';
+import { initServices } from 'monaco-languageclient/vscode/services';
 import getTextmateServiceOverride from '@codingame/monaco-vscode-textmate-service-override';
 import getThemeServiceOverride from '@codingame/monaco-vscode-theme-service-override';
-import { MonacoVscodeApiWrapper, type MonacoVscodeApiConfig } from 'monaco-languageclient/vscodeApiWrapper';
+import { LogLevel } from '@codingame/monaco-vscode-api';
 // monaco-editor does not supply json highlighting with the json worker,
 // that's why we use the textmate extension from VSCode
 import '@codingame/monaco-vscode-json-default-extension';
-import { configureDefaultWorkerFactory } from 'monaco-languageclient/workerFactory';
-import { LanguageClientWrapper, type LanguageClientConfig } from 'monaco-languageclient/lcwrapper';
+import { ConsoleLogger } from 'monaco-languageclient/tools';
+import { configureDefaultWorkerFactory } from 'monaco-editor-wrapper/workers/workerLoaders';
+import { LanguageClientWrapper, type LanguageClientConfig } from 'monaco-editor-wrapper';
 
 export const runClient = async () => {
+    const logger = new ConsoleLogger(LogLevel.Debug);
     const htmlContainer = document.getElementById('monaco-editor-root')!;
-    const vscodeApiConfig: MonacoVscodeApiConfig = {
-        $type: 'classic',
-        logLevel: LogLevel.Debug,
+    await initServices({
         serviceOverrides: {
             ...getTextmateServiceOverride(),
             ...getThemeServiceOverride()
@@ -28,11 +28,9 @@ export const runClient = async () => {
                 'editor.experimental.asyncTokenization': true
             })
         },
-        monacoWorkerFactory: configureDefaultWorkerFactory
-    };
-
-    const apiWrapper = new MonacoVscodeApiWrapper(vscodeApiConfig);
-    await apiWrapper.init();
+    }, {
+        logger
+    });
 
     // register the JSON language with Monaco
     monaco.languages.register({
@@ -42,6 +40,8 @@ export const runClient = async () => {
         mimetypes: ['application/json']
     });
 
+    configureDefaultWorkerFactory(logger);
+
     // create monaco editor
     monaco.editor.create(htmlContainer, {
         value: `{
@@ -64,9 +64,10 @@ export const runClient = async () => {
             }
         }
     };
-    const languageClientWrapper = new LanguageClientWrapper(
+    const languageClientWrapper = new LanguageClientWrapper({
         languageClientConfig,
-        apiWrapper.getLogger()
-    );
+        logger
+    });
+
     await languageClientWrapper.start();
 };

package/src/browser/main.ts

@@ -11,9 +11,8 @@ import { getLanguageService, TextDocument } from 'vscode-json-languageservice';
 import { createConverter as createCodeConverter } from 'vscode-languageclient/lib/common/codeConverter.js';
 import { createConverter as createProtocolConverter } from 'vscode-languageclient/lib/common/protocolConverter.js';
 import { LogLevel } from '@codingame/monaco-vscode-api';
-import { EditorApp, type EditorAppConfig } from 'monaco-languageclient/editorApp';
-import { configureDefaultWorkerFactory } from 'monaco-languageclient/workerFactory';
-import { MonacoVscodeApiWrapper, type MonacoVscodeApiConfig } from 'monaco-languageclient/vscodeApiWrapper';
+import { MonacoEditorLanguageClientWrapper, type WrapperConfig } from 'monaco-editor-wrapper';
+import { configureDefaultWorkerFactory } from 'monaco-editor-wrapper/workers/workerLoaders';
 
 export const runBrowserEditor = async () => {
     const codeConverter = createCodeConverter();
@@ -28,36 +27,35 @@ export const runBrowserEditor = async () => {
 }`;
     const codeUri = '/workspace/model.json';
 
-    const vscodeApiConfig: MonacoVscodeApiConfig = {
+    const wrapper = new MonacoEditorLanguageClientWrapper();
+    const jsonClientUserConfig: WrapperConfig = {
         $type: 'extended',
         htmlContainer,
         logLevel: LogLevel.Debug,
-        serviceOverrides: {
-            ...getKeybindingsServiceOverride(),
-        },
-        userConfiguration: {
-            json: JSON.stringify({
-                'workbench.colorTheme': 'Default Dark Modern',
-                'editor.guides.bracketPairsHorizontal': 'active',
-                'editor.lightbulb.enabled': 'On',
-                'editor.experimental.asyncTokenization': true
-            })
-        },
-        monacoWorkerFactory: configureDefaultWorkerFactory
-    };
-    const editorAppConfig: EditorAppConfig = {
-        $type: vscodeApiConfig.$type,
-        codeResources: {
-            modified: {
-                text: code,
-                uri: codeUri
+        vscodeApiConfig: {
+            serviceOverrides: {
+                ...getKeybindingsServiceOverride(),
+            },
+            userConfiguration: {
+                json: JSON.stringify({
+                    'workbench.colorTheme': 'Default Dark Modern',
+                    'editor.guides.bracketPairsHorizontal': 'active',
+                    'editor.lightbulb.enabled': 'On',
+                    'editor.experimental.asyncTokenization': true
+                })
             }
+        },
+        editorAppConfig: {
+            codeResources: {
+                modified: {
+                    text: code,
+                    uri: codeUri
+                }
+            },
+            monacoWorkerFactory: configureDefaultWorkerFactory
         }
     };
-    const apiWrapper = new MonacoVscodeApiWrapper(vscodeApiConfig);
-    await apiWrapper.init();
-
-    const editorApp = new EditorApp(editorAppConfig);
+    await wrapper.init(jsonClientUserConfig);
 
     vscode.workspace.onDidOpenTextDocument((_event) => {
         mainVscodeDocument = _event;
@@ -157,9 +155,9 @@ export const runBrowserEditor = async () => {
         diagnosticCollection.clear();
     };
 
-    await editorApp.start(htmlContainer);
+    await wrapper.start();
 
-    editorApp.getTextModels().modified?.onDidChangeContent(() => {
+    wrapper.getTextModels()?.modified?.onDidChangeContent(() => {
         validate();
     });
 };

package/src/clangd/client/config.ts

@@ -3,91 +3,113 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { LogLevel } from '@codingame/monaco-vscode-api';
-import getEnvironmentServiceOverride from '@codingame/monaco-vscode-environment-service-override';
-import getExplorerServiceOverride from '@codingame/monaco-vscode-explorer-service-override';
+import { Uri } from 'vscode';
 import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
 import getLifecycleServiceOverride from '@codingame/monaco-vscode-lifecycle-service-override';
-import getRemoteAgentServiceOverride from '@codingame/monaco-vscode-remote-agent-service-override';
-import getSecretStorageServiceOverride from '@codingame/monaco-vscode-secret-storage-service-override';
 import getBannerServiceOverride from '@codingame/monaco-vscode-view-banner-service-override';
 import getStatusBarServiceOverride from '@codingame/monaco-vscode-view-status-bar-service-override';
 import getTitleBarServiceOverride from '@codingame/monaco-vscode-view-title-bar-service-override';
-import type { EditorAppConfig } from 'monaco-languageclient/editorApp';
-import type { LanguageClientConfig } from 'monaco-languageclient/lcwrapper';
-import { defaultHtmlAugmentationInstructions, defaultViewsInit, type MonacoVscodeApiConfig } from 'monaco-languageclient/vscodeApiWrapper';
-import { configureDefaultWorkerFactory } from 'monaco-languageclient/workerFactory';
-import { Uri } from 'vscode';
+import getExplorerServiceOverride from '@codingame/monaco-vscode-explorer-service-override';
+import getRemoteAgentServiceOverride from '@codingame/monaco-vscode-remote-agent-service-override';
+import getEnvironmentServiceOverride from '@codingame/monaco-vscode-environment-service-override';
+import getSecretStorageServiceOverride from '@codingame/monaco-vscode-secret-storage-service-override';
+import { LogLevel } from '@codingame/monaco-vscode-api';
+import type { WrapperConfig } from 'monaco-editor-wrapper';
+import { configureDefaultWorkerFactory } from 'monaco-editor-wrapper/workers/workerLoaders';
+import { defaultHtmlAugmentationInstructions, defaultViewsInit } from 'monaco-editor-wrapper/vscode/services';
 import { ClangdWorkerHandler } from './workerHandler.js';
 
-export type ClangdAppConfig = {
-    languageClientConfig: LanguageClientConfig;
-    vscodeApiConfig: MonacoVscodeApiConfig;
-    editorAppConfig: EditorAppConfig;
-}
-
-export const createClangdAppConfig = async (config: {
+export const createWrapperConfig = async (config: {
     htmlContainer: HTMLElement,
     workspaceUri: Uri,
     workspaceFileUri: Uri,
     clangdWorkerHandler: ClangdWorkerHandler,
     lsMessageLocalPort: MessagePort
-}): Promise<ClangdAppConfig> => {
-    const vscodeApiConfig: MonacoVscodeApiConfig = {
+}): Promise<WrapperConfig> => {
+    return {
         $type: 'extended',
         htmlContainer: config.htmlContainer,
         logLevel: LogLevel.Debug,
-        serviceOverrides: {
-            ...getKeybindingsServiceOverride(),
-            ...getLifecycleServiceOverride(),
-            ...getBannerServiceOverride(),
-            ...getStatusBarServiceOverride(),
-            ...getTitleBarServiceOverride(),
-            ...getExplorerServiceOverride(),
-            ...getRemoteAgentServiceOverride(),
-            ...getEnvironmentServiceOverride(),
-            ...getSecretStorageServiceOverride()
-        },
-        viewsConfig: {
-            viewServiceType: 'ViewsService',
-            htmlAugmentationInstructions: defaultHtmlAugmentationInstructions,
-            viewsInitFunc: defaultViewsInit
+        languageClientConfigs: {
+            configs: {
+                LANGUAGE_ID: {
+                    name: 'Clangd WASM Language Server',
+                    connection: {
+                        options: {
+                            $type: 'WorkerDirect',
+                            worker: await config.clangdWorkerHandler.createWorker(),
+                            messagePort: config.lsMessageLocalPort
+                        }
+                    },
+                    restartOptions: {
+                        retries: 5,
+                        timeout: 1000,
+                        keepWorker: true
+                    },
+                    clientOptions: {
+                        documentSelector: ['cpp'],
+                        workspaceFolder: {
+                            index: 0,
+                            name: 'workspace',
+                            uri: config.workspaceUri
+                        }
+                    }
+                }
+            }
         },
-        workspaceConfig: {
-            enableWorkspaceTrust: true,
-            windowIndicator: {
-                label: 'mlc-clangd-example',
-                tooltip: '',
-                command: ''
+        vscodeApiConfig: {
+            serviceOverrides: {
+                ...getKeybindingsServiceOverride(),
+                ...getLifecycleServiceOverride(),
+                ...getBannerServiceOverride(),
+                ...getStatusBarServiceOverride(),
+                ...getTitleBarServiceOverride(),
+                ...getExplorerServiceOverride(),
+                ...getRemoteAgentServiceOverride(),
+                ...getEnvironmentServiceOverride(),
+                ...getSecretStorageServiceOverride()
             },
-            workspaceProvider: {
-                trusted: true,
-                async open() {
-                    window.open(window.location.href);
-                    return true;
+            viewsConfig: {
+                viewServiceType: 'ViewsService',
+                htmlAugmentationInstructions: defaultHtmlAugmentationInstructions,
+                viewsInitFunc: defaultViewsInit
+            },
+            workspaceConfig: {
+                enableWorkspaceTrust: true,
+                windowIndicator: {
+                    label: 'mlc-clangd-example',
+                    tooltip: '',
+                    command: ''
                 },
-                workspace: {
-                    workspaceUri: config.workspaceFileUri
+                workspaceProvider: {
+                    trusted: true,
+                    async open() {
+                        window.open(window.location.href);
+                        return true;
+                    },
+                    workspace: {
+                        workspaceUri: config.workspaceFileUri
+                    },
                 },
+                configurationDefaults: {
+                    'window.title': 'mlc-clangd-exampled${separator}${dirty}${activeEditorShort}'
+                },
+                productConfiguration: {
+                    nameShort: 'mlc-clangd-example',
+                    nameLong: 'mlc-clangd-example'
+                }
             },
-            configurationDefaults: {
-                'window.title': 'mlc-clangd-exampled${separator}${dirty}${activeEditorShort}'
-            },
-            productConfiguration: {
-                nameShort: 'mlc-clangd-example',
-                nameLong: 'mlc-clangd-example'
+            userConfiguration: {
+                json: JSON.stringify({
+                    'workbench.colorTheme': 'Default Dark Modern',
+                    'editor.wordBasedSuggestions': 'off',
+                    'editor.guides.bracketPairsHorizontal': true,
+                    'editor.inlayHints.enabled': 'offUnlessPressed',
+                    'editor.quickSuggestionsDelay': 200,
+                    'editor.experimental.asyncTokenization': false
+                })
             }
         },
-        userConfiguration: {
-            json: JSON.stringify({
-                'workbench.colorTheme': 'Default Dark Modern',
-                'editor.wordBasedSuggestions': 'off',
-                'editor.guides.bracketPairsHorizontal': true,
-                'editor.inlayHints.enabled': 'offUnlessPressed',
-                'editor.quickSuggestionsDelay': 200,
-                'editor.experimental.asyncTokenization': false
-            })
-        },
         extensions: [{
             config: {
                 name: 'mlc-clangd-example',
@@ -98,40 +120,8 @@ export const createClangdAppConfig = async (config: {
                 }
             }
         }],
-        monacoWorkerFactory: configureDefaultWorkerFactory
-    };
-
-    const languageClientConfig: LanguageClientConfig = {
-        name: 'Clangd WASM Language Server',
-        connection: {
-            options: {
-                $type: 'WorkerDirect',
-                worker: await config.clangdWorkerHandler.createWorker(),
-                messagePort: config.lsMessageLocalPort
-            }
-        },
-        restartOptions: {
-            retries: 5,
-            timeout: 1000,
-            keepWorker: true
-        },
-        clientOptions: {
-            documentSelector: ['cpp'],
-            workspaceFolder: {
-                index: 0,
-                name: 'workspace',
-                uri: config.workspaceUri
-            }
+        editorAppConfig: {
+            monacoWorkerFactory: configureDefaultWorkerFactory
         }
     };
-
-    const editorAppConfig: EditorAppConfig = {
-        $type: vscodeApiConfig.$type
-    };
-
-    return {
-        vscodeApiConfig,
-        languageClientConfig,
-        editorAppConfig
-    };
 };

package/src/clangd/client/main.ts

@@ -3,17 +3,18 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { RegisteredFileSystemProvider, RegisteredMemoryFile, registerFileSystemOverlay } from '@codingame/monaco-vscode-files-service-override';
 import * as vscode from 'vscode';
+import { RegisteredFileSystemProvider, RegisteredMemoryFile, registerFileSystemOverlay } from '@codingame/monaco-vscode-files-service-override';
 // this is required syntax highlighting
 import '@codingame/monaco-vscode-cpp-default-extension';
-import { LanguageClientWrapper } from 'monaco-languageclient/lcwrapper';
-import { MonacoVscodeApiWrapper } from 'monaco-languageclient/vscodeApiWrapper';
+import { MonacoEditorLanguageClientWrapper } from 'monaco-editor-wrapper';
+import { createWrapperConfig } from './config.js';
+import { ClangdWorkerHandler } from './workerHandler.js';
+import { MainRemoteMessageChannelFs } from './mainRemoteMessageChannelFs.js';
 import { createDefaultWorkspaceContent, disableElement } from '../../common/client/utils.js';
 import { HOME_DIR, WORKSPACE_PATH } from '../definitions.js';
-import { createClangdAppConfig } from './config.js';
-import { MainRemoteMessageChannelFs } from './mainRemoteMessageChannelFs.js';
-import { ClangdWorkerHandler } from './workerHandler.js';
+
+const wrapper = new MonacoEditorLanguageClientWrapper();
 
 export const runClangdWrapper = async () => {
     const channelLs = new MessageChannel();
@@ -31,7 +32,7 @@ export const runClangdWrapper = async () => {
     new MainRemoteMessageChannelFs(fileSystemProvider, channelFs.port1, readiness);
 
     const clangdWorkerHandler = new ClangdWorkerHandler();
-    const appConfig = await createClangdAppConfig({
+    const wrapperConfig = await createWrapperConfig({
         htmlContainer: document.body,
         workspaceUri: vscode.Uri.file(WORKSPACE_PATH),
         workspaceFileUri,
@@ -39,12 +40,7 @@ export const runClangdWrapper = async () => {
         lsMessageLocalPort: channelLs.port1
     });
 
-    // perform global init
-    const apiWrapper = new MonacoVscodeApiWrapper(appConfig.vscodeApiConfig);
-    await apiWrapper.init();
-
-    const lcWrapper = new LanguageClientWrapper(appConfig.languageClientConfig);
-
+    await wrapper.init(wrapperConfig);
     const initConfig = {
         lsMessagePort: channelLs.port2,
         fsMessagePort: channelFs.port2,
@@ -57,7 +53,7 @@ export const runClangdWrapper = async () => {
     const startWrapper = async () => {
         await clangdWorkerHandler.init(initConfig);
         await clangdWorkerHandler.launch();
-        await lcWrapper.start();
+        await wrapper.startLanguageClients();
     };
 
     try {

package/src/clangd/worker/clangd-server.ts

@@ -104,7 +104,7 @@ export class ClangdInteractionWorker implements ComRouter {
         // Pre-fetch wasm file
         const wasmReader = (await fetch(clangdWasmUrl)).body!.getReader();
 
-        const chunks: Uint8Array[] = [];
+        const chunks: BlobPart[] = [];
         let loadingComplete = false;
         while (!loadingComplete) {
             const { done, value } = await wasmReader.read();
@@ -446,7 +446,7 @@ export class ClangdInteractionWorker implements ComRouter {
                 const content = this.emscriptenFS.readFile(filename, { encoding: 'binary' });
                 allPromises.push(this.remoteFs.syncFile({
                     resourceUri: filename,
-                    content: content
+                    content: content as unknown as ArrayBufferLike
                 }));
 
             } catch (e) {

package/src/common/client/utils.ts

@@ -4,9 +4,6 @@
  * ------------------------------------------------------------------------------------------ */
 
 import type { IStoredWorkspace } from '@codingame/monaco-vscode-configuration-service-override';
-import type { EditorAppConfig } from 'monaco-languageclient/editorApp';
-import type { LanguageClientConfig } from 'monaco-languageclient/lcwrapper';
-import type { MonacoVscodeApiConfig } from 'monaco-languageclient/vscodeApiWrapper';
 
 export const disableElement = (id: string, disabled: boolean) => {
     const button = document.getElementById(id) as HTMLButtonElement | HTMLInputElement | null;
@@ -29,8 +26,6 @@ export const createDefaultWorkspaceContent = (workspacePath: string) => {
     );
 };
 
-export type ExampleAppConfig = {
-    vscodeApiConfig: MonacoVscodeApiConfig;
-    languageClientConfig: LanguageClientConfig;
-    editorAppConfig: EditorAppConfig;
+export const delayExecution = (ms: number) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
 };

package/src/debugger/client/debugger.ts

@@ -4,7 +4,7 @@
  * ------------------------------------------------------------------------------------------ */
 
 import * as vscode from 'vscode';
-import type { ExtensionConfig } from 'monaco-languageclient/vscodeApiWrapper';
+import type { ExtensionConfig } from 'monaco-editor-wrapper';
 import type { ConfigParams, InitMessage } from '../common/definitions.js';
 
 // This is derived from:

package/src/eclipse.jdt.ls/client/main.ts

@@ -3,12 +3,86 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
+import * as vscode from 'vscode';
+import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
+import { RegisteredFileSystemProvider, RegisteredMemoryFile, registerFileSystemOverlay } from '@codingame/monaco-vscode-files-service-override';
 // this is required syntax highlighting
 import '@codingame/monaco-vscode-java-default-extension';
-import helloJavaCode from '../../../resources/eclipse.jdt.ls/workspace/hello.java?raw';
-import { runExtendedClient } from '../../common/client/extendedClient.js';
+import { LogLevel } from '@codingame/monaco-vscode-api';
+import { MonacoEditorLanguageClientWrapper, type WrapperConfig } from 'monaco-editor-wrapper';
+import { configureDefaultWorkerFactory } from 'monaco-editor-wrapper/workers/workerLoaders';
 import { eclipseJdtLsConfig } from '../config.js';
+import helloJavaCode from '../../../resources/eclipse.jdt.ls/workspace/hello.java?raw';
+
+export const runEclipseJdtLsClient = () => {
+    const helloJavaUri = vscode.Uri.file(`${eclipseJdtLsConfig.basePath}/workspace/hello.java`);
+    const fileSystemProvider = new RegisteredFileSystemProvider(false);
+    fileSystemProvider.registerFile(new RegisteredMemoryFile(helloJavaUri, helloJavaCode));
+    registerFileSystemOverlay(1, fileSystemProvider);
+
+    const wrapperConfig: WrapperConfig = {
+        $type: 'extended',
+        htmlContainer: document.getElementById('monaco-editor-root')!,
+        logLevel: LogLevel.Debug,
+        vscodeApiConfig: {
+            serviceOverrides: {
+                ...getKeybindingsServiceOverride(),
+            },
+            userConfiguration: {
+                json: JSON.stringify({
+                    'workbench.colorTheme': 'Default Dark Modern',
+                    'editor.guides.bracketPairsHorizontal': 'active',
+                    'editor.wordBasedSuggestions': 'off',
+                    'editor.experimental.asyncTokenization': true
+                })
+            }
+        },
+        editorAppConfig: {
+            codeResources: {
+                modified: {
+                    text: helloJavaCode,
+                    uri: `${eclipseJdtLsConfig.basePath}/workspace/hello.java`
+                }
+            },
+            monacoWorkerFactory: configureDefaultWorkerFactory
+        },
+        languageClientConfigs: {
+            configs: {
+                java: {
+                    connection: {
+                        options: {
+                            $type: 'WebSocketUrl',
+                            url: 'ws://localhost:30003/jdtls'
+                        }
+                    },
+                    clientOptions: {
+                        documentSelector: ['java'],
+                        workspaceFolder: {
+                            index: 0,
+                            name: 'workspace',
+                            uri: vscode.Uri.parse(`${eclipseJdtLsConfig.basePath}/workspace`)
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    const wrapper = new MonacoEditorLanguageClientWrapper();
+
+    try {
+        document.querySelector('#button-start')?.addEventListener('click', async () => {
+            await wrapper.init(wrapperConfig);
+
+            // open files, so the LS can pick it up
+            await vscode.workspace.openTextDocument(helloJavaUri);
 
-export const runEclipseJdtLsClient = async () => {
-    await runExtendedClient(eclipseJdtLsConfig, helloJavaCode);
+            await wrapper.start();
+        });
+        document.querySelector('#button-dispose')?.addEventListener('click', async () => {
+            await wrapper.dispose();
+        });
+    } catch (e) {
+        console.error(e);
+    }
 };

package/src/eclipse.jdt.ls/config.ts

@@ -2,12 +2,8 @@
  * Copyright (c) 2024 TypeFox and others.
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
-
-import type { ExampleLsConfig } from '../common/client/extendedClient.js';
-
-export const eclipseJdtLsConfig: ExampleLsConfig = {
+export const eclipseJdtLsConfig = {
     port: 30003,
     path: '/jdtls',
-    basePath: '/home/mlc/packages/examples/resources/eclipse.jdt.ls',
-    documentSelector: 'java'
+    basePath: '/home/mlc/packages/examples/resources/eclipse.jdt.ls'
 };

package/src/groovy/client/main.ts

@@ -3,12 +3,73 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
+import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
 // this is required syntax highlighting
 import '@codingame/monaco-vscode-groovy-default-extension';
-import helloGroovyCode from '../../../resources/groovy/workspace/hello.groovy?raw';
-import { runExtendedClient } from '../../common/client/extendedClient.js';
+import { LogLevel } from '@codingame/monaco-vscode-api';
+import { MonacoEditorLanguageClientWrapper, type WrapperConfig } from 'monaco-editor-wrapper';
+import { configureDefaultWorkerFactory } from 'monaco-editor-wrapper/workers/workerLoaders';
 import { groovyConfig } from '../config.js';
 
-export const runGroovyClient = async () => {
-    await runExtendedClient(groovyConfig, helloGroovyCode);
+const code = `package test.org;
+import java.io.File;
+File file = new File("E:/Example.txt");
+`;
+
+const wrapperConfig: WrapperConfig = {
+    $type: 'extended',
+    htmlContainer: document.getElementById('monaco-editor-root')!,
+    logLevel: LogLevel.Debug,
+    vscodeApiConfig: {
+        serviceOverrides: {
+            ...getKeybindingsServiceOverride(),
+        },
+        userConfiguration: {
+            json: JSON.stringify({
+                'workbench.colorTheme': 'Default Dark Modern',
+                'editor.guides.bracketPairsHorizontal': 'active',
+                'editor.wordBasedSuggestions': 'off',
+                'editor.experimental.asyncTokenization': true
+            })
+        }
+    },
+    editorAppConfig: {
+        codeResources: {
+            modified: {
+                text: code,
+                uri: '/workspace/test.groovy'
+            }
+        },
+        monacoWorkerFactory: configureDefaultWorkerFactory
+    },
+    languageClientConfigs: {
+        configs: {
+            groovy: {
+                clientOptions: {
+                    documentSelector: ['groovy']
+                },
+                connection: {
+                    options: {
+                        $type: 'WebSocketUrl',
+                        url: `ws://localhost:${groovyConfig.port}${groovyConfig.path}`
+                    }
+                }
+            }
+        }
+    }
+};
+
+export const runGroovyClient = () => {
+    const wrapper = new MonacoEditorLanguageClientWrapper();
+
+    try {
+        document.querySelector('#button-start')?.addEventListener('click', async () => {
+            await wrapper.initAndStart(wrapperConfig);
+        });
+        document.querySelector('#button-dispose')?.addEventListener('click', async () => {
+            await wrapper.dispose();
+        });
+    } catch (e) {
+        console.error(e);
+    }
 };