@theia/core 1.28.0-next.7 → 1.28.0

package/src/browser/menu/browser-menu-plugin.ts

@@ -18,8 +18,8 @@ import { injectable, inject } from 'inversify';
 import { MenuBar, Menu as MenuWidget, Widget } from '@phosphor/widgets';
 import { CommandRegistry as PhosphorCommandRegistry } from '@phosphor/commands';
 import {
-    CommandRegistry, ActionMenuNode, CompositeMenuNode, environment,
-    MenuModelRegistry, MAIN_MENU_BAR, MenuPath, DisposableCollection, Disposable, MenuNode
+    CommandRegistry, CompositeMenuNode, environment,
+    MenuModelRegistry, MAIN_MENU_BAR, MenuPath, DisposableCollection, Disposable, MenuNode, MenuCommandExecutor, CompoundMenuNode, CompoundMenuNodeRole, CommandMenuNode
 } from '../../common';
 import { KeybindingRegistry } from '../keybinding';
 import { FrontendApplicationContribution, FrontendApplication } from '../frontend-application';
@@ -35,6 +35,12 @@ export abstract class MenuBarWidget extends MenuBar {
     abstract triggerMenuItem(label: string, ...labels: string[]): Promise<MenuWidget.IItem>;
 }
 
+export interface BrowserMenuOptions extends MenuWidget.IOptions {
+    commands: MenuCommandRegistry,
+    context?: HTMLElement,
+    rootMenuPath: MenuPath
+};
+
 @injectable()
 export class BrowserMainMenuFactory implements MenuWidgetFactory {
 
@@ -47,6 +53,9 @@ export class BrowserMainMenuFactory implements MenuWidgetFactory {
     @inject(CommandRegistry)
     protected readonly commandRegistry: CommandRegistry;
 
+    @inject(MenuCommandExecutor)
+    protected readonly menuCommandExecutor: MenuCommandExecutor;
+
     @inject(CorePreferences)
     protected readonly corePreferences: CorePreferences;
 
@@ -92,50 +101,39 @@ export class BrowserMainMenuFactory implements MenuWidgetFactory {
         const menuCommandRegistry = this.createMenuCommandRegistry(menuModel);
         for (const menu of menuModel.children) {
             if (menu instanceof CompositeMenuNode) {
-                const menuWidget = this.createMenuWidget(menu, { commands: menuCommandRegistry });
+                const menuWidget = this.createMenuWidget(menu, { commands: menuCommandRegistry, rootMenuPath: MAIN_MENU_BAR });
                 menuBar.addMenu(menuWidget);
             }
         }
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    createContextMenu(path: MenuPath, args?: any[]): MenuWidget {
+    createContextMenu(path: MenuPath, args?: unknown[], context?: HTMLElement): MenuWidget {
         const menuModel = this.menuProvider.getMenu(path);
-        const menuCommandRegistry = this.createMenuCommandRegistry(menuModel, args).snapshot();
-        const contextMenu = this.createMenuWidget(menuModel, { commands: menuCommandRegistry });
+        const menuCommandRegistry = this.createMenuCommandRegistry(menuModel, args).snapshot(path);
+        const contextMenu = this.createMenuWidget(menuModel, { commands: menuCommandRegistry, context, rootMenuPath: path });
         return contextMenu;
     }
 
-    createMenuWidget(menu: CompositeMenuNode, options: MenuWidget.IOptions & { commands: MenuCommandRegistry }): DynamicMenuWidget {
+    createMenuWidget(menu: CompositeMenuNode, options: BrowserMenuOptions): DynamicMenuWidget {
         return new DynamicMenuWidget(menu, options, this.services);
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    protected createMenuCommandRegistry(menu: CompositeMenuNode, args: any[] = []): MenuCommandRegistry {
+    protected createMenuCommandRegistry(menu: CompositeMenuNode, args: unknown[] = []): MenuCommandRegistry {
         const menuCommandRegistry = new MenuCommandRegistry(this.services);
         this.registerMenu(menuCommandRegistry, menu, args);
         return menuCommandRegistry;
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    protected registerMenu(menuCommandRegistry: MenuCommandRegistry, menu: CompositeMenuNode, args: any[]): void {
-        for (const child of menu.children) {
-            if (child instanceof ActionMenuNode) {
-                menuCommandRegistry.registerActionMenu(child, args);
-                if (child.altNode) {
-                    menuCommandRegistry.registerActionMenu(child.altNode, args);
-                }
-            } else if (child instanceof CompositeMenuNode) {
-                this.registerMenu(menuCommandRegistry, child, args);
-            } else {
-                this.handleDefault(menuCommandRegistry, child, args);
+    protected registerMenu(menuCommandRegistry: MenuCommandRegistry, menu: MenuNode, args: unknown[]): void {
+        if (CompoundMenuNode.is(menu)) {
+            menu.children.forEach(child => this.registerMenu(menuCommandRegistry, child, args));
+        } else if (CommandMenuNode.is(menu)) {
+            menuCommandRegistry.registerActionMenu(menu, args);
+            if (menu.altNode) {
+                menuCommandRegistry.registerActionMenu(menu.altNode, args);
             }
-        }
-    }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    protected handleDefault(menuCommandRegistry: MenuCommandRegistry, menuNode: MenuNode, args: any[]): void {
-        // NOOP
+        }
     }
 
     protected get services(): MenuServices {
@@ -144,7 +142,8 @@ export class BrowserMainMenuFactory implements MenuWidgetFactory {
             contextKeyService: this.contextKeyService,
             commandRegistry: this.commandRegistry,
             keybindingRegistry: this.keybindingRegistry,
-            menuWidgetFactory: this
+            menuWidgetFactory: this,
+            commandExecutor: this.menuCommandExecutor,
         };
     }
 
@@ -225,10 +224,11 @@ export class MenuServices {
     readonly contextKeyService: ContextKeyService;
     readonly context: ContextMenuContext;
     readonly menuWidgetFactory: MenuWidgetFactory;
+    readonly commandExecutor: MenuCommandExecutor;
 }
 
 export interface MenuWidgetFactory {
-    createMenuWidget(menu: CompositeMenuNode, options: MenuWidget.IOptions & { commands: MenuCommandRegistry }): MenuWidget;
+    createMenuWidget(menu: MenuNode & Required<Pick<MenuNode, 'children'>>, options: BrowserMenuOptions): MenuWidget;
 }
 
 /**
@@ -243,7 +243,7 @@ export class DynamicMenuWidget extends MenuWidget {
 
     constructor(
         protected menu: CompositeMenuNode,
-        protected options: MenuWidget.IOptions & { commands: MenuCommandRegistry },
+        protected options: BrowserMenuOptions,
         protected services: MenuServices
     ) {
         super(options);
@@ -260,7 +260,7 @@ export class DynamicMenuWidget extends MenuWidget {
         this.preserveFocusedElement(previousFocusedElement);
         this.clearItems();
         this.runWithPreservedFocusContext(() => {
-            this.options.commands.snapshot();
+            this.options.commands.snapshot(this.options.rootMenuPath);
             this.updateSubMenus(this, this.menu, this.options.commands);
         });
     }
@@ -275,59 +275,51 @@ export class DynamicMenuWidget extends MenuWidget {
         super.open(x, y, options);
     }
 
-    private updateSubMenus(parent: MenuWidget, menu: CompositeMenuNode, commands: MenuCommandRegistry): void {
+    protected updateSubMenus(parent: MenuWidget, menu: CompositeMenuNode, commands: MenuCommandRegistry): void {
         const items = this.buildSubMenus([], menu, commands);
+        while (items[items.length - 1]?.type === 'separator') {
+            items.pop();
+        }
         for (const item of items) {
             parent.addItem(item);
         }
     }
 
-    private buildSubMenus(items: MenuWidget.IItemOptions[], menu: CompositeMenuNode, commands: MenuCommandRegistry): MenuWidget.IItemOptions[] {
-        for (const item of menu.children) {
-            if (item instanceof CompositeMenuNode) {
-                if (item.children.length) { // do not render empty nodes
-                    if (item.isSubmenu) { // submenu node
-                        const submenu = this.services.menuWidgetFactory.createMenuWidget(item, this.options);
-                        if (!submenu.items.length) {
-                            continue;
-                        }
-                        items.push({
-                            type: 'submenu',
-                            submenu,
-                        });
-                    } else { // group node
-                        const submenu = this.buildSubMenus([], item, commands);
-                        if (!submenu.length) {
-                            continue;
-                        }
-                        if (items.length) { // do not put a separator above the first group
-                            items.push({
-                                type: 'separator'
-                            });
-                        }
-                        items.push(...submenu); // render children
+    protected buildSubmenusCalled = 0;
+
+    protected buildSubMenus(parentItems: MenuWidget.IItemOptions[], menu: MenuNode, commands: MenuCommandRegistry): MenuWidget.IItemOptions[] {
+        if (CompoundMenuNode.is(menu) && menu.children.length && this.undefinedOrMatch(menu.when, this.options.context)) {
+            const role = menu === this.menu ? CompoundMenuNodeRole.Group : CompoundMenuNode.getRole(menu);
+            if (role === CompoundMenuNodeRole.Submenu) {
+                const submenu = this.services.menuWidgetFactory.createMenuWidget(menu, this.options);
+                parentItems.push({ type: 'submenu', submenu });
+            } else if (role === CompoundMenuNodeRole.Group && menu.id !== 'inline') {
+                const children = CompoundMenuNode.getFlatChildren(menu.children);
+                const myItems: MenuWidget.IItemOptions[] = [];
+                children.forEach(child => this.buildSubMenus(myItems, child, commands));
+                if (myItems.length) {
+                    if (parentItems.length && parentItems[parentItems.length - 1].type !== 'separator') {
+                        parentItems.push({ type: 'separator' });
                     }
+                    parentItems.push(...myItems);
+                    parentItems.push({ type: 'separator' });
                 }
-            } else if (item instanceof ActionMenuNode) {
-                const { context, contextKeyService } = this.services;
-                const node = item.altNode && context.altPressed ? item.altNode : item;
-                const { when } = node.action;
-                if (!(commands.isVisible(node.action.commandId) && (!when || contextKeyService.match(when)))) {
-                    continue;
-                }
-                items.push({
-                    command: node.action.commandId,
+            }
+        } else if (menu.command) {
+            const node = menu.altNode && this.services.context.altPressed ? menu.altNode : (menu as MenuNode & CommandMenuNode);
+            if (commands.isVisible(node.command) && this.undefinedOrMatch(node.when, this.options.context)) {
+                parentItems.push({
+                    command: node.command,
                     type: 'command'
                 });
-            } else {
-                items.push(...this.handleDefault(item));
             }
         }
-        return items;
+        return parentItems;
     }
 
-    protected handleDefault(menuNode: MenuNode): MenuWidget.IItemOptions[] {
-        return [];
+    protected undefinedOrMatch(expression?: string, context?: HTMLElement): boolean {
+        if (expression) { return this.services.contextKeyService.match(expression, context); }
+        return true;
     }
 
     protected preserveFocusedElement(previousFocusedElement: Element | null = document.activeElement): boolean {
@@ -418,19 +410,16 @@ export class BrowserMenuBarContribution implements FrontendApplicationContributi
  */
 export class MenuCommandRegistry extends PhosphorCommandRegistry {
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    protected actions = new Map<string, [ActionMenuNode, any[]]>();
+    protected actions = new Map<string, [MenuNode & CommandMenuNode, unknown[]]>();
     protected toDispose = new DisposableCollection();
 
     constructor(protected services: MenuServices) {
         super();
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    registerActionMenu(menu: ActionMenuNode, args: any[]): void {
-        const { commandId } = menu.action;
+    registerActionMenu(menu: MenuNode & CommandMenuNode, args: unknown[]): void {
         const { commandRegistry } = this.services;
-        const command = commandRegistry.getCommand(commandId);
+        const command = commandRegistry.getCommand(menu.command);
         if (!command) {
             return;
         }
@@ -441,18 +430,17 @@ export class MenuCommandRegistry extends PhosphorCommandRegistry {
         this.actions.set(id, [menu, args]);
     }
 
-    snapshot(): this {
+    snapshot(menuPath: MenuPath): this {
         this.toDispose.dispose();
         for (const [menu, args] of this.actions.values()) {
-            this.toDispose.push(this.registerCommand(menu, args));
+            this.toDispose.push(this.registerCommand(menu, args, menuPath));
         }
         return this;
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    protected registerCommand(menu: ActionMenuNode, args: any[]): Disposable {
-        const { commandRegistry, keybindingRegistry } = this.services;
-        const command = commandRegistry.getCommand(menu.action.commandId);
+    protected registerCommand(menu: MenuNode & CommandMenuNode, args: unknown[], menuPath: MenuPath): Disposable {
+        const { commandRegistry, keybindingRegistry, commandExecutor } = this.services;
+        const command = commandRegistry.getCommand(menu.command);
         if (!command) {
             return Disposable.NULL;
         }
@@ -463,11 +451,11 @@ export class MenuCommandRegistry extends PhosphorCommandRegistry {
         }
 
         // We freeze the `isEnabled`, `isVisible`, and `isToggled` states so they won't change.
-        const enabled = commandRegistry.isEnabled(id, ...args);
-        const visible = commandRegistry.isVisible(id, ...args);
-        const toggled = commandRegistry.isToggled(id, ...args);
+        const enabled = commandExecutor.isEnabled(menuPath, id, ...args);
+        const visible = commandExecutor.isVisible(menuPath, id, ...args);
+        const toggled = commandExecutor.isToggled(menuPath, id, ...args);
         const unregisterCommand = this.addCommand(id, {
-            execute: () => commandRegistry.executeCommand(id, ...args),
+            execute: () => commandExecutor.executeCommand(menuPath, id, ...args),
             label: menu.label,
             icon: menu.icon,
             isEnabled: () => enabled,

package/src/browser/resource-context-key.ts

@@ -36,6 +36,7 @@ export class ResourceContextKey {
     protected resourceLangId: ContextKey<string>;
     protected resourceDirName: ContextKey<string>;
     protected resourcePath: ContextKey<string>;
+    protected resourceSet: ContextKey<boolean>;
 
     @postConstruct()
     protected init(): void {
@@ -46,6 +47,7 @@ export class ResourceContextKey {
         this.resourceLangId = this.contextKeyService.createKey<string>('resourceLangId', undefined);
         this.resourceDirName = this.contextKeyService.createKey<string>('resourceDirName', undefined);
         this.resourcePath = this.contextKeyService.createKey<string>('resourcePath', undefined);
+        this.resourceSet = this.contextKeyService.createKey<boolean>('resourceSet', false);
     }
 
     get(): URI | undefined {
@@ -54,13 +56,14 @@ export class ResourceContextKey {
     }
 
     set(resourceUri: URI | undefined): void {
-        this.resource.set(resourceUri && resourceUri['codeUri']);
-        this.resourceSchemeKey.set(resourceUri && resourceUri.scheme);
-        this.resourceFileName.set(resourceUri && resourceUri.path.base);
-        this.resourceExtname.set(resourceUri && resourceUri.path.ext);
+        this.resource.set(resourceUri?.['codeUri']);
+        this.resourceSchemeKey.set(resourceUri?.scheme);
+        this.resourceFileName.set(resourceUri?.path.base);
+        this.resourceExtname.set(resourceUri?.path.ext);
         this.resourceLangId.set(resourceUri && this.getLanguageId(resourceUri));
-        this.resourceDirName.set(resourceUri && resourceUri.path.dir.fsPath());
-        this.resourcePath.set(resourceUri && resourceUri.path.fsPath());
+        this.resourceDirName.set(resourceUri?.path.dir.fsPath());
+        this.resourcePath.set(resourceUri?.path.fsPath());
+        this.resourceSet.set(Boolean(resourceUri));
     }
 
     protected getLanguageId(uri: URI | undefined): string | undefined {

package/src/browser/shell/shell-layout-restorer.ts

@@ -27,6 +27,7 @@ import { MaybePromise } from '../../common/types';
 import { ApplicationShell, applicationShellLayoutVersion, ApplicationShellLayoutVersion } from './application-shell';
 import { CommonCommands } from '../common-frontend-contribution';
 import { WindowService } from '../window/window-service';
+import { StopReason } from '../../common/frontend-application-state';
 
 /**
  * A contract for widgets that want to store and restore their inner state, between sessions.
@@ -139,7 +140,7 @@ export class ShellLayoutRestorer implements CommandContribution {
     }
 
     protected async resetLayout(): Promise<void> {
-        if (await this.windowService.isSafeToShutDown()) {
+        if (await this.windowService.isSafeToShutDown(StopReason.Reload)) {
             this.logger.info('>>> Resetting layout...');
             this.shouldStoreLayout = false;
             this.storageService.setData(this.storageKey, undefined);

package/src/browser/shell/side-panel-toolbar.ts

@@ -101,7 +101,6 @@ export class SidePanelToolbar extends BaseWidget {
         }
     }
 
-    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
     showMoreContextMenu(anchor: Anchor): ContextMenuAccess {
         if (this.toolbar) {
             return this.toolbar.renderMoreContextMenu(anchor);

package/src/browser/shell/tab-bar-toolbar/index.ts

@@ -0,0 +1,19 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+export * from './tab-bar-toolbar';
+export * from './tab-bar-toolbar-registry';
+export * from './tab-bar-toolbar-types';

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-menu-adapters.ts

@@ -0,0 +1,31 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { MenuNode, MenuPath } from '../../../common';
+import { NAVIGATION, TabBarToolbarItem } from './tab-bar-toolbar-types';
+
+export const TOOLBAR_WRAPPER_ID_SUFFIX = '-as-tabbar-toolbar-item';
+
+export class ToolbarMenuNodeWrapper implements TabBarToolbarItem {
+    constructor(protected readonly menuNode: MenuNode, readonly group?: string, readonly menuPath?: MenuPath) { }
+    get id(): string { return this.menuNode.id + TOOLBAR_WRAPPER_ID_SUFFIX; }
+    get command(): string { return this.menuNode.command ?? ''; };
+    get icon(): string | undefined { return this.menuNode.icon; }
+    get tooltip(): string | undefined { return this.menuNode.label; }
+    get when(): string | undefined { return this.menuNode.when; }
+    get text(): string | undefined { return (this.group === NAVIGATION || this.group === undefined) ? undefined : this.menuNode.label; }
+}
+

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-registry.ts

@@ -0,0 +1,170 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import debounce = require('lodash.debounce');
+import { inject, injectable, named } from 'inversify';
+// eslint-disable-next-line max-len
+import { CommandMenuNode, CommandRegistry, CompoundMenuNode, ContributionProvider, Disposable, DisposableCollection, Emitter, Event, MenuModelRegistry, MenuPath } from '../../../common';
+import { ContextKeyService } from '../../context-key-service';
+import { FrontendApplicationContribution } from '../../frontend-application';
+import { Widget } from '../../widgets';
+import { MenuDelegate, ReactTabBarToolbarItem, TabBarToolbarItem } from './tab-bar-toolbar-types';
+import { ToolbarMenuNodeWrapper } from './tab-bar-toolbar-menu-adapters';
+
+/**
+ * Clients should implement this interface if they want to contribute to the tab-bar toolbar.
+ */
+export const TabBarToolbarContribution = Symbol('TabBarToolbarContribution');
+/**
+ * Representation of a tabbar toolbar contribution.
+ */
+export interface TabBarToolbarContribution {
+    /**
+     * Registers toolbar items.
+     * @param registry the tabbar toolbar registry.
+     */
+    registerToolbarItems(registry: TabBarToolbarRegistry): void;
+}
+
+function yes(): true { return true; }
+const menuDelegateSeparator = '=@=';
+
+/**
+ * Main, shared registry for tab-bar toolbar items.
+ */
+@injectable()
+export class TabBarToolbarRegistry implements FrontendApplicationContribution {
+
+    protected items = new Map<string, TabBarToolbarItem | ReactTabBarToolbarItem>();
+    protected menuDelegates = new Map<string, MenuDelegate>();
+
+    @inject(CommandRegistry) protected readonly commandRegistry: CommandRegistry;
+    @inject(ContextKeyService) protected readonly contextKeyService: ContextKeyService;
+    @inject(MenuModelRegistry) protected readonly menuRegistry: MenuModelRegistry;
+
+    @inject(ContributionProvider) @named(TabBarToolbarContribution)
+    protected readonly contributionProvider: ContributionProvider<TabBarToolbarContribution>;
+
+    protected readonly onDidChangeEmitter = new Emitter<void>();
+    readonly onDidChange: Event<void> = this.onDidChangeEmitter.event;
+    // debounce in order to avoid to fire more than once in the same tick
+    protected fireOnDidChange = debounce(() => this.onDidChangeEmitter.fire(undefined), 0);
+
+    onStart(): void {
+        const contributions = this.contributionProvider.getContributions();
+        for (const contribution of contributions) {
+            contribution.registerToolbarItems(this);
+        }
+    }
+
+    /**
+     * Registers the given item. Throws an error, if the corresponding command cannot be found or an item has been already registered for the desired command.
+     *
+     * @param item the item to register.
+     */
+    registerItem(item: TabBarToolbarItem | ReactTabBarToolbarItem): Disposable {
+        const { id } = item;
+        if (this.items.has(id)) {
+            throw new Error(`A toolbar item is already registered with the '${id}' ID.`);
+        }
+        this.items.set(id, item);
+        this.fireOnDidChange();
+        const toDispose = new DisposableCollection(
+            Disposable.create(() => this.fireOnDidChange()),
+            Disposable.create(() => this.items.delete(id))
+        );
+        if (item.onDidChange) {
+            toDispose.push(item.onDidChange(() => this.fireOnDidChange()));
+        }
+        return toDispose;
+    }
+
+    /**
+     * Returns an array of tab-bar toolbar items which are visible when the `widget` argument is the current one.
+     *
+     * By default returns with all items where the command is enabled and `item.isVisible` is `true`.
+     */
+    visibleItems(widget: Widget): Array<TabBarToolbarItem | ReactTabBarToolbarItem> {
+        if (widget.isDisposed) {
+            return [];
+        }
+        const result: Array<TabBarToolbarItem | ReactTabBarToolbarItem> = [];
+        for (const item of this.items.values()) {
+            const visible = TabBarToolbarItem.is(item)
+                ? this.commandRegistry.isVisible(item.command, widget)
+                : (!item.isVisible || item.isVisible(widget));
+            if (visible && (!item.when || this.contextKeyService.match(item.when, widget.node))) {
+                result.push(item);
+            }
+        }
+        for (const delegate of this.menuDelegates.values()) {
+            if (delegate.isVisible(widget)) {
+                const menu = this.menuRegistry.getMenu(delegate.menuPath);
+                const children = CompoundMenuNode.getFlatChildren(menu.children);
+                for (const child of children) {
+                    if (!child.when || this.contextKeyService.match(child.when, widget.node)) {
+                        if (child.children) {
+                            for (const grandchild of child.children) {
+                                if (!grandchild.when || this.contextKeyService.match(grandchild.when, widget.node)) {
+                                    if (CommandMenuNode.is(grandchild)) {
+                                        result.push(new ToolbarMenuNodeWrapper(grandchild, child.id, delegate.menuPath));
+                                    } else if (CompoundMenuNode.is(grandchild)) {
+                                        let menuPath;
+                                        if (menuPath = this.menuRegistry.getPath(grandchild)) {
+                                            result.push(new ToolbarMenuNodeWrapper(grandchild, child.id, menuPath));
+                                        }
+                                    }
+                                }
+                            }
+                        } else if (child.command) {
+                            result.push(new ToolbarMenuNodeWrapper(child, '', delegate.menuPath));
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    unregisterItem(itemOrId: TabBarToolbarItem | ReactTabBarToolbarItem | string): void {
+        const id = typeof itemOrId === 'string' ? itemOrId : itemOrId.id;
+        if (this.items.delete(id)) {
+            this.fireOnDidChange();
+        }
+    }
+
+    registerMenuDelegate(menuPath: MenuPath, when?: string | ((widget: Widget) => boolean)): Disposable {
+        const id = menuPath.join(menuDelegateSeparator);
+        if (!this.menuDelegates.has(id)) {
+            const isVisible: MenuDelegate['isVisible'] = !when
+                ? yes
+                : typeof when === 'function'
+                    ? when
+                    : widget => this.contextKeyService.match(when, widget?.node);
+            this.menuDelegates.set(id, { menuPath, isVisible });
+            this.fireOnDidChange();
+            return { dispose: () => this.unregisterMenuDelegate(menuPath) };
+        }
+        console.warn('Unable to register menu delegate. Delegate has already been registered', menuPath);
+        return Disposable.NULL;
+    }
+
+    unregisterMenuDelegate(menuPath: MenuPath): void {
+        if (this.menuDelegates.delete(menuPath.join(menuDelegateSeparator))) {
+            this.fireOnDidChange();
+        }
+    }
+}