@theia/core 1.65.0-next.55 → 1.65.0

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

@@ -23,37 +23,36 @@ import { ACTION_ITEM, codicon } from '../../widgets';
 import { ContextMenuRenderer } from '../../context-menu-renderer';
 import { TabBarToolbarItem } from './tab-toolbar-item';
 import { ContextKeyService, ContextMatcher } from '../../context-key-service';
-import { CommandMenu, CompoundMenuNode, MenuModelRegistry, MenuNode, MenuPath, RenderedMenuNode } from '../../../common/menu';
+import { CommandMenu, CompoundMenuNode, ContextExpressionMatcher, Group, MenuModelRegistry, MenuNode, MenuPath, RenderedMenuNode, Submenu } from '../../../common/menu';
 
 export const TOOLBAR_WRAPPER_ID_SUFFIX = '-as-tabbar-toolbar-item';
 
 abstract class AbstractToolbarMenuWrapper {
 
     constructor(
-        protected readonly effectiveMenuPath: MenuPath,
+        readonly effectiveMenuPath: MenuPath,
         protected readonly commandRegistry: CommandRegistry,
         protected readonly menuRegistry: MenuModelRegistry,
         protected readonly contextKeyService: ContextKeyService,
         protected readonly contextMenuRenderer: ContextMenuRenderer) {
     }
 
-    protected abstract menuPath?: MenuPath;
-    protected abstract menuNode?: MenuNode;
+    protected abstract menuNode: MenuNode | undefined;
     protected abstract id: string;
     protected abstract icon: string | undefined;
     protected abstract tooltip: string | undefined;
     protected abstract text: string | undefined;
-    protected abstract executeCommand(e: React.MouseEvent<HTMLDivElement, MouseEvent>): void;
+    protected abstract executeCommand(widget: Widget, e: React.MouseEvent<HTMLDivElement, MouseEvent>): void;
 
-    isEnabled(): boolean {
+    isEnabled(widget: Widget): boolean {
         if (CommandMenu.is(this.menuNode)) {
-            return this.menuNode.isEnabled(this.effectiveMenuPath);
+            return this.menuNode.isEnabled(this.effectiveMenuPath, widget);
         }
         return true;
     }
-    isToggled(): boolean {
+    isToggled(widget: Widget): boolean {
         if (CommandMenu.is(this.menuNode) && this.menuNode.isToggled) {
-            return !!this.menuNode.isToggled(this.effectiveMenuPath);
+            return !!this.menuNode.isToggled(this.effectiveMenuPath, widget);
         }
         return false;
     }
@@ -61,9 +60,7 @@ abstract class AbstractToolbarMenuWrapper {
         return this.renderMenuItem(widget);
     }
 
-    toMenuNode?(): MenuNode | undefined {
-        return this.menuNode;
-    }
+    abstract toMenuNode(): MenuNode | undefined;
 
     /**
      * Presents the menu to popup on the `event` that is the clicking of
@@ -78,7 +75,7 @@ abstract class AbstractToolbarMenuWrapper {
         const anchor = toAnchor(event);
 
         this.contextMenuRenderer.render({
-            menuPath: menuPath,
+            menuPath: this.effectiveMenuPath,
             menu: this.menuNode as CompoundMenuNode,
             args: [widget],
             anchor,
@@ -102,9 +99,9 @@ abstract class AbstractToolbarMenuWrapper {
             return <div key={this.id} className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled menu'}>
                 <div className={className}
                     title={this.tooltip || this.text}
-                    onClick={e => this.executeCommand(e)}
+                    onClick={e => this.executeCommand(widget, e)}
                 />
-                <div className={ACTION_ITEM} onClick={event => this.showPopupMenu(widget, this.menuPath!, event, contextMatcher)} >
+                <div className={ACTION_ITEM} onClick={event => this.showPopupMenu(widget, this.effectiveMenuPath!, event, contextMatcher)} >
                     <div className={codicon('chevron-down') + ' chevron'} />
                 </div>
             </div>;
@@ -112,41 +109,67 @@ abstract class AbstractToolbarMenuWrapper {
             return <div key={this.id} className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled menu'}>
                 <div className={className}
                     title={this.tooltip || this.text}
-                    onClick={e => this.executeCommand(e)}
+                    onClick={e => this.executeCommand(widget, e)}
                 />
             </div>;
         }
     }
 }
 
-export class ToolbarMenuNodeWrapper extends AbstractToolbarMenuWrapper implements TabBarToolbarItem {
+export class SubmenuAsToolbarItemWrapper extends AbstractToolbarMenuWrapper implements TabBarToolbarItem {
     constructor(
         effectiveMenuPath: MenuPath,
         commandRegistry: CommandRegistry,
         menuRegistry: MenuModelRegistry,
         contextKeyService: ContextKeyService,
         contextMenuRenderer: ContextMenuRenderer,
-        protected readonly menuNode: MenuNode & RenderedMenuNode,
-        readonly group: string | undefined,
-        readonly menuPath?: MenuPath) {
+        protected readonly menuNode: Submenu,
+        readonly group: string | undefined) {
         super(effectiveMenuPath, commandRegistry, menuRegistry, contextKeyService, contextMenuRenderer);
     }
+    priority?: number | undefined;
 
-    executeCommand(e: React.MouseEvent<HTMLDivElement, MouseEvent>): void {
-        if (CommandMenu.is(this.menuNode)) {
-            this.menuNode.run(this.effectiveMenuPath);
-        }
+    executeCommand(widget: Widget, e: React.MouseEvent<HTMLDivElement, MouseEvent>): void {
     }
 
     isVisible(widget: Widget): boolean {
-        const menuNodeVisible = this.menuNode.isVisible(this.effectiveMenuPath, this.contextKeyService, widget.node);
-        if (CommandMenu.is(this.menuNode)) {
-            return menuNodeVisible;
-        } else if (CompoundMenuNode.is(this.menuNode)) {
-            return menuNodeVisible && !MenuModelRegistry.isEmpty(this.menuNode);
-        } else {
-            return menuNodeVisible;
-        }
+        const menuNodeVisible = this.menuNode.isVisible(this.effectiveMenuPath, this.contextKeyService, widget.node, widget);
+        return menuNodeVisible && !MenuModelRegistry.isEmpty(this.menuNode);
+    }
+
+    get id(): string { return this.menuNode.id + TOOLBAR_WRAPPER_ID_SUFFIX; }
+    get icon(): string | undefined { return this.menuNode.icon; }
+    get tooltip(): string | undefined { return this.menuNode.label; }
+    get text(): string | undefined {
+        return (this.group === NAVIGATION || this.group === undefined) ? undefined : this.menuNode.label;
+    }
+    get onDidChange(): Event<void> | undefined {
+        return this.menuNode.onDidChange;
+    }
+
+    override toMenuNode(): Group | undefined {
+        return new ToolbarItemAsSubmenuWrapper(this.menuNode!, this.effectiveMenuPath);
+    };
+}
+
+export class CommandMenuAsToolbarItemWrapper extends AbstractToolbarMenuWrapper implements TabBarToolbarItem {
+    constructor(
+        effectiveMenuPath: MenuPath,
+        commandRegistry: CommandRegistry,
+        menuRegistry: MenuModelRegistry,
+        contextKeyService: ContextKeyService,
+        contextMenuRenderer: ContextMenuRenderer,
+        protected readonly menuNode: CommandMenu,
+        readonly group: string | undefined) {
+        super(effectiveMenuPath, commandRegistry, menuRegistry, contextKeyService, contextMenuRenderer);
+    }
+
+    isVisible(widget: Widget): boolean {
+        return this.menuNode.isVisible(this.effectiveMenuPath, this.contextKeyService, widget.node, widget);
+    }
+
+    executeCommand(widget: Widget, e: React.MouseEvent<HTMLDivElement, MouseEvent>): void {
+        this.menuNode.run(this.effectiveMenuPath, widget);
     }
 
     get id(): string { return this.menuNode.id + TOOLBAR_WRAPPER_ID_SUFFIX; }
@@ -158,9 +181,13 @@ export class ToolbarMenuNodeWrapper extends AbstractToolbarMenuWrapper implement
     get onDidChange(): Event<void> | undefined {
         return this.menuNode.onDidChange;
     }
+
+    override toMenuNode(): MenuNode | undefined {
+        return new ToolbarItemAsCommandMenuWrapper(this.menuNode, this.effectiveMenuPath);
+    }
 }
 
-export class ToolbarSubmenuWrapper extends AbstractToolbarMenuWrapper implements TabBarToolbarItem {
+export class ToolbarActionWrapper extends AbstractToolbarMenuWrapper implements TabBarToolbarItem {
     constructor(
         effectiveMenuPath: MenuPath,
         commandRegistry: CommandRegistry,
@@ -176,7 +203,7 @@ export class ToolbarSubmenuWrapper extends AbstractToolbarMenuWrapper implements
         return this.toolbarItem.command ? this.commandRegistry.isEnabled(this.toolbarItem.command, widget) : !!this.toolbarItem.menuPath;
     }
 
-    protected executeCommand(e: React.MouseEvent<HTMLElement>, widget?: Widget): void {
+    protected executeCommand(widget: Widget, e: React.MouseEvent<HTMLElement>): void {
         e.preventDefault();
         e.stopPropagation();
 
@@ -232,8 +259,80 @@ export class ToolbarSubmenuWrapper extends AbstractToolbarMenuWrapper implements
         return this.toolbarItem.menuPath!;
     }
 
-    get menuNode(): MenuNode | undefined {
+    get menuNode(): CompoundMenuNode | undefined {
         return this.menuRegistry.getMenu(this.menuPath);
     }
+
+    override toMenuNode(): MenuNode | undefined {
+        return new ToolbarItemAsSubmenuWrapper(this.menuNode!, this.effectiveMenuPath);
+    }
 }
 
+/**
+ * This class wraps a menu node, but replaces the effective menu path. Command parameters need to be mapped
+ * for commands contributed by extension and this mapping is keyed by the menu path
+ */
+abstract class AbstractMenuNodeAsToolbarItemWrapper<T extends MenuNode> {
+    constructor(protected readonly menuNode: T, readonly effectiveMenuPath: MenuPath) { }
+
+    get label(): string | undefined {
+        if (RenderedMenuNode.is(this.menuNode)) {
+            return this.menuNode.label;
+        }
+    };
+    /**
+     * Icon classes for the menu node. If present, these will produce an icon to the left of the label in browser-style menus.
+     */
+    get icon(): string | undefined {
+        if (RenderedMenuNode.is(this.menuNode)) {
+            return this.menuNode.label;
+        }
+    }
+    get id(): string {
+        return this.menuNode.id;
+    }
+    get sortString(): string {
+        return this.menuNode.sortString;
+    }
+
+    isVisible<K>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<K>, context: K | undefined, ...args: unknown[]): boolean {
+        return this.menuNode!.isVisible(this.effectiveMenuPath, contextMatcher, context, args);
+    }
+}
+
+/**
+ * Wrapper form submenu nodes
+ */
+class ToolbarItemAsSubmenuWrapper extends AbstractMenuNodeAsToolbarItemWrapper<CompoundMenuNode> implements Group {
+
+    get contextKeyOverlays(): Record<string, string> | undefined {
+        return this.menuNode.contextKeyOverlays;
+    }
+    isEmpty<T>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: unknown[]): boolean {
+        return this.menuNode.isEmpty(this.effectiveMenuPath, contextMatcher, context, args);
+    }
+    get children(): MenuNode[] {
+        return this.menuNode.children;
+    }
+
+}
+/**
+ * Wrapper for command menus
+ */
+class ToolbarItemAsCommandMenuWrapper extends AbstractMenuNodeAsToolbarItemWrapper<CommandMenu> implements CommandMenu {
+
+    isEnabled(effectiveMenuPath: MenuPath, ...args: unknown[]): boolean {
+        return this.menuNode.isEnabled(this.effectiveMenuPath, ...args);
+    }
+    isToggled(effectiveMenuPath: MenuPath, ...args: unknown[]): boolean {
+        return this.menuNode.isToggled(this.effectiveMenuPath, ...args);
+    }
+    run(effectiveMenuPath: MenuPath, ...args: unknown[]): Promise<void> {
+        return this.menuNode.run(this.effectiveMenuPath, args);
+    }
+
+    override get label(): string {
+        return super.label!;
+    }
+
+}

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

@@ -22,7 +22,7 @@ import { ContextKeyService } from '../../context-key-service';
 import { FrontendApplicationContribution } from '../../frontend-application-contribution';
 import { Widget } from '../../widgets';
 import { ReactTabBarToolbarAction, RenderedToolbarAction } from './tab-bar-toolbar-types';
-import { ToolbarMenuNodeWrapper, ToolbarSubmenuWrapper } from './tab-bar-toolbar-menu-adapters';
+import { CommandMenuAsToolbarItemWrapper, SubmenuAsToolbarItemWrapper, ToolbarActionWrapper } from './tab-bar-toolbar-menu-adapters';
 import { KeybindingRegistry } from '../../keybinding';
 import { LabelParser } from '../../label-parser';
 import { ContextMenuRenderer } from '../../context-menu-renderer';
@@ -90,7 +90,7 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
             return this.doRegisterItem(new ReactToolbarItemImpl(this.commandRegistry, this.contextKeyService, item));
         } else {
             if (item.menuPath) {
-                return this.doRegisterItem(new ToolbarSubmenuWrapper(item.menuPath,
+                return this.doRegisterItem(new ToolbarActionWrapper(item.menuPath,
                     this.commandRegistry, this.menuRegistry, this.contextKeyService, this.contextMenuRenderer, item));
             } else {
                 const wrapper = new RenderedToolbarItemImpl(this.commandRegistry, this.contextKeyService, this.keybindingRegistry, this.labelParser, item);
@@ -146,13 +146,19 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
                                 for (const grandchild of child.children) {
                                     if (grandchild.isVisible([...delegate.menuPath, child.id, grandchild.id],
                                         this.contextKeyService, widget.node) && RenderedMenuNode.is(grandchild)) {
-                                        result.push(new ToolbarMenuNodeWrapper([...delegate.menuPath, child.id, grandchild.id], this.commandRegistry, this.menuRegistry,
-                                            this.contextKeyService, this.contextMenuRenderer, grandchild, child.id, delegate.menuPath));
+                                        if (CommandMenu.is(grandchild)) {
+                                            result.push(new CommandMenuAsToolbarItemWrapper([...delegate.menuPath, child.id, grandchild.id], this.commandRegistry,
+                                                this.menuRegistry, this.contextKeyService, this.contextMenuRenderer, grandchild, child.id));
+                                        } else if (CompoundMenuNode.is(grandchild)) {
+                                            result.push(new SubmenuAsToolbarItemWrapper([...delegate.menuPath, child.id, grandchild.id], this.commandRegistry, this.menuRegistry,
+                                                this.contextKeyService, this.contextMenuRenderer, grandchild, child.id));
+                                        }
+
                                     }
                                 }
                             } else if (CommandMenu.is(child)) {
-                                result.push(new ToolbarMenuNodeWrapper([...delegate.menuPath, child.id], this.commandRegistry, this.menuRegistry,
-                                    this.contextKeyService, this.contextMenuRenderer, child, undefined, delegate.menuPath));
+                                result.push(new CommandMenuAsToolbarItemWrapper([...delegate.menuPath, child.id], this.commandRegistry, this.menuRegistry,
+                                    this.contextKeyService, this.contextMenuRenderer, child, undefined));
                             }
                         }
                     }

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar.tsx

@@ -22,7 +22,7 @@ import { Anchor, ContextMenuAccess, ContextMenuRenderer } from '../../context-me
 import { LabelParser } from '../../label-parser';
 import { codicon, ReactWidget, Widget } from '../../widgets';
 import { TabBarToolbarRegistry } from './tab-bar-toolbar-registry';
-import { TabBarDelegator, TabBarToolbarAction } from './tab-bar-toolbar-types';
+import { TAB_BAR_TOOLBAR_CONTEXT_MENU, TabBarDelegator, TabBarToolbarAction } from './tab-bar-toolbar-types';
 import { KeybindingRegistry } from '../..//keybinding';
 import { TabBarToolbarItem } from './tab-toolbar-item';
 import { GroupImpl, MenuModelRegistry } from '../../../common/menu';
@@ -173,7 +173,7 @@ export class TabBarToolbar extends ReactWidget {
         }
         return this.contextMenuRenderer.render({
             menu: MenuModelRegistry.removeSingleRootNodes(menu),
-            menuPath: ['contextMenu'],
+            menuPath: TAB_BAR_TOOLBAR_CONTEXT_MENU,
             args: [this.current],
             anchor,
             context: this.current?.node || this.node,

package/src/browser/shell/tab-bar-toolbar/tab-toolbar-item.tsx

@@ -28,8 +28,8 @@ import { ActionMenuNode, GroupImpl, MenuNode } from '../../../common/menu';
 export interface TabBarToolbarItem {
     id: string;
     isVisible(widget: Widget): boolean;
-    isEnabled(widget?: Widget): boolean;
-    isToggled(): boolean;
+    isEnabled(widget: Widget): boolean;
+    isToggled(widget: Widget): boolean;
     render(widget?: Widget): React.ReactNode;
     onDidChange?: Event<void>;
     group?: string;

package/src/browser/shell/theia-dock-panel.ts

@@ -241,6 +241,13 @@ export class TheiaDockPanel extends DockPanel {
         }
         return undefined;
     }
+
+    override dispose(): void {
+        super.dispose();
+        this.onDidChangeCurrentEmitter.dispose();
+        this._currentTitle = undefined;
+        this.toDisposeOnMarkAsCurrent.dispose();
+    }
 }
 export namespace TheiaDockPanel {
     export const Factory = Symbol('TheiaDockPanel#Factory');

package/src/browser/tree/tree-widget.tsx

@@ -1442,9 +1442,10 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
             if (contextMenuPath) {
                 const { x, y } = event.nativeEvent;
                 const args = this.toContextMenuArgs(node);
+                const target = event.currentTarget;
                 setTimeout(() => this.contextMenuRenderer.render({
                     menuPath: contextMenuPath,
-                    context: event.currentTarget,
+                    context: target,
                     anchor: { x, y },
                     args
                 }), 10);

package/src/browser/view-container.ts

@@ -23,7 +23,7 @@ import {
 import { Event as CommonEvent, Emitter } from '../common/event';
 import { Disposable, DisposableCollection } from '../common/disposable';
 import { CommandRegistry } from '../common/command';
-import { MenuModelRegistry, MenuPath, MenuAction, SubmenuImpl, ActionMenuNode, MenuNode, RenderedMenuNode } from '../common/menu';
+import { MenuModelRegistry, MenuPath, MenuAction, SubmenuImpl, ActionMenuNode, Submenu } from '../common/menu';
 import { ApplicationShell, StatefulWidget, SplitPositionHandler, SplitPositionOptions, SIDE_PANEL_TOOLBAR_CONTEXT_MENU } from './shell';
 import { MAIN_AREA_ID, BOTTOM_AREA_ID } from './shell/theia-dock-panel';
 import { FrontendApplicationStateService } from './frontend-application-state';
@@ -40,7 +40,7 @@ import { ElementExt } from '@lumino/domutils';
 import { TabBarDecoratorService } from './shell/tab-bar-decorator';
 import { ContextKeyService } from './context-key-service';
 import { KeybindingRegistry } from './keybinding';
-import { ToolbarMenuNodeWrapper } from './shell/tab-bar-toolbar/tab-bar-toolbar-menu-adapters';
+import { SubmenuAsToolbarItemWrapper } from './shell/tab-bar-toolbar/tab-bar-toolbar-menu-adapters';
 import { TheiaSplitPanel } from './shell/theia-split-panel';
 
 export interface ViewContainerTitleOptions {
@@ -94,7 +94,7 @@ export namespace DynamicToolbarWidget {
     }
 }
 
-class PartsMenuToolbarItem extends ToolbarMenuNodeWrapper {
+class PartsMenuToolbarItem extends SubmenuAsToolbarItemWrapper {
     constructor(
         protected readonly target: () => Widget | undefined,
         effectiveMenuPath: MenuPath,
@@ -102,11 +102,11 @@ class PartsMenuToolbarItem extends ToolbarMenuNodeWrapper {
         menuRegistry: MenuModelRegistry,
         contextKeyService: ContextKeyService,
         contextMenuRenderer: ContextMenuRenderer,
-        menuNode: MenuNode & RenderedMenuNode,
+        menuNode: Submenu,
         group: string | undefined,
         menuPath?: MenuPath,
     ) {
-        super(effectiveMenuPath, commandRegistry, menuRegistry, contextKeyService, contextMenuRenderer, menuNode, group, menuPath);
+        super(effectiveMenuPath, commandRegistry, menuRegistry, contextKeyService, contextMenuRenderer, menuNode, group);
     }
 
     override isVisible(widget: Widget): boolean {

package/src/common/menu/menu-types.ts

@@ -39,6 +39,8 @@ export interface MenuNode {
      * Menu nodes are sorted in ascending order based on their `sortString`.
      */
     readonly sortString: string;
+
+    readonly effectiveMenuPath?: string[]; // override the path to be passed as the effectiveMenuPath
     isVisible<T>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: unknown[]): boolean;
     onDidChange?: Event<void>;
 }

package/src/common/stream.ts

@@ -26,6 +26,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { DisposableCollection, Disposable } from './disposable';
+import { BinaryBuffer } from './buffer';
 
 export interface ReadableStreamEvents<T> {
 
@@ -205,7 +206,7 @@ export interface ITransformer<Original, Transformed> {
 }
 
 export function newWriteableStream<T>(reducer: Reducer<T>, options?: WriteableStreamOptions): WriteableStream<T> {
-    return new WriteableStreamImpl<T>(reducer);
+    return new WriteableStreamImpl<T>(reducer, options);
 }
 
 export interface WriteableStreamOptions {
@@ -716,3 +717,103 @@ export function transform<Original, Transformed>(stream: ReadableStreamEvents<Or
 
     return target;
 }
+
+/**
+ * Convert File to ReadableStream<BinaryBuffer> for use in services which require ReadableStream
+ */
+export function fileToStream(file: File): ReadableStream<BinaryBuffer> {
+    const ws = newWriteableStream<BinaryBuffer>(BinaryBuffer.concat, { highWaterMark: 0 });
+
+    (async () => {
+        const reader = file.stream().getReader();
+
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done) {break;}
+
+                if (value?.byteLength) {
+                    await ws.write(BinaryBuffer.wrap(value));
+                }
+            }
+            ws.end();
+        } catch (e: unknown) {
+            try {
+                await reader.cancel();
+            } catch {}
+
+            ws.error(e instanceof Error ? e : new Error(String(e)));
+        }
+    })();
+
+    return ws as ReadableStream<BinaryBuffer>;
+}
+
+/**
+ * Convert BinaryBufferReadableStream to Web ReadableStream<Uint8Array>
+ */
+export function binaryStreamToWebStream(
+    binaryStream: ReadableStream<BinaryBuffer>,
+    abortSignal?: AbortSignal
+): globalThis.ReadableStream<Uint8Array> {
+    return new globalThis.ReadableStream<Uint8Array>({
+        start(controller) {
+            const cleanup = () => {
+                // Remove all event listeners
+                binaryStream.removeListener('data', onData);
+                binaryStream.removeListener('end', onEnd);
+                binaryStream.removeListener('error', onError);
+            };
+
+            const onAbort = () => {
+                cleanup();
+                controller.error(new Error('Operation aborted'));
+            };
+
+            if (abortSignal?.aborted) {
+                onAbort();
+                return;
+            }
+
+            if (abortSignal) {
+                abortSignal.addEventListener('abort', onAbort, { once: true });
+            }
+
+            const onData = (chunk: BinaryBuffer) => {
+                if (abortSignal?.aborted) {
+                    return;
+                }
+                try {
+                    // Convert BinaryBuffer to Uint8Array efficiently
+                    controller.enqueue(new Uint8Array(chunk.buffer));
+                } catch (error) {
+                    cleanup();
+                    if (abortSignal) {
+                        abortSignal.removeEventListener('abort', onAbort);
+                    }
+                    controller.error(error);
+                }
+            };
+
+            const onEnd = () => {
+                cleanup();
+                if (abortSignal) {
+                    abortSignal.removeEventListener('abort', onAbort);
+                }
+                controller.close();
+            };
+
+            const onError = (error: Error) => {
+                cleanup();
+                if (abortSignal) {
+                    abortSignal.removeEventListener('abort', onAbort);
+                }
+                controller.error(error);
+            };
+
+            binaryStream.on('data', onData);
+            binaryStream.on('end', onEnd);
+            binaryStream.on('error', onError);
+        }
+    });
+}

package/src/electron-browser/menu/electron-main-menu-factory.ts

@@ -175,7 +175,9 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
         const showDisabled = options?.showDisabled !== false;
         const honorDisabled = options?.honorDisabled !== false;
 
-        if (CompoundMenuNode.is(menu) && menu.children.length && menu.isVisible(menuPath, contextMatcher, options.context, ...args)) {
+        const effectivePath = menu.effectiveMenuPath || menuPath;
+
+        if (CompoundMenuNode.is(menu) && menu.children.length && menu.isVisible(effectivePath, contextMatcher, options.context, ...args)) {
             if (Group.is(menu) && menu.id === 'inline') {
                 return parentItems;
             }
@@ -186,7 +188,7 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
             }
             const children = menu.children;
             const myItems: MenuDto[] = [];
-            children.forEach(child => this.fillMenuTemplate(myItems, [...menuPath, child.id], child, args, contextMatcher, options, false));
+            children.forEach(child => this.fillMenuTemplate(myItems, [...effectivePath, child.id], child, args, contextMatcher, options, false));
             if (myItems.length === 0) {
                 return parentItems;
             }
@@ -200,12 +202,12 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
                 parentItems.push({ type: 'separator' });
             }
         } else if (CommandMenu.is(menu)) {
-            if (!menu.isVisible(menuPath, contextMatcher, options.context, ...args)) {
+            if (!menu.isVisible(effectivePath, contextMatcher, options.context, ...args)) {
                 return parentItems;
             }
 
             // We should omit rendering context-menu items which are disabled.
-            if (!showDisabled && !menu.isEnabled(menuPath, ...args)) {
+            if (!showDisabled && !menu.isEnabled(effectivePath, ...args)) {
                 return parentItems;
             }
 
@@ -214,15 +216,15 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
             const menuItem: MenuDto = {
                 id: menu.id,
                 label: menu.label,
-                type: menu.isToggled(menuPath, ...args) ? 'checkbox' : 'normal',
-                checked: menu.isToggled(menuPath, ...args),
-                enabled: !honorDisabled || menu.isEnabled(menuPath, ...args), // see https://github.com/eclipse-theia/theia/issues/446
+                type: menu.isToggled(effectivePath, ...args) ? 'checkbox' : 'normal',
+                checked: menu.isToggled(effectivePath, ...args),
+                enabled: !honorDisabled || menu.isEnabled(effectivePath, ...args), // see https://github.com/eclipse-theia/theia/issues/446
                 visible: true,
                 accelerator,
                 execute: async () => {
                     const wasToggled = menuItem.checked;
-                    await menu.run(menuPath, ...args);
-                    const isToggled = menu.isToggled(menuPath, ...args);
+                    await menu.run(effectivePath, ...args);
+                    const isToggled = menu.isToggled(effectivePath, ...args);
                     if (isToggled !== wasToggled) {
                         menuItem.type = isToggled ? 'checkbox' : 'normal';
                         menuItem.checked = isToggled;