@codingame/monaco-vscode-api 4.5.1 → 5.0.0

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

@@ -0,0 +1,76 @@
+/*---------------------------------------------------------------------------------------------
+ *  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' {
+
+	/**
+	 * A hover represents additional information for a symbol or word. Hovers are
+	 * rendered in a tooltip-like widget.
+	 */
+	export class VerboseHover extends Hover {
+
+		/**
+		 * Can increase the verbosity of the hover
+		 */
+		canIncreaseVerbosity?: boolean;
+
+		/**
+		 * Can decrease the verbosity of the hover
+		 */
+		canDecreaseVerbosity?: boolean;
+
+		/**
+		 * Creates a new hover object.
+		 *
+		 * @param contents The contents of the hover.
+		 * @param range The range to which the hover applies.
+		 */
+		constructor(contents: MarkdownString | MarkedString | Array<MarkdownString | MarkedString>, range?: Range, canIncreaseVerbosity?: boolean, canDecreaseVerbosity?: boolean);
+	}
+
+	export interface HoverContext {
+
+		/**
+		 * Whether to increase or decrease the hover's verbosity
+		 */
+		readonly action?: HoverVerbosityAction;
+
+		/**
+		 * The previous hover sent for the same position
+		 */
+		readonly previousHover?: Hover;
+	}
+
+	export enum HoverVerbosityAction {
+		/**
+		 * Increase the hover verbosity
+		 */
+		Increase = 0,
+		/**
+		 * Decrease the hover verbosity
+		 */
+		Decrease = 1
+	}
+
+	/**
+	 * The hover provider class
+	 */
+	export interface HoverProvider {
+
+		/**
+		 * Provide a hover for the given position and document. Multiple hovers at the same
+		 * position will be merged by the editor. A hover can have a range which defaults
+		 * to the word range at the position when omitted.
+		 *
+		 * @param document The document in which the command was invoked.
+		 * @param position The position at which the command was invoked.
+		 * @param token A cancellation token.
+		 * @oaram context A hover context.
+		 * @returns A hover or a thenable that resolves to such. The lack of a result can be
+		 * signaled by returning `undefined` or `null`.
+		 */
+		provideHover(document: TextDocument, position: Position, token: CancellationToken, context?: HoverContext): ProviderResult<VerboseHover>;
+	}
+}

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

@@ -110,28 +110,12 @@ declare module 'vscode' {
 		handleInteractiveEditorResponseFeedback?(session: S, response: R, kind: InteractiveEditorResponseFeedbackKind): void;
 	}
 
-	export interface InteractiveSession {
-	}
-
-	export interface InteractiveSessionProvider<S extends InteractiveSession = InteractiveSession> {
-		prepareSession(token: CancellationToken): ProviderResult<S>;
-	}
-
-	export interface InteractiveSessionDynamicRequest {
-		/**
-		 * The message that will be displayed in the UI
-		 */
-		message: string;
-	}
-
 	export namespace interactive {
 		// current version of the proposal.
 		export const _version: 1 | number;
 
-		export function registerInteractiveSessionProvider(id: string, provider: InteractiveSessionProvider): Disposable;
-
 		export function registerInteractiveEditorSessionProvider(provider: InteractiveEditorSessionProvider, metadata?: InteractiveEditorSessionProviderMetadata): Disposable;
 
-		export function transferChatSession(session: InteractiveSession, toWorkspace: Uri): void;
+		export function transferActiveChat(toWorkspace: Uri): void;
 	}
 }

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

@@ -98,9 +98,38 @@ declare module 'vscode' {
 	 */
 	export type LanguageModelChatMessage = LanguageModelChatSystemMessage | LanguageModelChatUserMessage | LanguageModelChatAssistantMessage;
 
+	/**
+	 * Represents information about a registered language model.
+	 */
+	export interface LanguageModelInformation {
+		/**
+		 * The identifier of the language model.
+		 */
+		readonly id: string;
+
+		/**
+		 * The human-readable name of the language model.
+		 */
+		readonly name: string;
+
+		/**
+		 * The version of the language model.
+		 */
+		readonly version: string;
+
+		/**
+		 * The number of available tokens that can be used when sending requests
+		 * to the language model.
+		 *
+		 * @see {@link lm.sendChatRequest}
+		 */
+		readonly tokens: number;
+	}
+
 	/**
 	 * An event describing the change in the set of available language models.
 	 */
+	// TODO@API use LanguageModelInformation instead of string?
 	export interface LanguageModelChangeEvent {
 		/**
 		 * Added language models.
@@ -173,6 +202,24 @@ declare module 'vscode' {
 	 */
 	export namespace lm {
 
+		/**
+		 * The identifiers of all language models that are currently available.
+		 */
+		export const languageModels: readonly string[];
+
+		/**
+		 * An event that is fired when the set of available language models changes.
+		 */
+		export const onDidChangeLanguageModels: Event<LanguageModelChangeEvent>;
+
+		/**
+		 * Retrieve information about a language model.
+		 *
+		 * @param languageModel A language model identifier.
+		 * @returns A {@link LanguageModelInformation} instance or `undefined` if the language model does not exist.
+		 */
+		export function getLanguageModelInformation(languageModel: string): LanguageModelInformation | undefined;
+
 		/**
 		 * Make a chat request using a language model.
 		 *
@@ -198,14 +245,16 @@ declare module 'vscode' {
 		export function sendChatRequest(languageModel: string, messages: LanguageModelChatMessage[], options: LanguageModelChatRequestOptions, token: CancellationToken): Thenable<LanguageModelChatResponse>;
 
 		/**
-		 * The identifiers of all language models that are currently available.
-		 */
-		export const languageModels: readonly string[];
-
-		/**
-		 * An event that is fired when the set of available language models changes.
+		 * Uses the language model specific tokenzier and computes the length in token of a given message.
+		 *
+		 * *Note* that this function will throw when the language model does not exist.
+		 *
+		 * @param languageModel A language model identifier.
+		 * @param text A string or a message instance.
+		 * @param token Optional cancellation token.
+		 * @returns A thenable that resolves to the length of the message in tokens.
 		 */
-		export const onDidChangeLanguageModels: Event<LanguageModelChangeEvent>;
+		export function computeTokenLength(languageModel: string, text: string | LanguageModelChatMessage, token?: CancellationToken): Thenable<number>;
 	}
 
 	/**
@@ -228,10 +277,6 @@ declare module 'vscode' {
 		 * model does not exist or consent hasn't been asked for.
 		 */
 		canSendRequest(languageModelId: string): boolean | undefined;
-
-		// TODO@API SYNC or ASYNC?
-		// TODO@API future
-		// retrieveQuota(languageModelId: string): { remaining: number; resets: Date };
 	}
 
 	export interface ExtensionContext {

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

@@ -11,6 +11,11 @@ declare module 'vscode' {
 		AIGenerated = 1
 	}
 
+	export enum NewSymbolNameTriggerKind {
+		Invoke = 0,
+		Automatic = 1,
+	}
+
 	export class NewSymbolName {
 		readonly newSymbolName: string;
 		readonly tags?: readonly NewSymbolNameTag[];
@@ -19,6 +24,12 @@ declare module 'vscode' {
 	}
 
 	export interface NewSymbolNamesProvider {
+
+		/**
+		 * @default false
+		 */
+		readonly supportsAutomaticTriggerKind?: Thenable<boolean>;
+
 		/**
 		 * Provide possible new names for the symbol at the given range.
 		 *
@@ -27,7 +38,7 @@ declare module 'vscode' {
 		 * @param token A cancellation token.
 		 * @return A list of new symbol names.
 		 */
-		provideNewSymbolNames(document: TextDocument, range: Range, token: CancellationToken): ProviderResult<NewSymbolName[]>;
+		provideNewSymbolNames(document: TextDocument, range: Range, triggerKind: NewSymbolNameTriggerKind, token: CancellationToken): ProviderResult<NewSymbolName[]>;
 	}
 
 	export namespace languages {

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

@@ -38,13 +38,13 @@ declare module 'vscode' {
 
 	export interface SourceControlHistoryItemGroup {
 		readonly id: string;
-		readonly label: string;
+		readonly name: string;
 		readonly base?: Omit<SourceControlRemoteHistoryItemGroup, 'base'>;
 	}
 
 	export interface SourceControlRemoteHistoryItemGroup {
 		readonly id: string;
-		readonly label: string;
+		readonly name: string;
 	}
 
 	export interface SourceControlHistoryItemStatistics {
@@ -56,8 +56,8 @@ declare module 'vscode' {
 	export interface SourceControlHistoryItem {
 		readonly id: string;
 		readonly parentIds: string[];
-		readonly label: string;
-		readonly description?: string;
+		readonly message: string;
+		readonly author?: string;
 		readonly icon?: Uri | { light: Uri; dark: Uri } | ThemeIcon;
 		readonly timestamp?: number;
 		readonly statistics?: SourceControlHistoryItemStatistics;

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

@@ -15,7 +15,8 @@ declare module 'vscode' {
 		Started = 1,
 		Recognizing = 2,
 		Recognized = 3,
-		Stopped = 4
+		Stopped = 4,
+		Error = 5
 	}
 
 	export interface SpeechToTextEvent {

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

@@ -7,62 +7,124 @@ declare module 'vscode' {
 
 	// https://github.com/microsoft/vscode/issues/145234
 
+	/**
+	 * A command that was executed in a terminal.
+	 */
 	export interface TerminalShellExecution {
-		// TODO: This is circular, is that fine? Should we add a `TerminalShellExecutionEvent`?
 		/**
-		 * The {@link Terminal} the command was executed in.
-		 */
-		readonly terminal: Terminal;
-
-		/**
-		 * The full command line that was executed, including both the command and arguments.
-		 * The accuracy of this value depends on the shell integration implementation:
+		 * 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.
 		 *
-		 * - It may be undefined or the empty string until {@link onDidEndTerminalShellExecution} is
-		 *   fired.
-		 * - It may be inaccurate initially if the command line is pulled from the buffer directly
-		 *   via the [`OSC 633/133 ; A`, `B` and `C` sequences](https://code.visualstudio.com/docs/terminal/shell-integration#_vs-code-custom-sequences-osc-633-st).
-		 * - It may contain line continuation characters and/or parts of the right prompt.
-		 * - It may be inaccurate if the shell integration does not support command line reporting
-		 *   via the [`OSC 633 ; E` sequence](https://code.visualstudio.com/docs/terminal/shell-integration#_vs-code-custom-sequences-osc-633-st).
+		 * @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.ommandLine.value}`,
+		 *     `  Confidence: ${command.ommandLine.confidence}`,
+		 *     `  Trusted: ${command.ommandLine.isTrusted}
+		 *   ].join('\n');
+		 * }
 		 */
-		readonly commandLine: string | undefined;
+		readonly commandLine: TerminalShellExecutionCommandLine;
 
 		/**
 		 * The working directory that was reported by the shell when this command executed. This
-		 * will be a {@link Uri} if the string reported by the shell can reliably be mapped to the
-		 * connected machine. This requires the shell integration to support working directory
-		 * reporting via the [`OSC 633 ; P`](https://code.visualstudio.com/docs/terminal/shell-integration#_vs-code-custom-sequences-osc-633-st)
-		 * or `OSC 1337 ; CurrentDir=<Cwd> ST` sequences.
-		 */
-		readonly cwd: Uri | string | undefined;
-
-		/**
-		 * The exit code reported by the shell.
+		 * {@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 exitCode: Thenable<number | undefined>;
+		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 `stream` was called for the
-		 * first time, ie. you must call `dataStream` immediately after the command is executed via
-		 * {@link executeCommand} or {@link onDidStartTerminalShellExecution} to not miss any data.
+		 * 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.createDataStream();
+		 * const stream = command.read();
 		 * for await (const data of stream) {
 		 *   console.log(data);
 		 * }
 		 */
-		createDataStream(): AsyncIterable<string>;
+		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
+		 * features for the terminal. This will always be `undefined` immediately after the terminal
 		 * is created. Listen to {@link window.onDidActivateTerminalShellIntegration} to be notified
 		 * when shell integration is activated for a terminal.
 		 *
@@ -73,13 +135,16 @@ declare module 'vscode' {
 		readonly shellIntegration: TerminalShellIntegration | undefined;
 	}
 
+	/**
+	 * [Shell integration](https://code.visualstudio.com/docs/terminal/shell-integration)-powered capabilities owned by a terminal.
+	 */
 	export interface TerminalShellIntegration {
-		// TODO: Is this fine to share the TerminalShellIntegrationChangeEvent event?
 		/**
-		 * The current working directory of the terminal. This will be a {@link Uri} if the string
-		 * reported by the shell can reliably be mapped to the connected machine.
+		 * 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 | string | undefined;
+		readonly cwd: Uri | undefined;
 
 		/**
 		 * Execute a command, sending ^C as necessary to interrupt any running command if needed.
@@ -178,12 +243,53 @@ declare module 'vscode' {
 		 * 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. `undefined` means the shell did not report an exit
+		 * code or the shell reported a command started before the command finished.
+		 */
+		readonly exitCode: number | undefined;
+	}
+
 	export namespace window {
 		/**
 		 * Fires when shell integration activates or one of its properties changes in a terminal.
@@ -195,13 +301,13 @@ declare module 'vscode' {
 		 * [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) is
 		 * activated for the terminal.
 		 */
-		export const onDidStartTerminalShellExecution: Event<TerminalShellExecution>;
+		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<TerminalShellExecution>;
+		export const onDidEndTerminalShellExecution: Event<TerminalShellExecutionEndEvent>;
 	}
 }

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

@@ -0,0 +1,28 @@
+/*---------------------------------------------------------------------------------------------
+ *  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' {
+
+	// See https://github.com/microsoft/vscode/issues/209491
+
+	export class TestRunRequest2 extends TestRunRequest {
+		/**
+		 * Controls how test Test Results view is focused.  If true, the editor
+		 * will keep the maintain the user's focus. If false, the editor will
+		 * prefer to move focus into the Test Results view, although
+		 * this may be configured by users.
+		 */
+		readonly preserveFocus: boolean;
+
+		/**
+		 * @param include Array of specific tests to run, or undefined to run all tests
+		 * @param exclude An array of tests to exclude from the run.
+		 * @param profile The run profile used for this request.
+		 * @param continuous Whether to run tests continuously as source changes.
+		 * @param preserveFocus Whether to preserve the user's focus when the run is started
+		 */
+		constructor(include?: readonly TestItem[], exclude?: readonly TestItem[], profile?: TestRunProfile, continuous?: boolean);
+	}
+}