@theia/core 1.75.0-next.8 → 1.75.0

package/src/browser/widget-manager.ts

@@ -119,7 +119,7 @@ export class WidgetManager {
     @inject(ContributionProvider) @named(WidgetFactory)
     protected readonly factoryProvider: ContributionProvider<WidgetFactory>;
 
-    @inject(ILogger)
+    @inject(ILogger) @named('core:WidgetManager')
     protected readonly logger: ILogger;
 
     protected readonly onWillCreateWidgetEmitter = new Emitter<WillCreateWidgetEvent>();

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';
@@ -59,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;
             }
 
@@ -80,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 }, '*');

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));
     }
 
     /**