@theia/core 1.73.0-next.9 → 1.73.1

package/src/browser/preferences/frontend-config-preference-contributions.ts

@@ -14,16 +14,21 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from 'inversify';
+import { injectable, named, inject } from 'inversify';
 import { PreferenceContribution, PreferenceSchema, PreferenceSchemaService } from '../../common/preferences/preference-schema';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
 import { FrontendApplicationPreferenceConfig } from './preference-contribution';
 import { PreferenceLanguageOverrideService } from '../../common/preferences/preference-language-override-service';
 import { PreferenceScope } from '../../common/preferences';
 import { DefaultTheme } from '@theia/application-package/lib/application-props';
+import { ILogger } from '../../common/logger';
 
 @injectable()
 export class FrontendConfigPreferenceContribution implements PreferenceContribution {
+
+    @inject(ILogger) @named('core:FrontendConfigPreferenceContribution')
+    protected readonly logger: ILogger;
+
     schema: PreferenceSchema = { scope: PreferenceScope.Folder, properties: {} };
     async initSchema(service: PreferenceSchemaService): Promise<void> {
         const config = FrontendApplicationConfigProvider.get();
@@ -44,7 +49,7 @@ export class FrontendConfigPreferenceContribution implements PreferenceContribut
                     }
                 }
             } catch (e) {
-                console.error('Failed to load preferences from frontend configuration.', e);
+                this.logger.error('Failed to load preferences from frontend configuration.', e);
             }
         }
     }

package/src/browser/preferences/preference-proxy.spec.ts

@@ -162,6 +162,14 @@ describe('Preference Proxy', () => {
                 expect(Object.keys(proxy).join()).to.equal(['my.pref'].join());
             });
 
+            it('supports object introspection through Symbol.toStringTag', async () => {
+                const { proxy, promisedSchema } = getProxy();
+                if (promisedSchema) {
+                    await promisedSchema;
+                }
+                expect(Object.prototype.toString.call(proxy)).to.equal('[object Object]');
+            });
+
             it('it should provide access in deep style but not flat', async () => {
                 const { proxy, promisedSchema } = getProxy(undefined, { style: 'deep' });
                 if (promisedSchema) {

package/src/browser/preferences/preference-schema-provider.spec.ts

@@ -24,6 +24,8 @@ import { bindPreferenceService } from '../frontend-application-bindings';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
 import { IndexedAccess, PreferenceDataProperty, PreferenceSchemaService } from '../../common/preferences/preference-schema';
 import { PreferenceProvider, PreferenceProviderProvider, PreferenceScope } from '../../common/preferences';
+import { ILogger } from '../../common';
+import { MockLogger } from '../../common/test/mock-logger';
 
 disableJSDOM();
 
@@ -38,6 +40,9 @@ let testContainer: Container;
 function createTestContainer(): Container {
     const result = new Container();
     bindPreferenceService(result.bind.bind(result));
+
+    result.bind(ILogger).to(MockLogger).inSingletonScope();
+
     return result;
 }
 

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

@@ -21,9 +21,10 @@ import { JSONValue } from '@lumino/coreutils';
 import { IJSONSchema, JsonType } from '../../common/json-schema';
 import {
     DefaultsPreferenceProvider, Disposable, PreferenceDataProperty, PreferenceProvider,
-    PreferenceSchemaService, PreferenceSchemaServiceImpl, PreferenceScope
+    PreferenceSchemaService, PreferenceSchemaServiceImpl, PreferenceScope, ILogger
 } from '../../common';
 import { PreferenceLanguageOverrideService } from '../../common/preferences/preference-language-override-service';
+import { MockLogger } from '../../common/test/mock-logger';
 
 /* eslint-disable no-null/no-null */
 
@@ -35,6 +36,7 @@ describe('Preference Validation Service', () => {
     } as unknown as PreferenceSchemaService);
     container.bind(PreferenceLanguageOverrideService).to(PreferenceLanguageOverrideService).inSingletonScope();
     container.bind(PreferenceProvider).to(DefaultsPreferenceProvider).inSingletonScope().whenTargetNamed(PreferenceScope.Default);
+    container.bind(ILogger).to(MockLogger).inSingletonScope();
 
     const validator = container.resolve(PreferenceValidationService);
     const validateBySchema: (value: JSONValue, schema: PreferenceDataProperty) => JSONValue = validator.validateBySchema.bind(validator, 'dummy');

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