@codingame/monaco-vscode-chat-service-override 10.1.3 → 11.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditorActions.js

@@ -0,0 +1,109 @@
+import { isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
+import { localize2 } from 'vscode/vscode/vs/nls';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { Action2, MenuId, registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { CHAT_CATEGORY } from '@codingame/monaco-vscode-chat-extensions-interactive-notebook-quickaccess-search-terminal-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ctxHasEditorModification, ChatEditorController } from './chatEditorController.js';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IChatEditingService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
+
+class NavigateAction extends Action2 {
+    constructor(next) {
+        super({
+            id: next
+                ? 'chatEditor.action.navigateNext'
+                : 'chatEditor.action.navigatePrevious',
+            title: next
+                ? ( localize2(7588, 'Go to Next Chat Edit'))
+                : ( localize2(7589, 'Go to Previous Chat Edit')),
+            category: CHAT_CATEGORY,
+            icon: next ? Codicon.arrowDown : Codicon.arrowUp,
+            keybinding: {
+                primary: next
+                    ? 512  | 63
+                    : 512  | 1024  | 63 ,
+                weight: 100 ,
+                when: ( (ContextKeyExpr.and(ctxHasEditorModification, EditorContextKeys.focus))),
+            },
+            f1: true,
+            menu: {
+                id: MenuId.EditorTitle,
+                group: 'navigation',
+                order: next ? -100 : -101,
+                when: ctxHasEditorModification
+            }
+        });
+        this.next = next;
+    }
+    run(accessor) {
+        const editor = accessor.get(IEditorService).activeTextEditorControl;
+        if (!isCodeEditor(editor)) {
+            return;
+        }
+        if (this.next) {
+            ChatEditorController.get(editor)?.revealNext();
+        }
+        else {
+            ChatEditorController.get(editor)?.revealPrevious();
+        }
+    }
+}
+class AcceptDiscardAction extends Action2 {
+    constructor(accept) {
+        super({
+            id: accept
+                ? 'chatEditor.action.accept'
+                : 'chatEditor.action.reject',
+            title: accept
+                ? ( localize2(7590, 'Accept Chat Edit'))
+                : ( localize2(7591, 'Reject Chat Edit')),
+            category: CHAT_CATEGORY,
+            icon: accept
+                ? Codicon.check
+                : Codicon.discard,
+            menu: {
+                id: MenuId.EditorTitle,
+                group: 'navigation',
+                order: accept ? -103 : -102,
+                when: ctxHasEditorModification
+            }
+        });
+        this.accept = accept;
+    }
+    run(accessor) {
+        const chatEditingService = accessor.get(IChatEditingService);
+        const editorService = accessor.get(IEditorService);
+        const editor = editorService.activeTextEditorControl;
+        if (!isCodeEditor(editor) || !editor.hasModel()) {
+            return;
+        }
+        const session = chatEditingService.getEditingSession(editor.getModel().uri);
+        if (!session) {
+            return;
+        }
+        if (this.accept) {
+            session.accept(editor.getModel().uri);
+        }
+        else {
+            session.reject(editor.getModel().uri);
+        }
+    }
+}
+function registerChatEditorActions() {
+    registerAction2(class NextAction extends NavigateAction {
+        constructor() { super(true); }
+    });
+    registerAction2(class PrevAction extends NavigateAction {
+        constructor() { super(false); }
+    });
+    registerAction2(class AcceptAction extends AcceptDiscardAction {
+        constructor() { super(true); }
+    });
+    registerAction2(class RejectAction extends AcceptDiscardAction {
+        constructor() { super(false); }
+    });
+}
+
+export { registerChatEditorActions };

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditorController.js

@@ -0,0 +1,284 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { coalesceInPlace, binarySearch } from 'vscode/vscode/vs/base/common/arrays';
+import { Disposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import 'vscode/vscode/vs/base/common/event';
+import { autorun } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
+import { derived } from 'vscode/vscode/vs/base/common/observableInternal/derived';
+import 'vscode/vscode/vs/base/common/cancellation';
+import 'vscode/vscode/vs/base/common/observableInternal/utils';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { themeColorFromId } from 'vscode/vscode/vs/base/common/themables';
+import { RenderOptions, LineSource, renderLines } from 'vscode/vscode/vs/editor/browser/widget/diffEditor/components/diffEditorViewZones/renderLines';
+import { diffAddDecoration, diffWholeLineAddDecoration, diffDeleteDecoration } from 'vscode/vscode/vs/editor/browser/widget/diffEditor/registrations.contribution';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { OverviewRulerLane } from 'vscode/vscode/vs/editor/common/model';
+import { ModelDecorationOptions } from 'vscode/vscode/vs/editor/common/model/textModel';
+import { InlineDecoration } from 'vscode/vscode/vs/editor/common/viewModel';
+import { localize } from 'vscode/vscode/vs/nls';
+import { RawContextKey } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { overviewRulerModifiedForeground, minimapGutterModifiedBackground, overviewRulerAddedForeground, minimapGutterAddedBackground, overviewRulerDeletedForeground, minimapGutterDeletedBackground } from 'vscode/vscode/vs/workbench/contrib/scm/browser/dirtydiffDecorator';
+import { IChatEditingService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
+
+var ChatEditorController_1;
+const ctxHasEditorModification = ( (new RawContextKey('chat.hasEditorModifications', undefined, ( localize(7592, "The current editor contains chat modifications")))));
+let ChatEditorController = class ChatEditorController extends Disposable {
+    static { ChatEditorController_1 = this; }
+    static { this.ID = 'editor.contrib.chatEditorController'; }
+    static get(editor) {
+        const controller = editor.getContribution(ChatEditorController_1.ID);
+        return controller;
+    }
+    constructor(_editor, _chatEditingService, contextKeyService) {
+        super();
+        this._editor = _editor;
+        this._chatEditingService = _chatEditingService;
+        this._sessionStore = this._register(( (new DisposableStore())));
+        this._decorations = this._editor.createDecorationsCollection();
+        this._viewZones = [];
+        this._register(this._editor.onDidChangeModel(() => this._update()));
+        this._register(this._chatEditingService.onDidChangeEditingSession(() => this._updateSessionDecorations()));
+        this._register(toDisposable(() => this._clearRendering()));
+        this._ctxHasEditorModification = ctxHasEditorModification.bindTo(contextKeyService);
+        this._register(autorun(r => {
+            if (this._editor.getOption(63 )) {
+                return;
+            }
+            const session = this._chatEditingService.currentEditingSessionObs.read(r);
+            const entry = session?.entries.read(r).find(e => isEqual(e.modifiedURI, this._editor.getModel()?.uri));
+            if (!entry || entry.state.read(r) !== 0 ) {
+                this._clearRendering();
+                return;
+            }
+            const diff = entry?.diffInfo.read(r);
+            this._updateWithDiff(entry, diff);
+        }));
+        const shouldBeReadOnly = derived(this, r => {
+            const value = this._chatEditingService.currentEditingSessionObs.read(r);
+            if (!value || value.state.read(r) !== 1 ) {
+                return false;
+            }
+            return (
+                 (value.entries.read(r).some(e => isEqual(e.modifiedURI, this._editor.getModel()?.uri)))
+            );
+        });
+        let actualReadonly;
+        let actualDeco;
+        this._register(autorun(r => {
+            const value = shouldBeReadOnly.read(r);
+            if (value) {
+                actualReadonly ??= this._editor.getOption(94 );
+                actualDeco ??= this._editor.getOption(101 );
+                this._editor.updateOptions({
+                    readOnly: true,
+                    renderValidationDecorations: 'off'
+                });
+            }
+            else {
+                if (actualReadonly !== undefined && actualDeco !== undefined) {
+                    this._editor.updateOptions({
+                        readOnly: actualReadonly,
+                        renderValidationDecorations: actualDeco
+                    });
+                    actualReadonly = undefined;
+                    actualDeco = undefined;
+                }
+            }
+        }));
+    }
+    dispose() {
+        this._clearRendering();
+        super.dispose();
+    }
+    _update() {
+        this._sessionStore.clear();
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        if (this._editor.getOption(63 )) {
+            return;
+        }
+        if (this._editor.getOption(63 )) {
+            this._clearRendering();
+            return;
+        }
+        this._updateSessionDecorations();
+    }
+    _updateSessionDecorations() {
+        if (!this._editor.hasModel()) {
+            this._clearRendering();
+            return;
+        }
+        const model = this._editor.getModel();
+        const editingSession = this._chatEditingService.getEditingSession(model.uri);
+        const entry = this._getEntry(editingSession, model);
+        if (!entry || entry.state.get() !== 0 ) {
+            this._clearRendering();
+            return;
+        }
+        const diff = entry.diffInfo.get();
+        this._updateWithDiff(entry, diff);
+    }
+    _getEntry(editingSession, model) {
+        if (!editingSession) {
+            return null;
+        }
+        return editingSession.entries.get().find(e => ( (e.modifiedURI.toString())) === ( (model.uri.toString()))) || null;
+    }
+    _clearRendering() {
+        this._editor.changeViewZones((viewZoneChangeAccessor) => {
+            for (const id of this._viewZones) {
+                viewZoneChangeAccessor.removeZone(id);
+            }
+        });
+        this._viewZones = [];
+        this._decorations.clear();
+        this._ctxHasEditorModification.reset();
+    }
+    _updateWithDiff(entry, diff) {
+        if (!diff) {
+            this._clearRendering();
+            return;
+        }
+        this._ctxHasEditorModification.set(true);
+        const originalModel = entry.originalModel;
+        const chatDiffAddDecoration = ModelDecorationOptions.createDynamic({
+            ...diffAddDecoration,
+            stickiness: 1
+        });
+        const chatDiffWholeLineAddDecoration = ModelDecorationOptions.createDynamic({
+            ...diffWholeLineAddDecoration,
+            stickiness: 1 ,
+        });
+        const createOverviewDecoration = (overviewRulerColor, minimapColor) => {
+            return ModelDecorationOptions.createDynamic({
+                description: 'chat-editing-decoration',
+                overviewRuler: { color: themeColorFromId(overviewRulerColor), position: OverviewRulerLane.Left },
+                minimap: { color: themeColorFromId(minimapColor), position: 2  },
+            });
+        };
+        const modifiedDecoration = createOverviewDecoration(overviewRulerModifiedForeground, minimapGutterModifiedBackground);
+        const addedDecoration = createOverviewDecoration(overviewRulerAddedForeground, minimapGutterAddedBackground);
+        const deletedDecoration = createOverviewDecoration(overviewRulerDeletedForeground, minimapGutterDeletedBackground);
+        this._editor.changeViewZones((viewZoneChangeAccessor) => {
+            for (const id of this._viewZones) {
+                viewZoneChangeAccessor.removeZone(id);
+            }
+            this._viewZones = [];
+            const modifiedDecorations = [];
+            const mightContainNonBasicASCII = originalModel.mightContainNonBasicASCII();
+            const mightContainRTL = originalModel.mightContainRTL();
+            const renderOptions = RenderOptions.fromEditor(this._editor);
+            for (const diffEntry of diff.changes) {
+                const originalRange = diffEntry.original;
+                originalModel.tokenization.forceTokenization(Math.max(1, originalRange.endLineNumberExclusive - 1));
+                const source = ( (new LineSource(
+                    originalRange.mapToLineArray(l => originalModel.tokenization.getLineTokens(l)),
+                    [],
+                    mightContainNonBasicASCII,
+                    mightContainRTL
+                )));
+                const decorations = [];
+                for (const i of diffEntry.innerChanges || []) {
+                    decorations.push(( (new InlineDecoration(
+                        i.originalRange.delta(-(diffEntry.original.startLineNumber - 1)),
+                        diffDeleteDecoration.className,
+                        0
+                    ))));
+                    modifiedDecorations.push({
+                        range: i.modifiedRange, options: chatDiffAddDecoration
+                    });
+                }
+                if (!diffEntry.modified.isEmpty) {
+                    modifiedDecorations.push({
+                        range: diffEntry.modified.toInclusiveRange(), options: chatDiffWholeLineAddDecoration
+                    });
+                }
+                if (diffEntry.original.isEmpty) {
+                    modifiedDecorations.push({
+                        range: diffEntry.modified.toInclusiveRange(),
+                        options: addedDecoration
+                    });
+                }
+                else if (diffEntry.modified.isEmpty) {
+                    modifiedDecorations.push({
+                        range: ( (new Range(
+                            diffEntry.modified.startLineNumber,
+                            1,
+                            diffEntry.modified.startLineNumber,
+                            1
+                        ))),
+                        options: deletedDecoration
+                    });
+                }
+                else {
+                    modifiedDecorations.push({
+                        range: diffEntry.modified.toInclusiveRange(),
+                        options: modifiedDecoration
+                    });
+                }
+                const domNode = document.createElement('div');
+                domNode.className = 'chat-editing-original-zone view-lines line-delete monaco-mouse-cursor-text';
+                const result = renderLines(source, renderOptions, decorations, domNode);
+                const viewZoneData = {
+                    afterLineNumber: diffEntry.modified.startLineNumber - 1,
+                    heightInLines: result.heightInLines,
+                    domNode,
+                    ordinal: 50000 + 2
+                };
+                this._viewZones.push(viewZoneChangeAccessor.addZone(viewZoneData));
+            }
+            this._decorations.set(modifiedDecorations);
+        });
+    }
+    revealNext() {
+        this._reveal(true);
+    }
+    revealPrevious() {
+        this._reveal(false);
+    }
+    _reveal(next) {
+        const position = this._editor.getPosition();
+        if (!position) {
+            return;
+        }
+        const decorations = this._decorations
+            .getRanges()
+            .sort((a, b) => Range.compareRangesUsingStarts(a, b));
+        for (let i = 0; i < decorations.length; i++) {
+            const decoration = decorations[i];
+            for (let j = 0; j < decorations.length; j++) {
+                if (i !== j && decoration && decorations[j]?.containsRange(decoration)) {
+                    decorations[i] = undefined;
+                    break;
+                }
+            }
+        }
+        coalesceInPlace(decorations);
+        if (decorations.length === 0) {
+            return;
+        }
+        let idx = binarySearch(decorations, Range.fromPositions(position), Range.compareRangesUsingStarts);
+        if (idx < 0) {
+            idx = ~idx;
+        }
+        let target;
+        if (decorations[idx]?.containsPosition(position)) {
+            target = idx + (next ? 1 : -1);
+        }
+        else {
+            target = next ? idx : idx - 1;
+        }
+        target = (target + decorations.length) % decorations.length;
+        const targetPosition = decorations[target].getStartPosition();
+        this._editor.setPosition(targetPosition);
+        this._editor.revealPositionInCenter(targetPosition, 0 );
+        this._editor.focus();
+    }
+};
+ChatEditorController = ChatEditorController_1 = ( (__decorate([
+    ( (__param(1, IChatEditingService))),
+    ( (__param(2, IContextKeyService)))
+], ChatEditorController)));
+
+export { ChatEditorController, ctxHasEditorModification };