@codingame/monaco-vscode-api 1.83.14 → 1.83.15

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

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/126280 @mjbvz
+
+	export interface NotebookCellData {
+		/**
+		 * Mime type determines how the cell's `value` is interpreted.
+		 *
+		 * The mime selects which notebook renders is used to render the cell.
+		 *
+		 * If not set, internally the cell is treated as having a mime type of `text/plain`.
+		 * Cells that set `language` to `markdown` instead are treated as `text/markdown`.
+		 */
+		mime?: string;
+	}
+
+	export interface NotebookCell {
+		/**
+		 * Mime type determines how the markup cell's `value` is interpreted.
+		 *
+		 * The mime selects which notebook renders is used to render the cell.
+		 *
+		 * If not set, internally the cell is treated as having a mime type of `text/plain`.
+		 * Cells that set `language` to `markdown` instead are treated as `text/markdown`.
+		 */
+		mime: string | undefined;
+	}
+}

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

@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/115616 @alexr00
+
+	/**
+	 * The action that should be taken when a port is discovered through automatic port forwarding discovery.
+	 */
+	export enum PortAutoForwardAction {
+		/**
+		 * Notify the user that the port is being forwarded. This is the default action.
+		 */
+		Notify = 1,
+		/**
+		 * Once the port is forwarded, open the user's web browser to the forwarded port.
+		 */
+		OpenBrowser = 2,
+		/**
+		 * Once the port is forwarded, open the preview browser to the forwarded port.
+		 */
+		OpenPreview = 3,
+		/**
+		 * Forward the port silently.
+		 */
+		Silent = 4,
+		/**
+		 * Do not forward the port.
+		 */
+		Ignore = 5
+	}
+
+	/**
+	 * The attributes that a forwarded port can have.
+	 */
+	export class PortAttributes {
+		/**
+		 * The action to be taken when this port is detected for auto forwarding.
+		 */
+		autoForwardAction: PortAutoForwardAction;
+
+		/**
+		 * Creates a new PortAttributes object
+		 * @param port the port number
+		 * @param autoForwardAction the action to take when this port is detected
+		 */
+		constructor(autoForwardAction: PortAutoForwardAction);
+	}
+
+	/**
+	 * A provider of port attributes. Port attributes are used to determine what action should be taken when a port is discovered.
+	 */
+	export interface PortAttributesProvider {
+		/**
+		 * Provides attributes for the given port. For ports that your extension doesn't know about, simply
+		 * return undefined. For example, if `providePortAttributes` is called with ports 3000 but your
+		 * extension doesn't know anything about 3000 you should return undefined.
+		 * @param port The port number of the port that attributes are being requested for.
+		 * @param pid The pid of the process that is listening on the port. If the pid is unknown, undefined will be passed.
+		 * @param commandLine The command line of the process that is listening on the port. If the command line is unknown, undefined will be passed.
+		 * @param token A cancellation token that indicates the result is no longer needed.
+		 */
+		providePortAttributes(attributes: { port: number; pid?: number; commandLine?: string }, token: CancellationToken): ProviderResult<PortAttributes>;
+	}
+
+	/**
+	 * A selector that will be used to filter which {@link PortAttributesProvider} should be called for each port.
+	 */
+	export interface PortAttributesSelector {
+		/**
+		 * Specifying a port range will cause your provider to only be called for ports within the range.
+		 * The start is inclusive and the end is exclusive.
+		 */
+		portRange?: [number, number] | number;
+
+		/**
+		 * Specifying a command pattern will cause your provider to only be called for processes whose command line matches the pattern.
+		 */
+		commandPattern?: RegExp;
+	}
+
+	export namespace workspace {
+		/**
+		 * If your extension listens on ports, consider registering a PortAttributesProvider to provide information
+		 * about the ports. For example, a debug extension may know about debug ports in it's debuggee. By providing
+		 * this information with a PortAttributesProvider the extension can tell the editor that these ports should be
+		 * ignored, since they don't need to be user facing.
+		 *
+		 * The results of the PortAttributesProvider are merged with the user setting `remote.portsAttributes`. If the values conflict, the user setting takes precedence.
+		 *
+		 * @param portSelector It is best practice to specify a port selector to avoid unnecessary calls to your provider.
+		 * If you don't specify a port selector your provider will be called for every port, which will result in slower port forwarding for the user.
+		 * @param provider The {@link PortAttributesProvider PortAttributesProvider}.
+		 */
+		export function registerPortAttributesProvider(portSelector: PortAttributesSelector, provider: PortAttributesProvider): Disposable;
+	}
+}

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

@@ -0,0 +1,19 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 interface ProfileContentHandler {
+		readonly name: string;
+		readonly description?: string;
+		saveProfile(name: string, content: string, token: CancellationToken): Thenable<{ readonly id: string; readonly link: Uri } | null>;
+		readProfile(idOrUri: string | Uri, token: CancellationToken): Thenable<string | null>;
+	}
+
+	export namespace window {
+		export function registerProfileContentHandler(id: string, profileContentHandler: ProfileContentHandler): Disposable;
+	}
+
+}

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

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/169012
+
+	export namespace window {
+		export function registerQuickDiffProvider(selector: DocumentSelector, quickDiffProvider: QuickDiffProvider, label: string, rootUri?: Uri): Disposable;
+	}
+
+	interface QuickDiffProvider {
+		label?: string;
+	}
+}

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

@@ -0,0 +1,16 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/175662
+
+	export interface QuickPickItem {
+		/**
+		 * A tooltip that is rendered when hovering over the item.
+		 */
+		tooltip?: string | MarkdownString;
+	}
+}

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

@@ -0,0 +1,16 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/73904
+
+	export interface QuickPick<T extends QuickPickItem> extends QuickInput {
+		/**
+		 * An optional flag to sort the final results by index of first query match in label. Defaults to true.
+		 */
+		sortByLabel: boolean;
+	}
+}

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

@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// https://github.com/microsoft/vscode/issues/166971
+
+declare module 'vscode' {
+
+	export namespace workspace {
+
+		export function registerFileSystemProvider(scheme: string, provider: FileSystemProvider, options?: { readonly isCaseSensitive?: boolean; readonly isReadonly?: boolean | MarkdownString }): Disposable;
+	}
+}

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

@@ -0,0 +1,371 @@
+/*---------------------------------------------------------------------------------------------
+ *  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' {
+
+	//resolvers: @alexdima
+
+	export interface MessageOptions {
+		/**
+		 * Do not render a native message box.
+		 */
+		useCustom?: boolean;
+	}
+
+	export interface RemoteAuthorityResolverContext {
+		resolveAttempt: number;
+		/**
+		 * Exec server from a recursively-resolved remote authority. If the
+		 * remote authority includes nested authorities delimited by `@`, it is
+		 * resolved from outer to inner authorities with ExecServer passed down
+		 * to each resolver in the chain.
+		 */
+		execServer?: ExecServer;
+	}
+
+	export class ResolvedAuthority {
+		readonly host: string;
+		readonly port: number;
+		readonly connectionToken: string | undefined;
+
+		constructor(host: string, port: number, connectionToken?: string);
+	}
+
+	export interface ManagedMessagePassing {
+		onDidReceiveMessage: Event<Uint8Array>;
+		onDidClose: Event<Error | undefined>;
+		onDidEnd: Event<void>;
+
+		send: (data: Uint8Array) => void;
+		end: () => void;
+		drain?: () => Thenable<void>;
+	}
+
+	export class ManagedResolvedAuthority {
+		readonly makeConnection: () => Thenable<ManagedMessagePassing>;
+		readonly connectionToken: string | undefined;
+
+		constructor(makeConnection: () => Thenable<ManagedMessagePassing>, connectionToken?: string);
+	}
+
+	export interface ResolvedOptions {
+		extensionHostEnv?: { [key: string]: string | null };
+
+		isTrusted?: boolean;
+
+		/**
+		 * When provided, remote server will be initialized with the extensions synced using the given user account.
+		 */
+		authenticationSessionForInitializingExtensions?: AuthenticationSession & { providerId: string };
+	}
+
+	export interface TunnelPrivacy {
+		themeIcon: string;
+		id: string;
+		label: string;
+	}
+
+	export namespace env {
+		/** Quality of the application. May be undefined if running from sources. */
+		export const appQuality: string | undefined;
+		/** Commit of the application. May be undefined if running from sources. */
+		export const appCommit: string | undefined;
+	}
+
+	interface TunnelOptions {
+		remoteAddress: { port: number; host: string };
+		// The desired local port. If this port can't be used, then another will be chosen.
+		localAddressPort?: number;
+		label?: string;
+		/**
+		 * @deprecated Use privacy instead
+		 */
+		public?: boolean;
+		privacy?: string;
+		protocol?: string;
+	}
+
+	interface TunnelDescription {
+		remoteAddress: { port: number; host: string };
+		//The complete local address(ex. localhost:1234)
+		localAddress: { port: number; host: string } | string;
+		/**
+		 * @deprecated Use privacy instead
+		 */
+		public?: boolean;
+		privacy?: string;
+		// If protocol is not provided it is assumed to be http, regardless of the localAddress.
+		protocol?: string;
+	}
+
+	interface Tunnel extends TunnelDescription {
+		// Implementers of Tunnel should fire onDidDispose when dispose is called.
+		onDidDispose: Event<void>;
+		dispose(): void | Thenable<void>;
+	}
+
+	/**
+	 * Used as part of the ResolverResult if the extension has any candidate,
+	 * published, or forwarded ports.
+	 */
+	export interface TunnelInformation {
+		/**
+		 * Tunnels that are detected by the extension. The remotePort is used for display purposes.
+		 * The localAddress should be the complete local address (ex. localhost:1234) for connecting to the port. Tunnels provided through
+		 * detected are read-only from the forwarded ports UI.
+		 */
+		environmentTunnels?: TunnelDescription[];
+
+		tunnelFeatures?: {
+			elevation: boolean;
+			/**
+			 * One of the the options must have the ID "private".
+			 */
+			privacyOptions: TunnelPrivacy[];
+		};
+	}
+
+	export interface TunnelCreationOptions {
+		/**
+		 * True when the local operating system will require elevation to use the requested local port.
+		 */
+		elevationRequired?: boolean;
+	}
+
+	export enum CandidatePortSource {
+		None = 0,
+		Process = 1,
+		Output = 2
+	}
+
+	export type ResolverResult = (ResolvedAuthority | ManagedResolvedAuthority) & ResolvedOptions & TunnelInformation;
+
+	export class RemoteAuthorityResolverError extends Error {
+		static NotAvailable(message?: string, handled?: boolean): RemoteAuthorityResolverError;
+		static TemporarilyNotAvailable(message?: string): RemoteAuthorityResolverError;
+
+		constructor(message?: string);
+	}
+
+	/**
+	 * An ExecServer allows spawning processes on a remote machine. An ExecServer is provided by resolvers. It can be
+	 * acquired by `workspace.getRemoteExecServer` or from the context when in a resolver (`RemoteAuthorityResolverContext.execServer`).
+	 */
+	export interface ExecServer {
+		/**
+		 * Spawns a given subprocess with the given command and arguments.
+		 * @param command The command to execute.
+		 * @param args The arguments to pass to the command.
+		 * @param options Additional options for the spawned process.
+		 * @returns A promise that gives access to the process' stdin, stdout and stderr streams, as well as the process' exit code.
+		 */
+		spawn(command: string, args: string[], options?: ExecServerSpawnOptions): Thenable<SpawnedCommand>;
+
+		/**
+		 * Spawns an connector that allows to start a remote server. It is assumed the command starts a Code CLI. Additional
+		 * arguments will be passed to the connector.
+		 * @param command The command to execute. It is assumed the command spawns a Code CLI executable.
+		 * @param args The arguments to pass to the connector
+		 * @param options Additional options for the spawned process.
+		 * @returns A promise that gives access to the spawned {@link RemoteServerConnector}. It also provides a stream to which standard
+		 * log messages are written.
+		 */
+		spawnRemoteServerConnector?(command: string, args: string[], options?: ExecServerSpawnOptions): Thenable<RemoteServerConnector>;
+
+		/**
+		 * Downloads the CLI executable of the desired platform and quality and pipes it to the
+		 * provided process' stdin.
+		 * @param buildTarget The CLI build target to download.
+		 * @param command The command to execute. The downloaded bits will be piped to the command's stdin.
+		 * @param args The arguments to pass to the command.
+		 * @param options Additional options for the spawned process.
+		 * @returns A promise that resolves when the process exits with a {@link ProcessExit} object.
+		 */
+		downloadCliExecutable?(buildTarget: CliBuild, command: string, args: string[], options?: ExecServerSpawnOptions): Thenable<ProcessExit>;
+
+		/**
+		 * Gets the environment where the exec server is running.
+		 * @returns A promise that resolves to an {@link ExecEnvironment} object.
+		 */
+		env(): Thenable<ExecEnvironment>;
+
+		/**
+		 * Access to the file system of the remote.
+		 */
+		readonly fs: RemoteFileSystem;
+	}
+
+	export type ProcessEnv = Record<string, string>;
+
+	export interface ExecServerSpawnOptions {
+		readonly env?: ProcessEnv;
+		readonly cwd?: string;
+	}
+
+	export interface SpawnedCommand {
+		readonly stdin: WriteStream;
+		readonly stdout: ReadStream;
+		readonly stderr: ReadStream;
+		readonly onExit: Thenable<ProcessExit>;
+	}
+
+	export interface RemoteServerConnector {
+		readonly logs: ReadStream;
+		readonly onExit: Thenable<ProcessExit>;
+		/**
+		 * Connect to a new code server, returning a stream that can be used to communicate with it.
+		 * @param params The parameters for the code server.
+		 * @returns A promise that resolves to a {@link ManagedMessagePassing} object that can be used with a resolver
+		 */
+		connect(params: ServeParams): Thenable<ManagedMessagePassing>;
+	}
+
+	export interface ProcessExit {
+		readonly status: number;
+		readonly message?: string;
+	}
+
+	export interface ReadStream {
+		readonly onDidReceiveMessage: Event<Uint8Array>;
+		readonly onEnd: Thenable<void>;
+	}
+
+	export interface WriteStream {
+		write(data: Uint8Array): void;
+		end(): void;
+	}
+
+	export interface ServeParams {
+		readonly socketId: number;
+		readonly commit?: string;
+		readonly quality: string;
+		readonly extensions: string[];
+		/** Whether server traffic should be compressed. */
+		readonly compress?: boolean;
+		/** Optional explicit connection token for the server. */
+		readonly connectionToken?: string;
+	}
+
+	export interface CliBuild {
+		readonly quality: string;
+		/** 'LinuxAlpineX64' | 'LinuxX64' | 'LinuxARM64' | 'LinuxARM32' | 'DarwinX64' | 'DarwinARM64' | 'WindowsX64' | 'WindowsX86' | 'WindowsARM64' */
+		readonly buildTarget: string;
+		readonly commit: string;
+	}
+
+	export interface ExecEnvironment {
+		readonly env: ProcessEnv;
+		/** 'darwin' | 'linux' | 'win32' */
+		readonly osPlatform: string;
+		/** uname.version or windows version number, undefined if it could not be read. */
+		readonly osRelease?: string;
+	}
+
+	export interface RemoteFileSystem {
+		/**
+		 * Retrieve metadata about a file.
+		 *
+		 * @param path The path of the file to retrieve metadata about.
+		 * @returns The file metadata about the file.
+		 * @throws an exception when `path` doesn't exist.
+		 */
+		stat(path: string): Thenable<FileStat>;
+	}
+
+	export interface RemoteAuthorityResolver {
+		/**
+		 * Resolve the authority part of the current opened `vscode-remote://` URI.
+		 *
+		 * This method will be invoked once during the startup of the editor and again each time
+		 * the editor detects a disconnection.
+		 *
+		 * @param authority The authority part of the current opened `vscode-remote://` URI.
+		 * @param context A context indicating if this is the first call or a subsequent call.
+		 */
+		resolve(authority: string, context: RemoteAuthorityResolverContext): ResolverResult | Thenable<ResolverResult>;
+
+		/**
+		 * Resolves an exec server interface for the authority. Called if an
+		 * authority is a midpoint in a transit to the desired remote.
+		 *
+		 * @param authority The authority part of the current opened `vscode-remote://` URI.
+		 * @returns The exec server interface, as defined in a contract between extensions.
+		 */
+		resolveExecServer?(remoteAuthority: string, context: RemoteAuthorityResolverContext): ExecServer | Thenable<ExecServer>;
+
+		/**
+		 * Get the canonical URI (if applicable) for a `vscode-remote://` URI.
+		 *
+		 * @returns The canonical URI or undefined if the uri is already canonical.
+		 */
+		getCanonicalURI?(uri: Uri): ProviderResult<Uri>;
+
+		/**
+		 * Can be optionally implemented if the extension can forward ports better than the core.
+		 * When not implemented, the core will use its default forwarding logic.
+		 * When implemented, the core will use this to forward ports.
+		 *
+		 * To enable the "Change Local Port" action on forwarded ports, make sure to set the `localAddress` of
+		 * the returned `Tunnel` to a `{ port: number, host: string; }` and not a string.
+		 */
+		tunnelFactory?: (tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions) => Thenable<Tunnel> | undefined;
+
+		/**p
+		 * Provides filtering for candidate ports.
+		 */
+		showCandidatePort?: (host: string, port: number, detail: string) => Thenable<boolean>;
+
+		/**
+		 * @deprecated Return tunnelFeatures as part of the resolver result in tunnelInformation.
+		 */
+		tunnelFeatures?: {
+			elevation: boolean;
+			public: boolean;
+			privacyOptions: TunnelPrivacy[];
+		};
+
+		candidatePortSource?: CandidatePortSource;
+	}
+
+	export interface ResourceLabelFormatter {
+		scheme: string;
+		authority?: string;
+		formatting: ResourceLabelFormatting;
+	}
+
+	export interface ResourceLabelFormatting {
+		label: string; // myLabel:/${path}
+		// For historic reasons we use an or string here. Once we finalize this API we should start using enums instead and adopt it in extensions.
+		// eslint-disable-next-line local/vscode-dts-literal-or-types, local/vscode-dts-string-type-literals
+		separator: '/' | '\\' | '';
+		tildify?: boolean;
+		normalizeDriveLetter?: boolean;
+		workspaceSuffix?: string;
+		workspaceTooltip?: string;
+		authorityPrefix?: string;
+		stripPathStartingSeparator?: boolean;
+	}
+
+	export namespace workspace {
+		export function registerRemoteAuthorityResolver(authorityPrefix: string, resolver: RemoteAuthorityResolver): Disposable;
+		export function registerResourceLabelFormatter(formatter: ResourceLabelFormatter): Disposable;
+		export function getRemoteExecServer(authority: string): Thenable<ExecServer | undefined>;
+	}
+
+	export namespace env {
+
+		/**
+		 * The authority part of the current opened `vscode-remote://` URI.
+		 * Defined by extensions, e.g. `ssh-remote+${host}` for remotes using a secure shell.
+		 *
+		 * *Note* that the value is `undefined` when there is no remote extension host but that the
+		 * value is defined in all extension hosts (local and remote) in case a remote extension host
+		 * exists. Use {@link Extension.extensionKind} to know if
+		 * a specific extension runs remote or not.
+		 */
+		export const remoteAuthority: string | undefined;
+
+	}
+}

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

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// https://github.com/microsoft/vscode/issues/178713
+
+declare module 'vscode' {
+
+	export namespace workspace {
+
+		/**
+		 * Saves the editor identified by the given resource and returns the resulting resource or `undefined`
+		 * if save was not successful or no editor with the given resource was found.
+		 *
+		 * **Note** that an editor with the provided resource must be opened in order to be saved.
+		 *
+		 * @param uri the associated uri for the opened editor to save.
+		 * @return A thenable that resolves when the save operation has finished.
+		 */
+		export function save(uri: Uri): Thenable<Uri | undefined>;
+
+		/**
+		 * Saves the editor identified by the given resource to a new file name as provided by the user and
+		 * returns the resulting resource or `undefined` if save was not successful or cancelled or no editor
+		 * with the given resource was found.
+		 *
+		 * **Note** that an editor with the provided resource must be opened in order to be saved as.
+		 *
+		 * @param uri the associated uri for the opened editor to save as.
+		 * @return A thenable that resolves when the save-as operation has finished.
+		 */
+		export function saveAs(uri: Uri): Thenable<Uri | undefined>;
+	}
+}

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

@@ -0,0 +1,19 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/133935
+
+	export interface SourceControlActionButton {
+		command: Command;
+		secondaryCommands?: Command[][];
+		description?: string;
+		enabled: boolean;
+	}
+
+	export interface SourceControl {
+		actionButton?: SourceControlActionButton;
+	}
+}