@codingame/monaco-vscode-api 1.83.14 → 1.83.15

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;
+	}
+}

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

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/123601
+
+	/**
+	 * Represents a script that is loaded into the notebook renderer before rendering output. This allows
+	 * to provide and share functionality for notebook markup and notebook output renderers.
+	 */
+	export class NotebookRendererScript {
+
+		/**
+		 * APIs that the preload provides to the renderer. These are matched
+		 * against the `dependencies` and `optionalDependencies` arrays in the
+		 * notebook renderer contribution point.
+		 */
+		provides: readonly string[];
+
+		/**
+		 * URI of the JavaScript module to preload.
+		 *
+		 * This module must export an `activate` function that takes a context object that contains the notebook API.
+		 */
+		uri: Uri;
+
+		/**
+		 * @param uri URI of the JavaScript module to preload
+		 * @param provides Value for the `provides` property
+		 */
+		constructor(uri: Uri, provides?: string | readonly string[]);
+	}
+
+	export interface NotebookController {
+
+		// todo@API allow add, not remove
+		readonly rendererScripts: NotebookRendererScript[];
+
+		/**
+		 * An event that fires when a {@link NotebookController.rendererScripts renderer script} has send a message to
+		 * the controller.
+		 */
+		readonly onDidReceiveMessage: Event<{ readonly editor: NotebookEditor; readonly message: any }>;
+
+		/**
+		 * Send a message to the renderer of notebook editors.
+		 *
+		 * Note that only editors showing documents that are bound to this controller
+		 * are receiving the message.
+		 *
+		 * @param message The message to send.
+		 * @param editor A specific editor to send the message to. When `undefined` all applicable editors are receiving the message.
+		 * @returns A promise that resolves to a boolean indicating if the message has been send or not.
+		 */
+		postMessage(message: any, editor?: NotebookEditor): Thenable<boolean>;
+
+		//todo@API validate this works
+		asWebviewUri(localResource: Uri): Uri;
+	}
+
+	export namespace notebooks {
+
+		export function createNotebookController(id: string, viewType: string, label: string, handler?: (cells: NotebookCell[], notebook: NotebookDocument, controller: NotebookController) => void | Thenable<void>, rendererScripts?: NotebookRendererScript[]): NotebookController;
+	}
+}