@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatWidget.js

@@ -0,0 +1,562 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { h, trackFocus, reset, getTotalHeight, getActiveElement, getWindow, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { renderLabelWithIcons } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { DisposableStore, toDisposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { AccessibleDiffViewer } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/diffEditor/components/accessibleDiffViewer';
+import { EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { LineRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/lineRange';
+import { Selection } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection';
+import { RangeMapping, DetailedLineRangeMapping } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/rangeMapping';
+import { ScrollType } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorCommon';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IAccessibleViewService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView.service';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { MenuWorkbenchButtonBar } from '../../../../platform/actions/browser/buttonbar.js';
+import { createActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuWorkbenchToolBar } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId, MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+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 { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ILayoutService } from '@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service';
+import { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
+import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
+import { asCssVariableName, asCssVariable } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorBackground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import { inputBackground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { EDITOR_DRAG_AND_DROP_BACKGROUND } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/theme';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { AccessibilityCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/common/accessibilityCommands';
+import { MarkUnhelpfulActionId } from '../../chat/browser/actions/chatTitleActions.js';
+import { ChatVoteDownButton } from '../../chat/browser/chatListRenderer.js';
+import { ChatWidget } from '../../chat/browser/chatWidget.js';
+import { chatRequestBackground } from '../../chat/common/chatColors.js';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
+import { ChatAgentVoteDirection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { inlineChatBackground, inlineChatForeground, CTX_INLINE_CHAT_RESPONSE_FOCUSED, CTX_INLINE_CHAT_FOCUSED } from '../common/inlineChat.js';
+import * as inlineChat from './media/inlineChat.css';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+
+var HunkAccessibleDiffViewer_1;
+registerCss(inlineChat);
+let InlineChatWidget = class InlineChatWidget {
+    constructor(location, _options, _instantiationService, _contextKeyService, _keybindingService, _accessibilityService, _configurationService, _accessibleViewService, _textModelResolverService, _chatService, _hoverService, _chatEntitlementService, _markdownRendererService) {
+        this._options = _options;
+        this._instantiationService = _instantiationService;
+        this._contextKeyService = _contextKeyService;
+        this._keybindingService = _keybindingService;
+        this._accessibilityService = _accessibilityService;
+        this._configurationService = _configurationService;
+        this._accessibleViewService = _accessibleViewService;
+        this._textModelResolverService = _textModelResolverService;
+        this._chatService = _chatService;
+        this._hoverService = _hoverService;
+        this._chatEntitlementService = _chatEntitlementService;
+        this._markdownRendererService = _markdownRendererService;
+        this._elements = h('div.inline-chat@root', [
+            h('div.chat-widget@chatWidget'),
+            h('div.accessibleViewer@accessibleViewer'),
+            h('div.status@status', [
+                h('div.label.info.hidden@infoLabel'),
+                h('div.actions.hidden@toolbar1'),
+                h('div.label.status.hidden@statusLabel'),
+                h('div.actions.secondary.hidden@toolbar2'),
+                h('div.label.disclaimer.hidden@disclaimerLabel'),
+            ]),
+        ]);
+        this._store = ( new DisposableStore());
+        this._onDidChangeHeight = this._store.add(( new Emitter()));
+        this.onDidChangeHeight = Event.filter(this._onDidChangeHeight.event, _ => !this._isLayouting);
+        this._requestInProgress = observableValue(this, false);
+        this.requestInProgress = this._requestInProgress;
+        this._isLayouting = false;
+        this.scopedContextKeyService = this._store.add(_contextKeyService.createScoped(this._elements.chatWidget));
+        const scopedInstaService = _instantiationService.createChild(( new ServiceCollection([
+            IContextKeyService,
+            this.scopedContextKeyService
+        ])), this._store);
+        this._chatWidget = scopedInstaService.createInstance(ChatWidget, location, { isInlineChat: true }, {
+            autoScroll: true,
+            defaultElementHeight: 32,
+            renderStyle: 'minimal',
+            renderInputOnTop: false,
+            renderFollowups: true,
+            supportsFileReferences: true,
+            filter: item => {
+                if (!isResponseVM(item) || item.errorDetails) {
+                    return true;
+                }
+                const emptyResponse = item.response.value.length === 0;
+                if (emptyResponse) {
+                    return false;
+                }
+                if (item.response.value.every(item => item.kind === 'textEditGroup' && _options.chatWidgetViewOptions?.rendererOptions?.renderTextEditsAsSummary?.(item.uri))) {
+                    return false;
+                }
+                return true;
+            },
+            dndContainer: this._elements.root,
+            defaultMode: ChatMode.Ask,
+            ..._options.chatWidgetViewOptions
+        }, {
+            listForeground: inlineChatForeground,
+            listBackground: inlineChatBackground,
+            overlayBackground: EDITOR_DRAG_AND_DROP_BACKGROUND,
+            inputEditorBackground: inputBackground,
+            resultEditorBackground: editorBackground
+        });
+        this._elements.root.classList.toggle('in-zone-widget', !!_options.inZoneWidget);
+        this._chatWidget.render(this._elements.chatWidget);
+        this._elements.chatWidget.style.setProperty(asCssVariableName(chatRequestBackground), asCssVariable(inlineChatBackground));
+        this._chatWidget.setVisible(true);
+        this._store.add(this._chatWidget);
+        const ctxResponse = ChatContextKeys.isResponse.bindTo(this.scopedContextKeyService);
+        const ctxResponseVote = ChatContextKeys.responseVote.bindTo(this.scopedContextKeyService);
+        const ctxResponseSupportIssues = ChatContextKeys.responseSupportsIssueReporting.bindTo(this.scopedContextKeyService);
+        const ctxResponseError = ChatContextKeys.responseHasError.bindTo(this.scopedContextKeyService);
+        const ctxResponseErrorFiltered = ChatContextKeys.responseIsFiltered.bindTo(this.scopedContextKeyService);
+        const viewModelStore = this._store.add(( new DisposableStore()));
+        this._store.add(this._chatWidget.onDidChangeViewModel(() => {
+            viewModelStore.clear();
+            const viewModel = this._chatWidget.viewModel;
+            if (!viewModel) {
+                return;
+            }
+            viewModelStore.add(toDisposable(() => {
+                toolbar2.context = undefined;
+                ctxResponse.reset();
+                ctxResponseVote.reset();
+                ctxResponseError.reset();
+                ctxResponseErrorFiltered.reset();
+                ctxResponseSupportIssues.reset();
+            }));
+            viewModelStore.add(viewModel.onDidChange(() => {
+                this._requestInProgress.set(viewModel.model.requestInProgress.get(), undefined);
+                const last = viewModel.getItems().at(-1);
+                toolbar2.context = last;
+                ctxResponse.set(isResponseVM(last));
+                ctxResponseVote.set(isResponseVM(last) ? last.vote === ChatAgentVoteDirection.Down ? 'down' : last.vote === ChatAgentVoteDirection.Up ? 'up' : '' : '');
+                ctxResponseError.set(isResponseVM(last) && last.errorDetails !== undefined);
+                ctxResponseErrorFiltered.set((!!(isResponseVM(last) && last.errorDetails?.responseIsFiltered)));
+                ctxResponseSupportIssues.set(isResponseVM(last) && (last.agent?.metadata.supportIssueReporting ?? false));
+                this._onDidChangeHeight.fire();
+            }));
+            this._onDidChangeHeight.fire();
+        }));
+        this._store.add(this.chatWidget.onDidChangeContentHeight(() => {
+            this._onDidChangeHeight.fire();
+        }));
+        this._ctxResponseFocused = CTX_INLINE_CHAT_RESPONSE_FOCUSED.bindTo(this._contextKeyService);
+        const tracker = this._store.add(trackFocus(this.domNode));
+        this._store.add(tracker.onDidBlur(() => this._ctxResponseFocused.set(false)));
+        this._store.add(tracker.onDidFocus(() => this._ctxResponseFocused.set(true)));
+        this._ctxInputEditorFocused = CTX_INLINE_CHAT_FOCUSED.bindTo(_contextKeyService);
+        this._store.add(this._chatWidget.inputEditor.onDidFocusEditorWidget(() => this._ctxInputEditorFocused.set(true)));
+        this._store.add(this._chatWidget.inputEditor.onDidBlurEditorWidget(() => this._ctxInputEditorFocused.set(false)));
+        const statusMenuId = _options.statusMenuId instanceof MenuId ? _options.statusMenuId : _options.statusMenuId.menu;
+        const statusMenuOptions = _options.statusMenuId instanceof MenuId ? undefined : _options.statusMenuId.options;
+        const statusButtonBar = scopedInstaService.createInstance(MenuWorkbenchButtonBar, this._elements.toolbar1, statusMenuId, {
+            toolbarOptions: { primaryGroup: '0_main' },
+            telemetrySource: _options.chatWidgetViewOptions?.menus?.telemetrySource,
+            menuOptions: { renderShortTitle: true },
+            ...statusMenuOptions,
+        });
+        this._store.add(statusButtonBar.onDidChange(() => this._onDidChangeHeight.fire()));
+        this._store.add(statusButtonBar);
+        const toolbar2 = scopedInstaService.createInstance(MenuWorkbenchToolBar, this._elements.toolbar2, _options.secondaryMenuId ?? MenuId.for(''), {
+            telemetrySource: _options.chatWidgetViewOptions?.menus?.telemetrySource,
+            menuOptions: { renderShortTitle: true, shouldForwardArgs: true },
+            actionViewItemProvider: (action, options) => {
+                if (action instanceof MenuItemAction && action.item.id === MarkUnhelpfulActionId) {
+                    return scopedInstaService.createInstance(ChatVoteDownButton, action, options);
+                }
+                return createActionViewItem(scopedInstaService, action, options);
+            }
+        });
+        this._store.add(toolbar2.onDidChangeMenuItems(() => this._onDidChangeHeight.fire()));
+        this._store.add(toolbar2);
+        this._store.add(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(AccessibilityVerbositySettingId.InlineChat)) {
+                this._updateAriaLabel();
+            }
+        }));
+        this._elements.root.tabIndex = 0;
+        this._elements.statusLabel.tabIndex = 0;
+        this._updateAriaLabel();
+        this._setupDisclaimer();
+        this._store.add(this._hoverService.setupManagedHover(getDefaultHoverDelegate('element'), this._elements.statusLabel, () => {
+            return this._elements.statusLabel.dataset['title'];
+        }));
+        this._store.add(this._chatService.onDidPerformUserAction(e => {
+            if (isEqual(e.sessionResource, this._chatWidget.viewModel?.model.sessionResource) && e.action.kind === 'vote') {
+                this.updateStatus(( localize(8320, "Thank you for your feedback!")), { resetAfter: 1250 });
+            }
+        }));
+    }
+    _updateAriaLabel() {
+        this._elements.root.ariaLabel = this._accessibleViewService.getOpenAriaHint(AccessibilityVerbositySettingId.InlineChat);
+        if (this._accessibilityService.isScreenReaderOptimized()) {
+            let label = defaultAriaLabel;
+            if (this._configurationService.getValue(AccessibilityVerbositySettingId.InlineChat)) {
+                const kbLabel = this._keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp)?.getLabel();
+                label = kbLabel
+                    ? ( localize(
+                    8321,
+                    "Inline Chat Input, Use {0} for Inline Chat Accessibility Help.",
+                    kbLabel
+                ))
+                    : ( localize(
+                    8322,
+                    "Inline Chat Input, Run the Inline Chat Accessibility Help command for more information."
+                ));
+            }
+            this._chatWidget.inputEditor.updateOptions({ ariaLabel: label });
+        }
+    }
+    _setupDisclaimer() {
+        const disposables = this._store.add(( new DisposableStore()));
+        this._store.add(autorun(reader => {
+            disposables.clear();
+            reset(this._elements.disclaimerLabel);
+            const sentiment = this._chatEntitlementService.sentimentObs.read(reader);
+            const anonymous = this._chatEntitlementService.anonymousObs.read(reader);
+            const requestInProgress = this._chatService.requestInProgressObs.read(reader);
+            const showDisclaimer = !sentiment.installed && anonymous && !requestInProgress;
+            this._elements.disclaimerLabel.classList.toggle('hidden', !showDisclaimer);
+            if (showDisclaimer) {
+                const renderedMarkdown = disposables.add(this._markdownRendererService.render(( new MarkdownString(( localize(
+                    8323,
+                    "By continuing with {0} Copilot, you agree to {1}'s [Terms]({2}) and [Privacy Statement]({3})",
+                    product.defaultChatAgent?.provider?.default?.name ?? '',
+                    product.defaultChatAgent?.provider?.default?.name ?? '',
+                    product.defaultChatAgent?.termsStatementUrl ?? '',
+                    product.defaultChatAgent?.privacyStatementUrl ?? ''
+                )), { isTrusted: true }))));
+                this._elements.disclaimerLabel.appendChild(renderedMarkdown.element);
+            }
+            this._onDidChangeHeight.fire();
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+    }
+    get domNode() {
+        return this._elements.root;
+    }
+    get chatWidget() {
+        return this._chatWidget;
+    }
+    saveState() {
+        this._chatWidget.saveState();
+    }
+    layout(widgetDim) {
+        const contentHeight = this.contentHeight;
+        this._isLayouting = true;
+        try {
+            this._doLayout(widgetDim);
+        }
+        finally {
+            this._isLayouting = false;
+            if (this.contentHeight !== contentHeight) {
+                this._onDidChangeHeight.fire();
+            }
+        }
+    }
+    _doLayout(dimension) {
+        const extraHeight = this._getExtraHeight();
+        const statusHeight = getTotalHeight(this._elements.status);
+        this._elements.root.style.height = `${dimension.height - extraHeight}px`;
+        this._elements.root.style.width = `${dimension.width}px`;
+        this._chatWidget.layout(dimension.height - statusHeight - extraHeight, dimension.width);
+    }
+    get contentHeight() {
+        const data = {
+            chatWidgetContentHeight: this._chatWidget.contentHeight,
+            statusHeight: getTotalHeight(this._elements.status),
+            extraHeight: this._getExtraHeight()
+        };
+        const result = data.chatWidgetContentHeight + data.statusHeight + data.extraHeight;
+        return result;
+    }
+    get minHeight() {
+        let maxWidgetOutputHeight = 100;
+        for (const item of this._chatWidget.viewModel?.getItems() ?? []) {
+            if (isResponseVM(item) && ( item.response.value.some(r => r.kind === 'textEditGroup' && !r.state?.applied))) {
+                maxWidgetOutputHeight = 270;
+                break;
+            }
+        }
+        let value = this.contentHeight;
+        value -= this._chatWidget.contentHeight;
+        value += Math.min(this._chatWidget.input.contentHeight + maxWidgetOutputHeight, this._chatWidget.contentHeight);
+        return value;
+    }
+    _getExtraHeight() {
+        return this._options.inZoneWidget ? 1 : ((2  + 4) );
+    }
+    get value() {
+        return this._chatWidget.getInput();
+    }
+    set value(value) {
+        this._chatWidget.setInput(value);
+    }
+    selectAll() {
+        this._chatWidget.inputEditor.setSelection(( new Selection(1, 1, Number.MAX_SAFE_INTEGER, 1)));
+    }
+    set placeholder(value) {
+        this._chatWidget.setInputPlaceholder(value);
+    }
+    toggleStatus(show) {
+        this._elements.toolbar1.classList.toggle('hidden', !show);
+        this._elements.toolbar2.classList.toggle('hidden', !show);
+        this._elements.status.classList.toggle('hidden', !show);
+        this._elements.infoLabel.classList.toggle('hidden', !show);
+        this._onDidChangeHeight.fire();
+    }
+    updateToolbar(show) {
+        this._elements.root.classList.toggle('toolbar', show);
+        this._elements.toolbar1.classList.toggle('hidden', !show);
+        this._elements.toolbar2.classList.toggle('hidden', !show);
+        this._elements.status.classList.toggle('actions', show);
+        this._elements.infoLabel.classList.toggle('hidden', show);
+        this._onDidChangeHeight.fire();
+    }
+    async getCodeBlockInfo(codeBlockIndex) {
+        const { viewModel } = this._chatWidget;
+        if (!viewModel) {
+            return undefined;
+        }
+        const items = viewModel.getItems().filter(i => isResponseVM(i));
+        const item = items.at(-1);
+        if (!item) {
+            return;
+        }
+        return viewModel.codeBlockModelCollection.get(viewModel.sessionResource, item, codeBlockIndex)?.model;
+    }
+    get responseContent() {
+        const requests = this._chatWidget.viewModel?.model.getRequests();
+        return requests?.at(-1)?.response?.response.toString();
+    }
+    getChatModel() {
+        return this._chatWidget.viewModel?.model;
+    }
+    setChatModel(chatModel) {
+        chatModel.inputModel.setState({ inputText: '', selections: [] });
+        this._chatWidget.setModel(chatModel);
+    }
+    updateInfo(message) {
+        this._elements.infoLabel.classList.toggle('hidden', !message);
+        const renderedMessage = renderLabelWithIcons(message);
+        reset(this._elements.infoLabel, ...renderedMessage);
+        this._onDidChangeHeight.fire();
+    }
+    updateStatus(message, ops = {}) {
+        const isTempMessage = typeof ops.resetAfter === 'number';
+        if (isTempMessage && !this._elements.statusLabel.dataset['state']) {
+            const statusLabel = this._elements.statusLabel.innerText;
+            const title = this._elements.statusLabel.dataset['title'];
+            const classes = Array.from(( this._elements.statusLabel.classList.values()));
+            setTimeout(() => {
+                this.updateStatus(statusLabel, { classes, keepMessage: true, title });
+            }, ops.resetAfter);
+        }
+        const renderedMessage = renderLabelWithIcons(message);
+        reset(this._elements.statusLabel, ...renderedMessage);
+        this._elements.statusLabel.className = `label status ${(ops.classes ?? []).join(' ')}`;
+        this._elements.statusLabel.classList.toggle('hidden', !message);
+        if (isTempMessage) {
+            this._elements.statusLabel.dataset['state'] = 'temp';
+        }
+        else {
+            delete this._elements.statusLabel.dataset['state'];
+        }
+        if (ops.title) {
+            this._elements.statusLabel.dataset['title'] = ops.title;
+        }
+        else {
+            delete this._elements.statusLabel.dataset['title'];
+        }
+        this._onDidChangeHeight.fire();
+    }
+    reset() {
+        this._chatWidget.attachmentModel.clear(true);
+        this._chatWidget.saveState();
+        reset(this._elements.statusLabel);
+        this._elements.statusLabel.classList.toggle('hidden', true);
+        this._elements.toolbar1.classList.add('hidden');
+        this._elements.toolbar2.classList.add('hidden');
+        this.updateInfo('');
+        this._elements.accessibleViewer.classList.toggle('hidden', true);
+        this._onDidChangeHeight.fire();
+    }
+    focus() {
+        this._chatWidget.focusInput();
+    }
+    hasFocus() {
+        return this.domNode.contains(getActiveElement());
+    }
+};
+InlineChatWidget = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IAccessibilityService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IAccessibleViewService)),
+    ( __param(8, ITextModelService)),
+    ( __param(9, IChatService)),
+    ( __param(10, IHoverService)),
+    ( __param(11, IChatEntitlementService)),
+    ( __param(12, IMarkdownRendererService))
+], InlineChatWidget));
+const defaultAriaLabel = ( localize(8324, "Inline Chat Input"));
+let EditorBasedInlineChatWidget = class EditorBasedInlineChatWidget extends InlineChatWidget {
+    constructor(location, _parentEditor, options, contextKeyService, keybindingService, instantiationService, accessibilityService, configurationService, accessibleViewService, textModelResolverService, chatService, hoverService, layoutService, chatEntitlementService, markdownRendererService) {
+        const overflowWidgetsNode = layoutService.getContainer(getWindow(_parentEditor.getContainerDomNode())).appendChild($('.inline-chat-overflow.monaco-editor'));
+        super(location, {
+            ...options,
+            chatWidgetViewOptions: {
+                ...options.chatWidgetViewOptions,
+                editorOverflowWidgetsDomNode: overflowWidgetsNode
+            }
+        }, instantiationService, contextKeyService, keybindingService, accessibilityService, configurationService, accessibleViewService, textModelResolverService, chatService, hoverService, chatEntitlementService, markdownRendererService);
+        this._parentEditor = _parentEditor;
+        this._accessibleViewer = this._store.add(( new MutableDisposable()));
+        this._store.add(toDisposable(() => {
+            overflowWidgetsNode.remove();
+        }));
+    }
+    get contentHeight() {
+        let result = super.contentHeight;
+        if (this._accessibleViewer.value) {
+            result += this._accessibleViewer.value.height + 8 ;
+        }
+        return result;
+    }
+    _doLayout(dimension) {
+        let newHeight = dimension.height;
+        if (this._accessibleViewer.value) {
+            this._accessibleViewer.value.width = dimension.width - 12;
+            newHeight -= this._accessibleViewer.value.height + 8;
+        }
+        super._doLayout(dimension.with(undefined, newHeight));
+        this._elements.root.style.height = `${dimension.height - this._getExtraHeight()}px`;
+    }
+    reset() {
+        this._accessibleViewer.clear();
+        this.chatWidget.setInput();
+        super.reset();
+    }
+    showAccessibleHunk(session, hunkData) {
+        this._elements.accessibleViewer.classList.remove('hidden');
+        this._accessibleViewer.clear();
+        this._accessibleViewer.value = this._instantiationService.createInstance(HunkAccessibleDiffViewer, this._elements.accessibleViewer, session, hunkData, ( new AccessibleHunk(this._parentEditor, session, hunkData)));
+        this._onDidChangeHeight.fire();
+    }
+};
+EditorBasedInlineChatWidget = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IAccessibilityService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IAccessibleViewService)),
+    ( __param(9, ITextModelService)),
+    ( __param(10, IChatService)),
+    ( __param(11, IHoverService)),
+    ( __param(12, ILayoutService)),
+    ( __param(13, IChatEntitlementService)),
+    ( __param(14, IMarkdownRendererService))
+], EditorBasedInlineChatWidget));
+let HunkAccessibleDiffViewer = HunkAccessibleDiffViewer_1 = class HunkAccessibleDiffViewer extends AccessibleDiffViewer {
+    set width(value) {
+        this._width2.set(value, undefined);
+    }
+    constructor(parentNode, session, hunk, models, instantiationService) {
+        const width = observableValue('width', 0);
+        const diff = observableValue('diff', HunkAccessibleDiffViewer_1._asMapping(hunk));
+        const diffs = derived(r => [diff.read(r)]);
+        const lines = Math.min(10, 8 + diff.get().changedLineCount);
+        const height = models.getModifiedOptions().get(EditorOption.lineHeight) * lines;
+        super(parentNode, constObservable(true), () => { }, constObservable(false), width, constObservable(height), diffs, models, instantiationService);
+        this.height = height;
+        this._width2 = width;
+        this._store.add(session.textModelN.onDidChangeContent(() => {
+            diff.set(HunkAccessibleDiffViewer_1._asMapping(hunk), undefined);
+        }));
+    }
+    static _asMapping(hunk) {
+        const ranges0 = hunk.getRanges0();
+        const rangesN = hunk.getRangesN();
+        const originalLineRange = LineRange.fromRangeInclusive(ranges0[0]);
+        const modifiedLineRange = LineRange.fromRangeInclusive(rangesN[0]);
+        const innerChanges = [];
+        for (let i = 1; i < ranges0.length; i++) {
+            innerChanges.push(( new RangeMapping(ranges0[i], rangesN[i])));
+        }
+        return ( new DetailedLineRangeMapping(originalLineRange, modifiedLineRange, innerChanges));
+    }
+};
+HunkAccessibleDiffViewer = HunkAccessibleDiffViewer_1 = ( __decorate([
+    ( __param(4, IInstantiationService))
+], HunkAccessibleDiffViewer));
+class AccessibleHunk {
+    constructor(_editor, _session, _hunk) {
+        this._editor = _editor;
+        this._session = _session;
+        this._hunk = _hunk;
+    }
+    getOriginalModel() {
+        return this._session.textModel0;
+    }
+    getModifiedModel() {
+        return this._session.textModelN;
+    }
+    getOriginalOptions() {
+        return this._editor.getOptions();
+    }
+    getModifiedOptions() {
+        return this._editor.getOptions();
+    }
+    originalReveal(range) {
+    }
+    modifiedReveal(range) {
+        this._editor.revealRangeInCenterIfOutsideViewport(range || this._hunk.getRangesN()[0], ScrollType.Smooth);
+    }
+    modifiedSetSelection(range) {
+    }
+    modifiedFocus() {
+        this._editor.focus();
+    }
+    getModifiedPosition() {
+        return this._hunk.getRangesN()[0].getStartPosition();
+    }
+}
+
+export { EditorBasedInlineChatWidget, InlineChatWidget };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatZoneWidget.d.ts

@@ -0,0 +1,42 @@
+import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { ZoneWidget } from "@codingame/monaco-vscode-api/vscode/vs/editor/contrib/zoneWidget/browser/zoneWidget";
+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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IChatWidgetViewOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatWidgetLocationOptions } from "../../chat/browser/chatWidget.js";
+import { INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { EditorBasedInlineChatWidget } from "./inlineChatWidget.js";
+export declare class InlineChatZoneWidget extends ZoneWidget {
+    private readonly _instaService;
+    private _logService;
+    private static readonly _options;
+    readonly widget: EditorBasedInlineChatWidget;
+    private readonly _scrollUp;
+    private readonly _ctxCursorPosition;
+    private _dimension?;
+    private notebookEditor?;
+    constructor(location: IChatWidgetLocationOptions, options: IChatWidgetViewOptions | undefined, editors: {
+        editor: ICodeEditor;
+        notebookEditor?: INotebookEditor;
+    }, 
+    /** @deprecated should go away with inline2 */
+    clearDelegate: () => Promise<void>, _instaService: IInstantiationService, _logService: ILogService, contextKeyService: IContextKeyService);
+    protected _fillContainer(container: HTMLElement): void;
+    protected _doLayout(heightInPixel: number): void;
+    private _computeHeight;
+    protected _getResizeBounds(): {
+        minLines: number;
+        maxLines: number;
+    };
+    protected _onWidth(_widthInPixel: number): void;
+    show(position: Position): void;
+    private _updatePadding;
+    reveal(position: Position): void;
+    updatePositionAndHeight(position: Position): void;
+    private _createZoneAndScrollRestoreFn;
+    protected revealRange(range: Range, isLastLine: boolean): void;
+    hide(): void;
+}