monaco-languageclient 10.7.0 → 11.0.0-next.0

package/src/common/utils.ts

@@ -6,62 +6,62 @@
 import type { WebSocketUrlParams, WebSocketUrlString } from './commonTypes.js';
 
 export const createUrl = (config: WebSocketUrlParams | WebSocketUrlString) => {
-    let buildUrl = '';
-    if ((config as WebSocketUrlString).url) {
-        const options = config as WebSocketUrlString;
-        if (!options.url.startsWith('ws://') && !options.url.startsWith('wss://')) {
-            throw new Error(`This is not a proper websocket url: ${options.url}`);
-        }
-        buildUrl = options.url;
-    } else {
-        const options = config as WebSocketUrlParams;
-        const protocol = options.secured ? 'wss' : 'ws';
-        buildUrl = `${protocol}://${options.host}`;
-        if (options.port !== undefined) {
-            if (options.port !== 80) {
-                buildUrl += `:${options.port}`;
-            }
-        }
-        if (options.path !== undefined) {
-            buildUrl += `/${options.path}`;
-        }
-        if (options.extraParams) {
-            const url = new URL(buildUrl);
+  let buildUrl = '';
+  if (Object.hasOwn(config, 'url')) {
+    const options = config as WebSocketUrlString;
+    if (!options.url.startsWith('ws://') && !options.url.startsWith('wss://')) {
+      throw new Error(`This is not a proper websocket url: ${options.url}`);
+    }
+    buildUrl = options.url;
+  } else {
+    const options = config as WebSocketUrlParams;
+    const protocol = options.secured ? 'wss' : 'ws';
+    buildUrl = `${protocol}://${options.host}`;
+    if (options.port !== undefined) {
+      if (options.port !== 80) {
+        buildUrl += `:${options.port}`;
+      }
+    }
+    if (options.path !== undefined) {
+      buildUrl += `/${options.path}`;
+    }
+    if (options.extraParams !== undefined) {
+      const url = new URL(buildUrl);
 
-            for (const [key, value] of Object.entries(options.extraParams)) {
-                url.searchParams.set(key, value instanceof Array ? value.join(',') : value.toString());
-            }
+      for (const [key, value] of Object.entries(options.extraParams)) {
+        url.searchParams.set(key, value instanceof Array ? value.join(',') : value.toString());
+      }
 
-            buildUrl = url.toString();
-        }
+      buildUrl = url.toString();
     }
-    return buildUrl;
+  }
+  return buildUrl;
 };
 
 export const encodeStringOrUrlToDataUrl = (input: string | URL) => {
-    if (input instanceof URL) {
-        return input.href;
-    } else {
-        const bytes = new TextEncoder().encode(input);
-        const binString = Array.from(bytes, (b) => String.fromCodePoint(b)).join('');
-        const base64 = btoa(binString);
-        return new URL(`data:text/plain;base64,${base64}`).href;
-    }
+  if (input instanceof URL) {
+    return input.href;
+  } else {
+    const bytes = new TextEncoder().encode(input);
+    const binString = Array.from(bytes, (b) => String.fromCodePoint(b)).join('');
+    const base64 = btoa(binString);
+    return new URL(`data:text/plain;base64,${base64}`).href;
+  }
 };
 
 export const delayExecution = (ms: number) => {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 };
 
 export class Deferred<T = void> {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: unknown) => void;
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (reason?: unknown) => void;
 
-    constructor() {
-        this.promise = new Promise<T>((res, rej) => {
-            this.resolve = res;
-            this.reject = rej;
-        });
-    }
+  constructor() {
+    this.promise = new Promise<T>((res, rej) => {
+      this.resolve = res;
+      this.reject = rej;
+    });
+  }
 }

package/src/debugger/index.ts

@@ -14,155 +14,152 @@ import { Uri } from 'vscode';
 // The client configuration is generic and can be used for a another language
 
 export type FileDefinition = {
-    path: string;
-    code: string;
-    uri: Uri;
-}
+  path: string;
+  code: string;
+  uri: Uri;
+};
 
 export type InitMessage = {
-    id: 'init',
-    files: Record<string, FileDefinition>
-    defaultFile: string;
-    debuggerExecCall: string;
+  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;
-}
+  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
-    };
+  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?: ILogger) => {
-    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));
-            };
-        }
+  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;
+    _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();
-        }
+    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);
     }
 
-    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));
-
-            // oxlint-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);
+    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));
+
+      // oxlint-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
-        )
-    );
+  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/config.ts

@@ -5,61 +5,61 @@
 
 import { LogLevel } from '@codingame/monaco-vscode-api';
 import { type ITextFileEditorModel } from '@codingame/monaco-vscode-api/monaco';
-import * as monaco from '@codingame/monaco-vscode-editor-api';
+import type { editor, languages, IDisposable } from '@codingame/monaco-vscode-editor-api';
 import type { IReference } from '@codingame/monaco-vscode-editor-service-override';
 
 export class ModelRefs {
-    modified?: IReference<ITextFileEditorModel>;
-    original?: IReference<ITextFileEditorModel>;
+  modified?: IReference<ITextFileEditorModel>;
+  original?: IReference<ITextFileEditorModel>;
 }
 
 export interface TextModels {
-    modified?: monaco.editor.ITextModel | null;
-    original?: monaco.editor.ITextModel | null;
+  modified?: editor.ITextModel | null;
+  original?: editor.ITextModel | null;
 }
 
 export interface TextContents {
-    modified?: string;
-    original?: string;
+  modified?: string;
+  original?: string;
 }
 
 export interface CodeContent {
-    text: string;
-    uri: string;
-    enforceLanguageId?: string;
+  text: string;
+  uri: string;
+  enforceLanguageId?: string;
 }
 
 export interface CodeResources {
-    modified?: CodeContent;
-    original?: CodeContent;
+  modified?: CodeContent;
+  original?: CodeContent;
 }
 
 export interface CallbackDisposeable {
-    modified?: monaco.IDisposable;
-    original?: monaco.IDisposable;
+  modified?: IDisposable;
+  original?: IDisposable;
 }
 
 export interface DisposableModelRefs {
-    modified?: IReference<ITextFileEditorModel>;
-    original?: IReference<ITextFileEditorModel>;
+  modified?: IReference<ITextFileEditorModel>;
+  original?: IReference<ITextFileEditorModel>;
 }
 
 export interface EditorAppConfig {
-    id?: string;
-    logLevel?: LogLevel | number;
-    codeResources?: CodeResources;
-    useDiffEditor?: boolean;
-    domReadOnly?: boolean;
-    readOnly?: boolean;
-    overrideAutomaticLayout?: boolean;
-    editorOptions?: monaco.editor.IStandaloneEditorConstructionOptions;
-    diffEditorOptions?: monaco.editor.IStandaloneDiffEditorConstructionOptions;
-    languageDef?: {
-        languageExtensionConfig: monaco.languages.ILanguageExtensionPoint;
-        monarchLanguage?: monaco.languages.IMonarchLanguage;
-        theme?: {
-            name: monaco.editor.BuiltinTheme | string;
-            data: monaco.editor.IStandaloneThemeData;
-        }
-    }
+  id?: string;
+  logLevel?: LogLevel | number;
+  codeResources?: CodeResources;
+  useDiffEditor?: boolean;
+  domReadOnly?: boolean;
+  readOnly?: boolean;
+  overrideAutomaticLayout?: boolean;
+  editorOptions?: editor.IStandaloneEditorConstructionOptions;
+  diffEditorOptions?: editor.IStandaloneDiffEditorConstructionOptions;
+  languageDef?: {
+    languageExtensionConfig: languages.ILanguageExtensionPoint;
+    monarchLanguage?: languages.IMonarchLanguage;
+    theme?: {
+      name: string;
+      data: editor.IStandaloneThemeData;
+    };
+  };
 }