@codingame/monaco-vscode-api 4.5.1 → 5.0.0

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

@@ -35,6 +35,7 @@ import '../../theme/common/colors/quickpickColors.js';
 import '../../theme/common/colors/searchColors.js';
 import { defaultSelectBoxStyles } from '../../theme/browser/defaultStyles.js';
 import { IAccessibilityService } from '../../accessibility/common/accessibility.service.js';
+const _moduleId = "vs/platform/actions/browser/menuEntryActionViewItem";
 function createAndFillInContextMenuActions(menu, options, target, primaryGroup) {
     const groups = menu.getActions(options);
     const modifierKeyEmitter = ModifierKeyEmitter.getInstance();
@@ -57,19 +58,19 @@ function fillInActions(groups, target, useAlternativeActions, isPrimaryAction =
         primaryBucket = target.primary;
         secondaryBucket = target.secondary;
     }
-    const submenuInfo = ( new Set());
+    const submenuInfo = ( (new Set()));
     for (const [group, actions] of groups) {
         let target;
         if (isPrimaryAction(group)) {
             target = primaryBucket;
             if (target.length > 0 && useSeparatorsInPrimaryActions) {
-                target.push(( new Separator()));
+                target.push(( (new Separator())));
             }
         }
         else {
             target = secondaryBucket;
             if (target.length > 0) {
-                target.push(( new Separator()));
+                target.push(( (new Separator())));
             }
         }
         for (let action of actions) {
@@ -100,7 +101,7 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
         this._contextMenuService = _contextMenuService;
         this._accessibilityService = _accessibilityService;
         this._wantsAltCommand = false;
-        this._itemClassDispose = this._register(( new MutableDisposable()));
+        this._itemClassDispose = this._register(( (new MutableDisposable())));
         this._altKey = ModifierKeyEmitter.getInstance();
     }
     get _menuItemAction() {
@@ -160,30 +161,18 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
         const keybindingLabel = keybinding && keybinding.getLabel();
         const tooltip = this._commandAction.tooltip || this._commandAction.label;
         let title = keybindingLabel
-            ? ( localizeWithPath(
-            'vs/platform/actions/browser/menuEntryActionViewItem',
-            'titleAndKb',
-            "{0} ({1})",
-            tooltip,
-            keybindingLabel
-        ))
+            ? ( localizeWithPath(_moduleId, 0, "{0} ({1})", tooltip, keybindingLabel))
             : tooltip;
         if (!this._wantsAltCommand && this._menuItemAction.alt?.enabled) {
             const altTooltip = this._menuItemAction.alt.tooltip || this._menuItemAction.alt.label;
             const altKeybinding = this._keybindingService.lookupKeybinding(this._menuItemAction.alt.id, this._contextKeyService);
             const altKeybindingLabel = altKeybinding && altKeybinding.getLabel();
             const altTitleSection = altKeybindingLabel
-                ? ( localizeWithPath(
-                'vs/platform/actions/browser/menuEntryActionViewItem',
-                'titleAndKb',
-                "{0} ({1})",
-                altTooltip,
-                altKeybindingLabel
-            ))
+                ? ( localizeWithPath(_moduleId, 0, "{0} ({1})", altTooltip, altKeybindingLabel))
                 : altTooltip;
             title = ( localizeWithPath(
-                'vs/platform/actions/browser/menuEntryActionViewItem',
-                'titleAndKbAndAlt',
+                _moduleId,
+                1,
                 "{0}\n[{1}] {2}",
                 title,
                 UILabelProvider.modifierLabels[OS].altKey,
@@ -235,14 +224,14 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
         }
     }
 };
-MenuEntryActionViewItem = ( __decorate([
-    ( __param(2, IKeybindingService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IThemeService)),
-    ( __param(6, IContextMenuService)),
-    ( __param(7, IAccessibilityService))
-], MenuEntryActionViewItem));
+MenuEntryActionViewItem = ( (__decorate([
+    ( (__param(2, IKeybindingService))),
+    ( (__param(3, INotificationService))),
+    ( (__param(4, IContextKeyService))),
+    ( (__param(5, IThemeService))),
+    ( (__param(6, IContextMenuService))),
+    ( (__param(7, IAccessibilityService)))
+], MenuEntryActionViewItem)));
 let SubmenuEntryActionViewItem = class SubmenuEntryActionViewItem extends DropdownMenuActionViewItem {
     constructor(action, options, _keybindingService, _contextMenuService, _themeService) {
         const dropdownOptions = {
@@ -278,11 +267,11 @@ let SubmenuEntryActionViewItem = class SubmenuEntryActionViewItem extends Dropdo
         }
     }
 };
-SubmenuEntryActionViewItem = ( __decorate([
-    ( __param(2, IKeybindingService)),
-    ( __param(3, IContextMenuService)),
-    ( __param(4, IThemeService))
-], SubmenuEntryActionViewItem));
+SubmenuEntryActionViewItem = ( (__decorate([
+    ( (__param(2, IKeybindingService))),
+    ( (__param(3, IContextMenuService))),
+    ( (__param(4, IThemeService)))
+], SubmenuEntryActionViewItem)));
 let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem extends BaseActionViewItem {
     get onDidChangeDropdownVisibility() {
         return this._dropdown.onDidChangeVisibility;
@@ -312,14 +301,14 @@ let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem
             ...options,
             menuAsChild: options?.menuAsChild ?? true,
             classNames: options?.classNames ?? ['codicon', 'codicon-chevron-down'],
-            actionRunner: options?.actionRunner ?? ( new ActionRunner()),
+            actionRunner: options?.actionRunner ?? ( (new ActionRunner())),
         };
-        this._dropdown = ( new DropdownMenuActionViewItem(
+        this._dropdown = ( (new DropdownMenuActionViewItem(
             submenuAction,
             submenuAction.actions,
             this._contextMenuService,
             dropdownOptions
-        ));
+        )));
         this._register(this._dropdown.actionRunner.onDidRun((e) => {
             if (e.action instanceof MenuItemAction) {
                 this.update(e.action);
@@ -363,7 +352,7 @@ let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem
         const primaryContainer = $('.action-container');
         this._defaultAction.render(append(this._container, primaryContainer));
         this._register(addDisposableListener(primaryContainer, EventType.KEY_DOWN, (e) => {
-            const event = ( new StandardKeyboardEvent(e));
+            const event = ( (new StandardKeyboardEvent(e)));
             if (event.equals(17 )) {
                 this._defaultAction.element.tabIndex = -1;
                 this._dropdown.focus();
@@ -373,7 +362,7 @@ let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem
         const dropdownContainer = $('.dropdown-action-container');
         this._dropdown.render(append(this._container, dropdownContainer));
         this._register(addDisposableListener(dropdownContainer, EventType.KEY_DOWN, (e) => {
-            const event = ( new StandardKeyboardEvent(e));
+            const event = ( (new StandardKeyboardEvent(e)));
             if (event.equals(15 )) {
                 this._defaultAction.element.tabIndex = 0;
                 this._dropdown.setFocusable(false);
@@ -411,20 +400,20 @@ let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem
         super.dispose();
     }
 };
-DropdownWithDefaultActionViewItem = ( __decorate([
-    ( __param(2, IKeybindingService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IMenuService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IStorageService))
-], DropdownWithDefaultActionViewItem));
+DropdownWithDefaultActionViewItem = ( (__decorate([
+    ( (__param(2, IKeybindingService))),
+    ( (__param(3, INotificationService))),
+    ( (__param(4, IContextMenuService))),
+    ( (__param(5, IMenuService))),
+    ( (__param(6, IInstantiationService))),
+    ( (__param(7, IStorageService)))
+], DropdownWithDefaultActionViewItem)));
 let SubmenuEntrySelectActionViewItem = class SubmenuEntrySelectActionViewItem extends SelectActionViewItem {
     constructor(action, contextViewService) {
-        super(null, action, ( action.actions.map(a => ({
+        super(null, action, ( (action.actions.map(a => ({
             text: a.id === Separator.ID ? '\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500' : a.label,
             isDisabled: !a.enabled,
-        }))), 0, contextViewService, defaultSelectBoxStyles, { ariaLabel: action.tooltip, optionsAsChildren: true });
+        })))), 0, contextViewService, defaultSelectBoxStyles, { ariaLabel: action.tooltip, optionsAsChildren: true });
         this.select(Math.max(0, action.actions.findIndex(a => a.checked)));
     }
     render(container) {
@@ -438,9 +427,9 @@ let SubmenuEntrySelectActionViewItem = class SubmenuEntrySelectActionViewItem ex
         }
     }
 };
-SubmenuEntrySelectActionViewItem = ( __decorate([
-    ( __param(1, IContextViewService))
-], SubmenuEntrySelectActionViewItem));
+SubmenuEntrySelectActionViewItem = ( (__decorate([
+    ( (__param(1, IContextViewService)))
+], SubmenuEntrySelectActionViewItem)));
 function createActionViewItem(instaService, action, options) {
     if (action instanceof MenuItemAction) {
         return instaService.createInstance(MenuEntryActionViewItem, action, options);

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

@@ -2,6 +2,7 @@ import { ToolBar, IToolBarOptions } from '../../../base/browser/ui/toolbar/toolb
 import { IAction } from '../../../base/common/actions.js';
 import { MenuId, IMenuActionOptions } from '../common/actions.js';
 import { IMenuService } from '../common/actions.service.js';
+import { ICommandService } from '../../commands/common/commands.service.js';
 import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
 import { IContextMenuService } from '../../contextview/browser/contextView.service.js';
 import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
@@ -65,8 +66,10 @@ declare class WorkbenchToolBar extends ToolBar {
     private readonly _menuService;
     private readonly _contextKeyService;
     private readonly _contextMenuService;
+    private readonly _keybindingService;
+    private readonly _commandService;
     private readonly _sessionDisposables;
-    constructor(container: HTMLElement, _options: IWorkbenchToolBarOptions | undefined, _menuService: IMenuService, _contextKeyService: IContextKeyService, _contextMenuService: IContextMenuService, keybindingService: IKeybindingService, telemetryService: ITelemetryService);
+    constructor(container: HTMLElement, _options: IWorkbenchToolBarOptions | undefined, _menuService: IMenuService, _contextKeyService: IContextKeyService, _contextMenuService: IContextMenuService, _keybindingService: IKeybindingService, _commandService: ICommandService, telemetryService: ITelemetryService);
     setActions(_primary: readonly IAction[], _secondary?: readonly IAction[], menuIds?: readonly MenuId[]): void;
 }
 

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

@@ -1,7 +1,7 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { addDisposableListener, getWindow } from '../../../base/browser/dom.js';
 import { StandardMouseEvent } from '../../../base/browser/mouseEvent.js';
-import { ToolBar } from '../../../base/browser/ui/toolbar/toolbar.js';
+import { ToolBar, ToggleMenuAction } from '../../../base/browser/ui/toolbar/toolbar.js';
 import { Separator, toAction } from '../../../base/common/actions.js';
 import { coalesceInPlace } from '../../../base/common/arrays.js';
 import { intersection } from '../../../base/common/collections.js';
@@ -13,14 +13,17 @@ import { localizeWithPath } from '../../../nls.js';
 import { createAndFillInActionBarActions } from './menuEntryActionViewItem.js';
 import { MenuItemAction, SubmenuItemAction } from '../common/actions.js';
 import { IMenuService } from '../common/actions.service.js';
+import { createConfigureKeybindingAction } from '../common/menuService.js';
+import { ICommandService } from '../../commands/common/commands.service.js';
 import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
 import { IContextMenuService } from '../../contextview/browser/contextView.service.js';
 import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
 import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
+const _moduleId = "vs/platform/actions/browser/toolbar";
 let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
-    constructor(container, _options, _menuService, _contextKeyService, _contextMenuService, keybindingService, telemetryService) {
+    constructor(container, _options, _menuService, _contextKeyService, _contextMenuService, _keybindingService, _commandService, telemetryService) {
         super(container, _contextMenuService, {
-            getKeyBinding: (action) => keybindingService.lookupKeybinding(action.id) ?? undefined,
+            getKeyBinding: (action) => _keybindingService.lookupKeybinding(action.id) ?? undefined,
             ..._options,
             allowContextMenu: true,
             skipTelemetry: typeof _options?.telemetrySource === 'string',
@@ -29,7 +32,9 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
         this._menuService = _menuService;
         this._contextKeyService = _contextKeyService;
         this._contextMenuService = _contextMenuService;
-        this._sessionDisposables = this._store.add(( new DisposableStore()));
+        this._keybindingService = _keybindingService;
+        this._commandService = _commandService;
+        this._sessionDisposables = this._store.add(( (new DisposableStore())));
         const telemetrySource = _options?.telemetrySource;
         if (telemetrySource) {
             this._store.add(this.actionBar.onDidRun(e => telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: telemetrySource })));
@@ -66,7 +71,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
             }
         }
         if (this._options?.overflowBehavior !== undefined) {
-            const exemptedIds = intersection(( new Set(this._options.overflowBehavior.exempted)), ( Iterable.map(primary, a => a?.id)));
+            const exemptedIds = intersection(( (new Set(this._options.overflowBehavior.exempted))), ( (Iterable.map(primary, a => a?.id))));
             const maxItems = this._options.overflowBehavior.maxItems - exemptedIds.size;
             let count = 0;
             for (let i = 0; i < primary.length; i++) {
@@ -75,7 +80,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     continue;
                 }
                 count++;
-                if (( exemptedIds.has(action.id))) {
+                if (( (exemptedIds.has(action.id)))) {
                     continue;
                 }
                 if (count >= maxItems) {
@@ -87,58 +92,69 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
         coalesceInPlace(primary);
         coalesceInPlace(extraSecondary);
         super.setActions(primary, Separator.join(extraSecondary, secondary));
-        if (toggleActions.length > 0) {
+        if (toggleActions.length > 0 || primary.length > 0) {
             this._sessionDisposables.add(addDisposableListener(this.getElement(), 'contextmenu', e => {
-                const event = ( new StandardMouseEvent(getWindow(this.getElement()), e));
+                const event = ( (new StandardMouseEvent(getWindow(this.getElement()), e)));
                 const action = this.getItemAction(event.target);
                 if (!(action)) {
                     return;
                 }
                 event.preventDefault();
                 event.stopPropagation();
-                let noHide = false;
-                if (toggleActionsCheckedCount === 1 && this._options?.hiddenItemStrategy === 0 ) {
-                    noHide = true;
-                    for (let i = 0; i < toggleActions.length; i++) {
-                        if (toggleActions[i].checked) {
-                            toggleActions[i] = toAction({
-                                id: action.id,
-                                label: action.label,
-                                checked: true,
-                                enabled: false,
-                                run() { }
-                            });
-                            break;
+                const primaryActions = [];
+                if (action instanceof MenuItemAction && action.menuKeybinding) {
+                    primaryActions.push(action.menuKeybinding);
+                }
+                else if (!(action instanceof SubmenuItemAction || action instanceof ToggleMenuAction)) {
+                    primaryActions.push(createConfigureKeybindingAction(action.id, undefined, this._commandService, this._keybindingService));
+                }
+                if (toggleActions.length > 0) {
+                    let noHide = false;
+                    if (toggleActionsCheckedCount === 1 && this._options?.hiddenItemStrategy === 0 ) {
+                        noHide = true;
+                        for (let i = 0; i < toggleActions.length; i++) {
+                            if (toggleActions[i].checked) {
+                                toggleActions[i] = toAction({
+                                    id: action.id,
+                                    label: action.label,
+                                    checked: true,
+                                    enabled: false,
+                                    run() { }
+                                });
+                                break;
+                            }
                         }
                     }
-                }
-                let hideAction;
-                if (!noHide && (action instanceof MenuItemAction || action instanceof SubmenuItemAction)) {
-                    if (!action.hideActions) {
-                        return;
+                    if (!noHide && (action instanceof MenuItemAction || action instanceof SubmenuItemAction)) {
+                        if (!action.hideActions) {
+                            return;
+                        }
+                        primaryActions.push(action.hideActions.hide);
+                    }
+                    else {
+                        primaryActions.push(toAction({
+                            id: 'label',
+                            label: ( localizeWithPath(_moduleId, 0, "Hide")),
+                            enabled: false,
+                            run() { }
+                        }));
                     }
-                    hideAction = action.hideActions.hide;
-                }
-                else {
-                    hideAction = toAction({
-                        id: 'label',
-                        label: ( localizeWithPath('vs/platform/actions/browser/toolbar', 'hide', "Hide")),
-                        enabled: false,
-                        run() { }
-                    });
                 }
-                const actions = Separator.join([hideAction], toggleActions);
+                const actions = Separator.join(primaryActions, toggleActions);
                 if (this._options?.resetMenu && !menuIds) {
                     menuIds = [this._options.resetMenu];
                 }
                 if (someAreHidden && menuIds) {
-                    actions.push(( new Separator()));
+                    actions.push(( (new Separator())));
                     actions.push(toAction({
                         id: 'resetThisMenu',
-                        label: ( localizeWithPath('vs/platform/actions/browser/toolbar', 'resetThisMenu', "Reset Menu")),
+                        label: ( localizeWithPath(_moduleId, 1, "Reset Menu")),
                         run: () => this._menuService.resetHiddenStates(menuIds)
                     }));
                 }
+                if (actions.length === 0) {
+                    return;
+                }
                 this._contextMenuService.showContextMenu({
                     getAnchor: () => event,
                     getActions: () => actions,
@@ -151,17 +167,18 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
         }
     }
 };
-WorkbenchToolBar = ( __decorate([
-    ( __param(2, IMenuService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IKeybindingService)),
-    ( __param(6, ITelemetryService))
-], WorkbenchToolBar));
+WorkbenchToolBar = ( (__decorate([
+    ( (__param(2, IMenuService))),
+    ( (__param(3, IContextKeyService))),
+    ( (__param(4, IContextMenuService))),
+    ( (__param(5, IKeybindingService))),
+    ( (__param(6, ICommandService))),
+    ( (__param(7, ITelemetryService)))
+], WorkbenchToolBar)));
 let MenuWorkbenchToolBar = class MenuWorkbenchToolBar extends WorkbenchToolBar {
-    constructor(container, menuId, options, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService) {
-        super(container, { resetMenu: menuId, ...options }, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService);
-        this._onDidChangeMenuItems = this._store.add(( new Emitter()));
+    constructor(container, menuId, options, menuService, contextKeyService, contextMenuService, keybindingService, commandService, telemetryService) {
+        super(container, { resetMenu: menuId, ...options }, menuService, contextKeyService, contextMenuService, keybindingService, commandService, telemetryService);
+        this._onDidChangeMenuItems = this._store.add(( (new Emitter())));
         this.onDidChangeMenuItems = this._onDidChangeMenuItems.event;
         const menu = this._store.add(menuService.createMenu(menuId, contextKeyService, { emitEventsForSubmenuChanges: true }));
         const updateToolbar = () => {
@@ -178,14 +195,15 @@ let MenuWorkbenchToolBar = class MenuWorkbenchToolBar extends WorkbenchToolBar {
         updateToolbar();
     }
     setActions() {
-        throw new BugIndicatingError('This toolbar is populated from a menu.');
+        throw ( (new BugIndicatingError('This toolbar is populated from a menu.')));
     }
 };
-MenuWorkbenchToolBar = ( __decorate([
-    ( __param(3, IMenuService)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IContextMenuService)),
-    ( __param(6, IKeybindingService)),
-    ( __param(7, ITelemetryService))
-], MenuWorkbenchToolBar));
+MenuWorkbenchToolBar = ( (__decorate([
+    ( (__param(3, IMenuService))),
+    ( (__param(4, IContextKeyService))),
+    ( (__param(5, IContextMenuService))),
+    ( (__param(6, IKeybindingService))),
+    ( (__param(7, ICommandService))),
+    ( (__param(8, ITelemetryService)))
+], MenuWorkbenchToolBar)));
 export { MenuWorkbenchToolBar, WorkbenchToolBar };

package/vscode/src/vs/platform/actions/common/actions.contribution.js

@@ -0,0 +1,5 @@
+import { registerAction2 } from './actions.js';
+import '../../instantiation/common/instantiation.js';
+import { MenuHiddenStatesReset } from './menuResetAction.js';
+import './menuService.js';
+registerAction2(MenuHiddenStatesReset);

package/vscode/src/vs/platform/actions/common/actions.d.ts

@@ -195,6 +195,7 @@ declare class MenuId {
     static readonly InlineEditToolbar: MenuId;
     static readonly ChatContext: MenuId;
     static readonly ChatCodeBlock: MenuId;
+    static readonly ChatCompareBlock: MenuId;
     static readonly ChatMessageTitle: MenuId;
     static readonly ChatExecute: MenuId;
     static readonly ChatExecuteSecondary: MenuId;
@@ -270,6 +271,7 @@ interface IMenuItemHide {
 }
 declare class MenuItemAction implements IAction {
     readonly hideActions: IMenuItemHide | undefined;
+    readonly menuKeybinding: IAction | undefined;
     private _commandService;
     static label(action: ICommandAction, options?: IMenuActionOptions): string;
     readonly item: ICommandAction;
@@ -281,7 +283,7 @@ declare class MenuItemAction implements IAction {
     readonly class: string | undefined;
     readonly enabled: boolean;
     readonly checked?: boolean;
-    constructor(item: ICommandAction, alt: ICommandAction | undefined, options: IMenuActionOptions | undefined, hideActions: IMenuItemHide | undefined, contextKeyService: IContextKeyService, _commandService: ICommandService);
+    constructor(item: ICommandAction, alt: ICommandAction | undefined, options: IMenuActionOptions | undefined, hideActions: IMenuItemHide | undefined, menuKeybinding: IAction | undefined, contextKeyService: IContextKeyService, _commandService: ICommandService);
     run(...args: any[]): Promise<void>;
 }
 

package/vscode/src/vs/platform/actions/common/actions.js

@@ -187,6 +187,7 @@ class MenuId {
     static { this.InlineEditToolbar = ( new MenuId('InlineEditToolbar')); }
     static { this.ChatContext = ( new MenuId('ChatContext')); }
     static { this.ChatCodeBlock = ( new MenuId('ChatCodeblock')); }
+    static { this.ChatCompareBlock = ( new MenuId('ChatCompareBlock')); }
     static { this.ChatMessageTitle = ( new MenuId('ChatMessageTitle')); }
     static { this.ChatExecute = ( new MenuId('ChatExecute')); }
     static { this.ChatExecuteSecondary = ( new MenuId('ChatExecuteSecondary')); }
@@ -200,7 +201,9 @@ class MenuId {
     }
     constructor(identifier) {
         if (( MenuId._instances.has(identifier))) {
-            throw new TypeError(`MenuId with identifier '${identifier}' already exists. Use MenuId.for(ident) or a unique identifier`);
+            throw ( new TypeError(
+                `MenuId with identifier '${identifier}' already exists. Use MenuId.for(ident) or a unique identifier`
+            ));
         }
         MenuId._instances.set(identifier, this);
         this.id = identifier;
@@ -319,8 +322,9 @@ let MenuItemAction = MenuItemAction_1 = class MenuItemAction {
             ? (typeof action.shortTitle === 'string' ? action.shortTitle : action.shortTitle.value)
             : (typeof action.title === 'string' ? action.title : action.title.value);
     }
-    constructor(item, alt, options, hideActions, contextKeyService, _commandService) {
+    constructor(item, alt, options, hideActions, menuKeybinding, contextKeyService, _commandService) {
         this.hideActions = hideActions;
+        this.menuKeybinding = menuKeybinding;
         this._commandService = _commandService;
         this.id = item.id;
         this.label = MenuItemAction_1.label(item, options);
@@ -345,7 +349,15 @@ let MenuItemAction = MenuItemAction_1 = class MenuItemAction {
             icon = ThemeIcon.isThemeIcon(item.icon) ? item.icon : undefined;
         }
         this.item = item;
-        this.alt = alt ? ( new MenuItemAction_1(alt, undefined, options, hideActions, contextKeyService, _commandService)) : undefined;
+        this.alt = alt ? ( new MenuItemAction_1(
+            alt,
+            undefined,
+            options,
+            hideActions,
+            undefined,
+            contextKeyService,
+            _commandService
+        )) : undefined;
         this._options = options;
         this.class = icon && ThemeIcon.asClassName(icon);
     }
@@ -361,8 +373,8 @@ let MenuItemAction = MenuItemAction_1 = class MenuItemAction {
     }
 };
 MenuItemAction = MenuItemAction_1 = ( __decorate([
-    ( __param(4, IContextKeyService)),
-    ( __param(5, ICommandService))
+    ( __param(5, IContextKeyService)),
+    ( __param(6, ICommandService))
 ], MenuItemAction));
 class Action2 {
     constructor(desc) {
@@ -374,7 +386,7 @@ function registerAction2(ctor) {
     const action = ( new ctor());
     const { f1, menu, keybinding, ...command } = action.desc;
     if (CommandsRegistry.getCommand(command.id)) {
-        throw new Error(`Cannot register two commands with the same id: ${command.id}`);
+        throw ( new Error(`Cannot register two commands with the same id: ${command.id}`));
     }
     disposables.add(CommandsRegistry.registerCommand({
         id: command.id,

package/vscode/src/vs/platform/actions/common/menuResetAction.js

@@ -0,0 +1,21 @@
+import { localize2WithPath } from '../../../nls.js';
+import { Categories } from '../../action/common/actionCommonCategories.js';
+import { Action2 } from './actions.js';
+import { IMenuService } from './actions.service.js';
+import { ILogService } from '../../log/common/log.service.js';
+const _moduleId = "vs/platform/actions/common/menuResetAction";
+class MenuHiddenStatesReset extends Action2 {
+    constructor() {
+        super({
+            id: 'menu.resetHiddenStates',
+            title: ( localize2WithPath(_moduleId, 0, "Reset All Menus")),
+            category: Categories.View,
+            f1: true
+        });
+    }
+    run(accessor) {
+        accessor.get(IMenuService).resetHiddenStates();
+        accessor.get(ILogService).info('did RESET all menu hidden states');
+    }
+}
+export { MenuHiddenStatesReset };