@theia/core 1.28.0-next.7 → 1.28.0

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

@@ -0,0 +1,183 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+/**
+ * A menu entry representing an action, e.g. "New File".
+ */
+export interface MenuAction extends MenuNodeRenderingData, Pick<MenuNodeMetadata, 'when'> {
+    /**
+     * 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.
+     */
+    alt?: string;
+    /**
+     * Menu entries are sorted in ascending order based on their `order` strings. If omitted the determined
+     * label will be used instead.
+     */
+    order?: string;
+}
+
+export namespace MenuAction {
+    /* Determine whether object is a MenuAction */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    export function is(arg: MenuAction | any): arg is MenuAction {
+        return !!arg && arg === Object(arg) && 'commandId' in arg;
+    }
+}
+
+/**
+ * Additional options when creating a new submenu.
+ */
+export interface SubMenuOptions extends Pick<MenuAction, 'order'>, Pick<MenuNodeMetadata, 'when'>, Partial<Pick<CompoundMenuNodeMetadata, 'role'>> {
+    /**
+     * The class to use for the submenu icon.
+     */
+    iconClass?: string;
+}
+
+export type MenuPath = string[];
+
+export const MAIN_MENU_BAR: MenuPath = ['menubar'];
+
+export const SETTINGS_MENU: MenuPath = ['settings_menu'];
+export const ACCOUNTS_MENU: MenuPath = ['accounts_menu'];
+export const ACCOUNTS_SUBMENU = [...ACCOUNTS_MENU, '1_accounts_submenu'];
+
+export interface MenuNodeMetadata {
+    /**
+     * technical identifier.
+     */
+    readonly id: string;
+    /**
+     * Menu nodes are sorted in ascending order based on their `sortString`.
+     */
+    readonly sortString: string;
+    /**
+     * Condition under which the menu node should be rendered.
+     * See https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts
+     */
+    readonly when?: string;
+    /**
+     * A reference to the parent node - useful for determining the menu path by which the node can be accessed.
+     */
+    readonly parent?: MenuNode;
+}
+
+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;
+}
+
+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 interface CompoundMenuNode {
+    /**
+     * Items that are grouped under this menu.
+     */
+    readonly children: ReadonlyArray<MenuNode>
+}
+
+export namespace CompoundMenuNode {
+    export function is(node: MenuNode): node is MenuNode & CompoundMenuNode { return 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 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)) {
+            return -1;
+        }
+        if (isNavigationGroup(m2)) {
+            return 1;
+        }
+        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.
+     *
+     * @param node the menu node to check.
+     * @returns `true` when the given node is a {@link CompoundMenuNode} with id `navigation`,
+     * `false` otherwise.
+     */
+    export function isNavigationGroup(node: MenuNode): node is MenuNode & CompoundMenuNode {
+        return is(node) && node.id === 'navigation';
+    }
+}
+
+export interface CompoundMenuNodeMetadata {
+    /**
+     * @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 interface CommandMenuNode {
+    command: string;
+}
+
+export namespace CommandMenuNode {
+    export function is(candidate: MenuNode): candidate is MenuNode & CommandMenuNode { return Boolean(candidate.command); }
+}
+
+export interface AlternativeHandlerMenuNode {
+    altNode: MenuNodeMetadata & MenuNodeRenderingData & CommandMenuNode;
+}
+
+/**
+ * Base interface of the nodes used in the menu tree structure.
+ */
+export interface MenuNode extends MenuNodeMetadata,
+    MenuNodeRenderingData,
+    Partial<CompoundMenuNode>,
+    Partial<CommandMenuNode>,
+    Partial<CompoundMenuNodeMetadata>,
+    Partial<AlternativeHandlerMenuNode> { }

package/src/common/{menu.spec.ts → menu/menu.spec.ts}

@@ -14,9 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { CommandContribution, CommandRegistry } from './command';
-import { CompositeMenuNode, MenuContribution, MenuModelRegistry } from './menu';
+import { CommandContribution, CommandRegistry } from '../command';
+import { MenuContribution, MenuModelRegistry } from './menu-model-registry';
 import * as chai from 'chai';
+import { CompositeMenuNode } from './composite-menu-node';
 
 const expect = chai.expect;
 

package/src/common/message-rpc/rpc-message-encoder.ts

@@ -92,17 +92,18 @@ export enum ObjectType {
     JSON = 0,
     ByteArray = 1,
     ObjectArray = 2,
-    Undefined = 3,
-    Object = 4,
-    String = 5,
-    Boolean = 6,
-    Number = 7,
+    Null = 3,
+    Undefined = 4,
+    Object = 5,
+    String = 6,
+    Boolean = 7,
+    Number = 8,
     // eslint-disable-next-line @typescript-eslint/no-shadow
-    ResponseError = 8,
-    Error = 9,
-    Map = 10,
-    Set = 11,
-    Function = 12
+    ResponseError = 9,
+    Error = 10,
+    Map = 11,
+    Set = 12,
+    Function = 13
 
 }
 
@@ -110,7 +111,7 @@ export enum ObjectType {
  * A value encoder writes javascript values to a write buffer. Encoders will be asked
  * in turn (ordered by their tag value, descending) whether they can encode a given value
  * This means encoders with higher tag values have priority. Since the default encoders
- * have tag values from 1-12, they can be easily overridden.
+ * have tag values from 1-13, they can be easily overridden.
  */
 export interface ValueEncoder {
     /**
@@ -200,6 +201,11 @@ export class RpcMessageDecoder {
             read: () => undefined
         });
 
+        this.registerDecoder(ObjectType.Null, {
+            // eslint-disable-next-line no-null/no-null
+            read: () => null
+        });
+
         this.registerDecoder(ObjectType.Object, {
             read: (buf, recursiveRead) => {
                 const propertyCount = buf.readLength();
@@ -429,9 +435,14 @@ export class RpcMessageEncoder {
             write: (buf, value: Set<any>, visitedObjects) => this.writeArray(buf, [...value], visitedObjects)
         });
 
-        this.registerEncoder(ObjectType.Undefined, {
+        this.registerEncoder(ObjectType.Null, {
             // eslint-disable-next-line no-null/no-null
-            is: value => value == null,
+            is: value => value === null,
+            write: () => { }
+        });
+
+        this.registerEncoder(ObjectType.Undefined, {
+            is: value => value === undefined,
             write: () => { }
         });
 

package/src/common/messaging/abstract-connection-provider.ts

@@ -71,7 +71,7 @@ export abstract class AbstractConnectionProvider<AbstractOptions extends object>
         return factory.createProxy();
     }
 
-    protected channelMultiPlexer?: ChannelMultiplexer;
+    protected channelMultiplexer?: ChannelMultiplexer;
 
     // A set of channel opening functions that are executed if the backend reconnects to restore the
     // the channels that were open before the disconnect occurred.
@@ -80,7 +80,7 @@ export abstract class AbstractConnectionProvider<AbstractOptions extends object>
     protected initializeMultiplexer(): void {
         const mainChannel = this.createMainChannel();
         mainChannel.onMessage(() => this.onIncomingMessageActivityEmitter.fire());
-        this.channelMultiPlexer = new ChannelMultiplexer(mainChannel);
+        this.channelMultiplexer = new ChannelMultiplexer(mainChannel);
     }
 
     /**
@@ -93,10 +93,10 @@ export abstract class AbstractConnectionProvider<AbstractOptions extends object>
     }
 
     async openChannel(path: string, handler: (channel: Channel) => void, options?: AbstractOptions): Promise<void> {
-        if (!this.channelMultiPlexer) {
+        if (!this.channelMultiplexer) {
             throw new Error('The channel multiplexer has not been initialized yet!');
         }
-        const newChannel = await this.channelMultiPlexer.open(path);
+        const newChannel = await this.channelMultiplexer.open(path);
         newChannel.onClose(() => {
             const { reconnecting } = { reconnecting: true, ...options };
             if (reconnecting) {

package/src/common/quick-pick-service.ts

@@ -195,6 +195,7 @@ export interface QuickPick<T extends QuickPickItemOrSeparator> extends QuickInpu
 }
 
 export interface PickOptions<T extends QuickPickItem> {
+    title?: string;
     placeHolder?: string;
     matchOnDescription?: boolean;
     matchOnDetail?: boolean;

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

@@ -101,8 +101,8 @@ export class ElectronContextMenuRenderer extends BrowserContextMenuRenderer {
 
     protected override doRender(options: RenderContextMenuOptions): ContextMenuAccess {
         if (this.useNativeStyle) {
-            const { menuPath, anchor, args, onHide } = options;
-            const menu = this.electronMenuFactory.createElectronContextMenu(menuPath, args);
+            const { menuPath, anchor, args, onHide, context } = options;
+            const menu = this.electronMenuFactory.createElectronContextMenu(menuPath, args, context);
             const { x, y } = coordinateFromAnchor(anchor);
             const zoom = electron.webFrame.getZoomFactor();
             // TODO: Remove the offset once Electron fixes https://github.com/electron/electron/issues/31641

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

@@ -18,9 +18,7 @@
 
 import * as electronRemote from '../../../electron-shared/@electron/remote';
 import { inject, injectable, postConstruct } from 'inversify';
-import {
-    isOSX, ActionMenuNode, CompositeMenuNode, MAIN_MENU_BAR, MenuPath, MenuNode
-} from '../../common';
+import { isOSX, MAIN_MENU_BAR, MenuPath, MenuNode, CommandMenuNode, CompoundMenuNode, CompoundMenuNodeRole } from '../../common';
 import { Keybinding } from '../../common/keybinding';
 import { PreferenceService, CommonCommands } from '../../browser';
 import debounce = require('lodash.debounce');
@@ -36,6 +34,15 @@ export interface ElectronMenuOptions {
      * Defaults to `true`.
      */
     readonly showDisabled?: boolean;
+    /**
+     * A DOM context to use when evaluating any `when` clauses
+     * of menu items registered for this item.
+     */
+    context?: HTMLElement;
+    /**
+     * The root menu path for which the menu is being built.
+     */
+    rootMenuPath: MenuPath
 }
 
 /**
@@ -100,7 +107,7 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
         const maxWidget = document.getElementsByClassName(MAXIMIZED_CLASS);
         if (preference === 'visible' || (preference === 'classic' && maxWidget.length === 0)) {
             const menuModel = this.menuProvider.getMenu(MAIN_MENU_BAR);
-            const template = this.fillMenuTemplate([], menuModel);
+            const template = this.fillMenuTemplate([], menuModel, [], { rootMenuPath: MAIN_MENU_BAR });
             if (isOSX) {
                 template.unshift(this.createOSXMenu());
             }
@@ -116,111 +123,90 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
         return null;
     }
 
-    createElectronContextMenu(menuPath: MenuPath, args?: any[]): Electron.Menu {
+    createElectronContextMenu(menuPath: MenuPath, args?: any[], context?: HTMLElement): Electron.Menu {
         const menuModel = this.menuProvider.getMenu(menuPath);
-        const template = this.fillMenuTemplate([], menuModel, args, { showDisabled: false });
+        const template = this.fillMenuTemplate([], menuModel, args, { showDisabled: false, context, rootMenuPath: menuPath });
         return electronRemote.Menu.buildFromTemplate(template);
     }
 
-    protected fillMenuTemplate(items: Electron.MenuItemConstructorOptions[],
-        menuModel: CompositeMenuNode,
-        args: any[] = [],
-        options?: ElectronMenuOptions
+    protected fillMenuTemplate(parentItems: Electron.MenuItemConstructorOptions[],
+        menu: MenuNode,
+        args: unknown[] = [],
+        options: ElectronMenuOptions
     ): Electron.MenuItemConstructorOptions[] {
-        const showDisabled = (options?.showDisabled === undefined) ? true : options?.showDisabled;
-        for (const menu of menuModel.children) {
-            if (menu instanceof CompositeMenuNode) {
-                if (menu.children.length > 0) {
-                    // do not render empty nodes
-
-                    if (menu.isSubmenu) { // submenu node
-
-                        const submenu = this.fillMenuTemplate([], menu, args, options);
-                        if (submenu.length === 0) {
-                            continue;
-                        }
-
-                        items.push({
-                            label: menu.label,
-                            submenu
-                        });
-
-                    } else { // group node
-
-                        // process children
-                        const submenu = this.fillMenuTemplate([], menu, args, options);
-                        if (submenu.length === 0) {
-                            continue;
-                        }
-
-                        if (items.length > 0) {
-                            // do not put a separator above the first group
-
-                            items.push({
-                                type: 'separator'
-                            });
-                        }
-
-                        // render children
-                        items.push(...submenu);
-                    }
-                }
-            } else if (menu instanceof ActionMenuNode) {
-                const node = menu.altNode && this.context.altPressed ? menu.altNode : menu;
-                const commandId = node.action.commandId;
-
-                // That is only a sanity check at application startup.
-                if (!this.commandRegistry.getCommand(commandId)) {
-                    console.debug(`Skipping menu item with missing command: "${commandId}".`);
-                    continue;
+        const showDisabled = options?.showDisabled !== false;
+
+        if (CompoundMenuNode.is(menu) && menu.children.length && this.undefinedOrMatch(menu.when, options.context)) {
+            const role = CompoundMenuNode.getRole(menu);
+            if (role === CompoundMenuNodeRole.Group && menu.id === 'inline') { return parentItems; }
+            const children = CompoundMenuNode.getFlatChildren(menu.children);
+            const myItems: Electron.MenuItemConstructorOptions[] = [];
+            children.forEach(child => this.fillMenuTemplate(myItems, child, args, options));
+            if (myItems.length === 0) { return parentItems; }
+            if (role === CompoundMenuNodeRole.Submenu) {
+                parentItems.push({ label: menu.label, submenu: myItems });
+            } else if (role === CompoundMenuNodeRole.Group && menu.id !== 'inline') {
+                if (parentItems.length && parentItems[parentItems.length - 1].type !== 'separator') {
+                    parentItems.push({ type: 'separator' });
                 }
+                parentItems.push(...myItems);
+                parentItems.push({ type: 'separator' });
+            }
+        } else if (menu.command) {
+            const node = menu.altNode && this.context.altPressed ? menu.altNode : (menu as MenuNode & CommandMenuNode);
+            const commandId = node.command;
+
+            // That is only a sanity check at application startup.
+            if (!this.commandRegistry.getCommand(commandId)) {
+                console.debug(`Skipping menu item with missing command: "${commandId}".`);
+                return parentItems;
+            }
 
-                if (!this.commandRegistry.isVisible(commandId, ...args)
-                    || (!!node.action.when && !this.contextKeyService.match(node.action.when))) {
-                    continue;
-                }
+            if (!this.menuCommandExecutor.isVisible(options.rootMenuPath, commandId, ...args) || !this.undefinedOrMatch(node.when, options.context)) {
+                return parentItems;
+            }
 
-                // We should omit rendering context-menu items which are disabled.
-                if (!showDisabled && !this.commandRegistry.isEnabled(commandId, ...args)) {
-                    continue;
-                }
+            // We should omit rendering context-menu items which are disabled.
+            if (!showDisabled && !this.menuCommandExecutor.isEnabled(options.rootMenuPath, commandId, ...args)) {
+                return parentItems;
+            }
 
-                const bindings = this.keybindingRegistry.getKeybindingsForCommand(commandId);
+            const bindings = this.keybindingRegistry.getKeybindingsForCommand(commandId);
 
-                const accelerator = bindings[0] && this.acceleratorFor(bindings[0]);
+            const accelerator = bindings[0] && this.acceleratorFor(bindings[0]);
 
-                const menuItem: Electron.MenuItemConstructorOptions = {
-                    id: node.id,
-                    label: node.label,
-                    type: this.commandRegistry.getToggledHandler(commandId, ...args) ? 'checkbox' : 'normal',
-                    checked: this.commandRegistry.isToggled(commandId, ...args),
-                    enabled: true, // https://github.com/eclipse-theia/theia/issues/446
-                    visible: true,
-                    accelerator,
-                    click: () => this.execute(commandId, args)
-                };
+            const menuItem: Electron.MenuItemConstructorOptions = {
+                id: node.id,
+                label: node.label,
+                type: this.commandRegistry.getToggledHandler(commandId, ...args) ? 'checkbox' : 'normal',
+                checked: this.commandRegistry.isToggled(commandId, ...args),
+                enabled: true, // https://github.com/eclipse-theia/theia/issues/446
+                visible: true,
+                accelerator,
+                click: () => this.execute(commandId, args, options.rootMenuPath)
+            };
 
-                if (isOSX) {
-                    const role = this.roleFor(node.id);
-                    if (role) {
-                        menuItem.role = role;
-                        delete menuItem.click;
-                    }
+            if (isOSX) {
+                const role = this.roleFor(node.id);
+                if (role) {
+                    menuItem.role = role;
+                    delete menuItem.click;
                 }
-                items.push(menuItem);
+            }
+            parentItems.push(menuItem);
 
-                if (this.commandRegistry.getToggledHandler(commandId, ...args)) {
-                    this._toggledCommands.add(commandId);
-                }
-            } else {
-                items.push(...this.handleElectronDefault(menu, args, options));
+            if (this.commandRegistry.getToggledHandler(commandId, ...args)) {
+                this._toggledCommands.add(commandId);
             }
         }
-        return items;
+        return parentItems;
     }
 
-    protected handleElectronDefault(menuNode: MenuNode, args: any[] = [], options?: ElectronMenuOptions): Electron.MenuItemConstructorOptions[] {
-        return [];
+    protected undefinedOrMatch(expression?: string, context?: HTMLElement): boolean {
+        if (expression) {
+            return this.contextKeyService.match(expression, context);
+        }
+        return true;
     }
 
     /**
@@ -268,17 +254,17 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
         return role;
     }
 
-    protected async execute(command: string, args: any[]): Promise<void> {
+    protected async execute(command: string, args: any[], menuPath: MenuPath): Promise<void> {
         try {
             // This is workaround for https://github.com/eclipse-theia/theia/issues/446.
             // Electron menus do not update based on the `isEnabled`, `isVisible` property of the command.
             // We need to check if we can execute it.
-            if (this.commandRegistry.isEnabled(command, ...args)) {
-                await this.commandRegistry.executeCommand(command, ...args);
-                if (this._menu && this.commandRegistry.isVisible(command, ...args)) {
+            if (this.menuCommandExecutor.isEnabled(menuPath, command, ...args)) {
+                await this.menuCommandExecutor.executeCommand(menuPath, command, ...args);
+                if (this._menu && this.menuCommandExecutor.isVisible(menuPath, command, ...args)) {
                     const item = this._menu.getMenuItemById(command);
                     if (item) {
-                        item.checked = this.commandRegistry.isToggled(command, ...args);
+                        item.checked = this.menuCommandExecutor.isToggled(menuPath, command, ...args);
                         electronRemote.getCurrentWindow().setMenu(this._menu);
                     }
                 }

package/src/electron-browser/menu/electron-menu-contribution.ts

@@ -337,6 +337,14 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
                 command: ElectronCommands.ZOOM_IN.id,
                 keybinding: 'ctrlcmd+='
             },
+            {
+                command: ElectronCommands.ZOOM_IN.id,
+                keybinding: 'ctrlcmd+add'
+            },
+            {
+                command: ElectronCommands.ZOOM_OUT.id,
+                keybinding: 'ctrlcmd+subtract'
+            },
             {
                 command: ElectronCommands.ZOOM_OUT.id,
                 keybinding: 'ctrlcmd+-'

package/src/electron-browser/messaging/electron-ws-connection-provider.ts

@@ -37,7 +37,7 @@ export class ElectronWebSocketConnectionProvider extends WebSocketConnectionProv
         // Manually close the websocket connections `onStop`. Otherwise, the channels will be closed with 30 sec (`MessagingContribution#checkAliveTimeout`) delay.
         // https://github.com/eclipse-theia/theia/issues/6499
         // `1001` indicates that an endpoint is "going away", such as a server going down or a browser having navigated away from a page.
-        this.channelMultiPlexer?.onUnderlyingChannelClose({ reason: 'The frontend is "going away"', code: 1001 });
+        this.channelMultiplexer?.onUnderlyingChannelClose({ reason: 'The frontend is "going away"', code: 1001 });
     }
 
     override async openChannel(path: string, handler: (channel: Channel) => void, options?: WebSocketOptions): Promise<void> {

package/src/electron-browser/window/electron-window-service.ts

@@ -72,7 +72,7 @@ export class ElectronWindowService extends DefaultWindowService {
      * after running FrontendApplication `onWillStop` handlers or on the `cancelChannel` if it is not safe to exit.
      */
     protected async handleCloseRequestedEvent(event: CloseRequestArguments): Promise<void> {
-        const safeToClose = await this.isSafeToShutDown();
+        const safeToClose = await this.isSafeToShutDown(event.reason);
         if (safeToClose) {
             console.debug(`Shutting down because of ${StopReason[event.reason]} request.`);
             electron.ipcRenderer.send(event.confirmChannel);

package/src/electron-common/messaging/electron-messages.ts

@@ -14,6 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { StopReason } from '../../common/frontend-application-state';
+/** @deprecated @since 1.28 import from common/frontend-application-state instead */
+export { StopReason };
+
 export const RequestTitleBarStyle = 'requestTitleBarStyle';
 export const TitleBarStyleChanged = 'titleBarStyleChanged';
 export const TitleBarStyleAtStartup = 'titleBarStyleAtStartup';
@@ -31,21 +35,6 @@ export const RELOAD_REQUESTED_SIGNAL = 'reload-requested';
  */
 export const APPLICATION_STATE_CHANGE_SIGNAL = 'application-state-changed';
 
-export enum StopReason {
-    /**
-     * Closing the window with no prospect of restart.
-     */
-    Close,
-    /**
-     * Reload without closing the window.
-     */
-    Reload,
-    /**
-     * Reload that includes closing the window.
-     */
-    Restart, // eslint-disable-line @typescript-eslint/no-shadow
-}
-
 export interface CloseRequestArguments {
     confirmChannel: string;
     cancelChannel: string;

package/src/electron-main/messaging/electron-messaging-contribution.ts

@@ -44,9 +44,9 @@ export class ElectronMessagingContribution implements ElectronMainApplicationCon
 
     protected readonly channelHandlers = new MessagingContribution.ConnectionHandlers<Channel>();
     /**
-     * Each electron window has a main chanel and its own multiplexer to route multiple client messages the same IPC connection.
+     * Each electron window has a main channel and its own multiplexer to route multiple client messages the same IPC connection.
      */
-    protected readonly windowChannelMultiplexer = new Map<number, { channel: ElectronWebContentChannel, multiPlexer: ChannelMultiplexer }>();
+    protected readonly windowChannelMultiplexer = new Map<number, { channel: ElectronWebContentChannel, multiplexer: ChannelMultiplexer }>();
 
     @postConstruct()
     protected init(): void {
@@ -67,10 +67,10 @@ export class ElectronMessagingContribution implements ElectronMainApplicationCon
     }
 
     // Creates a new multiplexer for a given sender/window
-    protected createWindowChannelData(sender: Electron.WebContents): { channel: ElectronWebContentChannel, multiPlexer: ChannelMultiplexer } {
+    protected createWindowChannelData(sender: Electron.WebContents): { channel: ElectronWebContentChannel, multiplexer: ChannelMultiplexer } {
         const mainChannel = this.createWindowMainChannel(sender);
-        const multiPlexer = new ChannelMultiplexer(mainChannel);
-        multiPlexer.onDidOpenChannel(openEvent => {
+        const multiplexer = new ChannelMultiplexer(mainChannel);
+        multiplexer.onDidOpenChannel(openEvent => {
             const { channel, id } = openEvent;
             if (this.channelHandlers.route(id, channel)) {
                 console.debug(`Opening channel for service path '${id}'.`);
@@ -78,9 +78,9 @@ export class ElectronMessagingContribution implements ElectronMainApplicationCon
             }
         });
 
-        sender.once('did-navigate', () => multiPlexer.onUnderlyingChannelClose({ reason: 'Window was refreshed' })); // When refreshing the browser window.
-        sender.once('destroyed', () => multiPlexer.onUnderlyingChannelClose({ reason: 'Window was closed' })); // When closing the browser window.
-        const data = { channel: mainChannel, multiPlexer };
+        sender.once('did-navigate', () => multiplexer.onUnderlyingChannelClose({ reason: 'Window was refreshed' })); // When refreshing the browser window.
+        sender.once('destroyed', () => multiplexer.onUnderlyingChannelClose({ reason: 'Window was closed' })); // When closing the browser window.
+        const data = { channel: mainChannel, multiplexer };
         this.windowChannelMultiplexer.set(sender.id, data);
         return data;
     }