@theia/core 1.40.1 → 1.42.0

package/src/browser/preferences/preference-contribution.ts

@@ -34,6 +34,8 @@ import { JSONValue } from '@phosphor/coreutils';
 
 export const PreferenceContribution = Symbol('PreferenceContribution');
 
+export const DefaultOverridesPreferenceSchemaId = 'defaultOverrides';
+
 /**
  * A {@link PreferenceContribution} allows adding additional custom preferences.
  * For this, the {@link PreferenceContribution} has to provide a valid JSON Schema specifying which preferences
@@ -202,34 +204,44 @@ export class PreferenceSchemaProvider extends PreferenceProvider {
         const defaultScope = PreferenceSchema.getDefaultScope(schema);
         const overridable = schema.overridable || false;
         for (const [preferenceName, rawSchemaProps] of Object.entries(schema.properties)) {
-            if (this.combinedSchema.properties[preferenceName]) {
+            if (this.combinedSchema.properties[preferenceName] && DefaultOverridesPreferenceSchemaId !== schema.id) {
                 console.error('Preference name collision detected in the schema for property: ' + preferenceName);
-            } else if (!rawSchemaProps.hasOwnProperty('included') || rawSchemaProps.included) {
-                const schemaProps = PreferenceDataProperty.fromPreferenceSchemaProperty(rawSchemaProps, defaultScope);
-                if (typeof schemaProps.overridable !== 'boolean' && overridable) {
-                    schemaProps.overridable = true;
-                }
-                if (schemaProps.overridable) {
-                    this.overridePatternProperties.properties[preferenceName] = schemaProps;
+            } else {
+                let schemaProps;
+                if (this.combinedSchema.properties[preferenceName] && DefaultOverridesPreferenceSchemaId === schema.id) {
+                    // update existing default value in schema
+                    schemaProps = PreferenceDataProperty.fromPreferenceSchemaProperty(rawSchemaProps, defaultScope);
+                    this.updateSchemaPropsDefault(preferenceName, schemaProps);
+                } else if (!rawSchemaProps.hasOwnProperty('included') || rawSchemaProps.included) {
+                    // add overrides for languages
+                    schemaProps = PreferenceDataProperty.fromPreferenceSchemaProperty(rawSchemaProps, defaultScope);
+                    if (typeof schemaProps.overridable !== 'boolean' && overridable) {
+                        schemaProps.overridable = true;
+                    }
+                    if (schemaProps.overridable) {
+                        this.overridePatternProperties.properties[preferenceName] = schemaProps;
+                    }
+                    this.updateSchemaProps(preferenceName, schemaProps);
                 }
-                this.updateSchemaProps(preferenceName, schemaProps);
-
-                const schemaDefault = this.getDefaultValue(schemaProps);
-                const configuredDefault = this.getConfiguredDefault(preferenceName);
-                if (this.preferenceOverrideService.testOverrideValue(preferenceName, schemaDefault)) {
-                    schemaProps.defaultValue = PreferenceSchemaProperties.is(configuredDefault)
-                        ? PreferenceProvider.merge(schemaDefault, configuredDefault)
-                        : schemaDefault;
-                    if (schemaProps.defaultValue && PreferenceSchemaProperties.is(schemaProps.defaultValue)) {
-                        for (const overriddenPreferenceName in schemaProps.defaultValue) {
-                            const overrideValue = schemaDefault[overriddenPreferenceName];
-                            const overridePreferenceName = `${preferenceName}.${overriddenPreferenceName}`;
-                            changes.push(this.doSetPreferenceValue(overridePreferenceName, overrideValue, { scope, domain }));
+
+                if (schemaProps !== undefined) {
+                    const schemaDefault = this.getDefaultValue(schemaProps);
+                    const configuredDefault = this.getConfiguredDefault(preferenceName);
+                    if (this.preferenceOverrideService.testOverrideValue(preferenceName, schemaDefault)) {
+                        schemaProps.defaultValue = PreferenceSchemaProperties.is(configuredDefault)
+                            ? PreferenceProvider.merge(schemaDefault, configuredDefault)
+                            : schemaDefault;
+                        if (schemaProps.defaultValue && PreferenceSchemaProperties.is(schemaProps.defaultValue)) {
+                            for (const overriddenPreferenceName in schemaProps.defaultValue) {
+                                const overrideValue = schemaDefault[overriddenPreferenceName];
+                                const overridePreferenceName = `${preferenceName}.${overriddenPreferenceName}`;
+                                changes.push(this.doSetPreferenceValue(overridePreferenceName, overrideValue, { scope, domain }));
+                            }
                         }
+                    } else {
+                        schemaProps.defaultValue = configuredDefault === undefined ? schemaDefault : configuredDefault;
+                        changes.push(this.doSetPreferenceValue(preferenceName, schemaProps.defaultValue, { scope, domain }));
                     }
-                } else {
-                    schemaProps.defaultValue = configuredDefault === undefined ? schemaDefault : configuredDefault;
-                    changes.push(this.doSetPreferenceValue(preferenceName, schemaProps.defaultValue, { scope, domain }));
                 }
             }
         }
@@ -383,6 +395,19 @@ export class PreferenceSchemaProvider extends PreferenceProvider {
         }
     }
 
+    protected updateSchemaPropsDefault(key: string, property: PreferenceDataProperty): void {
+        this.combinedSchema.properties[key].default = property.default;
+        this.combinedSchema.properties[key].defaultValue = property.defaultValue;
+        if (this.workspaceSchema.properties[key]) {
+            this.workspaceSchema.properties[key].default = property.default;
+            this.workspaceSchema.properties[key].defaultValue = property.defaultValue;
+        }
+        if (this.folderSchema.properties[key]) {
+            this.folderSchema.properties[key].default = property.default;
+            this.folderSchema.properties[key].defaultValue = property.defaultValue;
+        }
+    }
+
     protected removePropFromSchemas(key: string): void {
         // If we remove a key from combined, it should also be removed from all narrower scopes.
         delete this.combinedSchema.properties[key];

package/src/browser/preload/i18n-preload-contribution.ts

@@ -0,0 +1,50 @@
+// *****************************************************************************
+// Copyright (C) 2023 TypeFox 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 { PreloadContribution } from './preloader';
+import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
+import { nls } from '../../common/nls';
+import { inject, injectable } from 'inversify';
+import { LocalizationServer } from '../../common/i18n/localization-server';
+
+@injectable()
+export class I18nPreloadContribution implements PreloadContribution {
+
+    @inject(LocalizationServer)
+    protected readonly localizationServer: LocalizationServer;
+
+    async initialize(): Promise<void> {
+        const defaultLocale = FrontendApplicationConfigProvider.get().defaultLocale;
+        if (defaultLocale && !nls.locale) {
+            Object.assign(nls, {
+                locale: defaultLocale
+            });
+        }
+        if (nls.locale) {
+            const localization = await this.localizationServer.loadLocalization(nls.locale);
+            if (localization.languagePack) {
+                nls.localization = localization;
+            } else {
+                // In case the localization that we've loaded doesn't localize Theia completely (languagePack is false)
+                // We simply reset the locale to the default again
+                Object.assign(nls, {
+                    locale: defaultLocale || undefined
+                });
+            }
+        }
+    }
+
+}

package/src/browser/preload/os-preload-contribution.ts

@@ -0,0 +1,37 @@
+// *****************************************************************************
+// Copyright (C) 2023 TypeFox 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 { inject, injectable } from 'inversify';
+import { OS, OSBackendProvider } from '../../common';
+import { PreloadContribution } from './preloader';
+
+@injectable()
+export class OSPreloadContribution implements PreloadContribution {
+
+    @inject(OSBackendProvider)
+    protected readonly osBackendProvider: OSBackendProvider;
+
+    async initialize(): Promise<void> {
+        const osType = await this.osBackendProvider.getBackendOS();
+        const isWindows = osType === 'Windows';
+        const isOSX = osType === 'OSX';
+        OS.backend.isOSX = isOSX;
+        OS.backend.isWindows = isWindows;
+        OS.backend.type = () => osType;
+        OS.backend.EOL = isWindows ? '\r\n' : '\n';
+    }
+
+}

package/src/browser/preload/preload-module.ts

@@ -0,0 +1,45 @@
+// *****************************************************************************
+// Copyright (C) 2023 TypeFox 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 { ContainerModule } from 'inversify';
+import { PreloadContribution, Preloader } from './preloader';
+import { bindContributionProvider } from '../../common/contribution-provider';
+import { I18nPreloadContribution } from './i18n-preload-contribution';
+import { OSPreloadContribution } from './os-preload-contribution';
+import { ThemePreloadContribution } from './theme-preload-contribution';
+import { LocalizationServer, LocalizationServerPath } from '../../common/i18n/localization-server';
+import { WebSocketConnectionProvider } from '../messaging/ws-connection-provider';
+import { OSBackendProvider, OSBackendProviderPath } from '../../common/os';
+
+export default new ContainerModule(bind => {
+    bind(Preloader).toSelf().inSingletonScope();
+    bindContributionProvider(bind, PreloadContribution);
+
+    bind(LocalizationServer).toDynamicValue(ctx =>
+        WebSocketConnectionProvider.createProxy<LocalizationServer>(ctx.container, LocalizationServerPath)
+    ).inSingletonScope();
+
+    bind(OSBackendProvider).toDynamicValue(ctx =>
+        WebSocketConnectionProvider.createProxy<OSBackendProvider>(ctx.container, OSBackendProviderPath)
+    ).inSingletonScope();
+
+    bind(I18nPreloadContribution).toSelf().inSingletonScope();
+    bind(PreloadContribution).toService(I18nPreloadContribution);
+    bind(OSPreloadContribution).toSelf().inSingletonScope();
+    bind(PreloadContribution).toService(OSPreloadContribution);
+    bind(ThemePreloadContribution).toSelf().inSingletonScope();
+    bind(PreloadContribution).toService(ThemePreloadContribution);
+});

package/src/browser/preload/preloader.ts

@@ -0,0 +1,37 @@
+// *****************************************************************************
+// Copyright (C) 2023 TypeFox 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 { MaybePromise } from '../../common/types';
+import { inject, injectable, interfaces, named } from 'inversify';
+import { ContributionProvider } from '../../common/contribution-provider';
+
+export const PreloadContribution = Symbol('PreloadContribution') as symbol & interfaces.Abstract<PreloadContribution>;
+
+export interface PreloadContribution {
+    initialize(): MaybePromise<void>;
+}
+
+@injectable()
+export class Preloader {
+
+    @inject(ContributionProvider) @named(PreloadContribution)
+    protected readonly contributions: ContributionProvider<PreloadContribution>;
+
+    async initialize(): Promise<void> {
+        await Promise.allSettled(this.contributions.getContributions().map(contrib => contrib.initialize()));
+    }
+
+}

package/src/browser/preload/theme-preload-contribution.ts

@@ -0,0 +1,31 @@
+// *****************************************************************************
+// Copyright (C) 2023 TypeFox 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 { PreloadContribution } from './preloader';
+import { DEFAULT_BACKGROUND_COLOR_STORAGE_KEY } from '../frontend-application-config-provider';
+import { injectable } from 'inversify';
+import { DefaultTheme } from '@theia/application-package';
+
+@injectable()
+export class ThemePreloadContribution implements PreloadContribution {
+
+    initialize(): void {
+        const dark = window.matchMedia?.('(prefers-color-scheme: dark)').matches;
+        const value = window.localStorage.getItem(DEFAULT_BACKGROUND_COLOR_STORAGE_KEY) || DefaultTheme.defaultBackgroundColor(dark);
+        document.documentElement.style.setProperty('--theia-editor-background', value);
+    }
+
+}

package/src/browser/saveable.ts

@@ -16,13 +16,13 @@
 
 import { Widget } from '@phosphor/widgets';
 import { Message } from '@phosphor/messaging';
-import { Event } from '../common/event';
+import { Emitter, Event } from '../common/event';
 import { MaybePromise } from '../common/types';
 import { Key } from './keyboard/keys';
 import { AbstractDialog } from './dialogs';
 import { waitForClosed } from './widgets';
 import { nls } from '../common/nls';
-import { isObject } from '../common';
+import { Disposable, isObject } from '../common';
 
 export interface Saveable {
     readonly dirty: boolean;
@@ -50,6 +50,45 @@ export interface SaveableSource {
     readonly saveable: Saveable;
 }
 
+export class SaveableDelegate implements Saveable {
+    dirty = false;
+    protected readonly onDirtyChangedEmitter = new Emitter<void>();
+
+    get onDirtyChanged(): Event<void> {
+        return this.onDirtyChangedEmitter.event;
+    }
+    autoSave: 'off' | 'afterDelay' | 'onFocusChange' | 'onWindowChange' = 'off';
+
+    async save(options?: SaveOptions): Promise<void> {
+        await this.delegate?.save(options);
+    }
+
+    revert?(options?: Saveable.RevertOptions): Promise<void>;
+    createSnapshot?(): Saveable.Snapshot;
+    applySnapshot?(snapshot: object): void;
+
+    protected delegate?: Saveable;
+    protected toDispose?: Disposable;
+
+    set(delegate: Saveable): void {
+        this.toDispose?.dispose();
+        this.delegate = delegate;
+        this.toDispose = this.delegate.onDirtyChanged(() => {
+            this.dirty = delegate.dirty;
+            this.onDirtyChangedEmitter.fire();
+        });
+        this.autoSave = delegate.autoSave;
+        if (this.dirty !== delegate.dirty) {
+            this.dirty = delegate.dirty;
+            this.onDirtyChangedEmitter.fire();
+        }
+        this.revert = delegate.revert?.bind(delegate);
+        this.createSnapshot = delegate.createSnapshot?.bind(delegate);
+        this.applySnapshot = delegate.applySnapshot?.bind(delegate);
+    }
+
+}
+
 export namespace Saveable {
     export interface RevertOptions {
         /**

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

@@ -246,6 +246,9 @@ export class ApplicationShell extends Widget {
     protected readonly onDidChangeCurrentWidgetEmitter = new Emitter<FocusTracker.IChangedArgs<Widget>>();
     readonly onDidChangeCurrentWidget = this.onDidChangeCurrentWidgetEmitter.event;
 
+    protected readonly onDidDoubleClickMainAreaEmitter = new Emitter<void>();
+    readonly onDidDoubleClickMainArea = this.onDidDoubleClickMainAreaEmitter.event;
+
     @inject(TheiaDockPanel.Factory)
     protected readonly dockPanelFactory: TheiaDockPanel.Factory;
 
@@ -578,6 +581,14 @@ export class ApplicationShell extends Widget {
                 }
             }
         });
+
+        dockPanel.node.addEventListener('dblclick', event => {
+            const el = event.target as Element;
+            if (el.id === MAIN_AREA_ID || el.classList.contains('p-TabBar-content')) {
+                this.onDidDoubleClickMainAreaEmitter.fire();
+            }
+        });
+
         const handler = (e: DragEvent) => {
             if (e.dataTransfer) {
                 e.dataTransfer.dropEffect = 'link';

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

@@ -17,11 +17,11 @@
 import debounce = require('lodash.debounce');
 import { inject, injectable, named } from 'inversify';
 // eslint-disable-next-line max-len
-import { CommandMenuNode, CommandRegistry, CompoundMenuNode, ContributionProvider, Disposable, DisposableCollection, Emitter, Event, MenuModelRegistry, MenuPath } from '../../../common';
+import { CommandMenuNode, CommandRegistry, CompoundMenuNode, ContributionProvider, Disposable, DisposableCollection, Emitter, Event, MenuModelRegistry, MenuNode, MenuPath } from '../../../common';
 import { ContextKeyService } from '../../context-key-service';
 import { FrontendApplicationContribution } from '../../frontend-application';
 import { Widget } from '../../widgets';
-import { MenuDelegate, ReactTabBarToolbarItem, TabBarToolbarItem } from './tab-bar-toolbar-types';
+import { AnyToolbarItem, ConditionalToolbarItem, MenuDelegate, MenuToolbarItem, ReactTabBarToolbarItem, TabBarToolbarItem } from './tab-bar-toolbar-types';
 import { ToolbarMenuNodeWrapper } from './tab-bar-toolbar-menu-adapters';
 
 /**
@@ -103,10 +103,7 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
         }
         const result: Array<TabBarToolbarItem | ReactTabBarToolbarItem> = [];
         for (const item of this.items.values()) {
-            const visible = TabBarToolbarItem.is(item)
-                ? this.commandRegistry.isVisible(item.command, widget)
-                : (!item.isVisible || item.isVisible(widget));
-            if (visible && (!item.when || this.contextKeyService.match(item.when, widget.node))) {
+            if (this.isItemVisible(item, widget)) {
                 result.push(item);
             }
         }
@@ -139,6 +136,83 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
         return result;
     }
 
+    /**
+     * Query whether a toolbar `item` should be shown in the toolbar.
+     * This implementation delegates to item-specific checks according to their type.
+     *
+     * @param item a menu toolbar item
+     * @param widget the widget that is updating the toolbar
+     * @returns `false` if the `item` should be suppressed, otherwise `true`
+     */
+    protected isItemVisible(item: TabBarToolbarItem | ReactTabBarToolbarItem, widget: Widget): boolean {
+        if (TabBarToolbarItem.is(item) && item.command && !this.isTabBarToolbarItemVisible(item, widget)) {
+            return false;
+        }
+        if (MenuToolbarItem.is(item) && !this.isMenuToolbarItemVisible(item, widget)) {
+            return false;
+        }
+        if (AnyToolbarItem.isConditional(item) && !this.isConditionalItemVisible(item, widget)) {
+            return false;
+        }
+        // The item is not vetoed. Accept it
+        return true;
+    }
+
+    /**
+     * Query whether a conditional toolbar `item` should be shown in the toolbar.
+     * This implementation delegates to the `item`'s own intrinsic conditionality.
+     *
+     * @param item a menu toolbar item
+     * @param widget the widget that is updating the toolbar
+     * @returns `false` if the `item` should be suppressed, otherwise `true`
+     */
+    protected isConditionalItemVisible(item: ConditionalToolbarItem, widget: Widget): boolean {
+        if (item.isVisible && !item.isVisible(widget)) {
+            return false;
+        }
+        if (item.when && !this.contextKeyService.match(item.when, widget.node)) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Query whether a tab-bar toolbar `item` that has a command should be shown in the toolbar.
+     * This implementation returns `false` if the `item`'s command is not visible in the
+     * `widget` according to the command registry.
+     *
+     * @param item a tab-bar toolbar item that has a non-empty `command`
+     * @param widget the widget that is updating the toolbar
+     * @returns `false` if the `item` should be suppressed, otherwise `true`
+     */
+    protected isTabBarToolbarItemVisible(item: TabBarToolbarItem, widget: Widget): boolean {
+        return this.commandRegistry.isVisible(item.command, widget);
+    }
+
+    /**
+     * Query whether a menu toolbar `item` should be shown in the toolbar.
+     * This implementation returns `false` if the `item` does not have any actual menu to show.
+     *
+     * @param item a menu toolbar item
+     * @param widget the widget that is updating the toolbar
+     * @returns `false` if the `item` should be suppressed, otherwise `true`
+     */
+    protected isMenuToolbarItemVisible(item: MenuToolbarItem, widget: Widget): boolean {
+        const menu = this.menuRegistry.getMenu(item.menuPath);
+        const isVisible: (node: MenuNode) => boolean = node =>
+            node.children?.length
+                // Either the node is a sub-menu that has some visible child ...
+                ? node.children?.some(isVisible)
+                // ... or there is a command ...
+                : !!node.command
+                // ... that is visible ...
+                && this.commandRegistry.isVisible(node.command, widget)
+                // ... and a "when" clause does not suppress the menu node.
+                && (!node.when || this.contextKeyService.match(node.when, widget?.node));
+
+        return isVisible(menu);
+    }
+
     unregisterItem(itemOrId: TabBarToolbarItem | ReactTabBarToolbarItem | string): void {
         const id = typeof itemOrId === 'string' ? itemOrId : itemOrId.id;
         if (this.items.delete(id)) {
@@ -147,7 +221,7 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
     }
 
     registerMenuDelegate(menuPath: MenuPath, when?: string | ((widget: Widget) => boolean)): Disposable {
-        const id = menuPath.join(menuDelegateSeparator);
+        const id = this.toElementId(menuPath);
         if (!this.menuDelegates.has(id)) {
             const isVisible: MenuDelegate['isVisible'] = !when
                 ? yes
@@ -163,8 +237,20 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
     }
 
     unregisterMenuDelegate(menuPath: MenuPath): void {
-        if (this.menuDelegates.delete(menuPath.join(menuDelegateSeparator))) {
+        if (this.menuDelegates.delete(this.toElementId(menuPath))) {
             this.fireOnDidChange();
         }
     }
+
+    /**
+     * Generate a single ID string from a menu path that
+     * is likely to be unique amongst the items in the toolbar.
+     *
+     * @param menuPath a menubar path
+     * @returns a likely unique ID based on the path
+     */
+    toElementId(menuPath: MenuPath): string {
+        return menuPath.join(menuDelegateSeparator);
+    }
+
 }

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

@@ -83,7 +83,7 @@ export interface MenuToolbarItem {
     menuPath: MenuPath;
 }
 
-interface ConditionalToolbarItem {
+export interface ConditionalToolbarItem {
     /**
      * https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts
      */
@@ -130,6 +130,7 @@ export interface TabBarToolbarItem extends RegisteredToolbarItem,
     RenderedToolbarItem,
     Omit<ConditionalToolbarItem, 'isVisible'>,
     Pick<InlineToolbarItemMetadata, 'priority'>,
+    Partial<MenuToolbarItem>,
     Partial<MenuToolbarItemMetadata> { }
 
 /**
@@ -174,7 +175,33 @@ export namespace TabBarToolbarItem {
 }
 
 export namespace MenuToolbarItem {
+    /**
+     * Type guard for a toolbar item that actually is a menu item, amongst
+     * the other kinds of item that it may also be.
+     *
+     * @param item a toolbar item
+     * @returns whether the `item` is a menu item
+     */
+    export function is<T extends AnyToolbarItem>(item: T): item is T & MenuToolbarItem {
+        return Array.isArray(item.menuPath);
+    }
+
     export function getMenuPath(item: AnyToolbarItem): MenuPath | undefined {
         return Array.isArray(item.menuPath) ? item.menuPath : undefined;
     }
 }
+
+export namespace AnyToolbarItem {
+    /**
+     * Type guard for a toolbar item that actually manifests any of the
+     * features of a conditional toolbar item.
+     *
+     * @param item a toolbar item
+     * @returns whether the `item` is a conditional item
+     */
+    export function isConditional<T extends AnyToolbarItem>(item: T): item is T & ConditionalToolbarItem {
+        return 'isVisible' in item && typeof item.isVisible === 'function'
+            || 'onDidChange' in item && typeof item.onDidChange === 'function'
+            || 'when' in item && typeof item.when === 'string';
+    }
+}