@theia/core 1.48.1 → 1.48.2

package/lib/browser/shell/tab-bar-toolbar/tab-bar-toolbar-types.d.ts

@@ -1,137 +1,137 @@
-import * as React from 'react';
-import { Event, MenuPath } from '../../../common';
-import { Widget } from '../../widgets';
-/** Items whose group is exactly 'navigation' will be rendered inline. */
-export declare const NAVIGATION = "navigation";
-export declare const TAB_BAR_TOOLBAR_CONTEXT_MENU: string[];
-export interface TabBarDelegator extends Widget {
-    getTabBarDelegate(): Widget | undefined;
-}
-export declare namespace TabBarDelegator {
-    function is(candidate?: Widget): candidate is TabBarDelegator;
-}
-interface RegisteredToolbarItem {
-    /**
-     * The unique ID of the toolbar item.
-     */
-    id: string;
-}
-interface RenderedToolbarItem {
-    /**
-     * Optional icon for the item.
-     */
-    icon?: string | (() => string);
-    /**
-     * Optional text of the item.
-     *
-     * Strings in the format `$(iconIdentifier~animationType) will be treated as icon references.
-     * If the iconIdentifier begins with fa-, Font Awesome icons will be used; otherwise it will be treated as Codicon name.
-     *
-     * You can find Codicon classnames here: https://microsoft.github.io/vscode-codicons/dist/codicon.html
-     * You can find Font Awesome classnames here: http://fontawesome.io/icons/
-     * The type of animation can be either `spin` or `pulse`.
-     */
-    text?: string;
-    /**
-     * Optional tooltip for the item.
-     */
-    tooltip?: string;
-}
-interface SelfRenderingToolbarItem {
-    render(widget?: Widget): React.ReactNode;
-}
-interface ExecutableToolbarItem {
-    /**
-     * The command to execute when the item is selected.
-     */
-    command: string;
-}
-export interface MenuToolbarItem {
-    /**
-     * A menu path with which this item is associated.
-     * If accompanied by a command, this data will be passed to the {@link MenuCommandExecutor}.
-     * If no command is present, this menu will be opened.
-     */
-    menuPath: MenuPath;
-}
-export interface ConditionalToolbarItem {
-    /**
-     * https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts
-     */
-    when?: string;
-    /**
-     * Checked before the item is shown.
-     */
-    isVisible?(widget?: Widget): boolean;
-    /**
-     * When defined, the container tool-bar will be updated if this event is fired.
-     *
-     * Note: currently, each item of the container toolbar will be re-rendered if any of the items have changed.
-     */
-    onDidChange?: Event<void>;
-}
-interface InlineToolbarItemMetadata {
-    /**
-     * Priority among the items. Can be negative. The smaller the number the left-most the item will be placed in the toolbar. It is `0` by default.
-     */
-    priority?: number;
-    group: 'navigation' | undefined;
-}
-interface MenuToolbarItemMetadata {
-    /**
-     * Optional group for the item. Default `navigation`.
-     * `navigation` group will be inlined, while all the others will appear in the `...` dropdown.
-     * A group in format `submenu_group_1/submenu 1/.../submenu_group_n/ submenu n/item_group` means that the item will be located in a submenu(s) of the `...` dropdown.
-     * The submenu's title is named by the submenu section name, e.g. `group/<submenu name>/subgroup`.
-     */
-    group: string;
-    /**
-     * Optional ordering string for placing the item within its group
-     */
-    order?: string;
-}
-/**
- * Representation of an item in the tab
- */
-export interface TabBarToolbarItem extends RegisteredToolbarItem, ExecutableToolbarItem, RenderedToolbarItem, Omit<ConditionalToolbarItem, 'isVisible'>, Pick<InlineToolbarItemMetadata, 'priority'>, Partial<MenuToolbarItem>, Partial<MenuToolbarItemMetadata> {
-}
-/**
- * Tab-bar toolbar item backed by a `React.ReactNode`.
- * Unlike the `TabBarToolbarItem`, this item is not connected to the command service.
- */
-export interface ReactTabBarToolbarItem extends RegisteredToolbarItem, SelfRenderingToolbarItem, ConditionalToolbarItem, Pick<InlineToolbarItemMetadata, 'priority'>, Pick<Partial<MenuToolbarItemMetadata>, 'group'> {
-}
-export interface AnyToolbarItem extends RegisteredToolbarItem, Partial<ExecutableToolbarItem>, Partial<RenderedToolbarItem>, Partial<SelfRenderingToolbarItem>, Partial<ConditionalToolbarItem>, Partial<MenuToolbarItem>, Pick<InlineToolbarItemMetadata, 'priority'>, Partial<MenuToolbarItemMetadata> {
-}
-export interface MenuDelegate extends MenuToolbarItem, Required<Pick<ConditionalToolbarItem, 'isVisible'>> {
-}
-export declare namespace TabBarToolbarItem {
-    /**
-     * Compares the items by `priority` in ascending. Undefined priorities will be treated as `0`.
-     */
-    const PRIORITY_COMPARATOR: (left: TabBarToolbarItem, right: TabBarToolbarItem) => number;
-    function is(arg: unknown): arg is TabBarToolbarItem;
-}
-export declare 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
-     */
-    function is<T extends AnyToolbarItem>(item: T): item is T & MenuToolbarItem;
-    function getMenuPath(item: AnyToolbarItem): MenuPath | undefined;
-}
-export declare 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
-     */
-    function isConditional<T extends AnyToolbarItem>(item: T): item is T & ConditionalToolbarItem;
-}
-export {};
+import * as React from 'react';
+import { Event, MenuPath } from '../../../common';
+import { Widget } from '../../widgets';
+/** Items whose group is exactly 'navigation' will be rendered inline. */
+export declare const NAVIGATION = "navigation";
+export declare const TAB_BAR_TOOLBAR_CONTEXT_MENU: string[];
+export interface TabBarDelegator extends Widget {
+    getTabBarDelegate(): Widget | undefined;
+}
+export declare namespace TabBarDelegator {
+    function is(candidate?: Widget): candidate is TabBarDelegator;
+}
+interface RegisteredToolbarItem {
+    /**
+     * The unique ID of the toolbar item.
+     */
+    id: string;
+}
+interface RenderedToolbarItem {
+    /**
+     * Optional icon for the item.
+     */
+    icon?: string | (() => string);
+    /**
+     * Optional text of the item.
+     *
+     * Strings in the format `$(iconIdentifier~animationType) will be treated as icon references.
+     * If the iconIdentifier begins with fa-, Font Awesome icons will be used; otherwise it will be treated as Codicon name.
+     *
+     * You can find Codicon classnames here: https://microsoft.github.io/vscode-codicons/dist/codicon.html
+     * You can find Font Awesome classnames here: http://fontawesome.io/icons/
+     * The type of animation can be either `spin` or `pulse`.
+     */
+    text?: string;
+    /**
+     * Optional tooltip for the item.
+     */
+    tooltip?: string;
+}
+interface SelfRenderingToolbarItem {
+    render(widget?: Widget): React.ReactNode;
+}
+interface ExecutableToolbarItem {
+    /**
+     * The command to execute when the item is selected.
+     */
+    command: string;
+}
+export interface MenuToolbarItem {
+    /**
+     * A menu path with which this item is associated.
+     * If accompanied by a command, this data will be passed to the {@link MenuCommandExecutor}.
+     * If no command is present, this menu will be opened.
+     */
+    menuPath: MenuPath;
+}
+export interface ConditionalToolbarItem {
+    /**
+     * https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts
+     */
+    when?: string;
+    /**
+     * Checked before the item is shown.
+     */
+    isVisible?(widget?: Widget): boolean;
+    /**
+     * When defined, the container tool-bar will be updated if this event is fired.
+     *
+     * Note: currently, each item of the container toolbar will be re-rendered if any of the items have changed.
+     */
+    onDidChange?: Event<void>;
+}
+interface InlineToolbarItemMetadata {
+    /**
+     * Priority among the items. Can be negative. The smaller the number the left-most the item will be placed in the toolbar. It is `0` by default.
+     */
+    priority?: number;
+    group: 'navigation' | undefined;
+}
+interface MenuToolbarItemMetadata {
+    /**
+     * Optional group for the item. Default `navigation`.
+     * `navigation` group will be inlined, while all the others will appear in the `...` dropdown.
+     * A group in format `submenu_group_1/submenu 1/.../submenu_group_n/ submenu n/item_group` means that the item will be located in a submenu(s) of the `...` dropdown.
+     * The submenu's title is named by the submenu section name, e.g. `group/<submenu name>/subgroup`.
+     */
+    group: string;
+    /**
+     * Optional ordering string for placing the item within its group
+     */
+    order?: string;
+}
+/**
+ * Representation of an item in the tab
+ */
+export interface TabBarToolbarItem extends RegisteredToolbarItem, ExecutableToolbarItem, RenderedToolbarItem, Omit<ConditionalToolbarItem, 'isVisible'>, Pick<InlineToolbarItemMetadata, 'priority'>, Partial<MenuToolbarItem>, Partial<MenuToolbarItemMetadata> {
+}
+/**
+ * Tab-bar toolbar item backed by a `React.ReactNode`.
+ * Unlike the `TabBarToolbarItem`, this item is not connected to the command service.
+ */
+export interface ReactTabBarToolbarItem extends RegisteredToolbarItem, SelfRenderingToolbarItem, ConditionalToolbarItem, Pick<InlineToolbarItemMetadata, 'priority'>, Pick<Partial<MenuToolbarItemMetadata>, 'group'> {
+}
+export interface AnyToolbarItem extends RegisteredToolbarItem, Partial<ExecutableToolbarItem>, Partial<RenderedToolbarItem>, Partial<SelfRenderingToolbarItem>, Partial<ConditionalToolbarItem>, Partial<MenuToolbarItem>, Pick<InlineToolbarItemMetadata, 'priority'>, Partial<MenuToolbarItemMetadata> {
+}
+export interface MenuDelegate extends MenuToolbarItem, Required<Pick<ConditionalToolbarItem, 'isVisible'>> {
+}
+export declare namespace TabBarToolbarItem {
+    /**
+     * Compares the items by `priority` in ascending. Undefined priorities will be treated as `0`.
+     */
+    const PRIORITY_COMPARATOR: (left: TabBarToolbarItem, right: TabBarToolbarItem) => number;
+    function is(arg: unknown): arg is TabBarToolbarItem;
+}
+export declare 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
+     */
+    function is<T extends AnyToolbarItem>(item: T): item is T & MenuToolbarItem;
+    function getMenuPath(item: AnyToolbarItem): MenuPath | undefined;
+}
+export declare 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
+     */
+    function isConditional<T extends AnyToolbarItem>(item: T): item is T & ConditionalToolbarItem;
+}
+export {};
 //# sourceMappingURL=tab-bar-toolbar-types.d.ts.map

package/lib/browser/shell/tab-bar-toolbar/tab-bar-toolbar-types.js

@@ -1,89 +1,89 @@
-"use strict";
-// *****************************************************************************
-// Copyright (C) 2022 Ericsson 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
-// *****************************************************************************
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnyToolbarItem = exports.MenuToolbarItem = exports.TabBarToolbarItem = exports.TabBarDelegator = exports.TAB_BAR_TOOLBAR_CONTEXT_MENU = exports.NAVIGATION = void 0;
-const common_1 = require("../../../common");
-/** Items whose group is exactly 'navigation' will be rendered inline. */
-exports.NAVIGATION = 'navigation';
-exports.TAB_BAR_TOOLBAR_CONTEXT_MENU = ['TAB_BAR_TOOLBAR_CONTEXT_MENU'];
-var TabBarDelegator;
-(function (TabBarDelegator) {
-    function is(candidate) {
-        return (0, common_1.isObject)(candidate) && (0, common_1.isFunction)(candidate.getTabBarDelegate);
-    }
-    TabBarDelegator.is = is;
-})(TabBarDelegator = exports.TabBarDelegator || (exports.TabBarDelegator = {}));
-var TabBarToolbarItem;
-(function (TabBarToolbarItem) {
-    /**
-     * Compares the items by `priority` in ascending. Undefined priorities will be treated as `0`.
-     */
-    TabBarToolbarItem.PRIORITY_COMPARATOR = (left, right) => {
-        var _a, _b;
-        const leftGroup = (_a = left.group) !== null && _a !== void 0 ? _a : exports.NAVIGATION;
-        const rightGroup = (_b = right.group) !== null && _b !== void 0 ? _b : exports.NAVIGATION;
-        if (leftGroup === exports.NAVIGATION && rightGroup !== exports.NAVIGATION) {
-            return common_1.ArrayUtils.Sort.LeftBeforeRight;
-        }
-        if (rightGroup === exports.NAVIGATION && leftGroup !== exports.NAVIGATION) {
-            return common_1.ArrayUtils.Sort.RightBeforeLeft;
-        }
-        if (leftGroup !== rightGroup) {
-            return leftGroup.localeCompare(rightGroup);
-        }
-        return (left.priority || 0) - (right.priority || 0);
-    };
-    function is(arg) {
-        return (0, common_1.isObject)(arg) && (0, common_1.isString)(arg.command);
-    }
-    TabBarToolbarItem.is = is;
-})(TabBarToolbarItem = exports.TabBarToolbarItem || (exports.TabBarToolbarItem = {}));
-var MenuToolbarItem;
-(function (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
-     */
-    function is(item) {
-        return Array.isArray(item.menuPath);
-    }
-    MenuToolbarItem.is = is;
-    function getMenuPath(item) {
-        return Array.isArray(item.menuPath) ? item.menuPath : undefined;
-    }
-    MenuToolbarItem.getMenuPath = getMenuPath;
-})(MenuToolbarItem = exports.MenuToolbarItem || (exports.MenuToolbarItem = {}));
-var AnyToolbarItem;
-(function (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
-     */
-    function isConditional(item) {
-        return 'isVisible' in item && typeof item.isVisible === 'function'
-            || 'onDidChange' in item && typeof item.onDidChange === 'function'
-            || 'when' in item && typeof item.when === 'string';
-    }
-    AnyToolbarItem.isConditional = isConditional;
-})(AnyToolbarItem = exports.AnyToolbarItem || (exports.AnyToolbarItem = {}));
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyToolbarItem = exports.MenuToolbarItem = exports.TabBarToolbarItem = exports.TabBarDelegator = exports.TAB_BAR_TOOLBAR_CONTEXT_MENU = exports.NAVIGATION = void 0;
+const common_1 = require("../../../common");
+/** Items whose group is exactly 'navigation' will be rendered inline. */
+exports.NAVIGATION = 'navigation';
+exports.TAB_BAR_TOOLBAR_CONTEXT_MENU = ['TAB_BAR_TOOLBAR_CONTEXT_MENU'];
+var TabBarDelegator;
+(function (TabBarDelegator) {
+    function is(candidate) {
+        return (0, common_1.isObject)(candidate) && (0, common_1.isFunction)(candidate.getTabBarDelegate);
+    }
+    TabBarDelegator.is = is;
+})(TabBarDelegator = exports.TabBarDelegator || (exports.TabBarDelegator = {}));
+var TabBarToolbarItem;
+(function (TabBarToolbarItem) {
+    /**
+     * Compares the items by `priority` in ascending. Undefined priorities will be treated as `0`.
+     */
+    TabBarToolbarItem.PRIORITY_COMPARATOR = (left, right) => {
+        var _a, _b;
+        const leftGroup = (_a = left.group) !== null && _a !== void 0 ? _a : exports.NAVIGATION;
+        const rightGroup = (_b = right.group) !== null && _b !== void 0 ? _b : exports.NAVIGATION;
+        if (leftGroup === exports.NAVIGATION && rightGroup !== exports.NAVIGATION) {
+            return common_1.ArrayUtils.Sort.LeftBeforeRight;
+        }
+        if (rightGroup === exports.NAVIGATION && leftGroup !== exports.NAVIGATION) {
+            return common_1.ArrayUtils.Sort.RightBeforeLeft;
+        }
+        if (leftGroup !== rightGroup) {
+            return leftGroup.localeCompare(rightGroup);
+        }
+        return (left.priority || 0) - (right.priority || 0);
+    };
+    function is(arg) {
+        return (0, common_1.isObject)(arg) && (0, common_1.isString)(arg.command);
+    }
+    TabBarToolbarItem.is = is;
+})(TabBarToolbarItem = exports.TabBarToolbarItem || (exports.TabBarToolbarItem = {}));
+var MenuToolbarItem;
+(function (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
+     */
+    function is(item) {
+        return Array.isArray(item.menuPath);
+    }
+    MenuToolbarItem.is = is;
+    function getMenuPath(item) {
+        return Array.isArray(item.menuPath) ? item.menuPath : undefined;
+    }
+    MenuToolbarItem.getMenuPath = getMenuPath;
+})(MenuToolbarItem = exports.MenuToolbarItem || (exports.MenuToolbarItem = {}));
+var AnyToolbarItem;
+(function (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
+     */
+    function isConditional(item) {
+        return 'isVisible' in item && typeof item.isVisible === 'function'
+            || 'onDidChange' in item && typeof item.onDidChange === 'function'
+            || 'when' in item && typeof item.when === 'string';
+    }
+    AnyToolbarItem.isConditional = isConditional;
+})(AnyToolbarItem = exports.AnyToolbarItem || (exports.AnyToolbarItem = {}));
 //# sourceMappingURL=tab-bar-toolbar-types.js.map

package/lib/browser/shell/tab-bar-toolbar/tab-bar-toolbar.d.ts

@@ -1,90 +1,90 @@
-import * as React from 'react';
-import { ContextKeyService } from '../../context-key-service';
-import { CommandRegistry, Disposable, DisposableCollection, MenuCommandExecutor, MenuModelRegistry, MenuPath } from '../../../common';
-import { Anchor, ContextMenuAccess, ContextMenuRenderer } from '../../context-menu-renderer';
-import { LabelParser } from '../../label-parser';
-import { ReactWidget, Widget } from '../../widgets';
-import { TabBarToolbarRegistry } from './tab-bar-toolbar-registry';
-import { AnyToolbarItem, ReactTabBarToolbarItem, TabBarToolbarItem, MenuToolbarItem } from './tab-bar-toolbar-types';
-import { KeybindingRegistry } from '../..//keybinding';
-/**
- * Factory for instantiating tab-bar toolbars.
- */
-export declare const TabBarToolbarFactory: unique symbol;
-export interface TabBarToolbarFactory {
-    (): TabBarToolbar;
-}
-/**
- * Tab-bar toolbar widget representing the active [tab-bar toolbar items](TabBarToolbarItem).
- */
-export declare class TabBarToolbar extends ReactWidget {
-    protected current: Widget | undefined;
-    protected inline: Map<string, TabBarToolbarItem | ReactTabBarToolbarItem>;
-    protected more: Map<string, TabBarToolbarItem>;
-    protected contextKeyListener: Disposable | undefined;
-    protected toDisposeOnUpdateItems: DisposableCollection;
-    protected keybindingContextKeys: Set<string>;
-    protected readonly commands: CommandRegistry;
-    protected readonly labelParser: LabelParser;
-    protected readonly menus: MenuModelRegistry;
-    protected readonly menuCommandExecutor: MenuCommandExecutor;
-    protected readonly contextMenuRenderer: ContextMenuRenderer;
-    protected readonly toolbarRegistry: TabBarToolbarRegistry;
-    protected readonly contextKeyService: ContextKeyService;
-    protected readonly keybindings: KeybindingRegistry;
-    constructor();
-    protected init(): void;
-    updateItems(items: Array<TabBarToolbarItem | ReactTabBarToolbarItem>, current: Widget | undefined): void;
-    updateTarget(current?: Widget): void;
-    protected readonly toDisposeOnSetCurrent: DisposableCollection;
-    protected setCurrent(current: Widget | undefined): void;
-    protected updateContextKeyListener(contextKeys: Set<string>): void;
-    protected render(): React.ReactNode;
-    protected resolveKeybindingForCommand(command: string | undefined): string;
-    protected renderItem(item: AnyToolbarItem): React.ReactNode;
-    protected isEnabled(item: AnyToolbarItem): boolean;
-    protected getToolbarItemClassNames(item: AnyToolbarItem): string[];
-    protected renderMore(): React.ReactNode;
-    protected showMoreContextMenu: (event: React.MouseEvent) => void;
-    protected toAnchor(event: React.MouseEvent): Anchor;
-    renderMoreContextMenu(anchor: Anchor, subpath?: MenuPath): ContextMenuAccess;
-    /**
-     * Renders a toolbar item that is a menu, presenting it as a button with a little
-     * chevron decoration that pops up a floating menu when clicked.
-     *
-     * @param item a toolbar item that is a menu item
-     * @returns the rendered toolbar item
-     */
-    protected renderMenuItem(item: TabBarToolbarItem & MenuToolbarItem): React.ReactNode;
-    /**
-     * Presents the menu to popup on the `event` that is the clicking of
-     * a menu toolbar item.
-     *
-     * @param menuPath the path of the registered menu to show
-     * @param event the mouse event triggering the menu
-     */
-    protected showPopupMenu: (menuPath: MenuPath, event: React.MouseEvent) => void;
-    /**
-     * Renders the menu popped up on a menu toolbar item.
-     *
-     * @param menuPath the path of the registered menu to render
-     * @param anchor a description of where to render the menu
-     * @returns platform-specific access to the rendered context menu
-     */
-    protected renderPopupMenu(menuPath: MenuPath, anchor: Anchor): ContextMenuAccess;
-    shouldHandleMouseEvent(event: MouseEvent): boolean;
-    protected commandIsEnabled(command: string): boolean;
-    protected commandIsToggled(command: string): boolean;
-    protected evaluateWhenClause(whenClause: string | undefined): boolean;
-    protected executeCommand: (e: React.MouseEvent<HTMLElement>) => void;
-    protected maybeUpdate(): void;
-    protected onMouseDownEvent: (e: React.MouseEvent<HTMLElement>) => void;
-    protected onMouseUpEvent: (e: React.MouseEvent<HTMLElement>) => void;
-}
-export declare namespace TabBarToolbar {
-    namespace Styles {
-        const TAB_BAR_TOOLBAR = "p-TabBar-toolbar";
-        const TAB_BAR_TOOLBAR_ITEM = "item";
-    }
-}
+import * as React from 'react';
+import { ContextKeyService } from '../../context-key-service';
+import { CommandRegistry, Disposable, DisposableCollection, MenuCommandExecutor, MenuModelRegistry, MenuPath } from '../../../common';
+import { Anchor, ContextMenuAccess, ContextMenuRenderer } from '../../context-menu-renderer';
+import { LabelParser } from '../../label-parser';
+import { ReactWidget, Widget } from '../../widgets';
+import { TabBarToolbarRegistry } from './tab-bar-toolbar-registry';
+import { AnyToolbarItem, ReactTabBarToolbarItem, TabBarToolbarItem, MenuToolbarItem } from './tab-bar-toolbar-types';
+import { KeybindingRegistry } from '../..//keybinding';
+/**
+ * Factory for instantiating tab-bar toolbars.
+ */
+export declare const TabBarToolbarFactory: unique symbol;
+export interface TabBarToolbarFactory {
+    (): TabBarToolbar;
+}
+/**
+ * Tab-bar toolbar widget representing the active [tab-bar toolbar items](TabBarToolbarItem).
+ */
+export declare class TabBarToolbar extends ReactWidget {
+    protected current: Widget | undefined;
+    protected inline: Map<string, TabBarToolbarItem | ReactTabBarToolbarItem>;
+    protected more: Map<string, TabBarToolbarItem>;
+    protected contextKeyListener: Disposable | undefined;
+    protected toDisposeOnUpdateItems: DisposableCollection;
+    protected keybindingContextKeys: Set<string>;
+    protected readonly commands: CommandRegistry;
+    protected readonly labelParser: LabelParser;
+    protected readonly menus: MenuModelRegistry;
+    protected readonly menuCommandExecutor: MenuCommandExecutor;
+    protected readonly contextMenuRenderer: ContextMenuRenderer;
+    protected readonly toolbarRegistry: TabBarToolbarRegistry;
+    protected readonly contextKeyService: ContextKeyService;
+    protected readonly keybindings: KeybindingRegistry;
+    constructor();
+    protected init(): void;
+    updateItems(items: Array<TabBarToolbarItem | ReactTabBarToolbarItem>, current: Widget | undefined): void;
+    updateTarget(current?: Widget): void;
+    protected readonly toDisposeOnSetCurrent: DisposableCollection;
+    protected setCurrent(current: Widget | undefined): void;
+    protected updateContextKeyListener(contextKeys: Set<string>): void;
+    protected render(): React.ReactNode;
+    protected resolveKeybindingForCommand(command: string | undefined): string;
+    protected renderItem(item: AnyToolbarItem): React.ReactNode;
+    protected isEnabled(item: AnyToolbarItem): boolean;
+    protected getToolbarItemClassNames(item: AnyToolbarItem): string[];
+    protected renderMore(): React.ReactNode;
+    protected showMoreContextMenu: (event: React.MouseEvent) => void;
+    protected toAnchor(event: React.MouseEvent): Anchor;
+    renderMoreContextMenu(anchor: Anchor, subpath?: MenuPath): ContextMenuAccess;
+    /**
+     * Renders a toolbar item that is a menu, presenting it as a button with a little
+     * chevron decoration that pops up a floating menu when clicked.
+     *
+     * @param item a toolbar item that is a menu item
+     * @returns the rendered toolbar item
+     */
+    protected renderMenuItem(item: TabBarToolbarItem & MenuToolbarItem): React.ReactNode;
+    /**
+     * Presents the menu to popup on the `event` that is the clicking of
+     * a menu toolbar item.
+     *
+     * @param menuPath the path of the registered menu to show
+     * @param event the mouse event triggering the menu
+     */
+    protected showPopupMenu: (menuPath: MenuPath, event: React.MouseEvent) => void;
+    /**
+     * Renders the menu popped up on a menu toolbar item.
+     *
+     * @param menuPath the path of the registered menu to render
+     * @param anchor a description of where to render the menu
+     * @returns platform-specific access to the rendered context menu
+     */
+    protected renderPopupMenu(menuPath: MenuPath, anchor: Anchor): ContextMenuAccess;
+    shouldHandleMouseEvent(event: MouseEvent): boolean;
+    protected commandIsEnabled(command: string): boolean;
+    protected commandIsToggled(command: string): boolean;
+    protected evaluateWhenClause(whenClause: string | undefined): boolean;
+    protected executeCommand: (e: React.MouseEvent<HTMLElement>) => void;
+    protected maybeUpdate(): void;
+    protected onMouseDownEvent: (e: React.MouseEvent<HTMLElement>) => void;
+    protected onMouseUpEvent: (e: React.MouseEvent<HTMLElement>) => void;
+}
+export declare namespace TabBarToolbar {
+    namespace Styles {
+        const TAB_BAR_TOOLBAR = "p-TabBar-toolbar";
+        const TAB_BAR_TOOLBAR_ITEM = "item";
+    }
+}
 //# sourceMappingURL=tab-bar-toolbar.d.ts.map