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

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

@@ -1,11 +1,14 @@
 
 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 { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 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 { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
 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';
@@ -26,8 +29,22 @@ import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/comm
 import { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
 import { ChatAttachmentsContentPart } from './chatAttachmentsContentPart.js';
 
+var ChatToolOutputContentSubPart_1;
 let ChatToolOutputContentSubPart = class ChatToolOutputContentSubPart extends Disposable {
-    constructor(context, parts, _instantiationService, contextKeyService, _contextMenuService, _fileService, _markdownRendererService) {
+    static {
+        ChatToolOutputContentSubPart_1 = this;
+    }
+    constructor(
+        context,
+        parts,
+        _instantiationService,
+        contextKeyService,
+        _contextMenuService,
+        _fileService,
+        _markdownRendererService,
+        modelService,
+        languageService
+    ) {
         super();
         this.context = context;
         this.parts = parts;
@@ -36,32 +53,36 @@ let ChatToolOutputContentSubPart = class ChatToolOutputContentSubPart extends Di
         this._contextMenuService = _contextMenuService;
         this._fileService = _fileService;
         this._markdownRendererService = _markdownRendererService;
-        this._onDidChangeHeight = this._register(( new Emitter()));
-        this.onDidChangeHeight = this._onDidChangeHeight.event;
-        this._currentWidth = 0;
+        this.modelService = modelService;
+        this.languageService = languageService;
         this._editorReferences = [];
         this.codeblocks = [];
         this.domNode = this.createOutputContents();
-        this._currentWidth = context.currentWidth();
     }
     toMdString(value) {
-        if (typeof value === 'string') {
-            return ( new MarkdownString('')).appendText(value);
+        if (typeof value === "string") {
+            return ( new MarkdownString("")).appendText(value);
         }
-        return ( new MarkdownString(value.value, { isTrusted: value.isTrusted }));
+        return ( new MarkdownString(value.value, {
+            isTrusted: value.isTrusted
+        }));
     }
     createOutputContents() {
-        const container = $('div');
+        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);
+            if (part.kind === "code") {
+                const codeParts = [part];
+                while (i + 1 < this.parts.length && this.parts[i + 1].kind === "code") {
+                    codeParts.push(this.parts[++i]);
+                }
+                this.addCodeBlock(codeParts, container);
                 continue;
             }
             const group = [];
             for (let k = i; k < this.parts.length; k++) {
                 const part = this.parts[k];
-                if (part.kind !== 'data') {
+                if (part.kind !== "data") {
                     break;
                 }
                 group.push(part);
@@ -72,24 +93,86 @@ let ChatToolOutputContentSubPart = class ChatToolOutputContentSubPart extends Di
         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'),
+        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());
+        this.fillInResourceGroup(parts, el.items, el.actions);
         container.appendChild(el.root);
         return el.root;
     }
+    static {
+        this.IMAGE_DECODE_DELAY_MS = 100;
+    }
     async fillInResourceGroup(parts, itemsContainer, actionsContainer) {
-        const entries = await Promise.all(( parts.map(async (part) => {
+        const entries = [];
+        const deferredImageParts = [];
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
             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 };
+                if (part.base64Value) {
+                    entries.push({
+                        kind: "file",
+                        id: generateUuid(),
+                        name: basename(part.uri),
+                        fullName: part.uri.path,
+                        value: part.uri
+                    });
+                    deferredImageParts.push({
+                        index: i,
+                        part
+                    });
+                } else if (part.value) {
+                    entries.push({
+                        kind: "image",
+                        id: generateUuid(),
+                        name: basename(part.uri),
+                        value: part.value,
+                        mimeType: part.mimeType,
+                        isURL: false,
+                        references: [{
+                            kind: "reference",
+                            reference: part.uri
+                        }]
+                    });
+                } else {
+                    const value = await this._fileService.readFile(part.uri).then(f => f.value.buffer, () => undefined);
+                    if (!value) {
+                        entries.push({
+                            kind: "file",
+                            id: generateUuid(),
+                            name: basename(part.uri),
+                            fullName: part.uri.path,
+                            value: part.uri
+                        });
+                    } else {
+                        entries.push({
+                            kind: "image",
+                            id: generateUuid(),
+                            name: basename(part.uri),
+                            value,
+                            mimeType: part.mimeType,
+                            isURL: false,
+                            references: [{
+                                kind: "reference",
+                                reference: part.uri
+                            }]
+                        });
+                    }
+                }
+            } else {
+                entries.push({
+                    kind: "file",
+                    id: generateUuid(),
+                    name: basename(part.uri),
+                    fullName: part.uri.path,
+                    value: part.uri
+                });
             }
-        })));
+        }
+        if (this._store.isDisposed) {
+            return;
+        }
         const attachments = this._register(this._instantiationService.createInstance(ChatAttachmentsContentPart, {
             variables: entries,
             limit: 5,
@@ -104,70 +187,120 @@ let ChatToolOutputContentSubPart = class ChatToolOutputContentSubPart extends Di
                 event.stopPropagation();
                 this._contextMenuService.showContextMenu({
                     menuId: MenuId.ChatToolOutputResourceContext,
-                    menuActionOptions: { shouldForwardArgs: true },
-                    getAnchor: () => ({ x: event.pageX, y: event.pageY }),
-                    getActionsContext: () => ({ parts: [part] }),
+                    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 };
+        const toolbar = this._register(this._instantiationService.createInstance(
+            MenuWorkbenchToolBar,
+            actionsContainer,
+            MenuId.ChatToolOutputResourceToolbar,
+            {
+                menuOptions: {
+                    shouldForwardArgs: true
+                }
+            }
+        ));
+        toolbar.context = {
+            parts
+        };
+        if (deferredImageParts.length > 0) {
+            this._register(disposableTimeout(() => {
+                for (const {
+                    index,
+                    part
+                } of deferredImageParts) {
+                    try {
+                        const value = decodeBase64(part.base64Value).buffer;
+                        entries[index] = {
+                            kind: "image",
+                            id: generateUuid(),
+                            name: basename(part.uri),
+                            value,
+                            mimeType: part.mimeType,
+                            isURL: false,
+                            references: [{
+                                kind: "reference",
+                                reference: part.uri
+                            }]
+                        };
+                    } catch {}
+                }
+                attachments.updateVariables(entries);
+            }, ChatToolOutputContentSubPart_1.IMAGE_DECODE_DELAY_MS));
+        }
     }
-    addCodeBlock(part, container) {
-        if (part.title) {
-            const title = $('div.chat-confirmation-widget-title');
-            const renderedTitle = this._register(this._markdownRendererService.render(this.toMdString(part.title)));
+    addCodeBlock(parts, container) {
+        const firstPart = parts[0];
+        if (firstPart.title) {
+            const title = $("div.chat-confirmation-widget-title");
+            const renderedTitle = this._register(this._markdownRendererService.render(this.toMdString(firstPart.title)));
             title.appendChild(renderedTitle.element);
             container.appendChild(title);
         }
+        const combinedText = ( parts.map(p => p.data)).join("\n");
+        const textModel = this._register(this.modelService.createModel(
+            combinedText,
+            this.languageService.createById(firstPart.languageId),
+            undefined,
+            true
+        ));
         const data = {
-            languageId: part.languageId,
-            textModel: Promise.resolve(part.textModel),
-            codeBlockIndex: part.codeBlockInfo.codeBlockIndex,
+            languageId: firstPart.languageId,
+            textModel: Promise.resolve(textModel),
+            codeBlockIndex: firstPart.codeBlockIndex,
             codeBlockPartIndex: 0,
             element: this.context.element,
             parentContextKeyService: this.contextKeyService,
-            renderOptions: part.options,
-            chatSessionResource: this.context.element.sessionResource,
+            renderOptions: firstPart.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()));
+        editorReference.object.render(data, this.context.currentWidth.get());
         container.appendChild(editorReference.object.element);
         this._editorReferences.push(editorReference);
-        this.codeblocks.push(part.codeBlockInfo);
+        this.codeblocks.push({
+            ownerMarkdownPartId: firstPart.ownerMarkdownPartId,
+            codeBlockIndex: firstPart.codeBlockIndex,
+            elementId: this.context.element.id,
+            uri: textModel.uri,
+            uriPromise: Promise.resolve(textModel.uri),
+            codemapperUri: undefined,
+            chatSessionResource: this.context.element.sessionResource,
+            focus: () => {}
+        });
     }
     layout(width) {
-        this._currentWidth = width;
         this._editorReferences.forEach(r => r.object.layout(width));
     }
 };
-ChatToolOutputContentSubPart = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IFileService)),
-    ( __param(6, IMarkdownRendererService))
-], ChatToolOutputContentSubPart));
+ChatToolOutputContentSubPart = ChatToolOutputContentSubPart_1 = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IContextKeyService)), ( __param(4, IContextMenuService)), ( __param(5, IFileService)), ( __param(6, IMarkdownRendererService)), ( __param(7, IModelService)), ( __param(8, ILanguageService))], ChatToolOutputContentSubPart));
 class SaveResourcesAction extends Action2 {
-    static { this.ID = 'chat.toolOutput.save'; }
+    static {
+        this.ID = "chat.toolOutput.save";
+    }
     constructor() {
         super({
             id: SaveResourcesAction.ID,
-            title: ( localize2(5691, "Save As...")),
+            title: ( localize2(5937, "Save As...")),
             icon: Codicon.cloudDownload,
             menu: [{
-                    id: MenuId.ChatToolOutputResourceToolbar,
-                    group: 'navigation',
-                    order: 1
-                }, {
-                    id: MenuId.ChatToolOutputResourceContext,
-                }]
+                id: MenuId.ChatToolOutputResourceToolbar,
+                group: "navigation",
+                order: 1
+            }, {
+                id: MenuId.ChatToolOutputResourceContext
+            }]
         });
     }
     async run(accessor, context) {
@@ -182,34 +315,34 @@ class SaveResourcesAction extends Action2 {
         const savePart = async (part, isFolder, uri) => {
             const target = isFolder ? joinPath(uri, basename(part.uri)) : uri;
             try {
-                if (part.kind === 'data') {
+                if (part.kind === "data") {
                     await fileService.copy(part.uri, target, true);
-                }
-                else {
+                } else {
                     const contents = await fileService.readFile(part.uri);
                     await fileService.writeFile(target, contents.value);
                 }
-            }
-            catch (e) {
-                notificationService.error(( localize(5692, "Failed to save {0}: {1}", basename(part.uri), e)));
+            } catch (e) {
+                notificationService.error(( localize(5938, "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(5693, "Saving resources...")),
-            }, async (report) => {
+                title: ( localize(5939, "Saving resources..."))
+            }, async report => {
                 for (const task of todo) {
                     await task();
-                    report.report({ increment: 1, total: todo.length });
+                    report.report({
+                        increment: 1,
+                        total: todo.length
+                    });
                 }
             });
             if (workspaceContextService.isInsideWorkspace(thenReveal)) {
                 commandService.executeCommand(REVEAL_IN_EXPLORER_COMMAND_ID, thenReveal);
-            }
-            else {
-                notificationService.info(( localize(5694, "Saved resources to {0}", labelService.getUriLabel(thenReveal))));
+            } else {
+                notificationService.info(( localize(5940, "Saved resources to {0}", labelService.getUriLabel(thenReveal))));
             }
         };
         if (context.parts.length === 1) {
@@ -219,14 +352,13 @@ class SaveResourcesAction extends Action2 {
                 return;
             }
             await withProgress(uri, [() => savePart(part, false, uri)]);
-        }
-        else {
+        } else {
             const uris = await fileDialog.showOpenDialog({
-                title: ( localize(5695, "Pick folder to save resources")),
+                title: ( localize(5941, "Pick folder to save resources")),
                 canSelectFiles: false,
                 canSelectFolders: true,
                 canSelectMany: false,
-                defaultUri: workspaceContextService.getWorkspace().folders[0]?.uri,
+                defaultUri: workspaceContextService.getWorkspace().folders[0]?.uri
             });
             if (!uris?.length) {
                 return;

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

@@ -5,31 +5,33 @@ import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/pl
 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 { IChatResponseProgressFileTreeData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { IChatProgressRenderableResponseContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
 import { IDisposableReference } from "./chatCollections.js";
 import { IChatContentPart } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatContentParts";
-import { IChatProgressRenderableResponseContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
-import { IChatResponseProgressFileTreeData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/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);
+    constructor(data: IChatResponseProgressFileTreeData, treePool: TreePool, openerService: IOpenerService);
     domFocus(): void;
     hasSameContent(other: IChatProgressRenderableResponseContent): boolean;
     addDisposable(disposable: IDisposable): void;
 }
+interface ITreePoolWrapper extends IDisposable {
+    tree: WorkbenchCompressibleAsyncDataTree<IChatResponseProgressFileTreeData, IChatResponseProgressFileTreeData, 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>>;
+    get inUse(): ReadonlySet<ITreePoolWrapper>;
     constructor(_onDidChangeVisibility: Event<boolean>, instantiationService: IInstantiationService, configService: IConfigurationService, themeService: IThemeService);
     private treeFactory;
     get(): IDisposableReference<WorkbenchCompressibleAsyncDataTree<IChatResponseProgressFileTreeData, IChatResponseProgressFileTreeData, void>>;
+    clear(): void;
 }
+export {};

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

@@ -1,7 +1,6 @@
 
 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';
@@ -11,35 +10,29 @@ import { WorkbenchCompressibleAsyncDataTree } from '@codingame/monaco-vscode-api
 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';
+import { ResourcePool } from './chatCollections.js';
 
 const $ = $$1;
 let ChatTreeContentPart = class ChatTreeContentPart extends Disposable {
-    constructor(data, element, treePool, treeDataIndex, openerService) {
+    constructor(data, treePool, 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._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) => {
+        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;
@@ -48,15 +41,13 @@ let ChatTreeContentPart = class ChatTreeContentPart extends Disposable {
         this.tree.domFocus();
     }
     hasSameContent(other) {
-        return other.kind === 'treeData';
+        return other.kind === "treeData";
     }
     addDisposable(disposable) {
         this._register(disposable);
     }
 };
-ChatTreeContentPart = ( __decorate([
-    ( __param(4, IOpenerService))
-], ChatTreeContentPart));
+ChatTreeContentPart = ( __decorate([( __param(2, IOpenerService))], ChatTreeContentPart));
 let TreePool = class TreePool extends Disposable {
     get inUse() {
         return this._pool.inUse;
@@ -70,48 +61,64 @@ let TreePool = class TreePool extends Disposable {
         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(5696, "File Tree"))
-            },
-            alwaysConsumeMouseWheel: false
-        });
-        return tree;
+        const store = ( new DisposableStore());
+        const resourceLabels = store.add(this.instantiationService.createInstance(ResourceLabels, {
+            onDidChangeVisibility: this._onDidChangeVisibility
+        }));
+        const container = $(".interactive-response-progress-tree");
+        store.add(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(5942, "File Tree"))
+                },
+                alwaysConsumeMouseWheel: false
+            }
+        );
+        return {
+            tree,
+            dispose: () => store.dispose()
+        };
     }
     get() {
-        const object = this._pool.get();
+        const wrapper = this._pool.get();
         let stale = false;
         return {
-            object,
+            object: wrapper.tree,
             isStale: () => stale,
             dispose: () => {
                 stale = true;
-                this._pool.release(object);
+                this._pool.release(wrapper);
             }
         };
     }
+    clear() {
+        this._pool.clear();
+    }
 };
-TreePool = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IThemeService))
-], TreePool));
+TreePool = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IConfigurationService)), ( __param(3, IThemeService))], TreePool));
 class ChatListTreeDelegate {
-    static { this.ITEM_HEIGHT = 22; }
+    static {
+        this.ITEM_HEIGHT = 22;
+    }
     getHeight(element) {
         return ChatListTreeDelegate.ITEM_HEIGHT;
     }
     getTemplateId(element) {
-        return 'chatListTreeTemplate';
+        return "chatListTreeTemplate";
     }
 }
 class ChatListTreeCompressionDelegate {
@@ -123,34 +130,44 @@ class ChatListTreeRenderer {
     constructor(labels, decorations) {
         this.labels = labels;
         this.decorations = decorations;
-        this.templateId = 'chatListTreeTemplate';
+        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 }, {
+        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'],
+            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 };
+        const label = templateDisposables.add(this.labels.create(container, {
+            supportHighlights: true
+        }));
+        return {
+            templateDisposables,
+            label
+        };
     }
     renderElement(element, index, templateData) {
-        templateData.label.element.style.display = 'flex';
+        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,
+                fileDecorations: this.decorations
             });
-        }
-        else {
-            templateData.label.setResource({ resource: element.element.uri, name: element.element.label }, {
+        } else {
+            templateData.label.setResource({
+                resource: element.element.uri,
+                name: element.element.label
+            }, {
                 title: element.element.label,
                 fileKind: FileKind.FOLDER,
                 fileDecorations: this.decorations