@codingame/monaco-vscode-katex-common 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingEditorOverlay.js

@@ -0,0 +1,382 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as chatEditingEditorOverlay from './media/chatEditingEditorOverlay.css';
+import { MutableDisposable, Disposable, DisposableStore, toDisposable, DisposableMap, combinedDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { addDisposableGenericMouseMoveListener, createElement, append, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AcceptAction, navigationBearingFakeActionId, RejectAction } from './chatEditingEditorActions.js';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { EditorGroupView } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorGroupView';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { EditorResourceAccessor, SideBySideEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { derived, derivedOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+registerCss(chatEditingEditorOverlay);
+class ChatEditingAcceptRejectActionViewItem extends ActionViewItem {
+    constructor(
+        action,
+        options,
+        _entry,
+        _editor,
+        _keybindingService,
+        _primaryActionIds = [AcceptAction.ID]
+    ) {
+        super(undefined, action, {
+            ...options,
+            icon: false,
+            label: true,
+            keybindingNotRenderedWithLabel: true
+        });
+        this._entry = _entry;
+        this._editor = _editor;
+        this._keybindingService = _keybindingService;
+        this._primaryActionIds = _primaryActionIds;
+        this._reveal = this._store.add(( new MutableDisposable()));
+    }
+    render(container) {
+        super.render(container);
+        if (this._primaryActionIds.includes(this._action.id)) {
+            this.element?.classList.add("primary");
+        }
+        if (this._action.id === AcceptAction.ID) {
+            const listener = this._store.add(( new MutableDisposable()));
+            this._store.add(autorun(r => {
+                assertType(this.label);
+                assertType(this.element);
+                const ctrl = this._entry.read(r)?.autoAcceptController.read(r);
+                if (ctrl) {
+                    const ratio = -100 * (ctrl.remaining / ctrl.total);
+                    this.element.style.setProperty("--vscode-action-item-auto-timeout", `${ratio}%`);
+                    this.element.classList.toggle("auto", true);
+                    listener.value = addDisposableGenericMouseMoveListener(this.element, () => ctrl.cancel());
+                } else {
+                    this.element.classList.toggle("auto", false);
+                    listener.clear();
+                }
+            }));
+        }
+    }
+    set actionRunner(actionRunner) {
+        super.actionRunner = actionRunner;
+        if (this._editor) {
+            this._reveal.value = actionRunner.onWillRun(_e => {
+                this._editor.focus();
+            });
+        }
+    }
+    get actionRunner() {
+        return super.actionRunner;
+    }
+    getTooltip() {
+        const value = super.getTooltip();
+        if (!value || this.options.keybinding) {
+            return value;
+        }
+        return this._keybindingService.appendKeybinding(value, this._action.id);
+    }
+}
+let ChatEditorOverlayWidget = class ChatEditorOverlayWidget extends Disposable {
+    constructor(_editor, _keybindingService, _instaService) {
+        super();
+        this._editor = _editor;
+        this._keybindingService = _keybindingService;
+        this._instaService = _instaService;
+        this._showStore = this._store.add(( new DisposableStore()));
+        this._session = observableValue(this, undefined);
+        this._entry = observableValue(this, undefined);
+        this._navigationBearings = observableValue(this, {
+            changeCount: -1,
+            activeIdx: -1,
+            entriesCount: -1
+        });
+        this._domNode = createElement("div");
+        this._domNode.classList.add("chat-editor-overlay-widget");
+        this._isBusy = derived(r => {
+            const entry = this._entry.read(r);
+            return entry?.waitsForLastEdits.read(r);
+        });
+        const progressNode = createElement("div");
+        progressNode.classList.add("chat-editor-overlay-progress");
+        append(progressNode, renderIcon(ThemeIcon.modify(Codicon.loading, "spin")));
+        const textProgress = append(progressNode, $("span.progress-message"));
+        this._domNode.appendChild(progressNode);
+        this._store.add(autorun(r => {
+            const busy = this._isBusy.read(r);
+            this._domNode.classList.toggle("busy", busy);
+            textProgress.innerText = "";
+        }));
+        this._toolbarNode = createElement("div");
+        this._toolbarNode.classList.add("chat-editor-overlay-toolbar");
+    }
+    dispose() {
+        this.hide();
+        super.dispose();
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    show(session, entry, indicies) {
+        this._showStore.clear();
+        transaction(tx => {
+            this._session.set(session, tx);
+            this._entry.set(entry, tx);
+        });
+        this._showStore.add(autorun(r => {
+            const entryIndex = indicies.entryIndex.read(r);
+            const changeIndex = indicies.changeIndex.read(r);
+            const entries = session.entries.read(r);
+            let activeIdx = entryIndex !== undefined && changeIndex !== undefined ? changeIndex : -1;
+            let totalChangesCount = 0;
+            for (let i = 0; i < entries.length; i++) {
+                const changesCount = entries[i].changesCount.read(r);
+                totalChangesCount += changesCount;
+                if (entryIndex !== undefined && i < entryIndex) {
+                    activeIdx += changesCount;
+                }
+            }
+            this._navigationBearings.set({
+                changeCount: totalChangesCount,
+                activeIdx,
+                entriesCount: entries.length
+            }, undefined);
+        }));
+        this._domNode.appendChild(this._toolbarNode);
+        this._showStore.add(toDisposable(() => this._toolbarNode.remove()));
+        this._showStore.add(this._instaService.createInstance(
+            MenuWorkbenchToolBar,
+            this._toolbarNode,
+            MenuId.ChatEditingEditorContent,
+            {
+                telemetrySource: "chatEditor.overlayToolbar",
+                hiddenItemStrategy: HiddenItemStrategy.Ignore,
+                toolbarOptions: {
+                    primaryGroup: () => true,
+                    useSeparatorsInPrimaryActions: true
+                },
+                menuOptions: {
+                    renderShortTitle: true
+                },
+                actionViewItemProvider: (action, options) => {
+                    const that = this;
+                    if (action.id === navigationBearingFakeActionId) {
+                        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 => {
+                                    assertType(this.label);
+                                    const {
+                                        changeCount,
+                                        activeIdx
+                                    } = that._navigationBearings.read(r);
+                                    if (changeCount > 0) {
+                                        const n = activeIdx === -1 ? "1" : `${activeIdx + 1}`;
+                                        this.label.innerText = ( localize(5315, "{0} of {1}", n, changeCount));
+                                    } else {
+                                        this.label.innerText = ( localize(5316, "—"));
+                                    }
+                                    this.updateTooltip();
+                                }));
+                            }
+                            getTooltip() {
+                                const {
+                                    changeCount,
+                                    entriesCount
+                                } = that._navigationBearings.get();
+                                if (changeCount === -1 || entriesCount === -1) {
+                                    return undefined;
+                                }
+                                let result;
+                                if (changeCount === 1 && entriesCount === 1) {
+                                    result = ( localize(5317, "1 change in 1 file"));
+                                } else if (changeCount === 1) {
+                                    result = ( localize(5318, "1 change in {0} files", entriesCount));
+                                } else if (entriesCount === 1) {
+                                    result = ( localize(5319, "{0} changes in 1 file", changeCount));
+                                } else {
+                                    result = ( localize(5320, "{0} changes in {1} files", changeCount, entriesCount));
+                                }
+                                if (!that._isBusy.get()) {
+                                    return result;
+                                }
+                                return localize(5321, "{0} - Working...", result);
+                            }
+                        })();
+                    }
+                    if (action.id === AcceptAction.ID || action.id === RejectAction.ID) {
+                        return ( new ChatEditingAcceptRejectActionViewItem(action, options, that._entry, that._editor, that._keybindingService));
+                    }
+                    return undefined;
+                }
+            }
+        ));
+    }
+    hide() {
+        transaction(tx => {
+            this._session.set(undefined, tx);
+            this._entry.set(undefined, tx);
+            this._navigationBearings.set({
+                changeCount: -1,
+                activeIdx: -1,
+                entriesCount: -1
+            }, tx);
+        });
+        this._showStore.clear();
+    }
+};
+ChatEditorOverlayWidget = ( __decorate([( __param(1, IKeybindingService)), ( __param(2, IInstantiationService))], ChatEditorOverlayWidget));
+let ChatEditingOverlayController = class ChatEditingOverlayController {
+    constructor(container, group, instaService, chatEditingService) {
+        this._store = ( new DisposableStore());
+        this._domNode = createElement("div");
+        this._domNode.classList.add("chat-editing-editor-overlay");
+        this._domNode.style.position = "absolute";
+        this._domNode.style.bottom = `24px`;
+        this._domNode.style.right = `24px`;
+        this._domNode.style.zIndex = `100`;
+        const widget = instaService.createInstance(ChatEditorOverlayWidget, group);
+        this._domNode.appendChild(widget.getDomNode());
+        this._store.add(toDisposable(() => this._domNode.remove()));
+        this._store.add(widget);
+        const show = () => {
+            if (!container.contains(this._domNode)) {
+                container.appendChild(this._domNode);
+            }
+        };
+        const hide = () => {
+            if (container.contains(this._domNode)) {
+                widget.hide();
+                this._domNode.remove();
+            }
+        };
+        const activeEditorSignal = observableSignalFromEvent(this, Event.any(group.onDidActiveEditorChange, group.onDidModelChange));
+        const activeUriObs = derivedOpts({
+            equalsFn: isEqual
+        }, r => {
+            activeEditorSignal.read(r);
+            const editor = group.activeEditorPane;
+            const uri = EditorResourceAccessor.getOriginalUri(editor?.input, {
+                supportSideBySide: SideBySideEditor.PRIMARY
+            });
+            return uri;
+        });
+        const sessionAndEntry = derived(r => {
+            activeEditorSignal.read(r);
+            const uri = activeUriObs.read(r);
+            if (!uri) {
+                return undefined;
+            }
+            for (const session of chatEditingService.editingSessionsObs.read(r)) {
+                if (!session.isGlobalEditingSession) {
+                    continue;
+                }
+                const entry = session.readEntry(uri, r);
+                if (entry) {
+                    return {
+                        session,
+                        entry
+                    };
+                }
+            }
+            return undefined;
+        });
+        this._store.add(autorun(r => {
+            const data = sessionAndEntry.read(r);
+            if (!data) {
+                hide();
+                return;
+            }
+            const {
+                session,
+                entry
+            } = data;
+            if (entry?.state.read(r) === ModifiedFileEntryState.Modified) {
+                const editorPane = group.activeEditorPane;
+                assertType(editorPane);
+                const changeIndex = derived(
+                    r => entry ? entry.getEditorIntegration(editorPane).currentIndex.read(r) : 0
+                );
+                const entryIndex = derived(r => entry ? session.entries.read(r).indexOf(entry) : 0);
+                widget.show(session, entry, {
+                    entryIndex,
+                    changeIndex
+                });
+                show();
+            } else {
+                hide();
+            }
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+    }
+};
+ChatEditingOverlayController = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IChatEditingService))], ChatEditingOverlayController));
+let ChatEditingEditorOverlay = class ChatEditingEditorOverlay {
+    static {
+        this.ID = "chat.edits.editorOverlay";
+    }
+    constructor(editorGroupsService, instantiationService) {
+        this._store = ( new DisposableStore());
+        const editorGroups = observableFromEvent(
+            this,
+            Event.any(editorGroupsService.onDidAddGroup, editorGroupsService.onDidRemoveGroup),
+            () => editorGroupsService.groups
+        );
+        const overlayWidgets = this._store.add(( new DisposableMap()));
+        this._store.add(autorun(r => {
+            const toDelete = ( new Set(( overlayWidgets.keys())));
+            const groups = editorGroups.read(r);
+            for (const group of groups) {
+                if (!(group instanceof EditorGroupView)) {
+                    continue;
+                }
+                toDelete.delete(group);
+                if (!( overlayWidgets.has(group))) {
+                    const scopedInstaService = instantiationService.createChild(( new ServiceCollection([IContextKeyService, group.scopedContextKeyService])));
+                    const container = group.element;
+                    const ctrl = scopedInstaService.createInstance(ChatEditingOverlayController, container, group);
+                    overlayWidgets.set(group, combinedDisposable(ctrl, scopedInstaService));
+                }
+            }
+            for (const group of toDelete) {
+                overlayWidgets.deleteAndDispose(group);
+            }
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+    }
+};
+ChatEditingEditorOverlay = ( __decorate([( __param(0, IEditorGroupsService)), ( __param(1, IInstantiationService))], ChatEditingEditorOverlay));
+
+export { ChatEditingAcceptRejectActionViewItem, ChatEditingEditorOverlay };

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingExplanationWidget.d.ts

@@ -0,0 +1,101 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICodeEditor, IOverlayWidget, IOverlayWidgetPosition } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { DetailedLineRangeMapping, LineRangeMapping } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/rangeMapping";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IViewsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service";
+import { IExplanationDiffInfo } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingExplanationModelManager";
+import { IChatEditingExplanationModelManager } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingExplanationModelManager.service";
+/**
+ * Widget that displays explanatory comments for chat-made changes
+ * Positioned on the right side of the editor like a speech bubble
+ */
+export declare class ChatEditingExplanationWidget extends Disposable implements IOverlayWidget {
+    private readonly _editor;
+    private _changes;
+    private readonly _chatWidgetService;
+    private readonly _viewsService;
+    private readonly _chatSessionResource?;
+    private static _idPool;
+    private readonly _id;
+    private readonly _domNode;
+    private readonly _headerNode;
+    private readonly _readIndicator;
+    private readonly _titleNode;
+    private readonly _dismissButton;
+    private readonly _toggleButton;
+    private readonly _bodyNode;
+    private readonly _explanationItems;
+    private _position;
+    private _explanations;
+    private _isExpanded;
+    private _isAllRead;
+    private _disposed;
+    private _startLineNumber;
+    private readonly _uri;
+    private readonly _rangeHighlightDecoration;
+    private readonly _eventStore;
+    constructor(_editor: ICodeEditor, _changes: readonly (LineRangeMapping | DetailedLineRangeMapping)[], diffInfo: IExplanationDiffInfo, _chatWidgetService: IChatWidgetService, _viewsService: IViewsService, _chatSessionResource?: URI | undefined);
+    private _setupEventHandlers;
+    private _toggleExpanded;
+    private _dismiss;
+    private _updateReadIndicator;
+    private _updateTitle;
+    private _updateToggleButton;
+    private _buildExplanationItems;
+    /**
+     * Sets the explanation for a change matching the given line number range.
+     * @returns true if a matching explanation was found and updated
+     */
+    setExplanationByLineNumber(startLineNumber: number, endLineNumber: number, explanation: string): boolean;
+    /**
+     * Gets the number of explanations in this widget.
+     */
+    get explanationCount(): number;
+    private _updateExplanationText;
+    private _updateItemReadIndicator;
+    private _updateExplanationItemsReadState;
+    /**
+     * Updates the widget position and layout
+     */
+    layout(startLineNumber: number): void;
+    /**
+     * Shows or hides the widget
+     */
+    toggle(show: boolean): void;
+    /**
+     * Relayouts the widget at its current line number
+     */
+    relayout(): void;
+    getId(): string;
+    getDomNode(): HTMLElement;
+    getPosition(): IOverlayWidgetPosition | null;
+    dispose(): void;
+}
+/**
+ * Manager for explanation widgets in an editor
+ * Groups changes and creates combined widgets for nearby changes
+ */
+export declare class ChatEditingExplanationWidgetManager extends Disposable {
+    private readonly _editor;
+    private readonly _chatWidgetService;
+    private readonly _viewsService;
+    private readonly _modelUri;
+    private readonly _widgets;
+    private _visible;
+    private _chatSessionResource;
+    private _diffInfo;
+    constructor(_editor: ICodeEditor, _chatWidgetService: IChatWidgetService, _viewsService: IViewsService, modelManager: IChatEditingExplanationModelManager, _modelUri: URI);
+    private _createWidgets;
+    private _handleExplanations;
+    /**
+     * Shows all widgets
+     */
+    show(): void;
+    /**
+     * Hides all widgets
+     */
+    hide(): void;
+    private _clearWidgets;
+    dispose(): void;
+}