support to hide menu item from their context menu,

have persisted menu item hide states in menu service, create `MenuItemAction` with an util that can hide itself and its siblings (from the same menu), some adoptions

Author: jrieken

src/vs/platform/actions/browser/dropdownWithPrimaryActionViewItem.ts

@@ -3,7 +3,6 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IContextMenuProvider } from 'vs/base/browser/contextmenu';
 import * as DOM from 'vs/base/browser/dom';
 import { StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
 import { ActionViewItem, BaseActionViewItem } from 'vs/base/browser/ui/actionbar/actionViewItems';
@@ -18,6 +17,7 @@ import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
 import { INotificationService } from 'vs/platform/notification/common/notification';
 import { IThemeService } from 'vs/platform/theme/common/themeService';
+import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
 
 export interface IDropdownWithPrimaryActionViewItemOptions {
 	getKeyBinding?: (action: IAction) => ResolvedKeybinding | undefined;
@@ -38,15 +38,15 @@ export class DropdownWithPrimaryActionViewItem extends BaseActionViewItem {
 		dropdownAction: IAction,
 		dropdownMenuActions: IAction[],
 		className: string,
-		private readonly _contextMenuProvider: IContextMenuProvider,
+		private readonly _contextMenuProvider: IContextMenuService,
 		private readonly _options: IDropdownWithPrimaryActionViewItemOptions | undefined,
 		@IKeybindingService _keybindingService: IKeybindingService,
 		@INotificationService _notificationService: INotificationService,
 		@IContextKeyService _contextKeyService: IContextKeyService,
 		@IThemeService _themeService: IThemeService
 	) {
 		super(null, primaryAction);
-		this._primaryAction = new MenuEntryActionViewItem(primaryAction, undefined, _keybindingService, _notificationService, _contextKeyService, _themeService);
+		this._primaryAction = new MenuEntryActionViewItem(primaryAction, undefined, _keybindingService, _notificationService, _contextKeyService, _themeService, _contextMenuProvider);
 		this._dropdown = new DropdownMenuActionViewItem(dropdownAction, dropdownMenuActions, this._contextMenuProvider, {
 			menuAsChild: true,
 			classNames: ['codicon', 'codicon-chevron-down'],

src/vs/platform/actions/browser/menuEntryActionViewItem.ts

@@ -206,12 +206,16 @@ export class MenuEntryActionViewItem extends ActionViewItem {
 
 
 		this._register(addDisposableListener(container, 'contextmenu', event => {
+			if (!this._menuItemAction.hideActions) {
+				return;
+			}
+
 			event.preventDefault();
 			event.stopPropagation();
 
 			this._contextMenuService.showContextMenu({
 				getAnchor: () => container,
-				getActions: () => this._menuItemAction.hideActions.asList()
+				getActions: () => this._menuItemAction.hideActions!.asList()
 			});
 		}, true));
 	}

src/vs/platform/actions/common/actions.ts

@@ -353,6 +353,22 @@ export class SubmenuItemAction extends SubmenuAction {
 	}
 }
 
+export class MenuItemActionManageActions {
+	constructor(
+		private readonly _hideThis: IAction,
+		private readonly _toggleAny: IAction[][],
+	) { }
+
+	asList(): IAction[] {
+		let result: IAction[] = [this._hideThis];
+		for (const n of this._toggleAny) {
+			result.push(new Separator());
+			result = result.concat(n);
+		}
+		return result;
+	}
+}
+
 // implements IAction, does NOT extend Action, so that no one
 // subscribes to events of Action or modified properties
 export class MenuItemAction implements IAction {
@@ -373,6 +389,7 @@ export class MenuItemAction implements IAction {
 		item: ICommandAction,
 		alt: ICommandAction | undefined,
 		options: IMenuActionOptions | undefined,
+		readonly hideActions: MenuItemActionManageActions | undefined,
 		@IContextKeyService contextKeyService: IContextKeyService,
 		@ICommandService private _commandService: ICommandService
 	) {
@@ -399,7 +416,7 @@ export class MenuItemAction implements IAction {
 		}
 
 		this.item = item;
-		this.alt = alt ? new MenuItemAction(alt, undefined, options, contextKeyService, _commandService) : undefined;
+		this.alt = alt ? new MenuItemAction(alt, undefined, options, hideActions, contextKeyService, _commandService) : undefined;
 		this._options = options;
 		if (ThemeIcon.isThemeIcon(item.icon)) {
 			this.class = CSSIcon.asClassName(item.icon);

src/vs/platform/actions/common/menuService.ts

@@ -6,32 +6,98 @@
 import { RunOnceScheduler } from 'vs/base/common/async';
 import { Emitter, Event } from 'vs/base/common/event';
 import { DisposableStore } from 'vs/base/common/lifecycle';
-import { IMenu, IMenuActionOptions, IMenuCreateOptions, IMenuItem, IMenuService, isIMenuItem, ISubmenuItem, MenuId, MenuItemAction, MenuRegistry, SubmenuItemAction } from 'vs/platform/actions/common/actions';
-import { ILocalizedString } from 'vs/platform/action/common/action';
+import { IMenu, IMenuActionOptions, IMenuCreateOptions, IMenuItem, IMenuService, isIMenuItem, ISubmenuItem, MenuId, MenuItemAction, MenuItemActionManageActions, MenuRegistry, SubmenuItemAction } from 'vs/platform/actions/common/actions';
+import { ICommandAction, ILocalizedString } from 'vs/platform/action/common/action';
 import { ICommandService } from 'vs/platform/commands/common/commands';
 import { ContextKeyExpression, IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
+import { IAction, SubmenuAction } from 'vs/base/common/actions';
+import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
+import { removeFastWithoutKeepingOrder } from 'vs/base/common/arrays';
+import { localize } from 'vs/nls';
 
 export class MenuService implements IMenuService {
 
 	declare readonly _serviceBrand: undefined;
 
+	private readonly _hiddenStates: PersistedMenuHideState;
+
 	constructor(
-		@ICommandService private readonly _commandService: ICommandService
+		@ICommandService private readonly _commandService: ICommandService,
+		@IStorageService storageService: IStorageService,
 	) {
-		//
+		this._hiddenStates = new PersistedMenuHideState(storageService);
 	}
 
 	/**
 	 * Create a new menu for the given menu identifier. A menu sends events when it's entries
-	 * have changed (placement, enablement, checked-state). By default it does send events for
-	 * sub menu entries. That is more expensive and must be explicitly enabled with the
+	 * have changed (placement, enablement, checked-state). By default it does not send events for
+	 * submenu entries. That is more expensive and must be explicitly enabled with the
 	 * `emitEventsForSubmenuChanges` flag.
 	 */
 	createMenu(id: MenuId, contextKeyService: IContextKeyService, options?: IMenuCreateOptions): IMenu {
-		return new Menu(id, { emitEventsForSubmenuChanges: false, eventDebounceDelay: 50, ...options }, this._commandService, contextKeyService, this);
+		return new Menu(id, this._hiddenStates, { emitEventsForSubmenuChanges: false, eventDebounceDelay: 50, ...options }, this._commandService, contextKeyService, this);
 	}
 }
 
+class PersistedMenuHideState {
+
+	private static readonly _key = 'menu.hiddenCommands';
+
+	readonly onDidChange: Event<any>;
+	private readonly _disposables = new DisposableStore();
+	private readonly _data: Record<string, string[] | undefined>;
+
+	constructor(@IStorageService private readonly _storageService: IStorageService) {
+		try {
+			const raw = _storageService.get(PersistedMenuHideState._key, StorageScope.PROFILE, '{}');
+			this._data = JSON.parse(raw);
+		} catch (err) {
+			this._data = Object.create(null);
+		}
+
+		this.onDidChange = Event.filter(_storageService.onDidChangeValue, e => e.key === PersistedMenuHideState._key, this._disposables);
+	}
+
+	dispose() {
+		this._disposables.dispose();
+	}
+
+	isHidden(menu: MenuId, commandId: string): boolean {
+		return this._data[menu.id]?.includes(commandId) ?? false;
+	}
+
+	updateHidden(menu: MenuId, commandId: string, hidden: boolean): void {
+		const entries = this._data[menu.id];
+		if (!hidden) {
+			// remove and cleanup
+			if (entries) {
+				const idx = entries.indexOf(commandId);
+				if (idx >= 0) {
+					removeFastWithoutKeepingOrder(entries, idx);
+				}
+				if (entries.length === 0) {
+					delete this._data[menu.id];
+				}
+			}
+		} else {
+			// add unless already added
+			if (!entries) {
+				this._data[menu.id] = [commandId];
+			} else {
+				const idx = entries.indexOf(commandId);
+				if (idx < 0) {
+					entries.push(commandId);
+				}
+			}
+		}
+		this._persist();
+	}
+
+	private _persist(): void {
+		const raw = JSON.stringify(this._data);
+		this._storageService.store(PersistedMenuHideState._key, raw, StorageScope.PROFILE, StorageTarget.USER);
+	}
+}
 
 type MenuItemGroup = [string, Array<IMenuItem | ISubmenuItem>];
 
@@ -47,6 +113,7 @@ class Menu implements IMenu {
 
 	constructor(
 		private readonly _id: MenuId,
+		private readonly _hiddenStates: PersistedMenuHideState,
 		private readonly _options: Required<IMenuCreateOptions>,
 		@ICommandService private readonly _commandService: ICommandService,
 		@IContextKeyService private readonly _contextKeyService: IContextKeyService,
@@ -68,24 +135,27 @@ class Menu implements IMenu {
 			}
 		}));
 
-		// When context keys change we need to check if the menu also has changed. However,
-		// we only do that when someone listens on this menu because (1) context key events are
+		// When context keys or storage state changes we need to check if the menu also has changed. However,
+		// we only do that when someone listens on this menu because (1) these events are
 		// firing often and (2) menu are often leaked
-		const contextKeyListener = this._disposables.add(new DisposableStore());
-		const startContextKeyListener = () => {
+		const lazyListener = this._disposables.add(new DisposableStore());
+		const startLazyListener = () => {
 			const fireChangeSoon = new RunOnceScheduler(() => this._onDidChange.fire(this), _options.eventDebounceDelay);
-			contextKeyListener.add(fireChangeSoon);
-			contextKeyListener.add(_contextKeyService.onDidChangeContext(e => {
+			lazyListener.add(fireChangeSoon);
+			lazyListener.add(_contextKeyService.onDidChangeContext(e => {
 				if (e.affectsSome(this._contextKeys)) {
 					fireChangeSoon.schedule();
 				}
 			}));
+			lazyListener.add(_hiddenStates.onDidChange(() => {
+				fireChangeSoon.schedule();
+			}));
 		};
 
 		this._onDidChange = new Emitter({
 			// start/stop context key listener
-			onFirstListenerAdd: startContextKeyListener,
-			onLastListenerRemove: contextKeyListener.clear.bind(contextKeyListener)
+			onFirstListenerAdd: startLazyListener,
+			onLastListenerRemove: lazyListener.clear.bind(lazyListener)
 		});
 		this.onDidChange = this._onDidChange.event;
 
@@ -145,20 +215,47 @@ class Menu implements IMenu {
 
 	getActions(options?: IMenuActionOptions): [string, Array<MenuItemAction | SubmenuItemAction>][] {
 		const result: [string, Array<MenuItemAction | SubmenuItemAction>][] = [];
+		const allToggleActions: IAction[][] = [];
+
 		for (const group of this._menuGroups) {
 			const [id, items] = group;
+
+			const toggleActions: IAction[] = [];
+
 			const activeActions: Array<MenuItemAction | SubmenuItemAction> = [];
 			for (const item of items) {
 				if (this._contextKeyService.contextMatchesRules(item.when)) {
 					let action: MenuItemAction | SubmenuItemAction | undefined;
 					if (isIMenuItem(item)) {
-						action = new MenuItemAction(item.command, item.alt, options, this._contextKeyService, this._commandService);
+						if (!this._hiddenStates.isHidden(this._id, item.command.id)) {
+							action = new MenuItemAction(
+								item.command, item.alt, options,
+								new MenuItemActionManageActions(new HideMenuItemAction(this._id, item.command, this._hiddenStates), allToggleActions),
+								this._contextKeyService, this._commandService
+							);
+						}
+						// add toggle commmand
+						toggleActions.push(new ToggleMenuItemAction(this._id, item.command, this._hiddenStates));
 					} else {
 						action = new SubmenuItemAction(item, this._menuService, this._contextKeyService, options);
 						if (action.actions.length === 0) {
 							action.dispose();
 							action = undefined;
 						}
+						// add toggle submenu
+						if (action) {
+							// todo@jrieken this isn't good and O(n2) because this recurses for each submenu...
+							const makeToggleCommand = (id: MenuId, action: IAction): IAction => {
+								if (action instanceof SubmenuItemAction) {
+									return new SubmenuAction(action.id, action.label, action.actions.map(a => makeToggleCommand(action.item.submenu, a)));
+								} else if (action instanceof MenuItemAction) {
+									return new ToggleMenuItemAction(id, action.item, this._hiddenStates);
+								} else {
+									return action;
+								}
+							};
+							toggleActions.push(makeToggleCommand(this._id, action));
+						}
 					}
 
 					if (action) {
@@ -169,6 +266,9 @@ class Menu implements IMenu {
 			if (activeActions.length > 0) {
 				result.push([id, activeActions]);
 			}
+			if (toggleActions.length > 0) {
+				allToggleActions.push(toggleActions);
+			}
 		}
 		return result;
 	}
@@ -231,3 +331,55 @@ class Menu implements IMenu {
 		return aStr.localeCompare(bStr);
 	}
 }
+
+class ToggleMenuItemAction implements IAction {
+
+	readonly id: string;
+	readonly label: string;
+	readonly enabled: boolean = true;
+	readonly tooltip: string = '';
+
+	readonly checked: boolean;
+	readonly class: undefined;
+
+	run: () => void;
+
+	constructor(id: MenuId, command: ICommandAction, hiddenStates: PersistedMenuHideState) {
+		this.id = `toggle/${id.id}/${command.id}`;
+		this.label = typeof command.title === 'string' ? command.title : command.title.value;
+
+		let isHidden = hiddenStates.isHidden(id, command.id);
+		this.checked = !isHidden;
+		this.run = () => {
+			isHidden = !isHidden;
+			hiddenStates.updateHidden(id, command.id, isHidden);
+		};
+	}
+
+	dispose(): void {
+		// NOTHING
+	}
+}
+
+class HideMenuItemAction implements IAction {
+
+	readonly id: string;
+	readonly label: string;
+	readonly enabled: boolean = true;
+	readonly tooltip: string = '';
+
+	readonly checked: undefined;
+	readonly class: undefined;
+
+	run: () => void;
+
+	constructor(id: MenuId, command: ICommandAction, hiddenStates: PersistedMenuHideState) {
+		this.id = `hide/${id.id}/${command.id}`;
+		this.label = localize('hide.label', 'Hide \'{0}\'', typeof command.title === 'string' ? command.title : command.title.value);
+		this.run = () => { hiddenStates.updateHidden(id, command.id, true); };
+	}
+
+	dispose(): void {
+		// NOTHING
+	}
+}

src/vs/platform/actions/test/common/menuService.test.ts

@@ -9,6 +9,7 @@ import { isIMenuItem, MenuId, MenuRegistry } from 'vs/platform/actions/common/ac
 import { MenuService } from 'vs/platform/actions/common/menuService';
 import { NullCommandService } from 'vs/platform/commands/common/commands';
 import { MockContextKeyService } from 'vs/platform/keybinding/test/common/mockKeybindingService';
+import { InMemoryStorageService } from 'vs/platform/storage/common/storage';
 
 // --- service instances
 
@@ -27,7 +28,7 @@ suite('MenuService', function () {
 	let testMenuId: MenuId;
 
 	setup(function () {
-		menuService = new MenuService(NullCommandService);
+		menuService = new MenuService(NullCommandService, new InMemoryStorageService());
 		testMenuId = new MenuId('testo');
 		disposables.clear();
 	});

src/vs/workbench/contrib/notebook/browser/controller/editActions.ts

@@ -49,6 +49,7 @@ export class DeleteCellAction extends MenuItemAction {
 			},
 			undefined,
 			{ shouldForwardArgs: true },
+			undefined,
 			contextKeyService,
 			commandService);
 	}

src/vs/workbench/contrib/notebook/browser/diff/diffComponents.ts

@@ -156,7 +156,7 @@ class PropertyHeader extends Disposable {
 		this._toolbar = new ToolBar(cellToolbarContainer, this.contextMenuService, {
 			actionViewItemProvider: action => {
 				if (action instanceof MenuItemAction) {
-					const item = new CodiconActionViewItem(action, this.keybindingService, this.notificationService, this.contextKeyService, this.themeService);
+					const item = new CodiconActionViewItem(action, undefined, this.keybindingService, this.notificationService, this.contextKeyService, this.themeService, this.contextMenuService);
 					return item;
 				}
 

src/vs/workbench/contrib/notebook/browser/diff/notebookTextDiffList.ts

@@ -187,7 +187,7 @@ export class CellDiffSideBySideRenderer implements IListRenderer<SideBySideDiffE
 		const toolbar = new ToolBar(cellToolbarContainer, this.contextMenuService, {
 			actionViewItemProvider: action => {
 				if (action instanceof MenuItemAction) {
-					const item = new CodiconActionViewItem(action, this.keybindingService, this.notificationService, this.contextKeyService, this.themeService);
+					const item = new CodiconActionViewItem(action, undefined, this.keybindingService, this.notificationService, this.contextKeyService, this.themeService, this.contextMenuService);
 					return item;
 				}