@theia/core 1.76.0-next.28 → 1.76.0-next.34

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

@@ -18,13 +18,18 @@ import { enableJSDOM } from '../../test/jsdom';
 
 let disableJSDOM = enableJSDOM();
 import { expect } from 'chai';
+import { renderToStaticMarkup } from 'react-dom/server';
 import {
     CommandMenu, CommandRegistry, CompoundMenuNode, Group, GroupImpl, MenuAction, MenuModelRegistry, MenuNode, MenuNodeFactory, MutableCompoundMenuNode,
     Submenu, SubmenuImpl, SubMenuLink
 } from '../../../common';
-import { ContextKeyServiceDummyImpl } from '../../context-key-service';
+import { ContextKeyServiceDummyImpl, ContextMatcher } from '../../context-key-service';
 import { ContextMenuRenderer } from '../../context-menu-renderer';
 import { Widget } from '../../widgets';
+import URI from '../../../common/uri';
+import { ResourceContextKey } from '../../resource-context-key';
+import { WidgetContextKeyContribution } from '../../widget-context-key-contribution';
+import { TabBarToolbar } from './tab-bar-toolbar';
 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';
@@ -135,6 +140,106 @@ describe('tab-bar-toolbar', () => {
             testWidget.dispose();
         });
 
+        it('evaluates delegated items against the resource of the widget that owns the toolbar', () => {
+            const testWidget = new TestToolbarWidget(new URI('probe:/a.probe'));
+            const commands = createCommandRegistry();
+            commands.registerCommand({ id: TEST_COMMAND, label: 'Test Command' }, { execute: () => { } });
+            const menuRegistry = createMenuRegistry(commands);
+            menuRegistry.registerMenuAction([...TEST_MENU_PATH, 'other'], { commandId: TEST_COMMAND, when: 'resourceScheme == probe' });
+            const registry = createToolbarRegistry(commands, menuRegistry, new TestContextKeyService());
+            registry.registerMenuDelegate(TEST_MENU_PATH, TestToolbarWidget.is);
+
+            const commandItem = registry.visibleItems(testWidget).find(item => item.id === `${TEST_COMMAND}${TOOLBAR_WRAPPER_ID_SUFFIX}`);
+
+            const otherWidget = new TestToolbarWidget(new URI('file:/a.txt'));
+
+            expect(commandItem).to.exist;
+            expect(registry.visibleItems(otherWidget)).to.be.empty;
+            testWidget.dispose();
+            otherWidget.dispose();
+        });
+
+        it('evaluates registered items against the keys contributed for the widget that owns the toolbar', () => {
+            const testWidget = new TestToolbarWidget(new URI('probe:/a.probe'));
+            const otherWidget = new TestToolbarWidget(new URI('probe:/b.probe'));
+            const commands = createCommandRegistry();
+            commands.registerCommand({ id: TEST_COMMAND, label: 'Test Command' }, { execute: () => { } });
+            const menuRegistry = createMenuRegistry(commands);
+            const contribution: WidgetContextKeyContribution = {
+                getContextKeyValues: widget => [['activeCustomEditorId', widget === testWidget ? 'test.probeEditor' : '']]
+            };
+            const registry = createToolbarRegistry(commands, menuRegistry, new TestContextKeyService(), [contribution]);
+            registry.registerItem({ id: 'test-item', command: TEST_COMMAND, when: 'activeCustomEditorId == test.probeEditor' });
+
+            expect(registry.visibleItems(testWidget).map(item => item.id)).to.deep.equal(['test-item']);
+            expect(registry.visibleItems(otherWidget)).to.be.empty;
+            testWidget.dispose();
+            otherWidget.dispose();
+        });
+
+        it('renders the submenu chevron against the widget that owns the toolbar', () => {
+            const testWidget = new TestToolbarWidget();
+            const otherWidget = new TestToolbarWidget();
+            const commands = createCommandRegistry();
+            commands.registerCommand({ id: TEST_SUBMENU_COMMAND, label: 'Test Submenu Command' }, { execute: () => { } });
+            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, when: 'activeCustomEditorId == test.probeEditor' });
+            const contribution: WidgetContextKeyContribution = {
+                getContextKeyValues: widget => [['activeCustomEditorId', widget === testWidget ? 'test.probeEditor' : '']]
+            };
+            const registry = createToolbarRegistry(commands, menuRegistry, new TestContextKeyService(), [contribution]);
+            registry.registerMenuDelegate(TEST_MENU_PATH, TestToolbarWidget.is);
+            const submenuItem = registry.visibleItems(testWidget).find(item => item.id === `test-submenu${TOOLBAR_WRAPPER_ID_SUFFIX}`);
+
+            expect(submenuItem).to.exist;
+            expect(renderToStaticMarkup(submenuItem!.render(testWidget, registry.contextMatcherFor(testWidget)))).to.contain('chevron');
+            expect(renderToStaticMarkup(submenuItem!.render(testWidget, registry.contextMatcherFor(otherWidget)))).to.not.contain('chevron');
+            testWidget.dispose();
+            otherWidget.dispose();
+        });
+
+        it('opens the More Actions menu against the widget that owns the toolbar', () => {
+            const testWidget = new TestToolbarWidget();
+            const otherWidget = new TestToolbarWidget();
+            const commands = createCommandRegistry();
+            commands.registerCommand({ id: TEST_SUBMENU_COMMAND, label: 'Test Submenu Command' }, { execute: () => { } });
+            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, when: 'activeCustomEditorId == test.probeEditor' });
+            const contribution: WidgetContextKeyContribution = {
+                getContextKeyValues: widget => [['activeCustomEditorId', widget === testWidget ? 'test.probeEditor' : '']]
+            };
+            const ambient = new TestContextKeyService();
+            const registry = createToolbarRegistry(commands, menuRegistry, ambient, [contribution]);
+            registry.registerMenuDelegate(TEST_MENU_PATH, TestToolbarWidget.is);
+
+            let rendered: { contextKeyService?: ContextMatcher } | undefined;
+            const toolbar = new TabBarToolbar();
+            Reflect.set(toolbar, 'contextKeyService', ambient);
+            Reflect.set(toolbar, 'toolbarRegistry', registry);
+            Reflect.set(toolbar, 'contextMenuRenderer', {
+                render: (options: { contextKeyService?: ContextMatcher }) => {
+                    rendered = options;
+                    return { dispose: () => { } };
+                }
+            });
+            const setCurrent = Reflect.get(toolbar, 'setCurrent') as (widget: Widget) => void;
+
+            setCurrent.call(toolbar, testWidget);
+            toolbar.renderMoreContextMenu({ x: 0, y: 0 });
+            expect(rendered?.contextKeyService?.match('activeCustomEditorId == test.probeEditor')).to.be.true;
+
+            setCurrent.call(toolbar, otherWidget);
+            toolbar.renderMoreContextMenu({ x: 0, y: 0 });
+            expect(rendered?.contextKeyService?.match('activeCustomEditorId == test.probeEditor')).to.be.false;
+
+            testWidget.dispose();
+            otherWidget.dispose();
+        });
+
         it('preserves the widget for wrapped submenu emptiness checks', () => {
             const testWidget = new TestToolbarWidget();
             const commands = createCommandRegistry();
@@ -166,6 +271,38 @@ class TestToolbarWidget extends Widget {
     static is(candidate?: Widget): candidate is TestToolbarWidget {
         return candidate instanceof TestToolbarWidget;
     }
+
+    constructor(protected readonly resourceUri?: URI) {
+        super();
+    }
+
+    getResourceUri(): URI | undefined {
+        return this.resourceUri;
+    }
+
+    createMoveToUri(resourceUri: URI): URI | undefined {
+        return resourceUri;
+    }
+}
+
+/**
+ * Evaluates `key == value` clauses against the overlay alone, so that a visible item can only come from the
+ * values the registry attributed to the widget.
+ */
+class TestContextKeyService extends ContextKeyServiceDummyImpl {
+    override match(expression: string): boolean {
+        return false;
+    }
+
+    override createOverlay(overlay: Iterable<[string, unknown]>): ContextMatcher {
+        const values = new Map(overlay);
+        return {
+            match: (expression: string) => {
+                const [key, value] = expression.split(' == ');
+                return values.get(key) === value;
+            }
+        };
+    }
 }
 
 class TestMenuNodeFactory implements MenuNodeFactory {
@@ -187,7 +324,8 @@ class TestMenuNodeFactory implements MenuNodeFactory {
 
     createCommandMenu(item: MenuAction): CommandMenu {
         return {
-            isVisible: (_path, _contextMatcher, _context, ...args) => this.commands.isVisible(item.commandId, ...args),
+            isVisible: (_path, contextMatcher, context, ...args) =>
+                (!item.when || contextMatcher.match(item.when, context)) && 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,
@@ -208,7 +346,12 @@ function createMenuRegistry(commands: CommandRegistry): MenuModelRegistry {
     return new MenuModelRegistry({ getContributions: () => [] }, commands, new TestMenuNodeFactory(commands));
 }
 
-function createToolbarRegistry(commands: CommandRegistry, menuRegistry: MenuModelRegistry, contextKeyService: ContextKeyServiceDummyImpl): TabBarToolbarRegistry {
+function createToolbarRegistry(
+    commands: CommandRegistry,
+    menuRegistry: MenuModelRegistry,
+    contextKeyService: ContextKeyServiceDummyImpl,
+    contextKeyContributions: WidgetContextKeyContribution[] = []
+): TabBarToolbarRegistry {
     const registry = new TabBarToolbarRegistry();
     Reflect.set(registry, 'commandRegistry', commands);
     Reflect.set(registry, 'contextKeyService', contextKeyService);
@@ -216,5 +359,9 @@ function createToolbarRegistry(commands: CommandRegistry, menuRegistry: MenuMode
     Reflect.set(registry, 'keybindingRegistry', {});
     Reflect.set(registry, 'labelParser', {});
     Reflect.set(registry, 'contextMenuRenderer', { render: () => undefined } as unknown as ContextMenuRenderer);
+    const resourceContextKey = new ResourceContextKey();
+    Reflect.set(resourceContextKey, 'languages', { languages: [] });
+    Reflect.set(registry, 'resourceContextKey', resourceContextKey);
+    Reflect.set(registry, 'contextKeyContributionProvider', { getContributions: () => contextKeyContributions });
     return registry;
 }

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

@@ -17,7 +17,7 @@
 import { inject, injectable, postConstruct } from 'inversify';
 import * as React from 'react';
 import { buttonKeyboardProps, isActivationKey } from '../../keyboard/keyboard-utils';
-import { ContextKeyService } from '../../context-key-service';
+import { ContextKeyService, ContextMatcher } from '../../context-key-service';
 import { CommandRegistry, Disposable, DisposableCollection, nls } from '../../../common';
 import { Anchor, ContextMenuAccess, ContextMenuRenderer } from '../../context-menu-renderer';
 import { LabelParser } from '../../label-parser';
@@ -48,6 +48,7 @@ export function toAnchor(event: React.MouseEvent): Anchor {
 export class TabBarToolbar extends ReactWidget {
 
     protected current: Widget | undefined;
+    protected contextMatcher: ContextMatcher;
     protected inline = new Map<string, TabBarToolbarItem>();
     protected more = new Map<string, TabBarToolbarItem>();
 
@@ -73,6 +74,7 @@ export class TabBarToolbar extends ReactWidget {
 
     @postConstruct()
     protected init(): void {
+        this.contextMatcher = this.contextKeyService;
         this.toDispose.pushAll([
             this.keybindings.onKeybindingsChanged(() => this.maybeUpdate()),
             this.contextKeyService.onDidChange(e => {
@@ -129,6 +131,7 @@ export class TabBarToolbar extends ReactWidget {
         this.toDisposeOnSetCurrent.dispose();
         this.toDispose.push(this.toDisposeOnSetCurrent);
         this.current = current;
+        this.contextMatcher = current ? this.toolbarRegistry.contextMatcherFor(current) : this.contextKeyService;
         if (current) {
             const resetCurrent = () => {
                 this.setCurrent(undefined);
@@ -145,7 +148,7 @@ export class TabBarToolbar extends ReactWidget {
         this.keybindingContextKeys.clear();
         return <React.Fragment>
             {this.renderMore()}
-            {[...this.inline.values()].map(item => item.render(this.current))}
+            {[...this.inline.values()].map(item => item.render(this.current, this.contextMatcher))}
         </React.Fragment>;
     }
 
@@ -199,7 +202,7 @@ export class TabBarToolbar extends ReactWidget {
             args: [this.current],
             anchor,
             context: this.current?.node || this.node,
-            contextKeyService: this.contextKeyService,
+            contextKeyService: this.contextMatcher,
             includeAnchorArg: false,
             onHide: () => toDisposeOnHide.dispose()
         });

package/src/browser/shell/tab-bar-toolbar/tab-toolbar-item.tsx

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { ContextKeyService } from '../../context-key-service';
+import { ContextKeyService, ContextMatcher } from '../../context-key-service';
 import { ReactTabBarToolbarAction, RenderedToolbarAction, TabBarToolbarActionBase } from './tab-bar-toolbar-types';
 import { Widget } from '@lumino/widgets';
 import { LabelIcon, LabelParser } from '../../label-parser';
@@ -29,10 +29,18 @@ import { ActionMenuNode, GroupImpl, MenuNode } from '../../../common/menu';
 export interface TabBarToolbarItem {
     id: string;
     when?: string;
-    isVisible(widget: Widget): boolean;
+    /**
+     * @param contextMatcher evaluates `when` clauses with the values that describe the given widget. Keys
+     * scoped to a DOM node keep resolving against the focused element, as no context node is passed here.
+     */
+    isVisible(widget: Widget, contextMatcher: ContextMatcher): boolean;
     isEnabled(widget: Widget): boolean;
     isToggled(widget: Widget): boolean;
-    render(widget?: Widget): React.ReactNode;
+    /**
+     * @param contextMatcher evaluates `when` clauses with the values that describe the given widget. Defaults
+     * to the ambient context, for toolbars that render items with no owning widget.
+     */
+    render(widget?: Widget, contextMatcher?: ContextMatcher): React.ReactNode;
     onDidChange?: Event<void>;
     group?: string;
     priority?: number;
@@ -68,12 +76,12 @@ class AbstractToolbarItemImpl<T extends TabBarToolbarActionBase> {
         return this.action.onDidChange;
     }
 
-    isVisible(widget: Widget): boolean {
+    isVisible(widget: Widget, contextMatcher: ContextMatcher): boolean {
         if (this.action.isVisible) {
             return this.action.isVisible(widget);
         }
         const actionVisible = !this.action.command || this.commandRegistry.isVisible(this.action.command, widget);
-        const contextMatches = !this.action.when || this.contextKeyService.match(this.action.when);
+        const contextMatches = !this.action.when || contextMatcher.match(this.action.when);
 
         return actionVisible && contextMatches;
     }

package/src/browser/view-container.ts

@@ -38,7 +38,7 @@ import { Drag } from '@lumino/dragdrop';
 import { MimeData } from '@lumino/coreutils';
 import { ElementExt } from '@lumino/domutils';
 import { TabBarDecoratorService } from './shell/tab-bar-decorator';
-import { ContextKeyService } from './context-key-service';
+import { ContextKeyService, ContextMatcher } from './context-key-service';
 import { KeybindingRegistry } from './keybinding';
 import { SubmenuAsToolbarItemWrapper } from './shell/tab-bar-toolbar/tab-bar-toolbar-menu-adapters';
 import { TheiaSplitPanel } from './shell/theia-split-panel';
@@ -109,8 +109,8 @@ class PartsMenuToolbarItem extends SubmenuAsToolbarItemWrapper {
         super(effectiveMenuPath, commandRegistry, menuRegistry, contextKeyService, contextMenuRenderer, menuNode, group);
     }
 
-    override isVisible(widget: Widget): boolean {
-        return widget === this.target() && super.isVisible(widget);
+    override isVisible(widget: Widget, contextMatcher: ContextMatcher): boolean {
+        return widget === this.target() && super.isVisible(widget, contextMatcher);
     }
 }
 

package/src/browser/widget-context-key-contribution.ts

@@ -0,0 +1,34 @@
+// *****************************************************************************
+// Copyright (C) 2026 JuliaHub, Inc. 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 { Widget } from '@lumino/widgets';
+
+export const WidgetContextKeyContribution = Symbol('WidgetContextKeyContribution');
+
+/**
+ * Contributes the context key values that describe a particular widget, so that `when` clauses about
+ * that widget - such as the ones of its tab bar toolbar items - can be evaluated without consulting the
+ * ambient context, which describes whichever widget currently has focus.
+ */
+export interface WidgetContextKeyContribution {
+    /**
+     * @param widget the widget to describe.
+     * @returns the values to overlay over the ambient context, or `undefined` if this contribution does not
+     * describe the given widget. A contribution owning a key should return an explicit "unset" value for the
+     * widgets the key does not apply to, so that the ambient value of another widget cannot leak in.
+     */
+    getContextKeyValues(widget: Widget): Iterable<[string, unknown]> | undefined;
+}