Remove own ConsoleLogger implementation in mlc/common. It lead to too early api init (#1011)

kaisalmen · web-flow · commit 42855dcc86a8 · 2026-01-14T10:18:49.000+01:00
diff --git a/packages/client/src/common/commonTypes.ts b/packages/client/src/common/commonTypes.ts
@@ -3,7 +3,7 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { BaseLanguageClient } from 'vscode-languageclient/browser.js';
+import type { BaseLanguageClient } from 'vscode-languageclient/browser.js';
 
 export type ConnectionConfigOptions = WebSocketConfigOptionsDirect | WebSocketConfigOptionsParams | WebSocketConfigOptionsUrl | WorkerConfigOptionsParams | WorkerConfigOptionsDirect;
 
diff --git a/packages/client/src/common/index.ts b/packages/client/src/common/index.ts
@@ -4,5 +4,5 @@
  * ------------------------------------------------------------------------------------------ */
 
 export * from './commonTypes.js';
-export * from './logging.js';
 export * from './utils.js';
+
diff --git a/packages/client/src/common/logging.ts b/packages/client/src/common/logging.ts
diff --git a/packages/client/src/debugger/index.ts b/packages/client/src/debugger/index.ts
@@ -4,7 +4,7 @@
  * ------------------------------------------------------------------------------------------ */
 
 import { RegisteredMemoryFile } from '@codingame/monaco-vscode-files-service-override';
-import type { Logger } from 'monaco-languageclient/common';
+import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
 import type { ExtensionConfig } from 'monaco-languageclient/vscodeApiWrapper';
 import * as vscode from 'vscode';
 import { Uri } from 'vscode';
@@ -81,7 +81,7 @@ export const provideDebuggerExtensionConfig = (config: ConfigParams): ExtensionC
     };
 };
 
-export const configureDebugging = async (api: typeof vscode, config: ConfigParams, logger?: Logger) => {
+export const configureDebugging = async (api: typeof vscode, config: ConfigParams, logger?: ILogger) => {
     class WebsocketDebugAdapter implements vscode.DebugAdapter {
         private websocket: WebSocket;
 
diff --git a/packages/client/src/editorApp/editorApp.ts b/packages/client/src/editorApp/editorApp.ts
@@ -7,7 +7,8 @@ import { ConfigurationTarget, IConfigurationService, LogLevel, StandaloneService
 import { createModelReference, type ITextFileEditorModel } from '@codingame/monaco-vscode-api/monaco';
 import * as monaco from '@codingame/monaco-vscode-editor-api';
 import type { IReference } from '@codingame/monaco-vscode-editor-service-override';
-import { ConsoleLogger, type Logger } from 'monaco-languageclient/common';
+import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
+import { ConsoleLogger } from '@codingame/monaco-vscode-log-service-override';
 import { getEnhancedMonacoEnvironment } from 'monaco-languageclient/vscodeApiWrapper';
 import * as vscode from 'vscode';
 import type { CallbackDisposeable, CodeContent, CodeResources, DisposableModelRefs, EditorAppConfig, TextContents, TextModels } from './config.js';
@@ -25,7 +26,7 @@ export class EditorApp {
     private id: string;
     private config: EditorAppConfig;
 
-    protected logger: Logger = new ConsoleLogger();
+    protected logger: ILogger = new ConsoleLogger();
 
     private editor: monaco.editor.IStandaloneCodeEditor | undefined;
     private diffEditor: monaco.editor.IStandaloneDiffEditor | undefined;
diff --git a/packages/client/src/fs/definitions.ts b/packages/client/src/fs/definitions.ts
@@ -3,7 +3,7 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import type { Logger } from 'monaco-languageclient/common';
+import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
 
 export interface FileReadRequest {
     resourceUri: string
@@ -103,7 +103,7 @@ export interface FileSystemEndpoint extends FileSystemCapabilities {
      * Set an optional logger
      * @param logger the logger implemenation
      */
-    setLogger?(logger: Logger): void;
+    setLogger?(logger: ILogger): void;
 
     /**
      * Get the type of the client
diff --git a/packages/client/src/fs/endpoints/defaultEndpoint.ts b/packages/client/src/fs/endpoints/defaultEndpoint.ts
@@ -3,13 +3,13 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import type { Logger } from 'monaco-languageclient/common';
+import { type ILogger } from '@codingame/monaco-vscode-log-service-override';
 import type { DirectoryListingRequest, DirectoryListingRequestResult, EndpointType, FileReadRequest, FileReadRequestResult, FileSystemEndpoint, FileUpdate, FileUpdateResult, StatsRequest, StatsRequestResult } from '../definitions.js';
 
 export class EmptyFileSystemEndpoint implements FileSystemEndpoint {
 
     private endpointType: EndpointType;
-    private logger?: Logger;
+    private logger?: ILogger;
 
     constructor(endpointType: EndpointType) {
         this.endpointType = endpointType;
@@ -21,7 +21,7 @@ export class EmptyFileSystemEndpoint implements FileSystemEndpoint {
         return 'This file system performs no operations.';
     }
 
-    setLogger(logger: Logger): void {
+    setLogger(logger: ILogger): void {
         this.logger = logger;
     }
 
diff --git a/packages/client/src/vscode/apiWrapper.ts b/packages/client/src/vscode/apiWrapper.ts
@@ -8,9 +8,9 @@ import { ExtensionHostKind, getBuiltinExtensions, registerExtension, type IExten
 import { DisposableStore, setUnexpectedErrorHandler } from '@codingame/monaco-vscode-api/monaco';
 import getConfigurationServiceOverride, { initUserConfiguration } from '@codingame/monaco-vscode-configuration-service-override';
 import * as monaco from '@codingame/monaco-vscode-editor-api';
-import getLogServiceOverride from '@codingame/monaco-vscode-log-service-override';
+import getLogServiceOverride, { ConsoleLogger, type ILogger } 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 { encodeStringOrUrlToDataUrl } from 'monaco-languageclient/common';
 import { useWorkerFactory } from 'monaco-languageclient/workerFactory';
 import * as vscode from 'vscode';
 import 'vscode/localExtensionHost';
@@ -30,7 +30,7 @@ export interface StartInstructions {
 
 export class MonacoVscodeApiWrapper {
 
-    private logger: Logger = new ConsoleLogger();
+    private logger: ILogger = new ConsoleLogger();
     private extensionRegisterResults: Map<string, | RegisterExtensionResult> = new Map();
     private disposableStore: DisposableStore = new DisposableStore();
     private apiConfig: MonacoVscodeApiConfigRuntime;
@@ -250,7 +250,11 @@ export class MonacoVscodeApiWrapper {
         }
 
         setUnexpectedErrorHandler((e) => {
-            this.logger.createErrorAndLog('Unexpected error', e);
+            const message = 'Unexpected error';
+            if (this.logger.getLevel() >= LogLevel.Error) {
+                this.logger.error(message, e);
+            }
+            return new Error(message);
         });
     }
 
diff --git a/packages/client/src/vscode/config.ts b/packages/client/src/vscode/config.ts
@@ -3,13 +3,13 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import * as monaco from '@codingame/monaco-vscode-editor-api';
-import { LogLevel } from '@codingame/monaco-vscode-api';
 import type { IWorkbenchConstructionOptions } from '@codingame/monaco-vscode-api';
+import { LogLevel } from '@codingame/monaco-vscode-api';
 import type { IExtensionManifest } from '@codingame/monaco-vscode-api/extensions';
 import type { EnvironmentOverride } from '@codingame/monaco-vscode-api/workbench';
+import * as monaco from '@codingame/monaco-vscode-editor-api';
 import type { OpenEditor } from '@codingame/monaco-vscode-editor-service-override';
-import type { Logger } from 'monaco-languageclient/common';
+import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
 
 export type OverallConfigType = 'extended' | 'classic';
 
@@ -51,7 +51,7 @@ export interface MonacoVscodeApiConfig {
     userConfiguration?: UserConfiguration;
     envOptions?: EnvironmentOverride;
     extensions?: ExtensionConfig[];
-    monacoWorkerFactory?: (logger?: Logger) => void;
+    monacoWorkerFactory?: (logger?: ILogger) => void;
     advanced?: {
         loadExtensionServices?: boolean;
         enableExtHostWorker?: boolean;
diff --git a/packages/client/src/vscode/locales.ts b/packages/client/src/vscode/locales.ts
@@ -4,7 +4,7 @@
  * ------------------------------------------------------------------------------------------ */
 
 import type { LocalizationOptions } from '@codingame/monaco-vscode-localization-service-override';
-import { type Logger } from 'monaco-languageclient/common';
+import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
 
 export const createDefaultLocaleConfiguration = (): LocalizationOptions => {
     return {
@@ -117,7 +117,7 @@ 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'), logger?: Logger) => {
+export const initLocaleLoader = async (locale = new URLSearchParams(window.location.search).get('locale'), logger?: ILogger) => {
     if (locale !== null) {
         const loader = localeLoader[locale];
         if (loader) {
diff --git a/packages/client/src/vscode/utils.ts b/packages/client/src/vscode/utils.ts
@@ -5,7 +5,7 @@
 
 import * as monaco from '@codingame/monaco-vscode-editor-api';
 import type { OpenEditor } from '@codingame/monaco-vscode-editor-service-override';
-import type { Logger } from 'monaco-languageclient/common';
+import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
 import type { MonacoEnvironmentEnhanced } from './config.js';
 
 export const getEnhancedMonacoEnvironment = (): MonacoEnvironmentEnhanced => {
@@ -26,7 +26,7 @@ export const getEnhancedMonacoEnvironment = (): MonacoEnvironmentEnhanced => {
     return envEnhanced;
 };
 
-export const reportServiceLoading = (services: monaco.editor.IEditorOverrideServices, logger?: Logger) => {
+export const reportServiceLoading = (services: monaco.editor.IEditorOverrideServices, logger?: ILogger) => {
     for (const serviceName of Object.keys(services)) {
         logger?.debug(`Loading service: ${serviceName}`);
     }
@@ -40,7 +40,7 @@ export const mergeServices = (overrideServices: monaco.editor.IEditorOverrideSer
     }
 };
 
-export const useOpenEditorStub: OpenEditor = async (modelRef, options, sideBySide, logger?: Logger) => {
+export const useOpenEditorStub: OpenEditor = async (modelRef, options, sideBySide, logger?: ILogger) => {
     logger?.info('Received open editor call with parameters: ', modelRef, options, sideBySide);
     return undefined;
 };
diff --git a/packages/client/src/worker/index.ts b/packages/client/src/worker/index.ts
@@ -3,8 +3,8 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
+import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
 import { getEnhancedMonacoEnvironment } from 'monaco-languageclient/vscodeApiWrapper';
-import type { Logger } from 'monaco-languageclient/common';
 
 export class Worker {
     url: string | URL;
@@ -20,7 +20,7 @@ export type WorkerLoader = (() => Worker) | undefined;
 
 export interface WorkerFactoryConfig {
     workerLoaders?: Partial<Record<string, WorkerLoader>>;
-    logger?: Logger;
+    logger?: ILogger;
 }
 
 export const useWorkerFactory = (config: WorkerFactoryConfig) => {
@@ -64,7 +64,7 @@ export const defineDefaultWorkerLoaders: () => Partial<Record<string, WorkerLoad
     };
 };
 
-export const configureDefaultWorkerFactory = (logger?: Logger) => {
+export const configureDefaultWorkerFactory = (logger?: ILogger) => {
     useWorkerFactory({
         workerLoaders: defineDefaultWorkerLoaders(),
         logger
diff --git a/packages/client/src/wrapper/lcmanager.ts b/packages/client/src/wrapper/lcmanager.ts
@@ -4,13 +4,13 @@
  * ------------------------------------------------------------------------------------------ */
 
 import { LogLevel } from '@codingame/monaco-vscode-api';
-import { ConsoleLogger, type Logger } from 'monaco-languageclient/common';
+import { ConsoleLogger, type ILogger } from '@codingame/monaco-vscode-log-service-override';
 import type { LanguageClientConfig, LanguageClientConfigs } from './lcconfig.js';
 import { LanguageClientWrapper } from './lcwrapper.js';
 
 export class LanguageClientManager {
 
-    private logger: Logger = new ConsoleLogger();
+    private logger: ILogger = new ConsoleLogger();
     private languageClientConfigs?: LanguageClientConfigs;
     private languageClientWrappers: Map<string, LanguageClientWrapper> = new Map();
 
diff --git a/packages/client/src/wrapper/lcwrapper.ts b/packages/client/src/wrapper/lcwrapper.ts
@@ -3,13 +3,14 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-languageserver-protocol/browser.js';
+import { LogLevel } from '@codingame/monaco-vscode-api';
+import { ConsoleLogger, type ILogger } from '@codingame/monaco-vscode-log-service-override';
+import { MonacoLanguageClient, MonacoLanguageClientWithProposedFeatures } from 'monaco-languageclient';
+import { createUrl, type WorkerConfigOptionsDirect, type WorkerConfigOptionsParams } from 'monaco-languageclient/common';
 import { CloseAction, ErrorAction, MessageTransports, State } from 'vscode-languageclient/browser.js';
-import { ConsoleLogger, createUrl, type Logger, type WorkerConfigOptionsDirect, type WorkerConfigOptionsParams } from 'monaco-languageclient/common';
+import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-languageserver-protocol/browser.js';
 import { toSocket, WebSocketMessageReader, WebSocketMessageWriter } from 'vscode-ws-jsonrpc';
-import { MonacoLanguageClient, MonacoLanguageClientWithProposedFeatures } from 'monaco-languageclient';
 import type { LanguageClientConfig, LanguageClientRestartOptions } from './lcconfig.js';
-import { LogLevel } from '@codingame/monaco-vscode-api';
 
 export interface LanguageClientError {
     message: string;
@@ -23,7 +24,7 @@ export class LanguageClientWrapper {
     private worker?: Worker;
     private port?: MessagePort;
     private languageId: string;
-    private logger: Logger | undefined;
+    private logger: ILogger | undefined;
 
     constructor(config: LanguageClientConfig) {
         this.languageClientConfig = config;
diff --git a/packages/client/test/common/logging.test.ts b/packages/client/test/common/logging.test.ts
@@ -3,16 +3,16 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { describe, expect, test } from 'vitest';
-import { ConsoleLogger } from 'monaco-languageclient/common';
 import { LogLevel } from '@codingame/monaco-vscode-api';
+import { ConsoleLogger } from '@codingame/monaco-vscode-log-service-override';
+import { describe, expect, test } from 'vitest';
 
 describe('Logger', () => {
 
     test('Config: None', () => {
         const logger = new ConsoleLogger();
 
-        expect(logger.getLevel()).toBe(LogLevel.Off);
+        expect(logger.getLevel()).toBe(LogLevel.Info);
     });
 
     test('Config: Off', () => {
diff --git a/packages/client/test/editorApp/editorApp.test.ts b/packages/client/test/editorApp/editorApp.test.ts
@@ -6,7 +6,7 @@
 /* eslint-disable dot-notation */
 
 import { LogLevel } from '@codingame/monaco-vscode-api';
-import type { Logger } from 'monaco-languageclient/common';
+import { type ILogger } from '@codingame/monaco-vscode-log-service-override';
 import { encodeStringOrUrlToDataUrl } from 'monaco-languageclient/common';
 import { EditorApp, type TextContents } from 'monaco-languageclient/editorApp';
 import { MonacoVscodeApiWrapper } from 'monaco-languageclient/vscodeApiWrapper';
@@ -249,13 +249,13 @@ describe('Test EditorApp', () => {
             }
         });
         let editorApp = new EditorApp(editorAppConfig);
-        let logLevel = (editorApp['logger'] as Logger).getLevel();
+        let logLevel = (editorApp['logger'] as ILogger).getLevel();
         expect(logLevel).toBe(LogLevel.Off);
         expect(logLevel).toBe(0);
 
         editorAppConfig.logLevel = LogLevel.Debug;
         editorApp = new EditorApp(editorAppConfig);
-        logLevel = (editorApp['logger'] as Logger).getLevel();
+        logLevel = (editorApp['logger'] as ILogger).getLevel();
         expect(logLevel).toBe(LogLevel.Debug);
         expect(logLevel).toBe(2);
     });
diff --git a/packages/client/test/support/helper-classic.ts b/packages/client/test/support/helper-classic.ts
@@ -3,8 +3,8 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
+import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
 import { useWorkerFactory, Worker, type WorkerLoader } from 'monaco-languageclient/workerFactory';
-import type { Logger } from 'monaco-languageclient/common';
 
 const workerResolver: Map<string, (value: void | PromiseLike<void>) => void> = new Map();
 const workerPromises: Map<string, Promise<void>> = new Map();
@@ -76,7 +76,7 @@ export const defineClassicWorkers: () => Partial<Record<string, WorkerLoader>> =
     };
 };
 
-export const configureClassicWorkerFactory = (logger?: Logger) => {
+export const configureClassicWorkerFactory = (logger?: ILogger) => {
     useWorkerFactory({
         workerLoaders: defineClassicWorkers(),
         logger
diff --git a/packages/client/test/vscode/manager.editorservice.test.ts b/packages/client/test/vscode/manager.editorservice.test.ts
@@ -2,6 +2,9 @@
  * Copyright (c) 2025 TypeFox and others.
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
+
+import { LogLevel } from '@codingame/monaco-vscode-api';
+import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
 import { MonacoVscodeApiWrapper } from 'monaco-languageclient/vscodeApiWrapper';
 import { describe, expect, test } from 'vitest';
 import { createDefaultMonacoVscodeApiConfig } from '../support/helper.js';
@@ -14,6 +17,9 @@ describe('MonacoVscodeApiWrapper Tests: Different config', () => {
         const apiWrapper = new MonacoVscodeApiWrapper(apiConfig!);
         const awaited = await apiWrapper.start();
         expect(awaited).toBeUndefined();
+
+        // eslint-disable-next-line dot-notation
+        expect((apiWrapper['logger'] as ILogger).getLevel()).toBe(LogLevel.Off);
     });
 
 });
diff --git a/packages/client/test/worker/workerFactory.test.ts b/packages/client/test/worker/workerFactory.test.ts
@@ -3,11 +3,11 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { describe, expect, test } from 'vitest';
 import { LogLevel } from '@codingame/monaco-vscode-api';
-import { ConsoleLogger } from 'monaco-languageclient/common';
-import { useWorkerFactory, Worker } from 'monaco-languageclient/workerFactory';
+import { ConsoleLogger } from '@codingame/monaco-vscode-log-service-override';
 import { getEnhancedMonacoEnvironment } from 'monaco-languageclient/vscodeApiWrapper';
+import { useWorkerFactory, Worker } from 'monaco-languageclient/workerFactory';
+import { describe, expect, test } from 'vitest';
 
 describe('WorkerFactory Tests', () => {
 
diff --git a/packages/client/test/wrapper/lcmanager.test.ts b/packages/client/test/wrapper/lcmanager.test.ts
diff --git a/packages/client/test/wrapper/lcwrapper.test.ts b/packages/client/test/wrapper/lcwrapper.test.ts
diff --git a/packages/examples/src/json/client/classic.ts b/packages/examples/src/json/client/classic.ts
diff --git a/packages/examples/src/langium/statemachine/main-react.tsx b/packages/examples/src/langium/statemachine/main-react.tsx
diff --git a/packages/wrapper-react/src/index.tsx b/packages/wrapper-react/src/index.tsx
