@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatContentParts/chatReferencesContentPart.js

@@ -0,0 +1,528 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $ as $$1, EventHelper, hide, append, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { matchesSomeScheme, Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { basenameOrAuthority, isEqualAuthority } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { getFlatContextMenuActions } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuWorkbenchToolBar } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId, registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
+import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
+import { ContextKeyExpr } 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 { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { FileKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { WorkbenchList } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { isDark } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/theme';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { fillEditorsDragData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/dnd';
+import { ResourceLabels } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/labels';
+import { ResourceContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { SETTINGS_AUTHORITY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences';
+import { createFileIconThemableTreeContainerScope } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/views/explorerView';
+import { ExplorerFolderContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/common/files';
+import { chatEditingWidgetFileStateContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { ChatResponseReferencePartStatusKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatCollapsibleContentPart } from './chatCollapsibleContentPart.js';
+import { ResourcePool } from './chatCollections.js';
+
+var CollapsibleListRenderer_1, DividerRenderer_1;
+const $ = $$1;
+let ChatCollapsibleListContentPart = class ChatCollapsibleListContentPart extends ChatCollapsibleContentPart {
+    constructor(data, labelOverride, context, contentReferencesListPool, openerService, menuService, instantiationService, contextMenuService) {
+        super(labelOverride ?? (data.length > 1 ?
+            ( localize(5089, "Used {0} references", data.length)) :
+            ( localize(5090, "Used {0} reference", 1))), context);
+        this.data = data;
+        this.contentReferencesListPool = contentReferencesListPool;
+        this.openerService = openerService;
+        this.menuService = menuService;
+        this.instantiationService = instantiationService;
+        this.contextMenuService = contextMenuService;
+    }
+    initContent() {
+        const ref = this._register(this.contentReferencesListPool.get());
+        const list = ref.object;
+        this._register(list.onDidOpen((e) => {
+            if (e.element && 'reference' in e.element && typeof e.element.reference === 'object') {
+                const uriOrLocation = 'variableName' in e.element.reference ? e.element.reference.value : e.element.reference;
+                const uri = URI.isUri(uriOrLocation) ? uriOrLocation :
+                    uriOrLocation?.uri;
+                if (uri) {
+                    this.openerService.open(uri, {
+                        fromUserGesture: true,
+                        editorOptions: {
+                            ...e.editorOptions,
+                            ...{
+                                selection: uriOrLocation && 'range' in uriOrLocation ? uriOrLocation.range : undefined
+                            }
+                        }
+                    });
+                }
+            }
+        }));
+        this._register(list.onContextMenu(e => {
+            EventHelper.stop(e.browserEvent, true);
+            const uri = e.element && getResourceForElement(e.element);
+            if (!uri) {
+                return;
+            }
+            this.contextMenuService.showContextMenu({
+                getAnchor: () => e.anchor,
+                getActions: () => {
+                    const menu = this.menuService.getMenuActions(MenuId.ChatAttachmentsContext, list.contextKeyService, { shouldForwardArgs: true, arg: uri });
+                    return getFlatContextMenuActions(menu);
+                }
+            });
+        }));
+        const resourceContextKey = this._register(this.instantiationService.createInstance(ResourceContextKey));
+        this._register(list.onDidChangeFocus(e => {
+            resourceContextKey.reset();
+            const element = e.elements.length ? e.elements[0] : undefined;
+            const uri = element && getResourceForElement(element);
+            resourceContextKey.set(uri ?? null);
+        }));
+        const maxItemsShown = 6;
+        const itemsShown = Math.min(this.data.length, maxItemsShown);
+        const height = itemsShown * 22;
+        list.layout(height);
+        list.getHTMLElement().style.height = `${height}px`;
+        list.splice(0, list.length, this.data);
+        return list.getHTMLElement().parentElement;
+    }
+    hasSameContent(other, followingContent, element) {
+        return other.kind === 'references' && other.references.length === this.data.length && (!!followingContent.length === this.hasFollowingContent);
+    }
+};
+ChatCollapsibleListContentPart = ( __decorate([
+    ( __param(4, IOpenerService)),
+    ( __param(5, IMenuService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IContextMenuService))
+], ChatCollapsibleListContentPart));
+let ChatUsedReferencesListContentPart = class ChatUsedReferencesListContentPart extends ChatCollapsibleListContentPart {
+    constructor(data, labelOverride, context, contentReferencesListPool, options, openerService, menuService, instantiationService, contextMenuService) {
+        super(data, labelOverride, context, contentReferencesListPool, openerService, menuService, instantiationService, contextMenuService);
+        this.options = options;
+        if (data.length === 0) {
+            hide(this.domNode);
+        }
+    }
+    isExpanded() {
+        const element = this.context.element;
+        return element.usedReferencesExpanded ?? !!(this.options.expandedWhenEmptyResponse && element.response.value.length === 0);
+    }
+    setExpanded(value) {
+        const element = this.context.element;
+        element.usedReferencesExpanded = !this.isExpanded();
+    }
+};
+ChatUsedReferencesListContentPart = ( __decorate([
+    ( __param(5, IOpenerService)),
+    ( __param(6, IMenuService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IContextMenuService))
+], ChatUsedReferencesListContentPart));
+let CollapsibleListPool = class CollapsibleListPool extends Disposable {
+    get inUse() {
+        return this._pool.inUse;
+    }
+    constructor(_onDidChangeVisibility, menuId, listOptions, instantiationService, themeService, labelService) {
+        super();
+        this._onDidChangeVisibility = _onDidChangeVisibility;
+        this.menuId = menuId;
+        this.listOptions = listOptions;
+        this.instantiationService = instantiationService;
+        this.themeService = themeService;
+        this.labelService = labelService;
+        this._pool = this._register(( new ResourcePool(() => this.listFactory())));
+    }
+    listFactory() {
+        const resourceLabels = this._register(this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this._onDidChangeVisibility }));
+        const container = $('.chat-used-context-list');
+        this._register(createFileIconThemableTreeContainerScope(container, this.themeService));
+        const list = this.instantiationService.createInstance((WorkbenchList), 'ChatListRenderer', container, ( new CollapsibleListDelegate()), [this.instantiationService.createInstance(CollapsibleListRenderer, resourceLabels, this.menuId), this.instantiationService.createInstance(DividerRenderer)], {
+            ...this.listOptions,
+            alwaysConsumeMouseWheel: false,
+            accessibilityProvider: {
+                getAriaLabel: (element) => {
+                    if (element.kind === 'warning') {
+                        return element.content.value;
+                    }
+                    if (element.kind === 'divider') {
+                        return element.label;
+                    }
+                    const reference = element.reference;
+                    if (typeof reference === 'string') {
+                        return reference;
+                    }
+                    else if ('variableName' in reference) {
+                        return reference.variableName;
+                    }
+                    else if (URI.isUri(reference)) {
+                        return basename(reference.path);
+                    }
+                    else {
+                        return basename(reference.uri.path);
+                    }
+                },
+                getWidgetAriaLabel: () => ( localize(5091, "Collapsible Chat References List"))
+            },
+            dnd: {
+                getDragURI: (element) => getResourceForElement(element)?.toString() ?? null,
+                getDragLabel: (elements, originalEvent) => {
+                    const uris = coalesce(( elements.map(getResourceForElement)));
+                    if (!uris.length) {
+                        return undefined;
+                    }
+                    else if (uris.length === 1) {
+                        return this.labelService.getUriLabel(uris[0], { relative: true });
+                    }
+                    else {
+                        return `${uris.length}`;
+                    }
+                },
+                dispose: () => { },
+                onDragOver: () => false,
+                drop: () => { },
+                onDragStart: (data, originalEvent) => {
+                    try {
+                        const elements = data.getData();
+                        const uris = coalesce(( elements.map(getResourceForElement)));
+                        this.instantiationService.invokeFunction(accessor => fillEditorsDragData(accessor, uris, originalEvent));
+                    }
+                    catch {
+                    }
+                },
+            },
+        });
+        return list;
+    }
+    get() {
+        const object = this._pool.get();
+        let stale = false;
+        return {
+            object,
+            isStale: () => stale,
+            dispose: () => {
+                stale = true;
+                this._pool.release(object);
+            }
+        };
+    }
+};
+CollapsibleListPool = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, ILabelService))
+], CollapsibleListPool));
+class CollapsibleListDelegate {
+    getHeight(element) {
+        return 22;
+    }
+    getTemplateId(element) {
+        if (element.kind === 'divider') {
+            return DividerRenderer.TEMPLATE_ID;
+        }
+        return CollapsibleListRenderer.TEMPLATE_ID;
+    }
+}
+let CollapsibleListRenderer = class CollapsibleListRenderer {
+    static { CollapsibleListRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'chatCollapsibleListRenderer'; }
+    constructor(labels, menuId, themeService, productService, instantiationService, contextKeyService) {
+        this.labels = labels;
+        this.menuId = menuId;
+        this.themeService = themeService;
+        this.productService = productService;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.templateId = CollapsibleListRenderer_1.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const templateDisposables = ( new DisposableStore());
+        const label = templateDisposables.add(this.labels.create(container, { supportHighlights: true, supportIcons: true }));
+        const fileDiffsContainer = $('.working-set-line-counts');
+        const addedSpan = $$1('.working-set-lines-added');
+        const removedSpan = $$1('.working-set-lines-removed');
+        fileDiffsContainer.appendChild(addedSpan);
+        fileDiffsContainer.appendChild(removedSpan);
+        label.element.appendChild(fileDiffsContainer);
+        let toolbar;
+        let actionBarContainer;
+        let contextKeyService;
+        if (this.menuId) {
+            actionBarContainer = $('.chat-collapsible-list-action-bar');
+            contextKeyService = templateDisposables.add(this.contextKeyService.createScoped(actionBarContainer));
+            const scopedInstantiationService = templateDisposables.add(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService]))));
+            toolbar = templateDisposables.add(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, actionBarContainer, this.menuId, { menuOptions: { shouldForwardArgs: true, arg: undefined } }));
+            label.element.appendChild(actionBarContainer);
+        }
+        return { templateDisposables, label, toolbar, actionBarContainer, contextKeyService, fileDiffsContainer, addedSpan, removedSpan };
+    }
+    getReferenceIcon(data) {
+        if (ThemeIcon.isThemeIcon(data.iconPath)) {
+            return data.iconPath;
+        }
+        else {
+            return isDark(this.themeService.getColorTheme().type) && data.iconPath?.dark
+                ? data.iconPath?.dark
+                : data.iconPath?.light;
+        }
+    }
+    renderElement(data, index, templateData) {
+        if (data.kind === 'warning') {
+            templateData.label.setResource({ name: data.content.value }, { icon: Codicon.warning });
+            return;
+        }
+        if (data.kind === 'divider') {
+            return;
+        }
+        const reference = data.reference;
+        const icon = this.getReferenceIcon(data);
+        templateData.label.element.style.display = 'flex';
+        let arg;
+        if (typeof reference === 'object' && 'variableName' in reference) {
+            if (reference.value) {
+                const uri = URI.isUri(reference.value) ? reference.value : reference.value.uri;
+                templateData.label.setResource({
+                    resource: uri,
+                    name: basenameOrAuthority(uri),
+                    description: `#${reference.variableName}`,
+                    range: 'range' in reference.value ? reference.value.range : undefined,
+                }, { icon, title: data.options?.status?.description ?? data.title });
+            }
+            else if (reference.variableName.startsWith('kernelVariable')) {
+                const variable = reference.variableName.split(':')[1];
+                const asVariableName = `${variable}`;
+                const label = `Kernel variable`;
+                templateData.label.setLabel(label, asVariableName, { title: data.options?.status?.description });
+            }
+            else {
+                templateData.label.setLabel('Unknown variable type');
+            }
+        }
+        else if (typeof reference === 'string') {
+            templateData.label.setLabel(reference, undefined, { iconPath: URI.isUri(icon) ? icon : undefined, title: data.options?.status?.description ?? data.title });
+        }
+        else {
+            const uri = 'uri' in reference ? reference.uri : reference;
+            arg = uri;
+            const extraClasses = data.excluded ? ['excluded'] : [];
+            if (uri.scheme === 'https' && isEqualAuthority(uri.authority, 'github.com') && uri.path.includes('/tree/')) {
+                templateData.label.setResource(getResourceLabelForGithubUri(uri), { icon: Codicon.github, title: data.title, strikethrough: data.excluded, extraClasses });
+            }
+            else if (uri.scheme === this.productService.urlProtocol && isEqualAuthority(uri.authority, SETTINGS_AUTHORITY)) {
+                const settingId = uri.path.substring(1);
+                templateData.label.setResource({ resource: uri, name: settingId }, { icon: Codicon.settingsGear, title: ( localize(5092, "Open setting '{0}'", settingId)), strikethrough: data.excluded, extraClasses });
+            }
+            else if (matchesSomeScheme(uri, Schemas.mailto, Schemas.http, Schemas.https)) {
+                templateData.label.setResource({ resource: uri, name: ( uri.toString(true)) }, { icon: icon ?? Codicon.globe, title: data.options?.status?.description ?? data.title ?? ( uri.toString(true)), strikethrough: data.excluded, extraClasses });
+            }
+            else {
+                templateData.label.setFile(uri, {
+                    fileKind: FileKind.FILE,
+                    fileDecorations: undefined,
+                    range: 'range' in reference ? reference.range : undefined,
+                    title: data.options?.status?.description ?? data.title,
+                    strikethrough: data.excluded,
+                    extraClasses
+                });
+            }
+        }
+        for (const selector of ['.monaco-icon-suffix-container', '.monaco-icon-name-container']) {
+            const element = templateData.label.element.querySelector(selector);
+            if (element) {
+                if (data.options?.status?.kind === ChatResponseReferencePartStatusKind.Omitted || data.options?.status?.kind === ChatResponseReferencePartStatusKind.Partial) {
+                    element.classList.add('warning');
+                }
+                else {
+                    element.classList.remove('warning');
+                }
+            }
+        }
+        if (data.state !== undefined) {
+            if (templateData.actionBarContainer) {
+                const diffMeta = data?.options?.diffMeta;
+                if (diffMeta) {
+                    if (!templateData.fileDiffsContainer || !templateData.addedSpan || !templateData.removedSpan) {
+                        return;
+                    }
+                    templateData.addedSpan.textContent = `+${diffMeta.added}`;
+                    templateData.removedSpan.textContent = `-${diffMeta.removed}`;
+                    templateData.fileDiffsContainer.setAttribute('aria-label', ( localize(
+                        5093,
+                        '{0} lines added, {1} lines removed',
+                        diffMeta.added,
+                        diffMeta.removed
+                    )));
+                }
+                templateData.label.element.querySelector('.monaco-icon-name-container')?.classList.add('modified');
+            }
+            if (templateData.toolbar) {
+                templateData.toolbar.context = arg;
+            }
+            if (templateData.contextKeyService) {
+                if (data.state !== undefined) {
+                    chatEditingWidgetFileStateContextKey.bindTo(templateData.contextKeyService).set(data.state);
+                }
+            }
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.templateDisposables.dispose();
+    }
+};
+CollapsibleListRenderer = CollapsibleListRenderer_1 = ( __decorate([
+    ( __param(2, IThemeService)),
+    ( __param(3, IProductService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IContextKeyService))
+], CollapsibleListRenderer));
+let DividerRenderer = class DividerRenderer {
+    static { DividerRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'chatListDividerRenderer'; }
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+        this.templateId = DividerRenderer_1.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const templateDisposables = ( new DisposableStore());
+        const elementDisposables = templateDisposables.add(( new DisposableStore()));
+        container.classList.add('chat-list-divider');
+        const label = append(container, $$1('span.chat-list-divider-label'));
+        const line = append(container, $$1('div.chat-list-divider-line'));
+        const toolbarContainer = append(container, $$1('.chat-list-divider-toolbar'));
+        return { container, label, line, toolbarContainer, templateDisposables, elementDisposables, toolbar: undefined };
+    }
+    renderElement(data, index, templateData) {
+        templateData.label.textContent = data.label;
+        templateData.elementDisposables.clear();
+        templateData.toolbar = undefined;
+        clearNode(templateData.toolbarContainer);
+        if (data.menuId) {
+            const instantiationService = data.scopedInstantiationService || this.instantiationService;
+            templateData.toolbar = templateData.elementDisposables.add(instantiationService.createInstance(MenuWorkbenchToolBar, templateData.toolbarContainer, data.menuId, { menuOptions: { arg: data.menuArg } }));
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.templateDisposables.dispose();
+    }
+};
+DividerRenderer = DividerRenderer_1 = ( __decorate([
+    ( __param(0, IInstantiationService))
+], DividerRenderer));
+function getResourceLabelForGithubUri(uri) {
+    const repoPath = uri.path.split('/').slice(1, 3).join('/');
+    const filePath = uri.path.split('/').slice(5);
+    const fileName = filePath.at(-1);
+    const range = getLineRangeFromGithubUri(uri);
+    return {
+        resource: uri,
+        name: fileName ?? filePath.join('/'),
+        description: [repoPath, ...filePath.slice(0, -1)].join('/'),
+        range
+    };
+}
+function getLineRangeFromGithubUri(uri) {
+    if (!uri.fragment) {
+        return undefined;
+    }
+    const match = uri.fragment.match(/\bL(\d+)(?:-L(\d+))?/);
+    if (!match) {
+        return undefined;
+    }
+    const startLine = parseInt(match[1]);
+    if (isNaN(startLine)) {
+        return undefined;
+    }
+    const endLine = match[2] ? parseInt(match[2]) : startLine;
+    if (isNaN(endLine)) {
+        return undefined;
+    }
+    return {
+        startLineNumber: startLine,
+        startColumn: 1,
+        endLineNumber: endLine,
+        endColumn: 1
+    };
+}
+function getResourceForElement(element) {
+    if (element.kind === 'warning' || element.kind === 'divider') {
+        return null;
+    }
+    const { reference } = element;
+    if (typeof reference === 'string' || 'variableName' in reference) {
+        return null;
+    }
+    else if (URI.isUri(reference)) {
+        return reference;
+    }
+    else {
+        return reference.uri;
+    }
+}
+registerAction2(class AddToChatAction extends Action2 {
+    static { this.id = 'workbench.action.chat.addToChatAction'; }
+    constructor() {
+        super({
+            id: AddToChatAction.id,
+            title: {
+                ...( localize2(5094, "Add File to Chat")),
+            },
+            f1: false,
+            menu: [{
+                    id: MenuId.ChatAttachmentsContext,
+                    group: 'chat',
+                    order: 1,
+                    when: ( ContextKeyExpr.and(ResourceContextKey.IsFileSystemResource, ( ExplorerFolderContext.negate()))),
+                }]
+        });
+    }
+    async run(accessor, resource) {
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        if (!resource) {
+            return;
+        }
+        const widget = chatWidgetService.lastFocusedWidget;
+        if (widget) {
+            widget.attachmentModel.addFile(resource);
+        }
+    }
+});
+registerAction2(class OpenChatReferenceLinkAction extends Action2 {
+    static { this.id = 'workbench.action.chat.copyLink'; }
+    constructor() {
+        super({
+            id: OpenChatReferenceLinkAction.id,
+            title: {
+                ...( localize2(5095, "Copy Link")),
+            },
+            f1: false,
+            menu: [{
+                    id: MenuId.ChatAttachmentsContext,
+                    group: 'chat',
+                    order: 0,
+                    when: ( ContextKeyExpr.or(( ResourceContextKey.Scheme.isEqualTo(Schemas.http)), ( ResourceContextKey.Scheme.isEqualTo(Schemas.https)))),
+                }]
+        });
+    }
+    async run(accessor, resource) {
+        await accessor.get(IClipboardService).writeResources([resource]);
+    }
+});
+
+export { ChatCollapsibleListContentPart, ChatUsedReferencesListContentPart, CollapsibleListPool };

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

@@ -0,0 +1,31 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IChatMode } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IHandOff } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser";
+export interface INextPromptSelection {
+    readonly handoff: IHandOff;
+    readonly agentId?: string;
+}
+export declare class ChatSuggestNextWidget extends Disposable {
+    private readonly contextMenuService;
+    private readonly chatSessionsService;
+    readonly domNode: HTMLElement;
+    private readonly _onDidChangeHeight;
+    readonly onDidChangeHeight: Event<void>;
+    private readonly _onDidSelectPrompt;
+    readonly onDidSelectPrompt: Event<INextPromptSelection>;
+    private promptsContainer;
+    private titleElement;
+    private _currentMode;
+    private buttonDisposables;
+    constructor(contextMenuService: IContextMenuService, chatSessionsService: IChatSessionsService);
+    get height(): number;
+    getCurrentMode(): IChatMode | undefined;
+    private createSuggestNextWidget;
+    render(mode: IChatMode): void;
+    private createPromptButton;
+    hide(): void;
+    dispose(): void;
+}