monaco-languageclient-examples 2025.8.2 → 2025.8.4

package/src/clangd/client/config.ts

@@ -3,113 +3,91 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { Uri } from 'vscode';
+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 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 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 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 { ClangdWorkerHandler } from './workerHandler.js';
 
-export const createWrapperConfig = async (config: {
+export type ClangdAppConfig = {
+    languageClientConfig: LanguageClientConfig;
+    vscodeApiConfig: MonacoVscodeApiConfig;
+    editorAppConfig: EditorAppConfig;
+}
+
+export const createClangdAppConfig = async (config: {
     htmlContainer: HTMLElement,
     workspaceUri: Uri,
     workspaceFileUri: Uri,
     clangdWorkerHandler: ClangdWorkerHandler,
     lsMessageLocalPort: MessagePort
-}): Promise<WrapperConfig> => {
-    return {
+}): Promise<ClangdAppConfig> => {
+    const vscodeApiConfig: MonacoVscodeApiConfig = {
         $type: 'extended',
         htmlContainer: config.htmlContainer,
         logLevel: LogLevel.Debug,
-        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
-                        }
-                    }
-                }
-            }
+        serviceOverrides: {
+            ...getKeybindingsServiceOverride(),
+            ...getLifecycleServiceOverride(),
+            ...getBannerServiceOverride(),
+            ...getStatusBarServiceOverride(),
+            ...getTitleBarServiceOverride(),
+            ...getExplorerServiceOverride(),
+            ...getRemoteAgentServiceOverride(),
+            ...getEnvironmentServiceOverride(),
+            ...getSecretStorageServiceOverride()
         },
-        vscodeApiConfig: {
-            serviceOverrides: {
-                ...getKeybindingsServiceOverride(),
-                ...getLifecycleServiceOverride(),
-                ...getBannerServiceOverride(),
-                ...getStatusBarServiceOverride(),
-                ...getTitleBarServiceOverride(),
-                ...getExplorerServiceOverride(),
-                ...getRemoteAgentServiceOverride(),
-                ...getEnvironmentServiceOverride(),
-                ...getSecretStorageServiceOverride()
-            },
-            viewsConfig: {
-                viewServiceType: 'ViewsService',
-                htmlAugmentationInstructions: defaultHtmlAugmentationInstructions,
-                viewsInitFunc: defaultViewsInit
+        viewsConfig: {
+            viewServiceType: 'ViewsService',
+            htmlAugmentationInstructions: defaultHtmlAugmentationInstructions,
+            viewsInitFunc: defaultViewsInit
+        },
+        workspaceConfig: {
+            enableWorkspaceTrust: true,
+            windowIndicator: {
+                label: 'mlc-clangd-example',
+                tooltip: '',
+                command: ''
             },
-            workspaceConfig: {
-                enableWorkspaceTrust: true,
-                windowIndicator: {
-                    label: 'mlc-clangd-example',
-                    tooltip: '',
-                    command: ''
-                },
-                workspaceProvider: {
-                    trusted: true,
-                    async open() {
-                        window.open(window.location.href);
-                        return true;
-                    },
-                    workspace: {
-                        workspaceUri: config.workspaceFileUri
-                    },
+            workspaceProvider: {
+                trusted: true,
+                async open() {
+                    window.open(window.location.href);
+                    return true;
                 },
-                configurationDefaults: {
-                    'window.title': 'mlc-clangd-exampled${separator}${dirty}${activeEditorShort}'
+                workspace: {
+                    workspaceUri: config.workspaceFileUri
                 },
-                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
-                })
+            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
+            })
+        },
         extensions: [{
             config: {
                 name: 'mlc-clangd-example',
@@ -120,8 +98,40 @@ export const createWrapperConfig = async (config: {
                 }
             }
         }],
-        editorAppConfig: {
-            monacoWorkerFactory: configureDefaultWorkerFactory
+        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
+            }
         }
     };
+
+    const editorAppConfig: EditorAppConfig = {
+        $type: vscodeApiConfig.$type
+    };
+
+    return {
+        vscodeApiConfig,
+        languageClientConfig,
+        editorAppConfig
+    };
 };

package/src/clangd/client/main.ts

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

package/src/common/client/extendedClient.ts

@@ -0,0 +1,111 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2025 TypeFox and others.
+ * 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 getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
+import * as vscode from 'vscode';
+// this is required syntax highlighting
+import { LogLevel } from '@codingame/monaco-vscode-api';
+import '@codingame/monaco-vscode-java-default-extension';
+import { EditorApp, type EditorAppConfig } from 'monaco-languageclient/editorApp';
+import { configureDefaultWorkerFactory } from 'monaco-languageclient/workerFactory';
+import { LanguageClientWrapper, type LanguageClientConfig } from 'monaco-languageclient/lcwrapper';
+import { MonacoVscodeApiWrapper, type MonacoVscodeApiConfig } from 'monaco-languageclient/vscodeApiWrapper';
+
+export const runExtendedClient = async (lsConfig: ExampleLsConfig, helloCode: string) => {
+    const helloUri = vscode.Uri.file(`${lsConfig.basePath}/workspace/hello.${lsConfig.documentSelector}`);
+    const fileSystemProvider = new RegisteredFileSystemProvider(false);
+    fileSystemProvider.registerFile(new RegisteredMemoryFile(helloUri, helloCode));
+    registerFileSystemOverlay(1, fileSystemProvider);
+
+    const htmlContainer = document.getElementById('monaco-editor-root')!;
+    const vscodeApiConfig: MonacoVscodeApiConfig = {
+        $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.wordBasedSuggestions': 'off',
+                'editor.experimental.asyncTokenization': true
+            })
+        },
+        monacoWorkerFactory: configureDefaultWorkerFactory
+    };
+
+    const languageClientConfig: LanguageClientConfig = {
+        connection: {
+            options: {
+                $type: 'WebSocketUrl',
+                url: `ws://localhost:${lsConfig.port}${lsConfig.path}`,
+                startOptions: {
+                    onCall: () => {
+                        console.log('Connected to socket.');
+                    },
+                    reportStatus: true
+                },
+                stopOptions: {
+                    onCall: () => {
+                        console.log('Disconnected from socket.');
+                    },
+                    reportStatus: true
+                }
+            },
+        },
+        clientOptions: {
+            documentSelector: [lsConfig.documentSelector],
+            workspaceFolder: {
+                index: 0,
+                name: 'workspace',
+                uri: vscode.Uri.parse(`${lsConfig.basePath}/workspace`)
+            }
+        }
+    };
+
+    const editorAppConfig: EditorAppConfig = {
+        $type: vscodeApiConfig.$type,
+        codeResources: {
+            modified: {
+                text: helloCode,
+                uri: helloUri.path
+            }
+        }
+    };
+
+    // perform global init
+    const apiWrapper = new MonacoVscodeApiWrapper(vscodeApiConfig);
+    await apiWrapper.init();
+
+    const lcWrapper = new LanguageClientWrapper(languageClientConfig, apiWrapper.getLogger());
+    const editorApp = new EditorApp(editorAppConfig);
+
+    try {
+        document.querySelector('#button-start')?.addEventListener('click', async () => {
+            await editorApp.start(htmlContainer);
+            await lcWrapper.start();
+
+            // open files, so the LS can pick it up
+            await vscode.workspace.openTextDocument(helloUri);
+        });
+        document.querySelector('#button-dispose')?.addEventListener('click', async () => {
+            await editorApp.dispose();
+            await lcWrapper.dispose();
+        });
+    } catch (e) {
+        console.error(e);
+    }
+};
+
+export type ExampleLsConfig = {
+    port: number;
+    path: string;
+    basePath: string;
+    documentSelector: string;
+};

package/src/common/client/utils.ts

@@ -4,6 +4,9 @@
  * ------------------------------------------------------------------------------------------ */
 
 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;
@@ -26,6 +29,8 @@ export const createDefaultWorkspaceContent = (workspacePath: string) => {
     );
 };
 
-export const delayExecution = (ms: number) => {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+export type ExampleAppConfig = {
+    vscodeApiConfig: MonacoVscodeApiConfig;
+    languageClientConfig: LanguageClientConfig;
+    editorAppConfig: EditorAppConfig;
 };

package/src/debugger/client/debugger.ts

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

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

@@ -3,86 +3,12 @@
  * 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 { 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';
+import { runExtendedClient } from '../../common/client/extendedClient.js';
+import { eclipseJdtLsConfig } from '../config.js';
 
-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);
-
-            await wrapper.start();
-        });
-        document.querySelector('#button-dispose')?.addEventListener('click', async () => {
-            await wrapper.dispose();
-        });
-    } catch (e) {
-        console.error(e);
-    }
+export const runEclipseJdtLsClient = async () => {
+    await runExtendedClient(eclipseJdtLsConfig, helloJavaCode);
 };

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

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

package/src/groovy/client/main.ts

@@ -3,73 +3,12 @@
  * 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 { LogLevel } from '@codingame/monaco-vscode-api';
-import { MonacoEditorLanguageClientWrapper, type WrapperConfig } from 'monaco-editor-wrapper';
-import { configureDefaultWorkerFactory } from 'monaco-editor-wrapper/workers/workerLoaders';
+import helloGroovyCode from '../../../resources/groovy/workspace/hello.groovy?raw';
+import { runExtendedClient } from '../../common/client/extendedClient.js';
 import { groovyConfig } from '../config.js';
 
-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);
-    }
+export const runGroovyClient = async () => {
+    await runExtendedClient(groovyConfig, helloGroovyCode);
 };

package/src/groovy/config.ts

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

package/src/json/client/client.ts

@@ -0,0 +1,14 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2025 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+// this is required syntax highlighting
+import '@codingame/monaco-vscode-json-default-extension';
+import helloJsonCode from '../../../resources/json/workspace/hello.json?raw';
+import { runExtendedClient } from '../../common/client/extendedClient.js';
+import { jsontLsConfig } from './config.js';
+
+export const runJsonWrapper = async () => {
+    await runExtendedClient(jsontLsConfig, helloJsonCode);
+};

package/src/json/client/config.ts

@@ -0,0 +1,13 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2025 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 jsontLsConfig: ExampleLsConfig = {
+    port: 30000,
+    path: '/sampleServer',
+    basePath: '/home/mlc/packages/examples/resources/json',
+    documentSelector: 'json'
+};

package/src/json/server/main.ts

@@ -36,7 +36,7 @@ export const startMockHttpServerForSavingCodeFromEditor = () => {
     app.post('/save-code', (req, res) => {
         const { code } = req.body;
         console.log('Received code:', code);
-        res.json({ success: true, message: code});
+        res.json({ success: true, message: code });
     });
 
     const PORT = 3003;