monaco-languageclient 10.0.0-next.1 → 10.0.0

package/src/vscode/apiWrapper.ts

@@ -4,23 +4,32 @@
  * ------------------------------------------------------------------------------------------ */
 
 import { initialize, LogLevel } from '@codingame/monaco-vscode-api';
-import { ExtensionHostKind, getExtensionManifests, registerExtension, type IExtensionManifest, type RegisterExtensionResult } from '@codingame/monaco-vscode-api/extensions';
+import { ExtensionHostKind, getBuiltinExtensions, registerExtension, type IExtensionManifest, type RegisterExtensionResult } from '@codingame/monaco-vscode-api/extensions';
 import { DisposableStore, setUnexpectedErrorHandler } from '@codingame/monaco-vscode-api/monaco';
 import getConfigurationServiceOverride, { initUserConfiguration } from '@codingame/monaco-vscode-configuration-service-override';
-import getLanguagesServiceOverride from '@codingame/monaco-vscode-languages-service-override';
+import * as monaco from '@codingame/monaco-vscode-editor-api';
 import getLogServiceOverride from '@codingame/monaco-vscode-log-service-override';
 import getModelServiceOverride from '@codingame/monaco-vscode-model-service-override';
 import { ConsoleLogger, encodeStringOrUrlToDataUrl, type Logger } from 'monaco-languageclient/common';
 import { useWorkerFactory } from 'monaco-languageclient/workerFactory';
 import * as vscode from 'vscode';
 import 'vscode/localExtensionHost';
-import type { ExtensionConfig, MonacoVscodeApiConfig } from './config.js';
+import type { ExtensionConfig, MonacoVscodeApiConfig, ViewsConfig } from './config.js';
 import { configureExtHostWorker, getEnhancedMonacoEnvironment, mergeServices, reportServiceLoading, useOpenEditorStub } from './utils.js';
 
-export interface InitServicesInstructions {
+export interface ViewsConfigRuntime extends ViewsConfig {
+    htmlContainer: HTMLElement;
+}
+
+export interface MonacoVscodeApiConfigRuntime extends MonacoVscodeApiConfig {
+    serviceOverrides: monaco.editor.IEditorOverrideServices;
+    logLevel: LogLevel | number;
+    viewsConfig: ViewsConfigRuntime;
+}
+
+export interface StartInstructions {
     caller?: string;
     performServiceConsistencyChecks?: boolean;
-    htmlContainer?: HTMLElement | null;
 }
 
 export class MonacoVscodeApiWrapper {
@@ -28,11 +37,20 @@ export class MonacoVscodeApiWrapper {
     private logger: Logger = new ConsoleLogger();
     private extensionRegisterResults: Map<string, | RegisterExtensionResult> = new Map();
     private disposableStore: DisposableStore = new DisposableStore();
-    private apiConfig: MonacoVscodeApiConfig;
+    private apiConfig: MonacoVscodeApiConfigRuntime;
 
     constructor(apiConfig: MonacoVscodeApiConfig) {
-        this.apiConfig = apiConfig;
-        this.apiConfig.logLevel = this.apiConfig.logLevel ?? LogLevel.Off;
+        const intermediate = {
+            ...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);
     }
 
@@ -48,6 +66,10 @@ 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);
@@ -62,7 +84,9 @@ export class MonacoVscodeApiWrapper {
         if (this.apiConfig.$type === 'extended') {
             const getTextmateServiceOverride = (await import('@codingame/monaco-vscode-textmate-service-override')).default;
             const getThemeServiceOverride = (await import('@codingame/monaco-vscode-theme-service-override')).default;
+            const getLanguagesServiceOverride = (await import('@codingame/monaco-vscode-languages-service-override')).default;
             mergeServices(this.apiConfig.serviceOverrides, {
+                ...getLanguagesServiceOverride(),
                 ...getTextmateServiceOverride(),
                 ...getThemeServiceOverride()
             });
@@ -75,19 +99,19 @@ export class MonacoVscodeApiWrapper {
     }
 
     protected async configureViewsServices() {
-        const viewServiceType = this.apiConfig.viewsConfig?.viewServiceType ?? 'EditorService';
-        if (this.apiConfig.$type === 'classic' && (viewServiceType === 'ViewsService' || viewServiceType === 'WorkspaceService')) {
-            throw new Error(`View Service Type "${viewServiceType}" cannot be used with classic configuration.`);
+        const viewsConfigType = this.apiConfig.viewsConfig.$type;
+        if (this.apiConfig.$type === 'classic' && (viewsConfigType === 'ViewsService' || viewsConfigType === 'WorkspaceService')) {
+            throw new Error(`View Service Type "${viewsConfigType}" cannot be used with classic configuration.`);
         }
 
         const envEnhanced = getEnhancedMonacoEnvironment();
-        if (this.apiConfig.viewsConfig?.viewServiceType === 'ViewsService') {
+        if (viewsConfigType === 'ViewsService') {
             const getViewsServiceOverride = (await import('@codingame/monaco-vscode-views-service-override')).default;
             mergeServices(this.apiConfig.serviceOverrides, {
                 ...getViewsServiceOverride(this.apiConfig.viewsConfig.openEditorFunc ?? useOpenEditorStub)
             });
             envEnhanced.viewServiceType = 'ViewsService';
-        } else if (this.apiConfig.viewsConfig?.viewServiceType === 'WorkspaceService') {
+        } else if (viewsConfigType === 'WorkspaceService') {
             const getWorkbenchServiceOverride = (await import('@codingame/monaco-vscode-workbench-service-override')).default;
             mergeServices(this.apiConfig.serviceOverrides, {
                 ...getWorkbenchServiceOverride()
@@ -96,15 +120,15 @@ export class MonacoVscodeApiWrapper {
         } else {
             const getEditorServiceOverride = (await import('@codingame/monaco-vscode-editor-service-override')).default;
             mergeServices(this.apiConfig.serviceOverrides, {
-                ...getEditorServiceOverride(this.apiConfig.viewsConfig?.openEditorFunc ?? useOpenEditorStub)
+                ...getEditorServiceOverride(this.apiConfig.viewsConfig.openEditorFunc ?? useOpenEditorStub)
             });
             envEnhanced.viewServiceType = 'EditorService';
         }
     }
 
     protected async applyViewsPostConfig() {
-        this.apiConfig.viewsConfig?.htmlAugmentationInstructions?.(this.apiConfig.htmlContainer);
-        await this.apiConfig.viewsConfig?.viewsInitFunc?.();
+        this.apiConfig.viewsConfig.htmlAugmentationInstructions?.(this.apiConfig.viewsConfig.htmlContainer);
+        await this.apiConfig.viewsConfig.viewsInitFunc?.();
     }
 
     /**
@@ -169,7 +193,6 @@ export class MonacoVscodeApiWrapper {
     protected async supplyRequiredServices() {
         return {
             ...getConfigurationServiceOverride(),
-            ...getLanguagesServiceOverride(),
             ...getLogServiceOverride(),
             ...getModelServiceOverride()
         };
@@ -204,8 +227,9 @@ export class MonacoVscodeApiWrapper {
      *   - languages
      *   - log
      *   - model
+     *   - configuration services
      */
-    protected async importAllServices(instructions?: InitServicesInstructions) {
+    protected async initAllServices(performServiceConsistencyChecks?: boolean) {
         const services = await this.supplyRequiredServices();
 
         mergeServices(services, this.apiConfig.serviceOverrides);
@@ -213,12 +237,12 @@ export class MonacoVscodeApiWrapper {
 
         reportServiceLoading(services, this.logger);
 
-        if (instructions?.performServiceConsistencyChecks === true) {
+        if (performServiceConsistencyChecks ?? true) {
             this.checkServiceConsistency();
         }
 
-        if (this.apiConfig.viewsConfig?.viewServiceType === 'ViewsService' || this.apiConfig.viewsConfig?.viewServiceType === 'WorkspaceService') {
-            await initialize(services, this.apiConfig.htmlContainer, this.apiConfig.workspaceConfig, this.apiConfig.envOptions);
+        if (this.apiConfig.viewsConfig.$type === 'ViewsService' || this.apiConfig.viewsConfig.$type === 'WorkspaceService') {
+            await initialize(services, this.apiConfig.viewsConfig.htmlContainer, this.apiConfig.workspaceConfig, this.apiConfig.envOptions);
         } else {
             await initialize(services, undefined, this.apiConfig.workspaceConfig, this.apiConfig.envOptions);
         }
@@ -237,7 +261,7 @@ export class MonacoVscodeApiWrapper {
         if (this.apiConfig.extensions) {
             const allPromises: Array<Promise<void>> = [];
             const extensionIds: string[] = [];
-            getExtensionManifests().forEach((ext) => {
+            getBuiltinExtensions().forEach((ext) => {
                 extensionIds.push(ext.identifier.id);
             });
             for (const extensionConfig of extensions ?? []) {
@@ -276,33 +300,41 @@ export class MonacoVscodeApiWrapper {
 
     protected markGlobalInitDone() {
         const envEnhanced = getEnhancedMonacoEnvironment();
-        if (typeof envEnhanced.vscodeApiGlobalInitResolve === 'function') {
-            envEnhanced.vscodeApiGlobalInitResolve();
-        }
+        envEnhanced.vscodeApiGlobalInitResolve?.();
+
         envEnhanced.vscodeApiInitialised = true;
         envEnhanced.vscodeApiGlobalInitAwait = undefined;
         envEnhanced.vscodeApiGlobalInitResolve = undefined;
         this.logger.debug('markGlobalInitDone');
     }
 
-    async init(instructions?: InitServicesInstructions): Promise<void> {
+    overrideViewsConfig(viewsConfigOverride: ViewsConfigRuntime) {
+        const orgViewsConfig = this.apiConfig.viewsConfig;
+        this.apiConfig.viewsConfig = {
+            $type: viewsConfigOverride.$type,
+            htmlContainer: viewsConfigOverride.htmlContainer,
+            htmlAugmentationInstructions: viewsConfigOverride.htmlAugmentationInstructions ?? orgViewsConfig.htmlAugmentationInstructions,
+            openEditorFunc: viewsConfigOverride.openEditorFunc ?? orgViewsConfig.openEditorFunc,
+            viewsInitFunc: viewsConfigOverride.viewsInitFunc ?? orgViewsConfig.viewsInitFunc
+        };
+    }
+
+    async start(startInstructions?: StartInstructions): Promise<void> {
         const envEnhanced = getEnhancedMonacoEnvironment();
         if (envEnhanced.vscodeApiInitialised === true) {
             this.logger.warn('Initialization of monaco-vscode api can only performed once!');
         } else {
             if (!(envEnhanced.vscodeApiInitialising === true)) {
+
                 envEnhanced.vscodeApiInitialising = true;
                 this.markGlobalInit();
-                if (instructions?.htmlContainer !== undefined && instructions.htmlContainer !== null) {
-                    this.apiConfig.htmlContainer = instructions.htmlContainer;
-                }
 
                 // ensures "vscodeApiConfig.workspaceConfig" is available
                 this.configureWorkspaceConfig();
 
                 // ensure logging and development logging options are in-line
                 this.configureDevLogLevel();
-                this.logger.info(`Initializing monaco-vscode api. Caller: ${instructions?.caller ?? 'unknown'}`);
+                this.logger.info(`Initializing monaco-vscode api. Caller: ${startInstructions?.caller ?? 'unknown'}`);
 
                 await this.configureMonacoWorkers();
 
@@ -317,7 +349,7 @@ export class MonacoVscodeApiWrapper {
 
                 await this.initUserConfiguration();
 
-                await this.importAllServices(instructions);
+                await this.initAllServices(startInstructions?.performServiceConsistencyChecks);
 
                 await this.applyViewsPostConfig();
 

package/src/vscode/config.ts

@@ -11,21 +11,27 @@ import type { EnvironmentOverride } from '@codingame/monaco-vscode-api/workbench
 import type { OpenEditor } from '@codingame/monaco-vscode-editor-service-override';
 import type { Logger } from 'monaco-languageclient/common';
 
+export type OverallConfigType = 'extended' | 'classic';
+
+export type ViewsConfigTypes = 'EditorService' | 'ViewsService' | 'WorkspaceService';
+
+export type HtmlContainerConfig = HTMLElement | 'ReactPlaceholder';
+
 export interface MonacoEnvironmentEnhanced extends monaco.Environment {
     vscodeApiInitialising?: boolean;
     vscodeApiInitialised?: boolean;
     vscodeApiGlobalInitAwait?: Promise<void>;
     vscodeApiGlobalInitResolve?: ((value: void | PromiseLike<void>) => void);
-    viewServiceType?: 'EditorService' | 'ViewsService' | 'WorkspaceService';
+    viewServiceType?: ViewsConfigTypes;
 }
 
-export type OverallConfigType = 'extended' | 'classic';
-
 export interface UserConfiguration {
     json?: string;
 }
+
 export interface ViewsConfig {
-    viewServiceType: 'EditorService' | 'ViewsService' | 'WorkspaceService';
+    $type: ViewsConfigTypes;
+    htmlContainer: HtmlContainerConfig;
     openEditorFunc?: OpenEditor;
     htmlAugmentationInstructions?: (htmlContainer: HTMLElement | null | undefined) => void;
     viewsInitFunc?: () => Promise<void>;
@@ -38,12 +44,11 @@ export interface ExtensionConfig {
 
 export interface MonacoVscodeApiConfig {
     $type: OverallConfigType;
-    htmlContainer?: HTMLElement;
-    serviceOverrides: monaco.editor.IEditorOverrideServices;
+    viewsConfig: ViewsConfig,
+    serviceOverrides?: monaco.editor.IEditorOverrideServices;
     logLevel?: LogLevel | number;
     workspaceConfig?: IWorkbenchConstructionOptions;
     userConfiguration?: UserConfiguration;
-    viewsConfig?: ViewsConfig,
     envOptions?: EnvironmentOverride;
     extensions?: ExtensionConfig[];
     monacoWorkerFactory?: (logger?: Logger) => void;

package/src/vscode/utils.ts

@@ -12,11 +12,10 @@ import { FakeWorker as Worker } from 'monaco-languageclient/workerFactory';
 import type { MonacoEnvironmentEnhanced } from './config.js';
 
 export const getEnhancedMonacoEnvironment = (): MonacoEnvironmentEnhanced => {
-    const monWin = (self as Window);
-    if (monWin.MonacoEnvironment === undefined) {
-        monWin.MonacoEnvironment = {};
+    if (typeof MonacoEnvironment === 'undefined') {
+        globalThis.MonacoEnvironment = {};
     }
-    const envEnhanced = monWin.MonacoEnvironment as MonacoEnvironmentEnhanced;
+    const envEnhanced = MonacoEnvironment as MonacoEnvironmentEnhanced;
     if (envEnhanced.vscodeApiInitialising === undefined) {
         envEnhanced.vscodeApiInitialising = false;
     }

package/src/wrapper/lcconfig.ts

@@ -12,11 +12,13 @@ export interface ConnectionConfig {
 }
 
 export interface LanguageClientConfig {
-    name?: string;
+    languageId: string;
     connection: ConnectionConfig;
     clientOptions: LanguageClientOptions;
     restartOptions?: LanguageClientRestartOptions;
     disposeWorker?: boolean;
+    overwriteExisting?: boolean;
+    enforceDispose?: boolean;
 }
 
 export interface LanguageClientRestartOptions {
@@ -26,7 +28,5 @@ export interface LanguageClientRestartOptions {
 }
 
 export interface LanguageClientConfigs {
-    configs: Record<string, LanguageClientConfig>
-    overwriteExisting?: boolean;
-    enforceDispose?: boolean;
+    configs: Record<string, LanguageClientConfig>;
 }

package/src/wrapper/lcmanager.ts

@@ -4,7 +4,7 @@
  * ------------------------------------------------------------------------------------------ */
 
 import type { Logger } from 'monaco-languageclient/common';
-import type { LanguageClientConfigs } from './lcconfig.js';
+import type { LanguageClientConfig, LanguageClientConfigs } from './lcconfig.js';
 import { LanguageClientWrapper } from './lcwrapper.js';
 
 export class LanguageClientsManager {
@@ -33,25 +33,30 @@ export class LanguageClientsManager {
         return this.languageClientWrappers.get(languageId)?.getWorker();
     }
 
+    async setConfig(languageClientConfig: LanguageClientConfig): Promise<void> {
+        const languageId = languageClientConfig.languageId;
+        const current = this.languageClientWrappers.get(languageId);
+        const lcw = new LanguageClientWrapper(languageClientConfig, this.logger);
+
+        if (current !== undefined) {
+            if (languageClientConfig.overwriteExisting === true) {
+                if (languageClientConfig.enforceDispose === true) {
+                    await current.dispose();
+                }
+            } else {
+                throw new Error(`A languageclient config with id "${languageId}" already exists and you confiured to not override.`);
+            }
+        }
+        this.languageClientWrappers.set(languageId, lcw);
+    }
+
     async setConfigs(languageClientConfigs: LanguageClientConfigs): Promise<void> {
         this.languageClientConfigs = languageClientConfigs;
 
-        const lccEntries = Object.entries(this.languageClientConfigs.configs);
-        if (lccEntries.length > 0) {
-            for (const [languageId, lcc] of lccEntries) {
-                const current = this.languageClientWrappers.get(languageId);
-                const lcw = new LanguageClientWrapper(lcc, this.logger);
-
-                if (current !== undefined) {
-                    if (languageClientConfigs.overwriteExisting === true) {
-                        if (languageClientConfigs.enforceDispose === true) {
-                            await current.dispose();
-                        }
-                    } else {
-                        throw new Error(`A languageclient config with id "${languageId}" already exists and you confiured to not override.`);
-                    }
-                }
-                this.languageClientWrappers.set(languageId, lcw);
+        const lccs = Object.values(this.languageClientConfigs.configs);
+        if (lccs.length > 0) {
+            for (const lcc of lccs) {
+                await this.setConfig(lcc);
             }
         }
     }

package/src/wrapper/lcwrapper.ts

@@ -21,12 +21,12 @@ export class LanguageClientWrapper {
     private languageClientConfig: LanguageClientConfig;
     private worker?: Worker;
     private port?: MessagePort;
-    private name?: string;
+    private languageId: string;
     private logger: Logger | undefined;
 
     constructor(config: LanguageClientConfig, logger?: Logger) {
         this.languageClientConfig = config;
-        this.name = this.languageClientConfig.name ?? 'unnamed';
+        this.languageId = this.languageClientConfig.languageId;
         this.logger = logger;
     }
 
@@ -102,7 +102,7 @@ export class LanguageClientWrapper {
         };
         webSocket.onerror = (ev: Event) => {
             const languageClientError: LanguageClientError = {
-                message: `languageClientWrapper (${this.name}): Websocket connection failed.`,
+                message: `languageClientWrapper (${this.languageId}): Websocket connection failed.`,
                 error: (ev as ErrorEvent).error ?? 'No error was provided.'
             };
             reject(languageClientError);
@@ -120,7 +120,7 @@ export class LanguageClientWrapper {
 
                 this.worker.onerror = (ev) => {
                     const languageClientError: LanguageClientError = {
-                        message: `languageClientWrapper (${this.name}): Illegal worker configuration detected.`,
+                        message: `languageClientWrapper (${this.languageId}): Illegal worker configuration detected.`,
                         error: ev.error ?? 'No error was provided.'
                     };
                     reject(languageClientError);
@@ -155,7 +155,8 @@ export class LanguageClientWrapper {
         }
 
         const mlcConfig = {
-            name: this.languageClientConfig.name ?? 'Monaco Wrapper Language Client',
+            id: this.languageClientConfig.languageId,
+            name: 'Monaco Wrapper Language Client',
             clientOptions: {
                 // disable the default error handler...
                 errorHandler: {
@@ -205,12 +206,12 @@ export class LanguageClientWrapper {
             }
         } catch (e: unknown) {
             const languageClientError: LanguageClientError = {
-                message: `languageClientWrapper (${this.name}): Start was unsuccessful.`,
+                message: `languageClientWrapper (${this.languageId}): Start was unsuccessful.`,
                 error: Object.hasOwn(e ?? {}, 'cause') ? (e as Error) : 'No error was provided.'
             };
             reject(languageClientError);
         }
-        this.logger?.info(`languageClientWrapper (${this.name}): Started successfully.`);
+        this.logger?.info(`languageClientWrapper (${this.languageId}): Started successfully.`);
         resolve();
         starting = false;
     }
@@ -258,7 +259,7 @@ export class LanguageClientWrapper {
             }
         } catch (e) {
             const languageClientError: LanguageClientError = {
-                message: `languageClientWrapper (${this.name}): Disposing the monaco-languageclient resulted in error.`,
+                message: `languageClientWrapper (${this.languageId}): Disposing the monaco-languageclient resulted in error.`,
                 error: Object.hasOwn(e ?? {}, 'cause') ? (e as Error) : 'No error was provided.'
             };
             return Promise.reject(languageClientError);