@codingame/monaco-vscode-api 8.0.4 → 9.0.2

package/vscode/src/vs/editor/browser/services/webWorker.js

@@ -1,57 +0,0 @@
-import { getAllMethodNames } from '../../../base/common/objects.js';
-import { EditorWorkerClient } from './editorWorkerService.js';
-function createWebWorker(modelService, languageConfigurationService, opts) {
-    return ( new MonacoWebWorkerImpl(modelService, languageConfigurationService, opts));
-}
-class MonacoWebWorkerImpl extends EditorWorkerClient {
-    constructor(modelService, languageConfigurationService, opts) {
-        super(modelService, opts.keepIdleModels || false, opts.label, languageConfigurationService);
-        this._foreignModuleId = opts.moduleId;
-        this._foreignModuleCreateData = opts.createData || null;
-        this._foreignModuleHost = opts.host || null;
-        this._foreignProxy = null;
-    }
-    fhr(method, args) {
-        if (!this._foreignModuleHost || typeof this._foreignModuleHost[method] !== 'function') {
-            return Promise.reject(( new Error('Missing method ' + method + ' or missing main thread foreign host.')));
-        }
-        try {
-            return Promise.resolve(this._foreignModuleHost[method].apply(this._foreignModuleHost, args));
-        }
-        catch (e) {
-            return Promise.reject(e);
-        }
-    }
-    _getForeignProxy() {
-        if (!this._foreignProxy) {
-            this._foreignProxy = this._getProxy().then((proxy) => {
-                const foreignHostMethods = this._foreignModuleHost ? getAllMethodNames(this._foreignModuleHost) : [];
-                return proxy.loadForeignModule(this._foreignModuleId, this._foreignModuleCreateData, foreignHostMethods).then((foreignMethods) => {
-                    this._foreignModuleCreateData = null;
-                    const proxyMethodRequest = (method, args) => {
-                        return proxy.fmr(method, args);
-                    };
-                    const createProxyMethod = (method, proxyMethodRequest) => {
-                        return function () {
-                            const args = Array.prototype.slice.call(arguments, 0);
-                            return proxyMethodRequest(method, args);
-                        };
-                    };
-                    const foreignProxy = {};
-                    for (const foreignMethod of foreignMethods) {
-                        foreignProxy[foreignMethod] = createProxyMethod(foreignMethod, proxyMethodRequest);
-                    }
-                    return foreignProxy;
-                });
-            });
-        }
-        return this._foreignProxy;
-    }
-    getProxy() {
-        return this._getForeignProxy();
-    }
-    withSyncedResources(resources) {
-        return this._withSyncedResources(resources).then(_ => ( this.getProxy()));
-    }
-}
-export { createWebWorker };

package/vscode/src/vs/editor/editor.worker.js

@@ -1,21 +0,0 @@
-import { SimpleWorkerServer } from '../base/common/worker/simpleWorker.js';
-import { EditorSimpleWorker } from './common/services/editorSimpleWorker.js';
-let initialized = false;
-function initialize(foreignModule) {
-    if (initialized) {
-        return;
-    }
-    initialized = true;
-    const simpleWorker = ( new SimpleWorkerServer((msg) => {
-        globalThis.postMessage(msg);
-    }, (host) => ( new EditorSimpleWorker(host, foreignModule))));
-    globalThis.onmessage = (e) => {
-        simpleWorker.onmessage(e.data);
-    };
-}
-globalThis.onmessage = (e) => {
-    if (!initialized) {
-        initialize(null);
-    }
-};
-export { initialize };

package/vscode-dts/vscode.proposed.authGetSessions.d.ts

@@ -1,70 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-declare module 'vscode' {
-
-	// https://github.com/microsoft/vscode/issues/152399
-
-	// FOR THE CONSUMER
-
-	export namespace authentication {
-		/**
-		 * Get all accounts that the user is logged in to for the specified provider.
-		 * Use this paired with {@link getSession} in order to get an authentication session for a specific account.
-		 *
-		 * Currently, there are only two authentication providers that are contributed from built in extensions
-		 * to the editor that implement GitHub and Microsoft authentication: their providerId's are 'github' and 'microsoft'.
-		 *
-		 * Note: Getting accounts does not imply that your extension has access to that account or its authentication sessions. You can verify access to the account by calling {@link getSession}.
-		 *
-			 * @param providerId The id of the provider to use
-			 * @returns A thenable that resolves to a readonly array of authentication accounts.
-			 */
-		export function getAccounts(providerId: string): Thenable<readonly AuthenticationSessionAccountInformation[]>;
-	}
-
-	export interface AuthenticationGetSessionOptions {
-		/**
-		 * The account that you would like to get a session for. This is passed down to the Authentication Provider to be used for creating the correct session.
-		 */
-		account?: AuthenticationSessionAccountInformation;
-	}
-
-	// FOR THE AUTH PROVIDER
-
-	export interface AuthenticationProviderSessionOptions {
-		/**
-		 * The account that is being asked about. If this is passed in, the provider should
-		 * attempt to return the sessions that are only related to this account.
-		 */
-		account?: AuthenticationSessionAccountInformation;
-	}
-
-	export interface AuthenticationProvider {
-		/**
-		 * Get a list of sessions.
-		 * @param scopes An optional list of scopes. If provided, the sessions returned should match
-		 * these permissions, otherwise all sessions should be returned.
-		 * @param options Additional options for getting sessions.
-		 * @returns A promise that resolves to an array of authentication sessions.
-		 */
-		getSessions(scopes: readonly string[] | undefined, options: AuthenticationProviderSessionOptions): Thenable<AuthenticationSession[]>;
-		/**
-		 * Prompts a user to login.
-		 *
-		 * If login is successful, the onDidChangeSessions event should be fired.
-		 *
-		 * If login fails, a rejected promise should be returned.
-		 *
-		 * If the provider has specified that it does not support multiple accounts,
-		 * then this should never be called if there is already an existing session matching these
-		 * scopes.
-		 * @param scopes A list of scopes, permissions, that the new session should be created with.
-		 * @param options Additional options for creating a session.
-		 * @returns A promise that resolves to an authentication session.
-		 */
-		createSession(scopes: readonly string[], options: AuthenticationProviderSessionOptions): Thenable<AuthenticationSession>;
-	}
-}

package/vscode-dts/vscode.proposed.terminalShellIntegration.d.ts

@@ -1,338 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-declare module 'vscode' {
-
-	// https://github.com/microsoft/vscode/issues/145234
-
-	/**
-	 * A command that was executed in a terminal.
-	 */
-	export interface TerminalShellExecution {
-		/**
-		 * The command line that was executed. The {@link TerminalShellExecutionCommandLineConfidence confidence}
-		 * of this value depends on the specific shell's shell integration implementation. This
-		 * value may become more accurate after {@link window.onDidEndTerminalShellExecution} is
-		 * fired.
-		 *
-		 * @example
-		 * // Log the details of the command line on start and end
-		 * window.onDidStartTerminalShellExecution(event => {
-		 *   const commandLine = event.execution.commandLine;
-		 *   console.log(`Command started\n${summarizeCommandLine(commandLine)}`);
-		 * });
-		 * window.onDidEndTerminalShellExecution(event => {
-		 *   const commandLine = event.execution.commandLine;
-		 *   console.log(`Command ended\n${summarizeCommandLine(commandLine)}`);
-		 * });
-		 * function summarizeCommandLine(commandLine: TerminalShellExecutionCommandLine) {
-		 *   return [
-		 *     `  Command line: ${command.commandLine.value}`,
-		 *     `  Confidence: ${command.commandLine.confidence}`,
-		 *     `  Trusted: ${command.commandLine.isTrusted}
-		 *   ].join('\n');
-		 * }
-		 */
-		readonly commandLine: TerminalShellExecutionCommandLine;
-
-		/**
-		 * The working directory that was reported by the shell when this command executed. This
-		 * {@link Uri} may represent a file on another machine (eg. ssh into another machine). This
-		 * requires the shell integration to support working directory reporting.
-		 */
-		readonly cwd: Uri | undefined;
-
-		/**
-		 * Creates a stream of raw data (including escape sequences) that is written to the
-		 * terminal. This will only include data that was written after `read` was called for
-		 * the first time, ie. you must call `read` immediately after the command is executed via
-		 * {@link TerminalShellIntegration.executeCommand} or
-		 * {@link window.onDidStartTerminalShellExecution} to not miss any data.
-		 *
-		 * @example
-		 * // Log all data written to the terminal for a command
-		 * const command = term.shellIntegration.executeCommand({ commandLine: 'echo "Hello world"' });
-		 * const stream = command.read();
-		 * for await (const data of stream) {
-		 *   console.log(data);
-		 * }
-		 */
-		read(): AsyncIterable<string>;
-	}
-
-	/**
-	 * A command line that was executed in a terminal.
-	 */
-	export interface TerminalShellExecutionCommandLine {
-		/**
-		 * The full command line that was executed, including both the command and its arguments.
-		 */
-		readonly value: string;
-
-		/**
-		 * Whether the command line value came from a trusted source and is therefore safe to
-		 * execute without user additional confirmation, such as a notification that asks "Do you
-		 * want to execute (command)?". This verification is likely only needed if you are going to
-		 * execute the command again.
-		 *
-		 * This is `true` only when the command line was reported explicitly by the shell
-		 * integration script (ie. {@link TerminalShellExecutionCommandLineConfidence.High high confidence})
-		 * and it used a nonce for verification.
-		 */
-		readonly isTrusted: boolean;
-
-		/**
-		 * The confidence of the command line value which is determined by how the value was
-		 * obtained. This depends upon the implementation of the shell integration script.
-		 */
-		readonly confidence: TerminalShellExecutionCommandLineConfidence;
-	}
-
-	/**
-	 * The confidence of a {@link TerminalShellExecutionCommandLine} value.
-	 */
-	enum TerminalShellExecutionCommandLineConfidence {
-		/**
-		 * The command line value confidence is low. This means that the value was read from the
-		 * terminal buffer using markers reported by the shell integration script. Additionally one
-		 * of the following conditions will be met:
-		 *
-		 * - The command started on the very left-most column which is unusual, or
-		 * - The command is multi-line which is more difficult to accurately detect due to line
-		 *   continuation characters and right prompts.
-		 * - Command line markers were not reported by the shell integration script.
-		 */
-		Low = 0,
-
-		/**
-		 * The command line value confidence is medium. This means that the value was read from the
-		 * terminal buffer using markers reported by the shell integration script. The command is
-		 * single-line and does not start on the very left-most column (which is unusual).
-		 */
-		Medium = 1,
-
-		/**
-		 * The command line value confidence is high. This means that the value was explicitly sent
-		 * from the shell integration script or the command was executed via the
-		 * {@link TerminalShellIntegration.executeCommand} API.
-		 */
-		High = 2
-	}
-
-	export interface Terminal {
-		/**
-		 * An object that contains [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration)-powered
-		 * features for the terminal. This will always be `undefined` immediately after the terminal
-		 * is created. Listen to {@link window.onDidChangeTerminalShellIntegration} to be notified
-		 * when shell integration is activated for a terminal.
-		 *
-		 * Note that this object may remain undefined if shell integation never activates. For
-		 * example Command Prompt does not support shell integration and a user's shell setup could
-		 * conflict with the automatic shell integration activation.
-		 */
-		readonly shellIntegration: TerminalShellIntegration | undefined;
-	}
-
-	/**
-	 * [Shell integration](https://code.visualstudio.com/docs/terminal/shell-integration)-powered capabilities owned by a terminal.
-	 */
-	export interface TerminalShellIntegration {
-		/**
-		 * The current working directory of the terminal. This {@link Uri} may represent a file on
-		 * another machine (eg. ssh into another machine). This requires the shell integration to
-		 * support working directory reporting.
-		 */
-		readonly cwd: Uri | undefined;
-
-		/**
-		 * Execute a command, sending ^C as necessary to interrupt any running command if needed.
-		 *
-		 * @param commandLine The command line to execute, this is the exact text that will be sent
-		 * to the terminal.
-		 *
-		 * @example
-		 * // Execute a command in a terminal immediately after being created
-		 * const myTerm = window.createTerminal();
-		 * window.onDidChangeTerminalShellIntegration(async ({ terminal, shellIntegration }) => {
-		 *   if (terminal === myTerm) {
-		 *     const execution = shellIntegration.executeCommand('echo "Hello world"');
-		 *     window.onDidEndTerminalShellExecution(event => {
-		 *     if (event.execution === execution) {
-		 *       console.log(`Command exited with code ${event.exitCode}`);
-		 *     }
-		 *   }
-		 * }));
-		 * // Fallback to sendText if there is no shell integration within 3 seconds of launching
-		 * setTimeout(() => {
-		 *   if (!myTerm.shellIntegration) {
-		 *     myTerm.sendText('echo "Hello world"');
-		 *     // Without shell integration, we can't know when the command has finished or what the
-		 *     // exit code was.
-		 *   }
-		 * }, 3000);
-		 *
-		 * @example
-		 * // Send command to terminal that has been alive for a while
-		 * const commandLine = 'echo "Hello world"';
-		 * if (term.shellIntegration) {
-		 *   const execution = shellIntegration.executeCommand({ commandLine });
-		 *   window.onDidEndTerminalShellExecution(event => {
-		 *   if (event.execution === execution) {
-		 *     console.log(`Command exited with code ${event.exitCode}`);
-		 *   }
-		 * } else {
-		 *   term.sendText(commandLine);
-		 *   // Without shell integration, we can't know when the command has finished or what the
-		 *   // exit code was.
-		 * }
-		 */
-		executeCommand(commandLine: string): TerminalShellExecution;
-
-		/**
-		 * Execute a command, sending ^C as necessary to interrupt any running command if needed.
-		 *
-		 * *Note* This is not guaranteed to work as [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration)
-		 * must be activated. Check whether {@link TerminalShellExecution.exitCode} is rejected to
-		 * verify whether it was successful.
-		 *
-		 * @param command A command to run.
-		 * @param args Arguments to launch the executable with which will be automatically escaped
-		 * based on the executable type.
-		 *
-		 * @example
-		 * // Execute a command in a terminal immediately after being created
-		 * const myTerm = window.createTerminal();
-		 * window.onDidActivateTerminalShellIntegration(async ({ terminal, shellIntegration }) => {
-		 *   if (terminal === myTerm) {
-		 *     const command = shellIntegration.executeCommand({
-		 *       command: 'echo',
-		 *       args: ['Hello world']
-		 *     });
-		 *     const code = await command.exitCode;
-		 *     console.log(`Command exited with code ${code}`);
-		 *   }
-		 * }));
-		 * // Fallback to sendText if there is no shell integration within 3 seconds of launching
-		 * setTimeout(() => {
-		 *   if (!myTerm.shellIntegration) {
-		 *     myTerm.sendText('echo "Hello world"');
-		 *     // Without shell integration, we can't know when the command has finished or what the
-		 *     // exit code was.
-		 *   }
-		 * }, 3000);
-		 *
-		 * @example
-		 * // Send command to terminal that has been alive for a while
-		 * const commandLine = 'echo "Hello world"';
-		 * if (term.shellIntegration) {
-		 *   const command = term.shellIntegration.executeCommand({
-		 *     command: 'echo',
-		 *     args: ['Hello world']
-		 *   });
-		 *   const code = await command.exitCode;
-		 *   console.log(`Command exited with code ${code}`);
-		 * } else {
-		 *   term.sendText(commandLine);
-		 *   // Without shell integration, we can't know when the command has finished or what the
-		 *   // exit code was.
-		 * }
-		 */
-		executeCommand(executable: string, args: string[]): TerminalShellExecution;
-	}
-
-	export interface TerminalShellIntegrationChangeEvent {
-		/**
-		 * The terminal that shell integration has been activated in.
-		 */
-		readonly terminal: Terminal;
-
-		/**
-		 * The shell integration object.
-		 */
-		readonly shellIntegration: TerminalShellIntegration;
-	}
-
-	export interface TerminalShellExecutionStartEvent {
-		/**
-		 * The terminal that shell integration has been activated in.
-		 */
-		readonly terminal: Terminal;
-
-		/**
-		 * The shell integration object.
-		 */
-		readonly shellIntegration: TerminalShellIntegration;
-
-		/**
-		 * The terminal shell execution that has ended.
-		 */
-		readonly execution: TerminalShellExecution;
-	}
-
-	export interface TerminalShellExecutionEndEvent {
-		/**
-		 * The terminal that shell integration has been activated in.
-		 */
-		readonly terminal: Terminal;
-
-		/**
-		 * The shell integration object.
-		 */
-		readonly shellIntegration: TerminalShellIntegration;
-
-		/**
-		 * The terminal shell execution that has ended.
-		 */
-		readonly execution: TerminalShellExecution;
-
-		/**
-		 * The exit code reported by the shell.
-		 *
-		 * Note that `undefined` means the shell either did not report an exit  code (ie. the shell
-		 * integration script is misbehaving) or the shell reported a command started before the command
-		 * finished (eg. a sub-shell was opened). Generally this should not happen, depending on the use
-		 * case, it may be best to treat this as a failure.
-		 *
-		 * @example
-		 * const execution = shellIntegration.executeCommand({
-		 *   command: 'echo',
-		 *   args: ['Hello world']
-		 * });
-		 * window.onDidEndTerminalShellExecution(event => {
-		 *   if (event.execution === execution) {
-		 *     if (event.exitCode === undefined) {
-		 * 	     console.log('Command finished but exit code is unknown');
-		 *     } else if (event.exitCode === 0) {
-		 * 	     console.log('Command succeeded');
-		 *     } else {
-		 * 	     console.log('Command failed');
-		 *     }
-		 *   }
-		 * });
-		 */
-		readonly exitCode: number | undefined;
-	}
-
-	export namespace window {
-		/**
-		 * Fires when shell integration activates or one of its properties changes in a terminal.
-		 */
-		export const onDidChangeTerminalShellIntegration: Event<TerminalShellIntegrationChangeEvent>;
-
-		/**
-		 * This will be fired when a terminal command is started. This event will fire only when
-		 * [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) is
-		 * activated for the terminal.
-		 */
-		export const onDidStartTerminalShellExecution: Event<TerminalShellExecutionStartEvent>;
-
-		/**
-		 * This will be fired when a terminal command is ended. This event will fire only when
-		 * [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) is
-		 * activated for the terminal.
-		 */
-		export const onDidEndTerminalShellExecution: Event<TerminalShellExecutionEndEvent>;
-	}
-}

package/vscode-dts/vscode.proposed.testMessageStackTrace.d.ts

@@ -1,38 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-declare module 'vscode' {
-	export class TestMessage2 extends TestMessage {
-		/**
-		 * The stack trace associated with the message or failure.
-		 */
-		stackTrace?: TestMessageStackFrame[];
-	}
-
-	export class TestMessageStackFrame {
-		/**
-		 * The location of this stack frame. This should be provided as a URI if the
-		 * location of the call frame can be accessed by the editor.
-		 */
-		file?: Uri;
-
-		/**
-		 * Position of the stack frame within the file.
-		 */
-		position?: Position;
-
-		/**
-		 * The name of the stack frame, typically a method or function name.
-		 */
-		label: string;
-
-		/**
-		 * @param label The name of the stack frame
-		 * @param file The file URI of the stack frame
-		 * @param position The position of the stack frame within the file
-		 */
-		constructor(label: string, file?: Uri, position?: Position);
-	}
-}