@codingame/monaco-vscode-api 9.0.3 → 10.0.1

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

@@ -0,0 +1,302 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
+import { Event, Emitter } from '../../../../../base/common/event.js';
+import { Lazy } from '../../../../../base/common/lazy.js';
+import { Disposable, MutableDisposable, toDisposable, DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { showChatView } from '../../../chat/browser/chat.js';
+import { IChatCodeBlockContextProviderService } from '../../../chat/browser/chat.service.js';
+import { IChatService } from '../../../chat/common/chatService.service.js';
+import { isDetachedTerminalInstance } from '../../../terminal/browser/terminal.js';
+import { ITerminalService } from '../../../terminal/browser/terminal.service.js';
+import { TerminalChatWidget } from './terminalChatWidget.js';
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import { TerminalChatContextKeys } from './terminalChat.js';
+import { IViewsService } from '../../../../services/views/common/viewsService.service.js';
+import { IStorageService } from '../../../../../platform/storage/common/storage.service.js';
+import { assertType } from '../../../../../base/common/types.js';
+import { createCancelablePromise, DeferredPromise } from '../../../../../base/common/async.js';
+import { ChatAgentLocation } from '../../../chat/common/chatAgents.js';
+var TerminalChatController_1;
+let TerminalChatController = class TerminalChatController extends Disposable {
+    static { TerminalChatController_1 = this; }
+    static { this.ID = 'terminal.chat'; }
+    static get(instance) {
+        return instance.getContribution(TerminalChatController_1.ID);
+    }
+    static { this._storageKey = 'terminal-inline-chat-history'; }
+    static { this._promptHistory = []; }
+    get terminalChatWidget() { return this._terminalChatWidget?.value; }
+    get chatWidget() { return this._terminalChatWidget?.value.inlineChatWidget?.chatWidget; }
+    get lastResponseContent() {
+        return this._lastResponseContent;
+    }
+    get onDidHide() { return this.terminalChatWidget?.onDidHide ?? Event.None; }
+    get scopedContextKeyService() {
+        return this._terminalChatWidget?.value.inlineChatWidget.scopedContextKeyService ?? this._contextKeyService;
+    }
+    constructor(_instance, processManager, widgetManager, _terminalService, _instantiationService, _contextKeyService, _chatService, _chatCodeBlockContextProviderService, _viewsService, _storageService) {
+        super();
+        this._instance = _instance;
+        this._terminalService = _terminalService;
+        this._instantiationService = _instantiationService;
+        this._contextKeyService = _contextKeyService;
+        this._chatService = _chatService;
+        this._chatCodeBlockContextProviderService = _chatCodeBlockContextProviderService;
+        this._viewsService = _viewsService;
+        this._storageService = _storageService;
+        this._messages = this._store.add(( new Emitter()));
+        this.onDidAcceptInput = Event.filter(this._messages.event, m => m === 32 , this._store);
+        this._terminalAgentName = 'terminal';
+        this._model = this._register(( new MutableDisposable()));
+        this._historyOffset = -1;
+        this._historyCandidate = '';
+        this._forcedPlaceholder = undefined;
+        this._requestActiveContextKey = TerminalChatContextKeys.requestActive.bindTo(this._contextKeyService);
+        this._responseContainsCodeBlockContextKey = TerminalChatContextKeys.responseContainsCodeBlock.bindTo(this._contextKeyService);
+        this._responseContainsMulitpleCodeBlocksContextKey = TerminalChatContextKeys.responseContainsMultipleCodeBlocks.bindTo(this._contextKeyService);
+        this._register(this._chatCodeBlockContextProviderService.registerProvider({
+            getCodeBlockContext: (editor) => {
+                if (!editor || !this._terminalChatWidget?.hasValue || !this.hasFocus()) {
+                    return;
+                }
+                return {
+                    element: editor,
+                    code: editor.getValue(),
+                    codeBlockIndex: 0,
+                    languageId: editor.getModel().getLanguageId()
+                };
+            }
+        }, 'terminal'));
+        TerminalChatController_1._promptHistory = JSON.parse(this._storageService.get(TerminalChatController_1._storageKey, 0 , '[]'));
+        this._historyUpdate = (prompt) => {
+            const idx = TerminalChatController_1._promptHistory.indexOf(prompt);
+            if (idx >= 0) {
+                TerminalChatController_1._promptHistory.splice(idx, 1);
+            }
+            TerminalChatController_1._promptHistory.unshift(prompt);
+            this._historyOffset = -1;
+            this._historyCandidate = '';
+            this._storageService.store(TerminalChatController_1._storageKey, JSON.stringify(TerminalChatController_1._promptHistory), 0 , 0 );
+        };
+    }
+    xtermReady(xterm) {
+        this._terminalChatWidget = ( new Lazy(() => {
+            const chatWidget = this._register(this._instantiationService.createInstance(TerminalChatWidget, this._instance.domElement, this._instance, xterm));
+            this._register(chatWidget.focusTracker.onDidFocus(() => {
+                TerminalChatController_1.activeChatController = this;
+                if (!isDetachedTerminalInstance(this._instance)) {
+                    this._terminalService.setActiveInstance(this._instance);
+                }
+            }));
+            this._register(chatWidget.focusTracker.onDidBlur(() => {
+                TerminalChatController_1.activeChatController = undefined;
+                this._instance.resetScrollbarVisibility();
+            }));
+            if (!this._instance.domElement) {
+                throw ( new Error('FindWidget expected terminal DOM to be initialized'));
+            }
+            return chatWidget;
+        }));
+    }
+    async _createSession() {
+        this._sessionCtor = createCancelablePromise(async (token) => {
+            if (!this._model.value) {
+                this._model.value = this._chatService.startSession(ChatAgentLocation.Terminal, token);
+                if (!this._model.value) {
+                    throw ( new Error('Failed to start chat session'));
+                }
+            }
+        });
+        this._register(toDisposable(() => this._sessionCtor?.cancel()));
+    }
+    _updatePlaceholder() {
+        const inlineChatWidget = this._terminalChatWidget?.value.inlineChatWidget;
+        if (inlineChatWidget) {
+            inlineChatWidget.placeholder = this._getPlaceholderText();
+        }
+    }
+    _getPlaceholderText() {
+        return this._forcedPlaceholder ?? '';
+    }
+    setPlaceholder(text) {
+        this._forcedPlaceholder = text;
+        this._updatePlaceholder();
+    }
+    resetPlaceholder() {
+        this._forcedPlaceholder = undefined;
+        this._updatePlaceholder();
+    }
+    clear() {
+        this.cancel();
+        this._model.clear();
+        this._responseContainsCodeBlockContextKey.reset();
+        this._requestActiveContextKey.reset();
+        this._terminalChatWidget?.value.hide();
+        this._terminalChatWidget?.value.setValue(undefined);
+    }
+    async acceptInput(isVoiceInput) {
+        assertType(this._terminalChatWidget);
+        if (!this._model.value) {
+            await this.reveal();
+        }
+        assertType(this._model.value);
+        const lastInput = this._terminalChatWidget.value.inlineChatWidget.value;
+        if (!lastInput) {
+            return;
+        }
+        const model = this._model.value;
+        this._terminalChatWidget.value.inlineChatWidget.setChatModel(model);
+        this._historyUpdate(lastInput);
+        this._activeRequestCts?.cancel();
+        this._activeRequestCts = ( new CancellationTokenSource());
+        const store = ( new DisposableStore());
+        this._requestActiveContextKey.set(true);
+        let responseContent = '';
+        const response = await this._terminalChatWidget.value.inlineChatWidget.chatWidget.acceptInput(lastInput, isVoiceInput);
+        this._currentRequestId = response?.requestId;
+        const responsePromise = ( new DeferredPromise());
+        try {
+            this._requestActiveContextKey.set(true);
+            if (response) {
+                store.add(response.onDidChange(async () => {
+                    responseContent += response.response.value;
+                    if (response.isCanceled) {
+                        this._requestActiveContextKey.set(false);
+                        responsePromise.complete(undefined);
+                        return;
+                    }
+                    if (response.isComplete) {
+                        this._requestActiveContextKey.set(false);
+                        this._requestActiveContextKey.set(false);
+                        const containsCode = responseContent.includes('```');
+                        this._terminalChatWidget.value.inlineChatWidget.updateChatMessage({ message: ( new MarkdownString(responseContent)), requestId: response.requestId }, false, containsCode);
+                        const firstCodeBlock = await this.terminalChatWidget?.inlineChatWidget.getCodeBlockInfo(0);
+                        const secondCodeBlock = await this.terminalChatWidget?.inlineChatWidget.getCodeBlockInfo(1);
+                        this._responseContainsCodeBlockContextKey.set(!!firstCodeBlock);
+                        this._responseContainsMulitpleCodeBlocksContextKey.set(!!secondCodeBlock);
+                        this._terminalChatWidget?.value.inlineChatWidget.updateToolbar(true);
+                        responsePromise.complete(response);
+                    }
+                }));
+            }
+            await responsePromise.p;
+            return response;
+        }
+        catch {
+            return;
+        }
+        finally {
+            store.dispose();
+        }
+    }
+    updateInput(text, selectAll = true) {
+        const widget = this._terminalChatWidget?.value.inlineChatWidget;
+        if (widget) {
+            widget.value = text;
+            if (selectAll) {
+                widget.selectAll();
+            }
+        }
+    }
+    getInput() {
+        return this._terminalChatWidget?.value.input() ?? '';
+    }
+    focus() {
+        this._terminalChatWidget?.value.focus();
+    }
+    hasFocus() {
+        return this._terminalChatWidget?.rawValue?.hasFocus() ?? false;
+    }
+    populateHistory(up) {
+        if (!this._terminalChatWidget?.value) {
+            return;
+        }
+        const len = TerminalChatController_1._promptHistory.length;
+        if (len === 0) {
+            return;
+        }
+        if (this._historyOffset === -1) {
+            this._historyCandidate = this._terminalChatWidget.value.inlineChatWidget.value;
+        }
+        const newIdx = this._historyOffset + (up ? 1 : -1);
+        if (newIdx >= len) {
+            return;
+        }
+        let entry;
+        if (newIdx < 0) {
+            entry = this._historyCandidate;
+            this._historyOffset = -1;
+        }
+        else {
+            entry = TerminalChatController_1._promptHistory[newIdx];
+            this._historyOffset = newIdx;
+        }
+        this._terminalChatWidget.value.inlineChatWidget.value = entry;
+        this._terminalChatWidget.value.inlineChatWidget.selectAll();
+    }
+    cancel() {
+        this._sessionCtor?.cancel();
+        this._sessionCtor = undefined;
+        this._activeRequestCts?.cancel();
+        this._requestActiveContextKey.set(false);
+        const model = this._terminalChatWidget?.value.inlineChatWidget.getChatModel();
+        if (!model?.sessionId) {
+            return;
+        }
+        this._chatService.cancelCurrentRequestForSession(model?.sessionId);
+    }
+    async acceptCommand(shouldExecute) {
+        const code = await this.terminalChatWidget?.inlineChatWidget.getCodeBlockInfo(0);
+        if (!code) {
+            return;
+        }
+        this._terminalChatWidget?.value.acceptCommand(code.textEditorModel.getValue(), shouldExecute);
+    }
+    async reveal() {
+        await this._createSession();
+        this._terminalChatWidget?.value.reveal();
+        this._terminalChatWidget?.value.focus();
+    }
+    async viewInChat() {
+        const widget = await showChatView(this._viewsService);
+        const currentRequest = this.terminalChatWidget?.inlineChatWidget.chatWidget.viewModel?.model.getRequests().find(r => r.id === this._currentRequestId);
+        if (!widget || !currentRequest?.response) {
+            return;
+        }
+        const message = [];
+        for (const item of currentRequest.response.response.value) {
+            if (item.kind === 'textEditGroup') {
+                for (const group of item.edits) {
+                    message.push({
+                        kind: 'textEdit',
+                        edits: group,
+                        uri: item.uri
+                    });
+                }
+            }
+            else {
+                message.push(item);
+            }
+        }
+        this._chatService.addCompleteRequest(widget.viewModel.sessionId,
+        `@${this._terminalAgentName} ${currentRequest.message.text}`, currentRequest.variableData, currentRequest.attempt, {
+            message,
+            result: currentRequest.response.result,
+            followups: currentRequest.response.followups
+        });
+        widget.focusLastMessage();
+        this._terminalChatWidget?.rawValue?.hide();
+    }
+};
+TerminalChatController = TerminalChatController_1 = ( __decorate([
+    ( __param(3, ITerminalService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IChatService)),
+    ( __param(7, IChatCodeBlockContextProviderService)),
+    ( __param(8, IViewsService)),
+    ( __param(9, IStorageService))
+], TerminalChatController));
+export { TerminalChatController };

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

@@ -0,0 +1,203 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { trackFocus, getActiveWindow, Dimension } from '../../../../../base/browser/dom.js';
+import { Emitter, Event } from '../../../../../base/common/event.js';
+import { Disposable, toDisposable } from '../../../../../base/common/lifecycle.js';
+import { MicrotaskDelay } from '../../../../../base/common/symbols.js';
+import './media/terminalChatWidget.css.js';
+import { localize } from '../../../../../nls.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { ChatAgentLocation } from '../../../chat/common/chatAgents.js';
+import { InlineChatWidget } from '../../../inlineChat/browser/inlineChatWidget.js';
+import { TerminalChatContextKeys, MENU_TERMINAL_CHAT_WIDGET_STATUS, MENU_TERMINAL_CHAT_INPUT, MENU_TERMINAL_CHAT_WIDGET } from './terminalChat.js';
+import { TerminalStickyScrollContribution } from '../../stickyScroll/browser/terminalStickyScrollContribution.js';
+import { MENU_INLINE_CHAT_WIDGET_SECONDARY } from '../../../inlineChat/common/inlineChat.js';
+let TerminalChatWidget = class TerminalChatWidget extends Disposable {
+    get inlineChatWidget() { return this._inlineChatWidget; }
+    constructor(_terminalElement, _instance, _xterm, _instantiationService, _contextKeyService) {
+        super();
+        this._terminalElement = _terminalElement;
+        this._instance = _instance;
+        this._xterm = _xterm;
+        this._instantiationService = _instantiationService;
+        this._contextKeyService = _contextKeyService;
+        this._onDidHide = this._register(( (new Emitter())));
+        this.onDidHide = this._onDidHide.event;
+        this._focusedContextKey = TerminalChatContextKeys.focused.bindTo(this._contextKeyService);
+        this._visibleContextKey = TerminalChatContextKeys.visible.bindTo(this._contextKeyService);
+        this._container = document.createElement('div');
+        this._container.classList.add('terminal-inline-chat');
+        _terminalElement.appendChild(this._container);
+        this._inlineChatWidget = this._instantiationService.createInstance(InlineChatWidget, {
+            location: ChatAgentLocation.Terminal,
+            resolveData: () => {
+                return undefined;
+            }
+        }, {
+            statusMenuId: {
+                menu: MENU_TERMINAL_CHAT_WIDGET_STATUS,
+                options: {
+                    buttonConfigProvider: action => {
+                        if (action.id === "workbench.action.terminal.chat.viewInChat"  || action.id === "workbench.action.terminal.chat.runCommand"  || action.id === "workbench.action.terminal.chat.runFirstCommand" ) {
+                            return { isSecondary: false };
+                        }
+                        else {
+                            return { isSecondary: true };
+                        }
+                    }
+                }
+            },
+            secondaryMenuId: MENU_INLINE_CHAT_WIDGET_SECONDARY,
+            chatWidgetViewOptions: {
+                rendererOptions: { editableCodeBlock: true },
+                menus: {
+                    telemetrySource: 'terminal-inline-chat',
+                    executeToolbar: MENU_TERMINAL_CHAT_INPUT,
+                    inputSideToolbar: MENU_TERMINAL_CHAT_WIDGET,
+                }
+            }
+        });
+        this._register(Event.any(this._inlineChatWidget.onDidChangeHeight, this._instance.onDimensionsChanged, this._inlineChatWidget.chatWidget.onDidChangeContentHeight, Event.debounce(this._xterm.raw.onCursorMove, () => void 0, MicrotaskDelay))(() => this._relayout()));
+        const observer = ( (new ResizeObserver(() => this._relayout())));
+        observer.observe(this._terminalElement);
+        this._register(toDisposable(() => observer.disconnect()));
+        this._reset();
+        this._container.appendChild(this._inlineChatWidget.domNode);
+        this._focusTracker = this._register(trackFocus(this._container));
+        this._register(this._focusTracker.onDidFocus(() => this._focusedContextKey.set(true)));
+        this._register(this._focusTracker.onDidBlur(() => {
+            this._focusedContextKey.set(false);
+            if (!this.inlineChatWidget.responseContent) {
+                this.hide();
+            }
+        }));
+        this.hide();
+    }
+    _relayout() {
+        if (this._dimension) {
+            this._doLayout(this._inlineChatWidget.contentHeight);
+        }
+    }
+    _doLayout(heightInPixel) {
+        const xtermElement = this._xterm.raw.element;
+        if (!xtermElement) {
+            return;
+        }
+        const style = getActiveWindow().getComputedStyle(xtermElement);
+        const xtermPadding = parseInt(style.paddingLeft) + parseInt(style.paddingRight);
+        const width = Math.min(640, xtermElement.clientWidth - 12  - 2  - 10  - xtermPadding);
+        const terminalWrapperHeight = this._getTerminalWrapperHeight() ?? Number.MAX_SAFE_INTEGER;
+        let height = Math.min(480, heightInPixel, terminalWrapperHeight);
+        const top = this._getTop() ?? 0;
+        if (width === 0 || height === 0) {
+            return;
+        }
+        let adjustedHeight = undefined;
+        if (height < this._inlineChatWidget.contentHeight) {
+            if (height - top > 0) {
+                height = height - top - 30 ;
+            }
+            else {
+                height = height - 30 ;
+                adjustedHeight = height;
+            }
+        }
+        this._container.style.paddingLeft = style.paddingLeft;
+        this._dimension = ( (new Dimension(width, height)));
+        this._inlineChatWidget.layout(this._dimension);
+        this._updateVerticalPosition(adjustedHeight);
+    }
+    _reset() {
+        this._inlineChatWidget.placeholder = ( localize(11583, "Ask how to do something in the terminal"));
+        this._inlineChatWidget.updateInfo(( localize(11584, "AI-generated commands may be incorrect")));
+    }
+    reveal() {
+        this._doLayout(this._inlineChatWidget.contentHeight);
+        this._container.classList.remove('hide');
+        this._visibleContextKey.set(true);
+        this._inlineChatWidget.focus();
+        this._instance.scrollToBottom();
+    }
+    _getTop() {
+        const font = this._instance.xterm?.getFont();
+        if (!font?.charHeight) {
+            return;
+        }
+        const terminalWrapperHeight = this._getTerminalWrapperHeight() ?? 0;
+        const cellHeight = font.charHeight * font.lineHeight;
+        const topPadding = terminalWrapperHeight - (this._instance.rows * cellHeight);
+        const cursorY = (this._instance.xterm?.raw.buffer.active.cursorY ?? 0) + 1;
+        return topPadding + cursorY * cellHeight;
+    }
+    _updateVerticalPosition(adjustedHeight) {
+        const top = this._getTop();
+        if (!top) {
+            return;
+        }
+        this._container.style.top = `${top}px`;
+        const widgetHeight = this._inlineChatWidget.contentHeight;
+        const terminalWrapperHeight = this._getTerminalWrapperHeight();
+        if (!terminalWrapperHeight) {
+            return;
+        }
+        if (top > terminalWrapperHeight - widgetHeight && terminalWrapperHeight - widgetHeight > 0) {
+            this._setTerminalOffset(top - (terminalWrapperHeight - widgetHeight));
+        }
+        else if (adjustedHeight) {
+            this._setTerminalOffset(adjustedHeight);
+        }
+        else {
+            this._setTerminalOffset(undefined);
+        }
+    }
+    _getTerminalWrapperHeight() {
+        return this._terminalElement.clientHeight;
+    }
+    hide() {
+        this._container.classList.add('hide');
+        this._inlineChatWidget.reset();
+        this._reset();
+        this._inlineChatWidget.updateToolbar(false);
+        this._visibleContextKey.set(false);
+        this._inlineChatWidget.value = '';
+        this._instance.focus();
+        this._setTerminalOffset(undefined);
+        this._onDidHide.fire();
+    }
+    _setTerminalOffset(offset) {
+        if (offset === undefined || this._container.classList.contains('hide')) {
+            this._terminalElement.style.position = '';
+            this._terminalElement.style.bottom = '';
+            TerminalStickyScrollContribution.get(this._instance)?.hideUnlock();
+        }
+        else {
+            this._terminalElement.style.position = 'relative';
+            this._terminalElement.style.bottom = `${offset}px`;
+            TerminalStickyScrollContribution.get(this._instance)?.hideLock();
+        }
+    }
+    focus() {
+        this._inlineChatWidget.focus();
+    }
+    hasFocus() {
+        return this._inlineChatWidget.hasFocus();
+    }
+    input() {
+        return this._inlineChatWidget.value;
+    }
+    setValue(value) {
+        this._inlineChatWidget.value = value ?? '';
+    }
+    acceptCommand(code, shouldExecute) {
+        this._instance.runCommand(code, shouldExecute);
+        this.hide();
+    }
+    get focusTracker() {
+        return this._focusTracker;
+    }
+};
+TerminalChatWidget = ( (__decorate([
+    ( (__param(3, IInstantiationService))),
+    ( (__param(4, IContextKeyService)))
+], TerminalChatWidget)));
+export { TerminalChatWidget };

package/vscode/src/vs/workbench/contrib/terminalContrib/find/common/terminal.find.js

@@ -1,22 +1,11 @@
-var TerminalFindCommandId;
-( (function(TerminalFindCommandId) {
-    TerminalFindCommandId["FindFocus"] = "workbench.action.terminal.focusFind";
-    TerminalFindCommandId["FindHide"] = "workbench.action.terminal.hideFind";
-    TerminalFindCommandId["FindNext"] = "workbench.action.terminal.findNext";
-    TerminalFindCommandId["FindPrevious"] = "workbench.action.terminal.findPrevious";
-    TerminalFindCommandId["ToggleFindRegex"] = "workbench.action.terminal.toggleFindRegex";
-    TerminalFindCommandId["ToggleFindWholeWord"] = "workbench.action.terminal.toggleFindWholeWord";
-    TerminalFindCommandId["ToggleFindCaseSensitive"] = "workbench.action.terminal.toggleFindCaseSensitive";
-    TerminalFindCommandId["SearchWorkspace"] = "workbench.action.terminal.searchWorkspace";
-})(TerminalFindCommandId || (TerminalFindCommandId = {})));
 const defaultTerminalFindCommandToSkipShell = [
-    TerminalFindCommandId.FindFocus,
-    TerminalFindCommandId.FindHide,
-    TerminalFindCommandId.FindNext,
-    TerminalFindCommandId.FindPrevious,
-    TerminalFindCommandId.ToggleFindRegex,
-    TerminalFindCommandId.ToggleFindWholeWord,
-    TerminalFindCommandId.ToggleFindCaseSensitive,
-    TerminalFindCommandId.SearchWorkspace,
+    "workbench.action.terminal.focusFind" ,
+    "workbench.action.terminal.hideFind" ,
+    "workbench.action.terminal.findNext" ,
+    "workbench.action.terminal.findPrevious" ,
+    "workbench.action.terminal.toggleFindRegex" ,
+    "workbench.action.terminal.toggleFindWholeWord" ,
+    "workbench.action.terminal.toggleFindCaseSensitive" ,
+    "workbench.action.terminal.searchWorkspace" ,
 ];
-export { TerminalFindCommandId, defaultTerminalFindCommandToSkipShell };
+export { defaultTerminalFindCommandToSkipShell };

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".terminal-sticky-scroll{background:var(--vscode-terminalStickyScroll-background,var(--vscode-terminal-background,var(--vscode-panel-background)));border-bottom:1px solid var(--vscode-terminalStickyScroll-border,transparent);box-shadow:var(--vscode-scrollbar-shadow) 0 3px 2px -2px;display:none;left:0;position:absolute;right:14px;z-index:32}.part.auxiliarybar .terminal-sticky-scroll,.part.sidebar .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{padding-bottom:0!important;pointer-events:none;position:relative!important}.terminal-sticky-scroll .hover-overlay{bottom:0;cursor:pointer!important;left:0;position:absolute;right:0;top:0}.terminal-sticky-scroll .hover-overlay:hover{background-color:var(--vscode-terminalStickyScrollHover-background,transparent)}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,22 @@
+import { localize } from '../../../../../nls.js';
+import { registerColor } from '../../../../../platform/theme/common/colorUtils.js';
+const terminalStickyScrollBackground = registerColor('terminalStickyScroll.background', null, ( localize(
+    11263,
+    '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(
+    11264,
+    '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(11265, 'The border of the sticky scroll overlay in the terminal.')));
+export { terminalStickyScrollBackground, terminalStickyScrollHoverBackground };

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

@@ -0,0 +1,97 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from '../../../../../base/common/event.js';
+import { Disposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
+import './media/stickyScroll.css.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.service.js';
+import { TerminalInstance, TerminalInstanceColorProvider } from '../../../terminal/browser/terminalInstance.js';
+import { TerminalStickyScrollOverlay } from './terminalStickyScrollOverlay.js';
+var TerminalStickyScrollContribution_1;
+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(_instance, processManager, widgetManager, _configurationService, _contextKeyService, _instantiationService, _keybindingService) {
+        super();
+        this._instance = _instance;
+        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._register(Event.runAndSubscribe(this._configurationService.onDidChangeConfiguration, e => {
+            if (!e || e.affectsConfiguration("terminal.integrated.stickyScroll.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._instance.capabilities.onDidRemoveCapability(e => {
+                    if (e.id === 2 ) {
+                        this._refreshState();
+                    }
+                });
+            }
+        }
+        else {
+            this._disableListeners.clear();
+            if (!this._enableListeners.value) {
+                this._enableListeners.value = this._instance.capabilities.onDidAddCapability(e => {
+                    if (e.id === 2 ) {
+                        this._refreshState();
+                    }
+                });
+            }
+        }
+    }
+    _tryEnable() {
+        if (this._shouldBeEnabled()) {
+            const xtermCtorEventually = TerminalInstance.getXtermConstructor(this._keybindingService, this._contextKeyService);
+            this._overlay.value = this._instantiationService.createInstance(TerminalStickyScrollOverlay, this._instance, this._xterm, this._instantiationService.createInstance(TerminalInstanceColorProvider, this._instance), this._instance.capabilities.get(2 ), xtermCtorEventually);
+        }
+    }
+    _tryDisable() {
+        if (!this._shouldBeEnabled()) {
+            this._overlay.clear();
+        }
+    }
+    _shouldBeEnabled() {
+        const capability = this._instance.capabilities.get(2 );
+        return !!(this._configurationService.getValue("terminal.integrated.stickyScroll.enabled" ) && capability && this._xterm?.raw?.element);
+    }
+};
+TerminalStickyScrollContribution = TerminalStickyScrollContribution_1 = ( __decorate([
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IKeybindingService))
+], TerminalStickyScrollContribution));
+export { TerminalStickyScrollContribution };