@codingame/monaco-vscode-api 4.5.2 → 5.0.0

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

package/vscode/src/vs/base/browser/ui/hover/updatableHoverWidget.d.ts

@@ -1,21 +0,0 @@
-import { IDisposable } from '../../../common/lifecycle.js';
-
-/**
- * Copied from src\vs\workbench\services\hover\browser\hover.ts
- * @deprecated Use IHoverService
- */
-interface IHoverAction {
-    label: string;
-    commandId: string;
-    iconClass?: string;
-    run(target: HTMLElement): void;
-}
-interface IUpdatableHoverOptions {
-    actions?: IHoverAction[];
-    linkHandler?(url: string): void;
-}
-interface IHoverWidget extends IDisposable {
-    readonly isDisposed: boolean;
-}
-
-export type { IHoverWidget, IUpdatableHoverOptions };

package/vscode/src/vs/base/browser/ui/hover/updatableHoverWidget.js

@@ -1,214 +0,0 @@
-import { addDisposableListener, EventType, getWindow } from '../../dom.js';
-import { TimeoutTimer } from '../../../common/async.js';
-import { CancellationTokenSource } from '../../../common/cancellation.js';
-import { isMarkdownString } from '../../../common/htmlContent.js';
-import { stripIcons } from '../../../common/iconLabels.js';
-import { DisposableStore } from '../../../common/lifecycle.js';
-import { isString, isFunction } from '../../../common/types.js';
-import { localizeWithPath } from '../../../../nls.js';
-const _moduleId = "vs/base/browser/ui/hover/updatableHoverWidget";
-function setupNativeHover(htmlElement, tooltip) {
-    if (isString(tooltip)) {
-        htmlElement.title = stripIcons(tooltip);
-    }
-    else if (tooltip?.markdownNotSupportedFallback) {
-        htmlElement.title = tooltip.markdownNotSupportedFallback;
-    }
-    else {
-        htmlElement.removeAttribute('title');
-    }
-}
-class UpdatableHoverWidget {
-    constructor(hoverDelegate, target, fadeInAnimation) {
-        this.hoverDelegate = hoverDelegate;
-        this.target = target;
-        this.fadeInAnimation = fadeInAnimation;
-    }
-    async update(content, focus, options) {
-        if (this._cancellationTokenSource) {
-            this._cancellationTokenSource.dispose(true);
-            this._cancellationTokenSource = undefined;
-        }
-        if (this.isDisposed) {
-            return;
-        }
-        let resolvedContent;
-        if (content === undefined || isString(content) || content instanceof HTMLElement) {
-            resolvedContent = content;
-        }
-        else if (!isFunction(content.markdown)) {
-            resolvedContent = content.markdown ?? content.markdownNotSupportedFallback;
-        }
-        else {
-            if (!this._hoverWidget) {
-                this.show(( localizeWithPath(_moduleId, 0, "Loading...")), focus);
-            }
-            this._cancellationTokenSource = ( (new CancellationTokenSource()));
-            const token = this._cancellationTokenSource.token;
-            resolvedContent = await content.markdown(token);
-            if (resolvedContent === undefined) {
-                resolvedContent = content.markdownNotSupportedFallback;
-            }
-            if (this.isDisposed || token.isCancellationRequested) {
-                return;
-            }
-        }
-        this.show(resolvedContent, focus, options);
-    }
-    show(content, focus, options) {
-        const oldHoverWidget = this._hoverWidget;
-        if (this.hasContent(content)) {
-            const hoverOptions = {
-                content,
-                target: this.target,
-                appearance: {
-                    showPointer: this.hoverDelegate.placement === 'element',
-                    skipFadeInAnimation: !this.fadeInAnimation || !!oldHoverWidget,
-                },
-                position: {
-                    hoverPosition: 2 ,
-                },
-                ...options
-            };
-            this._hoverWidget = this.hoverDelegate.showHover(hoverOptions, focus);
-        }
-        oldHoverWidget?.dispose();
-    }
-    hasContent(content) {
-        if (!content) {
-            return false;
-        }
-        if (isMarkdownString(content)) {
-            return !!content.value;
-        }
-        return true;
-    }
-    get isDisposed() {
-        return this._hoverWidget?.isDisposed;
-    }
-    dispose() {
-        this._hoverWidget?.dispose();
-        this._cancellationTokenSource?.dispose(true);
-        this._cancellationTokenSource = undefined;
-    }
-}
-function getHoverTargetElement(element, stopElement) {
-    stopElement = stopElement ?? getWindow(element).document.body;
-    while (!element.hasAttribute('custom-hover') && element !== stopElement) {
-        element = element.parentElement;
-    }
-    return element;
-}
-function setupCustomHover(hoverDelegate, htmlElement, content, options) {
-    htmlElement.setAttribute('custom-hover', 'true');
-    if (htmlElement.title !== '') {
-        console.warn('HTML element already has a title attribute, which will conflict with the custom hover. Please remove the title attribute.');
-        console.trace('Stack trace:', htmlElement.title);
-        htmlElement.title = '';
-    }
-    let hoverPreparation;
-    let hoverWidget;
-    const hideHover = (disposeWidget, disposePreparation) => {
-        const hadHover = hoverWidget !== undefined;
-        if (disposeWidget) {
-            hoverWidget?.dispose();
-            hoverWidget = undefined;
-        }
-        if (disposePreparation) {
-            hoverPreparation?.dispose();
-            hoverPreparation = undefined;
-        }
-        if (hadHover) {
-            hoverDelegate.onDidHideHover?.();
-            hoverWidget = undefined;
-        }
-    };
-    const triggerShowHover = (delay, focus, target) => {
-        return (
-             (new TimeoutTimer(async () => {
-                if (!hoverWidget || hoverWidget.isDisposed) {
-                    hoverWidget = ( (new UpdatableHoverWidget(hoverDelegate, target || htmlElement, delay > 0)));
-                    await hoverWidget.update(typeof content === 'function' ? content() : content, focus, options);
-                }
-            }, delay))
-        );
-    };
-    let isMouseDown = false;
-    const mouseDownEmitter = addDisposableListener(htmlElement, EventType.MOUSE_DOWN, () => {
-        isMouseDown = true;
-        hideHover(true, true);
-    }, true);
-    const mouseUpEmitter = addDisposableListener(htmlElement, EventType.MOUSE_UP, () => {
-        isMouseDown = false;
-    }, true);
-    const mouseLeaveEmitter = addDisposableListener(htmlElement, EventType.MOUSE_LEAVE, (e) => {
-        isMouseDown = false;
-        hideHover(false, e.fromElement === htmlElement);
-    }, true);
-    const onMouseOver = (e) => {
-        if (hoverPreparation) {
-            return;
-        }
-        const toDispose = ( (new DisposableStore()));
-        const target = {
-            targetElements: [htmlElement],
-            dispose: () => { }
-        };
-        if (hoverDelegate.placement === undefined || hoverDelegate.placement === 'mouse') {
-            const onMouseMove = (e) => {
-                target.x = e.x + 10;
-                if ((e.target instanceof HTMLElement) && getHoverTargetElement(e.target, htmlElement) !== htmlElement) {
-                    hideHover(true, true);
-                }
-            };
-            toDispose.add(addDisposableListener(htmlElement, EventType.MOUSE_MOVE, onMouseMove, true));
-        }
-        hoverPreparation = toDispose;
-        if ((e.target instanceof HTMLElement) && getHoverTargetElement(e.target, htmlElement) !== htmlElement) {
-            return;
-        }
-        toDispose.add(triggerShowHover(hoverDelegate.delay, false, target));
-    };
-    const mouseOverDomEmitter = addDisposableListener(htmlElement, EventType.MOUSE_OVER, onMouseOver, true);
-    const onFocus = () => {
-        if (isMouseDown || hoverPreparation) {
-            return;
-        }
-        const target = {
-            targetElements: [htmlElement],
-            dispose: () => { }
-        };
-        const toDispose = ( (new DisposableStore()));
-        const onBlur = () => hideHover(true, true);
-        toDispose.add(addDisposableListener(htmlElement, EventType.BLUR, onBlur, true));
-        toDispose.add(triggerShowHover(hoverDelegate.delay, false, target));
-        hoverPreparation = toDispose;
-    };
-    let focusDomEmitter;
-    const tagName = htmlElement.tagName.toLowerCase();
-    if (tagName !== 'input' && tagName !== 'textarea') {
-        focusDomEmitter = addDisposableListener(htmlElement, EventType.FOCUS, onFocus, true);
-    }
-    const hover = {
-        show: focus => {
-            hideHover(false, true);
-        },
-        hide: () => {
-            hideHover(true, true);
-        },
-        update: async (newContent, hoverOptions) => {
-            content = newContent;
-            await hoverWidget?.update(content, undefined, hoverOptions);
-        },
-        dispose: () => {
-            mouseOverDomEmitter.dispose();
-            mouseLeaveEmitter.dispose();
-            mouseDownEmitter.dispose();
-            mouseUpEmitter.dispose();
-            focusDomEmitter?.dispose();
-            hideHover(true, true);
-        }
-    };
-    return hover;
-}
-export { setupCustomHover, setupNativeHover };

package/vscode/src/vs/editor/browser/services/hoverService/hoverService.d.ts

@@ -1,32 +0,0 @@
-import { IHoverOptions } from '../../../../platform/hover/browser/hover.js';
-import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
-import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.service.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
-import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.service.js';
-import { ILayoutService } from '../../../../platform/layout/browser/layoutService.service.js';
-import { IHoverWidget } from '../../../../base/browser/ui/hover/updatableHoverWidget.js';
-
-declare class HoverService extends Disposable implements IHoverService {
-    private readonly _instantiationService;
-    private readonly _keybindingService;
-    private readonly _layoutService;
-    private readonly _accessibilityService;
-    readonly _serviceBrand: undefined;
-    private _contextViewHandler;
-    private _currentHoverOptions;
-    private _currentHover;
-    private _lastHoverOptions;
-    private _lastFocusedElementBeforeOpen;
-    constructor(_instantiationService: IInstantiationService, contextMenuService: IContextMenuService, _keybindingService: IKeybindingService, _layoutService: ILayoutService, _accessibilityService: IAccessibilityService);
-    showHover(options: IHoverOptions, focus?: boolean, skipLastFocusedUpdate?: boolean): IHoverWidget | undefined;
-    hideHover(): void;
-    private doHideHover;
-    private _intersectionChange;
-    showAndFocusLastHover(): void;
-    private _keyDown;
-    private _keyUp;
-}
-
-export { HoverService };