@codingame/monaco-vscode-api 2.0.3 → 2.1.0

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

@@ -1,96 +1,136 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { disposableWindowInterval } from '../../../../base/browser/dom.js';
-import { $window } from '../../../../base/browser/window.js';
-import { toAction } from '../../../../base/common/actions.js';
-import { equals, tail } from '../../../../base/common/arrays.js';
-import { AsyncIterableSource } from '../../../../base/common/async.js';
-import { Codicon } from '../../../../base/common/codicons.js';
-import { Event, Emitter } from '../../../../base/common/event.js';
+import { WindowIntervalTimer } from '../../../../base/browser/dom.js';
+import { coalesceInPlace } from '../../../../base/common/arrays.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
 import { Lazy } from '../../../../base/common/lazy.js';
-import { DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
-import { ThemeIcon } from '../../../../base/common/themables.js';
-import { IBulkEditService } from '../../../../editor/browser/services/bulkEditService.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { themeColorFromId } from '../../../../base/common/themables.js';
 import { StableEditorScrollState } from '../../../../editor/browser/stableEditorScroll.js';
-import { RenderOptions, LineSource, renderLines } from '../../../../editor/browser/widget/diffEditor/renderLines.js';
+import { RenderOptions, LineSource, renderLines } from '../../../../editor/browser/widget/diffEditor/components/diffEditorViewZones/renderLines.js';
 import { EditOperation } from '../../../../editor/common/core/editOperation.js';
+import { LineRange } from '../../../../editor/common/core/lineRange.js';
 import { Range } from '../../../../editor/common/core/range.js';
-import { Selection } from '../../../../editor/common/core/selection.js';
-import { DetailedLineRangeMapping } from '../../../../editor/common/diff/rangeMapping.js';
-import { TextEdit } from '../../../../editor/common/languages.js';
+import { OverviewRulerLane } from '../../../../editor/common/model.js';
 import { ModelDecorationOptions } from '../../../../editor/common/model/textModel.js';
 import { IEditorWorkerService } from '../../../../editor/common/services/editorWorker.js';
 import { InlineDecoration } from '../../../../editor/common/viewModel.js';
 import { localizeWithPath } from '../../../../nls.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { countWords, getNWords } from '../../chat/common/chatWordCounter.js';
+import { Progress } from '../../../../platform/progress/common/progress.js';
+import { countWords } from '../../chat/common/chatWordCounter.js';
 import { InlineChatFileCreatePreviewWidget, InlineChatLivePreviewWidget } from './inlineChatLivePreviewWidget.js';
 import { ReplyResponse } from './inlineChatSession.js';
-import { CTX_INLINE_CHAT_DOCUMENT_CHANGED, CTX_INLINE_CHAT_CHANGE_HAS_DIFF, CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF } from '../common/inlineChat.js';
-var LiveStrategy_1, LiveStrategy3_1;
+import { CTX_INLINE_CHAT_DOCUMENT_CHANGED, CTX_INLINE_CHAT_CHANGE_HAS_DIFF, CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF, overviewRulerInlineChatDiffInserted } 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';
 class EditModeStrategy {
-    constructor(_zone) {
+    static { this._decoBlock = ModelDecorationOptions.register({
+        description: 'inline-chat',
+        showIfCollapsed: false,
+        isWholeLine: true,
+        className: 'inline-chat-block-selection',
+    }); }
+    constructor(_session, _editor, _zone) {
+        this._session = _session;
+        this._editor = _editor;
         this._zone = _zone;
-        this._onDidAccept = ( new Emitter());
-        this._onDidDiscard = ( new Emitter());
+        this._store = ( new DisposableStore());
+        this._onDidAccept = this._store.add(( new Emitter()));
+        this._onDidDiscard = this._store.add(( new Emitter()));
+        this._editCount = 0;
         this.onDidAccept = this._onDidAccept.event;
         this.onDidDiscard = this._onDidDiscard.event;
     }
     dispose() {
-        this._onDidAccept.dispose();
-        this._onDidDiscard.dispose();
+        this._store.dispose();
+    }
+    cancel() {
+        return this._session.hunkData.discardAll();
+    }
+    async acceptHunk() {
+        this._onDidAccept.fire();
+    }
+    async discardHunk() {
+        this._onDidDiscard.fire();
+    }
+    async _makeChanges(edits, obs, opts, progress) {
+        if (++this._editCount === 1) {
+            this._editor.pushUndoStop();
+        }
+        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);
+            }
+        }
+        else {
+            obs.start();
+            this._session.textModelN.pushEditOperations(null, edits, (undoEdits) => {
+                progress?.report(undoEdits);
+                return null;
+            });
+            obs.stop();
+        }
+    }
+    getWholeRangeDecoration() {
+        const ranges = [this._session.wholeRange.value];
+        const newDecorations = ( ranges.map(
+            range => range.isEmpty() ? undefined : ({ range, options: EditModeStrategy._decoBlock })
+        ));
+        coalesceInPlace(newDecorations);
+        return newDecorations;
     }
 }
 let PreviewStrategy = class PreviewStrategy extends EditModeStrategy {
-    constructor(_session, zone, contextKeyService) {
-        super(zone);
-        this._session = _session;
+    constructor(session, editor, zone, modelService, contextKeyService) {
+        super(session, editor, zone);
         this._ctxDocumentChanged = CTX_INLINE_CHAT_DOCUMENT_CHANGED.bindTo(contextKeyService);
-        this._listener = Event.debounce(_session.textModelN.onDidChangeContent.bind(_session.textModelN), () => { }, 350)(_ => {
-            if (!_session.textModelN.isDisposed() && !_session.textModel0.isDisposed()) {
-                this._ctxDocumentChanged.set(_session.hasChangedText);
+        const baseModel = modelService.getModel(session.targetUri);
+        Event.debounce(baseModel.onDidChangeContent.bind(baseModel), () => { }, 350)(_ => {
+            if (!baseModel.isDisposed() && !session.textModel0.isDisposed()) {
+                this._ctxDocumentChanged.set(session.hasChangedText);
             }
-        });
+        }, undefined, this._store);
     }
     dispose() {
-        this._listener.dispose();
         this._ctxDocumentChanged.reset();
         super.dispose();
     }
-    async start() {
-    }
     async apply() {
-        if (!(this._session.lastExchange?.response instanceof ReplyResponse)) {
-            return;
-        }
-        const editResponse = this._session.lastExchange?.response;
-        const { textModelN: modelN } = this._session;
-        if (modelN.equalsTextBuffer(this._session.textModel0.getTextBuffer())) {
-            modelN.pushStackElement();
-            for (const edits of editResponse.allLocalEdits) {
-                modelN.pushEditOperations(null, ( edits.map(TextEdit.asEditOperation)), () => null);
+        const textModel = this._editor.getModel();
+        if (textModel?.equalsTextBuffer(this._session.textModel0.getTextBuffer())) {
+            this._session.hunkData.getInfo().forEach(item => item.acceptChanges());
+            const newText = this._session.textModel0.getValue();
+            const range = textModel.getFullModelRange();
+            textModel.pushStackElement();
+            textModel.pushEditOperations(null, [EditOperation.replace(range, newText)], () => null);
+            textModel.pushStackElement();
+        }
+        if (this._session.lastExchange?.response instanceof ReplyResponse) {
+            const { untitledTextModel } = this._session.lastExchange.response;
+            if (untitledTextModel && !untitledTextModel.isDisposed() && untitledTextModel.isDirty()) {
+                await untitledTextModel.save({ reason: 1  });
             }
-            modelN.pushStackElement();
         }
-        const { untitledTextModel } = this._session.lastExchange.response;
-        if (untitledTextModel && !untitledTextModel.isDisposed() && untitledTextModel.isDirty()) {
-            await untitledTextModel.save({ reason: 1  });
-        }
-    }
-    async cancel() {
     }
-    async makeChanges(_edits) {
+    async makeChanges(edits, obs) {
+        return this._makeChanges(edits, obs, undefined, undefined);
     }
-    async undoChanges(_altVersionId) {
+    async makeProgressiveChanges(edits, obs, opts) {
+        return this._makeChanges(edits, obs, opts, undefined);
     }
-    async makeProgressiveChanges() {
+    async undoChanges(altVersionId) {
+        const { textModelN } = this._session;
+        await undoModelUntil(textModelN, altVersionId);
     }
     async renderChanges(response) {
         if (response.allLocalEdits.length > 0) {
-            const allEditOperation = ( response.allLocalEdits.map(edits => ( edits.map(TextEdit.asEditOperation))));
-            await this._zone.widget.showEditsPreview(this._session.textModel0, this._session.textModelN, allEditOperation);
+            await this._zone.widget.showEditsPreview(this._session.textModel0, this._session.textModelN);
         }
         else {
             this._zone.widget.hideEditsPreview();
@@ -105,98 +145,28 @@ let PreviewStrategy = class PreviewStrategy extends EditModeStrategy {
     hasFocus() {
         return this._zone.widget.hasFocus();
     }
-    needsMargin() {
-        return true;
-    }
 };
 PreviewStrategy = ( __decorate([
-    ( __param(2, IContextKeyService))
+    ( __param(3, IModelService)),
+    ( __param(4, IContextKeyService))
 ], PreviewStrategy));
-class InlineDiffDecorations {
-    constructor(editor, visible = false) {
-        this._data = [];
-        this._visible = false;
-        this._collection = editor.createDecorationsCollection();
-        this._visible = visible;
-    }
-    get visible() {
-        return this._visible;
-    }
-    set visible(value) {
-        this._visible = value;
-        this.update();
-    }
-    clear() {
-        this._collection.clear();
-        this._data.length = 0;
-    }
-    collectEditOperation(op) {
-        this._data.push(InlineDiffDecorations._asDecorationData(op));
-    }
-    update() {
-        this._collection.set(( this._data.map(d => {
-            const res = { ...d.tracking };
-            if (this._visible) {
-                res.options = { ...res.options, ...d.decorating };
-            }
-            return res;
-        })));
-    }
-    static _asDecorationData(edit) {
-        let content = edit.text;
-        if (content.length > 12) {
-            content = content.substring(0, 12) + '…';
-        }
-        const tracking = {
-            range: edit.range,
-            options: {
-                description: 'inline-chat-inline-diff',
-            }
-        };
-        const decorating = {
-            description: 'inline-chat-inline-diff',
-            className: !edit.range.isEmpty() ? 'inline-chat-lines-inserted-range' : undefined,
-            showIfCollapsed: true,
-            before: {
-                content,
-                inlineClassName: 'inline-chat-lines-deleted-range-inline',
-                attachedData: edit,
-            }
-        };
-        return { tracking, decorating };
-    }
-}
-let LiveStrategy = LiveStrategy_1 = class LiveStrategy extends EditModeStrategy {
-    constructor(_session, _editor, zone, configService, _storageService, _bulkEditService, _editorWorkerService, _instaService) {
-        super(zone);
-        this._session = _session;
-        this._editor = _editor;
-        this._storageService = _storageService;
-        this._bulkEditService = _bulkEditService;
-        this._editorWorkerService = _editorWorkerService;
+let LivePreviewStrategy = class LivePreviewStrategy extends EditModeStrategy {
+    constructor(session, editor, zone, _instaService) {
+        super(session, editor, zone);
         this._instaService = _instaService;
-        this._diffEnabled = false;
-        this._store = ( new DisposableStore());
-        this._editCount = 0;
-        this._diffEnabled = configService.getValue('inlineChat.showDiff');
-        this._inlineDiffDecorations = ( new InlineDiffDecorations(this._editor, this._diffEnabled));
-        this._inlineDiffDecorations.visible = this._diffEnabled;
-        this._store.add(configService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('inlineChat.showDiff')) {
-                this._diffEnabled = !this._diffEnabled;
-                this._doToggleDiff();
-            }
-        }));
+        this._diffZonePool = [];
+        this._previewZone = ( new Lazy(
+            () => _instaService.createInstance(InlineChatFileCreatePreviewWidget, editor)
+        ));
     }
     dispose() {
+        for (const zone of this._diffZonePool) {
+            zone.hide();
+            zone.dispose();
+        }
+        this._previewZone.rawValue?.hide();
+        this._previewZone.rawValue?.dispose();
         super.dispose();
-        this._inlineDiffDecorations.clear();
-        this._store.dispose();
-    }
-    _doToggleDiff() {
-        this._inlineDiffDecorations.visible = this._diffEnabled;
-    }
-    async start() {
     }
     async apply() {
         if (this._editCount > 0) {
@@ -210,297 +180,159 @@ let LiveStrategy = LiveStrategy_1 = class LiveStrategy extends EditModeStrategy
             await untitledTextModel.save({ reason: 1  });
         }
     }
-    async cancel() {
-        const { textModelN: modelN, textModelNAltVersion, textModelNSnapshotAltVersion } = this._session;
-        if (modelN.isDisposed()) {
-            return;
-        }
-        const targetAltVersion = textModelNSnapshotAltVersion ?? textModelNAltVersion;
-        LiveStrategy_1._undoModelUntil(modelN, targetAltVersion);
-    }
-    async makeChanges(edits) {
-        const cursorStateComputerAndInlineDiffCollection = (undoEdits) => {
-            let last = null;
-            for (const edit of undoEdits) {
-                last = !last || last.isBefore(edit.range.getEndPosition()) ? edit.range.getEndPosition() : last;
-                this._inlineDiffDecorations.collectEditOperation(edit);
-            }
-            return last && [Selection.fromPositions(last)];
-        };
-        if (++this._editCount === 1) {
-            this._editor.pushUndoStop();
-        }
-        this._editor.executeEdits('inline-chat-live', edits, cursorStateComputerAndInlineDiffCollection);
-    }
     async undoChanges(altVersionId) {
         const { textModelN } = this._session;
-        LiveStrategy_1._undoModelUntil(textModelN, altVersionId);
+        await undoModelUntil(textModelN, altVersionId);
+        this._updateDiffZones();
     }
-    async makeProgressiveChanges(edits, opts) {
-        if (++this._editCount === 1) {
-            this._editor.pushUndoStop();
-        }
-        const durationInSec = opts.duration / 1000;
-        for (const edit of edits) {
-            const wordCount = countWords(edit.text ?? '');
-            const speed = wordCount / durationInSec;
-            await performAsyncTextEdit(this._session.textModelN, asProgressiveEdit(edit, speed, opts.token));
-        }
+    async makeChanges(edits, obs) {
+        return this._makeChanges(edits, obs, undefined, undefined);
+    }
+    async makeProgressiveChanges(edits, obs, opts) {
+        await this._makeChanges(edits, obs, opts, ( new Progress(() => {
+            this._updateDiffZones();
+        })));
     }
     async renderChanges(response) {
-        const diff = await this._editorWorkerService.computeDiff(this._session.textModel0.uri, this._session.textModelN.uri, { ignoreTrimWhitespace: false, maxComputationTimeMs: 5000, computeMoves: false }, 'advanced');
-        this._updateSummaryMessage(diff?.changes ?? []);
-        this._inlineDiffDecorations.update();
-        if (response.untitledTextModel) {
-            this._zone.widget.showCreatePreview(response.untitledTextModel);
+        if (response.untitledTextModel && !response.untitledTextModel.isDisposed()) {
+            this._previewZone.value.showCreation(this._session.wholeRange.value.getStartPosition().delta(-1), response.untitledTextModel);
         }
         else {
-            this._zone.widget.hideCreatePreview();
-        }
-    }
-    static _undoModelUntil(model, targetAltVersion) {
-        while (targetAltVersion < model.getAlternativeVersionId() && model.canUndo()) {
-            model.undo();
+            this._previewZone.value.hide();
         }
+        return this._updateDiffZones();
     }
-    _updateSummaryMessage(mappings) {
-        let linesChanged = 0;
-        for (const change of mappings) {
-            linesChanged += change.changedLineCount;
-        }
+    _updateSummaryMessage(hunkCount) {
         let message;
-        if (linesChanged === 0) {
+        if (hunkCount === 0) {
             message = ( localizeWithPath(
                 'vs/workbench/contrib/inlineChat/browser/inlineChatStrategies',
-                'lines.0',
+                'change.0',
                 "Nothing changed"
             ));
         }
-        else if (linesChanged === 1) {
+        else if (hunkCount === 1) {
             message = ( localizeWithPath(
                 'vs/workbench/contrib/inlineChat/browser/inlineChatStrategies',
-                'lines.1',
-                "Changed 1 line"
+                'change.1',
+                "1 change"
             ));
         }
         else {
             message = ( localizeWithPath(
                 'vs/workbench/contrib/inlineChat/browser/inlineChatStrategies',
-                'lines.N',
-                "Changed {0} lines",
-                linesChanged
+                'lines.NM',
+                "{0} changes",
+                hunkCount
             ));
         }
         this._zone.widget.updateStatus(message);
     }
-    needsMargin() {
-        return true;
-    }
-    hasFocus() {
-        return this._zone.widget.hasFocus();
-    }
-};
-LiveStrategy = LiveStrategy_1 = ( __decorate([
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, IBulkEditService)),
-    ( __param(6, IEditorWorkerService)),
-    ( __param(7, IInstantiationService))
-], LiveStrategy));
-let LivePreviewStrategy = class LivePreviewStrategy extends LiveStrategy {
-    constructor(session, editor, zone, configService, storageService, bulkEditService, editorWorkerService, instaService) {
-        super(session, editor, zone, configService, storageService, bulkEditService, editorWorkerService, instaService);
-        this._diffZonePool = [];
-        this._currentLineRangeGroups = [];
-        this._previewZone = ( new Lazy(
-            () => instaService.createInstance(InlineChatFileCreatePreviewWidget, editor)
-        ));
-    }
-    dispose() {
-        for (const zone of this._diffZonePool) {
-            zone.hide();
-            zone.dispose();
-        }
-        this._previewZone.rawValue?.hide();
-        this._previewZone.rawValue?.dispose();
-        super.dispose();
-    }
-    async _updateDiffZones() {
-        const diff = await this._editorWorkerService.computeDiff(this._session.textModel0.uri, this._session.textModelN.uri, { ignoreTrimWhitespace: false, maxComputationTimeMs: 5000, computeMoves: false }, 'advanced');
-        if (!diff || diff.changes.length === 0) {
+    _updateDiffZones() {
+        const { hunkData } = this._session;
+        const hunks = hunkData.getInfo().filter(hunk => hunk.getState() === 0 );
+        if (hunks.length === 0) {
             for (const zone of this._diffZonePool) {
                 zone.hide();
             }
-            return;
-        }
-        const originalStartLineNumber = this._session.session.wholeRange?.startLineNumber ?? 1;
-        const mainGroup = [];
-        let lastGroup;
-        const groups = [mainGroup];
-        for (let i = 0; i < diff.changes.length; i++) {
-            const change = diff.changes[i];
-            if (change.original.startLineNumber >= originalStartLineNumber || 'true') {
-                mainGroup.push(change);
-                continue;
-            }
-            if (!lastGroup) {
-                lastGroup = [change];
-                groups.push(lastGroup);
-                continue;
-            }
-            const last = tail(lastGroup);
-            const treshold = Math.ceil((change.modified.length + last.modified.length) * .75);
-            if (change.modified.startLineNumber - last.modified.endLineNumberExclusive <= treshold) {
-                lastGroup.push(change);
+            if (hunkData.getInfo().find(hunk => hunk.getState() === 1 )) {
+                this._onDidAccept.fire();
             }
             else {
-                lastGroup = [change];
-                groups.push(lastGroup);
+                this._onDidDiscard.fire();
             }
-        }
-        const beforeAndNowAreEqual = equals(this._currentLineRangeGroups, groups, (groupA, groupB) => {
-            return equals(groupA, groupB, (mappingA, mappingB) => {
-                return mappingA.original.equals(mappingB.original) && mappingA.modified.equals(mappingB.modified);
-            });
-        });
-        if (beforeAndNowAreEqual) {
             return;
         }
-        this._updateSummaryMessage(diff.changes);
-        this._currentLineRangeGroups = groups;
-        const handleDiff = () => {
-            this._updateDiffZones();
-        };
-        while (groups.length > this._diffZonePool.length) {
+        this._updateSummaryMessage(hunks.length);
+        const handleDiff = () => this._updateDiffZones();
+        let nearest;
+        while (hunks.length > this._diffZonePool.length) {
             this._diffZonePool.push(this._instaService.createInstance(InlineChatLivePreviewWidget, this._editor, this._session, {}, this._diffZonePool.length === 0 ? handleDiff : undefined));
         }
-        for (let i = 0; i < groups.length; i++) {
-            this._diffZonePool[i].showForChanges(groups[i]);
+        for (let i = 0; i < hunks.length; i++) {
+            const hunk = hunks[i];
+            this._diffZonePool[i].showForChanges(hunk);
+            const modifiedRange = hunk.getRangesN()[0];
+            const zoneLineNumber = this._zone.position.lineNumber;
+            const distance = zoneLineNumber <= modifiedRange.startLineNumber
+                ? modifiedRange.startLineNumber - zoneLineNumber
+                : zoneLineNumber - modifiedRange.endLineNumber;
+            if (!nearest || nearest.distance > distance) {
+                nearest = {
+                    position: modifiedRange.getStartPosition().delta(-1),
+                    distance,
+                    accept: () => {
+                        hunk.acceptChanges();
+                        handleDiff();
+                    },
+                    discard: () => {
+                        hunk.discardChanges();
+                        handleDiff();
+                    }
+                };
+            }
         }
-        for (let i = groups.length; i < this._diffZonePool.length; i++) {
+        for (let i = hunks.length; i < this._diffZonePool.length; i++) {
             this._diffZonePool[i].hide();
         }
-    }
-    async makeProgressiveChanges(edits, opts) {
-        const changeTask = super.makeProgressiveChanges(edits, opts);
-        let renderTask = Promise.resolve();
-        const changeListener = this._session.textModelN.onDidChangeContent(() => {
-            changeListener.dispose();
-            renderTask = this._updateDiffZones();
-        });
-        await changeTask;
-        await renderTask;
-        changeListener.dispose();
-    }
-    async undoChanges(altVersionId) {
-        await super.undoChanges(altVersionId);
-        await this._updateDiffZones();
-    }
-    async renderChanges(response) {
-        await this._updateDiffZones();
-        if (response.untitledTextModel && !response.untitledTextModel.isDisposed()) {
-            this._previewZone.value.showCreation(this._session.wholeRange.value.getStartPosition().delta(-1), response.untitledTextModel);
-        }
-        else {
-            this._previewZone.value.hide();
+        this.acceptHunk = async () => nearest?.accept();
+        this.discardHunk = async () => nearest?.discard();
+        if (nearest) {
+            this._zone.updatePositionAndHeight(nearest.position);
+            this._editor.revealPositionInCenterIfOutsideViewport(nearest.position);
         }
+        return nearest?.position;
     }
     hasFocus() {
-        return super.hasFocus() || Boolean(this._previewZone.rawValue?.hasFocus()) || ( this._diffZonePool.some(zone => zone.isVisible && zone.hasFocus()));
+        return this._zone.widget.hasFocus()
+            || Boolean(this._previewZone.rawValue?.hasFocus())
+            || ( this._diffZonePool.some(zone => zone.isVisible && zone.hasFocus()));
     }
 };
 LivePreviewStrategy = ( __decorate([
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, IBulkEditService)),
-    ( __param(6, IEditorWorkerService)),
-    ( __param(7, IInstantiationService))
+    ( __param(3, IInstantiationService))
 ], LivePreviewStrategy));
-async function performAsyncTextEdit(model, edit) {
-    const [id] = model.deltaDecorations([], [{
-            range: edit.range,
-            options: {
-                description: 'asyncTextEdit',
-                stickiness: 0
-            }
-        }]);
-    let first = true;
-    for await (const part of edit.newText) {
-        if (model.isDisposed()) {
-            break;
-        }
-        const range = model.getDecorationRange(id);
-        if (!range) {
-            throw new Error('FAILED to perform async replace edit because the anchor decoration was removed');
-        }
-        const edit = first
-            ? EditOperation.replace(range, part)
-            : EditOperation.insert(range.getEndPosition(), part);
-        model.pushEditOperations(null, [edit], () => null);
-        first = false;
-    }
-}
-function asProgressiveEdit(edit, wordsPerSec, token) {
-    wordsPerSec = Math.max(10, wordsPerSec);
-    const stream = ( new AsyncIterableSource());
-    let newText = edit.text ?? '';
-    const handle = disposableWindowInterval($window, () => {
-        const r = getNWords(newText, 1);
-        stream.emitOne(r.value);
-        newText = newText.substring(r.value.length);
-        if (r.isFullString) {
-            handle.dispose();
-            stream.resolve();
-            d.dispose();
-        }
-    }, 1000 / wordsPerSec);
-    const d = token.onCancellationRequested(() => {
-        handle.dispose();
-        stream.resolve();
-        d.dispose();
-    });
-    return {
-        range: edit.range,
-        newText: stream.asyncIterable
-    };
-}
-let LiveStrategy3 = LiveStrategy3_1 = class LiveStrategy3 extends EditModeStrategy {
-    constructor(_session, _editor, zone, contextKeyService, _storageService, _bulkEditService, _editorWorkerService, _instaService) {
-        super(zone);
-        this._session = _session;
-        this._editor = _editor;
-        this._storageService = _storageService;
-        this._bulkEditService = _bulkEditService;
+let LiveStrategy = class LiveStrategy extends EditModeStrategy {
+    constructor(session, editor, zone, contextKeyService, _editorWorkerService, _instaService) {
+        super(session, editor, zone);
         this._editorWorkerService = _editorWorkerService;
         this._instaService = _instaService;
-        this._store = ( new DisposableStore());
-        this._sessionStore = ( new DisposableStore());
-        this._modifiedRangesThatHaveBeenInteractedWith = [];
-        this._editCount = 0;
-        this._decoModifiedInteractedWith = ModelDecorationOptions.register({ description: 'inline-chat-modified-interacted-with', stickiness: 0  });
+        this._decoInsertedText = ModelDecorationOptions.register({
+            description: 'inline-modified-line',
+            className: 'inline-chat-inserted-range-linehighlight',
+            isWholeLine: true,
+            overviewRuler: {
+                position: OverviewRulerLane.Full,
+                color: themeColorFromId(overviewRulerInlineChatDiffInserted),
+            }
+        });
+        this._decoInsertedTextRange = ModelDecorationOptions.register({
+            description: 'inline-chat-inserted-range-linehighlight',
+            className: 'inline-chat-inserted-range',
+        });
+        this.acceptHunk = () => super.acceptHunk();
+        this.discardHunk = () => super.discardHunk();
+        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._modifiedRangesDecorations = this._editor.createDecorationsCollection();
+        this._progressiveEditingDecorations = this._editor.createDecorationsCollection();
         this._previewZone = ( new Lazy(
-            () => _instaService.createInstance(InlineChatFileCreatePreviewWidget, _editor)
+            () => _instaService.createInstance(InlineChatFileCreatePreviewWidget, editor)
         ));
     }
     dispose() {
         this._resetDiff();
         this._previewZone.rawValue?.dispose();
-        this._store.dispose();
         super.dispose();
     }
     _resetDiff() {
         this._ctxCurrentChangeHasDiff.reset();
         this._ctxCurrentChangeShowsDiff.reset();
-        this._sessionStore.clear();
-        this._modifiedRangesDecorations.clear();
-        this._modifiedRangesThatHaveBeenInteractedWith.length = 0;
         this._zone.widget.updateStatus('');
-    }
-    async start() {
-        this._resetDiff();
+        this._progressiveEditingDecorations.clear();
+        for (const data of ( this._hunkDisplayData.values())) {
+            data.remove();
+        }
     }
     async apply() {
         this._resetDiff();
@@ -515,237 +347,34 @@ let LiveStrategy3 = LiveStrategy3_1 = class LiveStrategy3 extends EditModeStrate
             await untitledTextModel.save({ reason: 1  });
         }
     }
-    async cancel() {
+    cancel() {
         this._resetDiff();
-        const { textModelN: modelN, textModelNAltVersion, textModelNSnapshotAltVersion } = this._session;
-        if (modelN.isDisposed()) {
-            return;
-        }
-        const targetAltVersion = textModelNSnapshotAltVersion ?? textModelNAltVersion;
-        LiveStrategy3_1._undoModelUntil(modelN, targetAltVersion);
-    }
-    async makeChanges(edits) {
-        const cursorStateComputerAndInlineDiffCollection = (undoEdits) => {
-            let last = null;
-            for (const edit of undoEdits) {
-                last = !last || last.isBefore(edit.range.getEndPosition()) ? edit.range.getEndPosition() : last;
-            }
-            return last && [Selection.fromPositions(last)];
-        };
-        if (++this._editCount === 1) {
-            this._editor.pushUndoStop();
-        }
-        this._editor.executeEdits('inline-chat-live', edits, cursorStateComputerAndInlineDiffCollection);
+        return super.cancel();
     }
     async undoChanges(altVersionId) {
-        this._sessionStore.clear();
-        this._modifiedRangesDecorations.clear();
-        this._modifiedRangesThatHaveBeenInteractedWith.length = 0;
         const { textModelN } = this._session;
-        LiveStrategy3_1._undoModelUntil(textModelN, altVersionId);
+        await undoModelUntil(textModelN, altVersionId);
     }
-    async makeProgressiveChanges(edits, opts) {
-        if (++this._editCount === 1) {
-            this._editor.pushUndoStop();
-        }
-        const listener = this._session.textModelN.onDidChangeContent(async () => {
-            await this._showDiff(false, false);
-        });
-        try {
-            const durationInSec = opts.duration / 1000;
-            for (const edit of edits) {
-                const wordCount = countWords(edit.text ?? '');
-                const speed = wordCount / durationInSec;
-                await performAsyncTextEdit(this._session.textModelN, asProgressiveEdit(edit, speed, opts.token));
-            }
-        }
-        finally {
-            listener.dispose();
-        }
-    }
-    async _computeDiff() {
-        const diff = await this._editorWorkerService.computeDiff(this._session.textModel0.uri, this._session.textModelN.uri, { ignoreTrimWhitespace: false, maxComputationTimeMs: Number.MAX_SAFE_INTEGER, computeMoves: false }, 'advanced');
-        if (!diff || diff.changes.length === 0) {
-            return { identical: false, quitEarly: false, changes: [], moves: [] };
-        }
-        const mergedChanges = [diff.changes[0]];
-        for (let i = 1; i < diff.changes.length; i++) {
-            const lastChange = mergedChanges[mergedChanges.length - 1];
-            const thisChange = diff.changes[i];
-            if (thisChange.modified.startLineNumber - lastChange.modified.endLineNumberExclusive <= 5) {
-                mergedChanges[mergedChanges.length - 1] = ( new DetailedLineRangeMapping(
-                    lastChange.original.join(thisChange.original),
-                    lastChange.modified.join(thisChange.modified),
-                    (lastChange.innerChanges ?? []).concat(thisChange.innerChanges ?? [])
-                ));
-            }
-            else {
-                mergedChanges.push(thisChange);
-            }
-        }
-        return {
-            identical: diff.identical,
-            quitEarly: diff.quitEarly,
-            changes: mergedChanges,
-            moves: []
-        };
+    async makeChanges(edits, obs) {
+        return this._makeChanges(edits, obs, undefined, undefined);
     }
-    async _showDiff(isFinalChanges, isAfterManualInteraction) {
-        const diff = await this._computeDiff();
-        this._sessionStore.clear();
-        if (diff.identical || diff.changes.length === 0) {
-            if (isAfterManualInteraction) {
-                this._sessionStore.clear();
-                this._onDidDiscard.fire();
-            }
-            return undefined;
-        }
-        const viewZoneIds = ( new Set());
-        const newDecorations = [];
-        const mightContainNonBasicASCII = this._session.textModel0.mightContainNonBasicASCII() ?? false;
-        const mightContainRTL = this._session.textModel0.mightContainRTL() ?? false;
-        const renderOptions = RenderOptions.fromEditor(this._editor);
-        let widgetData;
-        for (let i = 0; i < diff.changes.length; i++) {
-            const { original, modified, innerChanges } = diff.changes[i];
-            const modifiedRange = modified.isEmpty
-                ? ( new Range(
-                modified.startLineNumber,
-                1,
-                modified.startLineNumber,
-                this._session.textModelN.getLineLength(modified.startLineNumber)
-            ))
-                : ( new Range(
-                modified.startLineNumber,
-                1,
-                modified.endLineNumberExclusive - 1,
-                this._session.textModelN.getLineLength(modified.endLineNumberExclusive - 1)
-            ));
-            const hasBeenInteractedWith = ( this._modifiedRangesThatHaveBeenInteractedWith.some(id => {
-                const range = this._session.textModelN.getDecorationRange(id);
-                return range && Range.areIntersecting(range, modifiedRange);
-            }));
-            if (hasBeenInteractedWith) {
-                continue;
+    async makeProgressiveChanges(edits, obs, opts) {
+        const progress = ( new Progress(edits => {
+            const newLines = ( new Set());
+            for (const edit of edits) {
+                LineRange.fromRange(edit.range).forEach(line => newLines.add(line));
             }
-            if (innerChanges) {
-                for (const { modifiedRange } of innerChanges) {
-                    newDecorations.push({
-                        range: modifiedRange,
-                        options: {
-                            description: 'inline-modified',
-                            className: 'inline-chat-inserted-range',
-                        }
-                    });
-                    newDecorations.push({
-                        range: modifiedRange,
-                        options: {
-                            description: 'inline-modified',
-                            className: 'inline-chat-inserted-range-linehighlight',
-                            isWholeLine: true
-                        }
-                    });
-                }
+            const existingRanges = ( this._progressiveEditingDecorations.getRanges().map(LineRange.fromRange));
+            for (const existingRange of existingRanges) {
+                existingRange.forEach(line => newLines.delete(line));
             }
-            const source = ( new LineSource(
-                original.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(original.startLineNumber, 1, original.startLineNumber, 1)), '', 0 ))], domNode);
-            let myViewZoneId = '';
-            const myViewZone = {
-                afterLineNumber: modifiedRange.startLineNumber - 1,
-                heightInLines: result.heightInLines,
-                domNode,
-            };
-            if (isFinalChanges) {
-                const [id] = this._modifiedRangesDecorations.append([{ range: modifiedRange, options: this._decoModifiedInteractedWith }]);
-                const actions = [
-                    toAction({
-                        id: 'accept',
-                        label: ( localizeWithPath(
-                            'vs/workbench/contrib/inlineChat/browser/inlineChatStrategies',
-                            'accept',
-                            "Accept"
-                        )),
-                        class: ThemeIcon.asClassName(Codicon.check),
-                        run: () => {
-                            this._modifiedRangesThatHaveBeenInteractedWith.push(id);
-                            return this._showDiff(true, true);
-                        }
-                    }),
-                    toAction({
-                        id: 'discard',
-                        label: ( localizeWithPath(
-                            'vs/workbench/contrib/inlineChat/browser/inlineChatStrategies',
-                            'discard',
-                            "Discard"
-                        )),
-                        class: ThemeIcon.asClassName(Codicon.discard),
-                        run: () => {
-                            const edits = [];
-                            for (const innerChange of innerChanges) {
-                                const originalValue = this._session.textModel0.getValueInRange(innerChange.originalRange);
-                                edits.push(EditOperation.replace(innerChange.modifiedRange, originalValue));
-                            }
-                            this._session.textModelN.pushEditOperations(null, edits, () => null);
-                            return this._showDiff(true, true);
-                        }
-                    }),
-                ];
-                const toggleDiff = !original.isEmpty
-                    ? () => {
-                        const scrollState = StableEditorScrollState.capture(this._editor);
-                        if (!( viewZoneIds.has(myViewZoneId))) {
-                            this._editor.changeViewZones(accessor => {
-                                myViewZoneId = accessor.addZone(myViewZone);
-                                viewZoneIds.add(myViewZoneId);
-                            });
-                            this._ctxCurrentChangeShowsDiff.set(true);
-                        }
-                        else {
-                            this._editor.changeViewZones(accessor => {
-                                accessor.removeZone(myViewZoneId);
-                                viewZoneIds.delete(myViewZoneId);
-                            });
-                            this._ctxCurrentChangeShowsDiff.set(false);
-                        }
-                        scrollState.restore(this._editor);
-                    }
-                    : undefined;
-                const zoneLineNumber = this._zone.position.lineNumber;
-                const myDistance = zoneLineNumber <= modifiedRange.startLineNumber
-                    ? modifiedRange.startLineNumber - zoneLineNumber
-                    : zoneLineNumber - modifiedRange.endLineNumber;
-                if (!widgetData || widgetData.distance > myDistance) {
-                    widgetData = { distance: myDistance, position: modifiedRange.getStartPosition().delta(-1), index: i, actions, toggleDiff };
-                }
+            const newDecorations = [];
+            for (const line of newLines) {
+                newDecorations.push({ range: ( new Range(line, 1, line, Number.MAX_VALUE)), options: this._decoInsertedText });
             }
-        }
-        if (widgetData) {
-            this._zone.widget.setExtraButtons(widgetData.actions);
-            this._zone.updatePositionAndHeight(widgetData.position);
-            this._editor.revealPositionInCenterIfOutsideViewport(widgetData.position);
-            this._updateSummaryMessage(diff.changes, widgetData.index);
-            this._ctxCurrentChangeHasDiff.set(Boolean(widgetData.toggleDiff));
-            this.toggleDiff = widgetData.toggleDiff;
-        }
-        const decorations = this._editor.createDecorationsCollection(newDecorations);
-        this._sessionStore.add(toDisposable(() => {
-            decorations.clear();
-            this._editor.changeViewZones(accessor => viewZoneIds.forEach(accessor.removeZone, accessor));
-            viewZoneIds.clear();
-            this._zone.widget.setExtraButtons([]);
+            this._progressiveEditingDecorations.append(newDecorations);
         }));
-        if (isAfterManualInteraction && newDecorations.length === 0) {
-            this._sessionStore.clear();
-            this._onDidAccept.fire();
-        }
-        return widgetData?.position;
+        return this._makeChanges(edits, obs, opts, progress);
     }
     async renderChanges(response) {
         if (response.untitledTextModel && !response.untitledTextModel.isDisposed()) {
@@ -754,24 +383,158 @@ let LiveStrategy3 = LiveStrategy3_1 = class LiveStrategy3 extends EditModeStrate
         else {
             this._previewZone.value.hide();
         }
-        return await this._showDiff(true, false);
-    }
-    static _undoModelUntil(model, targetAltVersion) {
-        while (targetAltVersion < model.getAlternativeVersionId() && model.canUndo()) {
-            model.undo();
-        }
+        this._progressiveEditingDecorations.clear();
+        const renderHunks = () => {
+            let widgetData;
+            changeDecorationsAndViewZones(this._editor, (decorationsAccessor, viewZoneAccessor) => {
+                const keysNow = ( new Set(( this._hunkDisplayData.keys())));
+                widgetData = undefined;
+                for (const hunkData of this._session.hunkData.getInfo()) {
+                    keysNow.delete(hunkData);
+                    const hunkRanges = hunkData.getRangesN();
+                    let data = this._hunkDisplayData.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 = document.createElement('div');
+                        domNode.className = 'inline-chat-original-zone2';
+                        const result = renderLines(source, renderOptions, [( new InlineDecoration(( new Range(originalRange.startLineNumber, 1, originalRange.startLineNumber, 1)), '', 0 ))], domNode);
+                        const viewZoneData = {
+                            afterLineNumber: -1,
+                            heightInLines: result.heightInLines,
+                            domNode,
+                        };
+                        const toggleDiff = () => {
+                            const scrollState = StableEditorScrollState.capture(this._editor);
+                            changeDecorationsAndViewZones(this._editor, (_decorationsAccessor, viewZoneAccessor) => {
+                                assertType(data);
+                                if (!data.viewZoneId) {
+                                    const [hunkRange] = hunkData.getRangesN();
+                                    viewZoneData.afterLineNumber = hunkRange.startLineNumber - 1;
+                                    data.viewZoneId = viewZoneAccessor.addZone(viewZoneData);
+                                }
+                                else {
+                                    viewZoneAccessor.removeZone(data.viewZoneId);
+                                    data.viewZoneId = undefined;
+                                }
+                            });
+                            this._ctxCurrentChangeShowsDiff.set(typeof data?.viewZoneId === 'number');
+                            scrollState.restore(this._editor);
+                        };
+                        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);
+                                }
+                                data.decorationIds = [];
+                                data.viewZoneId = undefined;
+                            });
+                        };
+                        const zoneLineNumber = this._zone.position.lineNumber;
+                        const myDistance = zoneLineNumber <= hunkRanges[0].startLineNumber
+                            ? hunkRanges[0].startLineNumber - zoneLineNumber
+                            : zoneLineNumber - hunkRanges[0].endLineNumber;
+                        data = {
+                            decorationIds,
+                            viewZoneId: '',
+                            viewZone: viewZoneData,
+                            distance: myDistance,
+                            position: hunkRanges[0].getStartPosition().delta(-1),
+                            acceptHunk,
+                            discardHunk,
+                            toggleDiff: !hunkData.isInsertion() ? toggleDiff : undefined,
+                            remove,
+                        };
+                        this._hunkDisplayData.set(hunkData, data);
+                    }
+                    else if (hunkData.getState() !== 0 ) {
+                        data.remove();
+                    }
+                    else {
+                        const zoneLineNumber = this._zone.position.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() === 0  && (!widgetData || data.distance < widgetData.distance)) {
+                        widgetData = data;
+                    }
+                }
+                for (const key of keysNow) {
+                    const data = this._hunkDisplayData.get(key);
+                    if (data) {
+                        this._hunkDisplayData.delete(key);
+                        data.remove();
+                    }
+                }
+            });
+            if (widgetData) {
+                this._zone.updatePositionAndHeight(widgetData.position);
+                this._editor.revealPositionInCenterIfOutsideViewport(widgetData.position);
+                const remainingHunks = this._session.hunkData.pending;
+                this._updateSummaryMessage(remainingHunks);
+                this._ctxCurrentChangeHasDiff.set(Boolean(widgetData.toggleDiff));
+                this.toggleDiff = widgetData.toggleDiff;
+                this.acceptHunk = async () => widgetData.acceptHunk();
+                this.discardHunk = async () => widgetData.discardHunk();
+            }
+            else if (this._hunkDisplayData.size > 0) {
+                let oneAccepted = false;
+                for (const hunkData of this._session.hunkData.getInfo()) {
+                    if (hunkData.getState() === 1 ) {
+                        oneAccepted = true;
+                        break;
+                    }
+                }
+                if (oneAccepted) {
+                    this._onDidAccept.fire();
+                }
+                else {
+                    this._onDidDiscard.fire();
+                }
+            }
+            return widgetData;
+        };
+        return renderHunks()?.position;
     }
-    _updateSummaryMessage(mappings, index) {
-        const changesCount = mappings.length;
+    _updateSummaryMessage(hunkCount) {
         let message;
-        if (changesCount === 0) {
+        if (hunkCount === 0) {
             message = ( localizeWithPath(
                 'vs/workbench/contrib/inlineChat/browser/inlineChatStrategies',
                 'change.0',
                 "Nothing changed"
             ));
         }
-        else if (changesCount === 1) {
+        else if (hunkCount === 1) {
             message = ( localizeWithPath(
                 'vs/workbench/contrib/inlineChat/browser/inlineChatStrategies',
                 'change.1',
@@ -782,25 +545,34 @@ let LiveStrategy3 = LiveStrategy3_1 = class LiveStrategy3 extends EditModeStrate
             message = ( localizeWithPath(
                 'vs/workbench/contrib/inlineChat/browser/inlineChatStrategies',
                 'lines.NM',
-                "{1} changes",
-                index + 1,
-                changesCount
+                "{0} changes",
+                hunkCount
             ));
         }
         this._zone.widget.updateStatus(message);
     }
-    needsMargin() {
-        return true;
-    }
     hasFocus() {
         return this._zone.widget.hasFocus();
     }
+    getWholeRangeDecoration() {
+        return [];
+    }
 };
-LiveStrategy3 = LiveStrategy3_1 = ( __decorate([
+LiveStrategy = ( __decorate([
     ( __param(3, IContextKeyService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, IBulkEditService)),
-    ( __param(6, IEditorWorkerService)),
-    ( __param(7, IInstantiationService))
-], LiveStrategy3));
-export { EditModeStrategy, LivePreviewStrategy, LiveStrategy, LiveStrategy3, PreviewStrategy, asProgressiveEdit, performAsyncTextEdit };
+    ( __param(4, IEditorWorkerService)),
+    ( __param(5, IInstantiationService))
+], LiveStrategy));
+async function undoModelUntil(model, targetAltVersion) {
+    while (targetAltVersion < model.getAlternativeVersionId() && model.canUndo()) {
+        await model.undo();
+    }
+}
+function changeDecorationsAndViewZones(editor, callback) {
+    editor.changeDecorations(decorationsAccessor => {
+        editor.changeViewZones(viewZoneAccessor => {
+            callback(decorationsAccessor, viewZoneAccessor);
+        });
+    });
+}
+export { EditModeStrategy, LivePreviewStrategy, LiveStrategy, PreviewStrategy };