@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/browser/parts/globalCompositeBar.js

@@ -40,14 +40,11 @@ import { isString } from '../../../base/common/types.js';
 import { ACTIVITY_BAR_BADGE_BACKGROUND, ACTIVITY_BAR_BADGE_FOREGROUND } from '../../common/theme.js';
 import { ICommandService } from '../../../platform/commands/common/commands.service.js';
 var GlobalCompositeBar_1;
+const _moduleId = "vs/workbench/browser/parts/globalCompositeBar";
 let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
     static { GlobalCompositeBar_1 = this; }
     static { this.ACCOUNTS_ACTION_INDEX = 0; }
-    static { this.ACCOUNTS_ICON = registerIcon('accounts-view-bar-icon', Codicon.account, ( localizeWithPath(
-        'vs/workbench/browser/parts/globalCompositeBar',
-        'accountsViewBarIcon',
-        "Accounts icon in the view bar."
-    ))); }
+    static { this.ACCOUNTS_ICON = registerIcon('accounts-view-bar-icon', Codicon.account, ( localizeWithPath(_moduleId, 0, "Accounts icon in the view bar."))); }
     constructor(contextMenuActionsProvider, colors, activityHoverOptions, configurationService, instantiationService, storageService, extensionService) {
         super();
         this.contextMenuActionsProvider = contextMenuActionsProvider;
@@ -56,14 +53,14 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
         this.instantiationService = instantiationService;
         this.storageService = storageService;
         this.extensionService = extensionService;
-        this.globalActivityAction = this._register(( new Action(GLOBAL_ACTIVITY_ID)));
-        this.accountAction = this._register(( new Action(ACCOUNTS_ACTIVITY_ID)));
+        this.globalActivityAction = this._register(( (new Action(GLOBAL_ACTIVITY_ID))));
+        this.accountAction = this._register(( (new Action(ACCOUNTS_ACTIVITY_ID))));
         this.element = document.createElement('div');
         const contextMenuAlignmentOptions = () => ({
             anchorAlignment: configurationService.getValue('workbench.sideBar.location') === 'left' ? 1  : 0 ,
             anchorAxisAlignment: 1
         });
-        this.globalActivityActionBar = this._register(( new ActionBar(this.element, {
+        this.globalActivityActionBar = this._register(( (new ActionBar(this.element, {
             actionViewItemProvider: (action, options) => {
                 if (action.id === GLOBAL_ACTIVITY_ID) {
                     return this.instantiationService.createInstance(GlobalActivityActionViewItem, this.contextMenuActionsProvider, { ...options, colors: this.colors, hoverOptions: this.activityHoverOptions }, contextMenuAlignmentOptions);
@@ -75,21 +72,17 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
                         hoverOptions: this.activityHoverOptions
                     }, contextMenuAlignmentOptions, (actions) => {
                         actions.unshift(...[
-                            toAction({ id: 'hideAccounts', label: ( localizeWithPath(
-                                'vs/workbench/browser/parts/globalCompositeBar',
-                                'hideAccounts',
-                                "Hide Accounts"
-                            )), run: () => this.storageService.store(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, false, 0 , 0 ) }),
-                            ( new Separator())
+                            toAction({ id: 'hideAccounts', label: ( localizeWithPath(_moduleId, 1, "Hide Accounts")), run: () => setAccountsActionVisible(storageService, false) }),
+                            ( (new Separator()))
                         ]);
                     });
                 }
-                throw new Error(`No view item for action '${action.id}'`);
+                throw ( (new Error(`No view item for action '${action.id}'`)));
             },
             orientation: 1 ,
-            ariaLabel: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'manage', "Manage")),
+            ariaLabel: ( localizeWithPath(_moduleId, 2, "Manage")),
             preventLoopNavigation: true
-        })));
+        }))));
         if (this.accountsVisibilityPreference) {
             this.globalActivityActionBar.push(this.accountAction, { index: GlobalCompositeBar_1.ACCOUNTS_ACTION_INDEX });
         }
@@ -113,7 +106,7 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
         return this.globalActivityActionBar.viewItems.length;
     }
     getContextMenuActions() {
-        return [toAction({ id: 'toggleAccountsVisibility', label: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'accounts', "Accounts")), checked: this.accountsVisibilityPreference, run: () => this.accountsVisibilityPreference = !this.accountsVisibilityPreference })];
+        return [toAction({ id: 'toggleAccountsVisibility', label: ( localizeWithPath(_moduleId, 3, "Accounts")), checked: this.accountsVisibilityPreference, run: () => this.accountsVisibilityPreference = !this.accountsVisibilityPreference })];
     }
     toggleAccountsActivity() {
         if (this.globalActivityActionBar.length() === 2 && this.accountsVisibilityPreference) {
@@ -127,18 +120,18 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
         }
     }
     get accountsVisibilityPreference() {
-        return this.storageService.getBoolean(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, 0 , true);
+        return isAccountsActionVisible(this.storageService);
     }
     set accountsVisibilityPreference(value) {
-        this.storageService.store(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, value, 0 , 0 );
+        setAccountsActionVisible(this.storageService, value);
     }
 };
-GlobalCompositeBar = GlobalCompositeBar_1 = ( __decorate([
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IStorageService)),
-    ( __param(6, IExtensionService))
-], GlobalCompositeBar));
+GlobalCompositeBar = GlobalCompositeBar_1 = ( (__decorate([
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, IStorageService))),
+    ( (__param(6, IExtensionService)))
+], GlobalCompositeBar)));
 let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionViewItem extends CompositeBarActionViewItem {
     constructor(menuId, action, options, contextMenuActionsProvider, contextMenuAlignmentOptions, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService) {
         super(action, { draggable: false, icon: true, hasPopup: true, ...options }, () => true, themeService, hoverService, configurationService, keybindingService);
@@ -180,7 +173,9 @@ let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionVie
                 return result;
             }, '');
         };
-        return ( new NumberBadge(number, descriptorFn));
+        return (
+             (new NumberBadge(number, descriptorFn))
+        );
     }
     render(container) {
         super.render(container);
@@ -192,9 +187,10 @@ let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionVie
             }
         }));
         this._register(addDisposableListener(this.container, EventType.CONTEXT_MENU, async (e) => {
-            const disposables = ( new DisposableStore());
+            e.stopPropagation();
+            const disposables = ( (new DisposableStore()));
             const actions = await this.resolveContextMenuActions(disposables);
-            const event = ( new StandardMouseEvent(getWindow(this.container), e));
+            const event = ( (new StandardMouseEvent(getWindow(this.container), e)));
             this.contextMenuService.showContextMenu({
                 getAnchor: () => event,
                 getActions: () => actions,
@@ -202,7 +198,7 @@ let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionVie
             });
         }));
         this._register(addDisposableListener(this.container, EventType.KEY_UP, (e) => {
-            const event = ( new StandardKeyboardEvent(e));
+            const event = ( (new StandardKeyboardEvent(e)));
             if (event.equals(3 ) || event.equals(10 )) {
                 EventHelper.stop(e, true);
                 this.run();
@@ -217,7 +213,7 @@ let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionVie
         return this.contextMenuActionsProvider();
     }
     async run() {
-        const disposables = ( new DisposableStore());
+        const disposables = ( (new DisposableStore()));
         const menu = disposables.add(this.menuService.createMenu(this.menuId, this.contextKeyService));
         const actions = await this.resolveMainMenuActions(menu, disposables);
         const { anchorAlignment, anchorAxisAlignment } = this.contextMenuAlignmentOptions() ?? { anchorAlignment: undefined, anchorAxisAlignment: undefined };
@@ -236,22 +232,22 @@ let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionVie
         return actions;
     }
 };
-AbstractGlobalActivityActionViewItem = ( __decorate([
-    ( __param(5, IThemeService)),
-    ( __param(6, IHoverService)),
-    ( __param(7, IMenuService)),
-    ( __param(8, IContextMenuService)),
-    ( __param(9, IContextKeyService)),
-    ( __param(10, IConfigurationService)),
-    ( __param(11, IKeybindingService)),
-    ( __param(12, IActivityService))
-], AbstractGlobalActivityActionViewItem));
+AbstractGlobalActivityActionViewItem = ( (__decorate([
+    ( (__param(5, IThemeService))),
+    ( (__param(6, IHoverService))),
+    ( (__param(7, IMenuService))),
+    ( (__param(8, IContextMenuService))),
+    ( (__param(9, IContextKeyService))),
+    ( (__param(10, IConfigurationService))),
+    ( (__param(11, IKeybindingService))),
+    ( (__param(12, IActivityService)))
+], AbstractGlobalActivityActionViewItem)));
 let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extends AbstractGlobalActivityActionViewItem {
     static { this.ACCOUNTS_VISIBILITY_PREFERENCE_KEY = 'workbench.activity.showAccounts'; }
     constructor(contextMenuActionsProvider, options, contextMenuAlignmentOptions, fillContextMenuActions, themeService, lifecycleService, hoverService, contextMenuService, menuService, contextKeyService, authenticationService, environmentService, productService, configurationService, keybindingService, secretStorageService, logService, activityService, instantiationService, commandService) {
         const action = instantiationService.createInstance(CompositeBarAction, {
             id: ACCOUNTS_ACTIVITY_ID,
-            name: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'accounts', "Accounts")),
+            name: ( localizeWithPath(_moduleId, 3, "Accounts")),
             classNames: ThemeIcon.asClassNameArray(GlobalCompositeBar.ACCOUNTS_ICON)
         });
         super(MenuId.AccountsContext, action, options, contextMenuActionsProvider, contextMenuAlignmentOptions, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService);
@@ -262,12 +258,12 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
         this.secretStorageService = secretStorageService;
         this.logService = logService;
         this.commandService = commandService;
-        this.groupedAccounts = ( new Map());
-        this.problematicProviders = ( new Set());
+        this.groupedAccounts = ( (new Map()));
+        this.problematicProviders = ( (new Set()));
         this.initialized = false;
-        this.sessionFromEmbedder = ( new Lazy(
+        this.sessionFromEmbedder = ( (new Lazy(
             () => getCurrentAuthenticationSessionInfo(this.secretStorageService, this.productService)
-        ));
+        )));
         this._register(action);
         this.registerListeners();
         this.initialize();
@@ -308,7 +304,7 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
     }
     async doInitialize() {
         const providerIds = this.authenticationService.getProviderIds();
-        const results = await Promise.allSettled(( providerIds.map(providerId => this.addAccountsFromProvider(providerId))));
+        const results = await Promise.allSettled(( (providerIds.map(providerId => this.addAccountsFromProvider(providerId)))));
         for (const result of results) {
             if (result.status === 'rejected') {
                 this.logService.error(result.reason);
@@ -323,20 +319,15 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
         let menus = [];
         for (const providerId of providers) {
             if (!this.initialized) {
-                const noAccountsAvailableAction = disposables.add(( new Action('noAccountsAvailable', ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'loading', "Loading...")), undefined, false)));
+                const noAccountsAvailableAction = disposables.add(( (new Action('noAccountsAvailable', ( localizeWithPath(_moduleId, 4, "Loading...")), undefined, false))));
                 menus.push(noAccountsAvailableAction);
                 break;
             }
             const providerLabel = this.authenticationService.getProvider(providerId).label;
             const accounts = this.groupedAccounts.get(providerId);
             if (!accounts) {
-                if (( this.problematicProviders.has(providerId))) {
-                    const providerUnavailableAction = disposables.add(( new Action('providerUnavailable', ( localizeWithPath(
-                        'vs/workbench/browser/parts/globalCompositeBar',
-                        'authProviderUnavailable',
-                        '{0} is currently unavailable',
-                        providerLabel
-                    )), undefined, false)));
+                if (( (this.problematicProviders.has(providerId)))) {
+                    const providerUnavailableAction = disposables.add(( (new Action('providerUnavailable', ( localizeWithPath(_moduleId, 5, '{0} is currently unavailable', providerLabel)), undefined, false))));
                     menus.push(providerUnavailableAction);
                     try {
                         await this.addAccountsFromProvider(providerId);
@@ -350,11 +341,7 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
             for (const account of accounts) {
                 const manageExtensionsAction = toAction({
                     id: `configureSessions${account.label}`,
-                    label: ( localizeWithPath(
-                        'vs/workbench/browser/parts/globalCompositeBar',
-                        'manageTrustedExtensions',
-                        "Manage Trusted Extensions"
-                    )),
+                    label: ( localizeWithPath(_moduleId, 6, "Manage Trusted Extensions")),
                     enabled: true,
                     run: () => this.commandService.executeCommand('_manageTrustedExtensionsForAccount', { providerId, accountLabel: account.label })
                 });
@@ -362,35 +349,31 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
                 if (account.canSignOut) {
                     providerSubMenuActions.push(toAction({
                         id: 'signOut',
-                        label: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'signOut', "Sign Out")),
+                        label: ( localizeWithPath(_moduleId, 7, "Sign Out")),
                         enabled: true,
                         run: () => this.commandService.executeCommand('_signOutOfAccount', { providerId, accountLabel: account.label })
                     }));
                 }
-                const providerSubMenu = ( new SubmenuAction(
+                const providerSubMenu = ( (new SubmenuAction(
                     'activitybar.submenu',
                     `${account.label} (${providerLabel})`,
                     providerSubMenuActions
-                ));
+                )));
                 menus.push(providerSubMenu);
             }
         }
         if (providers.length && !menus.length) {
-            const noAccountsAvailableAction = disposables.add(( new Action('noAccountsAvailable', ( localizeWithPath(
-                'vs/workbench/browser/parts/globalCompositeBar',
-                'noAccounts',
-                "You are not signed in to any accounts"
-            )), undefined, false)));
+            const noAccountsAvailableAction = disposables.add(( (new Action('noAccountsAvailable', ( localizeWithPath(_moduleId, 8, "You are not signed in to any accounts")), undefined, false))));
             menus.push(noAccountsAvailableAction);
         }
         if (menus.length && otherCommands.length) {
-            menus.push(( new Separator()));
+            menus.push(( (new Separator())));
         }
         otherCommands.forEach((group, i) => {
             const actions = group[1];
             menus = menus.concat(actions);
             if (i !== otherCommands.length - 1) {
-                menus.push(( new Separator()));
+                menus.push(( (new Separator())));
             }
         });
         return menus;
@@ -410,9 +393,9 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
         let canSignOut = true;
         if (sessionFromEmbedder
             && !sessionFromEmbedder.canSignOut
-            && ( (await this.authenticationService.getSessions(providerId))
+            && ( ((await this.authenticationService.getSessions(providerId))
                 .some(s => s.id === sessionFromEmbedder.id
-                && s.account.id === account.id))) {
+                && s.account.id === account.id)))) {
             canSignOut = false;
         }
         const existingAccount = accounts.find(a => a.label === account.label);
@@ -458,29 +441,29 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
         }
     }
 };
-AccountsActivityActionViewItem = ( __decorate([
-    ( __param(4, IThemeService)),
-    ( __param(5, ILifecycleService)),
-    ( __param(6, IHoverService)),
-    ( __param(7, IContextMenuService)),
-    ( __param(8, IMenuService)),
-    ( __param(9, IContextKeyService)),
-    ( __param(10, IAuthenticationService)),
-    ( __param(11, IWorkbenchEnvironmentService)),
-    ( __param(12, IProductService)),
-    ( __param(13, IConfigurationService)),
-    ( __param(14, IKeybindingService)),
-    ( __param(15, ISecretStorageService)),
-    ( __param(16, ILogService)),
-    ( __param(17, IActivityService)),
-    ( __param(18, IInstantiationService)),
-    ( __param(19, ICommandService))
-], AccountsActivityActionViewItem));
+AccountsActivityActionViewItem = ( (__decorate([
+    ( (__param(4, IThemeService))),
+    ( (__param(5, ILifecycleService))),
+    ( (__param(6, IHoverService))),
+    ( (__param(7, IContextMenuService))),
+    ( (__param(8, IMenuService))),
+    ( (__param(9, IContextKeyService))),
+    ( (__param(10, IAuthenticationService))),
+    ( (__param(11, IWorkbenchEnvironmentService))),
+    ( (__param(12, IProductService))),
+    ( (__param(13, IConfigurationService))),
+    ( (__param(14, IKeybindingService))),
+    ( (__param(15, ISecretStorageService))),
+    ( (__param(16, ILogService))),
+    ( (__param(17, IActivityService))),
+    ( (__param(18, IInstantiationService))),
+    ( (__param(19, ICommandService)))
+], AccountsActivityActionViewItem)));
 let GlobalActivityActionViewItem = class GlobalActivityActionViewItem extends AbstractGlobalActivityActionViewItem {
     constructor(contextMenuActionsProvider, options, contextMenuAlignmentOptions, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService) {
         const action = instantiationService.createInstance(CompositeBarAction, {
             id: GLOBAL_ACTIVITY_ID,
-            name: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'manage', "Manage")),
+            name: ( localizeWithPath(_moduleId, 2, "Manage")),
             classNames: ThemeIcon.asClassNameArray(userDataProfileService.currentProfile.icon ? ThemeIcon.fromId(userDataProfileService.currentProfile.icon) : DEFAULT_ICON)
         });
         super(MenuId.GlobalActivity, action, options, contextMenuActionsProvider, contextMenuAlignmentOptions, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService);
@@ -525,29 +508,29 @@ let GlobalActivityActionViewItem = class GlobalActivityActionViewItem extends Ab
     }
     computeTitle() {
         return this.userDataProfileService.currentProfile.isDefault ? super.computeTitle() : ( localizeWithPath(
-            'vs/workbench/browser/parts/globalCompositeBar',
-            'manage profile',
+            _moduleId,
+            9,
             "Manage {0} (Profile)",
             this.userDataProfileService.currentProfile.name
         ));
     }
 };
-GlobalActivityActionViewItem = ( __decorate([
-    ( __param(3, IUserDataProfileService)),
-    ( __param(4, IThemeService)),
-    ( __param(5, IHoverService)),
-    ( __param(6, IMenuService)),
-    ( __param(7, IContextMenuService)),
-    ( __param(8, IContextKeyService)),
-    ( __param(9, IConfigurationService)),
-    ( __param(10, IWorkbenchEnvironmentService)),
-    ( __param(11, IKeybindingService)),
-    ( __param(12, IInstantiationService)),
-    ( __param(13, IActivityService))
-], GlobalActivityActionViewItem));
+GlobalActivityActionViewItem = ( (__decorate([
+    ( (__param(3, IUserDataProfileService))),
+    ( (__param(4, IThemeService))),
+    ( (__param(5, IHoverService))),
+    ( (__param(6, IMenuService))),
+    ( (__param(7, IContextMenuService))),
+    ( (__param(8, IContextKeyService))),
+    ( (__param(9, IConfigurationService))),
+    ( (__param(10, IWorkbenchEnvironmentService))),
+    ( (__param(11, IKeybindingService))),
+    ( (__param(12, IInstantiationService))),
+    ( (__param(13, IActivityService)))
+], GlobalActivityActionViewItem)));
 let SimpleAccountActivityActionViewItem = class SimpleAccountActivityActionViewItem extends AccountsActivityActionViewItem {
-    constructor(hoverOptions, options, themeService, lifecycleService, hoverService, contextMenuService, menuService, contextKeyService, authenticationService, environmentService, productService, configurationService, keybindingService, secretStorageService, logService, activityService, instantiationService, commandService) {
-        super(() => [], {
+    constructor(hoverOptions, options, themeService, lifecycleService, hoverService, contextMenuService, menuService, contextKeyService, authenticationService, environmentService, productService, configurationService, keybindingService, secretStorageService, storageService, logService, activityService, instantiationService, commandService) {
+        super(() => simpleActivityContextMenuActions(storageService, true), {
             ...options,
             colors: theme => ({
                 badgeBackground: theme.getColor(ACTIVITY_BAR_BADGE_BACKGROUND),
@@ -558,27 +541,28 @@ let SimpleAccountActivityActionViewItem = class SimpleAccountActivityActionViewI
         }, () => undefined, actions => actions, themeService, lifecycleService, hoverService, contextMenuService, menuService, contextKeyService, authenticationService, environmentService, productService, configurationService, keybindingService, secretStorageService, logService, activityService, instantiationService, commandService);
     }
 };
-SimpleAccountActivityActionViewItem = ( __decorate([
-    ( __param(2, IThemeService)),
-    ( __param(3, ILifecycleService)),
-    ( __param(4, IHoverService)),
-    ( __param(5, IContextMenuService)),
-    ( __param(6, IMenuService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, IAuthenticationService)),
-    ( __param(9, IWorkbenchEnvironmentService)),
-    ( __param(10, IProductService)),
-    ( __param(11, IConfigurationService)),
-    ( __param(12, IKeybindingService)),
-    ( __param(13, ISecretStorageService)),
-    ( __param(14, ILogService)),
-    ( __param(15, IActivityService)),
-    ( __param(16, IInstantiationService)),
-    ( __param(17, ICommandService))
-], SimpleAccountActivityActionViewItem));
+SimpleAccountActivityActionViewItem = ( (__decorate([
+    ( (__param(2, IThemeService))),
+    ( (__param(3, ILifecycleService))),
+    ( (__param(4, IHoverService))),
+    ( (__param(5, IContextMenuService))),
+    ( (__param(6, IMenuService))),
+    ( (__param(7, IContextKeyService))),
+    ( (__param(8, IAuthenticationService))),
+    ( (__param(9, IWorkbenchEnvironmentService))),
+    ( (__param(10, IProductService))),
+    ( (__param(11, IConfigurationService))),
+    ( (__param(12, IKeybindingService))),
+    ( (__param(13, ISecretStorageService))),
+    ( (__param(14, IStorageService))),
+    ( (__param(15, ILogService))),
+    ( (__param(16, IActivityService))),
+    ( (__param(17, IInstantiationService))),
+    ( (__param(18, ICommandService)))
+], SimpleAccountActivityActionViewItem)));
 let SimpleGlobalActivityActionViewItem = class SimpleGlobalActivityActionViewItem extends GlobalActivityActionViewItem {
-    constructor(hoverOptions, options, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService) {
-        super(() => [], {
+    constructor(hoverOptions, options, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService, storageService) {
+        super(() => simpleActivityContextMenuActions(storageService, false), {
             ...options,
             colors: theme => ({
                 badgeBackground: theme.getColor(ACTIVITY_BAR_BADGE_BACKGROUND),
@@ -589,17 +573,35 @@ let SimpleGlobalActivityActionViewItem = class SimpleGlobalActivityActionViewIte
         }, () => undefined, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService);
     }
 };
-SimpleGlobalActivityActionViewItem = ( __decorate([
-    ( __param(2, IUserDataProfileService)),
-    ( __param(3, IThemeService)),
-    ( __param(4, IHoverService)),
-    ( __param(5, IMenuService)),
-    ( __param(6, IContextMenuService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, IConfigurationService)),
-    ( __param(9, IWorkbenchEnvironmentService)),
-    ( __param(10, IKeybindingService)),
-    ( __param(11, IInstantiationService)),
-    ( __param(12, IActivityService))
-], SimpleGlobalActivityActionViewItem));
-export { AccountsActivityActionViewItem, GlobalActivityActionViewItem, GlobalCompositeBar, SimpleAccountActivityActionViewItem, SimpleGlobalActivityActionViewItem };
+SimpleGlobalActivityActionViewItem = ( (__decorate([
+    ( (__param(2, IUserDataProfileService))),
+    ( (__param(3, IThemeService))),
+    ( (__param(4, IHoverService))),
+    ( (__param(5, IMenuService))),
+    ( (__param(6, IContextMenuService))),
+    ( (__param(7, IContextKeyService))),
+    ( (__param(8, IConfigurationService))),
+    ( (__param(9, IWorkbenchEnvironmentService))),
+    ( (__param(10, IKeybindingService))),
+    ( (__param(11, IInstantiationService))),
+    ( (__param(12, IActivityService))),
+    ( (__param(13, IStorageService)))
+], SimpleGlobalActivityActionViewItem)));
+function simpleActivityContextMenuActions(storageService, isAccount) {
+    const currentElementContextMenuActions = [];
+    if (isAccount) {
+        currentElementContextMenuActions.push(toAction({ id: 'hideAccounts', label: ( localizeWithPath(_moduleId, 1, "Hide Accounts")), run: () => setAccountsActionVisible(storageService, false) }), ( (new Separator())));
+    }
+    return [
+        ...currentElementContextMenuActions,
+        toAction({ id: 'toggle.hideAccounts', label: ( localizeWithPath(_moduleId, 3, "Accounts")), checked: isAccountsActionVisible(storageService), run: () => setAccountsActionVisible(storageService, !isAccountsActionVisible(storageService)) }),
+        toAction({ id: 'toggle.hideManage', label: ( localizeWithPath(_moduleId, 2, "Manage")), checked: true, enabled: false, run: () => { throw ( (new Error('"Manage" can not be hidden'))); } })
+    ];
+}
+function isAccountsActionVisible(storageService) {
+    return storageService.getBoolean(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, 0 , true);
+}
+function setAccountsActionVisible(storageService, visible) {
+    storageService.store(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, visible, 0 , 0 );
+}
+export { AccountsActivityActionViewItem, GlobalActivityActionViewItem, GlobalCompositeBar, SimpleAccountActivityActionViewItem, SimpleGlobalActivityActionViewItem, isAccountsActionVisible };