@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,76 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { ISingleEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editOperation";
+import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
+import { IModelDeltaDecoration, IValidEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { IEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { HunkInformation, Session } from "./inlineChatSession.js";
+import { InlineChatZoneWidget } from "./inlineChatZoneWidget.js";
+import { IAccessibilityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ITextFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service";
+import { VersionedExtensionId } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+export interface IEditObserver {
+    start(): void;
+    stop(): void;
+}
+export declare enum HunkAction {
+    Accept = 0,
+    Discard = 1,
+    MoveNext = 2,
+    MovePrev = 3,
+    ToggleDiff = 4
+}
+export declare class LiveStrategy {
+    protected readonly _session: Session;
+    protected readonly _editor: ICodeEditor;
+    protected readonly _zone: InlineChatZoneWidget;
+    private readonly _showOverlayToolbar;
+    protected readonly _editorWorkerService: IEditorWorkerService;
+    private readonly _accessibilityService;
+    private readonly _configService;
+    private readonly _menuService;
+    private readonly _contextService;
+    private readonly _textFileService;
+    protected readonly _instaService: IInstantiationService;
+    private readonly _decoInsertedText;
+    private readonly _decoInsertedTextRange;
+    protected readonly _store: DisposableStore;
+    protected readonly _onDidAccept: Emitter<void>;
+    protected readonly _onDidDiscard: Emitter<void>;
+    private readonly _ctxCurrentChangeHasDiff;
+    private readonly _ctxCurrentChangeShowsDiff;
+    private readonly _progressiveEditingDecorations;
+    private readonly _lensActionsFactory;
+    private _editCount;
+    private readonly _hunkData;
+    readonly onDidAccept: Event<void>;
+    readonly onDidDiscard: Event<void>;
+    constructor(_session: Session, _editor: ICodeEditor, _zone: InlineChatZoneWidget, _showOverlayToolbar: boolean, contextKeyService: IContextKeyService, _editorWorkerService: IEditorWorkerService, _accessibilityService: IAccessibilityService, _configService: IConfigurationService, _menuService: IMenuService, _contextService: IContextKeyService, _textFileService: ITextFileService, _instaService: IInstantiationService);
+    dispose(): void;
+    private _resetDiff;
+    apply(): Promise<void>;
+    cancel(): IValidEditOperation[];
+    makeChanges(edits: ISingleEditOperation[], obs: IEditObserver, undoStopBefore: boolean, metadata: IInlineChatMetadata): Promise<void>;
+    makeProgressiveChanges(edits: ISingleEditOperation[], obs: IEditObserver, opts: ProgressingEditsOptions, undoStopBefore: boolean, metadata: IInlineChatMetadata): Promise<void>;
+    private _makeChanges;
+    performHunkAction(hunk: HunkInformation | undefined, action: HunkAction): void;
+    private _findDisplayData;
+    renderChanges(): Promise<Position | undefined>;
+    getWholeRangeDecoration(): IModelDeltaDecoration[];
+    private _doApplyChanges;
+}
+export interface ProgressingEditsOptions {
+    duration: number;
+    token: CancellationToken;
+}
+export interface IInlineChatMetadata {
+    modelId: string | undefined;
+    extensionId: VersionedExtensionId | undefined;
+    requestId: string | undefined;
+}

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

@@ -0,0 +1,464 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { WindowIntervalTimer, createElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { themeColorFromId, ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { StableEditorScrollState } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/stableEditorScroll';
+import { RenderOptions, LineSource, renderLines } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/diffEditor/components/diffEditorViewZones/renderLines';
+import { LineRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/lineRange';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { MinimapPosition, OverviewRulerLane, TrackedRangeStickiness } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { ModelDecorationOptions } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
+import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { Progress } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
+import { SaveReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { countWords } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatWordCounter';
+import { HunkState } from './inlineChatSession.js';
+import { minimapInlineChatDiffInserted, overviewRulerInlineChatDiffInserted, CTX_INLINE_CHAT_CHANGE_HAS_DIFF, CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF, MENU_INLINE_CHAT_ZONE, ACTION_TOGGLE_DIFF, InlineChatConfigKeys } from '../common/inlineChat.js';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { asProgressiveEdit, performAsyncTextEdit } from './utils.js';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { DefaultChatTextEditor } from '../../chat/browser/codeBlockPart.js';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { ConflictActionsFactory } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mergeEditor/browser/view/conflictActions';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
+import { InlineDecoration, InlineDecorationType } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/viewModel/inlineDecorations';
+import { EditSources } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditSource';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+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 LiveStrategy = class LiveStrategy {
+    constructor(_session, _editor, _zone, _showOverlayToolbar, contextKeyService, _editorWorkerService, _accessibilityService, _configService, _menuService, _contextService, _textFileService, _instaService) {
+        this._session = _session;
+        this._editor = _editor;
+        this._zone = _zone;
+        this._showOverlayToolbar = _showOverlayToolbar;
+        this._editorWorkerService = _editorWorkerService;
+        this._accessibilityService = _accessibilityService;
+        this._configService = _configService;
+        this._menuService = _menuService;
+        this._contextService = _contextService;
+        this._textFileService = _textFileService;
+        this._instaService = _instaService;
+        this._decoInsertedText = ModelDecorationOptions.register({
+            description: 'inline-modified-line',
+            className: 'inline-chat-inserted-range-linehighlight',
+            isWholeLine: true,
+            overviewRuler: {
+                position: OverviewRulerLane.Full,
+                color: themeColorFromId(overviewRulerInlineChatDiffInserted),
+            },
+            minimap: {
+                position: MinimapPosition.Inline,
+                color: themeColorFromId(minimapInlineChatDiffInserted),
+            }
+        });
+        this._decoInsertedTextRange = ModelDecorationOptions.register({
+            description: 'inline-chat-inserted-range-linehighlight',
+            className: 'inline-chat-inserted-range',
+            stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+        });
+        this._store = ( new DisposableStore());
+        this._onDidAccept = this._store.add(( new Emitter()));
+        this._onDidDiscard = this._store.add(( new Emitter()));
+        this._editCount = 0;
+        this._hunkData = ( new Map());
+        this.onDidAccept = this._onDidAccept.event;
+        this.onDidDiscard = this._onDidDiscard.event;
+        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();
+        this._store.dispose();
+    }
+    _resetDiff() {
+        this._ctxCurrentChangeHasDiff.reset();
+        this._ctxCurrentChangeShowsDiff.reset();
+        this._zone.widget.updateStatus('');
+        this._progressiveEditingDecorations.clear();
+        for (const data of ( this._hunkData.values())) {
+            data.remove();
+        }
+    }
+    async apply() {
+        this._resetDiff();
+        if (this._editCount > 0) {
+            this._editor.pushUndoStop();
+        }
+        await this._doApplyChanges(true);
+    }
+    cancel() {
+        this._resetDiff();
+        return this._session.hunkData.discardAll();
+    }
+    async makeChanges(edits, obs, undoStopBefore, metadata) {
+        return this._makeChanges(edits, obs, undefined, undefined, undoStopBefore, metadata);
+    }
+    async makeProgressiveChanges(edits, obs, opts, undoStopBefore, metadata) {
+        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));
+            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 });
+            }
+            this._progressiveEditingDecorations.append(newDecorations);
+        }));
+        return this._makeChanges(edits, obs, opts, progress, undoStopBefore, metadata);
+    }
+    async _makeChanges(edits, obs, opts, progress, undoStopBefore, metadata) {
+        if (undoStopBefore) {
+            this._editor.pushUndoStop();
+        }
+        this._editCount++;
+        const editSource = EditSources.inlineChatApplyEdit({
+            modelId: metadata.modelId,
+            extensionId: metadata.extensionId,
+            requestId: metadata.requestId,
+            sessionId: undefined,
+            languageId: this._session.textModelN.getLanguageId(),
+        });
+        if (opts) {
+            const durationInSec = opts.duration / 1000;
+            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);
+                await performAsyncTextEdit(this._session.textModelN, asyncEdit, progress, obs, editSource);
+            }
+        }
+        else {
+            obs.start();
+            this._session.textModelN.pushEditOperations(null, edits, (undoEdits) => {
+                progress?.report(undoEdits);
+                return null;
+            }, undefined, editSource);
+            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._hunkData.get(hunkInfo);
+        }
+        if (!result && this._zone.position) {
+            const zoneLine = this._zone.position.lineNumber;
+            let distance = Number.MAX_SAFE_INTEGER;
+            for (const candidate of ( this._hunkData.values())) {
+                if (candidate.hunk.getState() !== HunkState.Pending) {
+                    continue;
+                }
+                const hunkRanges = candidate.hunk.getRangesN();
+                if (hunkRanges.length === 0) {
+                    continue;
+                }
+                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._hunkData.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._hunkData.keys())));
+                widgetData = undefined;
+                for (const hunkData of this._session.hunkData.getInfo()) {
+                    keysNow.delete(hunkData);
+                    const hunkRanges = hunkData.getRangesN();
+                    let data = this._hunkData.get(hunkData);
+                    if (!data) {
+                        const decorationIds = [];
+                        for (let i = 0; i < hunkRanges.length; i++) {
+                            decorationIds.push(decorationsAccessor.addDecoration(hunkRanges[i], i === 0
+                                ? this._decoInsertedText
+                                : this._decoInsertedTextRange));
+                        }
+                        const acceptHunk = () => {
+                            hunkData.acceptChanges();
+                            renderHunks();
+                        };
+                        const discardHunk = () => {
+                            hunkData.discardChanges();
+                            renderHunks();
+                        };
+                        const mightContainNonBasicASCII = this._session.textModel0.mightContainNonBasicASCII();
+                        const mightContainRTL = this._session.textModel0.mightContainRTL();
+                        const renderOptions = RenderOptions.fromEditor(this._editor);
+                        const originalRange = hunkData.getRanges0()[0];
+                        const source = ( new LineSource(
+                            LineRange.fromRangeInclusive(originalRange).mapToLineArray(l => this._session.textModel0.tokenization.getLineTokens(l)),
+                            [],
+                            mightContainNonBasicASCII,
+                            mightContainRTL
+                        ));
+                        const domNode = 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 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.diffViewZoneId) {
+                                    const [hunkRange] = hunkData.getRangesN();
+                                    viewZoneData.afterLineNumber = hunkRange.startLineNumber - 1;
+                                    data.diffViewZoneId = viewZoneAccessor.addZone(viewZoneData);
+                                }
+                                else {
+                                    viewZoneAccessor.removeZone(data.diffViewZoneId);
+                                    data.diffViewZoneId = undefined;
+                                }
+                            });
+                            this._ctxCurrentChangeShowsDiff.set(typeof data?.diffViewZoneId === 'string');
+                            scrollState.restore(this._editor);
+                        };
+                        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({ arg: hunkData });
+                                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.diffViewZoneId) {
+                                    viewZoneAccessor.removeZone(data.diffViewZoneId);
+                                }
+                                data.decorationIds = [];
+                                data.diffViewZoneId = undefined;
+                                data.lensActionsViewZoneIds?.forEach(viewZoneAccessor.removeZone);
+                                data.lensActionsViewZoneIds = undefined;
+                            });
+                            lensActions?.dispose();
+                        };
+                        const move = (next) => {
+                            const keys = Array.from(( this._hunkData.keys()));
+                            const idx = keys.indexOf(hunkData);
+                            const nextIdx = (idx + (next ? 1 : -1) + keys.length) % keys.length;
+                            if (nextIdx !== idx) {
+                                const nextData = this._hunkData.get(keys[nextIdx]);
+                                this._zone.updatePositionAndHeight(nextData?.position);
+                                renderHunks();
+                            }
+                        };
+                        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,
+                            diffViewZoneId: '',
+                            diffViewZone: viewZoneData,
+                            lensActionsViewZoneIds,
+                            distance: myDistance,
+                            position: hunkRanges[0].getStartPosition().delta(-1),
+                            acceptHunk,
+                            discardHunk,
+                            toggleDiff: !hunkData.isInsertion() ? toggleDiff : undefined,
+                            remove,
+                            move,
+                        };
+                        this._hunkData.set(hunkData, data);
+                    }
+                    else if (hunkData.getState() !== HunkState.Pending) {
+                        data.remove();
+                    }
+                    else {
+                        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
+                            ? modifiedRangeNow.startLineNumber - zoneLineNumber
+                            : zoneLineNumber - modifiedRangeNow.endLineNumber;
+                    }
+                    if (hunkData.getState() === HunkState.Pending && (!widgetData || data.distance < widgetData.distance)) {
+                        widgetData = data;
+                    }
+                }
+                for (const key of keysNow) {
+                    const data = this._hunkData.get(key);
+                    if (data) {
+                        this._hunkData.delete(key);
+                        data.remove();
+                    }
+                }
+            });
+            if (widgetData) {
+                this._zone.reveal(widgetData.position);
+                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));
+            }
+            else if (this._hunkData.size > 0) {
+                let oneAccepted = false;
+                for (const hunkData of this._session.hunkData.getInfo()) {
+                    if (hunkData.getState() === HunkState.Accepted) {
+                        oneAccepted = true;
+                        break;
+                    }
+                }
+                if (oneAccepted) {
+                    this._onDidAccept.fire();
+                }
+                else {
+                    this._onDidDiscard.fire();
+                }
+            }
+            return widgetData;
+        };
+        return renderHunks()?.position;
+    }
+    getWholeRangeDecoration() {
+        return [];
+    }
+    async _doApplyChanges(ignoreLocal) {
+        const untitledModels = [];
+        const editor = this._instaService.createInstance(DefaultChatTextEditor);
+        for (const request of this._session.chatModel.getRequests()) {
+            if (!request.response?.response) {
+                continue;
+            }
+            for (const item of request.response.response.value) {
+                if (item.kind !== 'textEditGroup') {
+                    continue;
+                }
+                if (ignoreLocal && isEqual(item.uri, this._session.textModelN.uri)) {
+                    continue;
+                }
+                await editor.apply(request.response, item, undefined);
+                if (item.uri.scheme === Schemas.untitled) {
+                    const untitled = this._textFileService.untitled.get(item.uri);
+                    if (untitled) {
+                        untitledModels.push(untitled);
+                    }
+                }
+            }
+        }
+        for (const untitledModel of untitledModels) {
+            if (!untitledModel.isDisposed()) {
+                await untitledModel.resolve();
+                await untitledModel.save({ reason: SaveReason.EXPLICIT });
+            }
+        }
+    }
+};
+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 => {
+            callback(decorationsAccessor, viewZoneAccessor);
+        });
+    });
+}
+
+export { HunkAction, LiveStrategy };

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

@@ -0,0 +1,124 @@
+import { Dimension } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { ICodeEditorViewState } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/editorCommon";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+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 { IWorkbenchButtonBarOptions } from "../../../../platform/actions/browser/buttonbar.js";
+import { MenuId } 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 { 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 { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { IChatWidgetViewOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { ChatWidget, IChatWidgetLocationOptions } from "../../chat/browser/chatWidget.js";
+import { IChatModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { HunkInformation, Session } from "./inlineChatSession.js";
+export interface InlineChatWidgetViewState {
+    editorViewState: ICodeEditorViewState;
+    input: string;
+    placeholder: string;
+}
+export interface IInlineChatWidgetConstructionOptions {
+    /**
+     * The menu that rendered as button bar, use for accept, discard etc
+     */
+    statusMenuId: MenuId | {
+        menu: MenuId;
+        options: IWorkbenchButtonBarOptions;
+    };
+    secondaryMenuId?: MenuId;
+    /**
+     * The options for the chat widget
+     */
+    chatWidgetViewOptions?: IChatWidgetViewOptions;
+    inZoneWidget?: boolean;
+}
+export declare class InlineChatWidget {
+    private readonly _options;
+    protected readonly _instantiationService: IInstantiationService;
+    private readonly _contextKeyService;
+    private readonly _keybindingService;
+    private readonly _accessibilityService;
+    private readonly _configurationService;
+    private readonly _accessibleViewService;
+    protected readonly _textModelResolverService: ITextModelService;
+    private readonly _chatService;
+    private readonly _hoverService;
+    private readonly _chatEntitlementService;
+    private readonly _markdownRendererService;
+    protected readonly _elements: {
+        root: HTMLDivElement;
+        chatWidget: HTMLDivElement;
+        accessibleViewer: HTMLDivElement;
+        infoLabel: HTMLDivElement;
+        toolbar1: HTMLDivElement;
+        statusLabel: HTMLDivElement;
+        toolbar2: HTMLDivElement;
+        disclaimerLabel: HTMLDivElement;
+        status: HTMLDivElement;
+    };
+    protected readonly _store: DisposableStore;
+    private readonly _ctxInputEditorFocused;
+    private readonly _ctxResponseFocused;
+    private readonly _chatWidget;
+    protected readonly _onDidChangeHeight: Emitter<void>;
+    readonly onDidChangeHeight: Event<void>;
+    private readonly _requestInProgress;
+    readonly requestInProgress: IObservable<boolean>;
+    private _isLayouting;
+    readonly scopedContextKeyService: IContextKeyService;
+    constructor(location: IChatWidgetLocationOptions, _options: IInlineChatWidgetConstructionOptions, _instantiationService: IInstantiationService, _contextKeyService: IContextKeyService, _keybindingService: IKeybindingService, _accessibilityService: IAccessibilityService, _configurationService: IConfigurationService, _accessibleViewService: IAccessibleViewService, _textModelResolverService: ITextModelService, _chatService: IChatService, _hoverService: IHoverService, _chatEntitlementService: IChatEntitlementService, _markdownRendererService: IMarkdownRendererService);
+    private _updateAriaLabel;
+    private _setupDisclaimer;
+    dispose(): void;
+    get domNode(): HTMLElement;
+    get chatWidget(): ChatWidget;
+    saveState(): void;
+    layout(widgetDim: Dimension): void;
+    protected _doLayout(dimension: Dimension): void;
+    /**
+     * The content height of this widget is the size that would require no scrolling
+     */
+    get contentHeight(): number;
+    get minHeight(): number;
+    protected _getExtraHeight(): number;
+    get value(): string;
+    set value(value: string);
+    selectAll(): void;
+    set placeholder(value: string);
+    toggleStatus(show: boolean): void;
+    updateToolbar(show: boolean): void;
+    getCodeBlockInfo(codeBlockIndex: number): Promise<ITextModel | undefined>;
+    get responseContent(): string | undefined;
+    getChatModel(): IChatModel | undefined;
+    setChatModel(chatModel: IChatModel): void;
+    updateInfo(message: string): void;
+    updateStatus(message: string, ops?: {
+        classes?: string[];
+        resetAfter?: number;
+        keepMessage?: boolean;
+        title?: string;
+    }): void;
+    reset(): void;
+    focus(): void;
+    hasFocus(): boolean;
+}
+export declare class EditorBasedInlineChatWidget extends InlineChatWidget {
+    private readonly _parentEditor;
+    private readonly _accessibleViewer;
+    constructor(location: IChatWidgetLocationOptions, _parentEditor: ICodeEditor, options: IInlineChatWidgetConstructionOptions, contextKeyService: IContextKeyService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, accessibilityService: IAccessibilityService, configurationService: IConfigurationService, accessibleViewService: IAccessibleViewService, textModelResolverService: ITextModelService, chatService: IChatService, hoverService: IHoverService, layoutService: ILayoutService, chatEntitlementService: IChatEntitlementService, markdownRendererService: IMarkdownRendererService);
+    get contentHeight(): number;
+    protected _doLayout(dimension: Dimension): void;
+    reset(): void;
+    showAccessibleHunk(session: Session, hunkData: HunkInformation): void;
+}