monaco-languageclient 10.7.0 → 11.0.0-next.0

package/src/vscode/config.ts

@@ -7,7 +7,7 @@ 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 { editor, Environment } from '@codingame/monaco-vscode-editor-api';
 import type { OpenEditor } from '@codingame/monaco-vscode-editor-service-override';
 import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
 
@@ -17,45 +17,45 @@ export type ViewsConfigTypes = 'EditorService' | 'ViewsService' | 'WorkbenchServ
 
 // export type HtmlContainerConfig = HTMLElement;
 
-export interface MonacoEnvironmentEnhanced extends monaco.Environment {
-    vscodeApiInitialising?: boolean;
-    vscodeApiInitialised?: boolean;
-    vscodeApiGlobalInitAwait?: Promise<void>;
-    vscodeApiGlobalInitResolve?: ((value: void | PromiseLike<void>) => void);
-    viewServiceType?: ViewsConfigTypes;
+export interface MonacoEnvironmentEnhanced extends Environment {
+  vscodeApiInitialising?: boolean;
+  vscodeApiInitialised?: boolean;
+  vscodeApiGlobalInitAwait?: Promise<void>;
+  vscodeApiGlobalInitResolve?: (value: void | PromiseLike<void>) => void;
+  viewServiceType?: ViewsConfigTypes;
 }
 
 export interface UserConfiguration {
-    json?: string;
+  json?: string;
 }
 
 export interface ViewsConfig {
-    $type: ViewsConfigTypes;
-    htmlContainer?: HTMLElement;
-    openEditorFunc?: OpenEditor;
-    htmlAugmentationInstructions?: (htmlContainer: HTMLElement | null | undefined) => void;
-    viewsInitFunc?: () => Promise<void>;
+  $type: ViewsConfigTypes;
+  htmlContainer?: HTMLElement;
+  openEditorFunc?: OpenEditor;
+  htmlAugmentationInstructions?: (htmlContainer: HTMLElement | null | undefined) => void;
+  viewsInitFunc?: () => Promise<void>;
 }
 
 export interface ExtensionConfig {
-    config: IExtensionManifest;
-    filesOrContents?: Map<string, string | URL>;
+  config: IExtensionManifest;
+  filesOrContents?: Map<string, string | URL>;
 }
 
 export interface MonacoVscodeApiConfig {
-    $type: OverallConfigType;
-    viewsConfig: ViewsConfig,
-    serviceOverrides?: monaco.editor.IEditorOverrideServices;
-    logLevel?: LogLevel | number;
-    workspaceConfig?: IWorkbenchConstructionOptions;
-    userConfiguration?: UserConfiguration;
-    envOptions?: EnvironmentOverride;
-    extensions?: ExtensionConfig[];
-    monacoWorkerFactory?: (logger?: ILogger) => void;
-    advanced?: {
-        loadExtensionServices?: boolean;
-        enableExtHostWorker?: boolean;
-        loadThemes?: boolean;
-        enforceSemanticHighlighting?: boolean;
-    };
+  $type: OverallConfigType;
+  viewsConfig: ViewsConfig;
+  serviceOverrides?: editor.IEditorOverrideServices;
+  logLevel?: LogLevel | number;
+  workspaceConfig?: IWorkbenchConstructionOptions;
+  userConfiguration?: UserConfiguration;
+  envOptions?: EnvironmentOverride;
+  extensions?: ExtensionConfig[];
+  monacoWorkerFactory?: (logger?: ILogger) => void;
+  advanced?: {
+    loadExtensionServices?: boolean;
+    enableExtHostWorker?: boolean;
+    loadThemes?: boolean;
+    enforceSemanticHighlighting?: boolean;
+  };
 }

package/src/vscode/locales.ts

@@ -7,123 +7,140 @@ import type { LocalizationOptions } from '@codingame/monaco-vscode-localization-
 import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
 
 export const createDefaultLocaleConfiguration = (): LocalizationOptions => {
-    return {
-        async clearLocale() {
-            const url = new URL(window.location.href);
-            url.searchParams.delete('locale');
-            window.history.pushState(null, '', url.toString());
-        },
-        async setLocale(id: string) {
-            const url = new URL(window.location.href);
-            url.searchParams.set('locale', id);
-            window.history.pushState(null, '', url.toString());
-        },
-        availableLanguages: [{
-            locale: 'en',
-            languageName: 'English'
-        }, {
-            locale: 'cs',
-            languageName: 'Czech'
-        }, {
-            locale: 'de',
-            languageName: 'German'
-        }, {
-            locale: 'es',
-            languageName: 'Spanish'
-        }, {
-            locale: 'fr',
-            languageName: 'French'
-        }, {
-            locale: 'it',
-            languageName: 'Italian'
-        }, {
-            locale: 'ja',
-            languageName: 'Japanese'
-        }, {
-            locale: 'ko',
-            languageName: 'Korean'
-        }, {
-            locale: 'pl',
-            languageName: 'Polish'
-        }, {
-            locale: 'pt-br',
-            languageName: 'Portuguese (Brazil)'
-        }, {
-            locale: 'qps-ploc',
-            languageName: 'Pseudo Language'
-        }, {
-            locale: 'ru',
-            languageName: 'Russian'
-        }, {
-            locale: 'tr',
-            languageName: 'Turkish'
-        }, {
-            locale: 'zh-hans',
-            languageName: 'Chinese (Simplified)'
-        }, {
-            locale: 'zh-hant',
-            languageName: 'Chinese (Traditional)'
-        }, {
-            locale: 'en',
-            languageName: 'English'
-        }]
-    };
+  return {
+    async clearLocale() {
+      const url = new URL(window.location.href);
+      url.searchParams.delete('locale');
+      window.history.pushState(null, '', url.toString());
+    },
+    async setLocale(id: string) {
+      const url = new URL(window.location.href);
+      url.searchParams.set('locale', id);
+      window.history.pushState(null, '', url.toString());
+    },
+    availableLanguages: [
+      {
+        locale: 'en',
+        languageName: 'English'
+      },
+      {
+        locale: 'cs',
+        languageName: 'Czech'
+      },
+      {
+        locale: 'de',
+        languageName: 'German'
+      },
+      {
+        locale: 'es',
+        languageName: 'Spanish'
+      },
+      {
+        locale: 'fr',
+        languageName: 'French'
+      },
+      {
+        locale: 'it',
+        languageName: 'Italian'
+      },
+      {
+        locale: 'ja',
+        languageName: 'Japanese'
+      },
+      {
+        locale: 'ko',
+        languageName: 'Korean'
+      },
+      {
+        locale: 'pl',
+        languageName: 'Polish'
+      },
+      {
+        locale: 'pt-br',
+        languageName: 'Portuguese (Brazil)'
+      },
+      {
+        locale: 'qps-ploc',
+        languageName: 'Pseudo Language'
+      },
+      {
+        locale: 'ru',
+        languageName: 'Russian'
+      },
+      {
+        locale: 'tr',
+        languageName: 'Turkish'
+      },
+      {
+        locale: 'zh-hans',
+        languageName: 'Chinese (Simplified)'
+      },
+      {
+        locale: 'zh-hant',
+        languageName: 'Chinese (Traditional)'
+      },
+      {
+        locale: 'en',
+        languageName: 'English'
+      }
+    ]
+  };
 };
 
 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');
-    }
+  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');
+  }
 };
 
 export const locales = Object.keys(localeLoader);
 
 export const initLocaleLoader = async (locale = new URLSearchParams(window.location.search).get('locale'), logger?: ILogger) => {
-    if (locale !== null) {
-        const loader = localeLoader[locale];
-        if (loader) {
-            await loader();
-        } else {
-            logger?.error(`Unknown locale ${locale}`);
-        }
+  if (locale !== null) {
+    const loader = localeLoader[locale];
+    if (loader !== undefined) {
+      await loader();
+    } else {
+      logger?.error(`Unknown locale ${locale}`);
     }
+  }
 };

package/src/vscode/utils.ts

@@ -3,44 +3,38 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import * as monaco from '@codingame/monaco-vscode-editor-api';
+import type { editor } from '@codingame/monaco-vscode-editor-api';
 import type { OpenEditor } from '@codingame/monaco-vscode-editor-service-override';
 import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
 import type { MonacoEnvironmentEnhanced } from './config.js';
 
 export const getEnhancedMonacoEnvironment = (): MonacoEnvironmentEnhanced => {
-    if (typeof MonacoEnvironment === 'undefined') {
-        globalThis.MonacoEnvironment = {};
-    }
-    const envEnhanced = MonacoEnvironment as MonacoEnvironmentEnhanced;
-    if (envEnhanced.vscodeApiInitialising === undefined) {
-        envEnhanced.vscodeApiInitialising = false;
-    }
-    if (envEnhanced.vscodeApiInitialised === undefined) {
-        envEnhanced.vscodeApiInitialised = false;
-    }
-    if (envEnhanced.viewServiceType === undefined) {
-        envEnhanced.viewServiceType = 'EditorService';
-    }
+  if (typeof MonacoEnvironment === 'undefined') {
+    globalThis.MonacoEnvironment = {};
+  }
+  const envEnhanced = MonacoEnvironment as MonacoEnvironmentEnhanced;
+  envEnhanced.vscodeApiInitialising ??= false;
+  envEnhanced.vscodeApiInitialised ??= false;
+  envEnhanced.viewServiceType ??= 'EditorService';
 
-    return envEnhanced;
+  return envEnhanced;
 };
 
-export const reportServiceLoading = (services: monaco.editor.IEditorOverrideServices, logger?: ILogger) => {
-    for (const serviceName of Object.keys(services)) {
-        logger?.debug(`Loading service: ${serviceName}`);
-    }
+export const reportServiceLoading = (services: editor.IEditorOverrideServices, logger?: ILogger) => {
+  for (const serviceName of Object.keys(services)) {
+    logger?.debug(`Loading service: ${serviceName}`);
+  }
 };
 
-export const mergeServices = (overrideServices: monaco.editor.IEditorOverrideServices, services?: monaco.editor.IEditorOverrideServices) => {
-    if (services !== undefined) {
-        for (const [name, service] of Object.entries(services)) {
-            overrideServices[name] = service;
-        }
+export const mergeServices = (overrideServices: editor.IEditorOverrideServices, services?: editor.IEditorOverrideServices) => {
+  if (services !== undefined) {
+    for (const [name, service] of Object.entries(services)) {
+      overrideServices[name] = service;
     }
+  }
 };
 
 export const useOpenEditorStub: OpenEditor = async (modelRef, options, sideBySide, logger?: ILogger) => {
-    logger?.info('Received open editor call with parameters: ', modelRef, options, sideBySide);
-    return undefined;
+  logger?.info('Received open editor call with parameters: ', modelRef, options, sideBySide);
+  return undefined;
 };

package/src/vscode/viewsService.ts

@@ -4,44 +4,51 @@
  * ------------------------------------------------------------------------------------------ */
 
 export const defaultViewsInit = async () => {
-    const { Parts, Position, onPartVisibilityChange, isPartVisibile, attachPart, getSideBarPosition, onDidChangeSideBarPosition } = await import('@codingame/monaco-vscode-views-service-override');
+  const { Parts, Position, onPartVisibilityChange, isPartVisibile, attachPart, getSideBarPosition, onDidChangeSideBarPosition } =
+    await import('@codingame/monaco-vscode-views-service-override');
 
-    for (const config of [
-        { part: Parts.TITLEBAR_PART, element: '#titleBar' },
-        { part: Parts.BANNER_PART, element: '#banner' },
-        {
-            part: Parts.SIDEBAR_PART, get element() {
-                return getSideBarPosition() === Position.LEFT ? '#sidebar' : '#sidebar-right';
-            }, onDidElementChange: onDidChangeSideBarPosition
-        },
-        {
-            part: Parts.ACTIVITYBAR_PART, get element() {
-                return getSideBarPosition() === Position.LEFT ? '#activityBar' : '#activityBar-right';
-            }, onDidElementChange: onDidChangeSideBarPosition
-        },
-        {
-            part: Parts.AUXILIARYBAR_PART, get element() {
-                return getSideBarPosition() === Position.LEFT ? '#auxiliaryBar' : '#auxiliaryBar-left';
-            }, onDidElementChange: onDidChangeSideBarPosition
-        },
-        { part: Parts.EDITOR_PART, element: '#editors' },
-        { part: Parts.PANEL_PART, element: '#panel' },
-        { part: Parts.STATUSBAR_PART, element: '#statusBar' }
-    ]) {
-        attachPart(config.part, document.querySelector<HTMLDivElement>(config.element)!);
+  for (const config of [
+    { part: Parts.TITLEBAR_PART, element: '#titleBar' },
+    { part: Parts.BANNER_PART, element: '#banner' },
+    {
+      part: Parts.SIDEBAR_PART,
+      get element() {
+        return getSideBarPosition() === Position.LEFT ? '#sidebar' : '#sidebar-right';
+      },
+      onDidElementChange: onDidChangeSideBarPosition
+    },
+    {
+      part: Parts.ACTIVITYBAR_PART,
+      get element() {
+        return getSideBarPosition() === Position.LEFT ? '#activityBar' : '#activityBar-right';
+      },
+      onDidElementChange: onDidChangeSideBarPosition
+    },
+    {
+      part: Parts.AUXILIARYBAR_PART,
+      get element() {
+        return getSideBarPosition() === Position.LEFT ? '#auxiliaryBar' : '#auxiliaryBar-left';
+      },
+      onDidElementChange: onDidChangeSideBarPosition
+    },
+    { part: Parts.EDITOR_PART, element: '#editors' },
+    { part: Parts.PANEL_PART, element: '#panel' },
+    { part: Parts.STATUSBAR_PART, element: '#statusBar' }
+  ]) {
+    attachPart(config.part, document.querySelector<HTMLDivElement>(config.element)!);
 
-        config.onDidElementChange?.(() => {
-            attachPart(config.part, document.querySelector<HTMLDivElement>(config.element)!);
-        });
+    config.onDidElementChange?.(() => {
+      attachPart(config.part, document.querySelector<HTMLDivElement>(config.element)!);
+    });
 
-        if (!isPartVisibile(config.part)) {
-            document.querySelector<HTMLDivElement>(config.element)!.style.display = 'none';
-        }
-
-        onPartVisibilityChange(config.part, visible => {
-            document.querySelector<HTMLDivElement>(config.element)!.style.display = visible ? 'block' : 'none';
-        });
+    if (!isPartVisibile(config.part)) {
+      document.querySelector<HTMLDivElement>(config.element)!.style.display = 'none';
     }
+
+    onPartVisibilityChange(config.part, (visible) => {
+      document.querySelector<HTMLDivElement>(config.element)!.style.display = visible ? 'block' : 'none';
+    });
+  }
 };
 
 export const defaultViewsHtml = `<div id="workbench-container">
@@ -67,7 +74,7 @@ export const defaultViewsHtml = `<div id="workbench-container">
 </div>`;
 
 export const defaultHtmlAugmentationInstructions = (htmlElement: HTMLElement | null | undefined) => {
-    const htmlContainer = document.createElement('div', { is: 'app' });
-    htmlContainer.innerHTML = defaultViewsHtml;
-    htmlElement?.append(htmlContainer);
+  const htmlContainer = document.createElement('div', { is: 'app' });
+  htmlContainer.innerHTML = defaultViewsHtml;
+  htmlElement?.append(htmlContainer);
 };

package/src/worker/index.ts

@@ -7,67 +7,60 @@ import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
 import { getEnhancedMonacoEnvironment } from 'monaco-languageclient/vscodeApiWrapper';
 
 export class Worker {
-    url: string | URL;
-    options?: WorkerOptions;
+  url: string | URL;
+  options?: WorkerOptions;
 
-    constructor(url: string | URL, options?: WorkerOptions) {
-        this.url = url;
-        this.options = options;
-    }
+  constructor(url: string | URL, options?: WorkerOptions) {
+    this.url = url;
+    this.options = options;
+  }
 }
 
 export type WorkerLoader = (() => Worker) | undefined;
 
 export interface WorkerFactoryConfig {
-    workerLoaders?: Partial<Record<string, WorkerLoader>>;
-    logger?: ILogger;
+  workerLoaders?: Partial<Record<string, WorkerLoader>>;
+  logger?: ILogger;
 }
 
 export const useWorkerFactory = (config: WorkerFactoryConfig) => {
-    const envEnhanced = getEnhancedMonacoEnvironment();
+  const envEnhanced = getEnhancedMonacoEnvironment();
 
-    envEnhanced.getWorkerUrl = (workerId: string, label: string) => {
-        config.logger?.info(`getWorkerUrl: workerId: ${workerId} label: ${label}`);
-        return config.workerLoaders?.[label]?.().url.toString();
-    };
+  envEnhanced.getWorkerUrl = (workerId: string, label: string) => {
+    config.logger?.info(`getWorkerUrl: workerId: ${workerId} label: ${label}`);
+    return config.workerLoaders?.[label]?.().url.toString();
+  };
 
-    envEnhanced.getWorkerOptions = (moduleId: string, label: string) => {
-        config.logger?.info(`getWorkerOptions: moduleId: ${moduleId} label: ${label}`);
-        return config.workerLoaders?.[label]?.().options;
-    };
+  envEnhanced.getWorkerOptions = (moduleId: string, label: string) => {
+    config.logger?.info(`getWorkerOptions: moduleId: ${moduleId} label: ${label}`);
+    return config.workerLoaders?.[label]?.().options;
+  };
 };
 
 export const defineDefaultWorkerLoaders: () => Partial<Record<string, WorkerLoader>> = () => {
-    const defaultEditorWorkerService = () => new Worker(
-        new URL('@codingame/monaco-vscode-editor-api/esm/vs/editor/editor.worker.js', import.meta.url),
-        { type: 'module' }
-    );
-    const defaultExtensionHostWorkerMain = () => new Worker(
-        new URL('@codingame/monaco-vscode-api/workers/extensionHost.worker', import.meta.url),
-        { type: 'module' }
-    );
-    const defaultTextMateWorker = () => new Worker(
-        new URL('@codingame/monaco-vscode-textmate-service-override/worker', import.meta.url),
-        { type: 'module' }
-    );
+  const defaultEditorWorkerService = () =>
+    new Worker(new URL('@codingame/monaco-vscode-editor-api/esm/vs/editor/editor.worker.js', import.meta.url), { type: 'module' });
+  const defaultExtensionHostWorkerMain = () =>
+    new Worker(new URL('@codingame/monaco-vscode-api/workers/extensionHost.worker', import.meta.url), { type: 'module' });
+  const defaultTextMateWorker = () =>
+    new Worker(new URL('@codingame/monaco-vscode-textmate-service-override/worker', import.meta.url), { type: 'module' });
 
-    return {
-        // if you import monaco api as 'monaco-editor': monaco-editor/esm/vs/editor/editor.worker.js
-        editorWorkerService: defaultEditorWorkerService,
-        extensionHostWorkerMain: defaultExtensionHostWorkerMain,
-        TextMateWorker: defaultTextMateWorker,
-        // these are other possible workers not configured by default
-        OutputLinkDetectionWorker: undefined,
-        LanguageDetectionWorker: undefined,
-        NotebookEditorWorker: undefined,
-        LocalFileSearchWorker: undefined
-    };
+  return {
+    // if you import monaco api as 'monaco-editor': monaco-editor/esm/vs/editor/editor.worker.js
+    editorWorkerService: defaultEditorWorkerService,
+    extensionHostWorkerMain: defaultExtensionHostWorkerMain,
+    TextMateWorker: defaultTextMateWorker,
+    // these are other possible workers not configured by default
+    OutputLinkDetectionWorker: undefined,
+    LanguageDetectionWorker: undefined,
+    NotebookEditorWorker: undefined,
+    LocalFileSearchWorker: undefined
+  };
 };
 
 export const configureDefaultWorkerFactory = (logger?: ILogger) => {
-    useWorkerFactory({
-        workerLoaders: defineDefaultWorkerLoaders(),
-        logger
-    });
+  useWorkerFactory({
+    workerLoaders: defineDefaultWorkerLoaders(),
+    logger
+  });
 };
-

package/src/wrapper/lcconfig.ts

@@ -5,31 +5,31 @@
 
 import { LogLevel } from '@codingame/monaco-vscode-api';
 import { type ConnectionConfigOptions } from 'monaco-languageclient/common';
-import type { DynamicFeature, LanguageClientOptions, MessageTransports, StaticFeature } from 'vscode-languageclient/browser.js';
+import type { DynamicFeature, LanguageClientOptions, MessageTransports, StaticFeature } from 'vscode-languageclient/browser';
 
 export interface ConnectionConfig {
-    options: ConnectionConfigOptions;
-    messageTransports?: MessageTransports;
+  options: ConnectionConfigOptions;
+  messageTransports?: MessageTransports;
 }
 
 export interface LanguageClientConfig {
-    languageId: string;
-    connection: ConnectionConfig;
-    clientOptions: LanguageClientOptions;
-    restartOptions?: LanguageClientRestartOptions;
-    useClientWithProposedFeatures?: boolean;
-    // oxlint-disable-next-line @typescript-eslint/no-explicit-any
-    registerFeatures?: Array<(StaticFeature | DynamicFeature<any>)>;
-    disposeWorker?: boolean;
-    logLevel?: LogLevel | number;
+  languageId: string;
+  connection: ConnectionConfig;
+  clientOptions: LanguageClientOptions;
+  restartOptions?: LanguageClientRestartOptions;
+  useClientWithProposedFeatures?: boolean;
+  // oxlint-disable-next-line @typescript-eslint/no-explicit-any
+  registerFeatures?: Array<StaticFeature | DynamicFeature<any>>;
+  disposeWorker?: boolean;
+  logLevel?: LogLevel | number;
 }
 
 export interface LanguageClientRestartOptions {
-    retries: number;
-    timeout: number;
-    keepWorker?: boolean;
+  retries: number;
+  timeout: number;
+  keepWorker?: boolean;
 }
 
 export interface LanguageClientConfigs {
-    configs: Record<string, LanguageClientConfig>;
+  configs: Record<string, LanguageClientConfig>;
 }