@codingame/monaco-vscode-api 8.0.3 → 9.0.0

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

@@ -1,9 +1,9 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { WindowIntervalTimer } from '../../../../base/browser/dom.js';
+import { WindowIntervalTimer, getTotalWidth } from '../../../../base/browser/dom.js';
 import { coalesceInPlace } from '../../../../base/common/arrays.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
 import { DisposableStore } from '../../../../base/common/lifecycle.js';
-import { themeColorFromId } from '../../../../base/common/themables.js';
+import { themeColorFromId, ThemeIcon } from '../../../../base/common/themables.js';
 import { StableEditorScrollState } from '../../../../editor/browser/stableEditorScroll.js';
 import { RenderOptions, LineSource, renderLines } from '../../../../editor/browser/widget/diffEditor/components/diffEditorViewZones/renderLines.js';
 import { LineRange } from '../../../../editor/common/core/lineRange.js';
@@ -12,13 +12,12 @@ import { OverviewRulerLane, MinimapPosition, TrackedRangeStickiness } from '../.
 import { ModelDecorationOptions } from '../../../../editor/common/model/textModel.js';
 import { IEditorWorkerService } from '../../../../editor/common/services/editorWorker.js';
 import { InlineDecoration, InlineDecorationType } from '../../../../editor/common/viewModel.js';
-import { localize } from '../../../../nls.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
 import { Progress } from '../../../../platform/progress/common/progress.js';
 import { SaveReason } from '../../../common/editor.js';
 import { countWords } from '../../chat/common/chatWordCounter.js';
-import { CTX_INLINE_CHAT_DOCUMENT_CHANGED, CTX_INLINE_CHAT_CHANGE_HAS_DIFF, CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF, InlineChatConfigKeys, overviewRulerInlineChatDiffInserted, minimapInlineChatDiffInserted } from '../common/inlineChat.js';
 import { HunkState } from './inlineChatSession.js';
+import { CTX_INLINE_CHAT_DOCUMENT_CHANGED, CTX_INLINE_CHAT_CHANGE_HAS_DIFF, CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF, overviewRulerInlineChatDiffInserted, minimapInlineChatDiffInserted, MENU_INLINE_CHAT_ZONE, InlineChatConfigKeys, ACTION_TOGGLE_DIFF } from '../common/inlineChat.js';
 import { assertType } from '../../../../base/common/types.js';
 import { IModelService } from '../../../../editor/common/services/model.js';
 import { asProgressiveEdit, performAsyncTextEdit } from './utils.js';
@@ -29,14 +28,33 @@ import { Schemas } from '../../../../base/common/network.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { DefaultChatTextEditor } from '../../chat/browser/codeBlockPart.js';
 import { isEqual } from '../../../../base/common/resources.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
+import { MenuWorkbenchButtonBar } from '../../../../platform/actions/browser/buttonbar.js';
+import { EditorOption } from '../../../../editor/common/config/editorOptions.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { ConflictActionsFactory } from '../../mergeEditor/browser/view/conflictActions.js';
+import { observableValue } from '../../../../base/common/observableInternal/base.js';
+import '../../../../base/common/observableInternal/derived.js';
+import '../../../../base/common/observableInternal/autorun.js';
+import '../../../../base/common/observableInternal/utils.js';
+import '../../../../base/common/cancellation.js';
+import { MenuItemAction } from '../../../../platform/actions/common/actions.js';
+import { IMenuService } from '../../../../platform/actions/common/actions.service.js';
 var EditModeStrategy_1;
+var HunkAction;
+( (function(HunkAction) {
+    HunkAction[HunkAction["Accept"] = 0] = "Accept";
+    HunkAction[HunkAction["Discard"] = 1] = "Discard";
+    HunkAction[HunkAction["MoveNext"] = 2] = "MoveNext";
+    HunkAction[HunkAction["MovePrev"] = 3] = "MovePrev";
+    HunkAction[HunkAction["ToggleDiff"] = 4] = "ToggleDiff";
+})(HunkAction || (HunkAction = {})));
 let EditModeStrategy = class EditModeStrategy {
     static { EditModeStrategy_1 = this; }
     static { this._decoBlock = ModelDecorationOptions.register({
         description: 'inline-chat',
         showIfCollapsed: false,
         isWholeLine: true,
-        className: 'inline-chat-block-selection',
     }); }
     constructor(_session, _editor, _zone, _textFileService, _instaService) {
         this._session = _session;
@@ -44,15 +62,23 @@ let EditModeStrategy = class EditModeStrategy {
         this._zone = _zone;
         this._textFileService = _textFileService;
         this._instaService = _instaService;
-        this._store = ( (new DisposableStore()));
-        this._onDidAccept = this._store.add(( (new Emitter())));
-        this._onDidDiscard = this._store.add(( (new Emitter())));
+        this._store = ( new DisposableStore());
+        this._onDidAccept = this._store.add(( new Emitter()));
+        this._onDidDiscard = this._store.add(( new Emitter()));
         this.onDidAccept = this._onDidAccept.event;
         this.onDidDiscard = this._onDidDiscard.event;
     }
     dispose() {
         this._store.dispose();
     }
+    performHunkAction(_hunk, action) {
+        if (action === HunkAction.Accept) {
+            this._onDidAccept.fire();
+        }
+        else if (action === HunkAction.Discard) {
+            this._onDidDiscard.fire();
+        }
+    }
     async _doApplyChanges(ignoreLocal) {
         const untitledModels = [];
         const editor = this._instaService.createInstance(DefaultChatTextEditor);
@@ -86,25 +112,19 @@ let EditModeStrategy = class EditModeStrategy {
     cancel() {
         return this._session.hunkData.discardAll();
     }
-    async acceptHunk() {
-        this._onDidAccept.fire();
-    }
-    async discardHunk() {
-        this._onDidDiscard.fire();
-    }
     getWholeRangeDecoration() {
         const ranges = [this._session.wholeRange.value];
-        const newDecorations = ( (ranges.map(
+        const newDecorations = ( ranges.map(
             range => range.isEmpty() ? undefined : ({ range, options: EditModeStrategy_1._decoBlock })
-        )));
+        ));
         coalesceInPlace(newDecorations);
         return newDecorations;
     }
 };
-EditModeStrategy = EditModeStrategy_1 = ( (__decorate([
-    ( (__param(3, ITextFileService))),
-    ( (__param(4, IInstantiationService)))
-], EditModeStrategy)));
+EditModeStrategy = EditModeStrategy_1 = ( __decorate([
+    ( __param(3, ITextFileService)),
+    ( __param(4, IInstantiationService))
+], EditModeStrategy));
 let PreviewStrategy = class PreviewStrategy extends EditModeStrategy {
     constructor(session, editor, zone, modelService, contextKeyService, textFileService, instaService) {
         super(session, editor, zone, textFileService, instaService);
@@ -132,18 +152,21 @@ let PreviewStrategy = class PreviewStrategy extends EditModeStrategy {
         return this._zone.widget.hasFocus();
     }
 };
-PreviewStrategy = ( (__decorate([
-    ( (__param(3, IModelService))),
-    ( (__param(4, IContextKeyService))),
-    ( (__param(5, ITextFileService))),
-    ( (__param(6, IInstantiationService)))
-], PreviewStrategy)));
+PreviewStrategy = ( __decorate([
+    ( __param(3, IModelService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, ITextFileService)),
+    ( __param(6, IInstantiationService))
+], PreviewStrategy));
 let LiveStrategy = class LiveStrategy extends EditModeStrategy {
-    constructor(session, editor, zone, contextKeyService, _editorWorkerService, _accessibilityService, _configService, textFileService, instaService) {
+    constructor(session, editor, zone, _showOverlayToolbar, contextKeyService, _editorWorkerService, _accessibilityService, _configService, _menuService, _contextService, textFileService, instaService) {
         super(session, editor, zone, textFileService, instaService);
+        this._showOverlayToolbar = _showOverlayToolbar;
         this._editorWorkerService = _editorWorkerService;
         this._accessibilityService = _accessibilityService;
         this._configService = _configService;
+        this._menuService = _menuService;
+        this._contextService = _contextService;
         this._decoInsertedText = ModelDecorationOptions.register({
             description: 'inline-modified-line',
             className: 'inline-chat-inserted-range-linehighlight',
@@ -163,12 +186,11 @@ let LiveStrategy = class LiveStrategy extends EditModeStrategy {
             stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
         });
         this._editCount = 0;
-        this.acceptHunk = () => super.acceptHunk();
-        this.discardHunk = () => super.discardHunk();
-        this._hunkDisplayData = ( (new Map()));
+        this._hunkDisplayData = ( new Map());
         this._ctxCurrentChangeHasDiff = CTX_INLINE_CHAT_CHANGE_HAS_DIFF.bindTo(contextKeyService);
         this._ctxCurrentChangeShowsDiff = CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF.bindTo(contextKeyService);
         this._progressiveEditingDecorations = this._editor.createDecorationsCollection();
+        this._lensActionsFactory = this._store.add(( new ConflictActionsFactory(this._editor)));
     }
     dispose() {
         this._resetDiff();
@@ -179,7 +201,7 @@ let LiveStrategy = class LiveStrategy extends EditModeStrategy {
         this._ctxCurrentChangeShowsDiff.reset();
         this._zone.widget.updateStatus('');
         this._progressiveEditingDecorations.clear();
-        for (const data of ( (this._hunkDisplayData.values()))) {
+        for (const data of ( this._hunkDisplayData.values())) {
             data.remove();
         }
     }
@@ -198,21 +220,21 @@ let LiveStrategy = class LiveStrategy extends EditModeStrategy {
         return this._makeChanges(edits, obs, undefined, undefined, undoStopBefore);
     }
     async makeProgressiveChanges(edits, obs, opts, undoStopBefore) {
-        const progress = ( (new Progress(edits => {
-            const newLines = ( (new Set()));
+        const progress = ( new Progress(edits => {
+            const newLines = ( new Set());
             for (const edit of edits) {
                 LineRange.fromRange(edit.range).forEach(line => newLines.add(line));
             }
-            const existingRanges = ( (this._progressiveEditingDecorations.getRanges().map(LineRange.fromRange)));
+            const existingRanges = ( this._progressiveEditingDecorations.getRanges().map(LineRange.fromRange));
             for (const existingRange of existingRanges) {
                 existingRange.forEach(line => newLines.delete(line));
             }
             const newDecorations = [];
             for (const line of newLines) {
-                newDecorations.push({ range: ( (new Range(line, 1, line, Number.MAX_VALUE))), options: this._decoInsertedText });
+                newDecorations.push({ range: ( new Range(line, 1, line, Number.MAX_VALUE)), options: this._decoInsertedText });
             }
             this._progressiveEditingDecorations.append(newDecorations);
-        })));
+        }));
         return this._makeChanges(edits, obs, opts, progress, undoStopBefore);
     }
     async _makeChanges(edits, obs, opts, progress, undoStopBefore) {
@@ -225,7 +247,7 @@ let LiveStrategy = class LiveStrategy extends EditModeStrategy {
             for (const edit of edits) {
                 const wordCount = countWords(edit.text ?? '');
                 const speed = wordCount / durationInSec;
-                const asyncEdit = asProgressiveEdit(( (new WindowIntervalTimer(this._zone.domNode))), edit, speed, opts.token);
+                const asyncEdit = asProgressiveEdit(( new WindowIntervalTimer(this._zone.domNode)), edit, speed, opts.token);
                 await performAsyncTextEdit(this._session.textModelN, asyncEdit, progress, obs);
             }
         }
@@ -238,12 +260,66 @@ let LiveStrategy = class LiveStrategy extends EditModeStrategy {
             obs.stop();
         }
     }
+    performHunkAction(hunk, action) {
+        const displayData = this._findDisplayData(hunk);
+        if (!displayData) {
+            if (action === HunkAction.Accept) {
+                this._onDidAccept.fire();
+            }
+            else if (action === HunkAction.Discard) {
+                this._onDidDiscard.fire();
+            }
+            return;
+        }
+        if (action === HunkAction.Accept) {
+            displayData.acceptHunk();
+        }
+        else if (action === HunkAction.Discard) {
+            displayData.discardHunk();
+        }
+        else if (action === HunkAction.MoveNext) {
+            displayData.move(true);
+        }
+        else if (action === HunkAction.MovePrev) {
+            displayData.move(false);
+        }
+        else if (action === HunkAction.ToggleDiff) {
+            displayData.toggleDiff?.();
+        }
+    }
+    _findDisplayData(hunkInfo) {
+        let result;
+        if (hunkInfo) {
+            result = this._hunkDisplayData.get(hunkInfo);
+        }
+        if (!result && this._zone.position) {
+            const zoneLine = this._zone.position.lineNumber;
+            let distance = Number.MAX_SAFE_INTEGER;
+            for (const candidate of ( this._hunkDisplayData.values())) {
+                if (candidate.hunk.getState() !== HunkState.Pending) {
+                    continue;
+                }
+                const hunkRanges = candidate.hunk.getRangesN();
+                const myDistance = zoneLine <= hunkRanges[0].startLineNumber
+                    ? hunkRanges[0].startLineNumber - zoneLine
+                    : zoneLine - hunkRanges[0].endLineNumber;
+                if (myDistance < distance) {
+                    distance = myDistance;
+                    result = candidate;
+                }
+            }
+        }
+        if (!result) {
+            result = Iterable.first(Iterable.filter(( this._hunkDisplayData.values()), candidate => candidate.hunk.getState() === HunkState.Pending));
+        }
+        return result;
+    }
     async renderChanges() {
         this._progressiveEditingDecorations.clear();
         const renderHunks = () => {
             let widgetData;
             changeDecorationsAndViewZones(this._editor, (decorationsAccessor, viewZoneAccessor) => {
-                const keysNow = ( (new Set( (this._hunkDisplayData.keys()))));
+                const keysNow = ( new Set(( this._hunkDisplayData.keys())));
                 widgetData = undefined;
                 for (const hunkData of this._session.hunkData.getInfo()) {
                     keysNow.delete(hunkData);
@@ -268,89 +344,113 @@ let LiveStrategy = class LiveStrategy extends EditModeStrategy {
                         const mightContainRTL = this._session.textModel0.mightContainRTL();
                         const renderOptions = RenderOptions.fromEditor(this._editor);
                         const originalRange = hunkData.getRanges0()[0];
-                        const source = ( (new LineSource(
+                        const source = ( new LineSource(
                             LineRange.fromRangeInclusive(originalRange).mapToLineArray(l => this._session.textModel0.tokenization.getLineTokens(l)),
                             [],
                             mightContainNonBasicASCII,
                             mightContainRTL
-                        )));
+                        ));
                         const domNode = document.createElement('div');
                         domNode.className = 'inline-chat-original-zone2';
-                        const result = renderLines(source, renderOptions, [( (new InlineDecoration(
-                             (new Range(originalRange.startLineNumber, 1, originalRange.startLineNumber, 1)),
-                            '',
-                            InlineDecorationType.Regular
-                        )))], domNode);
+                        const result = renderLines(source, renderOptions, [( new InlineDecoration(( new Range(originalRange.startLineNumber, 1, originalRange.startLineNumber, 1)), '', InlineDecorationType.Regular))], domNode);
                         const viewZoneData = {
                             afterLineNumber: -1,
                             heightInLines: result.heightInLines,
                             domNode,
+                            ordinal: 50000 + 2
                         };
                         const toggleDiff = () => {
                             const scrollState = StableEditorScrollState.capture(this._editor);
                             changeDecorationsAndViewZones(this._editor, (_decorationsAccessor, viewZoneAccessor) => {
                                 assertType(data);
-                                if (!data.viewZoneId) {
+                                if (!data.diffViewZoneId) {
                                     const [hunkRange] = hunkData.getRangesN();
                                     viewZoneData.afterLineNumber = hunkRange.startLineNumber - 1;
-                                    data.viewZoneId = viewZoneAccessor.addZone(viewZoneData);
+                                    data.diffViewZoneId = viewZoneAccessor.addZone(viewZoneData);
+                                    overlay?.updateExtraTop(result.heightInLines);
                                 }
                                 else {
-                                    viewZoneAccessor.removeZone(data.viewZoneId);
-                                    data.viewZoneId = undefined;
+                                    viewZoneAccessor.removeZone(data.diffViewZoneId);
+                                    overlay?.updateExtraTop(0);
+                                    data.diffViewZoneId = undefined;
                                 }
                             });
-                            this._ctxCurrentChangeShowsDiff.set(typeof data?.viewZoneId === 'string');
+                            this._ctxCurrentChangeShowsDiff.set(typeof data?.diffViewZoneId === 'string');
                             scrollState.restore(this._editor);
                         };
+                        const overlay = this._showOverlayToolbar && false
+                            ? this._instaService.createInstance(InlineChangeOverlay, this._editor, hunkData)
+                            : undefined;
+                        let lensActions;
+                        const lensActionsViewZoneIds = [];
+                        if (this._showOverlayToolbar && hunkData.getState() === HunkState.Pending) {
+                            lensActions = ( new DisposableStore());
+                            const menu = this._menuService.createMenu(MENU_INLINE_CHAT_ZONE, this._contextService);
+                            const makeActions = () => {
+                                const actions = [];
+                                const tuples = menu.getActions();
+                                for (const [, group] of tuples) {
+                                    for (const item of group) {
+                                        if (item instanceof MenuItemAction) {
+                                            let text = item.label;
+                                            if (item.id === ACTION_TOGGLE_DIFF) {
+                                                text = item.checked ? 'Hide Changes' : 'Show Changes';
+                                            }
+                                            else if (ThemeIcon.isThemeIcon(item.item.icon)) {
+                                                text = `$(${item.item.icon.id}) ${text}`;
+                                            }
+                                            actions.push({
+                                                text,
+                                                tooltip: item.tooltip,
+                                                action: async () => item.run(),
+                                            });
+                                        }
+                                    }
+                                }
+                                return actions;
+                            };
+                            const obs = observableValue(this, makeActions());
+                            lensActions.add(menu.onDidChange(() => obs.set(makeActions(), undefined)));
+                            lensActions.add(menu);
+                            lensActions.add(this._lensActionsFactory.createWidget(viewZoneAccessor, hunkRanges[0].startLineNumber - 1, obs, lensActionsViewZoneIds));
+                        }
                         const remove = () => {
                             changeDecorationsAndViewZones(this._editor, (decorationsAccessor, viewZoneAccessor) => {
                                 assertType(data);
                                 for (const decorationId of data.decorationIds) {
                                     decorationsAccessor.removeDecoration(decorationId);
                                 }
-                                if (data.viewZoneId) {
-                                    viewZoneAccessor.removeZone(data.viewZoneId);
+                                if (data.diffViewZoneId) {
+                                    viewZoneAccessor.removeZone(data.diffViewZoneId);
                                 }
                                 data.decorationIds = [];
-                                data.viewZoneId = undefined;
+                                data.diffViewZoneId = undefined;
+                                data.lensActionsViewZoneIds?.forEach(viewZoneAccessor.removeZone);
+                                data.lensActionsViewZoneIds = undefined;
                             });
+                            lensActions?.dispose();
+                            overlay?.dispose();
                         };
                         const move = (next) => {
-                            assertType(widgetData);
-                            const candidates = [];
-                            for (const item of this._session.hunkData.getInfo()) {
-                                if (item.getState() === HunkState.Pending) {
-                                    candidates.push(item.getRangesN()[0].getStartPosition().delta(-1));
-                                }
-                            }
-                            if (candidates.length < 2) {
-                                return;
-                            }
-                            for (let i = 0; i < candidates.length; i++) {
-                                if (candidates[i].equals(widgetData.position)) {
-                                    let newPos;
-                                    if (next) {
-                                        newPos = candidates[(i + 1) % candidates.length];
-                                    }
-                                    else {
-                                        newPos = candidates[(i + candidates.length - 1) % candidates.length];
-                                    }
-                                    this._zone.updatePositionAndHeight(newPos);
-                                    renderHunks();
-                                    break;
-                                }
+                            const keys = Array.from(( this._hunkDisplayData.keys()));
+                            const idx = keys.indexOf(hunkData);
+                            const nextIdx = (idx + (next ? 1 : -1) + keys.length) % keys.length;
+                            if (nextIdx !== idx) {
+                                const nextData = this._hunkDisplayData.get(keys[nextIdx]);
+                                this._zone.updatePositionAndHeight(nextData?.position);
+                                renderHunks();
                             }
                         };
-                        const zoneLineNumber = this._zone.position.lineNumber;
+                        const zoneLineNumber = this._zone.position?.lineNumber ?? this._editor.getPosition().lineNumber;
                         const myDistance = zoneLineNumber <= hunkRanges[0].startLineNumber
                             ? hunkRanges[0].startLineNumber - zoneLineNumber
                             : zoneLineNumber - hunkRanges[0].endLineNumber;
                         data = {
                             hunk: hunkData,
                             decorationIds,
-                            viewZoneId: '',
-                            viewZone: viewZoneData,
+                            diffViewZoneId: '',
+                            diffViewZone: viewZoneData,
+                            lensActionsViewZoneIds,
                             distance: myDistance,
                             position: hunkRanges[0].getStartPosition().delta(-1),
                             acceptHunk,
@@ -365,7 +465,7 @@ let LiveStrategy = class LiveStrategy extends EditModeStrategy {
                         data.remove();
                     }
                     else {
-                        const zoneLineNumber = this._zone.position.lineNumber;
+                        const zoneLineNumber = this._zone.position?.lineNumber ?? this._editor.getPosition().lineNumber;
                         const modifiedRangeNow = hunkRanges[0];
                         data.position = modifiedRangeNow.getStartPosition().delta(-1);
                         data.distance = zoneLineNumber <= modifiedRangeNow.startLineNumber
@@ -386,17 +486,11 @@ let LiveStrategy = class LiveStrategy extends EditModeStrategy {
             });
             if (widgetData) {
                 this._zone.updatePositionAndHeight(widgetData.position);
-                const remainingHunks = this._session.hunkData.pending;
-                this._updateSummaryMessage(remainingHunks, this._session.hunkData.size);
                 const mode = this._configService.getValue(InlineChatConfigKeys.AccessibleDiffView);
                 if (mode === 'on' || mode === 'auto' && this._accessibilityService.isScreenReaderOptimized()) {
                     this._zone.widget.showAccessibleHunk(this._session, widgetData.hunk);
                 }
                 this._ctxCurrentChangeHasDiff.set(Boolean(widgetData.toggleDiff));
-                this.toggleDiff = widgetData.toggleDiff;
-                this.acceptHunk = async () => widgetData.acceptHunk();
-                this.discardHunk = async () => widgetData.discardHunk();
-                this.move = next => widgetData.move(next);
             }
             else if (this._hunkDisplayData.size > 0) {
                 let oneAccepted = false;
@@ -417,28 +511,6 @@ let LiveStrategy = class LiveStrategy extends EditModeStrategy {
         };
         return renderHunks()?.position;
     }
-    _updateSummaryMessage(remaining, total) {
-        const needsReview = this._configService.getValue(InlineChatConfigKeys.AcceptedOrDiscardBeforeSave);
-        let message;
-        if (total === 0) {
-            message = ( localize(10593, "Nothing changed."));
-        }
-        else if (remaining === 1) {
-            message = needsReview
-                ? ( localize(10594, "$(info) Accept or Discard change"))
-                : ( localize(10595, "1 change"));
-        }
-        else {
-            message = needsReview
-                ? ( localize(10596, "$(info) Accept or Discard {0} changes", remaining))
-                : ( localize(10597, "{0} changes", total));
-        }
-        let title;
-        if (needsReview) {
-            title = ( localize(10598, "Review (accept or discard) all changes before continuing"));
-        }
-        this._zone.widget.updateStatus(message, { title });
-    }
     hasFocus() {
         return this._zone.widget.hasFocus();
     }
@@ -446,14 +518,16 @@ let LiveStrategy = class LiveStrategy extends EditModeStrategy {
         return [];
     }
 };
-LiveStrategy = ( (__decorate([
-    ( (__param(3, IContextKeyService))),
-    ( (__param(4, IEditorWorkerService))),
-    ( (__param(5, IAccessibilityService))),
-    ( (__param(6, IConfigurationService))),
-    ( (__param(7, ITextFileService))),
-    ( (__param(8, IInstantiationService)))
-], LiveStrategy)));
+LiveStrategy = ( __decorate([
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IEditorWorkerService)),
+    ( __param(6, IAccessibilityService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IMenuService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, ITextFileService)),
+    ( __param(11, IInstantiationService))
+], LiveStrategy));
 function changeDecorationsAndViewZones(editor, callback) {
     editor.changeDecorations(decorationsAccessor => {
         editor.changeViewZones(viewZoneAccessor => {
@@ -461,4 +535,62 @@ function changeDecorationsAndViewZones(editor, callback) {
         });
     });
 }
-export { EditModeStrategy, LiveStrategy, PreviewStrategy };
+let InlineChangeOverlay = class InlineChangeOverlay {
+    constructor(_editor, _hunkInfo, _instaService) {
+        this._editor = _editor;
+        this._hunkInfo = _hunkInfo;
+        this._instaService = _instaService;
+        this.allowEditorOverflow = false;
+        this._id = `inline-chat-diff-overlay-` + generateUuid();
+        this._domNode = document.createElement('div');
+        this._store = ( new DisposableStore());
+        this._extraTopLines = 0;
+        this._domNode.classList.add('inline-chat-diff-overlay');
+        if (_hunkInfo.getState() === HunkState.Pending) {
+            const menuBar = this._store.add(this._instaService.createInstance(MenuWorkbenchButtonBar, this._domNode, MENU_INLINE_CHAT_ZONE, {
+                menuOptions: { arg: _hunkInfo },
+                telemetrySource: 'inlineChat-changesZone',
+                buttonConfigProvider: (_action, idx) => {
+                    return {
+                        isSecondary: idx > 0,
+                        showIcon: true,
+                        showLabel: false
+                    };
+                },
+            }));
+            this._store.add(menuBar.onDidChange(() => this._editor.layoutOverlayWidget(this)));
+        }
+        this._editor.addOverlayWidget(this);
+        this._store.add(Event.any(this._editor.onDidLayoutChange, this._editor.onDidScrollChange)(() => this._editor.layoutOverlayWidget(this)));
+        queueMicrotask(() => this._editor.layoutOverlayWidget(this));
+    }
+    dispose() {
+        this._editor.removeOverlayWidget(this);
+        this._store.dispose();
+    }
+    getId() {
+        return this._id;
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    getPosition() {
+        const line = this._hunkInfo.getRangesN()[0].startLineNumber;
+        const info = this._editor.getLayoutInfo();
+        const top = this._editor.getTopForLineNumber(line) - this._editor.getScrollTop();
+        const left = info.contentLeft + info.contentWidth - info.verticalScrollbarWidth;
+        const extraTop = this._editor.getOption(EditorOption.lineHeight) * this._extraTopLines;
+        const width = getTotalWidth(this._domNode);
+        return { preference: { top: top - extraTop, left: left - width } };
+    }
+    updateExtraTop(value) {
+        if (this._extraTopLines !== value) {
+            this._extraTopLines = value;
+            this._editor.layoutOverlayWidget(this);
+        }
+    }
+};
+InlineChangeOverlay = ( __decorate([
+    ( __param(2, IInstantiationService))
+], InlineChangeOverlay));
+export { EditModeStrategy, HunkAction, LiveStrategy, PreviewStrategy };