execute already registered command in the same tick

.gitpod.dockerfile

@@ -5,6 +5,8 @@ ENV TRIGGER_REBUILD 3
 
 # Install custom tools, runtime, etc.
 RUN sudo apt-get update \
+    # firefox for testing via VNC
+    && sudo apt-get install -y firefox \
     # window manager
     && sudo apt-get install -y jwm \
     # electron

packages/core/src/browser/keybinding.ts

@@ -434,6 +434,8 @@ export class KeybindingRegistry {
     /**
      * Tries to execute a keybinding.
      *
+     * **IMPORTANT:** This method has to be synchronous.
+     *
      * @param binding to execute
      * @param event keyboard event.
      */
@@ -502,6 +504,8 @@ export class KeybindingRegistry {
 
     /**
      * Run the command matching to the given keyboard event.
+     *
+     * **IMPORTANT:** This method has to be synchronous.
      */
     run(event: KeyboardEvent): void {
         if (event.defaultPrevented) {

packages/core/src/common/command.ts

@@ -18,6 +18,7 @@ import { injectable, inject, named } from 'inversify';
 import { Event, Emitter, WaitUntilEvent } from './event';
 import { Disposable, DisposableCollection } from './disposable';
 import { ContributionProvider } from './contribution-provider';
+import { MaybePromise } from './types';
 
 /**
  * A command is a unique identifier of a function
@@ -285,24 +286,34 @@ export class CommandRegistry implements CommandService {
      * Execute the active handler for the given command and arguments.
      *
      * Reject if a command cannot be executed.
+     *
+     * **IMPORTANT:** This method has to be synchronous.
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async executeCommand<T>(commandId: string, ...args: any[]): Promise<T | undefined> {
+    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);
+        if (!handler) {
+            const argsMessage = args && args.length > 0 ? ` (args: ${JSON.stringify(args)})` : '';
+            // eslint-disable-next-line max-len
+            throw Object.assign(new Error(`The command '${commandId}' cannot be executed. There are no active handlers available for the command.${argsMessage}`), { code: 'NO_ACTIVE_HANDLER' });
+        }
+        let invocation: MaybePromise<T | undefined>;
+        const waitForCommand = this.fireWillExecuteCommand(commandId, args);
+        if (waitForCommand) {
+            invocation = waitForCommand.then(() => handler.execute(...args));
+        } else {
+            // execute already registered command in the same tick, see https://github.com/eclipse-theia/theia/issues/7542#issuecomment-631452852
+            invocation = handler.execute(...args);
+        }
+        return Promise.resolve(invocation).then(result => {
             this.onDidExecuteCommandEmitter.fire({ commandId, args });
             return result;
-        }
-        const argsMessage = args && args.length > 0 ? ` (args: ${JSON.stringify(args)})` : '';
-        // eslint-disable-next-line max-len
-        throw Object.assign(new Error(`The command '${commandId}' cannot be executed. There are no active handlers available for the command.${argsMessage}`), { code: 'NO_ACTIVE_HANDLER' });
+        });
     }
 
     // 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);
+    protected fireWillExecuteCommand(commandId: string, args: any[] = []): MaybePromise<void> {
+        return WaitUntilEvent.fire(this.onWillExecuteCommandEmitter, { commandId, args }, 30000);
     }
 
     /**

packages/core/src/common/event.ts

@@ -199,8 +199,8 @@ export class Emitter<T = any> {
 
                 return result;
             }, {
-                    maxListeners: Emitter.LEAK_WARNING_THRESHHOLD
-                }
+                maxListeners: Emitter.LEAK_WARNING_THRESHHOLD
+            }
             );
         }
         return this._event;
@@ -308,11 +308,14 @@ export interface WaitUntilEvent {
     /* eslint-enable @typescript-eslint/no-explicit-any */
 }
 export namespace WaitUntilEvent {
-    export async function fire<T extends WaitUntilEvent>(
+    /**
+     * **IMPORTANT:** This method has to be synchronous.
+     */
+    export function fire<T extends WaitUntilEvent>(
         emitter: Emitter<T>,
         event: Pick<T, Exclude<keyof T, 'waitUntil'>>,
         timeout: number | undefined = undefined
-    ): Promise<void> {
+    ): MaybePromise<void> {
         const waitables: Promise<void>[] = [];
         const asyncEvent = Object.assign(event, {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -333,10 +336,12 @@ export namespace WaitUntilEvent {
         if (!waitables.length) {
             return;
         }
+        let invocation;
         if (timeout !== undefined) {
-            await Promise.race([Promise.all(waitables), new Promise(resolve => setTimeout(resolve, timeout))]);
+            invocation = Promise.race([Promise.all(waitables), new Promise(resolve => setTimeout(resolve, timeout))]);
         } else {
-            await Promise.all(waitables);
+            invocation = Promise.all(waitables);
         }
+        return invocation.then(() => Promise.resolve());
     }
 }