@theia/core 1.73.0-next.3 → 1.73.0-next.39

package/src/browser/shell/application-shell.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, inject, optional, postConstruct } from 'inversify';
+import { injectable, inject, optional, postConstruct, named } from 'inversify';
 import { ArrayExt, find, toArray, each } from '@lumino/algorithm';
 import {
     BoxLayout, BoxPanel, DockLayout, DockPanel, FocusTracker, Layout, Panel, SplitLayout,
@@ -46,6 +46,7 @@ import { OpenerService } from '../opener-service';
 import { PreviewableWidget } from '../widgets/previewable-widget';
 import { WindowService } from '../window/window-service';
 import { TheiaSplitPanel } from './theia-split-panel';
+import { ILogger } from '../../common/logger';
 
 /** The class name added to ApplicationShell instances. */
 export const APPLICATION_SHELL_CLASS = 'theia-ApplicationShell';
@@ -242,6 +243,9 @@ export class ApplicationShell extends Widget {
     @inject(UntitledResourceResolver)
     protected readonly untitledResourceResolver: UntitledResourceResolver;
 
+    @inject(ILogger) @named('core:ApplicationShell')
+    protected readonly logger: ILogger;
+
     protected readonly onDidAddWidgetEmitter = new Emitter<Widget>();
     readonly onDidAddWidget = this.onDidAddWidgetEmitter.event;
     protected fireDidAddWidget(widget: Widget): void {
@@ -595,7 +599,7 @@ export class ApplicationShell extends Widget {
                 const opener = await this.openerService.getOpener(fileUri);
                 opener.open(fileUri);
             } catch (e) {
-                console.info(`no opener found for '${fileUri}'`);
+                this.logger.info(`no opener found for '${fileUri}'`);
             }
         };
 
@@ -975,7 +979,7 @@ export class ApplicationShell extends Widget {
      */
     async addWidget(widget: Widget, options?: Readonly<ApplicationShell.WidgetOptions>): Promise<void> {
         if (!widget.id) {
-            console.error('Widgets added to the application shell must have a unique id property.');
+            this.logger.error('Widgets added to the application shell must have a unique id property.');
             return;
         }
         const { area, addOptions } = this.getInsertionOptions(options);
@@ -1430,7 +1434,7 @@ export class ApplicationShell extends Widget {
             if (delta < this.activationTimeout) {
                 request = setTimeout(step, 0);
             } else {
-                console.warn(`Widget was activated, but did not accept focus after ${this.activationTimeout}ms: ${widget.id}`);
+                this.logger.warn(`Widget was activated, but did not accept focus after ${this.activationTimeout}ms: ${widget.id}`);
             }
         };
         let request = setTimeout(step, 0);

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-menu-adapters.tsx

@@ -96,7 +96,7 @@ abstract class AbstractToolbarMenuWrapper {
         const icon = this.icon || 'ellipsis';
         const contextMatcher: ContextMatcher = this.contextKeyService;
         const className = `${icon} ${ACTION_ITEM}`;
-        if (CompoundMenuNode.is(this.menuNode) && !this.menuNode.isEmpty(this.effectiveMenuPath, this.contextKeyService, widget.node)) {
+        if (CompoundMenuNode.is(this.menuNode) && !this.menuNode.isEmpty(this.effectiveMenuPath, this.contextKeyService, widget.node, widget)) {
             return <div key={this.id} className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled menu'}>
                 <div className={className}
                     title={this.tooltip || this.text}
@@ -308,7 +308,7 @@ abstract class AbstractMenuNodeAsToolbarItemWrapper<T extends MenuNode> {
     }
 
     isVisible<K>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<K>, context: K | undefined, ...args: unknown[]): boolean {
-        return this.menuNode!.isVisible(this.effectiveMenuPath, contextMatcher, context, args);
+        return this.menuNode!.isVisible(this.effectiveMenuPath, contextMatcher, context, ...args);
     }
 }
 
@@ -321,7 +321,7 @@ class ToolbarItemAsSubmenuWrapper extends AbstractMenuNodeAsToolbarItemWrapper<C
         return this.menuNode.contextKeyOverlays;
     }
     isEmpty<T>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: unknown[]): boolean {
-        return this.menuNode.isEmpty(this.effectiveMenuPath, contextMatcher, context, args);
+        return this.menuNode.isEmpty(this.effectiveMenuPath, contextMatcher, context, ...args);
     }
     get children(): MenuNode[] {
         return this.menuNode.children;
@@ -340,7 +340,7 @@ class ToolbarItemAsCommandMenuWrapper extends AbstractMenuNodeAsToolbarItemWrapp
         return this.menuNode.isToggled(this.effectiveMenuPath, ...args);
     }
     run(effectiveMenuPath: MenuPath, ...args: unknown[]): Promise<void> {
-        return this.menuNode.run(this.effectiveMenuPath, args);
+        return this.menuNode.run(this.effectiveMenuPath, ...args);
     }
 
     override get label(): string {

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-registry.ts

@@ -141,11 +141,11 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
                 const menu = this.menuRegistry.getMenu(delegate.menuPath);
                 if (menu) {
                     for (const child of menu.children) {
-                        if (child.isVisible([...delegate.menuPath, child.id], this.contextKeyService, widget.node)) {
+                        if (child.isVisible([...delegate.menuPath, child.id], this.contextKeyService, widget.node, widget)) {
                             if (CompoundMenuNode.is(child)) {
                                 for (const grandchild of child.children) {
                                     if (grandchild.isVisible([...delegate.menuPath, child.id, grandchild.id],
-                                        this.contextKeyService, widget.node) && RenderedMenuNode.is(grandchild)) {
+                                        this.contextKeyService, widget.node, widget) && RenderedMenuNode.is(grandchild)) {
                                         if (CommandMenu.is(grandchild)) {
                                             result.push(new CommandMenuAsToolbarItemWrapper([...delegate.menuPath, child.id, grandchild.id], this.commandRegistry,
                                                 this.menuRegistry, this.contextKeyService, this.contextMenuRenderer, grandchild, child.id));

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar.spec.ts

@@ -18,7 +18,16 @@ import { enableJSDOM } from '../../test/jsdom';
 
 let disableJSDOM = enableJSDOM();
 import { expect } from 'chai';
-import { TabBarToolbarAction } from './tab-bar-toolbar-types';
+import {
+    CommandMenu, CommandRegistry, CompoundMenuNode, Group, GroupImpl, MenuAction, MenuModelRegistry, MenuNode, MenuNodeFactory, MutableCompoundMenuNode,
+    Submenu, SubmenuImpl, SubMenuLink
+} from '../../../common';
+import { ContextKeyServiceDummyImpl } from '../../context-key-service';
+import { ContextMenuRenderer } from '../../context-menu-renderer';
+import { Widget } from '../../widgets';
+import { TOOLBAR_WRAPPER_ID_SUFFIX } from './tab-bar-toolbar-menu-adapters';
+import { TabBarToolbarRegistry } from './tab-bar-toolbar-registry';
+import { TAB_BAR_TOOLBAR_CONTEXT_MENU, TabBarToolbarAction } from './tab-bar-toolbar-types';
 
 disableJSDOM();
 
@@ -59,4 +68,153 @@ describe('tab-bar-toolbar', () => {
 
     });
 
+    describe('menu delegates', () => {
+
+        const TEST_MENU_PATH = ['test-toolbar-delegate'];
+        const TEST_COMMAND = 'test.toolbar.command';
+        const TEST_SUBMENU_COMMAND = 'test.toolbar.submenu.command';
+
+        let contextKeyService: ContextKeyServiceDummyImpl;
+
+        before(() => {
+            disableJSDOM = enableJSDOM();
+        });
+
+        beforeEach(() => {
+            contextKeyService = new ContextKeyServiceDummyImpl();
+        });
+
+        after(() => {
+            disableJSDOM();
+        });
+
+        it('passes the delegated widget to command visibility', () => {
+            const testWidget = new TestToolbarWidget();
+            const commands = createCommandRegistry();
+            commands.registerCommand({ id: TEST_COMMAND, label: 'Test Command' }, {
+                execute: () => { },
+                isVisible: widget => TestToolbarWidget.is(widget) && widget === testWidget
+            });
+            const menuRegistry = createMenuRegistry(commands);
+            menuRegistry.registerMenuAction([...TEST_MENU_PATH, 'other'], { commandId: TEST_COMMAND });
+            const registry = createToolbarRegistry(commands, menuRegistry, contextKeyService);
+            registry.registerMenuDelegate(TEST_MENU_PATH, TestToolbarWidget.is);
+
+            const commandItem = registry.visibleItems(testWidget).find(item => item.id === `${TEST_COMMAND}${TOOLBAR_WRAPPER_ID_SUFFIX}`);
+
+            expect(commandItem).to.exist;
+            testWidget.dispose();
+        });
+
+        it('preserves the widget for wrapped command menu visibility, enablement, toggled state, and execution', async () => {
+            const testWidget = new TestToolbarWidget();
+            let executedWith: unknown;
+            const commands = createCommandRegistry();
+            commands.registerCommand({ id: TEST_COMMAND, label: 'Test Command' }, {
+                execute: widget => executedWith = widget,
+                isVisible: widget => TestToolbarWidget.is(widget) && widget === testWidget,
+                isEnabled: widget => TestToolbarWidget.is(widget) && widget === testWidget,
+                isToggled: widget => TestToolbarWidget.is(widget) && widget === testWidget
+            });
+            const menuRegistry = createMenuRegistry(commands);
+            menuRegistry.registerMenuAction([...TEST_MENU_PATH, 'other'], { commandId: TEST_COMMAND });
+            const registry = createToolbarRegistry(commands, menuRegistry, contextKeyService);
+            registry.registerMenuDelegate(TEST_MENU_PATH, TestToolbarWidget.is);
+            const commandItem = registry.visibleItems(testWidget).find(item => item.id === `${TEST_COMMAND}${TOOLBAR_WRAPPER_ID_SUFFIX}`);
+            const node = commandItem?.toMenuNode?.();
+
+            expect(CommandMenu.is(node)).to.be.true;
+            if (!CommandMenu.is(node)) {
+                throw new Error('Expected a command menu node.');
+            }
+            expect(node.isVisible(TAB_BAR_TOOLBAR_CONTEXT_MENU, contextKeyService, testWidget.node, testWidget)).to.be.true;
+            expect(node.isEnabled(TAB_BAR_TOOLBAR_CONTEXT_MENU, testWidget)).to.be.true;
+            expect(node.isToggled(TAB_BAR_TOOLBAR_CONTEXT_MENU, testWidget)).to.be.true;
+            await node.run(TAB_BAR_TOOLBAR_CONTEXT_MENU, testWidget);
+            expect(executedWith).to.equal(testWidget);
+            testWidget.dispose();
+        });
+
+        it('preserves the widget for wrapped submenu emptiness checks', () => {
+            const testWidget = new TestToolbarWidget();
+            const commands = createCommandRegistry();
+            commands.registerCommand({ id: TEST_SUBMENU_COMMAND, label: 'Test Submenu Command' }, {
+                execute: () => { },
+                isVisible: widget => TestToolbarWidget.is(widget) && widget === testWidget
+            });
+            const menuRegistry = createMenuRegistry(commands);
+            menuRegistry.registerSubmenu([...TEST_MENU_PATH, 'other', 'test-submenu'], 'Test Submenu');
+            menuRegistry.registerMenuAction([...TEST_MENU_PATH, 'other', 'test-submenu'], { commandId: TEST_SUBMENU_COMMAND });
+            const registry = createToolbarRegistry(commands, menuRegistry, contextKeyService);
+            registry.registerMenuDelegate(TEST_MENU_PATH, TestToolbarWidget.is);
+            const submenuItem = registry.visibleItems(testWidget).find(item => item.id === `test-submenu${TOOLBAR_WRAPPER_ID_SUFFIX}`);
+            const node = submenuItem?.toMenuNode?.();
+
+            expect(CompoundMenuNode.is(node)).to.be.true;
+            if (!CompoundMenuNode.is(node)) {
+                throw new Error('Expected a compound menu node.');
+            }
+            expect(node.isEmpty(TAB_BAR_TOOLBAR_CONTEXT_MENU, contextKeyService, testWidget.node, testWidget)).to.be.false;
+            testWidget.dispose();
+        });
+
+    });
+
 });
+
+class TestToolbarWidget extends Widget {
+    static is(candidate?: Widget): candidate is TestToolbarWidget {
+        return candidate instanceof TestToolbarWidget;
+    }
+}
+
+class TestMenuNodeFactory implements MenuNodeFactory {
+
+    constructor(protected readonly commands: CommandRegistry) { }
+
+    createGroup(id: string, orderString?: string, when?: string): Group & MutableCompoundMenuNode {
+        return new GroupImpl(id, orderString, when);
+    }
+
+    createSubmenu(id: string, label: string, contextKeyOverlays: Record<string, string> | undefined, orderString?: string, icon?: string, when?: string):
+        Submenu & MutableCompoundMenuNode {
+        return new SubmenuImpl(id, label, contextKeyOverlays, orderString, icon, when);
+    }
+
+    createSubmenuLink(delegate: Submenu, sortString?: string, when?: string): MenuNode {
+        return new SubMenuLink(delegate, sortString, when);
+    }
+
+    createCommandMenu(item: MenuAction): CommandMenu {
+        return {
+            isVisible: (_path, _contextMatcher, _context, ...args) => this.commands.isVisible(item.commandId, ...args),
+            isEnabled: (_path, ...args) => this.commands.isEnabled(item.commandId, ...args),
+            isToggled: (_path, ...args) => this.commands.isToggled(item.commandId, ...args),
+            id: item.commandId,
+            label: item.label || this.commands.getCommand(item.commandId)?.label || '',
+            icon: item.icon,
+            when: item.when,
+            sortString: item.order || '',
+            run: async (_path, ...args) => { await this.commands.executeCommand(item.commandId, ...args); }
+        };
+    }
+}
+
+function createCommandRegistry(): CommandRegistry {
+    return new CommandRegistry({ getContributions: () => [] });
+}
+
+function createMenuRegistry(commands: CommandRegistry): MenuModelRegistry {
+    return new MenuModelRegistry({ getContributions: () => [] }, commands, new TestMenuNodeFactory(commands));
+}
+
+function createToolbarRegistry(commands: CommandRegistry, menuRegistry: MenuModelRegistry, contextKeyService: ContextKeyServiceDummyImpl): TabBarToolbarRegistry {
+    const registry = new TabBarToolbarRegistry();
+    Reflect.set(registry, 'commandRegistry', commands);
+    Reflect.set(registry, 'contextKeyService', contextKeyService);
+    Reflect.set(registry, 'menuRegistry', menuRegistry);
+    Reflect.set(registry, 'keybindingRegistry', {});
+    Reflect.set(registry, 'labelParser', {});
+    Reflect.set(registry, 'contextMenuRenderer', { render: () => undefined } as unknown as ContextMenuRenderer);
+    return registry;
+}

package/src/browser/status-bar/status-bar.tsx

@@ -99,7 +99,7 @@ export class StatusBarImpl extends ReactWidget implements StatusBar {
     protected internalSetColor(color?: string): void {
         this.color = color;
     }
-    protected render(): JSX.Element {
+    protected render(): React.JSX.Element {
         const leftEntries = Array.from(this.viewModel.getLeft(), entry => this.renderElement(entry));
         const rightEntries = Array.from(this.viewModel.getRight(), entry => this.renderElement(entry));
 
@@ -192,9 +192,9 @@ export class StatusBarImpl extends ReactWidget implements StatusBar {
         return attrs;
     }
 
-    protected renderElement(entry: StatusBarViewEntry): JSX.Element {
+    protected renderElement(entry: StatusBarViewEntry): React.JSX.Element {
         const childStrings = this.entryService.parse(entry.entry.text);
-        const children: JSX.Element[] = [];
+        const children: React.JSX.Element[] = [];
 
         childStrings.forEach((val, key) => {
             if (LabelIcon.is(val)) {

package/src/browser/test/jsdom.ts

@@ -72,3 +72,21 @@ export function enableJSDOM(): () => void {
     };
     return disableJSDOM;
 }
+
+/**
+ * Enables React's act test environment and restores the previous value when disposed.
+ */
+export function enableReactActEnvironment(): () => void {
+    const reactActEnvironment = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
+    const hadReactActEnvironment = Object.prototype.hasOwnProperty.call(reactActEnvironment, 'IS_REACT_ACT_ENVIRONMENT');
+    const previousReactActEnvironment = reactActEnvironment.IS_REACT_ACT_ENVIRONMENT;
+    reactActEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+
+    return () => {
+        if (hadReactActEnvironment) {
+            reactActEnvironment.IS_REACT_ACT_ENVIRONMENT = previousReactActEnvironment;
+        } else {
+            delete reactActEnvironment.IS_REACT_ACT_ENVIRONMENT;
+        }
+    };
+}

package/src/browser/tree/tree-container.spec.ts

@@ -19,6 +19,8 @@ import { Container } from 'inversify';
 import { createTreeContainer, isTreeServices } from './tree-container';
 import { TreeSearch } from './tree-search';
 import { defaultTreeProps, TreeProps } from './tree-widget';
+import { ILogger } from '../../common/logger';
+import { MockLogger } from '../../common/test/mock-logger';
 
 describe('TreeContainer', () => {
     describe('IsTreeServices should accurately distinguish TreeProps from TreeContainerProps', () => {
@@ -33,11 +35,15 @@ describe('TreeContainer', () => {
         const nonDefault = { search: !defaultTreeProps.search, contextMenu: ['no-default-for-this'] };
         it('should use props passed in as just props', () => {
             const parent = new Container();
+            parent.bind(ILogger).to(MockLogger).inSingletonScope();
+
             const child = createTreeContainer(parent, nonDefault);
             assert.deepStrictEqual(child.get(TreeProps), { ...defaultTreeProps, ...nonDefault });
         });
         it('should use props passed in as part of TreeContainerProps', () => {
             const parent = new Container();
+            parent.bind(ILogger).to(MockLogger).inSingletonScope();
+
             const child = createTreeContainer(parent, { props: nonDefault });
             assert.deepStrictEqual(child.get(TreeProps), { ...defaultTreeProps, ...nonDefault });
         });

package/src/browser/tree/tree-widget.tsx

@@ -545,7 +545,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
                 return <this.ScrollingRowRenderer rows={rows} />;
             }
             return <TreeWidget.View
-                ref={view => this.view = (view || undefined)}
+                ref={view => { this.view = (view || undefined); }}
                 width={this.node.offsetWidth}
                 height={this.node.offsetHeight}
                 rows={rows}
@@ -1689,7 +1689,7 @@ export namespace TreeWidget {
         override render(): React.ReactNode {
             const { rows, width, height, scrollToRow, renderNodeRow, onScrollEmitter, ...other } = this.props;
             return <Virtuoso
-                ref={list => {
+                ref={(list: VirtuosoHandle | null) => {
                     this.list = (list || undefined);
                     this.scrollIntoViewIfNeeded();
                 }}

package/src/browser/tree/tree.ts

@@ -14,13 +14,14 @@
 // 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 { Event, Emitter, WaitUntilEvent } from '../../common/event';
 import { Disposable, DisposableCollection } from '../../common/disposable';
 import { CancellationToken, CancellationTokenSource } from '../../common/cancellation';
 import { timeout } from '../../common/promise-util';
 import { isObject, Mutable } from '../../common';
 import { AccessibilityInformation } from '../../common/accessibility';
+import { ILogger } from '../../common/logger';
 
 export const Tree = Symbol('Tree');
 
@@ -250,6 +251,9 @@ export namespace CompositeTreeNode {
 @injectable()
 export class TreeImpl implements Tree {
 
+    @inject(ILogger) @named('core:TreeImpl')
+    protected readonly logger: ILogger;
+
     protected _root: TreeNode | undefined;
     protected readonly onChangedEmitter = new Emitter<void>();
     protected readonly onNodeRefreshedEmitter = new Emitter<CompositeTreeNode & WaitUntilEvent>();
@@ -344,7 +348,7 @@ export class TreeImpl implements Tree {
     protected async setChildren(parent: CompositeTreeNode, children: TreeNode[]): Promise<CompositeTreeNode | undefined> {
         const root = this.getRootNode(parent);
         if (this.nodes[root.id] && this.nodes[root.id] !== root) {
-            console.error(`Child node '${parent.id}' does not belong to this '${root.id}' tree.`);
+            this.logger.error(`Child node '${parent.id}' does not belong to this '${root.id}' tree.`);
             return undefined;
         }
         this.removeNode(parent);

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

@@ -15,11 +15,12 @@
 // *****************************************************************************
 
 import { Container } from 'inversify';
-import { ContributionProvider } from '../../common';
+import { ContributionProvider, ILogger } from '../../common';
 import { CorePreferences } from '../../common/core-preferences';
 import { FrontendApplicationContribution } from '../frontend-application-contribution';
 import { DefaultWindowService } from './default-window-service';
 import assert = require('assert');
+import { MockLogger } from '../../common/test/mock-logger';
 
 describe('DefaultWindowService', () => {
     class TestFrontendApplicationContribution implements FrontendApplicationContribution {
@@ -42,6 +43,7 @@ describe('DefaultWindowService', () => {
             .toConstantValue({
                 'application.confirmExit': confirmExit,
             });
+        container.bind(ILogger).to(MockLogger).inSingletonScope();
         return container.get(DefaultWindowService);
     }
     it('onWillStop should be called on every contribution (never)', () => {

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

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { inject, injectable, named } from 'inversify';
-import { Event, Emitter } from '../../common';
+import { Event, Emitter, ILogger } from '../../common';
 import { CorePreferences } from '../../common/core-preferences';
 import { ContributionProvider } from '../../common/contribution-provider';
 import { FrontendApplicationContribution, OnWillStopAction } from '../frontend-application-contribution';
@@ -43,6 +43,9 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
     @named(FrontendApplicationContribution)
     protected readonly contributions: ContributionProvider<FrontendApplicationContribution>;
 
+    @inject(ILogger) @named('core:DefaultWindowService')
+    protected readonly logger: ILogger;
+
     onStart(app: FrontendApplication): void {
         this.frontendApplication = app;
         this.registerUnloadListeners();
@@ -114,7 +117,7 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
             return true;
         }
         const preparedValues = await Promise.all(vetoes.map(e => e.prepare?.(stopReason)));
-        console.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
+        this.logger.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
         for (let i = 0; i < vetoes.length; i++) {
             try {
                 const result = await vetoes[i].action(preparedValues[i], stopReason);
@@ -122,10 +125,10 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
                     return false;
                 }
             } catch (e) {
-                console.error(e);
+                this.logger.error(e);
             }
         }
-        console.debug('OnWillStop actions resolved; allowing shutdown');
+        this.logger.debug('OnWillStop actions resolved; allowing shutdown');
         this.allowVetoes = false;
         return true;
     }
@@ -145,10 +148,10 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
         const vetoes = this.collectContributionUnloadVetoes();
         if (vetoes.length) {
             // In the browser, we don't call the functions because this has to finish in a single tick, so we treat any desired action as a veto.
-            console.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
+            this.logger.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
             return this.preventUnload(event);
         }
-        console.debug('Shutdown will proceed.');
+        this.logger.debug('Shutdown will proceed.');
     }
 
     /**

package/src/browser-only/messaging/frontend-only-service-connection-provider.ts

@@ -14,8 +14,9 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { Event, RpcProxy, Channel, RpcProxyFactory, Emitter } from '../../common';
-import { injectable } from 'inversify';
+import { injectable, inject, named } from 'inversify';
 import { ServiceConnectionProvider } from '../../browser/messaging/service-connection-provider';
+import { ILogger } from '../../common/logger';
 import { ConnectionSource } from '../../browser/messaging/connection-source';
 
 @injectable()
@@ -25,15 +26,19 @@ export class FrontendOnlyConnectionSource implements ConnectionSource {
 
 @injectable()
 export class FrontendOnlyServiceConnectionProvider extends ServiceConnectionProvider {
+
+    @inject(ILogger) @named('core:FrontendOnlyServiceConnectionProvider')
+    protected readonly logger: ILogger;
+
     onSocketDidOpen = Event.None;
     onSocketDidClose = Event.None;
     onIncomingMessageActivity = Event.None;
     override createProxy<T extends object>(path: unknown, target?: unknown): RpcProxy<T> {
-        console.debug(`[Frontend-Only Fallback] Created proxy connection for ${path}`);
+        this.logger.debug(`[Frontend-Only Fallback] Created proxy connection for ${path}`);
         const factory = target instanceof RpcProxyFactory ? target : new RpcProxyFactory<T>(target);
         return factory.createProxy();
     }
     override listen(path: string, handler: ServiceConnectionProvider.ConnectionHandler, reconnect: boolean): void {
-        console.debug('[Frontend-Only Fallback] Listen to websocket connection requested');
+        this.logger.debug('[Frontend-Only Fallback] Listen to websocket connection requested');
     }
 }

package/src/common/command.ts

@@ -21,6 +21,7 @@ import { ContributionProvider } from './contribution-provider';
 import { nls } from './nls';
 import debounce = require('p-debounce');
 import { isObject } from './types';
+import { ILogger } from './logger';
 
 /**
  * A command is a unique identifier of a function
@@ -190,6 +191,9 @@ export interface CommandService {
 @injectable()
 export class CommandRegistry implements CommandService {
 
+    @inject(ILogger) @named('core:CommandRegistry')
+    protected readonly logger: ILogger;
+
     protected readonly _commands: { [id: string]: Command } = {};
     protected readonly _handlers: { [id: string]: CommandHandler[] } = {};
 
@@ -232,7 +236,7 @@ export class CommandRegistry implements CommandService {
      */
     registerCommand(command: Command, handler?: CommandHandler): Disposable {
         if (this._commands[command.id]) {
-            console.warn(`A command ${command.id} is already registered.`);
+            this.logger.warn(`A command ${command.id} is already registered.`);
             return Disposable.NULL;
         }
         const toDispose = new DisposableCollection(this.doRegisterCommand(command));
@@ -363,7 +367,7 @@ export class CommandRegistry implements CommandService {
                         return handler;
                     }
                 } catch (error) {
-                    console.error(error);
+                    this.logger.error(error);
                 }
             }
         }
@@ -383,7 +387,7 @@ export class CommandRegistry implements CommandService {
                         return handler;
                     }
                 } catch (error) {
-                    console.error(error);
+                    this.logger.error(error);
                 }
             }
         }
@@ -403,7 +407,7 @@ export class CommandRegistry implements CommandService {
                         return handler;
                     }
                 } catch (error) {
-                    console.error(error);
+                    this.logger.error(error);
                 }
             }
         }

package/src/common/preferences/injectable-preference-proxy.ts

@@ -106,7 +106,13 @@ export class InjectablePreferenceProxy<T extends Record<string, JSONValue>> impl
         }
     }
 
-    get(target: unknown, property: string, receiver: unknown): unknown {
+    get(target: unknown, property: string | symbol, receiver: unknown): unknown {
+        // React 19 dev mode calls Object.prototype.toString when handling prop diffs, which
+        // probes Symbol.toStringTag. Throwing should be avoided in this case, it crashes the React DOM.
+        if (property === Symbol.toStringTag) {
+            return undefined;
+        }
+
         if (typeof property !== 'string') {
             throw new Error(`Unexpected property: ${String(property)}`);
         }
@@ -156,7 +162,7 @@ export class InjectablePreferenceProxy<T extends Record<string, JSONValue>> impl
         }
     }
 
-    set(target: unknown, property: string, value: unknown, receiver: unknown): boolean {
+    set(target: unknown, property: string | symbol, value: unknown, receiver: unknown): boolean {
         if (typeof property !== 'string') {
             throw new Error(`Unexpected property: ${String(property)}`);
         }
@@ -212,8 +218,8 @@ export class InjectablePreferenceProxy<T extends Record<string, JSONValue>> impl
         return properties;
     }
 
-    getOwnPropertyDescriptor(target: unknown, property: string): PropertyDescriptor {
-        if (this.ownKeys().includes(property)) {
+    getOwnPropertyDescriptor(target: unknown, property: string | symbol): PropertyDescriptor {
+        if (typeof property === 'string' && this.ownKeys().includes(property)) {
             return {
                 enumerable: true,
                 configurable: true

package/src/common/preferences/preference-proxy.ts

@@ -239,7 +239,7 @@ export function createPreferenceProxy<T>(preferences: PreferenceService, promise
         return properties;
     };
 
-    const set: (target: any, prop: string, value: any, receiver: any) => boolean = (_, property: string | symbol | number, value: any) => {
+    const set: (target: any, prop: string | symbol, value: any, receiver: any) => boolean = (_, property: string | symbol | number, value: any) => {
         if (typeof property !== 'string') {
             throw new Error(`unexpected property: ${String(property)}`);
         }
@@ -270,7 +270,13 @@ export function createPreferenceProxy<T>(preferences: PreferenceService, promise
         return false;
     };
 
-    const get: (target: any, prop: string) => any = (_, property: string | symbol | number) => {
+    const get: (target: any, prop: string | symbol) => any = (_, property: string | symbol | number) => {
+        // React 19 dev mode calls Object.prototype.toString when handling prop diffs, which
+        // probes Symbol.toStringTag. Throwing should be avoided in this case, it crashes the React DOM.
+        if (property === Symbol.toStringTag) {
+            return undefined;
+        }
+
         if (typeof property !== 'string') {
             throw new Error(`unexpected property: ${String(property)}`);
         }
@@ -347,8 +353,8 @@ export function createPreferenceProxy<T>(preferences: PreferenceService, promise
     return new Proxy({}, {
         get,
         ownKeys,
-        getOwnPropertyDescriptor: (_, property: string) => {
-            if (ownKeys().indexOf(property) !== -1) {
+        getOwnPropertyDescriptor: (_, property: string | symbol) => {
+            if (typeof property === 'string' && ownKeys().indexOf(property) !== -1) {
                 return {
                     enumerable: true,
                     configurable: true

package/src/electron-main/electron-main-application.ts

@@ -394,6 +394,8 @@ export class ElectronMainApplication {
         const cancelTokenSource = new CancellationTokenSource();
         const minTime = timeout(splashScreenOptions.minDuration ?? 0, cancelTokenSource.token);
         const maxTime = timeout(splashScreenOptions.maxDuration ?? 30000, cancelTokenSource.token);
+        // Swallow rejections that occur when the cancellation token is cancelled after one of the timers wins.
+        const ignoreCancellation = () => { /* timer was cancelled, intentionally ignored */ };
 
         const showWindowAndCloseSplashScreen = () => {
             cancelTokenSource.cancel();
@@ -404,10 +406,10 @@ export class ElectronMainApplication {
         };
         TheiaRendererAPI.onApplicationStateChanged(mainWindow.webContents, state => {
             if (state === 'ready') {
-                minTime.then(() => showWindowAndCloseSplashScreen());
+                minTime.then(() => showWindowAndCloseSplashScreen(), ignoreCancellation);
             }
         });
-        maxTime.then(() => showWindowAndCloseSplashScreen());
+        maxTime.then(() => showWindowAndCloseSplashScreen(), ignoreCancellation);
         return splashScreenWindow;
     }