@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,224 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, h } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { basename, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuWorkbenchToolBar } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId, Action2, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.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 { IFileDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { ProgressLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
+import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { REVEAL_IN_EXPLORER_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/fileConstants';
+import { getAttachableImageExtension } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { ChatAttachmentsContentPart } from './chatAttachmentsContentPart.js';
+
+let ChatToolOutputContentSubPart = class ChatToolOutputContentSubPart extends Disposable {
+    constructor(context, parts, contextKeyService, _instantiationService, _contextMenuService, _fileService) {
+        super();
+        this.context = context;
+        this.parts = parts;
+        this.contextKeyService = contextKeyService;
+        this._instantiationService = _instantiationService;
+        this._contextMenuService = _contextMenuService;
+        this._fileService = _fileService;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this._currentWidth = 0;
+        this._editorReferences = [];
+        this.codeblocks = [];
+        this.domNode = this.createOutputContents();
+        this._currentWidth = context.currentWidth();
+    }
+    createOutputContents() {
+        const container = $('div');
+        for (let i = 0; i < this.parts.length; i++) {
+            const part = this.parts[i];
+            if (part.kind === 'code') {
+                this.addCodeBlock(part, container);
+                continue;
+            }
+            const group = [];
+            for (let k = i; k < this.parts.length; k++) {
+                const part = this.parts[k];
+                if (part.kind !== 'data') {
+                    break;
+                }
+                group.push(part);
+            }
+            this.addResourceGroup(group, container);
+            i += group.length - 1;
+        }
+        return container;
+    }
+    addResourceGroup(parts, container) {
+        const el = h('.chat-collapsible-io-resource-group', [
+            h('.chat-collapsible-io-resource-items@items'),
+            h('.chat-collapsible-io-resource-actions@actions'),
+        ]);
+        this.fillInResourceGroup(parts, el.items, el.actions).then(() => this._onDidChangeHeight.fire());
+        container.appendChild(el.root);
+        return el.root;
+    }
+    async fillInResourceGroup(parts, itemsContainer, actionsContainer) {
+        const entries = await Promise.all(( parts.map(async (part) => {
+            if (part.mimeType && getAttachableImageExtension(part.mimeType)) {
+                const value = part.value ?? (await this._fileService.readFile(part.uri).then(f => f.value.buffer, () => undefined));
+                return { kind: 'image', id: generateUuid(), name: basename(part.uri), value, mimeType: part.mimeType, isURL: false, references: [{ kind: 'reference', reference: part.uri }] };
+            }
+            else {
+                return { kind: 'file', id: generateUuid(), name: basename(part.uri), fullName: part.uri.path, value: part.uri };
+            }
+        })));
+        const attachments = this._register(this._instantiationService.createInstance(ChatAttachmentsContentPart, {
+            variables: entries,
+            limit: 5,
+            contentReferences: undefined,
+            domNode: undefined
+        }));
+        attachments.contextMenuHandler = (attachment, event) => {
+            const index = entries.indexOf(attachment);
+            const part = parts[index];
+            if (part) {
+                event.preventDefault();
+                event.stopPropagation();
+                this._contextMenuService.showContextMenu({
+                    menuId: MenuId.ChatToolOutputResourceContext,
+                    menuActionOptions: { shouldForwardArgs: true },
+                    getAnchor: () => ({ x: event.pageX, y: event.pageY }),
+                    getActionsContext: () => ({ parts: [part] }),
+                });
+            }
+        };
+        itemsContainer.appendChild(attachments.domNode);
+        const toolbar = this._register(this._instantiationService.createInstance(MenuWorkbenchToolBar, actionsContainer, MenuId.ChatToolOutputResourceToolbar, {
+            menuOptions: {
+                shouldForwardArgs: true,
+            },
+        }));
+        toolbar.context = { parts };
+    }
+    addCodeBlock(part, container) {
+        const data = {
+            languageId: part.languageId,
+            textModel: Promise.resolve(part.textModel),
+            codeBlockIndex: part.codeBlockInfo.codeBlockIndex,
+            codeBlockPartIndex: 0,
+            element: this.context.element,
+            parentContextKeyService: this.contextKeyService,
+            renderOptions: part.options,
+            chatSessionResource: this.context.element.sessionResource,
+        };
+        const editorReference = this._register(this.context.editorPool.get());
+        editorReference.object.render(data, this._currentWidth || 300);
+        this._register(editorReference.object.onDidChangeContentHeight(() => this._onDidChangeHeight.fire()));
+        container.appendChild(editorReference.object.element);
+        this._editorReferences.push(editorReference);
+        this.codeblocks.push(part.codeBlockInfo);
+    }
+    layout(width) {
+        this._currentWidth = width;
+        this._editorReferences.forEach(r => r.object.layout(width));
+    }
+};
+ChatToolOutputContentSubPart = ( __decorate([
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IFileService))
+], ChatToolOutputContentSubPart));
+class SaveResourcesAction extends Action2 {
+    static { this.ID = 'chat.toolOutput.save'; }
+    constructor() {
+        super({
+            id: SaveResourcesAction.ID,
+            title: ( localize2(5121, "Save As...")),
+            icon: Codicon.cloudDownload,
+            menu: [{
+                    id: MenuId.ChatToolOutputResourceToolbar,
+                    group: 'navigation',
+                    order: 1
+                }, {
+                    id: MenuId.ChatToolOutputResourceContext,
+                }]
+        });
+    }
+    async run(accessor, context) {
+        const fileDialog = accessor.get(IFileDialogService);
+        const fileService = accessor.get(IFileService);
+        const notificationService = accessor.get(INotificationService);
+        const progressService = accessor.get(IProgressService);
+        const workspaceContextService = accessor.get(IWorkspaceContextService);
+        const commandService = accessor.get(ICommandService);
+        const labelService = accessor.get(ILabelService);
+        const defaultFilepath = await fileDialog.defaultFilePath();
+        const savePart = async (part, isFolder, uri) => {
+            const target = isFolder ? joinPath(uri, basename(part.uri)) : uri;
+            try {
+                if (part.kind === 'data') {
+                    await fileService.copy(part.uri, target, true);
+                }
+                else {
+                    const contents = await fileService.readFile(part.uri);
+                    await fileService.writeFile(target, contents.value);
+                }
+            }
+            catch (e) {
+                notificationService.error(( localize(5122, "Failed to save {0}: {1}", basename(part.uri), e)));
+            }
+        };
+        const withProgress = async (thenReveal, todo) => {
+            await progressService.withProgress({
+                location: ProgressLocation.Notification,
+                delay: 5_000,
+                title: ( localize(5123, "Saving resources...")),
+            }, async (report) => {
+                for (const task of todo) {
+                    await task();
+                    report.report({ increment: 1, total: todo.length });
+                }
+            });
+            if (workspaceContextService.isInsideWorkspace(thenReveal)) {
+                commandService.executeCommand(REVEAL_IN_EXPLORER_COMMAND_ID, thenReveal);
+            }
+            else {
+                notificationService.info(( localize(5124, "Saved resources to {0}", labelService.getUriLabel(thenReveal))));
+            }
+        };
+        if (context.parts.length === 1) {
+            const part = context.parts[0];
+            const uri = await fileDialog.pickFileToSave(joinPath(defaultFilepath, basename(part.uri)));
+            if (!uri) {
+                return;
+            }
+            await withProgress(uri, [() => savePart(part, false, uri)]);
+        }
+        else {
+            const uris = await fileDialog.showOpenDialog({
+                title: ( localize(5125, "Pick folder to save resources")),
+                canSelectFiles: false,
+                canSelectFolders: true,
+                canSelectMany: false,
+                defaultUri: workspaceContextService.getWorkspace().folders[0]?.uri,
+            });
+            if (!uris?.length) {
+                return;
+            }
+            await withProgress(uris[0], ( context.parts.map(part => () => savePart(part, true, uris[0]))));
+        }
+    }
+}
+registerAction2(SaveResourcesAction);
+
+export { ChatToolOutputContentSubPart };

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

@@ -0,0 +1,35 @@
+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 { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { WorkbenchCompressibleAsyncDataTree } 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 { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { ChatTreeItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IDisposableReference } from "./chatCollections.js";
+import { IChatContentPart } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatContentParts";
+import { IChatProgressRenderableResponseContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IChatResponseProgressFileTreeData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+export declare class ChatTreeContentPart extends Disposable implements IChatContentPart {
+    private readonly openerService;
+    readonly domNode: HTMLElement;
+    private readonly _onDidChangeHeight;
+    readonly onDidChangeHeight: Event<void>;
+    readonly onDidFocus: Event<void>;
+    private tree;
+    constructor(data: IChatResponseProgressFileTreeData, element: ChatTreeItem, treePool: TreePool, treeDataIndex: number, openerService: IOpenerService);
+    domFocus(): void;
+    hasSameContent(other: IChatProgressRenderableResponseContent): boolean;
+    addDisposable(disposable: IDisposable): void;
+}
+export declare class TreePool extends Disposable {
+    private _onDidChangeVisibility;
+    private readonly instantiationService;
+    private readonly configService;
+    private readonly themeService;
+    private _pool;
+    get inUse(): ReadonlySet<WorkbenchCompressibleAsyncDataTree<IChatResponseProgressFileTreeData, IChatResponseProgressFileTreeData, void>>;
+    constructor(_onDidChangeVisibility: Event<boolean>, instantiationService: IInstantiationService, configService: IConfigurationService, themeService: IThemeService);
+    private treeFactory;
+    get(): IDisposableReference<WorkbenchCompressibleAsyncDataTree<IChatResponseProgressFileTreeData, IChatResponseProgressFileTreeData, void>>;
+}

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

@@ -0,0 +1,173 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $ as $$1 } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+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 { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { FileKind, FileType } 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 { WorkbenchCompressibleAsyncDataTree } 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 { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { ResourceLabels } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/labels';
+import { ResourcePool } from './chatCollections.js';
+import { createFileIconThemableTreeContainerScope } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/views/explorerView';
+
+const $ = $$1;
+let ChatTreeContentPart = class ChatTreeContentPart extends Disposable {
+    constructor(data, element, treePool, treeDataIndex, openerService) {
+        super();
+        this.openerService = openerService;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        const ref = this._register(treePool.get());
+        this.tree = ref.object;
+        this.onDidFocus = this.tree.onDidFocus;
+        this._register(this.tree.onDidOpen((e) => {
+            if (e.element && !('children' in e.element)) {
+                this.openerService.open(e.element.uri);
+            }
+        }));
+        this._register(this.tree.onDidChangeCollapseState(() => {
+            this._onDidChangeHeight.fire();
+        }));
+        this._register(this.tree.onContextMenu((e) => {
+            e.browserEvent.preventDefault();
+            e.browserEvent.stopPropagation();
+        }));
+        this.tree.setInput(data).then(() => {
+            if (!ref.isStale()) {
+                this.tree.layout();
+                this._onDidChangeHeight.fire();
+            }
+        });
+        this.domNode = this.tree.getHTMLElement().parentElement;
+    }
+    domFocus() {
+        this.tree.domFocus();
+    }
+    hasSameContent(other) {
+        return other.kind === 'treeData';
+    }
+    addDisposable(disposable) {
+        this._register(disposable);
+    }
+};
+ChatTreeContentPart = ( __decorate([
+    ( __param(4, IOpenerService))
+], ChatTreeContentPart));
+let TreePool = class TreePool extends Disposable {
+    get inUse() {
+        return this._pool.inUse;
+    }
+    constructor(_onDidChangeVisibility, instantiationService, configService, themeService) {
+        super();
+        this._onDidChangeVisibility = _onDidChangeVisibility;
+        this.instantiationService = instantiationService;
+        this.configService = configService;
+        this.themeService = themeService;
+        this._pool = this._register(( new ResourcePool(() => this.treeFactory())));
+    }
+    treeFactory() {
+        const resourceLabels = this._register(this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this._onDidChangeVisibility }));
+        const container = $('.interactive-response-progress-tree');
+        this._register(createFileIconThemableTreeContainerScope(container, this.themeService));
+        const tree = this.instantiationService.createInstance((WorkbenchCompressibleAsyncDataTree), 'ChatListRenderer', container, ( new ChatListTreeDelegate()), ( new ChatListTreeCompressionDelegate()), [( new ChatListTreeRenderer(resourceLabels, this.configService.getValue('explorer.decorations')))], ( new ChatListTreeDataSource()), {
+            collapseByDefault: () => false,
+            expandOnlyOnTwistieClick: () => false,
+            identityProvider: {
+                getId: (e) => ( e.uri.toString())
+            },
+            accessibilityProvider: {
+                getAriaLabel: (element) => element.label,
+                getWidgetAriaLabel: () => ( localize(5126, "File Tree"))
+            },
+            alwaysConsumeMouseWheel: false
+        });
+        return tree;
+    }
+    get() {
+        const object = this._pool.get();
+        let stale = false;
+        return {
+            object,
+            isStale: () => stale,
+            dispose: () => {
+                stale = true;
+                this._pool.release(object);
+            }
+        };
+    }
+};
+TreePool = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IThemeService))
+], TreePool));
+class ChatListTreeDelegate {
+    static { this.ITEM_HEIGHT = 22; }
+    getHeight(element) {
+        return ChatListTreeDelegate.ITEM_HEIGHT;
+    }
+    getTemplateId(element) {
+        return 'chatListTreeTemplate';
+    }
+}
+class ChatListTreeCompressionDelegate {
+    isIncompressible(element) {
+        return !element.children;
+    }
+}
+class ChatListTreeRenderer {
+    constructor(labels, decorations) {
+        this.labels = labels;
+        this.decorations = decorations;
+        this.templateId = 'chatListTreeTemplate';
+    }
+    renderCompressedElements(element, index, templateData) {
+        templateData.label.element.style.display = 'flex';
+        const label = ( element.element.elements.map((e) => e.label));
+        templateData.label.setResource({ resource: element.element.elements[0].uri, name: label }, {
+            title: element.element.elements[0].label,
+            fileKind: element.children ? FileKind.FOLDER : FileKind.FILE,
+            extraClasses: ['explorer-item'],
+            fileDecorations: this.decorations
+        });
+    }
+    renderTemplate(container) {
+        const templateDisposables = ( new DisposableStore());
+        const label = templateDisposables.add(this.labels.create(container, { supportHighlights: true }));
+        return { templateDisposables, label };
+    }
+    renderElement(element, index, templateData) {
+        templateData.label.element.style.display = 'flex';
+        if (!element.children.length && element.element.type !== FileType.Directory) {
+            templateData.label.setFile(element.element.uri, {
+                fileKind: FileKind.FILE,
+                hidePath: true,
+                fileDecorations: this.decorations,
+            });
+        }
+        else {
+            templateData.label.setResource({ resource: element.element.uri, name: element.element.label }, {
+                title: element.element.label,
+                fileKind: FileKind.FOLDER,
+                fileDecorations: this.decorations
+            });
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.templateDisposables.dispose();
+    }
+}
+class ChatListTreeDataSource {
+    hasChildren(element) {
+        return !!element.children;
+    }
+    async getChildren(element) {
+        return element.children ?? [];
+    }
+}
+
+export { ChatTreeContentPart, TreePool };