@codingame/monaco-vscode-chat-service-override 31.0.1 → 32.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackEditorContribution.js

@@ -0,0 +1,572 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as planReviewFeedback from './media/planReviewFeedback.css';
+import { DisposableStore, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { OverlayWidgetPositionPreference } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { registerEditorContribution, EditorContributionInstantiation } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions';
+import { EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { SelectionDirection } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { OverviewRulerLane } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { themeColorFromId } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService';
+import { overviewRulerInfo } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editorColorRegistry';
+import { createElement, getWindow, addStandardDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ActionBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { IPlanReviewFeedbackService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackService.service';
+import { PlanReviewFeedbackMenuId, navigationBearingFakeActionId, hasPlanReviewFeedback } from './planReviewFeedbackEditorActions.js';
+import { ActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(planReviewFeedback);
+class PlanReviewFeedbackInputWidget {
+    static {
+        this._ID = "planReviewFeedback.inputWidget";
+    }
+    static {
+        this._MIN_WIDTH = 150;
+    }
+    static {
+        this._MAX_WIDTH = 400;
+    }
+    constructor(_editor) {
+        this._editor = _editor;
+        this.allowEditorOverflow = false;
+        this._position = null;
+        this._lineHeight = 22;
+        this._onDidTriggerAdd = ( new Emitter());
+        this.onDidTriggerAdd = this._onDidTriggerAdd.event;
+        this._domNode = createElement("div");
+        this._domNode.classList.add("plan-review-feedback-input-widget");
+        this._domNode.style.display = "none";
+        this._inputElement = createElement("textarea");
+        this._inputElement.rows = 1;
+        this._inputElement.placeholder = ( localize(6725, "Add Feedback"));
+        this._domNode.appendChild(this._inputElement);
+        this._measureElement = createElement("span");
+        this._measureElement.classList.add("plan-review-feedback-input-measure");
+        this._domNode.appendChild(this._measureElement);
+        const actionsContainer = createElement("div");
+        actionsContainer.classList.add("plan-review-feedback-input-actions");
+        this._domNode.appendChild(actionsContainer);
+        this._addAction = ( new Action("planReviewFeedback.add", ( localize(6726, "Add Feedback (Enter)")), ThemeIcon.asClassName(Codicon.plus), false, () => {
+            this._onDidTriggerAdd.fire();
+            return Promise.resolve();
+        }));
+        this._actionBar = ( new ActionBar(actionsContainer));
+        this._actionBar.push(this._addAction, {
+            icon: true,
+            label: false,
+            keybinding: ( localize(6727, "Enter"))
+        });
+        this._inputElement.style.lineHeight = `${this._lineHeight}px`;
+    }
+    getId() {
+        return PlanReviewFeedbackInputWidget._ID;
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    getPosition() {
+        return this._position;
+    }
+    get inputElement() {
+        return this._inputElement;
+    }
+    setPosition(position) {
+        this._position = position;
+        this._editor.layoutOverlayWidget(this);
+    }
+    show() {
+        this._domNode.style.display = "";
+    }
+    hide() {
+        this._domNode.style.display = "none";
+    }
+    clearInput() {
+        this._inputElement.value = "";
+        this._updateActionEnabled();
+        this._autoSize();
+    }
+    autoSize() {
+        this._autoSize();
+    }
+    updateActionEnabled() {
+        this._updateActionEnabled();
+    }
+    _updateActionEnabled() {
+        const hasText = this._inputElement.value.trim().length > 0;
+        this._addAction.enabled = hasText;
+    }
+    _autoSize() {
+        const text = this._inputElement.value || this._inputElement.placeholder;
+        this._measureElement.textContent = text;
+        const textWidth = this._measureElement.scrollWidth;
+        const width = Math.max(
+            PlanReviewFeedbackInputWidget._MIN_WIDTH,
+            Math.min(textWidth + 10, PlanReviewFeedbackInputWidget._MAX_WIDTH)
+        );
+        this._inputElement.style.width = `${width}px`;
+        this._inputElement.style.height = "auto";
+        const newHeight = Math.max(this._inputElement.scrollHeight, this._lineHeight);
+        this._inputElement.style.height = `${newHeight}px`;
+    }
+    dispose() {
+        this._actionBar.dispose();
+        this._addAction.dispose();
+        this._onDidTriggerAdd.dispose();
+    }
+}
+class PlanReviewFeedbackOverlayWidget {
+    static {
+        this._ID = "planReviewFeedback.overlayWidget";
+    }
+    constructor(_codeEditor, _instaService) {
+        this._instaService = _instaService;
+        this._showStore = ( new DisposableStore());
+        this._navigationBearings = observableValue("planReviewFeedbackBearings", {
+            activeIdx: -1,
+            totalCount: 0
+        });
+        this._domNode = createElement("div");
+        this._domNode.classList.add("plan-review-feedback-overlay-widget");
+        this._domNode.style.display = "none";
+        this._toolbarNode = createElement("div");
+        this._toolbarNode.classList.add("plan-review-feedback-overlay-toolbar");
+        this._domNode.appendChild(this._toolbarNode);
+    }
+    getId() {
+        return PlanReviewFeedbackOverlayWidget._ID;
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    getPosition() {
+        return {
+            preference: OverlayWidgetPositionPreference.BOTTOM_RIGHT_CORNER
+        };
+    }
+    show(navigationBearings) {
+        this._showStore.clear();
+        this._navigationBearings.set(navigationBearings, undefined);
+        this._domNode.style.display = "";
+        this._showStore.add(
+            this._instaService.createInstance(MenuWorkbenchToolBar, this._toolbarNode, PlanReviewFeedbackMenuId, {
+                telemetrySource: "planReviewFeedback.overlayToolbar",
+                hiddenItemStrategy: HiddenItemStrategy.Ignore,
+                toolbarOptions: {
+                    primaryGroup: () => true,
+                    useSeparatorsInPrimaryActions: true
+                },
+                menuOptions: {
+                    renderShortTitle: true
+                },
+                actionViewItemProvider: (action, options) => {
+                    if (action.id === navigationBearingFakeActionId) {
+                        const that = this;
+                        return new (class extends ActionViewItem {
+                            constructor() {
+                                super(undefined, action, {
+                                    ...options,
+                                    icon: false,
+                                    label: true,
+                                    keybindingNotRenderedWithLabel: true
+                                });
+                            }
+                            render(container) {
+                                super.render(container);
+                                container.classList.add("label-item");
+                                this._store.add(autorun(r => {
+                                    if (!this.label) {
+                                        return;
+                                    }
+                                    const {
+                                        activeIdx,
+                                        totalCount
+                                    } = that._navigationBearings.read(r);
+                                    if (totalCount > 0) {
+                                        const current = activeIdx === -1 ? 1 : activeIdx + 1;
+                                        this.label.innerText = ( localize(6728, "{0}/{1}", current, totalCount));
+                                    } else {
+                                        this.label.innerText = ( localize(6729, "0/0"));
+                                    }
+                                }));
+                            }
+                        })();
+                    }
+                    return ( new ActionViewItem(undefined, action, {
+                        ...options,
+                        icon: true,
+                        label: false,
+                        keybindingNotRenderedWithLabel: true
+                    }));
+                }
+            })
+        );
+    }
+    hide() {
+        this._showStore.clear();
+        this._domNode.style.display = "none";
+        this._navigationBearings.set({
+            activeIdx: -1,
+            totalCount: 0
+        }, undefined);
+    }
+    dispose() {
+        this._showStore.dispose();
+    }
+}
+let PlanReviewFeedbackEditorContribution = class PlanReviewFeedbackEditorContribution extends Disposable {
+    static {
+        this.ID = "planReviewFeedback.editorContribution";
+    }
+    constructor(
+        _editor,
+        _planReviewFeedbackService,
+        contextKeyService,
+        _instantiationService
+    ) {
+        super();
+        this._editor = _editor;
+        this._planReviewFeedbackService = _planReviewFeedbackService;
+        this._instantiationService = _instantiationService;
+        this._visible = false;
+        this._mouseDown = false;
+        this._suppressSelectionChangeOnce = false;
+        this._isActivePlan = false;
+        this._widgetListeners = this._register(( new DisposableStore()));
+        this._decorations = this._editor.createDecorationsCollection();
+        this._hasFeedbackContextKey = hasPlanReviewFeedback.bindTo(contextKeyService);
+        this._register(this._editor.onDidChangeCursorSelection(() => this._onSelectionChanged()));
+        this._register(this._editor.onDidChangeModel(() => this._onModelChanged()));
+        this._register(this._editor.onDidScrollChange(() => {
+            if (this._visible) {
+                this._updatePosition();
+            }
+        }));
+        this._register(this._editor.onMouseDown(e => {
+            if (this._isWidgetTarget(e.event.target)) {
+                return;
+            }
+            this._mouseDown = true;
+            this._hide();
+        }));
+        this._register(this._editor.onMouseUp(e => {
+            this._mouseDown = false;
+            if (this._isWidgetTarget(e.event.target)) {
+                return;
+            }
+            this._onSelectionChanged();
+        }));
+        this._register(this._editor.onDidBlurEditorWidget(() => {
+            if (!this._visible) {
+                return;
+            }
+            getWindow(this._editor.getDomNode()).setTimeout(() => {
+                if (!this._visible) {
+                    return;
+                }
+                if (this._isWidgetTarget(getWindow(this._editor.getDomNode()).document.activeElement)) {
+                    return;
+                }
+                this._hide();
+            }, 0);
+        }));
+        this._register(this._editor.onDidFocusEditorText(() => this._onSelectionChanged()));
+        this._register(
+            this._planReviewFeedbackService.onDidChangeRegistrations(() => this._onModelChanged())
+        );
+        this._register(
+            this._planReviewFeedbackService.onDidChangeFeedback(() => this._updateDecorations())
+        );
+        this._register(
+            this._planReviewFeedbackService.onDidChangeNavigation(() => this._updateDecorations())
+        );
+        this._onModelChanged();
+    }
+    _isWidgetTarget(target) {
+        return !!this._widget && !!target && this._widget.getDomNode().contains(target);
+    }
+    _ensureWidget() {
+        if (!this._widget) {
+            this._widget = ( new PlanReviewFeedbackInputWidget(this._editor));
+            this._register(this._widget.onDidTriggerAdd(() => this._addFeedback()));
+            this._editor.addOverlayWidget(this._widget);
+        }
+        return this._widget;
+    }
+    _onModelChanged() {
+        this._hide();
+        this._suppressSelectionChangeOnce = false;
+        const model = this._editor.getModel();
+        this._isActivePlan = !!model && this._planReviewFeedbackService.isActivePlanReview(model.uri);
+        this._updateDecorations();
+    }
+    _onSelectionChanged() {
+        if (this._suppressSelectionChangeOnce) {
+            this._suppressSelectionChangeOnce = false;
+            return;
+        }
+        if (this._mouseDown || !this._editor.hasTextFocus()) {
+            return;
+        }
+        if (!this._isActivePlan) {
+            this._hide();
+            return;
+        }
+        const selection = this._editor.getSelection();
+        if (!selection) {
+            this._hide();
+            return;
+        }
+        const model = this._editor.getModel();
+        if (!model) {
+            this._hide();
+            return;
+        }
+        this._show();
+    }
+    _show() {
+        const widget = this._ensureWidget();
+        const wasVisible = this._visible;
+        if (!wasVisible) {
+            this._visible = true;
+            this._registerWidgetListeners(widget);
+            widget.clearInput();
+        }
+        widget.show();
+        this._updatePosition();
+    }
+    _hide() {
+        if (!this._visible) {
+            return;
+        }
+        this._visible = false;
+        this._widgetListeners.clear();
+        if (this._widget) {
+            this._widget.hide();
+            this._widget.setPosition(null);
+            this._widget.clearInput();
+        }
+    }
+    _registerWidgetListeners(widget) {
+        this._widgetListeners.clear();
+        const editorDomNode = this._editor.getDomNode();
+        if (editorDomNode) {
+            this._widgetListeners.add(addStandardDisposableListener(editorDomNode, "keydown", e => {
+                if (!this._visible) {
+                    return;
+                }
+                if (!this._editor.hasTextFocus()) {
+                    return;
+                }
+                if (e.keyCode === KeyCode.Ctrl || e.keyCode === KeyCode.Shift || e.keyCode === KeyCode.Alt || e.keyCode === KeyCode.Meta) {
+                    return;
+                }
+                if (e.keyCode === KeyCode.Escape) {
+                    this._hide();
+                    this._editor.focus();
+                    return;
+                }
+                if ((e.ctrlKey || e.metaKey) && e.keyCode === KeyCode.KeyI) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    widget.inputElement.focus();
+                    return;
+                }
+                if (e.ctrlKey || e.altKey || e.metaKey) {
+                    return;
+                }
+                if (e.keyCode === KeyCode.UpArrow || e.keyCode === KeyCode.DownArrow || e.keyCode === KeyCode.LeftArrow || e.keyCode === KeyCode.RightArrow) {
+                    return;
+                }
+                if (!this._editor.getOption(EditorOption.readOnly)) {
+                    return;
+                }
+                if (getWindow(widget.inputElement).document.activeElement !== widget.inputElement) {
+                    widget.inputElement.focus();
+                }
+            }));
+        }
+        this._widgetListeners.add(addStandardDisposableListener(widget.inputElement, "keydown", e => {
+            if (e.keyCode === KeyCode.Escape) {
+                e.preventDefault();
+                e.stopPropagation();
+                this._hide();
+                this._editor.focus();
+                return;
+            }
+            if (e.keyCode === KeyCode.Enter && !e.shiftKey) {
+                e.preventDefault();
+                e.stopPropagation();
+                this._addFeedback();
+                return;
+            }
+        }));
+        this._widgetListeners.add(addStandardDisposableListener(widget.inputElement, "keypress", e => {
+            e.stopPropagation();
+        }));
+        this._widgetListeners.add(addStandardDisposableListener(widget.inputElement, "input", () => {
+            widget.autoSize();
+            widget.updateActionEnabled();
+            this._updatePosition();
+        }));
+        this._widgetListeners.add(addStandardDisposableListener(widget.inputElement, "blur", () => {
+            const win = getWindow(widget.inputElement);
+            win.setTimeout(() => {
+                if (!this._visible) {
+                    return;
+                }
+                if (this._editor.hasWidgetFocus()) {
+                    return;
+                }
+                this._hide();
+            }, 0);
+        }));
+    }
+    _hideAndRefocusEditor() {
+        this._suppressSelectionChangeOnce = true;
+        this._hide();
+        this._editor.focus();
+    }
+    _addFeedback() {
+        if (!this._widget) {
+            return false;
+        }
+        const text = this._widget.inputElement.value.trim();
+        if (!text) {
+            return false;
+        }
+        const selection = this._editor.getSelection();
+        const model = this._editor.getModel();
+        if (!selection || !model) {
+            return false;
+        }
+        const line = selection.startLineNumber;
+        const column = selection.startColumn;
+        this._planReviewFeedbackService.addFeedback(model.uri, line, column, text);
+        this._hideAndRefocusEditor();
+        return true;
+    }
+    _updatePosition() {
+        if (!this._widget || !this._visible) {
+            return;
+        }
+        const selection = this._editor.getSelection();
+        if (!selection) {
+            this._hide();
+            return;
+        }
+        const lineHeight = this._editor.getOption(EditorOption.lineHeight);
+        const layoutInfo = this._editor.getLayoutInfo();
+        const widgetDom = this._widget.getDomNode();
+        const widgetHeight = widgetDom.offsetHeight || 30;
+        const widgetWidth = widgetDom.offsetWidth || 150;
+        const cursorPosition = selection.getDirection() === SelectionDirection.LTR ? selection.getEndPosition() : selection.getStartPosition();
+        const scrolledPosition = this._editor.getScrolledVisiblePosition(cursorPosition);
+        if (!scrolledPosition) {
+            this._widget.setPosition(null);
+            return;
+        }
+        let top;
+        if (selection.getDirection() === SelectionDirection.LTR) {
+            top = scrolledPosition.top + lineHeight;
+            if (top + widgetHeight > layoutInfo.height) {
+                top = scrolledPosition.top - widgetHeight;
+            }
+        } else {
+            top = scrolledPosition.top - widgetHeight;
+            if (top < 0) {
+                top = scrolledPosition.top + lineHeight;
+            }
+        }
+        top = Math.max(0, Math.min(top, layoutInfo.height - widgetHeight));
+        const left = Math.max(0, Math.min(scrolledPosition.left, layoutInfo.width - widgetWidth));
+        this._widget.setPosition({
+            preference: {
+                top,
+                left
+            }
+        });
+    }
+    _updateDecorations() {
+        const model = this._editor.getModel();
+        if (!model || !this._isActivePlan) {
+            this._decorations.clear();
+            this._hasFeedbackContextKey.set(false);
+            this._hideOverlayToolbar();
+            return;
+        }
+        const items = this._planReviewFeedbackService.getFeedback(model.uri);
+        this._hasFeedbackContextKey.set(items.length > 0);
+        if (items.length > 0) {
+            const bearings = this._planReviewFeedbackService.getNavigationBearing(model.uri);
+            this._showOverlayToolbar(bearings);
+        } else {
+            this._hideOverlayToolbar();
+        }
+        this._decorations.set(( items.map(item => ({
+            range: ( new Range(item.line, item.column, item.line, item.column)),
+            options: {
+                description: "plan-review-feedback",
+                glyphMarginClassName: ThemeIcon.asClassName(Codicon.comment),
+                glyphMarginHoverMessage: {
+                    value: item.text
+                },
+                overviewRuler: {
+                    color: themeColorFromId(overviewRulerInfo),
+                    position: OverviewRulerLane.Center
+                },
+                lineNumberClassName: "plan-review-feedback-line-number"
+            }
+        }))));
+    }
+    _ensureOverlayWidget() {
+        if (!this._overlayWidget) {
+            this._overlayWidget = ( new PlanReviewFeedbackOverlayWidget(this._editor, this._instantiationService));
+            this._editor.addOverlayWidget(this._overlayWidget);
+        }
+        return this._overlayWidget;
+    }
+    _showOverlayToolbar(bearings) {
+        const widget = this._ensureOverlayWidget();
+        widget.show(bearings);
+    }
+    _hideOverlayToolbar() {
+        if (this._overlayWidget) {
+            this._overlayWidget.hide();
+        }
+    }
+    dispose() {
+        if (this._widget) {
+            this._editor.removeOverlayWidget(this._widget);
+            this._widget.dispose();
+            this._widget = undefined;
+        }
+        if (this._overlayWidget) {
+            this._editor.removeOverlayWidget(this._overlayWidget);
+            this._overlayWidget.dispose();
+            this._overlayWidget = undefined;
+        }
+        super.dispose();
+    }
+};
+PlanReviewFeedbackEditorContribution = ( __decorate([( __param(1, IPlanReviewFeedbackService)), ( __param(2, IContextKeyService)), ( __param(3, IInstantiationService))], PlanReviewFeedbackEditorContribution));
+registerEditorContribution(
+    PlanReviewFeedbackEditorContribution.ID,
+    PlanReviewFeedbackEditorContribution,
+    EditorContributionInstantiation.Eventually
+);
+
+export { PlanReviewFeedbackEditorContribution };

package/vscode/src/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackService.d.ts

@@ -0,0 +1,36 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IChatPlanReviewResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { IPlanReviewFeedbackService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackService.service";
+export interface IPlanReviewFeedbackItem {
+    readonly id: string;
+    readonly line: number;
+    readonly column: number;
+    readonly text: string;
+}
+export declare class PlanReviewFeedbackService extends Disposable implements IPlanReviewFeedbackService {
+    readonly _serviceBrand: undefined;
+    private readonly _registrations;
+    private readonly _onDidChangeFeedback;
+    readonly onDidChangeFeedback: Event<URI>;
+    private readonly _onDidChangeNavigation;
+    readonly onDidChangeNavigation: Event<URI>;
+    private readonly _onDidChangeRegistrations;
+    readonly onDidChangeRegistrations: Event<void>;
+    registerPlanReview(planUri: URI, onSubmit: (result: IChatPlanReviewResult) => void): IDisposable;
+    isActivePlanReview(uri: URI): boolean;
+    addFeedback(planUri: URI, line: number, column: number, text: string): string;
+    removeFeedback(planUri: URI, feedbackId: string): void;
+    updateFeedback(planUri: URI, feedbackId: string, newText: string): void;
+    getFeedback(planUri: URI): readonly IPlanReviewFeedbackItem[];
+    clearFeedback(planUri: URI): void;
+    getNextFeedback(planUri: URI, next: boolean): IPlanReviewFeedbackItem | undefined;
+    getNavigationBearing(planUri: URI): {
+        activeIdx: number;
+        totalCount: number;
+    };
+    setNavigationAnchor(planUri: URI, itemId: string | undefined): void;
+    submitAllFeedback(planUri: URI): void;
+    private _formatFeedback;
+}