@codingame/monaco-vscode-xterm-common 24.1.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat.js

@@ -0,0 +1,69 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+
+var TerminalChatCommandId;
+(function (TerminalChatCommandId) {
+    TerminalChatCommandId["Start"] = "workbench.action.terminal.chat.start";
+    TerminalChatCommandId["Close"] = "workbench.action.terminal.chat.close";
+    TerminalChatCommandId["MakeRequest"] = "workbench.action.terminal.chat.makeRequest";
+    TerminalChatCommandId["Cancel"] = "workbench.action.terminal.chat.cancel";
+    TerminalChatCommandId["RunCommand"] = "workbench.action.terminal.chat.runCommand";
+    TerminalChatCommandId["RunFirstCommand"] = "workbench.action.terminal.chat.runFirstCommand";
+    TerminalChatCommandId["InsertCommand"] = "workbench.action.terminal.chat.insertCommand";
+    TerminalChatCommandId["InsertFirstCommand"] = "workbench.action.terminal.chat.insertFirstCommand";
+    TerminalChatCommandId["ViewInChat"] = "workbench.action.terminal.chat.viewInChat";
+    TerminalChatCommandId["RerunRequest"] = "workbench.action.terminal.chat.rerunRequest";
+    TerminalChatCommandId["ViewHiddenChatTerminals"] = "workbench.action.terminal.chat.viewHiddenChatTerminals";
+    TerminalChatCommandId["OpenTerminalSettingsLink"] = "workbench.action.terminal.chat.openTerminalSettingsLink";
+    TerminalChatCommandId["DisableSessionAutoApproval"] = "workbench.action.terminal.chat.disableSessionAutoApproval";
+    TerminalChatCommandId["FocusMostRecentChatTerminalOutput"] = "workbench.action.terminal.chat.focusMostRecentChatTerminalOutput";
+    TerminalChatCommandId["FocusMostRecentChatTerminal"] = "workbench.action.terminal.chat.focusMostRecentChatTerminal";
+    TerminalChatCommandId["ToggleChatTerminalOutput"] = "workbench.action.terminal.chat.toggleChatTerminalOutput";
+    TerminalChatCommandId["FocusChatInstanceAction"] = "workbench.action.terminal.chat.focusChatInstance";
+})(TerminalChatCommandId || (TerminalChatCommandId = {}));
+const MENU_TERMINAL_CHAT_WIDGET_INPUT_SIDE_TOOLBAR = MenuId.for('terminalChatWidget');
+const MENU_TERMINAL_CHAT_WIDGET_STATUS = MenuId.for('terminalChatWidget.status');
+MenuId.for('terminalChatWidget.toolbar');
+var TerminalChatContextKeyStrings;
+(function (TerminalChatContextKeyStrings) {
+    TerminalChatContextKeyStrings["ChatFocus"] = "terminalChatFocus";
+    TerminalChatContextKeyStrings["ChatVisible"] = "terminalChatVisible";
+    TerminalChatContextKeyStrings["ChatActiveRequest"] = "terminalChatActiveRequest";
+    TerminalChatContextKeyStrings["ChatInputHasText"] = "terminalChatInputHasText";
+    TerminalChatContextKeyStrings["ChatAgentRegistered"] = "terminalChatAgentRegistered";
+    TerminalChatContextKeyStrings["ChatResponseEditorFocused"] = "terminalChatResponseEditorFocused";
+    TerminalChatContextKeyStrings["ChatResponseContainsCodeBlock"] = "terminalChatResponseContainsCodeBlock";
+    TerminalChatContextKeyStrings["ChatResponseContainsMultipleCodeBlocks"] = "terminalChatResponseContainsMultipleCodeBlocks";
+    TerminalChatContextKeyStrings["ChatResponseSupportsIssueReporting"] = "terminalChatResponseSupportsIssueReporting";
+    TerminalChatContextKeyStrings["ChatSessionResponseVote"] = "terminalChatSessionResponseVote";
+    TerminalChatContextKeyStrings["ChatHasTerminals"] = "hasChatTerminals";
+    TerminalChatContextKeyStrings["ChatHasHiddenTerminals"] = "hasHiddenChatTerminals";
+})(TerminalChatContextKeyStrings || (TerminalChatContextKeyStrings = {}));
+var TerminalChatContextKeys;
+(function (TerminalChatContextKeys) {
+    TerminalChatContextKeys.focused = ( new RawContextKey(TerminalChatContextKeyStrings.ChatFocus, false, ( localize(11942, "Whether the chat view is focused."))));
+    TerminalChatContextKeys.visible = ( new RawContextKey(TerminalChatContextKeyStrings.ChatVisible, false, ( localize(11943, "Whether the chat view is visible."))));
+    TerminalChatContextKeys.requestActive = ( new RawContextKey(TerminalChatContextKeyStrings.ChatActiveRequest, false, ( localize(11944, "Whether there is an active chat request."))));
+    TerminalChatContextKeys.inputHasText = ( new RawContextKey(TerminalChatContextKeyStrings.ChatInputHasText, false, ( localize(11945, "Whether the chat input has text."))));
+    TerminalChatContextKeys.responseContainsCodeBlock = ( new RawContextKey(
+        TerminalChatContextKeyStrings.ChatResponseContainsCodeBlock,
+        false,
+        ( localize(11946, "Whether the chat response contains a code block."))
+    ));
+    TerminalChatContextKeys.responseContainsMultipleCodeBlocks = ( new RawContextKey(
+        TerminalChatContextKeyStrings.ChatResponseContainsMultipleCodeBlocks,
+        false,
+        ( localize(11947, "Whether the chat response contains multiple code blocks."))
+    ));
+    TerminalChatContextKeys.hasChatAgent = ( new RawContextKey(TerminalChatContextKeyStrings.ChatAgentRegistered, false, ( localize(11948, "Whether a chat agent is registered for the terminal location."))));
+    TerminalChatContextKeys.hasChatTerminals = ( new RawContextKey(TerminalChatContextKeyStrings.ChatHasTerminals, false, ( localize(11949, "Whether there are any chat terminals."))));
+    TerminalChatContextKeys.hasHiddenChatTerminals = ( new RawContextKey(
+        TerminalChatContextKeyStrings.ChatHasHiddenTerminals,
+        false,
+        ( localize(11950, "Whether there are any hidden chat terminals."))
+    ));
+})(TerminalChatContextKeys || (TerminalChatContextKeys = {}));
+
+export { MENU_TERMINAL_CHAT_WIDGET_INPUT_SIDE_TOOLBAR, MENU_TERMINAL_CHAT_WIDGET_STATUS, TerminalChatCommandId, TerminalChatContextKeyStrings, TerminalChatContextKeys };

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/media/stickyScroll.css

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.terminal-sticky-scroll {
+	display: none;
+	position: absolute;
+	left: 0;
+	right: 14px; /* Don't overlap terminal scroll bar */
+	z-index: 32; /* Must be higher than decorations */
+	background: var(--vscode-terminalStickyScroll-background, var(--vscode-terminal-background, var(--vscode-panel-background)));
+	box-shadow: var(--vscode-scrollbar-shadow) 0 3px 2px -2px;
+	border-bottom: 1px solid var(--vscode-terminalStickyScroll-border, transparent);
+}
+.part.sidebar .terminal-sticky-scroll,
+.part.auxiliarybar .terminal-sticky-scroll {
+	background: var(--vscode-terminalStickyScroll-background, var(--vscode-terminal-background, var(--vscode-sideBar-background)));
+}
+.editor-instance .terminal-sticky-scroll {
+	background: var(--vscode-terminalStickyScroll-background, var(--vscode-terminal-background, var(--vscode-editor-background)));
+}
+
+.terminal-sticky-scroll.visible {
+	display:block;
+}
+
+.terminal-sticky-scroll:hover {
+	cursor: pointer !important;
+}
+
+.terminal-sticky-scroll .xterm {
+	position: relative !important;
+	pointer-events: none;
+	padding-bottom: 0 !important;
+}
+
+.terminal-sticky-scroll .hover-overlay {
+	position: absolute;
+	left: 0;
+	right: 0;
+	top: 0;
+	bottom: 0;
+	cursor: pointer !important;
+}
+
+.terminal-sticky-scroll .hover-overlay:hover {
+	background-color: var(--vscode-terminalStickyScrollHover-background, transparent);
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollColorRegistry.d.ts

@@ -0,0 +1,2 @@
+export declare const terminalStickyScrollBackground: string;
+export declare const terminalStickyScrollHoverBackground: string;

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollColorRegistry.js

@@ -0,0 +1,25 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerColor } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+
+const terminalStickyScrollBackground = registerColor('terminalStickyScroll.background', null, ( localize(
+    12216,
+    'The background color of the sticky scroll overlay in the terminal.'
+)));
+const terminalStickyScrollHoverBackground = registerColor('terminalStickyScrollHover.background', {
+    dark: '#2A2D2E',
+    light: '#F0F0F0',
+    hcDark: '#E48B39',
+    hcLight: '#0f4a85'
+}, ( localize(
+    12217,
+    'The background color of the sticky scroll overlay in the terminal when hovered.'
+)));
+registerColor('terminalStickyScroll.border', {
+    dark: null,
+    light: null,
+    hcDark: '#6fc3df',
+    hcLight: '#0f4a85'
+}, ( localize(12218, 'The border of the sticky scroll overlay in the terminal.')));
+
+export { terminalStickyScrollBackground, terminalStickyScrollHoverBackground };

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollContribution.d.ts

@@ -0,0 +1,35 @@
+import type { Terminal as RawXtermTerminal } from "@xterm/xterm";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { ITerminalContribution, ITerminalInstance, IXtermTerminal } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import type { ITerminalContributionContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminalExtensions";
+export declare class TerminalStickyScrollContribution extends Disposable implements ITerminalContribution {
+    private readonly _ctx;
+    private readonly _configurationService;
+    private readonly _contextKeyService;
+    private readonly _instantiationService;
+    private readonly _keybindingService;
+    static readonly ID = "terminal.stickyScroll";
+    static get(instance: ITerminalInstance): TerminalStickyScrollContribution | null;
+    private _xterm?;
+    private readonly _overlay;
+    private readonly _enableListeners;
+    private readonly _disableListeners;
+    private readonly _richCommandDetectionListeners;
+    constructor(_ctx: ITerminalContributionContext, _configurationService: IConfigurationService, _contextKeyService: IContextKeyService, _instantiationService: IInstantiationService, _keybindingService: IKeybindingService);
+    xtermReady(xterm: IXtermTerminal & {
+        raw: RawXtermTerminal;
+    }): void;
+    xtermOpen(xterm: IXtermTerminal & {
+        raw: RawXtermTerminal;
+    }): void;
+    hideLock(): void;
+    hideUnlock(): void;
+    private _refreshState;
+    private _tryEnable;
+    private _tryDisable;
+    private _shouldBeEnabled;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollContribution.js

@@ -0,0 +1,117 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { TerminalInstance, TerminalInstanceColorProvider } from '../../../terminal/browser/terminalInstance.js';
+import { TerminalStickyScrollSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/stickyScroll/common/terminalStickyScrollConfiguration';
+import * as stickyScroll from './media/stickyScroll.css';
+import { TerminalStickyScrollOverlay } from './terminalStickyScrollOverlay.js';
+
+var TerminalStickyScrollContribution_1;
+registerCss(stickyScroll);
+let TerminalStickyScrollContribution = class TerminalStickyScrollContribution extends Disposable {
+    static { TerminalStickyScrollContribution_1 = this; }
+    static { this.ID = 'terminal.stickyScroll'; }
+    static get(instance) {
+        return instance.getContribution(TerminalStickyScrollContribution_1.ID);
+    }
+    constructor(_ctx, _configurationService, _contextKeyService, _instantiationService, _keybindingService) {
+        super();
+        this._ctx = _ctx;
+        this._configurationService = _configurationService;
+        this._contextKeyService = _contextKeyService;
+        this._instantiationService = _instantiationService;
+        this._keybindingService = _keybindingService;
+        this._overlay = this._register(( new MutableDisposable()));
+        this._enableListeners = this._register(( new MutableDisposable()));
+        this._disableListeners = this._register(( new MutableDisposable()));
+        this._richCommandDetectionListeners = this._register(( new MutableDisposable()));
+        this._register(Event.runAndSubscribe(this._configurationService.onDidChangeConfiguration, e => {
+            if (!e || e.affectsConfiguration(TerminalStickyScrollSettingId.Enabled)) {
+                this._refreshState();
+            }
+        }));
+    }
+    xtermReady(xterm) {
+        this._xterm = xterm;
+        this._refreshState();
+    }
+    xtermOpen(xterm) {
+        this._refreshState();
+    }
+    hideLock() {
+        this._overlay.value?.lockHide();
+    }
+    hideUnlock() {
+        this._overlay.value?.unlockHide();
+    }
+    _refreshState() {
+        if (this._overlay.value) {
+            this._tryDisable();
+        }
+        else {
+            this._tryEnable();
+        }
+        if (this._overlay.value) {
+            this._enableListeners.clear();
+            if (!this._disableListeners.value) {
+                this._disableListeners.value = this._ctx.instance.capabilities.onDidRemoveCapability(e => {
+                    if (e.id === TerminalCapability.CommandDetection) {
+                        this._refreshState();
+                    }
+                });
+            }
+        }
+        else {
+            this._disableListeners.clear();
+            if (!this._enableListeners.value) {
+                this._enableListeners.value = this._ctx.instance.capabilities.onDidAddCapability(e => {
+                    if (e.id === TerminalCapability.CommandDetection) {
+                        this._refreshState();
+                    }
+                });
+            }
+        }
+    }
+    _tryEnable() {
+        const capability = this._ctx.instance.capabilities.get(TerminalCapability.CommandDetection);
+        if (this._shouldBeEnabled()) {
+            const xtermCtorEventually = TerminalInstance.getXtermConstructor(this._keybindingService, this._contextKeyService);
+            this._overlay.value = this._instantiationService.createInstance(TerminalStickyScrollOverlay, this._ctx.instance, this._xterm, this._instantiationService.createInstance(TerminalInstanceColorProvider, this._ctx.instance.targetRef), capability, xtermCtorEventually);
+            this._richCommandDetectionListeners.clear();
+        }
+        else if (capability && !capability.hasRichCommandDetection) {
+            this._richCommandDetectionListeners.value = capability.onSetRichCommandDetection(() => {
+                this._refreshState();
+            });
+        }
+        else {
+            this._richCommandDetectionListeners.clear();
+        }
+    }
+    _tryDisable() {
+        if (!this._shouldBeEnabled()) {
+            this._overlay.clear();
+            this._richCommandDetectionListeners.clear();
+        }
+    }
+    _shouldBeEnabled() {
+        const capability = this._ctx.instance.capabilities.get(TerminalCapability.CommandDetection);
+        const result = !!(this._configurationService.getValue(TerminalStickyScrollSettingId.Enabled) && capability && capability.hasRichCommandDetection && this._xterm?.raw?.element);
+        return result;
+    }
+};
+TerminalStickyScrollContribution = TerminalStickyScrollContribution_1 = ( __decorate([
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IKeybindingService))
+], TerminalStickyScrollContribution));
+
+export { TerminalStickyScrollContribution };

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollOverlay.d.ts

@@ -0,0 +1,56 @@
+import type { Terminal as RawXtermTerminal, Terminal as XTermTerminal } from "@xterm/xterm";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { ICommandDetectionCapability } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { ITerminalInstance, IXtermColorProvider, IXtermTerminal } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { ITerminalConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+export declare class TerminalStickyScrollOverlay extends Disposable {
+    private readonly _instance;
+    private readonly _xterm;
+    private readonly _xtermColorProvider;
+    private readonly _commandDetection;
+    private readonly _contextMenuService;
+    private readonly _keybindingService;
+    private readonly _terminalConfigurationService;
+    private readonly _themeService;
+    private _stickyScrollOverlay?;
+    private readonly _xtermAddonLoader;
+    private _serializeAddon?;
+    private _webglAddon?;
+    private _ligaturesAddon?;
+    private _element?;
+    private _currentStickyCommand?;
+    private _currentContent?;
+    private _contextMenu;
+    private readonly _refreshListeners;
+    private _state;
+    private _isRefreshQueued;
+    private _rawMaxLineCount;
+    private _pendingShowOperation;
+    constructor(_instance: ITerminalInstance, _xterm: IXtermTerminal & {
+        raw: RawXtermTerminal;
+    }, _xtermColorProvider: IXtermColorProvider, _commandDetection: ICommandDetectionCapability, xtermCtor: Promise<typeof XTermTerminal>, configurationService: IConfigurationService, contextKeyService: IContextKeyService, _contextMenuService: IContextMenuService, _keybindingService: IKeybindingService, menuService: IMenuService, _terminalConfigurationService: ITerminalConfigurationService, _themeService: IThemeService);
+    lockHide(): void;
+    unlockHide(): void;
+    private _setState;
+    private _installRefreshListeners;
+    private _uninstallRefreshListeners;
+    private _setVisible;
+    private _show;
+    private _hide;
+    private _refresh;
+    private _refreshNow;
+    private _updateContent;
+    private _ensureElement;
+    private _syncOptions;
+    private _getOptions;
+    private _refreshGpuAcceleration;
+    private _shouldLoadWebgl;
+    private _getTheme;
+    private _isClearCommand;
+}