@theia/core 1.73.0-next.9 → 1.74.0-next.0

package/src/browser/preferences/preference-validation-service.ts

@@ -15,11 +15,12 @@
 // *****************************************************************************
 
 import { JSONObject, JSONValue } from '../../../shared/@lumino/coreutils';
-import { inject, injectable } from '../../../shared/inversify';
+import { inject, injectable, named } from '../../../shared/inversify';
 import { IJSONSchema, JsonType } from '../../common/json-schema';
 import { deepClone, unreachable } from '../../common';
 import { PreferenceLanguageOverrideService } from '../../common/preferences/preference-language-override-service';
 import { PreferenceSchemaService, PreferenceScope, PreferenceUtils, PreferenceDataProperty } from '../../common/preferences';
+import { ILogger } from '../../common/logger';
 
 export interface PreferenceValidator<T> {
     name: string;
@@ -40,6 +41,8 @@ type ValidatablePreferenceTuple = IJSONSchema & ({ items: IJSONSchema[] } | { pr
 export class PreferenceValidationService {
     @inject(PreferenceSchemaService) protected readonly schemaService: PreferenceSchemaService;
     @inject(PreferenceLanguageOverrideService) protected readonly languageOverrideService: PreferenceLanguageOverrideService;
+    @inject(ILogger) @named('core:PreferenceValidationService')
+    protected readonly logger: ILogger;
 
     validateOptions(options: Record<string, JSONValue>): Record<string, JSONValue> {
         const valid: Record<string, JSONValue> = {};
@@ -58,7 +61,7 @@ export class PreferenceValidationService {
         const validValue = this.doValidateByName(preferenceName, value);
         // If value is undefined, it means the preference wasn't set, not that a bad value was set.
         if (validValue !== value && value !== undefined) {
-            console.warn(`While validating options, found impermissible value for ${preferenceName}. Using valid value`, validValue, 'instead of configured value', value);
+            this.logger.warn(`While validating options, found impermissible value for ${preferenceName}. Using valid value`, validValue, 'instead of configured value', value);
         }
         return validValue;
     }
@@ -71,7 +74,7 @@ export class PreferenceValidationService {
     validateBySchema(key: string, value: JSONValue, schema: IJSONSchema | undefined): JSONValue {
         try {
             if (!schema) {
-                console.warn('Request to validate preference with no schema registered:', key);
+                this.logger.warn('Request to validate preference with no schema registered:', key);
                 return value;
             }
             if (schema.const !== undefined) {
@@ -87,7 +90,7 @@ export class PreferenceValidationService {
                 return this.validateOneOf(key, value, schema as IJSONSchema & { oneOf: IJSONSchema[] });
             }
             if (schema.type === undefined) {
-                console.warn('Request to validate preference with no type information:', key);
+                this.logger.warn('Request to validate preference with no type information:', key);
                 return value;
             }
             if (Array.isArray(schema.type)) {
@@ -112,7 +115,7 @@ export class PreferenceValidationService {
                     unreachable(schema.type, `Request to validate preference with unknown type in schema: ${key}`);
             }
         } catch (e) {
-            console.error('Encountered an error while validating', key, 'with value', value, 'against schema', schema, e);
+            this.logger.error('Encountered an error while validating', key, 'with value', value, 'against schema', schema, e);
             return value;
         }
     }
@@ -193,7 +196,7 @@ export class PreferenceValidationService {
             return [];
         }
         if (!schema.items && !schema.prefixItems) {
-            console.warn('Requested validation of array without item specification:', key);
+            this.logger.warn('Requested validation of array without item specification:', key);
             return candidate;
         }
         if (Array.isArray(schema.items) || Array.isArray(schema.prefixItems)) {

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

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import debounce = require('lodash.debounce');
-import { inject, injectable } from 'inversify';
+import { inject, injectable, named } from 'inversify';
 import { BoxLayout, ExtractableWidget, TabBar, Widget } from './widgets';
 import { MessageService } from '../common/message-service';
 import { ApplicationShell, DockPanelRenderer, MAIN_AREA_CLASS, MAIN_BOTTOM_AREA_CLASS } from './shell/application-shell';
@@ -23,6 +23,7 @@ import { Emitter } from '../common/event';
 import { isSecondaryWindow, SecondaryWindowRootWidget, SecondaryWindowService } from './window/secondary-window-service';
 import { KeybindingRegistry } from './keybinding';
 import { MAIN_AREA_ID, TheiaDockPanel } from './shell/theia-dock-panel';
+import { ILogger } from '../common/logger';
 import { nls } from '../common/nls';
 
 /** Widgets to be contained inside a DockPanel in the secondary window. */
@@ -104,6 +105,9 @@ export class SecondaryWindowHandler {
     @inject(TheiaDockPanel.Factory)
     protected dockPanelFactory: TheiaDockPanel.Factory;
 
+    @inject(ILogger) @named('core:SecondaryWindowHandler')
+    protected readonly logger: ILogger;
+
     protected readonly onWillAddWidgetEmitter = new Emitter<[Widget, Window]>();
     /** Subscribe to get notified when a widget is added to this handler, i.e. the widget was moved to an secondary window . */
     readonly onWillAddWidget = this.onWillAddWidgetEmitter.event;
@@ -157,11 +161,11 @@ export class SecondaryWindowHandler {
      */
     moveWidgetToSecondaryWindow(widget: ExtractableWidget): void {
         if (!this.applicationShell) {
-            console.error('Widget cannot be extracted because the WidgetExtractionHandler has not been initialized.');
+            this.logger.error('Widget cannot be extracted because the WidgetExtractionHandler has not been initialized.');
             return;
         }
         if (!widget.isExtractable) {
-            console.error('Widget is not extractable.', widget.id);
+            this.logger.error('Widget is not extractable.', widget.id);
             return;
         }
 
@@ -185,7 +189,7 @@ export class SecondaryWindowHandler {
 
             const element = newWindow.document.getElementById('widget-host');
             if (!element) {
-                console.error('Could not find dom element to attach to in secondary window');
+                this.logger.error('Could not find dom element to attach to in secondary window');
                 return;
             }
 
@@ -240,18 +244,18 @@ export class SecondaryWindowHandler {
     addWidgetToSecondaryWindow(widget: Widget, secondaryWindow: Window, options?: TheiaDockPanel.AddOptions): void {
         const rootWidget = isSecondaryWindow(secondaryWindow) ? secondaryWindow.rootWidget : undefined;
         if (!rootWidget) {
-            console.error('Given secondary window no known root.');
+            this.logger.error('Given secondary window no known root.');
             return;
         }
 
         // we allow to add any widget to an existing secondary window unless it is marked as not extractable or is already extracted
         if (ExtractableWidget.is(widget)) {
             if (!widget.isExtractable) {
-                console.error('Widget is not extractable.', widget.id);
+                this.logger.error('Widget is not extractable.', widget.id);
                 return;
             }
             if (widget.secondaryWindow !== undefined) {
-                console.error('Widget is extracted already.', widget.id);
+                this.logger.error('Widget is extracted already.', widget.id);
                 return;
             }
             widget.secondaryWindow = secondaryWindow;

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,9 +96,9 @@ 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}
+                <div id={this.id} className={className}
                     title={this.tooltip || this.text}
                     onClick={e => this.executeCommand(widget, e)}
                 />
@@ -108,7 +108,7 @@ abstract class AbstractToolbarMenuWrapper {
             </div>;
         } else {
             return <div key={this.id} className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled menu'}>
-                <div className={className}
+                <div id={this.id} className={className}
                     title={this.tooltip || this.text}
                     onClick={e => this.executeCommand(widget, e)}
                 />
@@ -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-model.ts

@@ -250,6 +250,10 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         return this.tree.validateNode(node);
     }
 
+    removeNode(node: TreeNode | undefined): void {
+        this.tree.removeNode(node);
+    }
+
     async refresh(parent?: Readonly<CompositeTreeNode>): Promise<CompositeTreeNode | undefined> {
         if (parent) {
             return this.tree.refresh(parent);

package/src/browser/tree/tree-view-welcome-widget.spec.ts

@@ -0,0 +1,82 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '../test/jsdom';
+
+// The widget module transitively imports `@lumino/widgets`, which touches `document` at load time.
+const disableJSDOM = enableJSDOM();
+
+import { Container } from 'inversify';
+import { expect } from 'chai';
+import { ReactElement, ReactNode } from 'react';
+import { CommandService } from '../../common';
+import { LabelParser } from '../label-parser';
+import { codicon } from '../widgets';
+import { TreeViewWelcomeWidget } from './tree-view-welcome-widget';
+
+disableJSDOM();
+
+let labelParser: LabelParser;
+
+before(() => {
+    const container = new Container();
+    container.bind(LabelParser).toSelf().inSingletonScope();
+    container.bind(CommandService).toDynamicValue(() => ({
+        executeCommand<T>(): Promise<T | undefined> {
+            return Promise.resolve(undefined);
+        }
+    })).inSingletonScope();
+    labelParser = container.get(LabelParser);
+});
+
+describe('TreeViewWelcomeWidget#renderLabelWithIcons', () => {
+
+    type SpanElement = ReactElement<{ className?: string; children?: ReactNode }>;
+
+    // Exercise the protected helper without standing up the full TreeWidget DI graph.
+    function render(label: string): SpanElement[] {
+        const widget = Object.create(TreeViewWelcomeWidget.prototype) as {
+            labelParser: LabelParser;
+            renderLabelWithIcons(label: string): SpanElement[];
+        };
+        widget.labelParser = labelParser;
+        return widget.renderLabelWithIcons(label);
+    }
+
+    it('renders a leading $(codicon) as a codicon span and keeps the trailing text', () => {
+        const nodes = render('$(robot) Launch AI Agent');
+        expect(nodes).to.have.lengthOf(2);
+        expect(nodes[0].props.className).to.equal(codicon('robot'));
+        expect(nodes[0].props.children).to.be.undefined;
+        expect(nodes[1].props.className).to.be.undefined;
+        expect(nodes[1].props.children).to.equal(' Launch AI Agent');
+    });
+
+    it('renders a plain label as a single text span with no codicon', () => {
+        const nodes = render('Open Documentation');
+        expect(nodes).to.have.lengthOf(1);
+        expect(nodes[0].props.className).to.be.undefined;
+        expect(nodes[0].props.children).to.equal('Open Documentation');
+    });
+
+    it('renders multiple codicons interleaved with text', () => {
+        const nodes = render('$(package) Import $(gear) Library');
+        const iconNodes = nodes.filter(n => typeof n.props.className === 'string' && n.props.className.includes('codicon-'));
+        expect(iconNodes).to.have.lengthOf(2);
+        expect(iconNodes[0].props.className).to.equal(codicon('package'));
+        expect(iconNodes[1].props.className).to.equal(codicon('gear'));
+    });
+});

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

@@ -209,22 +209,14 @@ export class TreeViewWelcomeWidget extends TreeWidget {
                     className='theia-button theia-WelcomeViewButton'
                     disabled={!this.isEnabledClick(enablement)}
                     onClick={e => this.openLinkOrCommand(e, node.href)}>
-                    {node.label}
+                    {this.renderLabelWithIcons(node.label)}
                 </button>
             </div>
         );
     }
 
     protected renderTextNode(node: string, textKey: string | number): React.ReactNode {
-        return <span key={`text-${textKey}`}>
-            {this.labelParser.parse(node)
-                .map((segment, index) =>
-                    LabelIcon.is(segment)
-                        ? <span
-                            key={index}
-                            className={codicon(segment.name)}
-                        />
-                        : <span key={index}>{segment}</span>)}</span>;
+        return <span key={`text-${textKey}`}>{this.renderLabelWithIcons(node)}</span>;
     }
 
     protected renderLinkNode(node: ILink, linkKey: string | number, enablement: string | undefined): React.ReactNode {
@@ -233,11 +225,18 @@ export class TreeViewWelcomeWidget extends TreeWidget {
                 className={this.getLinkClassName(node.href, enablement)}
                 title={node.title || ''}
                 onClick={e => this.openLinkOrCommand(e, node.href)}>
-                {node.label}
+                {this.renderLabelWithIcons(node.label)}
             </a>
         );
     }
 
+    protected renderLabelWithIcons(label: string): React.ReactNode[] {
+        return this.labelParser.parse(label).map((segment, index) =>
+            LabelIcon.is(segment)
+                ? <span key={index} className={codicon(segment.name)} />
+                : <span key={index}>{segment}</span>);
+    }
+
     protected getLinkClassName(href: string, enablement: string | undefined): string {
         const classNames = ['theia-WelcomeViewCommandLink'];
         // Only command-backed links can be disabled. All other, https:, file: remain enabled

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();
                 }}