monaco-languageclient 10.0.0 → 10.2.0

package/src/debugger/index.ts

@@ -0,0 +1,168 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import { RegisteredMemoryFile } from '@codingame/monaco-vscode-files-service-override';
+import type { Logger } from 'monaco-languageclient/common';
+import type { ExtensionConfig } from 'monaco-languageclient/vscodeApiWrapper';
+import * as vscode from 'vscode';
+import { Uri } from 'vscode';
+
+// This is derived from:
+// https://github.com/CodinGame/monaco-vscode-api/blob/main/demo/src/features/debugger.ts
+// The client configuration is generic and can be used for a another language
+
+export type FileDefinition = {
+    path: string;
+    code: string;
+    uri: Uri;
+}
+
+export type InitMessage = {
+    id: 'init',
+    files: Record<string, FileDefinition>
+    defaultFile: string;
+    debuggerExecCall: string;
+};
+
+export type ConfigParams = {
+    extensionName: string;
+    version: string;
+    publisher: string;
+    languageId: string;
+    documentSelector: string[];
+    homeDir: string;
+    workspaceRoot: string;
+    workspaceFile: Uri;
+    htmlContainer: HTMLElement;
+    protocol: 'ws' | 'wss';
+    hostname: string;
+    port: number;
+    files: Map<string, FileDefinition>;
+    defaultFile: string;
+    helpContainerCmd: string;
+    debuggerExecCall: string;
+}
+
+export const provideDebuggerExtensionConfig = (config: ConfigParams): ExtensionConfig => {
+    const filesOrContents = new Map<string, string | URL>();
+    filesOrContents.set('./extension.js', '// nothing');
+
+    return {
+        config: {
+            name: config.extensionName,
+            publisher: config.publisher,
+            version: config.version,
+            engines: {
+                vscode: '*'
+            },
+            // A browser field is mandatory for the extension to be flagged as `web`
+            browser: 'extension.js',
+            contributes: {
+                debuggers: [
+                    {
+                        type: config.languageId,
+                        label: 'Test',
+                        languages: [config.languageId]
+                    }
+                ],
+                breakpoints: [
+                    {
+                        language: config.languageId
+                    }
+                ]
+            },
+            activationEvents: [
+                'onDebug'
+            ]
+        },
+        filesOrContents
+    };
+};
+
+export const configureDebugging = async (api: typeof vscode, config: ConfigParams, logger?: Logger) => {
+    class WebsocketDebugAdapter implements vscode.DebugAdapter {
+        private websocket: WebSocket;
+
+        constructor(websocket: WebSocket) {
+            this.websocket = websocket;
+            this.websocket.onmessage = (message) => {
+                this._onDidSendMessage.fire(JSON.parse(message.data));
+            };
+        }
+
+        _onDidSendMessage = new api.EventEmitter<vscode.DebugProtocolMessage>();
+        onDidSendMessage = this._onDidSendMessage.event;
+
+        handleMessage(message: vscode.DebugProtocolMessage): void {
+            // path with on Windows (Chrome/Firefox) arrive here with \\ and not like expected with /
+            // Chrome on Ubuntu behaves as expected
+            const msg = JSON.stringify(message).replaceAll('\\\\', '/');
+            this.websocket.send(msg);
+        }
+
+        dispose() {
+            this.websocket.close();
+        }
+    }
+
+    api.debug.registerDebugAdapterDescriptorFactory(config.languageId, {
+        async createDebugAdapterDescriptor() {
+            const websocket = new WebSocket(`${config.protocol}://${config.hostname}:${config.port}`);
+
+            await new Promise((resolve, reject) => {
+                websocket.onopen = resolve;
+                websocket.onerror = () =>
+                    reject(new Error(`Unable to connect to debugger server. Run "${config.helpContainerCmd}"`));
+            });
+
+            const adapter = new WebsocketDebugAdapter(websocket);
+
+            const initMessage: InitMessage = {
+                id: 'init',
+                files: {},
+                // the default file is the one that will be used by the debugger
+                defaultFile: config.defaultFile,
+                debuggerExecCall: config.debuggerExecCall
+            };
+            for (const [name, fileDef] of config.files.entries()) {
+                logger?.info(`Found: ${name} Sending file: ${fileDef.path}`);
+                initMessage.files[name] = {
+                    path: fileDef.path,
+                    code: fileDef.code,
+                    uri: fileDef.uri
+                };
+            }
+            websocket.send(JSON.stringify(initMessage));
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            adapter.onDidSendMessage((message: any) => {
+                if (message.type === 'event' && message.event === 'output') {
+                    logger?.info('OUTPUT', message.body.output);
+                }
+            });
+            return new api.DebugAdapterInlineImplementation(adapter);
+        }
+    });
+};
+
+export const createDebugLaunchConfigFile = (workspacePath: string, type: string) => {
+    return new RegisteredMemoryFile(
+        Uri.file(`${workspacePath}/.vscode/launch.json`),
+        JSON.stringify(
+            {
+                version: '0.2.0',
+                configurations: [
+                    {
+                        name: 'Debugger: Lauch',
+                        type,
+                        request: 'attach',
+                    }
+                ]
+            },
+            null,
+            2
+        )
+    );
+};

package/src/editorApp/editorApp.ts

@@ -416,11 +416,11 @@ export class EditorApp {
         }
     }
 
-    updateLayout() {
+    updateLayout(dimension?: monaco.editor.IDimension, postponeRendering?: boolean) {
         if (this.isDiffEditor()) {
-            this.diffEditor?.layout();
+            this.diffEditor?.layout(dimension, postponeRendering);
         } else {
-            this.editor?.layout();
+            this.editor?.layout(dimension, postponeRendering);
         }
     }
 

package/src/fs/definitions.ts

@@ -50,12 +50,7 @@ export interface StatsRequestResult {
     mtime: number
 }
 
-export enum EndpointType {
-    DRIVER,
-    FOLLOWER,
-    LOCAL,
-    EMPTY
-}
+export type EndpointType = 'DRIVER' | 'FOLLOWER' | 'LOCAL' | 'EMPTY';
 
 export interface FileSystemCapabilities {
 

package/src/fs/endpoints/defaultEndpoint.ts

@@ -4,8 +4,7 @@
  * ------------------------------------------------------------------------------------------ */
 
 import type { Logger } from 'monaco-languageclient/common';
-import type { DirectoryListingRequest, DirectoryListingRequestResult, FileReadRequest, FileReadRequestResult, FileSystemEndpoint, FileUpdate, FileUpdateResult, StatsRequest, StatsRequestResult } from '../definitions.js';
-import { EndpointType } from '../definitions.js';
+import type { DirectoryListingRequest, DirectoryListingRequestResult, EndpointType, FileReadRequest, FileReadRequestResult, FileSystemEndpoint, FileUpdate, FileUpdateResult, StatsRequest, StatsRequestResult } from '../definitions.js';
 
 export class EmptyFileSystemEndpoint implements FileSystemEndpoint {
 

package/src/vscode/apiWrapper.ts

@@ -17,14 +17,10 @@ import 'vscode/localExtensionHost';
 import type { ExtensionConfig, MonacoVscodeApiConfig, ViewsConfig } from './config.js';
 import { configureExtHostWorker, getEnhancedMonacoEnvironment, mergeServices, reportServiceLoading, useOpenEditorStub } from './utils.js';
 
-export interface ViewsConfigRuntime extends ViewsConfig {
-    htmlContainer: HTMLElement;
-}
-
 export interface MonacoVscodeApiConfigRuntime extends MonacoVscodeApiConfig {
     serviceOverrides: monaco.editor.IEditorOverrideServices;
     logLevel: LogLevel | number;
-    viewsConfig: ViewsConfigRuntime;
+    viewsConfig: ViewsConfig;
 }
 
 export interface StartInstructions {
@@ -40,17 +36,18 @@ export class MonacoVscodeApiWrapper {
     private apiConfig: MonacoVscodeApiConfigRuntime;
 
     constructor(apiConfig: MonacoVscodeApiConfig) {
-        const intermediate = {
+        const viewsConfigType = apiConfig.viewsConfig.$type;
+        if ((viewsConfigType === 'ViewsService' || viewsConfigType === 'WorkbenchService') &&
+            apiConfig.viewsConfig.htmlContainer === undefined) {
+
+            throw new Error(`View Service Type "${viewsConfigType}" requires a HTMLElement.`);
+        }
+
+        this.apiConfig = {
             ...apiConfig,
             serviceOverrides: apiConfig.serviceOverrides ?? {},
             logLevel: apiConfig.logLevel ?? LogLevel.Off,
         };
-        if (intermediate.viewsConfig.htmlContainer === 'ReactPlaceholder') {
-            // this is temporary and must be overriden at start by react component with
-            // correct react dom element
-            intermediate.viewsConfig.htmlContainer = document.body;
-        }
-        this.apiConfig = intermediate as MonacoVscodeApiConfigRuntime;
         this.logger.setLevel(this.apiConfig.logLevel);
     }
 
@@ -66,10 +63,6 @@ export class MonacoVscodeApiWrapper {
         return this.apiConfig;
     }
 
-    getHtmlContainer() {
-        return this.apiConfig.viewsConfig.htmlContainer;
-    }
-
     protected configureMonacoWorkers() {
         if (typeof this.apiConfig.monacoWorkerFactory === 'function') {
             this.apiConfig.monacoWorkerFactory(this.logger);
@@ -100,7 +93,7 @@ export class MonacoVscodeApiWrapper {
 
     protected async configureViewsServices() {
         const viewsConfigType = this.apiConfig.viewsConfig.$type;
-        if (this.apiConfig.$type === 'classic' && (viewsConfigType === 'ViewsService' || viewsConfigType === 'WorkspaceService')) {
+        if (this.apiConfig.$type === 'classic' && (viewsConfigType === 'ViewsService' || viewsConfigType === 'WorkbenchService')) {
             throw new Error(`View Service Type "${viewsConfigType}" cannot be used with classic configuration.`);
         }
 
@@ -111,12 +104,12 @@ export class MonacoVscodeApiWrapper {
                 ...getViewsServiceOverride(this.apiConfig.viewsConfig.openEditorFunc ?? useOpenEditorStub)
             });
             envEnhanced.viewServiceType = 'ViewsService';
-        } else if (viewsConfigType === 'WorkspaceService') {
+        } else if (viewsConfigType === 'WorkbenchService') {
             const getWorkbenchServiceOverride = (await import('@codingame/monaco-vscode-workbench-service-override')).default;
             mergeServices(this.apiConfig.serviceOverrides, {
                 ...getWorkbenchServiceOverride()
             });
-            envEnhanced.viewServiceType = 'WorkspaceService';
+            envEnhanced.viewServiceType = 'WorkbenchService';
         } else {
             const getEditorServiceOverride = (await import('@codingame/monaco-vscode-editor-service-override')).default;
             mergeServices(this.apiConfig.serviceOverrides, {
@@ -241,7 +234,7 @@ export class MonacoVscodeApiWrapper {
             this.checkServiceConsistency();
         }
 
-        if (this.apiConfig.viewsConfig.$type === 'ViewsService' || this.apiConfig.viewsConfig.$type === 'WorkspaceService') {
+        if (this.apiConfig.viewsConfig.$type === 'ViewsService' || this.apiConfig.viewsConfig.$type === 'WorkbenchService') {
             await initialize(services, this.apiConfig.viewsConfig.htmlContainer, this.apiConfig.workspaceConfig, this.apiConfig.envOptions);
         } else {
             await initialize(services, undefined, this.apiConfig.workspaceConfig, this.apiConfig.envOptions);
@@ -308,7 +301,7 @@ export class MonacoVscodeApiWrapper {
         this.logger.debug('markGlobalInitDone');
     }
 
-    overrideViewsConfig(viewsConfigOverride: ViewsConfigRuntime) {
+    overrideViewsConfig(viewsConfigOverride: ViewsConfig) {
         const orgViewsConfig = this.apiConfig.viewsConfig;
         this.apiConfig.viewsConfig = {
             $type: viewsConfigOverride.$type,

package/src/vscode/config.ts

@@ -13,9 +13,9 @@ import type { Logger } from 'monaco-languageclient/common';
 
 export type OverallConfigType = 'extended' | 'classic';
 
-export type ViewsConfigTypes = 'EditorService' | 'ViewsService' | 'WorkspaceService';
+export type ViewsConfigTypes = 'EditorService' | 'ViewsService' | 'WorkbenchService';
 
-export type HtmlContainerConfig = HTMLElement | 'ReactPlaceholder';
+// export type HtmlContainerConfig = HTMLElement;
 
 export interface MonacoEnvironmentEnhanced extends monaco.Environment {
     vscodeApiInitialising?: boolean;
@@ -31,7 +31,7 @@ export interface UserConfiguration {
 
 export interface ViewsConfig {
     $type: ViewsConfigTypes;
-    htmlContainer: HtmlContainerConfig;
+    htmlContainer?: HTMLElement;
     openEditorFunc?: OpenEditor;
     htmlAugmentationInstructions?: (htmlContainer: HTMLElement | null | undefined) => void;
     viewsInitFunc?: () => Promise<void>;

package/src/vscode/locales.ts

@@ -4,6 +4,7 @@
  * ------------------------------------------------------------------------------------------ */
 
 import type { LocalizationOptions } from '@codingame/monaco-vscode-localization-service-override';
+import { type Logger } from 'monaco-languageclient/common';
 
 export const createDefaultLocaleConfiguration = (): LocalizationOptions => {
     return {
@@ -116,13 +117,13 @@ const localeLoader: Partial<Record<string, () => Promise<void>>> = {
 
 export const locales = Object.keys(localeLoader);
 
-export const initLocaleLoader = async (locale = new URLSearchParams(window.location.search).get('locale')) => {
+export const initLocaleLoader = async (locale = new URLSearchParams(window.location.search).get('locale'), logger?: Logger) => {
     if (locale !== null) {
         const loader = localeLoader[locale];
         if (loader) {
             await loader();
         } else {
-            console.error(`Unknown locale ${locale}`);
+            logger?.error(`Unknown locale ${locale}`);
         }
     }
 };

package/src/vscode/utils.ts

@@ -60,7 +60,7 @@ export const configureExtHostWorker = async (enableExtHostWorker: boolean, userS
     }
 };
 
-export const useOpenEditorStub: OpenEditor = async (modelRef, options, sideBySide) => {
-    console.log('Received open editor call with parameters: ', modelRef, options, sideBySide);
+export const useOpenEditorStub: OpenEditor = async (modelRef, options, sideBySide, logger?: Logger) => {
+    logger?.info('Received open editor call with parameters: ', modelRef, options, sideBySide);
     return undefined;
 };