@codingame/monaco-vscode-api 1.83.14 → 1.83.15-next.0

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

@@ -0,0 +1,71 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/124024 @hediet
+
+	export namespace languages {
+		/**
+		 * Registers an inline completion provider.
+		 *
+		 * Multiple providers can be registered for a language. In that case providers are asked in
+		 * parallel and the results are merged. A failing provider (rejected promise or exception) will
+		 * not cause a failure of the whole operation.
+		 *
+		 * @param selector A selector that defines the documents this provider is applicable to.
+		 * @param provider An inline completion provider.
+		 * @param metadata Metadata about the provider.
+		 * @return A {@link Disposable} that unregisters this provider when being disposed.
+		 */
+		export function registerInlineCompletionItemProvider(selector: DocumentSelector, provider: InlineCompletionItemProvider, metadata: InlineCompletionItemProviderMetadata): Disposable;
+	}
+
+	export interface InlineCompletionItem {
+		/**
+		 * If set to `true`, unopened closing brackets are removed and unclosed opening brackets are closed.
+		 * Defaults to `false`.
+		*/
+		completeBracketPairs?: boolean;
+	}
+
+	export interface InlineCompletionItemProviderMetadata {
+		/**
+		 * Specifies a list of extension ids that this provider yields to if they return a result.
+		 * If some inline completion provider registered by such an extension returns a result, this provider is not asked.
+		 */
+		yieldTo: string[];
+	}
+
+	export interface InlineCompletionItemProvider {
+		/**
+		 * @param completionItem The completion item that was shown.
+		 * @param updatedInsertText The actual insert text (after brackets were fixed).
+		 */
+		// eslint-disable-next-line local/vscode-dts-provider-naming
+		handleDidShowCompletionItem?(completionItem: InlineCompletionItem, updatedInsertText: string): void;
+
+		/**
+		 * Is called when an inline completion item was accepted partially.
+		 * @param acceptedLength The length of the substring of the inline completion that was accepted already.
+		 */
+		// eslint-disable-next-line local/vscode-dts-provider-naming
+		handleDidPartiallyAcceptCompletionItem?(completionItem: InlineCompletionItem, acceptedLength: number): void;
+	}
+
+	// When finalizing `commands`, make sure to add a corresponding constructor parameter.
+	export interface InlineCompletionList {
+		/**
+		 * A list of commands associated with the inline completions of this list.
+		 */
+		commands?: Command[];
+
+		/**
+		 * When set and the user types a suggestion without derivating from it, the inline suggestion is not updated.
+		 * Defaults to false (might change).
+		 */
+		enableForwardStability?: boolean;
+	}
+}

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

@@ -0,0 +1,227 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 InteractiveEditorSlashCommand {
+		command: string;
+		detail?: string;
+		refer?: boolean;
+		/**
+		 * Whether the command should execute as soon
+		 * as it is entered. Defaults to `false`.
+		 */
+		executeImmediately?: boolean;
+		// kind: CompletionItemKind;
+	}
+
+	// todo@API make classes
+	export interface InteractiveEditorSession {
+		placeholder?: string;
+		slashCommands?: InteractiveEditorSlashCommand[];
+		wholeRange?: Range;
+		message?: string;
+	}
+
+	// todo@API make classes
+	export interface InteractiveEditorRequest {
+		prompt: string;
+		selection: Selection;
+		wholeRange: Range;
+		attempt: number;
+		live: boolean;
+	}
+
+	// todo@API make classes
+	export interface InteractiveEditorResponse {
+		edits: TextEdit[] | WorkspaceEdit;
+		placeholder?: string;
+		wholeRange?: Range;
+	}
+
+	// todo@API make classes
+	export interface InteractiveEditorMessageResponse {
+		contents: MarkdownString;
+		placeholder?: string;
+		wholeRange?: Range;
+	}
+
+	export enum InteractiveEditorResponseFeedbackKind {
+		Unhelpful = 0,
+		Helpful = 1,
+		Undone = 2,
+		Accepted = 3
+	}
+
+	export interface TextDocumentContext {
+		document: TextDocument;
+		selection: Selection;
+	}
+
+	export interface InteractiveEditorSessionProviderMetadata {
+		label: string;
+	}
+
+	export interface InteractiveEditorSessionProvider<S extends InteractiveEditorSession = InteractiveEditorSession, R extends InteractiveEditorResponse | InteractiveEditorMessageResponse = InteractiveEditorResponse | InteractiveEditorMessageResponse> {
+
+		// Create a session. The lifetime of this session is the duration of the editing session with the input mode widget.
+		prepareInteractiveEditorSession(context: TextDocumentContext, token: CancellationToken): ProviderResult<S>;
+
+		provideInteractiveEditorResponse(session: S, request: InteractiveEditorRequest, progress: Progress<{ message: string; edits: TextEdit[] }>, token: CancellationToken): ProviderResult<R>;
+
+		// eslint-disable-next-line local/vscode-dts-provider-naming
+		handleInteractiveEditorResponseFeedback?(session: S, response: R, kind: InteractiveEditorResponseFeedbackKind): void;
+	}
+
+
+	export interface InteractiveSessionState { }
+
+	export interface InteractiveSessionParticipantInformation {
+		name: string;
+
+		/**
+		 * A full URI for the icon of the participant.
+		 */
+		icon?: Uri;
+	}
+
+	export interface InteractiveSession {
+		requester: InteractiveSessionParticipantInformation;
+		responder: InteractiveSessionParticipantInformation;
+		inputPlaceholder?: string;
+
+		saveState?(): InteractiveSessionState;
+	}
+
+	export interface InteractiveSessionRequestArgs {
+		command: string;
+		args: any;
+	}
+
+	export interface InteractiveRequest {
+		session: InteractiveSession;
+		message: string | InteractiveSessionReplyFollowup;
+	}
+
+	export interface InteractiveResponseErrorDetails {
+		message: string;
+		responseIsIncomplete?: boolean;
+		responseIsFiltered?: boolean;
+	}
+
+	export interface InteractiveResponseForProgress {
+		errorDetails?: InteractiveResponseErrorDetails;
+	}
+
+	export interface InteractiveProgressContent {
+		content: string | MarkdownString;
+	}
+
+	export interface InteractiveProgressId {
+		responseId: string;
+	}
+
+	export interface InteractiveProgressTask {
+		placeholder: string;
+		resolvedContent: Thenable<InteractiveProgressContent | InteractiveProgressFileTree>;
+	}
+
+	export interface FileTreeData {
+		label: string;
+		uri: Uri;
+		children?: FileTreeData[];
+	}
+
+	export interface InteractiveProgressFileTree {
+		treeData: FileTreeData;
+	}
+
+	export interface DocumentContext {
+		uri: Uri;
+		version: number;
+		ranges: Range[];
+	}
+
+	export interface InteractiveProgressUsedContext {
+		documents: DocumentContext[];
+	}
+
+	export type InteractiveProgress =
+		| InteractiveProgressContent
+		| InteractiveProgressId
+		| InteractiveProgressTask
+		| InteractiveProgressFileTree
+		| InteractiveProgressUsedContext;
+
+	export interface InteractiveResponseCommand {
+		commandId: string;
+		args?: any[];
+		title: string; // supports codicon strings
+		when?: string;
+	}
+
+	export interface InteractiveSessionSlashCommand {
+		command: string;
+		kind: CompletionItemKind;
+		detail?: string;
+		shouldRepopulate?: boolean;
+		followupPlaceholder?: string;
+		executeImmediately?: boolean;
+		yieldTo?: ReadonlyArray<{ readonly command: string }>;
+	}
+
+	export interface InteractiveSessionReplyFollowup {
+		message: string;
+		tooltip?: string;
+		title?: string;
+
+		// Extensions can put any serializable data here, such as an ID/version
+		metadata?: any;
+	}
+
+	export type InteractiveSessionFollowup = InteractiveSessionReplyFollowup | InteractiveResponseCommand;
+
+	export type InteractiveWelcomeMessageContent = string | InteractiveSessionReplyFollowup[];
+
+	export interface InteractiveSessionProvider<S extends InteractiveSession = InteractiveSession> {
+		provideWelcomeMessage?(token: CancellationToken): ProviderResult<InteractiveWelcomeMessageContent[]>;
+		provideFollowups?(session: S, token: CancellationToken): ProviderResult<(string | InteractiveSessionFollowup)[]>;
+		provideSlashCommands?(session: S, token: CancellationToken): ProviderResult<InteractiveSessionSlashCommand[]>;
+
+		prepareSession(initialState: InteractiveSessionState | undefined, token: CancellationToken): ProviderResult<S>;
+		resolveRequest(session: S, context: InteractiveSessionRequestArgs | string, token: CancellationToken): ProviderResult<InteractiveRequest>;
+		provideResponseWithProgress(request: InteractiveRequest, progress: Progress<InteractiveProgress>, token: CancellationToken): ProviderResult<InteractiveResponseForProgress>;
+
+		// eslint-disable-next-line local/vscode-dts-provider-naming
+		removeRequest(session: S, requestId: string): void;
+	}
+
+	export interface InteractiveSessionDynamicRequest {
+		/**
+		 * The message that will be displayed in the UI
+		 */
+		message: string;
+
+		/**
+		 * Any extra metadata/context that will go to the provider.
+		 * NOTE not actually used yet.
+		 */
+		metadata?: any;
+	}
+
+	export namespace interactive {
+		// current version of the proposal.
+		export const _version: 1 | number;
+
+		export function registerInteractiveSessionProvider(id: string, provider: InteractiveSessionProvider): Disposable;
+		export function addInteractiveRequest(context: InteractiveSessionRequestArgs): void;
+
+		export function sendInteractiveRequestToProvider(providerId: string, message: InteractiveSessionDynamicRequest): void;
+
+		export function registerInteractiveEditorSessionProvider(provider: InteractiveEditorSessionProvider, metadata?: InteractiveEditorSessionProviderMetadata): Disposable;
+
+		export function transferChatSession(session: InteractiveSession, toWorkspace: Uri): void;
+	}
+}

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

@@ -0,0 +1,70 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 enum InteractiveSessionVoteDirection {
+		Up = 1,
+		Down = 2
+	}
+
+	export interface InteractiveSessionVoteAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'vote';
+		responseId: string;
+		direction: InteractiveSessionVoteDirection;
+	}
+
+	export enum InteractiveSessionCopyKind {
+		// Keyboard shortcut or context menu
+		Action = 1,
+		Toolbar = 2
+	}
+
+	export interface InteractiveSessionCopyAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'copy';
+		responseId: string;
+		codeBlockIndex: number;
+		copyType: InteractiveSessionCopyKind;
+		copiedCharacters: number;
+		totalCharacters: number;
+		copiedText: string;
+	}
+
+	export interface InteractiveSessionInsertAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'insert';
+		responseId: string;
+		codeBlockIndex: number;
+		totalCharacters: number;
+		newFile?: boolean;
+	}
+
+	export interface InteractiveSessionTerminalAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'runInTerminal';
+		responseId: string;
+		codeBlockIndex: number;
+		languageId?: string;
+	}
+
+	export interface InteractiveSessionCommandAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'command';
+		command: InteractiveResponseCommand;
+	}
+
+	export type InteractiveSessionUserAction = InteractiveSessionVoteAction | InteractiveSessionCopyAction | InteractiveSessionInsertAction | InteractiveSessionTerminalAction | InteractiveSessionCommandAction;
+
+	export interface InteractiveSessionUserActionEvent {
+		action: InteractiveSessionUserAction;
+		providerId: string;
+	}
+
+	export namespace interactive {
+		export const onDidPerformUserAction: Event<InteractiveSessionUserActionEvent>;
+	}
+}

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

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  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' {
+	/**
+	 * The tab represents an interactive window.
+	 */
+	export class TabInputInteractiveWindow {
+		/**
+		 * The uri of the history notebook in the interactive window.
+		 */
+		readonly uri: Uri;
+		/**
+		 * The uri of the input box in the interactive window.
+		 */
+		readonly inputBoxUri: Uri;
+		private constructor(uri: Uri, inputBoxUri: Uri);
+	}
+
+	export interface Tab {
+		readonly input: TabInputText | TabInputTextDiff | TabInputCustom | TabInputWebview | TabInputNotebook | TabInputNotebookDiff | TabInputTerminal | TabInputInteractiveWindow | unknown;
+	}
+}

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

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 message passing protocol, which enables sending and receiving messages
+	 * between two parties.
+	 */
+	export interface MessagePassingProtocol {
+
+		/**
+		 * Fired when a message is received from the other party.
+		 */
+		readonly onDidReceiveMessage: Event<any>;
+
+		/**
+		 * Post a message to the other party.
+		 *
+		 * @param message Body of the message. This must be a JSON serializable object.
+		 * @param transfer A collection of `ArrayBuffer` instances which can be transferred
+		 * to the other party, saving costly memory copy operations.
+		 */
+		postMessage(message: any, transfer?: ArrayBuffer[]): void;
+	}
+
+	export interface ExtensionContext {
+
+		/**
+		 * When not `undefined`, this is an instance of {@link MessagePassingProtocol} in
+		 * which the other party is owned by the web embedder.
+		 */
+		readonly messagePassingProtocol: MessagePassingProtocol | undefined;
+	}
+}

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

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 DocumentContextItem {
+		readonly uri: Uri;
+		readonly version: number;
+		readonly ranges: Range[];
+	}
+
+	export interface MappedEditsContext {
+		documents: DocumentContextItem[][];
+	}
+
+	/**
+	 * Interface for providing mapped edits for a given document.
+	 */
+	export interface MappedEditsProvider {
+		/**
+		 * Provide mapped edits for a given document.
+		 * @param document The document to provide mapped edits for.
+		 * @param codeBlocks Code blocks that come from an LLM's reply.
+		 * 						"Insert at cursor" in the panel chat only sends one edit that the user clicks on, but inline chat can send multiple blocks and let the lang server decide what to do with them.
+		 * @param context The context for providing mapped edits.
+		 * @param token A cancellation token.
+		 * @returns A provider result of text edits.
+		 */
+		provideMappedEdits(
+			document: TextDocument,
+			codeBlocks: string[],
+			context: MappedEditsContext,
+			token: CancellationToken
+		): ProviderResult<WorkspaceEdit | null>;
+	}
+
+	namespace chat {
+		export function registerMappedEditsProvider(documentSelector: DocumentSelector, provider: MappedEditsProvider): Disposable;
+	}
+}

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

@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/124970
+
+	/**
+	 * The execution state of a notebook cell.
+	 */
+	export enum NotebookCellExecutionState {
+		/**
+		 * The cell is idle.
+		 */
+		Idle = 1,
+		/**
+		 * Execution for the cell is pending.
+		 */
+		Pending = 2,
+		/**
+		 * The cell is currently executing.
+		 */
+		Executing = 3,
+	}
+
+	/**
+	 * An event describing a cell execution state change.
+	 */
+	export interface NotebookCellExecutionStateChangeEvent {
+		/**
+		 * The {@link NotebookCell cell} for which the execution state has changed.
+		 */
+		readonly cell: NotebookCell;
+
+		/**
+		 * The new execution state of the cell.
+		 */
+		readonly state: NotebookCellExecutionState;
+	}
+
+	export namespace notebooks {
+
+		/**
+		 * An {@link Event} which fires when the execution state of a cell has changed.
+		 */
+		// todo@API this is an event that is fired for a property that cells don't have and that makes me wonder
+		// how a correct consumer works, e.g the consumer could have been late and missed an event?
+		export const onDidChangeNotebookCellExecutionState: Event<NotebookCellExecutionStateChangeEvent>;
+	}
+}

package/vscode-dts/vscode.proposed.notebookControllerAffinityHidden.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/161144
+	export enum NotebookControllerAffinity2 {
+		Default = 1,
+		Preferred = 2,
+		Hidden = -1
+	}
+
+	export interface NotebookController {
+		updateNotebookAffinity(notebook: NotebookDocument, affinity: NotebookControllerAffinity | NotebookControllerAffinity2): void;
+	}
+}

package/vscode-dts/vscode.proposed.notebookDeprecated.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/106744
+
+	export interface NotebookCellOutput {
+		/**
+		 * @deprecated
+		 */
+		id: string;
+	}
+}

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

@@ -0,0 +1,39 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 NotebookExecution is how {@link NotebookController notebook controller} can indicate whether the notebook controller is busy or not.
+	 *
+	 * When {@linkcode NotebookExecution.start start()} is called on the execution task, it causes the Notebook to enter a executing state .
+	 * When {@linkcode NotebookExecution.end end()} is called, it enters the idle state.
+	 */
+	export interface NotebookExecution {
+		/**
+		 * Signal that the execution has begun.
+		 */
+		start(): void;
+
+		/**
+		 * Signal that execution has ended.
+		 */
+		end(): void;
+	}
+
+	export interface NotebookController {
+		/**
+		 * Create an execution task.
+		 *
+		 * _Note_ that there can only be one execution per Notebook, that also includes NotebookCellExecutions and t an error is thrown if
+		 * a cell execution or another NotebookExecution is created while another is still active.
+		 *
+		 * This should be used to indicate the {@link NotebookController notebook controller} is busy even though user may not have executed any cell though the UI.
+		 * @param {NotebookDocument} notebook
+		 * @returns A notebook execution.
+		 */
+		createNotebookExecution(notebook: NotebookDocument): NotebookExecution;
+	}
+}

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

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 NotebookControllerDetectionTask {
+		/**
+		 * Dispose and remove the detection task.
+		 */
+		dispose(): void;
+	}
+
+	export class NotebookKernelSourceAction {
+		readonly label: string;
+		readonly description?: string;
+		readonly detail?: string;
+		readonly command: string | Command;
+		readonly documentation?: Uri;
+
+		constructor(label: string);
+	}
+
+	export interface NotebookKernelSourceActionProvider {
+		/**
+		 * An optional event to signal that the kernel source actions have changed.
+		 */
+		onDidChangeNotebookKernelSourceActions?: Event<void>;
+		/**
+		 * Provide kernel source actions
+		 */
+		provideNotebookKernelSourceActions(token: CancellationToken): ProviderResult<NotebookKernelSourceAction[]>;
+	}
+
+	export namespace notebooks {
+		/**
+		 * Create notebook controller detection task
+		 */
+		export function createNotebookControllerDetectionTask(notebookType: string): NotebookControllerDetectionTask;
+
+		/**
+		 * Register a notebook kernel source action provider
+		 */
+		export function registerKernelSourceActionProvider(notebookType: string, provider: NotebookKernelSourceActionProvider): Disposable;
+	}
+}

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

@@ -0,0 +1,21 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/106744
+
+	export interface NotebookRegistrationData {
+		readonly displayName: string;
+		readonly filenamePattern: ReadonlyArray<(GlobPattern | { readonly include: GlobPattern; readonly exclude: GlobPattern })>;
+		readonly exclusive?: boolean;
+	}
+
+	export namespace workspace {
+
+		// SPECIAL overload with NotebookRegistrationData
+		export function registerNotebookSerializer(notebookType: string, serializer: NotebookSerializer, options?: NotebookDocumentContentOptions, registration?: NotebookRegistrationData): Disposable;
+	}
+}