monaco-languageclient-examples 8.3.1 → 8.4.1

package/src/common/client/localeLoader.ts

@@ -0,0 +1,61 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+export const initLocalLoader = async () => {
+    const locale = new URLSearchParams(window.location.search).get('locale');
+    const localeLoader: Partial<Record<string, () => Promise<void>>> = {
+        cs: async () => {
+            await import('@codingame/monaco-vscode-language-pack-cs');
+        },
+        de: async () => {
+            await import('@codingame/monaco-vscode-language-pack-de');
+        },
+        es: async () => {
+            await import('@codingame/monaco-vscode-language-pack-es');
+        },
+        fr: async () => {
+            await import('@codingame/monaco-vscode-language-pack-fr');
+        },
+        it: async () => {
+            await import('@codingame/monaco-vscode-language-pack-it');
+        },
+        ja: async () => {
+            await import('@codingame/monaco-vscode-language-pack-ja');
+        },
+        ko: async () => {
+            await import('@codingame/monaco-vscode-language-pack-ko');
+        },
+        pl: async () => {
+            await import('@codingame/monaco-vscode-language-pack-pl');
+        },
+        'pt-br': async () => {
+            await import('@codingame/monaco-vscode-language-pack-pt-br');
+        },
+        'qps-ploc': async () => {
+            await import('@codingame/monaco-vscode-language-pack-qps-ploc');
+        },
+        ru: async () => {
+            await import('@codingame/monaco-vscode-language-pack-ru');
+        },
+        tr: async () => {
+            await import('@codingame/monaco-vscode-language-pack-tr');
+        },
+        'zh-hans': async () => {
+            await import('@codingame/monaco-vscode-language-pack-zh-hans');
+        },
+        'zh-hant': async () => {
+            await import('@codingame/monaco-vscode-language-pack-zh-hant');
+        }
+    };
+
+    if (locale !== null) {
+        const loader = localeLoader[locale];
+        if (loader) {
+            await loader();
+        } else {
+            console.error(`Unknown locale ${locale}`);
+        }
+    }
+};

package/src/common/{language-server-runner.ts → node/language-server-runner.ts}

@@ -4,16 +4,15 @@
  * ------------------------------------------------------------------------------------------ */
 
 import { WebSocketServer } from 'ws';
-import { Server } from 'http';
+import { Server } from 'node:http';
 import express from 'express';
-import { getLocalDirectory } from '../utils/fs-utils.js';
-import { LanguageServerRunConfig, upgradeWsServer } from './server-commons.js';
+import { getLocalDirectory, LanguageServerRunConfig, upgradeWsServer } from './server-commons.js';
 
 /** LSP server runner */
 export const runLanguageServer = (
     languageServerRunConfig: LanguageServerRunConfig
 ) => {
-    process.on('uncaughtException', function(err) {
+    process.on('uncaughtException', err => {
         console.error('Uncaught Exception: ', err.toString());
         if (err.stack) {
             console.error(err.stack);

package/src/common/{server-commons.ts → node/server-commons.ts}

@@ -3,9 +3,11 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 import { WebSocketServer, ServerOptions } from 'ws';
-import { IncomingMessage, Server } from 'http';
-import { URL } from 'url';
-import { Socket } from 'net';
+import { IncomingMessage, Server } from 'node:http';
+import { URL } from 'node:url';
+import { Socket } from 'node:net';
+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';
@@ -93,3 +95,11 @@ export const upgradeWsServer = (runconfig: LanguageServerRunConfig,
         }
     });
 };
+
+/**
+ * Solves: __dirname is not defined in ES module scope
+ */
+export const getLocalDirectory = (referenceUrl: string | URL) => {
+    const __filename = fileURLToPath(referenceUrl);
+    return dirname(__filename);
+};

package/src/groovy/client/main.ts

@@ -6,8 +6,7 @@
 import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
 // this is required syntax highlighting
 import '@codingame/monaco-vscode-groovy-default-extension';
-import { disposeEditor, startEditor } from '../../common/example-apps-common.js';
-import { UserConfig } from 'monaco-editor-wrapper';
+import { MonacoEditorLanguageClientWrapper, UserConfig } from 'monaco-editor-wrapper';
 import { groovyConfig } from '../config.js';
 import { useWorkerFactory } from 'monaco-editor-wrapper/workerFactory';
 
@@ -32,8 +31,12 @@ const userConfig: UserConfig = {
         },
         editorAppConfig: {
             $type: 'extended',
-            languageId: 'groovy',
-            code,
+            codeResources: {
+                main: {
+                    text: code,
+                    fileExt: 'groovy'
+                }
+            },
             useDiffEditor: false,
             userConfiguration: {
                 json: JSON.stringify({
@@ -44,6 +47,7 @@ const userConfig: UserConfig = {
         }
     },
     languageClientConfig: {
+        languageId: 'groovy',
         options: {
             $type: 'WebSocketUrl',
             url: `ws://localhost:${groovyConfig.port}${groovyConfig.path}`
@@ -52,13 +56,16 @@ const userConfig: UserConfig = {
 };
 
 export const runGroovyClient = () => {
+    const wrapper = new MonacoEditorLanguageClientWrapper();
+    const htmlElement = document.getElementById('monaco-editor-root');
+
     try {
-        const htmlElement = document.getElementById('monaco-editor-root');
-        document.querySelector('#button-start')?.addEventListener('click', () => {
-            startEditor(userConfig, htmlElement, code);
+        document.querySelector('#button-start')?.addEventListener('click', async () => {
+            await wrapper.dispose();
+            await wrapper.initAndStart(userConfig, htmlElement);
         });
         document.querySelector('#button-dispose')?.addEventListener('click', async () => {
-            await disposeEditor(userConfig.wrapperConfig.editorAppConfig.useDiffEditor);
+            await wrapper.dispose();
         });
     } catch (e) {
         console.error(e);

package/src/groovy/server/direct.ts

@@ -3,11 +3,11 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { resolve } from 'path';
-import { getLocalDirectory } from '../../utils/fs-utils.js';
+import { resolve } from 'node:path';
 import { runGroovyLanguageServer } from './main.js';
-const baseDir = resolve(getLocalDirectory(import.meta.url));
+import { getLocalDirectory } from '../../common/node/server-commons.js';
 
+const baseDir = resolve(getLocalDirectory(import.meta.url));
 const groovyJar = resolve(baseDir, '../../../resources/groovy/external/groovy-language-server-all.jar');
 const relativeDir = process.env.LANG_SERVER_JAR_PATH || groovyJar;
 console.log(`basedir: ${baseDir}`);

package/src/groovy/server/main.ts

@@ -3,10 +3,10 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { runLanguageServer } from '../../common/language-server-runner.js';
-import { resolve } from 'path';
+import { resolve } from 'node:path';
+import { runLanguageServer } from '../../common/node/language-server-runner.js';
+import { LanguageName } from '../../common/node/server-commons.js';
 import { groovyConfig } from '../config.js';
-import { LanguageName } from '../../common/server-commons.js';
 
 export const runGroovyLanguageServer = (baseDir: string, relativeDir: string) => {
     const processRunPath = resolve(baseDir, relativeDir);

package/src/index.ts

@@ -4,5 +4,5 @@
  * ------------------------------------------------------------------------------------------ */
 
 /* client side export only */
-export * from './common/example-apps-common.js';
-
+export * from './common/client/app-utils.js';
+export * from './common/client/localeLoader.js';

package/src/json/client/wrapperWs.ts

@@ -5,9 +5,8 @@
 
 import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
 // this is required syntax highlighting
-import  '@codingame/monaco-vscode-json-default-extension';
-import { disposeEditor, startEditor, swapEditors } from '../../common/example-apps-common.js';
-import { UserConfig } from 'monaco-editor-wrapper';
+import '@codingame/monaco-vscode-json-default-extension';
+import { MonacoEditorLanguageClientWrapper, UserConfig } from 'monaco-editor-wrapper';
 import { useWorkerFactory } from 'monaco-editor-wrapper/workerFactory';
 
 export const configureMonacoWorkers = () => {
@@ -20,11 +19,7 @@ export const configureMonacoWorkers = () => {
     });
 };
 
-let codeMain = `{
-    "$schema": "http://json.schemastore.org/coffeelint",
-    "line_endings": {"value": "windows"}
-}`;
-const codeOrg = `{
+const text = `{
     "$schema": "http://json.schemastore.org/coffeelint",
     "line_endings": {"value": "unix"}
 }`;
@@ -39,10 +34,13 @@ export const jsonClientUserConfig: UserConfig = {
         },
         editorAppConfig: {
             $type: 'extended',
-            languageId: 'json',
-            code: codeMain,
+            codeResources: {
+                main: {
+                    text,
+                    fileExt: 'json'
+                }
+            },
             useDiffEditor: false,
-            codeOriginal: codeOrg,
             userConfiguration: {
                 json: JSON.stringify({
                     'workbench.colorTheme': 'Default Dark Modern',
@@ -53,6 +51,7 @@ export const jsonClientUserConfig: UserConfig = {
         }
     },
     languageClientConfig: {
+        languageId: 'json',
         options: {
             $type: 'WebSocketUrl',
             url: 'ws://localhost:30000/sampleServer',
@@ -73,16 +72,16 @@ export const jsonClientUserConfig: UserConfig = {
 };
 
 export const runJsonWrapper = () => {
+    const wrapper = new MonacoEditorLanguageClientWrapper();
+    const htmlElement = document.getElementById('monaco-editor-root');
+
     try {
-        const htmlElement = document.getElementById('monaco-editor-root');
-        document.querySelector('#button-start')?.addEventListener('click', () => {
-            startEditor(jsonClientUserConfig, htmlElement, codeMain, codeOrg);
-        });
-        document.querySelector('#button-swap')?.addEventListener('click', () => {
-            swapEditors(jsonClientUserConfig, htmlElement, codeMain, codeOrg);
+        document.querySelector('#button-start')?.addEventListener('click', async () => {
+            await wrapper.dispose();
+            await wrapper.initAndStart(jsonClientUserConfig, htmlElement);
         });
         document.querySelector('#button-dispose')?.addEventListener('click', async () => {
-            codeMain = await disposeEditor(jsonClientUserConfig.wrapperConfig.editorAppConfig.useDiffEditor);
+            await wrapper.dispose();
         });
     } catch (e) {
         console.error(e);

package/src/json/server/direct.ts

@@ -2,9 +2,9 @@
  * Copyright (c) 2024 TypeFox and others.
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
-import { resolve } from 'path';
+import { resolve } from 'node:path';
 import { runJsonServer } from './main.js';
-import { getLocalDirectory } from '../../utils/fs-utils.js';
+import { getLocalDirectory } from '../../common/node/server-commons.js';
 
 const baseDir = resolve(getLocalDirectory(import.meta.url));
 const relativeDir = '../../../dist/json/server/json-server.js';

package/src/json/server/main.ts

@@ -2,9 +2,10 @@
  * Copyright (c) 2024 TypeFox and others.
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
-import { runLanguageServer } from '../../common/language-server-runner.js';
-import { resolve } from 'path';
-import { LanguageName } from '../../common/server-commons.js';
+
+import { resolve } from 'node:path';
+import { runLanguageServer } from '../../common/node/language-server-runner.js';
+import { LanguageName } from '../../common/node/server-commons.js';
 
 export const runJsonServer = (baseDir: string, relativeDir: string) => {
     const processRunPath = resolve(baseDir, relativeDir);

package/src/langium/langium-dsl/config/classicConfig.ts

@@ -9,9 +9,9 @@ import getEditorServiceOverride from '@codingame/monaco-vscode-editor-service-ov
 import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
 import { useOpenEditorStub } from 'monaco-editor-wrapper/vscode/services';
 import { UserConfig } from 'monaco-editor-wrapper';
-import { getTextContent } from '../../../common/example-apps-common.js';
 import { LangiumMonarchContent } from './langium.monarch.js';
 import { loadLangiumWorker } from '../wrapperLangium.js';
+import { getTextContent } from '../../../common/client/app-utils.js';
 
 export const setupLangiumClientClassic = async (): Promise<UserConfig> => {
     const code = await getTextContent(new URL('./src/langium/langium-dsl/content/example.langium', window.location.href));
@@ -44,19 +44,27 @@ export const setupLangiumClientClassic = async (): Promise<UserConfig> => {
             },
             editorAppConfig: {
                 $type: 'classic',
-                languageId: 'langium',
-                code: code,
+                codeResources: {
+                    main: {
+                        text: code,
+                        fileExt: 'langium',
+                        enforceLanguageId: 'langium'
+                    }
+                },
                 useDiffEditor: false,
-                theme: 'vs-dark',
                 editorOptions: {
                     'semanticHighlighting.enabled': true,
-                    wordBasedSuggestions: 'off'
+                    wordBasedSuggestions: 'off',
+                    theme: 'vs-dark'
                 },
-                languageExtensionConfig: { id: 'langium' },
-                languageDef: LangiumMonarchContent,
+                languageDef: {
+                    monarchLanguage: LangiumMonarchContent,
+                    languageExtensionConfig: { id: 'langium' },
+                }
             }
         },
         languageClientConfig: {
+            languageId: 'langium',
             options: {
                 $type: 'WorkerDirect',
                 worker: langiumWorker

package/src/langium/langium-dsl/config/extendedConfig.ts

@@ -8,8 +8,9 @@ import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-
 import '../../../../resources/vsix/GitHub.github-vscode-theme-6.3.4.vsix';
 import { useOpenEditorStub } from 'monaco-editor-wrapper/vscode/services';
 import { UserConfig } from 'monaco-editor-wrapper';
-import { getTextContent } from '../../../common/example-apps-common.js';
+import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-languageclient/browser.js';
 import { loadLangiumWorker } from '../wrapperLangium.js';
+import { getTextContent } from '../../../common/client/app-utils.js';
 
 export const setupLangiumClientExtended = async (): Promise<UserConfig> => {
     const code = await getTextContent(new URL('./src/langium/langium-dsl/content/example.langium', window.location.href));
@@ -22,6 +23,9 @@ export const setupLangiumClientExtended = async (): Promise<UserConfig> => {
     extensionFilesOrContents.set('/langium-grammar.json', langiumTextmateGrammar);
 
     const langiumWorker = loadLangiumWorker();
+    const reader = new BrowserMessageReader(langiumWorker);
+    const writer = new BrowserMessageWriter(langiumWorker);
+
     return {
         wrapperConfig: {
             serviceConfig: {
@@ -33,8 +37,12 @@ export const setupLangiumClientExtended = async (): Promise<UserConfig> => {
             },
             editorAppConfig: {
                 $type: 'extended',
-                languageId: 'langium',
-                code: code,
+                codeResources: {
+                    main: {
+                        text: code,
+                        fileExt: 'langium'
+                    }
+                },
                 useDiffEditor: false,
                 extensions: [{
                     config: {
@@ -70,9 +78,13 @@ export const setupLangiumClientExtended = async (): Promise<UserConfig> => {
             }
         },
         languageClientConfig: {
+            languageId: 'langium',
             options: {
                 $type: 'WorkerDirect',
                 worker: langiumWorker
+            },
+            connectionProvider: {
+                get: async () => ({ reader, writer }),
             }
         }
     };

package/src/langium/statemachine/config/wrapperStatemachineConfig.ts

@@ -8,17 +8,26 @@ import getLifecycleServiceOverride from '@codingame/monaco-vscode-lifecycle-serv
 import getLocalizationServiceOverride from '@codingame/monaco-vscode-localization-service-override';
 import { createDefaultLocaleConfiguration } from 'monaco-languageclient/vscode/services';
 import { UserConfig } from 'monaco-editor-wrapper';
-import { getTextContent } from '../../../common/example-apps-common.js';
-
-export const createLangiumGlobalConfig = async (worker: Worker, messagePort?: MessagePort): Promise<UserConfig> => {
-    const code = await getTextContent(new URL('./src/langium/statemachine/content/example.statemachine', window.location.href));
 
+export const createLangiumGlobalConfig = async (params: {
+    text?: string,
+    worker: Worker,
+    messagePort?: MessagePort
+}): Promise<UserConfig> => {
     const extensionFilesOrContents = new Map<string, string | URL>();
     const statemachineLanguageConfig = new URL('./src/langium/statemachine/config/language-configuration.json', window.location.href);
     const responseStatemachineTm = new URL('./src/langium/statemachine/syntaxes/statemachine.tmLanguage.json', window.location.href);
     extensionFilesOrContents.set('/statemachine-configuration.json', statemachineLanguageConfig);
     extensionFilesOrContents.set('/statemachine-grammar.json', responseStatemachineTm);
 
+    let main;
+    if (params.text) {
+        main = {
+            text: params.text,
+            fileExt: 'statemachine'
+        };
+    }
+
     return {
         wrapperConfig: {
             serviceConfig: {
@@ -31,8 +40,9 @@ export const createLangiumGlobalConfig = async (worker: Worker, messagePort?: Me
             },
             editorAppConfig: {
                 $type: 'extended',
-                languageId: 'statemachine',
-                code: code,
+                codeResources: {
+                    main
+                },
                 useDiffEditor: false,
                 extensions: [{
                     config: {
@@ -68,10 +78,11 @@ export const createLangiumGlobalConfig = async (worker: Worker, messagePort?: Me
             }
         },
         languageClientConfig: {
+            languageId: 'statemachine',
             options: {
                 $type: 'WorkerDirect',
-                worker,
-                messagePort
+                worker: params.worker,
+                messagePort: params.messagePort
             }
         }
     };

package/src/langium/statemachine/main-react.tsx

@@ -6,9 +6,10 @@
 import React from 'react';
 import ReactDOM from 'react-dom/client';
 import { MonacoEditorReactComp } from '@typefox/monaco-editor-react';
+import { useWorkerFactory } from 'monaco-editor-wrapper/workerFactory';
+import { getTextContent } from '../../common/client/app-utils.js';
 import { createLangiumGlobalConfig } from './config/wrapperStatemachineConfig.js';
 import { loadStatemachineWorkerRegular } from './main.js';
-import { useWorkerFactory } from 'monaco-editor-wrapper/workerFactory';
 
 export const configureMonacoWorkers = () => {
     useWorkerFactory({
@@ -18,7 +19,11 @@ export const configureMonacoWorkers = () => {
 
 export const runStatemachineReact = async () => {
     try {
-        const langiumGlobalConfig = await createLangiumGlobalConfig(loadStatemachineWorkerRegular());
+        const text = await getTextContent(new URL('./src/langium/statemachine/content/example.statemachine', window.location.href));
+        const langiumGlobalConfig = await createLangiumGlobalConfig({
+            text,
+            worker: loadStatemachineWorkerRegular()
+        });
         const comp = <MonacoEditorReactComp
             userConfig={langiumGlobalConfig}
             style={{
@@ -27,7 +32,7 @@ export const runStatemachineReact = async () => {
             }}
         />;
 
-        const htmlElement = document.getElementById('root');
+        const htmlElement = document.getElementById('monaco-editor-root');
         ReactDOM.createRoot(htmlElement!).render(comp);
     } catch (e) {
         console.error(e);

package/src/langium/statemachine/main.ts

@@ -4,9 +4,11 @@
  * ------------------------------------------------------------------------------------------ */
 
 import * as vscode from 'vscode';
+import { createModelReference } from 'vscode/monaco';
 import { MonacoEditorLanguageClientWrapper } from 'monaco-editor-wrapper';
-import { createLangiumGlobalConfig } from './config/wrapperStatemachineConfig.js';
 import { useWorkerFactory } from 'monaco-editor-wrapper/workerFactory';
+import { createLangiumGlobalConfig } from './config/wrapperStatemachineConfig.js';
+import { getTextContent } from '../../common/client/app-utils.js';
 
 const wrapper = new MonacoEditorLanguageClientWrapper();
 const wrapper2 = new MonacoEditorLanguageClientWrapper();
@@ -23,11 +25,24 @@ const startEditor = async () => {
         return;
     }
 
+    const text = await getTextContent(new URL('./src/langium/statemachine/content/example.statemachine', window.location.href));
+
     // init first worker regularly
     const stateMachineWorkerRegular = loadStatemachineWorkerRegular();
-    const langiumGlobalConfig = await createLangiumGlobalConfig(stateMachineWorkerRegular);
+
+    // the configuration does not contain any text content
+    const langiumGlobalConfig = await createLangiumGlobalConfig({
+        worker: stateMachineWorkerRegular
+    });
     await wrapper.initAndStart(langiumGlobalConfig, document.getElementById('monaco-editor-root'));
 
+    // here the modelReference is created manually and given to the updateEditorModels of the wrapper
+    const uri = vscode.Uri.parse('/workspace/statemachineUri.statemachine');
+    const modelRef = await createModelReference(uri, text);
+    wrapper.updateEditorModels({
+        modelRef
+    });
+
     // init second worker with port for client and worker
     const stateMachineWorkerPort = loadStatemachinWorkerPort();
     // use callback to receive message back from worker independent of the message channel the LSP is using
@@ -39,7 +54,11 @@ const startEditor = async () => {
         port: channel.port2
     }, [channel.port2]);
 
-    const langiumGlobalConfig2 = await createLangiumGlobalConfig(stateMachineWorkerPort, channel.port1);
+    const langiumGlobalConfig2 = await createLangiumGlobalConfig({
+        text,
+        worker: stateMachineWorkerPort,
+        messagePort: channel.port1
+    });
     await wrapper2.initAndStart(langiumGlobalConfig2, document.getElementById('monaco-editor-root2'));
 
     vscode.commands.getCommands().then((x) => {

package/src/node.ts

@@ -4,9 +4,8 @@
  * ------------------------------------------------------------------------------------------ */
 
 /* server side export only */
-export * from './common/server-commons.js';
-export * from './common/language-server-runner.js';
+export * from './common/node/server-commons.js';
+export * from './common/node/language-server-runner.js';
 export * from './json/server/json-server.js';
 export * from './json/server/main.js';
 export * from './python/server/main.js';
-export * from './utils/fs-utils.js';

package/src/python/client/bad.py

@@ -0,0 +1,3 @@
+# code is intentionally incorrect - language server will pick this up on connection and highlight the error
+def main():
+    return pass

package/src/python/client/config.ts

@@ -4,16 +4,19 @@
  * ------------------------------------------------------------------------------------------ */
 
 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 { useOpenEditorStub } from 'monaco-editor-wrapper/vscode/services';
 import { MonacoLanguageClient } from 'monaco-languageclient';
 
-export const createUserConfig = (code: string): UserConfig => {
+export const createUserConfig = (workspaceRoot: string, code: string, codeUri: string): UserConfig => {
     return {
         languageClientConfig: {
+            languageId: 'python',
+            name: 'Python Language Server Example',
             options: {
-                name: 'Python Language Server Example',
                 $type: 'WebSocket',
                 host: 'localhost',
                 port: 30001,
@@ -40,46 +43,32 @@ export const createUserConfig = (code: string): UserConfig => {
                 workspaceFolder: {
                     index: 0,
                     name: 'workspace',
-                    uri: vscode.Uri.parse('/workspace/')
+                    uri: vscode.Uri.parse(workspaceRoot)
                 },
             },
         },
         wrapperConfig: {
             serviceConfig: {
                 userServices: {
+                    ...getEditorServiceOverride(useOpenEditorStub),
                     ...getKeybindingsServiceOverride()
                 },
                 debugLogging: true
             },
             editorAppConfig: {
                 $type: 'extended',
-                languageId: 'python',
-                codeUri: '/workspace/python.py',
-                extensions: [{
-                    config: {
-                        name: 'python-client',
-                        publisher: 'monaco-languageclient-project',
-                        version: '1.0.0',
-                        engines: {
-                            vscode: '^1.85.0'
-                        },
-                        contributes: {
-                            languages: [{
-                                id: 'python',
-                                extensions: ['.py', 'pyi'],
-                                aliases: ['python'],
-                                mimetypes: ['application/python'],
-                            }],
-                        }
+                codeResources: {
+                    main: {
+                        text: code,
+                        uri: codeUri
                     }
-                }],
+                },
                 userConfiguration: {
                     json: JSON.stringify({
                         'workbench.colorTheme': 'Default Dark Modern'
                     })
                 },
-                useDiffEditor: false,
-                code
+                useDiffEditor: false
             }
         },
         loggerConfig: {

package/src/python/client/hello.py

@@ -0,0 +1,4 @@
+from hello2 import print_hello
+
+print_hello()
+print("Hello Moon!")

package/src/python/client/hello2.py

@@ -0,0 +1,2 @@
+def print_hello():
+    print("Hello World!")