@theia/core 1.75.0-next.3 → 1.75.0-next.34

package/src/browser/widgets/select-component.tsx

@@ -61,6 +61,10 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
     protected optimalWidth = 0;
     protected optimalHeight = 0;
     protected resizeObserver: ResizeObserver | undefined;
+    /** Window the scroll/wheel/resize listeners are attached to; may differ from the main window in secondary windows. */
+    protected listenersWindow: Window | undefined;
+    /** Perfect-scrollbar ancestors the `ps-scroll-y` listener was attached to. The field may have moved to another window since, so the elements are remembered. */
+    protected psScrollListenerTargets: HTMLElement[] = [];
 
     constructor(props: SelectComponentProps) {
         super(props);
@@ -71,14 +75,28 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
             hover: selected
         };
 
-        let list = document.getElementById(SELECT_COMPONENT_CONTAINER);
+        this.dropdownElement = this.resolveDropdownContainer(document);
+    }
+
+    /**
+     * The document that currently hosts this component. Falls back to the main document before
+     * the first render. Widgets can be moved to secondary windows, so this must be re-queried
+     * instead of captured once.
+     */
+    protected getHostDocument(): Document {
+        return this.fieldRef.current?.ownerDocument ?? document;
+    }
+
+    /** Finds or creates the dropdown portal container in the given document. */
+    protected resolveDropdownContainer(hostDocument: Document): HTMLElement {
+        let list = hostDocument.getElementById(SELECT_COMPONENT_CONTAINER);
         if (!list) {
-            list = document.createElement('div');
+            list = hostDocument.createElement('div');
             list.id = SELECT_COMPONENT_CONTAINER;
             list.className = 'theia-select-component-container';
-            document.body.appendChild(list);
+            hostDocument.body.appendChild(list);
         }
-        this.dropdownElement = list;
+        return list;
     }
 
     protected getInitialSelectedIndex(props: SelectComponentProps): number {
@@ -179,12 +197,14 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
             // neither triggers the `scroll`, `wheel` nor `blur` event
             if (parent.classList.contains('ps')) {
                 parent.addEventListener('ps-scroll-y', hide);
+                this.psScrollListenerTargets.push(parent);
             }
             parent = parent.parentElement;
         }
 
+        this.listenersWindow = this.getHostDocument().defaultView ?? window;
         for (const [key, listener] of this.mountedListeners.entries()) {
-            window.addEventListener(key, listener);
+            this.listenersWindow.addEventListener(key, listener);
         }
 
         // Catch Lumino sash drags globally - observe the closest lm-Widget panel
@@ -222,18 +242,24 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
     }
 
     override componentWillUnmount(): void {
+        this.detachListeners();
+    }
+
+    protected detachListeners(): void {
         this.resizeObserver?.disconnect();
+        this.resizeObserver = undefined;
         if (this.mountedListeners.size > 0) {
             const eventListener = this.mountedListeners.get('scroll')!;
-            let parent = this.fieldRef.current?.parentElement;
-            while (parent) {
-                parent.removeEventListener('ps-scroll-y', eventListener);
-                parent = parent.parentElement;
+            for (const target of this.psScrollListenerTargets) {
+                target.removeEventListener('ps-scroll-y', eventListener);
             }
             for (const [key, listener] of this.mountedListeners.entries()) {
-                window.removeEventListener(key, listener);
+                (this.listenersWindow ?? window).removeEventListener(key, listener);
             }
+            this.mountedListeners.clear();
         }
+        this.psScrollListenerTargets = [];
+        this.listenersWindow = undefined;
     }
 
     override render(): React.ReactNode {
@@ -345,6 +371,14 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
             return;
         }
         if (!this.state.dimensions) {
+            // Re-resolve the portal container and listener window against the document that
+            // currently hosts the field: the widget may have been moved to a secondary window
+            // (or back to the main window) since the last time the dropdown was opened.
+            const hostDocument = this.getHostDocument();
+            this.dropdownElement = this.resolveDropdownContainer(hostDocument);
+            if (this.listenersWindow && this.listenersWindow !== hostDocument.defaultView) {
+                this.detachListeners();
+            }
             const rect = this.fieldRef.current.getBoundingClientRect();
             this.setState({ dimensions: rect });
         } else {
@@ -361,7 +395,8 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
             hover: selectedIndex
         });
         // Force releasing focus of the select element to allow closing via escape later on
-        if (releaseFocus && document.activeElement && document.activeElement === this.fieldRef.current) {
+        const hostDocument = this.getHostDocument();
+        if (releaseFocus && hostDocument.activeElement && hostDocument.activeElement === this.fieldRef.current) {
             this.fieldRef.current.blur();
         }
     }
@@ -371,7 +406,9 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
             return;
         }
 
-        const shellArea = document.getElementById('theia-app-shell')!.getBoundingClientRect();
+        // Secondary windows have no 'theia-app-shell' element; use the document element as the boundary there.
+        const hostDocument = this.getHostDocument();
+        const shellArea = (hostDocument.getElementById('theia-app-shell') ?? hostDocument.documentElement).getBoundingClientRect();
         const maxWidth = this.alignLeft ? shellArea.width - this.state.dimensions.left : this.state.dimensions.right;
         if (this.mountedListeners.size === 0) {
             // Only attach our listeners once we render our dropdown menu

package/src/browser/window/default-secondary-window-service.ts

@@ -13,13 +13,13 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-import { inject, injectable, postConstruct } from 'inversify';
+import { inject, injectable, postConstruct, named } from 'inversify';
 import { SecondaryWindow, SecondaryWindowService } from './secondary-window-service';
 import { WindowService } from './window-service';
 import { ExtractableWidget, Widget } from '../widgets';
 import { ApplicationShell } from '../shell';
 import { Saveable } from '../saveable';
-import { Emitter, environment, Event, PreferenceService } from '../../common';
+import { Emitter, environment, Event, PreferenceService, ILogger } from '../../common';
 import { SaveableService } from '../saveable-service';
 import { getAllWidgetsFromSecondaryWindow, getDefaultRestoreArea } from '../secondary-window-handler';
 import { WindowFocusService } from './window-focus-service';
@@ -28,6 +28,8 @@ import { WindowFocusService } from './window-focus-service';
 export class DefaultSecondaryWindowService implements SecondaryWindowService {
     protected readonly onWindowOpenedEmitter = new Emitter<Window>;
     readonly onWindowOpened: Event<Window> = this.onWindowOpenedEmitter.event;
+    protected readonly onWindowLoadedEmitter = new Emitter<Window>;
+    readonly onWindowLoaded: Event<Window> = this.onWindowLoadedEmitter.event;
     protected readonly onWindowClosedEmitter = new Emitter<Window>;
     readonly onWindowClosed: Event<Window> = this.onWindowClosedEmitter.event;
     protected readonly beforeWidgetRestoreEmitter = new Emitter<[Widget, Window]>;
@@ -57,17 +59,20 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
     @inject(WindowFocusService)
     protected readonly windowFocusService: WindowFocusService;
 
+    @inject(ILogger) @named('core:DefaultSecondaryWindowService')
+    protected readonly logger: ILogger;
+
     @postConstruct()
     init(): void {
         // Set up messaging with secondary windows
         window.addEventListener('message', (event: MessageEvent) => {
-            console.trace('Message on main window', event);
+            this.logger.trace('Message on main window', event);
             if (event.data.fromSecondary) {
-                console.trace('Message comes from secondary window');
+                this.logger.trace('Message comes from secondary window');
                 return;
             }
             if (event.data.fromMain) {
-                console.trace('Message has mainWindow marker, therefore ignore it');
+                this.logger.trace('Message has mainWindow marker, therefore ignore it');
                 return;
             }
 
@@ -78,7 +83,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
                 return;
             }
 
-            console.trace('Delegate main window message to secondary windows', event);
+            this.logger.trace('Delegate main window message to secondary windows', event);
             this.secondaryWindows.forEach(secondaryWindow => {
                 if (!secondaryWindow.window.closed) {
                     secondaryWindow.window.postMessage({ ...event.data, fromMain: true }, '*');
@@ -110,6 +115,10 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
             this.secondaryWindows.push(newWindow);
             this.onWindowOpenedEmitter.fire(newWindow);
             newWindow.addEventListener('DOMContentLoaded', () => {
+                // This fires for the final secondary-window.html document, not for the initial
+                // about:blank document the window starts out with, so onWindowLoaded listeners
+                // can safely modify the document.
+                this.onWindowLoadedEmitter.fire(newWindow);
                 const focusRegistration = this.windowFocusService.registerWindow(newWindow);
                 newWindow.addEventListener('beforeunload', evt => {
                     const widgets = getAllWidgetsFromSecondaryWindow(newWindow) ?? [widget];
@@ -124,7 +133,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
                     }
                 }, { capture: true });
 
-                newWindow.addEventListener('unload', () => {
+                newWindow.addEventListener('pagehide', () => {
                     focusRegistration.dispose();
                     const extIndex = this.secondaryWindows.indexOf(newWindow);
                     if (extIndex > -1) {
@@ -140,7 +149,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
     }
 
     protected windowCreated(newWindow: Window, widget: ExtractableWidget, shell: ApplicationShell): void {
-        newWindow.addEventListener('unload', () => {
+        newWindow.addEventListener('pagehide', () => {
             this.restoreWidgets(newWindow, widget, shell);
         });
     }

package/src/browser/window/default-window-service.spec.ts

@@ -77,4 +77,26 @@ describe('DefaultWindowService', () => {
         assert(windowService['collectContributionUnloadVetoes']().length > 0, 'there should be vetoes');
         assert(frontendContributions.every(contribution => contribution.onWillStopCalled), 'contributions should have been called');
     });
+    it('should reload unconditionally when restored from the back/forward cache', () => {
+        const frontendContributions: TestFrontendApplicationContribution[] = [
+            new TestFrontendApplicationContribution(true),
+        ];
+        const windowService = setupWindowService('always', frontendContributions);
+        let reloaded = 0;
+        windowService.reload = () => { reloaded++; };
+        windowService['handlePageShow']({ persisted: false } as PageTransitionEvent);
+        const reloadsBeforeRestore = reloaded;
+        windowService['handlePageShow']({ persisted: true } as PageTransitionEvent);
+        assert(reloadsBeforeRestore === 0, 'a regular page show should not reload');
+        assert(reloaded === 1, 'a restored page should reload');
+        assert(windowService['collectContributionUnloadVetoes']().length === 0, 'the recovery reload should not be vetoed');
+    });
+    it('onUnload should fire at most once, even if `pagehide` fires repeatedly', () => {
+        const windowService = setupWindowService('never', []);
+        let fired = 0;
+        windowService.onUnload(() => fired++);
+        windowService['handlePageHide']();
+        windowService['handlePageHide']();
+        assert(fired === 1, `onUnload should have fired once, but fired ${fired} time(s)`);
+    });
 });

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

@@ -30,6 +30,7 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
 
     protected frontendApplication: FrontendApplication;
     protected allowVetoes = true;
+    protected unloaded = false;
 
     protected onUnloadEmitter = new Emitter<void>();
     get onUnload(): Event<void> {
@@ -103,12 +104,43 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
      * Implement the mechanism to detect unloading of the page.
      */
     protected registerUnloadListeners(): void {
+        // If `beforeunload` is cancelled and the user stays, the page is not unloaded, so `pagehide` is not fired.
         window.addEventListener('beforeunload', event => this.handleBeforeUnloadEvent(event));
-        // In a browser, `unload` is correctly fired when the page unloads, unlike Electron.
-        // If `beforeunload` is cancelled, the user will be prompted to leave or stay.
-        // If the user stays, the page won't be unloaded, so `unload` is not fired.
-        // If the user leaves, the page will be unloaded, so `unload` is fired.
-        window.addEventListener('unload', () => this.onUnloadEmitter.fire());
+        this.registerPageHideListener();
+        window.addEventListener('pageshow', event => this.handlePageShow(event));
+    }
+
+    /**
+     * `pagehide` is used instead of the deprecated `unload` event, which Chrome may block
+     * via permissions policy (https://developer.chrome.com/docs/web-platform/deprecating-unload),
+     * silently skipping the handler and thus e.g. losing the layout.
+     */
+    protected registerPageHideListener(): void {
+        window.addEventListener('pagehide', () => this.handlePageHide());
+    }
+
+    /**
+     * `pagehide` also fires when the page enters the back/forward cache, in which case the frontend
+     * has already shut down (state saved, connections closed). Reload to get a working application
+     * again if the page is restored from the cache. That shutdown already happened, so the reload
+     * must not be vetoed by the contributions.
+     */
+    protected handlePageShow(event: PageTransitionEvent): void {
+        if (event.persisted) {
+            this.setSafeToShutDown();
+            this.reload();
+        }
+    }
+
+    /**
+     * Fires {@link onUnload} at most once per document: `pagehide` fires again for the reload that
+     * recovers a page restored from the back/forward cache, but the application is already stopped.
+     */
+    protected handlePageHide(): void {
+        if (!this.unloaded) {
+            this.unloaded = true;
+            this.onUnloadEmitter.fire();
+        }
     }
 
     async isSafeToShutDown(stopReason: StopReason): Promise<boolean> {

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

@@ -55,6 +55,13 @@ export interface SecondaryWindowService {
      */
     createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): SecondaryWindow | Window | undefined;
     readonly onWindowOpened: Event<Window>;
+    /**
+     * Emitted once a secondary window's final document has finished loading. Listeners can safely
+     * modify the window's document, unlike with {@link onWindowOpened}: at that point the window
+     * still shows the initial `about:blank` document, and anything added to it is discarded when
+     * the final document replaces it.
+     */
+    readonly onWindowLoaded: Event<Window>;
     readonly onWindowClosed: Event<Window>;
     readonly beforeWidgetRestore: Event<[Widget, Window]>;
 

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

@@ -56,7 +56,7 @@ export interface WindowService {
     focus(): void;
 
     /**
-     * Fires when the `window` unloads. The unload event is inevitable. On this event, the frontend application can save its state and release resource.
+     * Fires when the application is shutting down. On this event, the frontend application can save its state and release resource.
      * Saving the state and releasing any resources must be a synchronous call. Any asynchronous calls invoked after emitting this event might be ignored.
      */
     readonly onUnload: Event<void>;

package/src/browser-only/frontend-only-application-module.ts

@@ -52,8 +52,32 @@ export const frontendOnlyApplicationModule = new ContainerModule((bind, unbind,
         bind(QuickPickService).to(QuickPickServiceImpl).inSingletonScope();
     }
 
+    let extensionsCache: Promise<ExtensionInfo[]> | undefined;
+
     const mockedApplicationServer: ApplicationServer = {
-        getExtensionsInfos: async (): Promise<ExtensionInfo[]> => [],
+        getExtensionsInfos: async (): Promise<ExtensionInfo[]> => {
+            if (extensionsCache === undefined) {
+                extensionsCache = (async () => {
+                    try {
+                        const res = await fetch('./extensions.json');
+                        if (!res.ok) {
+                            extensionsCache = undefined;
+                            return [];
+                        }
+                        const raw = await res.json();
+                        if (!Array.isArray(raw)) {
+                            extensionsCache = undefined;
+                            return [];
+                        }
+                        return raw as ExtensionInfo[];
+                    } catch {
+                        extensionsCache = undefined;
+                        return [];
+                    }
+                })();
+            }
+            return extensionsCache;
+        },
         getApplicationInfo: async (): Promise<ApplicationInfo | undefined> => undefined,
         getApplicationRoot: async (): Promise<string> => '',
         getApplicationPlatform: () => Promise.resolve('web'),

package/src/common/command.spec.ts

@@ -139,6 +139,131 @@ describe('Commands', () => {
         expect(commandRegistry.getAllHandlers('id').length).to.be.equal(2);
     });
 
+    describe('registerAlias', () => {
+
+        it('onDidExecuteCommand fires for alias when target is executed', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            commandRegistry.registerAlias('alias', 'target');
+            const events: string[] = [];
+            commandRegistry.onDidExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('target');
+            expect(events).to.deep.equal(['target', 'alias']);
+        });
+
+        it('onDidExecuteCommand fires only for alias when alias is executed (no reverse)', async () => {
+            commandRegistry.registerCommand({ id: 'alias' }, new StubCommandHandler());
+            commandRegistry.registerAlias('alias', 'target');
+            const events: string[] = [];
+            commandRegistry.onDidExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('alias');
+            // Unidirectional: an alias fires for its target, but not the other way round
+            expect(events).to.deep.equal(['alias']);
+        });
+
+        it('onWillExecuteCommand fires for alias when target is executed', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            commandRegistry.registerAlias('alias', 'target');
+            const events: string[] = [];
+            commandRegistry.onWillExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('target');
+            expect(events).to.deep.equal(['target', 'alias']);
+        });
+
+        it('disposing the alias removes the event link', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            const disposable = commandRegistry.registerAlias('alias', 'target');
+            disposable.dispose();
+            const events: string[] = [];
+            commandRegistry.onDidExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('target');
+            expect(events).to.deep.equal(['target']);
+        });
+
+        it('getAliases returns the aliases registered for a target', () => {
+            commandRegistry.registerAlias('a', 'b');
+            expect(commandRegistry.getAliases('b')).to.deep.equal(['a']);
+        });
+
+        it('getAliases returns nothing for the alias direction (unidirectional)', () => {
+            commandRegistry.registerAlias('a', 'b');
+            expect(commandRegistry.getAliases('a')).to.be.empty;
+        });
+
+        it('getAliases returns nothing for unaliased commands', () => {
+            expect(commandRegistry.getAliases('nonexistent')).to.be.empty;
+        });
+
+        it('a target can carry several aliases', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            commandRegistry.registerAlias('alias1', 'target');
+            commandRegistry.registerAlias('alias2', 'target');
+            const events: string[] = [];
+            commandRegistry.onDidExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('target');
+            expect(events).to.deep.equal(['target', 'alias1', 'alias2']);
+        });
+
+        it('disposing one alias keeps the others', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            const first = commandRegistry.registerAlias('alias1', 'target');
+            commandRegistry.registerAlias('alias2', 'target');
+            first.dispose();
+            expect(commandRegistry.getAliases('target')).to.deep.equal(['alias2']);
+        });
+
+        it('alias events include correct args', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new ConcatCommandHandler());
+            commandRegistry.registerAlias('alias', 'target');
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const capturedArgs: any[][] = [];
+            commandRegistry.onDidExecuteCommand(e => capturedArgs.push(e.args));
+            await commandRegistry.executeCommand('target', 'x', 'y');
+            expect(capturedArgs.length).to.equal(2);
+            expect(capturedArgs[0]).to.deep.equal(['x', 'y']);
+            expect(capturedArgs[1]).to.deep.equal(['x', 'y']);
+        });
+
+        it('nested execution: alias handler delegating to target fires target and alias events', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            commandRegistry.registerCommand({ id: 'alias' }, {
+                execute: () => commandRegistry.executeCommand('target')
+            });
+            commandRegistry.registerAlias('alias', 'target');
+            const events: string[] = [];
+            commandRegistry.onDidExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('alias');
+            // The alias is on the stack while the target runs, so its event is only reported once.
+            expect(events).to.deep.equal(['target', 'alias']);
+        });
+
+        it('reports the alias once for the will execute event as well', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            commandRegistry.registerCommand({ id: 'alias' }, {
+                execute: () => commandRegistry.executeCommand('target')
+            });
+            commandRegistry.registerAlias('alias', 'target');
+            const events: string[] = [];
+            commandRegistry.onWillExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('alias');
+            expect(events).to.deep.equal(['alias', 'target']);
+        });
+
+        it('reports the alias again once the delegating execution finished', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            commandRegistry.registerCommand({ id: 'alias' }, {
+                execute: () => commandRegistry.executeCommand('target')
+            });
+            commandRegistry.registerAlias('alias', 'target');
+            await commandRegistry.executeCommand('alias');
+
+            const events: string[] = [];
+            commandRegistry.onDidExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('target');
+            expect(events).to.deep.equal(['target', 'alias']);
+        });
+
+    });
+
     describe('compareCommands', () => {
 
         it('should sort command \'a\' before command \'b\' with categories', () => {

package/src/common/command.ts

@@ -202,6 +202,19 @@ export class CommandRegistry implements CommandService {
     // List of recently used commands.
     protected _recent: string[] = [];
 
+    /**
+     * Unidirectional alias map from a target command id to the alias command ids registered for it.
+     * When the target (for instance a native Theia command) is executed, events also fire for its
+     * aliases (for instance the VS Code command ids).
+     */
+    protected readonly _aliases = new Map<string, Set<string>>();
+
+    /**
+     * How often each command is currently executing, so that an alias event can be skipped while the
+     * alias command itself is on the stack.
+     */
+    protected readonly executionDepth = new Map<string, number>();
+
     protected readonly onWillExecuteCommandEmitter = new Emitter<WillExecuteCommandEvent>();
     readonly onWillExecuteCommand = this.onWillExecuteCommandEmitter.event;
 
@@ -277,6 +290,42 @@ export class CommandRegistry implements CommandService {
         }
     }
 
+    /**
+     * Register a unidirectional alias from a target command to an alias command.
+     * When the target command is executed, {@link onDidExecuteCommand} and {@link onWillExecuteCommand}
+     * fire for the alias id as well.
+     *
+     * This does not affect command handlers, enablement or visibility, only event emission. A target may
+     * carry several aliases.
+     *
+     * No event is fired for an alias while that alias is executing, which keeps an alias command that
+     * delegates to its target from reporting itself twice. The check is by command id rather than by call
+     * stack, so an unrelated execution of the alias that happens to overlap suppresses the event as well.
+     *
+     * @param aliasId the alias command id, for instance a VS Code command id
+     * @param targetId the target command id, for instance the native Theia command id
+     * @returns a `Disposable` that removes this alias again
+     */
+    registerAlias(aliasId: string, targetId: string): Disposable {
+        const aliases = this._aliases.get(targetId) ?? new Set<string>();
+        aliases.add(aliasId);
+        this._aliases.set(targetId, aliases);
+        return Disposable.create(() => {
+            const registered = this._aliases.get(targetId);
+            if (registered?.delete(aliasId) && registered.size === 0) {
+                this._aliases.delete(targetId);
+            }
+        });
+    }
+
+    /**
+     * Returns the alias ids registered for the given command id.
+     */
+    getAliases(commandId: string): readonly string[] {
+        const aliases = this._aliases.get(commandId);
+        return aliases ? Array.from(aliases) : [];
+    }
+
     /**
      * Register the given handler for the given command identifier.
      *
@@ -341,10 +390,23 @@ export class CommandRegistry implements CommandService {
     async executeCommand<T>(commandId: string, ...args: any[]): Promise<T | undefined> {
         const handler = this.getActiveHandler(commandId, ...args);
         if (handler) {
-            await this.fireWillExecuteCommand(commandId, args);
-            const result = await handler.execute(...args);
-            this.onDidExecuteCommandEmitter.fire({ commandId, args });
-            return result;
+            this.executionDepth.set(commandId, (this.executionDepth.get(commandId) ?? 0) + 1);
+            try {
+                await this.fireWillExecuteCommand(commandId, args);
+                const result = await handler.execute(...args);
+                this.onDidExecuteCommandEmitter.fire({ commandId, args });
+                for (const alias of this.getPendingAliases(commandId)) {
+                    this.onDidExecuteCommandEmitter.fire({ commandId: alias, args });
+                }
+                return result;
+            } finally {
+                const depth = this.executionDepth.get(commandId) ?? 1;
+                if (depth > 1) {
+                    this.executionDepth.set(commandId, depth - 1);
+                } else {
+                    this.executionDepth.delete(commandId);
+                }
+            }
         }
         throw Object.assign(new Error(`The command '${commandId}' cannot be executed. There are no active handlers available for the command.`), { code: 'NO_ACTIVE_HANDLER' });
     }
@@ -352,6 +414,17 @@ export class CommandRegistry implements CommandService {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     protected async fireWillExecuteCommand(commandId: string, args: any[] = []): Promise<void> {
         await WaitUntilEvent.fire(this.onWillExecuteCommandEmitter, { commandId, args }, 30000);
+        for (const alias of this.getPendingAliases(commandId)) {
+            await WaitUntilEvent.fire(this.onWillExecuteCommandEmitter, { commandId: alias, args }, 30000);
+        }
+    }
+
+    /**
+     * The aliases of the given command that are not executing themselves, and for which events are
+     * therefore still owed.
+     */
+    protected getPendingAliases(commandId: string): readonly string[] {
+        return this.getAliases(commandId).filter(alias => !this.executionDepth.has(alias));
     }
 
     /**

package/src/common/message-service-protocol.ts

@@ -14,9 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from 'inversify';
+import { injectable, inject, named } from 'inversify';
 import { CancellationToken } from './cancellation';
 import { nls } from './nls';
+import { ILogger } from './logger';
 
 export const messageServicePath = '/services/messageService';
 
@@ -115,6 +116,9 @@ export interface ProgressUpdate {
 @injectable()
 export class MessageClient {
 
+    @inject(ILogger) @named('core:MessageClient')
+    protected readonly logger: ILogger;
+
     /**
      * Show a message of the given type and possible actions to the user.
      * Resolve to a chosen action.
@@ -123,7 +127,7 @@ export class MessageClient {
      * To be implemented by an extension, e.g. by the messages extension.
      */
     showMessage(message: Message): Promise<string | undefined> {
-        console.info(message.text);
+        this.logger.info(message.text);
         return Promise.resolve(undefined);
     }
 
@@ -133,7 +137,7 @@ export class MessageClient {
      * To be implemented by an extension, e.g. by the messages extension.
      */
     showProgress(progressId: string, message: ProgressMessage, cancellationToken: CancellationToken): Promise<string | undefined> {
-        console.info(message.text);
+        this.logger.info(message.text);
         return Promise.resolve(undefined);
     }
 

package/src/common/performance/stopwatch.ts

@@ -16,7 +16,7 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { inject, injectable, unmanaged } from 'inversify';
+import { inject, injectable, unmanaged, named } from 'inversify';
 import { ILogger, LogLevel } from '../logger';
 import { MaybePromise } from '../types';
 import { Measurement, MeasurementOptions, MeasurementResult } from './measurement';
@@ -48,7 +48,7 @@ interface LogOptions extends MeasurementOptions {
 @injectable()
 export abstract class Stopwatch {
 
-    @inject(ILogger)
+    @inject(ILogger) @named('core:Stopwatch')
     protected readonly logger: ILogger;
 
     protected _storedMeasurements: MeasurementResult[] = [];