@codingame/monaco-vscode-api 26.2.2 → 28.0.0

package/vscode/src/vs/platform/actionWidget/browser/actionWidget.css

@@ -5,18 +5,17 @@
 
 .action-widget {
 	font-size: 13px;
-	border-radius: 0;
 	min-width: 100px;
 	max-width: 80vw;
 	z-index: 40;
 	display: block;
 	width: 100%;
 	border: 1px solid var(--vscode-editorHoverWidget-border) !important;
-	border-radius: 5px;
+	border-radius: var(--vscode-cornerRadius-large);
 	background-color: var(--vscode-menu-background);
 	color: var(--vscode-menu-foreground);
 	padding: 4px;
-	box-shadow: 0 2px 8px var(--vscode-widget-shadow);
+	box-shadow: var(--vscode-shadow-lg);
 }
 
 .context-view-block {
@@ -56,25 +55,25 @@
 
 /** Styles for each row in the list element **/
 .action-widget .monaco-list .monaco-list-row {
-	padding: 0 4px 0 4px;
+	padding: 0 4px 0 8px;
 	white-space: nowrap;
 	cursor: pointer;
 	touch-action: none;
 	width: 100%;
-	border-radius: 3px;
+	border-radius: var(--vscode-cornerRadius-medium);
 }
 
 .action-widget .monaco-list .monaco-list-row.action.focused:not(.option-disabled) {
-	background-color: var(--vscode-list-activeSelectionBackground) !important;
-	color: var(--vscode-list-activeSelectionForeground);
+	background-color: var(--vscode-list-hoverBackground) !important;
+	color: var(--vscode-list-hoverForeground);
 	outline: 1px solid var(--vscode-menu-selectionBorder, transparent);
 	outline-offset: -1px;
 }
 
 .action-widget .monaco-list-row.group-header {
 	color: var(--vscode-descriptionForeground) !important;
-	font-weight: 600;
-	font-size: 13px;
+	font-weight: 500;
+	font-size: 11px;
 }
 
 .action-widget .monaco-list-row.group-header:not(:first-of-type) {
@@ -120,10 +119,18 @@
 
 .action-widget .monaco-list-row.action {
 	display: flex;
-	gap: 4px;
+	gap: 8px;
 	align-items: center;
 }
 
+.action-widget .monaco-list-row.action .codicon {
+	font-size: 12px;
+}
+
+.action-widget .monaco-list-row.action .action-list-item-toolbar .codicon {
+	font-size: 16px;
+}
+
 .action-widget .monaco-list-row.action.option-disabled,
 .action-widget .monaco-list:focus .monaco-list-row.focused.action.option-disabled,
 .action-widget .monaco-list-row.action.option-disabled .codicon,
@@ -142,6 +149,16 @@
 	text-overflow: ellipsis;
 }
 
+.action-widget .monaco-list-row.action .action-item-badge {
+	padding: 0px 6px;
+	border-radius: 10px;
+	background-color: var(--vscode-badge-background);
+	color: var(--vscode-badge-foreground);
+	font-size: 11px;
+	line-height: 18px;
+	flex-shrink: 0;
+}
+
 .action-widget .monaco-list-row.action .monaco-keybinding > .monaco-keybinding-key {
 		background-color: var(--vscode-keybindingLabel-background);
 		color: var(--vscode-keybindingLabel-foreground);
@@ -168,13 +185,13 @@
 }
 
 .action-widget .action-widget-action-bar .actions-container {
-	padding: 4px 8px 2px 24px;
+	padding: 2px 8px 0px 26px;
 	width: auto;
 }
 
 .action-widget-action-bar .action-label {
 	color: var(--vscode-textLink-activeForeground);
-	font-size: 13px;
+	font-size: 12px;
 	line-height: 22px;
 	padding: 0;
 	pointer-events: all;
@@ -195,8 +212,34 @@
 }
 
 .action-widget .monaco-list .monaco-list-row .description {
-	opacity: 0.7;
+	color: var(--vscode-descriptionForeground);
 	margin-left: 0.5em;
+	font-size: 12px;
+}
+
+/* Description below mode — shows descriptions as subtext under the title */
+.action-widget .description-below .monaco-list .monaco-list-row.action {
+	flex-wrap: wrap;
+	align-content: center;
+	padding-top: 6px;
+	padding-right: 2px;
+
+	.title {
+		line-height: 14px;
+	}
+
+	.description {
+		display: block !important;
+		width: 100%;
+		margin-left: 0;
+		padding-left: 20px;
+		font-size: 11px;
+		line-height: 14px;
+		opacity: 0.8;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
 }
 
 /* Item toolbar - shows on hover/focus */
@@ -210,7 +253,7 @@
 }
 
 .action-widget .monaco-list-row .action-list-item-toolbar .monaco-action-bar:not(.vertical) .action-label:not(.disabled):hover{
-	background-color: var(--vscode-list-activeSelectionBackground);
+	background-color: var(--vscode-toolbar-hoverBackground);
 }
 
 .action-widget-delegate-label {
@@ -219,3 +262,35 @@
 	gap: 4px;
 	font-size: 12px;
 }
+
+/* Filter input */
+.action-widget .action-list-filter {
+	padding: 2px 2px 4px 2px
+}
+
+.action-widget .action-list-filter:first-child {
+	border-bottom: 1px solid var(--vscode-editorHoverWidget-border);
+}
+
+.action-widget .action-list-filter:last-child {
+	border-top: 1px solid var(--vscode-editorHoverWidget-border);
+}
+
+.action-widget .action-list-filter-input {
+	width: 100%;
+	box-sizing: border-box;
+	padding: 4px 8px;
+	border: 1px solid var(--vscode-input-border, transparent);
+	border-radius: 3px;
+	background-color: var(--vscode-input-background);
+	color: var(--vscode-input-foreground);
+	outline: none;
+}
+
+.action-widget .action-list-filter-input:focus {
+	border-color: var(--vscode-focusBorder);
+}
+
+.action-widget .action-list-filter-input::placeholder {
+	color: var(--vscode-input-placeholderForeground);
+}

package/vscode/src/vs/platform/actionWidget/browser/actionWidget.d.ts

@@ -1,7 +1,7 @@
 import { IAnchor } from "../../../base/browser/ui/contextview/contextview.js";
 import { IAction } from "../../../base/common/actions.js";
 import { Disposable } from "../../../base/common/lifecycle.js";
-import { IActionListDelegate, IActionListItem } from "./actionList.js";
+import { IActionListDelegate, IActionListItem, IActionListOptions } from "./actionList.js";
 import { IContextKeyService } from "../../contextkey/common/contextkey.service.js";
 import { IContextViewService } from "../../contextview/browser/contextView.service.js";
 import { IInstantiationService } from "../../instantiation/common/instantiation.js";
@@ -16,10 +16,14 @@ export declare class ActionWidgetService extends Disposable implements IActionWi
     get isVisible(): boolean;
     private readonly _list;
     constructor(_contextViewService: IContextViewService, _contextKeyService: IContextKeyService, _instantiationService: IInstantiationService);
-    show<T>(user: string, supportsPreview: boolean, items: readonly IActionListItem<T>[], delegate: IActionListDelegate<T>, anchor: HTMLElement | StandardMouseEvent | IAnchor, container: HTMLElement | undefined, actionBarActions?: readonly IAction[], accessibilityProvider?: Partial<IListAccessibilityProvider<IActionListItem<T>>>): void;
+    show<T>(user: string, supportsPreview: boolean, items: readonly IActionListItem<T>[], delegate: IActionListDelegate<T>, anchor: HTMLElement | StandardMouseEvent | IAnchor, container: HTMLElement | undefined, actionBarActions?: readonly IAction[], accessibilityProvider?: Partial<IListAccessibilityProvider<IActionListItem<T>>>, listOptions?: IActionListOptions): void;
     acceptSelected(preview?: boolean): void;
     focusPrevious(): void;
     focusNext(): void;
+    collapseSection(): void;
+    expandSection(): void;
+    toggleSection(): boolean;
+    clearFilter(): boolean;
     hide(didCancel?: boolean): void;
     clear(): void;
     private _renderWidget;

package/vscode/src/vs/platform/actionWidget/browser/actionWidget.js

@@ -9,7 +9,7 @@ import * as actionWidget from './actionWidget.css';
 import { localize, localize2 } from '../../../nls.js';
 import { ActionList, acceptSelectedActionCommand, previewSelectedActionCommand } from './actionList.js';
 import { registerAction2, Action2 } from '../../actions/common/actions.js';
-import { RawContextKey } from '../../contextkey/common/contextkey.js';
+import { RawContextKey, ContextKeyExpr } from '../../contextkey/common/contextkey.js';
 import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
 import { IContextViewService } from '../../contextview/browser/contextView.service.js';
 import '../../instantiation/common/extensions.js';
@@ -29,9 +29,10 @@ import '../../theme/common/colors/searchColors.js';
 import { IActionWidgetService } from './actionWidget.service.js';
 
 registerCss(actionWidget);
-registerColor("actionBar.toggledBackground", inputActiveOptionBackground, ( localize(1751, "Background color for toggled action items in action bar.")));
+registerColor("actionBar.toggledBackground", inputActiveOptionBackground, ( localize(1780, "Background color for toggled action items in action bar.")));
 const ActionWidgetContextKeys = {
-    Visible: ( new RawContextKey("codeActionMenuVisible", false, ( localize(1752, "Whether the action widget list is visible"))))
+    Visible: ( new RawContextKey("codeActionMenuVisible", false, ( localize(1781, "Whether the action widget list is visible")))),
+    FilterFocused: ( new RawContextKey("codeActionMenuFilterFocused", false, ( localize(1782, "Whether the action widget filter input is focused"))))
 };
 let ActionWidgetService = class ActionWidgetService extends Disposable {
     get isVisible() {
@@ -52,10 +53,20 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
         anchor,
         container,
         actionBarActions,
-        accessibilityProvider
+        accessibilityProvider,
+        listOptions
     ) {
         const visibleContext = ActionWidgetContextKeys.Visible.bindTo(this._contextKeyService);
-        const list = this._instantiationService.createInstance(ActionList, user, supportsPreview, items, delegate, accessibilityProvider);
+        const list = this._instantiationService.createInstance(
+            ActionList,
+            user,
+            supportsPreview,
+            items,
+            delegate,
+            accessibilityProvider,
+            listOptions,
+            anchor
+        );
         this._contextViewService.showContextView({
             getAnchor: () => anchor,
             render: container => {
@@ -65,6 +76,9 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
             onHide: didCancel => {
                 visibleContext.reset();
                 this._onWidgetClosed(didCancel);
+            },
+            get anchorPosition() {
+                return list.anchorPosition;
             }
         }, container, false);
     }
@@ -77,6 +91,18 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
     focusNext() {
         this._list?.value?.focusNext();
     }
+    collapseSection() {
+        this._list?.value?.collapseFocusedSection();
+    }
+    expandSection() {
+        this._list?.value?.expandFocusedSection();
+    }
+    toggleSection() {
+        return this._list?.value?.toggleFocusedSection() ?? false;
+    }
+    clearFilter() {
+        return this._list?.value?.clearFilter() ?? false;
+    }
     hide(didCancel) {
         this._list.value?.hide(didCancel);
         this._list.clear();
@@ -90,6 +116,9 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
         element.appendChild(widget);
         this._list.value = list;
         if (this._list.value) {
+            if (this._list.value.filterContainer) {
+                widget.appendChild(this._list.value.filterContainer);
+            }
             widget.appendChild(this._list.value.domNode);
         } else {
             throw ( new Error("List has no value"));
@@ -121,6 +150,20 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
         }
         const width = this._list.value?.layout(actionBarWidth);
         widget.style.width = `${width}px`;
+        this._list.value?.focus();
+        const filterFocusedContext = ActionWidgetContextKeys.FilterFocused.bindTo(this._contextKeyService);
+        renderDisposables.add({
+            dispose: () => filterFocusedContext.reset()
+        });
+        if (this._list.value?.filterInput) {
+            const filterInput = this._list.value.filterInput;
+            renderDisposables.add(
+                addDisposableListener(filterInput, "focus", () => filterFocusedContext.set(true))
+            );
+            renderDisposables.add(
+                addDisposableListener(filterInput, "blur", () => filterFocusedContext.set(false))
+            );
+        }
         const focusTracker = renderDisposables.add(trackFocus(element));
         renderDisposables.add(focusTracker.onDidBlur(() => {
             const activeElement = getActiveElement();
@@ -153,7 +196,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "hideCodeActionWidget",
-            title: ( localize2(1753, "Hide action widget")),
+            title: ( localize2(1783, "Hide action widget")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -166,11 +209,32 @@ registerAction2(class extends Action2 {
         accessor.get(IActionWidgetService).hide(true);
     }
 });
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "clearFilterCodeActionWidget",
+            title: ( localize2(1784, "Clear action widget filter")),
+            precondition: ( ContextKeyExpr.and(ActionWidgetContextKeys.Visible, ActionWidgetContextKeys.FilterFocused)),
+            keybinding: {
+                weight: weight + 1,
+                primary: KeyCode.Escape
+            }
+        });
+    }
+    run(accessor) {
+        const widgetService = accessor.get(IActionWidgetService);
+        if (widgetService instanceof ActionWidgetService) {
+            if (!widgetService.clearFilter()) {
+                widgetService.hide(true);
+            }
+        }
+    }
+});
 registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "selectPrevCodeAction",
-            title: ( localize2(1754, "Select previous action")),
+            title: ( localize2(1785, "Select previous action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -194,7 +258,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "selectNextCodeAction",
-            title: ( localize2(1755, "Select next action")),
+            title: ( localize2(1786, "Select next action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -214,11 +278,70 @@ registerAction2(class extends Action2 {
         }
     }
 });
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "collapseSectionCodeAction",
+            title: ( localize2(1787, "Collapse section")),
+            precondition: ( ContextKeyExpr.and(ActionWidgetContextKeys.Visible, ( ActionWidgetContextKeys.FilterFocused.negate()))),
+            keybinding: {
+                weight,
+                primary: KeyCode.LeftArrow
+            }
+        });
+    }
+    run(accessor) {
+        const widgetService = accessor.get(IActionWidgetService);
+        if (widgetService instanceof ActionWidgetService) {
+            widgetService.collapseSection();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "expandSectionCodeAction",
+            title: ( localize2(1788, "Expand section")),
+            precondition: ( ContextKeyExpr.and(ActionWidgetContextKeys.Visible, ( ActionWidgetContextKeys.FilterFocused.negate()))),
+            keybinding: {
+                weight,
+                primary: KeyCode.RightArrow
+            }
+        });
+    }
+    run(accessor) {
+        const widgetService = accessor.get(IActionWidgetService);
+        if (widgetService instanceof ActionWidgetService) {
+            widgetService.expandSection();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "toggleSectionCodeAction",
+            title: ( localize2(1789, "Toggle section")),
+            precondition: ( ContextKeyExpr.and(ActionWidgetContextKeys.Visible, ( ActionWidgetContextKeys.FilterFocused.negate()))),
+            keybinding: {
+                weight,
+                primary: KeyCode.Space
+            }
+        });
+    }
+    run(accessor) {
+        const widgetService = accessor.get(IActionWidgetService);
+        if (widgetService instanceof ActionWidgetService) {
+            if (!widgetService.toggleSection()) {
+                widgetService.acceptSelected();
+            }
+        }
+    }
+});
 registerAction2(class extends Action2 {
     constructor() {
         super({
             id: acceptSelectedActionCommand,
-            title: ( localize2(1756, "Accept selected action")),
+            title: ( localize2(1790, "Accept selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -238,7 +361,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: previewSelectedActionCommand,
-            title: ( localize2(1757, "Preview selected action")),
+            title: ( localize2(1791, "Preview selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,

package/vscode/src/vs/platform/actionWidget/browser/actionWidget.service.d.ts

@@ -2,11 +2,11 @@ import { StandardMouseEvent } from "../../../base/browser/mouseEvent.js";
 import { IAnchor } from "../../../base/browser/ui/contextview/contextview.js";
 import { IListAccessibilityProvider } from "../../../base/browser/ui/list/listWidget.js";
 import { IAction } from "../../../base/common/actions.js";
-import { IActionListItem, IActionListDelegate } from "./actionList.js";
+import { IActionListItem, IActionListDelegate, IActionListOptions } from "./actionList.js";
 export declare const IActionWidgetService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IActionWidgetService>;
 export interface IActionWidgetService {
     readonly _serviceBrand: undefined;
-    show<T>(user: string, supportsPreview: boolean, items: readonly IActionListItem<T>[], delegate: IActionListDelegate<T>, anchor: HTMLElement | StandardMouseEvent | IAnchor, container: HTMLElement | undefined, actionBarActions?: readonly IAction[], accessibilityProvider?: Partial<IListAccessibilityProvider<IActionListItem<T>>>): void;
+    show<T>(user: string, supportsPreview: boolean, items: readonly IActionListItem<T>[], delegate: IActionListDelegate<T>, anchor: HTMLElement | StandardMouseEvent | IAnchor, container: HTMLElement | undefined, actionBarActions?: readonly IAction[], accessibilityProvider?: Partial<IListAccessibilityProvider<IActionListItem<T>>>, listOptions?: IActionListOptions): void;
     hide(didCancel?: boolean): void;
     readonly isVisible: boolean;
 }

package/vscode/src/vs/platform/actions/browser/floatingMenu.js

@@ -50,7 +50,7 @@ let AbstractFloatingClickMenu = class AbstractFloatingClickMenu extends Disposab
     }
     constructor(menuId, menuService, contextKeyService) {
         super();
-        this.renderEmitter = ( new Emitter());
+        this.renderEmitter = this._register(( new Emitter()));
         this.menu = this._register(menuService.createMenu(menuId, contextKeyService));
     }
     render() {

package/vscode/src/vs/platform/actions/browser/menuEntryActionViewItem.d.ts

@@ -10,6 +10,7 @@ import { IInstantiationService } from "../../instantiation/common/instantiation.
 import { IKeybindingService } from "../../keybinding/common/keybinding.service.js";
 import { INotificationService } from "../../notification/common/notification.service.js";
 import { IStorageService } from "../../storage/common/storage.service.js";
+import { ClickAnimation } from "../../../base/browser/ui/animations/animations.js";
 import { IThemeService } from "../../theme/common/themeService.service.js";
 import { MenuItemAction, SubmenuItemAction } from "../common/actions.js";
 import { IMenuService } from "../common/actions.service.js";
@@ -42,6 +43,7 @@ export interface IMenuEntryActionViewItemOptions {
     readonly keybinding?: string | null;
     readonly hoverDelegate?: IHoverDelegate;
     readonly keybindingNotRenderedWithLabel?: boolean;
+    readonly onClickAnimation?: ClickAnimation;
 }
 export declare class MenuEntryActionViewItem<T extends IMenuEntryActionViewItemOptions = IMenuEntryActionViewItemOptions> extends ActionViewItem {
     protected readonly _options: T | undefined;

package/vscode/src/vs/platform/actions/browser/menuEntryActionViewItem.js

@@ -37,6 +37,7 @@ import '../../theme/common/colors/minimapColors.js';
 import '../../theme/common/colors/miscColors.js';
 import '../../theme/common/colors/quickpickColors.js';
 import '../../theme/common/colors/searchColors.js';
+import { triggerClickAnimation } from '../../../base/browser/ui/animations/animations.js';
 import { isDark } from '../../theme/common/theme.js';
 import { IThemeService } from '../../theme/common/themeService.service.js';
 import { hasNativeContextMenu } from '../../window/common/window.js';
@@ -206,6 +207,14 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
     async onClick(event) {
         event.preventDefault();
         event.stopPropagation();
+        if (this._options?.onClickAnimation && this.element && !this._accessibilityService.isMotionReduced()) {
+            const icon = this._menuItemAction.item.icon;
+            triggerClickAnimation(
+                this.element,
+                this._options.onClickAnimation,
+                ThemeIcon.isThemeIcon(icon) ? icon : undefined
+            );
+        }
         try {
             await this.actionRunner.run(this._commandAction, this._context);
         } catch (err) {
@@ -253,7 +262,7 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
             const altTooltip = this._menuItemAction.alt.tooltip || this._menuItemAction.alt.label;
             const altTitleSection = this._keybindingService.appendKeybinding(altTooltip, this._menuItemAction.alt.id, this._contextKeyService);
             title = ( localize(
-                1759,
+                1793,
                 "{0}\n[{1}] {2}",
                 title,
                 UILabelProvider.modifierLabels[OS].altKey,
@@ -321,9 +330,9 @@ class TextOnlyMenuEntryActionViewItem extends MenuEntryActionViewItem {
         if (this.label) {
             const kb2 = TextOnlyMenuEntryActionViewItem._symbolPrintEnter(kb);
             if (this._options?.conversational) {
-                this.label.textContent = ( localize(1760, "{1} to {0}", this._action.label, kb2));
+                this.label.textContent = ( localize(1794, "{1} to {0}", this._action.label, kb2));
             } else {
-                this.label.textContent = ( localize(1761, "{0} ({1})", this._action.label, kb2));
+                this.label.textContent = ( localize(1795, "{0} ({1})", this._action.label, kb2));
             }
         }
     }
@@ -472,7 +481,9 @@ let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem
     set actionRunner(actionRunner) {
         super.actionRunner = actionRunner;
         this._defaultAction.actionRunner = actionRunner;
-        this._dropdown.actionRunner = actionRunner;
+        if (!this._options?.togglePrimaryAction) {
+            this._dropdown.actionRunner = actionRunner;
+        }
         if (this._primaryActionListener.value) {
             this.registerTogglePrimaryActionListener();
         }

package/vscode/src/vs/platform/actions/browser/toolbar.d.ts

@@ -111,7 +111,18 @@ export interface IMenuWorkbenchToolBarOptions extends IWorkbenchToolBarOptions {
 export declare class MenuWorkbenchToolBar extends WorkbenchToolBar {
     private readonly _onDidChangeMenuItems;
     get onDidChangeMenuItems(): import("../../../base/common/event.js").Event<this>;
+    private readonly _menu;
+    private readonly _menuOptions;
+    private readonly _toolbarOptions;
+    private readonly _container;
     constructor(container: HTMLElement, menuId: MenuId, options: IMenuWorkbenchToolBarOptions | undefined, menuService: IMenuService, contextKeyService: IContextKeyService, contextMenuService: IContextMenuService, keybindingService: IKeybindingService, commandService: ICommandService, telemetryService: ITelemetryService, actionViewService: IActionViewItemService, instantiationService: IInstantiationService);
+    private _updateToolbar;
+    /**
+     * Force the toolbar to immediately re-evaluate its menu actions.
+     * Use this after synchronously updating context keys to avoid
+     * layout shifts caused by the debounced menu change event.
+     */
+    refresh(): void;
     /**
      * @deprecated The WorkbenchToolBar does not support this method because it works with menus.
      */

package/vscode/src/vs/platform/actions/browser/toolbar.js

@@ -114,7 +114,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
         }
         coalesceInPlace(primary);
         coalesceInPlace(extraSecondary);
-        super.setActions(primary, Separator.join(extraSecondary, secondary));
+        super.setActions(Separator.clean(primary), Separator.join(extraSecondary, secondary));
         if (toggleActions.length > 0 || primary.length > 0) {
             this._sessionDisposables.add(addDisposableListener(this.getElement(), "contextmenu", e => {
                 const event = ( new StandardMouseEvent(getWindow(this.getElement()), e));
@@ -162,7 +162,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     } else {
                         primaryActions.push(toAction({
                             id: "label",
-                            label: ( localize(1762, "Hide")),
+                            label: ( localize(1796, "Hide")),
                             enabled: false,
                             run() {}
                         }));
@@ -176,7 +176,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     actions.push(( new Separator()));
                     actions.push(toAction({
                         id: "resetThisMenu",
-                        label: ( localize(1763, "Reset Menu")),
+                        label: ( localize(1797, "Reset Menu")),
                         run: () => this._menuService.resetHiddenStates(menuIds)
                     }));
                 }
@@ -235,33 +235,39 @@ let MenuWorkbenchToolBar = class MenuWorkbenchToolBar extends WorkbenchToolBar {
             }
         }, menuService, contextKeyService, contextMenuService, keybindingService, commandService, telemetryService);
         this._onDidChangeMenuItems = this._store.add(( new Emitter()));
-        const menu = this._store.add(menuService.createMenu(menuId, contextKeyService, {
+        this._container = container;
+        this._menuOptions = options?.menuOptions;
+        this._toolbarOptions = options?.toolbarOptions;
+        this._menu = this._store.add(menuService.createMenu(menuId, contextKeyService, {
             emitEventsForSubmenuChanges: true,
             eventDebounceDelay: options?.eventDebounceDelay
         }));
-        const updateToolbar = () => {
-            const {
-                primary,
-                secondary
-            } = getActionBarActions(
-                menu.getActions(options?.menuOptions),
-                options?.toolbarOptions?.primaryGroup,
-                options?.toolbarOptions?.shouldInlineSubmenu,
-                options?.toolbarOptions?.useSeparatorsInPrimaryActions
-            );
-            container.classList.toggle("has-no-actions", primary.length === 0 && secondary.length === 0);
-            super.setActions(primary, secondary);
-        };
-        this._store.add(menu.onDidChange(() => {
-            updateToolbar();
+        this._store.add(this._menu.onDidChange(() => {
+            this._updateToolbar();
             this._onDidChangeMenuItems.fire(this);
         }));
         this._store.add(actionViewService.onDidChange(e => {
             if (e === menuId) {
-                updateToolbar();
+                this._updateToolbar();
             }
         }));
-        updateToolbar();
+        this._updateToolbar();
+    }
+    _updateToolbar() {
+        const {
+            primary,
+            secondary
+        } = getActionBarActions(
+            this._menu.getActions(this._menuOptions),
+            this._toolbarOptions?.primaryGroup,
+            this._toolbarOptions?.shouldInlineSubmenu,
+            this._toolbarOptions?.useSeparatorsInPrimaryActions
+        );
+        this._container.classList.toggle("has-no-actions", primary.length === 0 && secondary.length === 0);
+        super.setActions(primary, secondary);
+    }
+    refresh() {
+        this._updateToolbar();
     }
     setActions() {
         throw ( new BugIndicatingError("This toolbar is populated from a menu."));