@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,52 @@
+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 { ContextKeyExpression } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { BrandedService, IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+/**
+ * A widget that can be rendered on top of the chat input part.
+ */
+export interface IChatInputPartWidget extends IDisposable {
+    /**
+     * The DOM node of the widget.
+     */
+    readonly domNode: HTMLElement;
+    /**
+     * Fired when the height of the widget changes.
+     */
+    readonly onDidChangeHeight: Event<void>;
+    /**
+     * The current height of the widget in pixels.
+     */
+    readonly height: number;
+}
+export interface IChatInputPartWidgetDescriptor<Services extends BrandedService[] = BrandedService[]> {
+    readonly id: string;
+    readonly when?: ContextKeyExpression;
+    readonly ctor: new (...services: Services) => IChatInputPartWidget;
+}
+/**
+ * Registry for chat input part widgets.
+ * Widgets register themselves and are instantiated by the controller based on context key conditions.
+ */
+export declare const ChatInputPartWidgetsRegistry: {
+    readonly widgets: IChatInputPartWidgetDescriptor[];
+    register<Services extends BrandedService[]>(id: string, ctor: new (...services: Services) => IChatInputPartWidget, when?: ContextKeyExpression): void;
+    getWidgets(): readonly IChatInputPartWidgetDescriptor[];
+};
+/**
+ * Controller that manages the rendering of widgets in the chat input part.
+ * Widgets are shown/hidden based on context key conditions.
+ */
+export declare class ChatInputPartWidgetController extends Disposable {
+    private readonly container;
+    private readonly contextKeyService;
+    private readonly instantiationService;
+    private readonly _onDidChangeHeight;
+    readonly onDidChangeHeight: Event<void>;
+    private readonly renderedWidgets;
+    constructor(container: HTMLElement, contextKeyService: IContextKeyService, instantiationService: IInstantiationService);
+    private update;
+    get height(): number;
+    dispose(): void;
+}

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

@@ -0,0 +1,93 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+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';
+
+const ChatInputPartWidgetsRegistry = new (class {
+    constructor() {
+        this.widgets = [];
+    }
+    register(id, ctor, when) {
+        this.widgets.push({ id, ctor: ctor, when });
+    }
+    getWidgets() {
+        return this.widgets;
+    }
+})();
+let ChatInputPartWidgetController = class ChatInputPartWidgetController extends Disposable {
+    constructor(container, contextKeyService, instantiationService) {
+        super();
+        this.container = container;
+        this.contextKeyService = contextKeyService;
+        this.instantiationService = instantiationService;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this.renderedWidgets = ( new Map());
+        this.update();
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            const relevantKeys = ( new Set());
+            for (const descriptor of ChatInputPartWidgetsRegistry.getWidgets()) {
+                if (descriptor.when) {
+                    for (const key of ( descriptor.when.keys())) {
+                        relevantKeys.add(key);
+                    }
+                }
+            }
+            if (e.affectsSome(relevantKeys)) {
+                this.update();
+            }
+        }));
+    }
+    update() {
+        const visibleIds = ( new Set());
+        for (const descriptor of ChatInputPartWidgetsRegistry.getWidgets()) {
+            if (this.contextKeyService.contextMatchesRules(descriptor.when)) {
+                visibleIds.add(descriptor.id);
+            }
+        }
+        for (const [id, rendered] of this.renderedWidgets) {
+            if (!( visibleIds.has(id))) {
+                rendered.widget.domNode.remove();
+                rendered.disposables.dispose();
+                this.renderedWidgets.delete(id);
+            }
+        }
+        for (const descriptor of ChatInputPartWidgetsRegistry.getWidgets()) {
+            if (!( visibleIds.has(descriptor.id))) {
+                continue;
+            }
+            if (!( this.renderedWidgets.has(descriptor.id))) {
+                const disposables = ( new DisposableStore());
+                const widget = this.instantiationService.createInstance(descriptor.ctor);
+                disposables.add(widget);
+                disposables.add(widget.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+                this.renderedWidgets.set(descriptor.id, { descriptor, widget, disposables });
+                this.container.appendChild(widget.domNode);
+            }
+        }
+        this._onDidChangeHeight.fire();
+    }
+    get height() {
+        let total = 0;
+        for (const rendered of ( this.renderedWidgets.values())) {
+            total += rendered.widget.height;
+        }
+        return total;
+    }
+    dispose() {
+        for (const rendered of ( this.renderedWidgets.values())) {
+            rendered.widget.domNode.remove();
+            rendered.disposables.dispose();
+        }
+        this.renderedWidgets.clear();
+        super.dispose();
+    }
+};
+ChatInputPartWidgetController = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IInstantiationService))
+], ChatInputPartWidgetController));
+
+export { ChatInputPartWidgetController, ChatInputPartWidgetsRegistry };

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

@@ -0,0 +1,217 @@
+import { DropdownMenuActionViewItem, IDropdownMenuActionViewItemOptions } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/dropdown/dropdownActionViewItem";
+import { IListElementRenderDetails, IListVirtualDelegate } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/list";
+import { ITreeNode, ITreeRenderer } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/tree/tree";
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { FuzzyScore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/filters";
+import { Disposable, DisposableStore, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { MenuWorkbenchToolBar } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { IWorkbenchIssueService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/issue/common/issue.service";
+import { IChatFollowup, IChatThinkingPart } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IChatResponseViewModel, IChatViewModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel";
+import { CodeBlockModelCollection } from "../common/codeBlockModelCollection.js";
+import { ChatModeKind } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { ChatTreeItem, IChatCodeBlockInfo, IChatFileTreeInfo, IChatListItemRendererOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { ChatAgentHover } from "./chatAgentHover.js";
+import { IChatContentPart, IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatContentParts";
+import { ChatEditorOptions } from "./chatOptions.js";
+import { CodeBlockPart } from "./codeBlockPart.js";
+export interface IChatListItemTemplate {
+    currentElement?: ChatTreeItem;
+    /**
+     * The parts that are currently rendered in the template. Note that these are purposely not added to elementDisposables-
+     * they are disposed in a separate cycle after diffing with the next content to render.
+     */
+    renderedParts?: IChatContentPart[];
+    readonly rowContainer: HTMLElement;
+    readonly titleToolbar?: MenuWorkbenchToolBar;
+    readonly header?: HTMLElement;
+    readonly footerToolbar: MenuWorkbenchToolBar;
+    readonly footerDetailsContainer: HTMLElement;
+    readonly avatarContainer: HTMLElement;
+    readonly username: HTMLElement;
+    readonly detail: HTMLElement;
+    readonly value: HTMLElement;
+    readonly contextKeyService: IContextKeyService;
+    readonly instantiationService: IInstantiationService;
+    readonly templateDisposables: IDisposable;
+    readonly elementDisposables: DisposableStore;
+    readonly agentHover: ChatAgentHover;
+    readonly requestHover: HTMLElement;
+    readonly disabledOverlay: HTMLElement;
+    readonly checkpointToolbar: MenuWorkbenchToolBar;
+    readonly checkpointRestoreToolbar: MenuWorkbenchToolBar;
+    readonly checkpointContainer: HTMLElement;
+    readonly checkpointRestoreContainer: HTMLElement;
+}
+interface IItemHeightChangeParams {
+    element: ChatTreeItem;
+    height: number;
+}
+export interface IChatRendererDelegate {
+    container: HTMLElement;
+    getListLength(): number;
+    currentChatMode(): ChatModeKind;
+    readonly onDidScroll?: Event<void>;
+}
+export declare class ChatListItemRenderer extends Disposable implements ITreeRenderer<ChatTreeItem, FuzzyScore, IChatListItemTemplate> {
+    private rendererOptions;
+    private readonly delegate;
+    private readonly codeBlockModelCollection;
+    private viewModel;
+    private readonly instantiationService;
+    private readonly configService;
+    private readonly logService;
+    private readonly contextKeyService;
+    private readonly themeService;
+    private readonly commandService;
+    private readonly hoverService;
+    private readonly chatWidgetService;
+    private readonly chatEntitlementService;
+    static readonly ID = "item";
+    private readonly codeBlocksByResponseId;
+    private readonly codeBlocksByEditorUri;
+    private readonly fileTreesByResponseId;
+    private readonly focusedFileTreesByResponseId;
+    private readonly templateDataByRequestId;
+    private readonly chatContentMarkdownRenderer;
+    private readonly markdownDecorationsRenderer;
+    protected readonly _onDidClickFollowup: Emitter<IChatFollowup>;
+    readonly onDidClickFollowup: Event<IChatFollowup>;
+    private readonly _onDidClickRerunWithAgentOrCommandDetection;
+    readonly onDidClickRerunWithAgentOrCommandDetection: Event<{
+        readonly sessionResource: URI;
+        readonly requestId: string;
+    }>;
+    private readonly _onDidClickRequest;
+    readonly onDidClickRequest: Event<IChatListItemTemplate>;
+    private readonly _onDidRerender;
+    readonly onDidRerender: Event<IChatListItemTemplate>;
+    private readonly _onDidDispose;
+    readonly onDidDispose: Event<IChatListItemTemplate>;
+    private readonly _onDidFocusOutside;
+    readonly onDidFocusOutside: Event<void>;
+    protected readonly _onDidChangeItemHeight: Emitter<IItemHeightChangeParams>;
+    readonly onDidChangeItemHeight: Event<IItemHeightChangeParams>;
+    private readonly _editorPool;
+    private readonly _toolEditorPool;
+    private readonly _diffEditorPool;
+    private readonly _treePool;
+    private readonly _contentReferencesListPool;
+    private _currentLayoutWidth;
+    private _isVisible;
+    private _onDidChangeVisibility;
+    /**
+     * Tool invocations get their own so that the ChatViewModel doesn't overwrite it.
+     * TODO@roblourens shouldn't use the CodeBlockModelCollection at all
+     */
+    private readonly _toolInvocationCodeBlockCollection;
+    /**
+     * Prevents re-announcement of already rendered chat progress
+     * by screen readers
+     */
+    private readonly _announcedToolProgressKeys;
+    constructor(editorOptions: ChatEditorOptions, rendererOptions: IChatListItemRendererOptions, delegate: IChatRendererDelegate, codeBlockModelCollection: CodeBlockModelCollection, overflowWidgetsDomNode: HTMLElement | undefined, viewModel: IChatViewModel | undefined, instantiationService: IInstantiationService, configService: IConfigurationService, logService: ILogService, contextKeyService: IContextKeyService, themeService: IThemeService, commandService: ICommandService, hoverService: IHoverService, chatWidgetService: IChatWidgetService, chatEntitlementService: IChatEntitlementService);
+    updateOptions(options: IChatListItemRendererOptions): void;
+    get templateId(): string;
+    editorsInUse(): Iterable<CodeBlockPart>;
+    private traceLayout;
+    /**
+     * Compute a rate to render at in words/s.
+     */
+    private getProgressiveRenderRate;
+    getCodeBlockInfosForResponse(response: IChatResponseViewModel): IChatCodeBlockInfo[];
+    updateViewModel(viewModel: IChatViewModel | undefined): void;
+    getCodeBlockInfoForEditor(uri: URI): IChatCodeBlockInfo | undefined;
+    getFileTreeInfosForResponse(response: IChatResponseViewModel): IChatFileTreeInfo[];
+    getLastFocusedFileTreeForResponse(response: IChatResponseViewModel): IChatFileTreeInfo | undefined;
+    getTemplateDataForRequestId(requestId?: string): IChatListItemTemplate | undefined;
+    setVisible(visible: boolean): void;
+    layout(width: number): void;
+    renderTemplate(container: HTMLElement): IChatListItemTemplate;
+    renderElement(node: ITreeNode<ChatTreeItem, FuzzyScore>, index: number, templateData: IChatListItemTemplate): void;
+    private clearRenderedParts;
+    renderChatTreeItem(element: ChatTreeItem, index: number, templateData: IChatListItemTemplate): void;
+    private renderDetail;
+    private renderConfirmationAction;
+    private renderAvatar;
+    private getAgentIcon;
+    private renderChatResponseBasic;
+    private shouldShowWorkingProgress;
+    private getChatFileChangesSummaryPart;
+    private renderChatRequest;
+    updateItemHeightOnRender(element: ChatTreeItem, templateData: IChatListItemTemplate): void;
+    private updateItemHeight;
+    /**
+     *	@returns true if progressive rendering should be considered complete- the element's data is fully rendered or the view is not visible
+     */
+    private doNextProgressiveRender;
+    private renderChatContentDiff;
+    /**
+     * Returns all content parts that should be rendered, and trimmed markdown content. We will diff this with the current rendered set.
+     */
+    private getNextProgressiveRenderContent;
+    private shouldShowFileChangesSummary;
+    private getDataForProgressiveRender;
+    private diff;
+    private shouldPinPart;
+    private isCreateToolInvocationContent;
+    private getLastThinkingPart;
+    private finalizeCurrentThinkingPart;
+    private renderChatContentPart;
+    dispose(): void;
+    private renderChatErrorDetails;
+    private renderUndoStop;
+    private renderNoContent;
+    private renderTreeData;
+    private renderMultiDiffData;
+    private renderContentReferencesListData;
+    private renderCodeCitations;
+    private handleRenderedCodeblocks;
+    private renderToolInvocation;
+    private renderExtensionsContent;
+    private renderPullRequestContent;
+    private renderProgressTask;
+    private renderConfirmation;
+    private renderElicitation;
+    private renderChangesSummary;
+    private renderAttachments;
+    private renderTextEdit;
+    private renderMarkdown;
+    renderThinkingPart(content: IChatThinkingPart, context: IChatContentPartRenderContext, templateData: IChatListItemTemplate): IChatContentPart;
+    disposeElement(node: ITreeNode<ChatTreeItem, FuzzyScore>, index: number, templateData: IChatListItemTemplate, details?: IListElementRenderDetails): void;
+    private renderMcpServersInteractionRequired;
+    disposeTemplate(templateData: IChatListItemTemplate): void;
+    private hoverVisible;
+    private hoverHidden;
+}
+export declare class ChatListDelegate implements IListVirtualDelegate<ChatTreeItem> {
+    private readonly defaultElementHeight;
+    private readonly logService;
+    constructor(defaultElementHeight: number, logService: ILogService);
+    private _traceLayout;
+    getHeight(element: ChatTreeItem): number;
+    getTemplateId(element: ChatTreeItem): string;
+    hasDynamicHeight(element: ChatTreeItem): boolean;
+}
+export declare class ChatVoteDownButton extends DropdownMenuActionViewItem {
+    private readonly commandService;
+    private readonly issueService;
+    private readonly logService;
+    constructor(action: IAction, options: IDropdownMenuActionViewItemOptions | undefined, commandService: ICommandService, issueService: IWorkbenchIssueService, logService: ILogService, contextMenuService: IContextMenuService);
+    getActions(): readonly IAction[];
+    render(container: HTMLElement): void;
+    private getVoteDownDetailAction;
+}
+export {};