@codingame/monaco-vscode-api 4.5.2 → 5.0.0

package/vscode/src/vs/workbench/browser/parts/views/treeView.js

@@ -5,14 +5,14 @@ import { renderMarkdownAsPlaintext } from '../../../../base/browser/markdownRend
 import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
 import { ActionViewItem } from '../../../../base/browser/ui/actionbar/actionViewItems.js';
 import { CollapseAllAction } from '../../../../base/browser/ui/tree/treeDefaults.js';
-import { ActionRunner } from '../../../../base/common/actions.js';
+import { ActionRunner, Separator } from '../../../../base/common/actions.js';
 import { timeout } from '../../../../base/common/async.js';
 import { CancellationToken, CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { Codicon } from '../../../../base/common/codicons.js';
 import { isCancellationError } from '../../../../base/common/errors.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
 import { createMatches } from '../../../../base/common/filters.js';
-import { isMarkdownString } from '../../../../base/common/htmlContent.js';
+import { MarkdownString, isMarkdownString } from '../../../../base/common/htmlContent.js';
 import { Disposable, DisposableStore, toDisposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
 import { Mimes } from '../../../../base/common/mime.js';
 import { Schemas } from '../../../../base/common/network.js';
@@ -51,8 +51,7 @@ import { ThemeIcon } from '../../../../base/common/themables.js';
 import { fillEditorsDragData } from '../../dnd.js';
 import { ResourceLabels } from '../../labels.js';
 import { API_OPEN_EDITOR_COMMAND_ID, API_OPEN_DIFF_EDITOR_COMMAND_ID } from '../editor/editorCommands.js';
-import { ViewPane } from './viewPane.js';
-import { PANEL_BACKGROUND, SIDE_BAR_BACKGROUND } from '../../../common/theme.js';
+import { ViewPane, getLocationBasedViewColors } from './viewPane.js';
 import { ResolvableTreeItem, TreeItemCollapsibleState, Extensions } from '../../../common/views.js';
 import { IViewDescriptorService } from '../../../common/views.service.js';
 import { NumberBadge } from '../../../services/activity/common/activity.js';
@@ -69,11 +68,15 @@ import { TelemetryTrustedValue } from '../../../../platform/telemetry/common/tel
 import { ITreeViewsDnDService } from '../../../../editor/common/services/treeViewsDndService.js';
 import { DraggedTreeItemsIdentifier } from '../../../../editor/common/services/treeViewsDnd.js';
 import { MarkdownRenderer } from '../../../../editor/browser/widget/markdownRenderer/browser/markdownRenderer.js';
+import { parseLinkedText } from '../../../../base/common/linkedText.js';
+import { Button } from '../../../../base/browser/ui/button/button.js';
+import { defaultButtonStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { IAccessibleViewInformationService } from '../../../services/accessibility/common/accessibleViewInformationService.service.js';
 var TreeRenderer_1;
 const _moduleId = "vs/workbench/browser/parts/views/treeView";
 let TreeViewPane = class TreeViewPane extends ViewPane {
-    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, notificationService) {
-        super({ ...options, titleMenuId: MenuId.ViewTitle, donotForwardArgs: false }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, notificationService, hoverService, accessibleViewService) {
+        super({ ...options, titleMenuId: MenuId.ViewTitle, donotForwardArgs: false }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, hoverService, accessibleViewService);
         const { treeView } = ( (Registry.as(Extensions.ViewsRegistry))).getView(options.id);
         this.treeView = treeView;
         this._register(this.treeView.onDidChangeActions(() => this.updateActions(), this));
@@ -140,7 +143,9 @@ TreeViewPane = ( (__decorate([
     ( (__param(7, IOpenerService))),
     ( (__param(8, IThemeService))),
     ( (__param(9, ITelemetryService))),
-    ( (__param(10, INotificationService)))
+    ( (__param(10, INotificationService))),
+    ( (__param(11, IHoverService))),
+    ( (__param(12, IAccessibleViewInformationService)))
 ], TreeViewPane)));
 class Root {
     constructor() {
@@ -163,7 +168,7 @@ function isTreeCommandEnabled(treeCommand, contextKeyService) {
     return true;
 }
 function isRenderedMessageValue(messageValue) {
-    return !!messageValue && typeof messageValue !== 'string' && 'element' in messageValue && 'dispose' in messageValue;
+    return !!messageValue && typeof messageValue !== 'string' && 'element' in messageValue && 'disposables' in messageValue;
 }
 const noDataProviderMessage = ( localizeWithPath(
     _moduleId,
@@ -174,7 +179,7 @@ const RawCustomTreeViewContextKey = ( (new RawContextKey('customTreeView', false
 class Tree extends WorkbenchAsyncDataTree {
 }
 let AbstractTreeView = class AbstractTreeView extends Disposable {
-    constructor(id, _title, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, hoverService, contextKeyService, activityService, logService) {
+    constructor(id, _title, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, hoverService, contextKeyService, activityService, logService, openerService) {
         super();
         this.id = id;
         this._title = _title;
@@ -191,6 +196,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         this.contextKeyService = contextKeyService;
         this.activityService = activityService;
         this.logService = logService;
+        this.openerService = openerService;
         this.isVisible = false;
         this._hasIconForParentNode = false;
         this._hasIconForLeafNode = false;
@@ -220,6 +226,8 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         this._onDidCompleteRefresh = this._register(( (new Emitter())));
         this._isInitialized = false;
         this._activity = this._register(( (new MutableDisposable())));
+        this.activated = false;
+        this.treeDisposables = this._register(( (new DisposableStore())));
         this._height = 0;
         this._width = 0;
         this.refreshing = false;
@@ -247,7 +255,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         }));
         this._register(this.viewDescriptorService.onDidChangeLocation(({ views, from, to }) => {
             if (( (views.some(v => v.id === this.id)))) {
-                this.tree?.updateOptions({ overrideStyles: { listBackground: this.viewLocation === 1  ? PANEL_BACKGROUND : SIDE_BAR_BACKGROUND } });
+                this.tree?.updateOptions({ overrideStyles: getLocationBasedViewColors(this.viewLocation).listOverrideStyles });
             }
         }));
         this.registerActions();
@@ -325,6 +333,8 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         }
         else {
             this._dataProvider = undefined;
+            this.treeDisposables.clear();
+            this.activated = false;
             this.updateMessage();
         }
         this._onDidChangeWelcomeState.fire();
@@ -367,6 +377,9 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             };
             this._activity.value = this.activityService.showViewActivity(this.id, activity);
         }
+        else {
+            this._activity.clear();
+        }
     }
     get canSelectMany() {
         return this._canSelectMany;
@@ -538,16 +551,17 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         this._register(focusTracker.onDidBlur(() => this.focused = false));
     }
     createTree() {
+        this.treeDisposables.clear();
         const actionViewItemProvider = createActionViewItem.bind(undefined, this.instantiationService);
-        const treeMenus = this._register(this.instantiationService.createInstance(TreeMenus, this.id));
-        this.treeLabels = this._register(this.instantiationService.createInstance(ResourceLabels, this));
+        const treeMenus = this.treeDisposables.add(this.instantiationService.createInstance(TreeMenus, this.id));
+        this.treeLabels = this.treeDisposables.add(this.instantiationService.createInstance(ResourceLabels, this));
         const dataSource = this.instantiationService.createInstance(TreeDataSource, this, (task) => this.progressService.withProgress({ location: this.id }, () => task));
         const aligner = ( (new Aligner(this.themeService)));
-        const checkboxStateHandler = this._register(( (new CheckboxStateHandler())));
+        const checkboxStateHandler = this.treeDisposables.add(( (new CheckboxStateHandler())));
         const renderer = this.instantiationService.createInstance(TreeRenderer, this.id, treeMenus, this.treeLabels, actionViewItemProvider, aligner, checkboxStateHandler, () => this.manuallyManageCheckboxes);
-        this._register(renderer.onDidChangeCheckboxState(e => this._onDidChangeCheckboxState.fire(e)));
+        this.treeDisposables.add(renderer.onDidChangeCheckboxState(e => this._onDidChangeCheckboxState.fire(e)));
         const widgetAriaLabel = this._title;
-        this.tree = this._register(this.instantiationService.createInstance(Tree, this.id, this.treeContainer, ( (new TreeViewDelegate())), [renderer], dataSource, {
+        this.tree = this.treeDisposables.add(this.instantiationService.createInstance(Tree, this.id, this.treeContainer, ( (new TreeViewDelegate())), [renderer], dataSource, {
             identityProvider: ( (new TreeViewIdentityProvider())),
             accessibilityProvider: {
                 getAriaLabel(element) {
@@ -591,10 +605,9 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             },
             multipleSelectionSupport: this.canSelectMany,
             dnd: this.treeViewDnd,
-            overrideStyles: {
-                listBackground: this.viewLocation === 1  ? PANEL_BACKGROUND : SIDE_BAR_BACKGROUND
-            }
+            overrideStyles: getLocationBasedViewColors(this.viewLocation).listOverrideStyles
         }));
+        this.treeDisposables.add(this.tree);
         treeMenus.setContextKeyService(this.tree.contextKeyService);
         aligner.tree = this.tree;
         const actionRunner = ( (new MultipleSelectionActionRunner(this.notificationService, () => this.tree.getSelection())));
@@ -602,20 +615,20 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         this.tree.contextKeyService.createKey(this.id, true);
         const customTreeKey = RawCustomTreeViewContextKey.bindTo(this.tree.contextKeyService);
         customTreeKey.set(true);
-        this._register(this.tree.onContextMenu(e => this.onContextMenu(treeMenus, e, actionRunner)));
-        this._register(this.tree.onDidChangeSelection(e => {
+        this.treeDisposables.add(this.tree.onContextMenu(e => this.onContextMenu(treeMenus, e, actionRunner)));
+        this.treeDisposables.add(this.tree.onDidChangeSelection(e => {
             this.lastSelection = e.elements;
             this.lastActive = this.tree?.getFocus()[0] ?? this.lastActive;
             this._onDidChangeSelectionAndFocus.fire({ selection: this.lastSelection, focus: this.lastActive });
         }));
-        this._register(this.tree.onDidChangeFocus(e => {
+        this.treeDisposables.add(this.tree.onDidChangeFocus(e => {
             if (e.elements.length && (e.elements[0] !== this.lastActive)) {
                 this.lastActive = e.elements[0];
                 this.lastSelection = this.tree?.getSelection() ?? this.lastSelection;
                 this._onDidChangeSelectionAndFocus.fire({ selection: this.lastSelection, focus: this.lastActive });
             }
         }));
-        this._register(this.tree.onDidChangeCollapseState(e => {
+        this.treeDisposables.add(this.tree.onDidChangeCollapseState(e => {
             if (!e.node.element) {
                 return;
             }
@@ -628,7 +641,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             }
         }));
         this.tree.setInput(this.root).then(() => this.updateContentAreas());
-        this._register(this.tree.onDidOpen(async (e) => {
+        this.treeDisposables.add(this.tree.onDidOpen(async (e) => {
             if (!e.browserEvent) {
                 return;
             }
@@ -650,7 +663,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
                 }
             }
         }));
-        this._register(treeMenus.onDidChange((changed) => {
+        this.treeDisposables.add(treeMenus.onDidChange((changed) => {
             if (this.tree?.hasNode(changed)) {
                 this.tree?.rerender(changed);
             }
@@ -676,7 +689,11 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         event.preventDefault();
         event.stopPropagation();
         this.tree.setFocus([node]);
-        const actions = treeMenus.getResourceContextActions(node);
+        let selected = this.canSelectMany ? this.getSelection() : [];
+        if (!selected.find(item => item.handle === node.handle)) {
+            selected = [node];
+        }
+        const actions = treeMenus.getResourceContextActions(selected);
         if (!actions.length) {
             return;
         }
@@ -713,14 +730,65 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         }
         this.updateContentAreas();
     }
+    processMessage(message, disposables) {
+        const lines = message.value.split('\n');
+        const result = [];
+        let hasFoundButton = false;
+        for (const line of lines) {
+            const linkedText = parseLinkedText(line);
+            if (linkedText.nodes.length === 1 && typeof linkedText.nodes[0] !== 'string') {
+                const node = linkedText.nodes[0];
+                const buttonContainer = document.createElement('div');
+                buttonContainer.classList.add('button-container');
+                const button = ( (new Button(
+                    buttonContainer,
+                    { title: node.title, secondary: hasFoundButton, supportIcons: true, ...defaultButtonStyles }
+                )));
+                button.label = node.label;
+                button.onDidClick(_ => {
+                    this.openerService.open(node.href, { allowCommands: true });
+                }, null, disposables);
+                disposables.add(button);
+                hasFoundButton = true;
+                result.push(buttonContainer);
+            }
+            else {
+                hasFoundButton = false;
+                const rendered = this.markdownRenderer.render(( (new MarkdownString(
+                    line,
+                    { isTrusted: message.isTrusted, supportThemeIcons: message.supportThemeIcons, supportHtml: message.supportHtml }
+                ))));
+                result.push(rendered.element);
+                disposables.add(rendered);
+            }
+        }
+        const container = document.createElement('div');
+        container.classList.add('rendered-message');
+        for (const child of result) {
+            if (child instanceof HTMLElement) {
+                container.appendChild(child);
+            }
+            else {
+                container.appendChild(child.element);
+            }
+        }
+        return container;
+    }
     showMessage(message) {
         if (isRenderedMessageValue(this._messageValue)) {
-            this._messageValue.dispose();
+            this._messageValue.disposables.dispose();
         }
         if (isMarkdownString(message) && !this.markdownRenderer) {
             this.markdownRenderer = this.instantiationService.createInstance(MarkdownRenderer, {});
         }
-        this._messageValue = isMarkdownString(message) ? this.markdownRenderer.render(message) : message;
+        if (isMarkdownString(message)) {
+            const disposables = ( (new DisposableStore()));
+            const renderedMessage = this.processMessage(message, disposables);
+            this._messageValue = { element: renderedMessage, disposables };
+        }
+        else {
+            this._messageValue = message;
+        }
         if (!this.messageElement) {
             return;
         }
@@ -908,7 +976,8 @@ AbstractTreeView = ( (__decorate([
     ( (__param(11, IHoverService))),
     ( (__param(12, IContextKeyService))),
     ( (__param(13, IActivityService))),
-    ( (__param(14, ILogService)))
+    ( (__param(14, ILogService))),
+    ( (__param(15, IOpenerService)))
 ], AbstractTreeView)));
 class TreeViewIdentityProvider {
     getId(element) {
@@ -950,7 +1019,7 @@ let TreeRenderer = class TreeRenderer extends Disposable {
     static { TreeRenderer_1 = this; }
     static { this.ITEM_HEIGHT = 22; }
     static { this.TREE_TEMPLATE_ID = 'treeExplorer'; }
-    constructor(treeViewId, menus, labels, actionViewItemProvider, aligner, checkboxStateHandler, manuallyManageCheckboxes, themeService, configurationService, labelService, treeViewsService, contextKeyService, instantiationService) {
+    constructor(treeViewId, menus, labels, actionViewItemProvider, aligner, checkboxStateHandler, manuallyManageCheckboxes, themeService, configurationService, labelService, treeViewsService, contextKeyService, hoverService, instantiationService) {
         super();
         this.treeViewId = treeViewId;
         this.menus = menus;
@@ -964,6 +1033,7 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         this.labelService = labelService;
         this.treeViewsService = treeViewsService;
         this.contextKeyService = contextKeyService;
+        this.hoverService = hoverService;
         this._onDidChangeCheckboxState = this._register(( (new Emitter())));
         this.onDidChangeCheckboxState = this._onDidChangeCheckboxState.event;
         this._hasCheckbox = false;
@@ -1104,7 +1174,7 @@ let TreeRenderer = class TreeRenderer extends Disposable {
             }
         }
         templateData.actionBar.context = { $treeViewId: this.treeViewId, $treeItemHandle: node.handle };
-        const menuActions = this.menus.getResourceActions(node, templateData.elementDisposable);
+        const menuActions = this.menus.getResourceActions([node], templateData.elementDisposable);
         templateData.actionBar.push(menuActions.actions, { icon: true, label: false });
         if (this._actionRunner) {
             templateData.actionBar.actionRunner = this._actionRunner;
@@ -1134,7 +1204,8 @@ let TreeRenderer = class TreeRenderer extends Disposable {
                 const checkbox = ( (new TreeItemCheckbox(
                     templateData.checkboxContainer,
                     this.checkboxStateHandler,
-                    this._hoverDelegate
+                    this._hoverDelegate,
+                    this.hoverService
                 )));
                 templateData.checkbox = checkbox;
             }
@@ -1269,7 +1340,8 @@ TreeRenderer = TreeRenderer_1 = ( (__decorate([
     ( (__param(9, ILabelService))),
     ( (__param(10, ITreeViewsService))),
     ( (__param(11, IContextKeyService))),
-    ( (__param(12, IInstantiationService)))
+    ( (__param(12, IHoverService))),
+    ( (__param(13, IInstantiationService)))
 ], TreeRenderer)));
 class Aligner extends Disposable {
     constructor(themeService) {
@@ -1343,7 +1415,7 @@ class MultipleSelectionActionRunner extends ActionRunner {
                 return { $treeViewId: context.$treeViewId, $treeItemHandle: selected.handle };
             })));
         }
-        if (!actionInSelected) {
+        if (!actionInSelected && selectionHandleArgs) {
             selectionHandleArgs = undefined;
         }
         await action.run(context, selectionHandleArgs);
@@ -1356,37 +1428,88 @@ let TreeMenus = class TreeMenus {
         this._onDidChange = ( (new Emitter()));
         this.onDidChange = this._onDidChange.event;
     }
-    getResourceActions(element, disposableStore) {
-        const actions = this.getActions(MenuId.ViewItemContext, element, disposableStore);
-        return { menu: actions.menu, actions: actions.primary };
+    getResourceActions(elements, disposableStore) {
+        const actions = this.getActions(MenuId.ViewItemContext, elements, disposableStore);
+        return { actions: actions.primary };
     }
-    getResourceContextActions(element) {
-        return this.getActions(MenuId.ViewItemContext, element).secondary;
+    getResourceContextActions(elements) {
+        return this.getActions(MenuId.ViewItemContext, elements).secondary;
     }
     setContextKeyService(service) {
         this.contextKeyService = service;
     }
-    getActions(menuId, element, listen) {
+    filterNonUniversalActions(groups, newActions) {
+        const newActionsSet = ( (new Set( (newActions.map(a => a.id)))));
+        for (const group of groups) {
+            const actions = ( (group.keys()));
+            for (const action of actions) {
+                if (!( (newActionsSet.has(action)))) {
+                    group.delete(action);
+                }
+            }
+        }
+    }
+    buildMenu(groups) {
+        const result = [];
+        for (const group of groups) {
+            if (group.size > 0) {
+                if (result.length) {
+                    result.push(( (new Separator())));
+                }
+                result.push(...( (group.values())));
+            }
+        }
+        return result;
+    }
+    createGroups(actions) {
+        const groups = [];
+        let group = ( (new Map()));
+        for (const action of actions) {
+            if (action instanceof Separator) {
+                groups.push(group);
+                group = ( (new Map()));
+            }
+            else {
+                group.set(action.id, action);
+            }
+        }
+        groups.push(group);
+        return groups;
+    }
+    getActions(menuId, elements, listen) {
         if (!this.contextKeyService) {
             return { primary: [], secondary: [] };
         }
-        const contextKeyService = this.contextKeyService.createOverlay([
-            ['view', this.id],
-            ['viewItem', element.contextValue]
-        ]);
-        const menu = this.menuService.createMenu(menuId, contextKeyService);
-        const primary = [];
-        const secondary = [];
-        const result = { primary, secondary, menu };
-        createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, result, 'inline');
-        if (listen) {
-            listen.add(menu.onDidChange(() => this._onDidChange.fire(element)));
-            listen.add(menu);
-        }
-        else {
-            menu.dispose();
+        let primaryGroups = [];
+        let secondaryGroups = [];
+        for (let i = 0; i < elements.length; i++) {
+            const element = elements[i];
+            const contextKeyService = this.contextKeyService.createOverlay([
+                ['view', this.id],
+                ['viewItem', element.contextValue]
+            ]);
+            const menu = this.menuService.createMenu(menuId, contextKeyService);
+            const primary = [];
+            const secondary = [];
+            const result = { primary, secondary, menu };
+            createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, result, 'inline');
+            if (i === 0) {
+                primaryGroups = this.createGroups(result.primary);
+                secondaryGroups = this.createGroups(result.secondary);
+            }
+            else {
+                this.filterNonUniversalActions(primaryGroups, result.primary);
+                this.filterNonUniversalActions(secondaryGroups, result.secondary);
+            }
+            if (listen && elements.length === 1) {
+                listen.add(menu.onDidChange(() => this._onDidChange.fire(element)));
+                listen.add(menu);
+            }
+            else {
+                menu.dispose();
+            }
         }
-        return result;
+        return { primary: this.buildMenu(primaryGroups), secondary: this.buildMenu(secondaryGroups) };
     }
     dispose() {
         this.contextKeyService = undefined;
@@ -1396,12 +1519,11 @@ TreeMenus = ( (__decorate([
     ( (__param(1, IMenuService)))
 ], TreeMenus)));
 let CustomTreeView = class CustomTreeView extends AbstractTreeView {
-    constructor(id, title, extensionId, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, contextKeyService, hoverService, extensionService, activityService, telemetryService, logService) {
-        super(id, title, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, hoverService, contextKeyService, activityService, logService);
+    constructor(id, title, extensionId, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, contextKeyService, hoverService, extensionService, activityService, telemetryService, logService, openerService) {
+        super(id, title, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, hoverService, contextKeyService, activityService, logService, openerService);
         this.extensionId = extensionId;
         this.extensionService = extensionService;
         this.telemetryService = telemetryService;
-        this.activated = false;
     }
     activate() {
         if (!this.activated) {
@@ -1434,13 +1556,10 @@ CustomTreeView = ( (__decorate([
     ( (__param(14, IExtensionService))),
     ( (__param(15, IActivityService))),
     ( (__param(16, ITelemetryService))),
-    ( (__param(17, ILogService)))
+    ( (__param(17, ILogService))),
+    ( (__param(18, IOpenerService)))
 ], CustomTreeView)));
 class TreeView extends AbstractTreeView {
-    constructor() {
-        super(...arguments);
-        this.activated = false;
-    }
     activate() {
         if (!this.activated) {
             this.createTree();

package/vscode/src/vs/workbench/browser/parts/views/viewPane.d.ts

@@ -11,6 +11,7 @@ import { IConfigurationService } from '../../../../platform/configuration/common
 import { IView } from '../../../common/views.js';
 import { IViewDescriptorService } from '../../../common/views.service.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { PartialExcept } from '../../../../base/common/types.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { MenuId } from '../../../../platform/actions/common/actions.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
@@ -18,6 +19,9 @@ import { IProgressIndicator } from '../../../../platform/progress/common/progres
 import { CompositeMenuActions } from '../../actions.js';
 import { IDropdownMenuActionViewItemOptions } from '../../../../base/browser/ui/dropdown/dropdownActionViewItem.js';
 import { FilterWidget } from './viewFilter.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
+import { IListStyles } from '../../../../base/browser/ui/list/listWidget.js';
+import { IAccessibleViewInformationService } from '../../../services/accessibility/common/accessibleViewInformationService.service.js';
 
 declare enum ViewPaneShowActions {
     /** Show the actions when the view is hovered. This is the default behavior. */
@@ -44,6 +48,8 @@ declare abstract class ViewPane extends Pane implements IView {
     protected openerService: IOpenerService;
     protected themeService: IThemeService;
     protected telemetryService: ITelemetryService;
+    protected readonly hoverService: IHoverService;
+    protected readonly accessibleViewService?: IAccessibleViewInformationService | undefined;
     private static readonly AlwaysShowActionsConfig;
     private _onDidFocus;
     readonly onDidFocus: Event<void>;
@@ -78,7 +84,7 @@ declare abstract class ViewPane extends Pane implements IView {
     protected twistiesContainer?: HTMLElement;
     private viewWelcomeController;
     protected readonly scopedContextKeyService: IContextKeyService;
-    constructor(options: IViewPaneOptions, keybindingService: IKeybindingService, contextMenuService: IContextMenuService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, viewDescriptorService: IViewDescriptorService, instantiationService: IInstantiationService, openerService: IOpenerService, themeService: IThemeService, telemetryService: ITelemetryService);
+    constructor(options: IViewPaneOptions, keybindingService: IKeybindingService, contextMenuService: IContextMenuService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, viewDescriptorService: IViewDescriptorService, instantiationService: IInstantiationService, openerService: IOpenerService, themeService: IThemeService, telemetryService: ITelemetryService, hoverService: IHoverService, accessibleViewService?: IAccessibleViewInformationService | undefined);
     get headerVisible(): boolean;
     set headerVisible(visible: boolean);
     setVisible(visible: boolean): void;
@@ -93,6 +99,7 @@ declare abstract class ViewPane extends Pane implements IView {
     style(styles: IPaneStyles): void;
     private getIcon;
     protected renderHeaderTitle(container: HTMLElement, title: string): void;
+    private _getAriaLabel;
     protected updateTitle(title: string): void;
     private setTitleDescription;
     protected updateTitleDescription(description?: string | undefined): void;
@@ -102,7 +109,7 @@ declare abstract class ViewPane extends Pane implements IView {
     onDidScrollRoot(): void;
     getProgressIndicator(): IProgressIndicator;
     protected getProgressLocation(): string;
-    protected getBackgroundColor(): string;
+    protected getLocationBasedColors(): IViewPaneLocationColors;
     focus(): void;
     private setActions;
     private updateActionsVisibility;
@@ -116,5 +123,9 @@ declare abstract class ViewPane extends Pane implements IView {
     getFilterWidget(): FilterWidget | undefined;
     shouldShowFilterInHeader(): boolean;
 }
+interface IViewPaneLocationColors {
+    background: string;
+    listOverrideStyles: PartialExcept<IListStyles, 'listBackground' | 'treeStickyScrollBackground'>;
+}
 
-export { type IViewPaneOptions, ViewPane, ViewPaneShowActions };
+export { type IViewPaneLocationColors, type IViewPaneOptions, ViewPane, ViewPaneShowActions };