We can do it without transparent menu nodes, but it isn't as fun

Author: colin-grant-work

packages/core/src/browser/menu/browser-menu-node-factory.ts

@@ -38,9 +38,9 @@ export class BrowserMenuNodeFactory implements MenuNodeFactory {
     createCommandMenu(item: MenuAction): CommandMenu {
         return new ActionMenuNode(item, this.commandRegistry, this.keybindingRegistry, this.contextKeyService);
     }
-    createSubmenu(id: string, label: string, contextKeyOverlays: Record<string, string> | undefined, orderString?: string, icon?: string, when?: string, transparent?: boolean):
+    createSubmenu(id: string, label: string, contextKeyOverlays: Record<string, string> | undefined, orderString?: string, icon?: string, when?: string):
         Submenu & MutableCompoundMenuNode {
-        return new SubmenuImpl(id, label, contextKeyOverlays, orderString, icon, when, transparent);
+        return new SubmenuImpl(id, label, contextKeyOverlays, orderString, icon, when);
     }
     createSubmenuLink(delegate: Submenu, sortString?: string, when?: string, argumentAdapter?: (...args: unknown[]) => unknown[]): MenuNode {
         return new SubMenuLink(delegate, sortString, when, argumentAdapter);

packages/core/src/browser/menu/browser-menu-plugin.ts

@@ -306,7 +306,7 @@ export class DynamicMenuWidget extends MenuWidget {
 
     protected updateSubMenus(parent: MenuWidget, menu: CompoundMenuNode, commands: LuminoCommandRegistry,
         contextMatcher: ContextMatcher, context?: HTMLElement | undefined): void {
-        const items = this.createItems(CompoundMenuNode.flatten(menu), commands, contextMatcher, context);
+        const items = this.createItems(menu.children, commands, contextMatcher, context);
         while (items[items.length - 1]?.type === 'separator') {
             items.pop();
         }

packages/core/src/browser/menu/composite-menu-node.ts

@@ -14,20 +14,32 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { CommandMenu, CompoundMenuNode, ContextExpressionMatcher, Group, MenuNode, MenuPath, MutableCompoundMenuNode, RenderedMenuNode, Submenu } from '../../common/menu/menu-types';
-// import { Event } from '../../common';
+import {
+    CommandMenu,
+    CompoundMenuNode,
+    ContextExpressionMatcher,
+    Group,
+    MenuNode,
+    MenuPath,
+    MutableCompoundMenuNode,
+    RenderedMenuNode,
+    Submenu
+} from '../../common/menu/menu-types';
 
 export class SubMenuLink implements CompoundMenuNode {
     constructor(private readonly delegate: CompoundMenuNode & Partial<RenderedMenuNode>, private readonly _sortString?: string, private readonly _when?: string,
         private readonly argumentAdapter?: (...args: unknown[]) => unknown[]) { }
 
     get id(): string { return this.delegate.id; };
-    get transparent(): boolean | undefined { return this.delegate.transparent; }
     get children(): MenuNode[] {
         const { argumentAdapter } = this;
         if (!argumentAdapter) { return this.delegate.children; }
         return this.delegate.children.map(child =>
-            CommandMenu.is(child) ? new DelegatingAction(child, argumentAdapter) : CompoundMenuNode.is(child) ? new SubMenuLink(child, child.sortString, undefined, argumentAdapter) : child
+            CommandMenu.is(child)
+                ? new DelegatingAction(child, argumentAdapter)
+                : CompoundMenuNode.is(child)
+                    ? new SubMenuLink(child, child.sortString, undefined, argumentAdapter)
+                    : child
         );
     }
     get contextKeyOverlays(): Record<string, string> | undefined { return this.delegate.contextKeyOverlays; }
@@ -167,7 +179,6 @@ export class SubmenuImpl extends AbstractCompoundMenuImpl implements Submenu {
         orderString?: string,
         readonly icon?: string,
         when?: string,
-        readonly transparent?: boolean,
     ) {
         super(id, orderString, when);
     }

packages/core/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-registry.ts

@@ -136,24 +136,21 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
         }
 
         for (const delegate of this.menuDelegates.values()) {
-            if (delegate.isVisible(widget)) {
-                const menu = this.menuRegistry.getMenu(delegate.menuPath);
-                if (menu) {
-                    for (const child of CompoundMenuNode.flatten(menu)) {
-                        if (child.isVisible(this.contextKeyService, widget.node)) {
-                            if (CompoundMenuNode.is(child)) {
-                                for (const grandchild of CompoundMenuNode.flatten(child)) {
-                                    if (grandchild.isVisible(this.contextKeyService, widget.node) && RenderedMenuNode.is(grandchild)) {
-                                        result.push(new ToolbarMenuNodeWrapper(this.commandRegistry, this.menuRegistry,
-                                            this.contextKeyService, this.contextMenuRenderer, grandchild, child.id, delegate.menuPath));
-                                    }
-                                }
-                            } else if (CommandMenu.is(child)) {
-                                result.push(new ToolbarMenuNodeWrapper(this.commandRegistry, this.menuRegistry,
-                                    this.contextKeyService, this.contextMenuRenderer, child, undefined, delegate.menuPath));
-                            }
+            if (!delegate.isVisible(widget)) { continue; }
+            const menu = this.menuRegistry.getMenu(delegate.menuPath);
+            if (!menu) { continue; }
+            for (const child of menu.children) {
+                if (!child.isVisible(this.contextKeyService, widget.node)) { continue; }
+                if (CompoundMenuNode.is(child)) {
+                    for (const grandchild of child.children) {
+                        if (grandchild.isVisible(this.contextKeyService, widget.node) && RenderedMenuNode.is(grandchild)) {
+                            result.push(new ToolbarMenuNodeWrapper(this.commandRegistry, this.menuRegistry,
+                                this.contextKeyService, this.contextMenuRenderer, grandchild, child.id, delegate.menuPath));
                         }
                     }
+                } else if (CommandMenu.is(child)) {
+                    result.push(new ToolbarMenuNodeWrapper(this.commandRegistry, this.menuRegistry,
+                        this.contextKeyService, this.contextMenuRenderer, child, undefined, delegate.menuPath));
                 }
             }
         }

packages/core/src/common/menu/menu-model-registry.ts

@@ -86,10 +86,18 @@ export interface MenuNodeFactory {
     createGroup(id: string, orderString?: string, when?: string): Group & MutableCompoundMenuNode;
     createCommandMenu(item: MenuAction): CommandMenu;
     createSubmenu(id: string, label: string, contextKeyOverlays: Record<string, string> | undefined,
-        orderString?: string, icon?: string, when?: string, transparent?: boolean): Submenu & MutableCompoundMenuNode
+        orderString?: string, icon?: string, when?: string): Submenu & MutableCompoundMenuNode
     createSubmenuLink(delegate: Submenu, sortString?: string, when?: string, argumentAdapter?: (...args: unknown[]) => unknown[]): MenuNode;
 }
 
+export interface LinkedSubmenuOptions {
+    newParentPath: MenuPath;
+    submenuPath: MenuPath;
+    order?: string;
+    when?: string;
+    argumentAdapter?: (...args: unknown[]) => unknown[];
+}
+
 /**
  * The MenuModelRegistry allows to register and unregister menus, submenus and actions
  * via strings and {@link MenuAction}s without the need to access the underlying UI
@@ -176,14 +184,14 @@ export class MenuModelRegistry {
      * will be returned.
      */
     registerSubmenu(menuPath: MenuPath, label: string,
-        options: { sortString?: string, icon?: string, when?: string, contextKeyOverlay?: Record<string, string>, transparent?: boolean } = {}): Disposable {
-        const { contextKeyOverlay, sortString, icon, when, transparent } = options;
+        options: { sortString?: string, icon?: string, when?: string, contextKeyOverlay?: Record<string, string> } = {}): Disposable {
+        const { contextKeyOverlay, sortString, icon, when } = options;
 
         const parent = this.root.getOrCreate(menuPath, 0, menuPath.length - 1);
         const existing = parent.children.find(node => node.id === menuPath[menuPath.length - 1]);
         if (Group.is(existing)) {
             parent.removeNode(existing);
-            const newMenu = this.menuNodeFactory.createSubmenu(menuPath[menuPath.length - 1], label, contextKeyOverlay, sortString, icon, when, transparent);
+            const newMenu = this.menuNodeFactory.createSubmenu(menuPath[menuPath.length - 1], label, contextKeyOverlay, sortString, icon, when);
             newMenu.addNode(...existing.children);
             parent.addNode(newMenu);
             this.fireChangeEvent({
@@ -199,7 +207,7 @@ export class MenuModelRegistry {
                 });
             });
         } else {
-            const newMenu = this.menuNodeFactory.createSubmenu(menuPath[menuPath.length - 1], label, contextKeyOverlay, sortString, icon, when, transparent);
+            const newMenu = this.menuNodeFactory.createSubmenu(menuPath[menuPath.length - 1], label, contextKeyOverlay, sortString, icon, when);
             parent.addNode(newMenu);
             this.fireChangeEvent({
                 kind: ChangeKind.ADDED,
@@ -217,7 +225,7 @@ export class MenuModelRegistry {
         }
     }
 
-    linkCompoundMenuNode(params: { newParentPath: MenuPath, submenuPath: MenuPath, order?: string, when?: string, argumentAdapter?: (...args: unknown[]) => unknown[] }): Disposable {
+    linkCompoundMenuNode(params: LinkedSubmenuOptions): Disposable {
         const { newParentPath, submenuPath, order, when, argumentAdapter } = params;
         // add a wrapper here
         let i = 0;

packages/core/src/common/menu/menu-types.ts

@@ -122,8 +122,7 @@ export type Submenu = CompoundMenuNode & RenderedMenuNode;
 export interface CompoundMenuNode extends MenuNode {
     children: MenuNode[];
     contextKeyOverlays?: Record<string, string>;
-    /** If true, the menu node's children should be rendered as though they were direct children of the submenu's parent. */
-    transparent?: boolean;
+
     /**
      * Whether the group or submenu contains any visible children
      *
@@ -148,19 +147,6 @@ export namespace CompoundMenuNode {
         return m1.sortString.localeCompare(m2.sortString);
     }
 
-    const _flatten = (acc: MenuNode[], curr: MenuNode): MenuNode[] => {
-        if (is(curr) && curr.transparent) {
-            acc.push(...curr.children.reduce(_flatten, acc))
-        } else {
-            acc.push(curr);
-        }
-        return acc;
-    }
-
-    export function flatten(parent: CompoundMenuNode): MenuNode[] {
-        return parent.children.reduce(_flatten, []).sort(sortChildren);
-    }
-
     /**
      * Indicates whether the given node is the special `navigation` menu.
      *

packages/plugin-ext/src/main/browser/menus/menus-contribution-handler.ts

@@ -17,20 +17,24 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { inject, injectable, optional } from '@theia/core/shared/inversify';
-import { CommandRegistry, Disposable, DisposableCollection, nls, CommandMenu, AcceleratorSource, ContextExpressionMatcher } from '@theia/core';
+import { MenuPath, CommandRegistry, Disposable, DisposableCollection, nls, CommandMenu, AcceleratorSource, ContextExpressionMatcher } from '@theia/core';
 import { MenuModelRegistry } from '@theia/core/lib/common';
 import { TabBarToolbarRegistry } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
 import { DeployedPlugin, IconUrl, Menu } from '../../../common';
 import { ScmWidget } from '@theia/scm/lib/browser/scm-widget';
 import { KeybindingRegistry, QuickCommandService } from '@theia/core/lib/browser';
 import {
-    CodeEditorWidgetUtil, PLUGIN_EDITOR_TITLE_MENU, PLUGIN_EDITOR_TITLE_RUN_MENU, PLUGIN_SCM_TITLE_MENU, PLUGIN_VIEW_TITLE_MENU
+    CodeEditorWidgetUtil, codeToTheiaMappings, PLUGIN_EDITOR_TITLE_MENU, PLUGIN_EDITOR_TITLE_RUN_MENU, PLUGIN_SCM_TITLE_MENU, PLUGIN_VIEW_TITLE_MENU
 } from './vscode-theia-menu-mappings';
 import { PluginMenuCommandAdapter } from './plugin-menu-command-adapter';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { PluginSharedStyle } from '../plugin-shared-style';
 import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/base/common/themables';
 
+function identity(...args: unknown[]): unknown[] {
+    return args;
+}
+
 @injectable()
 export class MenusContributionPointHandler {
 
@@ -63,6 +67,9 @@ export class MenusContributionPointHandler {
         this.tabBarToolbar.registerMenuDelegate(PLUGIN_VIEW_TITLE_MENU, widget => !CodeEditorWidgetUtil.is(widget));
     }
 
+    private getMatchingTheiaMenuPaths(contributionPoint: string): MenuPath[] | undefined {
+        return (codeToTheiaMappings as Map<string, MenuPath[]>).get(contributionPoint);
+    }
 
     handle(plugin: DeployedPlugin): Disposable {
         const allMenus = plugin.contributes?.menus;
@@ -85,61 +92,66 @@ export class MenusContributionPointHandler {
                     if (contributionPoint === 'commandPalette') {
                         toDispose.push(this.registerCommandPaletteAction(item));
                     } else {
-                        const target = [this.pluginMenuCommandAdapter.toProbablyUniquePath(contributionPoint)];
+                        const targets = this.getMatchingTheiaMenuPaths(contributionPoint) ?? [[contributionPoint]];
                         const { group, order } = this.parseGroup(item.group);
                         const { submenu, command } = item;
                         if (submenu && command) {
                             console.warn(
                                 `Menu item ${command} from plugin ${plugin.metadata.model.id} contributed both submenu and command. Only command will be registered.`
                             );
                         }
+                        const contributionPointAdapter = this.pluginMenuCommandAdapter.getArgumentAdapter(contributionPoint);
                         if (command) {
-                            const menuPath = group ? [...target, group] : target;
-
-                            const cmd = this.commandRegistry.getCommand(command);
-                            if (!cmd) {
-                                console.debug(`No label for action menu node: No command "${command}" exists.`);
-                                continue;
-                            }
-                            const label = cmd.label || cmd.id;
-                            const icon = cmd.iconClass;
-                            const action: CommandMenu & AcceleratorSource = {
-                                id: command,
-                                sortString: order || '',
-                                isVisible: <T>(contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: any[]): boolean => {
-                                    if (item.when && !contextMatcher.match(item.when, context)) {
-                                        return false;
-                                    }
+                            const actionAdapter = contributionPointAdapter ?? identity;
+                            targets.forEach(target => {
+                                const menuPath = group ? [...target, group] : target;
 
-                                    return this.commandRegistry.isVisible(command, ...args);
-                                },
-                                icon: icon,
-                                label: label,
-                                isEnabled: (...args: any[]): boolean =>
-                                    this.commandRegistry.isEnabled(command, ...args),
-                                run: (...args: any[]): Promise<void> =>
-                                    this.commandRegistry.executeCommand(command, ...args),
-                                isToggled: () => false,
-                                getAccelerator: (context: HTMLElement | undefined): string[] => {
-                                    const bindings = this.keybindingRegistry.getKeybindingsForCommand(command);
-                                    // Only consider the first active keybinding.
-                                    if (bindings.length) {
-                                        const binding = bindings.find(b => this.keybindingRegistry.isEnabledInScope(b, context));
-                                        if (binding) {
-                                            return this.keybindingRegistry.acceleratorFor(binding, '+', true);
+                                const cmd = this.commandRegistry.getCommand(command);
+                                if (!cmd) {
+                                    console.debug(`No label for action menu node: No command "${command}" exists.`);
+                                    return;
+                                }
+                                const label = cmd.label || cmd.id;
+                                const icon = cmd.iconClass;
+                                const action: CommandMenu & AcceleratorSource = {
+                                    id: command,
+                                    sortString: order || '',
+                                    isVisible: <T>(contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: any[]): boolean => {
+                                        if (item.when && !contextMatcher.match(item.when, context)) {
+                                            return false;
+                                        }
+
+                                        return this.commandRegistry.isVisible(command, ...actionAdapter(...args));
+                                    },
+                                    icon: icon,
+                                    label: label,
+                                    isEnabled: (...args: any[]): boolean =>
+                                        this.commandRegistry.isEnabled(command, ...actionAdapter(...args)),
+                                    run: (...args: any[]): Promise<void> =>
+                                        this.commandRegistry.executeCommand(command, ...actionAdapter(...args)),
+                                    isToggled: () => false,
+                                    getAccelerator: (context: HTMLElement | undefined): string[] => {
+                                        const bindings = this.keybindingRegistry.getKeybindingsForCommand(command);
+                                        // Only consider the first active keybinding.
+                                        if (bindings.length) {
+                                            const binding = bindings.find(b => this.keybindingRegistry.isEnabledInScope(b, context));
+                                            if (binding) {
+                                                return this.keybindingRegistry.acceleratorFor(binding, '+', true);
+                                            }
                                         }
+                                        return [];
                                     }
-                                    return [];
-                                }
-                            };
-                            toDispose.push(this.menuRegistry.registerCommandMenu(menuPath, action));
+                                };
+                                toDispose.push(this.menuRegistry.registerCommandMenu(menuPath, action));
+                            });
                         } else if (submenu) {
-                            toDispose.push(this.menuRegistry.linkCompoundMenuNode({
+                            targets.forEach(target => toDispose.push(this.menuRegistry.linkCompoundMenuNode({
                                 newParentPath: group ? [...target, group] : target,
-                                submenuPath: [submenu],
+                                submenuPath: [submenu!],
                                 order: order,
                                 when: item.when,
-                            }));
+                                argumentAdapter: contributionPointAdapter
+                            })));
                         }
                     }
                 } catch (error) {