@theia/core 1.62.0-next.3 → 1.62.1

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

@@ -14,19 +14,23 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Disposable } from '../disposable';
+import { Event } from '../event';
 import { isObject } from '../types';
 
-export type MenuPath = string[];
 export const MAIN_MENU_BAR: MenuPath = ['menubar'];
+export type MenuPath = string[];
 export const MANAGE_MENU: MenuPath = ['manage_menu'];
 export const ACCOUNTS_MENU: MenuPath = ['accounts_menu'];
 export const ACCOUNTS_SUBMENU = [...ACCOUNTS_MENU, '1_accounts_submenu'];
 
+export interface ContextExpressionMatcher<T> {
+    match(whenExpression: string, context: T | undefined): boolean;
+}
+
 /**
  * @internal For most use cases, refer to {@link MenuAction} or {@link MenuNode}
  */
-export interface MenuNodeMetadata {
+export interface MenuNode {
     /**
      * technical identifier.
      */
@@ -35,126 +39,103 @@ export interface MenuNodeMetadata {
      * Menu nodes are sorted in ascending order based on their `sortString`.
      */
     readonly sortString: string;
+    isVisible<T>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: unknown[]): boolean;
+    onDidChange?: Event<void>;
+}
+
+export interface Action {
+    isEnabled(effectiveMenuPath: MenuPath, ...args: unknown[]): boolean;
+    isToggled(effectiveMenuPath: MenuPath, ...args: unknown[]): boolean;
+    run(effectiveMenuPath: MenuPath, ...args: unknown[]): Promise<void>;
+}
+
+export namespace Action {
+    export function is(node: object): node is Action {
+        return isObject<Action>(node) && typeof node.run === 'function' && typeof node.isEnabled === 'function';
+    }
+}
+
+export interface MenuAction {
     /**
-     * Condition under which the menu node should be rendered.
-     * See https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts
+     * The command to execute.
      */
-    readonly when?: string;
+    readonly commandId: string;
     /**
-     * A reference to the parent node - useful for determining the menu path by which the node can be accessed.
+     * Menu entries are sorted in ascending order based on their `order` strings. If omitted the determined
+     * label will be used instead.
      */
-    readonly parent?: MenuNode;
-}
+    readonly order?: string;
 
-/**
- * Metadata for the visual presentation of a node.
- * @internal For most uses cases, refer to {@link MenuNode}, {@link CommandMenuNode}, or {@link CompoundMenuNode}
- */
-export interface MenuNodeRenderingData {
-    /**
-     * Optional label. Will be rendered as text of the menu item.
-     */
     readonly label?: string;
     /**
      * Icon classes for the menu node. If present, these will produce an icon to the left of the label in browser-style menus.
      */
     readonly icon?: string;
+
+    readonly when?: string;
 }
 
-/** @internal For most use cases refer to {@link MenuNode}, {@link CommandMenuNode}, or {@link CompoundMenuNode} */
-export interface MenuNodeBase extends MenuNodeMetadata, MenuNodeRenderingData { }
+export namespace MenuAction {
+    export function is(obj: unknown): obj is MenuAction {
+        return isObject<MenuAction>(obj) && typeof obj.commandId === 'string';
+    }
+}
 
 /**
- * A menu entry representing an action, e.g. "New File".
+ * Metadata for the visual presentation of a node.
+ * @internal For most uses cases, refer to {@link MenuNode}, {@link CommandMenuNode}, or {@link CompoundMenuNode}
  */
-export interface MenuAction extends MenuNodeRenderingData, Pick<MenuNodeMetadata, 'when'> {
-
+export interface RenderedMenuNode extends MenuNode {
     /**
-     * The command to execute.
-     */
-    commandId: string;
-    /**
-     * In addition to the mandatory command property, an alternative command can be defined.
-     * It will be shown and invoked when pressing Alt while opening a menu.
+     * Optional label. Will be rendered as text of the menu item.
      */
-    alt?: string;
+    readonly label: string;
     /**
-     * Menu entries are sorted in ascending order based on their `order` strings. If omitted the determined
-     * label will be used instead.
+     * Icon classes for the menu node. If present, these will produce an icon to the left of the label in browser-style menus.
      */
-    order?: string;
+    readonly icon?: string;
 }
 
-export namespace MenuAction {
-    /* Determine whether object is a MenuAction */
-    export function is(arg: unknown): arg is MenuAction {
-        return isObject(arg) && 'commandId' in arg;
+export namespace RenderedMenuNode {
+    export function is(node: object): node is RenderedMenuNode {
+        return isObject<RenderedMenuNode>(node) && typeof node.label === 'string';
     }
 }
 
-/**
- * Additional options when creating a new submenu.
- */
-export interface SubMenuOptions extends Pick<MenuAction, 'order'>, Pick<MenuNodeMetadata, 'when'>, Partial<Pick<CompoundMenuNode, 'role' | 'label' | 'icon'>> {
-    /**
-     * The class to use for the submenu icon.
-     * @deprecated use `icon` instead;
-     */
-    iconClass?: string;
-}
+export type CommandMenu = MenuNode & RenderedMenuNode & Action;
 
-export const enum CompoundMenuNodeRole {
-    /** Indicates that the node should be rendered as submenu that opens a new menu on hover */
-    Submenu,
-    /** Indicates that the node's children should be rendered as group separated from other items by a separator */
-    Group,
-    /** Indicates that the node's children should be treated as though they were direct children of the node's parent */
-    Flat,
+export namespace CommandMenu {
+    export function is(node: MenuNode): node is CommandMenu {
+        return RenderedMenuNode.is(node) && Action.is(node);
+    }
 }
 
-export interface CompoundMenuNode extends MenuNodeBase {
-    /**
-     * Items that are grouped under this menu.
-     */
-    readonly children: ReadonlyArray<MenuNode>
-    /**
-     * @deprecated @since 1.28 use `role` instead.
-     * Whether the item should be rendered as a submenu.
-     */
-    readonly isSubmenu: boolean;
-    /**
-     * How the node and its children should be rendered. See {@link CompoundMenuNodeRole}.
-     */
-    readonly role: CompoundMenuNodeRole;
+export type Group = CompoundMenuNode;
+export namespace Group {
+    export function is(obj: unknown): obj is Group {
+        return CompoundMenuNode.is(obj) && !RenderedMenuNode.is(obj);
+    }
 }
 
-export interface MutableCompoundMenuNode extends CompoundMenuNode {
-    /**
-     * Inserts the given node at the position indicated by `sortString`.
-     *
-     * @returns a disposable which, when called, will remove the given node again.
-     */
-    addNode(node: MenuNode): Disposable;
-    /**
-     * Removes the first node with the given id.
-     *
-     * @param id node id.
-     * @returns true if the id was present
-     */
-    removeNode(id: string): boolean;
+export type Submenu = CompoundMenuNode & RenderedMenuNode;
 
+export interface CompoundMenuNode extends MenuNode {
+    children: MenuNode[];
+    contextKeyOverlays?: Record<string, string>;
     /**
-     * Fills any `undefined` fields with the values from the {@link options}.
+     * Whether the group or submenu contains any visible children
+     *
+     * @param effectiveMenuPath The menu path where visibility is checked
+     * @param contextMatcher The context matcher to use
+     * @param context the context to use
+     * @param args the command arguments, if applicable
      */
-    updateOptions(options: SubMenuOptions): void;
-}
+    isEmpty<T>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: unknown[]): boolean;
+};
 
 export namespace CompoundMenuNode {
-    export function is(node?: MenuNode): node is CompoundMenuNode { return !!node && Array.isArray(node.children); }
-    export function getRole(node: MenuNode): CompoundMenuNodeRole | undefined {
-        if (!is(node)) { return undefined; }
-        return node.role ?? (node.label ? CompoundMenuNodeRole.Submenu : CompoundMenuNodeRole.Group);
-    }
+    export function is(node?: unknown): node is CompoundMenuNode { return isObject<CompoundMenuNode>(node) && Array.isArray(node.children); }
+
     export function sortChildren(m1: MenuNode, m2: MenuNode): number {
         // The navigation group is special as it will always be sorted to the top/beginning of a menu.
         if (isNavigationGroup(m1)) {
@@ -166,18 +147,6 @@ export namespace CompoundMenuNode {
         return m1.sortString.localeCompare(m2.sortString);
     }
 
-    /** Collapses the children of any subemenus with role {@link CompoundMenuNodeRole Flat} and sorts */
-    export function getFlatChildren(children: ReadonlyArray<MenuNode>): MenuNode[] {
-        const childrenToMerge: ReadonlyArray<MenuNode>[] = [];
-        return children.filter(child => {
-            if (getRole(child) === CompoundMenuNodeRole.Flat) {
-                childrenToMerge.push((child as CompoundMenuNode).children);
-                return false;
-            }
-            return true;
-        }).concat(...childrenToMerge).sort(sortChildren);
-    }
-
     /**
      * Indicates whether the given node is the special `navigation` menu.
      *
@@ -188,34 +157,19 @@ export namespace CompoundMenuNode {
     export function isNavigationGroup(node: MenuNode): node is CompoundMenuNode {
         return is(node) && node.id === 'navigation';
     }
-
-    export function isMutable(node?: MenuNode): node is MutableCompoundMenuNode {
-        const candidate = node as MutableCompoundMenuNode;
-        return is(candidate) && typeof candidate.addNode === 'function' && typeof candidate.removeNode === 'function';
-    }
 }
 
-export interface CommandMenuNode extends MenuNodeBase {
-    command: string;
-}
-
-export namespace CommandMenuNode {
-    export function is(candidate?: MenuNode): candidate is CommandMenuNode { return Boolean(candidate?.command); }
-    export function hasAltHandler(candidate?: MenuNode): candidate is AlternativeHandlerMenuNode {
-        const asAltNode = candidate as AlternativeHandlerMenuNode;
-        return is(asAltNode) && is(asAltNode?.altNode);
+export interface MutableCompoundMenuNode {
+    addNode(...node: MenuNode[]): void;
+    removeNode(node: MenuNode): void;
+    getOrCreate(menuPath: MenuPath, pathIndex: number, endIndex: number): CompoundMenuNode & MutableCompoundMenuNode;
+};
+
+export namespace MutableCompoundMenuNode {
+    export function is(node: unknown): node is MutableCompoundMenuNode {
+        return isObject<MutableCompoundMenuNode>(node)
+            && typeof node.addNode === 'function'
+            && typeof node.removeNode === 'function'
+            && typeof node.getOrCreate === 'function';
     }
 }
-
-export interface AlternativeHandlerMenuNode extends CommandMenuNode {
-    altNode: CommandMenuNode;
-}
-
-/**
- * Base interface of the nodes used in the menu tree structure.
- */
-export type MenuNode = MenuNodeMetadata
-    & MenuNodeRenderingData
-    & Partial<CompoundMenuNode>
-    & Partial<CommandMenuNode>
-    & Partial<AlternativeHandlerMenuNode>;

package/src/common/messaging/proxy-factory.ts

@@ -237,6 +237,10 @@ export class RpcProxyFactory<T extends object> implements ProxyHandler<T> {
             // Prevent inversify from identifying this proxy as a promise object.
             return undefined;
         }
+        if (p === 'toJSON') {
+            // Prevent packr from attempting to serialize proxies with `toJSON`.
+            return undefined;
+        }
         const isNotify = this.isNotification(p);
         return (...args: any[]) => {
             const method = p.toString();
@@ -333,4 +337,3 @@ export class JsonRpcProxyFactory<T extends object> extends RpcProxyFactory<T> {
 decorate(injectable(), JsonRpcProxyFactory);
 // eslint-disable-next-line deprecation/deprecation
 decorate(unmanaged(), JsonRpcProxyFactory, 0);
-

package/src/electron-browser/menu/electron-context-menu-renderer.ts

@@ -18,12 +18,14 @@
 
 import { inject, injectable, postConstruct } from 'inversify';
 import {
-    ContextMenuRenderer, RenderContextMenuOptions, ContextMenuAccess, FrontendApplicationContribution, CommonCommands, coordinateFromAnchor, PreferenceService
+    ContextMenuRenderer, ContextMenuAccess, FrontendApplicationContribution, CommonCommands, coordinateFromAnchor, PreferenceService,
+    Anchor
 } from '../../browser';
 import { ElectronMainMenuFactory } from './electron-main-menu-factory';
 import { ContextMenuContext } from '../../browser/menu/context-menu-context';
-import { MenuPath, MenuContribution, MenuModelRegistry } from '../../common';
 import { BrowserContextMenuAccess, BrowserContextMenuRenderer } from '../../browser/menu/browser-context-menu-renderer';
+import { MenuPath, MenuContribution, MenuModelRegistry, CompoundMenuNode } from '../../common/menu';
+import { ContextKeyService, ContextMatcher } from '../../browser/context-key-service';
 
 export class ElectronContextMenuAccess extends ContextMenuAccess {
     constructor(readonly menuHandle: Promise<number>) {
@@ -46,6 +48,9 @@ export class ElectronTextInputContextMenuContribution implements FrontendApplica
     @inject(ContextMenuRenderer)
     protected readonly contextMenuRenderer: ContextMenuRenderer;
 
+    @inject(ContextKeyService)
+    protected readonly contextKeyService: ContextKeyService;
+
     onStart(): void {
         window.document.addEventListener('contextmenu', event => {
             if (event.target instanceof HTMLElement) {
@@ -55,6 +60,7 @@ export class ElectronTextInputContextMenuContribution implements FrontendApplica
                     event.stopPropagation();
                     this.contextMenuRenderer.render({
                         anchor: event,
+                        contextKeyService: this.contextKeyService,
                         menuPath: ElectronTextInputContextMenu.MENU_PATH,
                         context: event.target,
                         onHide: () => target.focus()
@@ -84,10 +90,13 @@ export class ElectronContextMenuRenderer extends BrowserContextMenuRenderer {
     @inject(PreferenceService)
     protected readonly preferenceService: PreferenceService;
 
+    @inject(ElectronMainMenuFactory)
+    protected readonly electronMenuFactory: ElectronMainMenuFactory;
+
     protected useNativeStyle: boolean = true;
 
-    constructor(@inject(ElectronMainMenuFactory) private electronMenuFactory: ElectronMainMenuFactory) {
-        super(electronMenuFactory);
+    constructor() {
+        super();
     }
 
     @postConstruct()
@@ -99,24 +108,31 @@ export class ElectronContextMenuRenderer extends BrowserContextMenuRenderer {
         this.useNativeStyle = await window.electronTheiaCore.getTitleBarStyleAtStartup() === 'native';
     }
 
-    protected override doRender(options: RenderContextMenuOptions): ContextMenuAccess {
+    protected override doRender(params: {
+        menuPath: MenuPath,
+        menu: CompoundMenuNode,
+        anchor: Anchor,
+        contextMatcher: ContextMatcher,
+        args?: any,
+        context?: HTMLElement,
+        onHide?: () => void
+    }): ContextMenuAccess {
         if (this.useNativeStyle) {
-            const { menuPath, anchor, args, onHide, context, contextKeyService, skipSingleRootNode } = options;
-            const menu = this.electronMenuFactory.createElectronContextMenu(menuPath, args, context, contextKeyService, skipSingleRootNode);
-            const { x, y } = coordinateFromAnchor(anchor);
+            const contextMenu = this.electronMenuFactory.createElectronContextMenu(params.menuPath, params.menu, params.contextMatcher, params.args, params.context);
+            const { x, y } = coordinateFromAnchor(params.anchor);
 
-            const windowName = options.context?.ownerDocument.defaultView?.Window.name;
+            const windowName = params.context?.ownerDocument.defaultView?.Window.name;
 
-            const menuHandle = window.electronTheiaCore.popup(menu, x, y, () => {
-                if (onHide) {
-                    onHide();
+            const menuHandle = window.electronTheiaCore.popup(contextMenu, x, y, () => {
+                if (params.onHide) {
+                    params.onHide();
                 }
             }, windowName);
             // native context menu stops the event loop, so there is no keyboard events
             this.context.resetAltPressed();
             return new ElectronContextMenuAccess(menuHandle);
         } else {
-            const menuAccess = super.doRender(options);
+            const menuAccess = super.doRender(params);
             const node = (menuAccess as BrowserContextMenuAccess).menu.node;
             const topPanelHeight = document.getElementById('theia-top-panel')?.clientHeight ?? 0;
             // ensure the context menu is not displayed outside of the main area