@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

package/dist/vscode/vs/workbench/browser/parts/activitybar/activitybarPart.js

@@ -0,0 +1,784 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/activitybarpart.css";
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { GLOBAL_ACTIVITY_ID, ACCOUNTS_ACTIVITY_ID } from '../../../common/activity.js';
+import { Part } from '../../part.js';
+import { GlobalActivityActionViewItem, AccountsActivityActionViewItem, ViewContainerActivityAction, PlaceHolderViewContainerActivityAction, PlaceHolderToggleCompositePinnedAction, PlaceHolderToggleCompositeBadgeAction } from './activitybarActions.js';
+import { NumberBadge } from '../../../services/activity/common/activity.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { DisposableStore, Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ToggleSidebarPositionAction, ToggleActivityBarVisibilityAction } from '../../actions/layoutActions.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ACTIVITY_BAR_BACKGROUND, ACTIVITY_BAR_BORDER, ACTIVITY_BAR_FOREGROUND, ACTIVITY_BAR_INACTIVE_FOREGROUND, ACTIVITY_BAR_ACTIVE_BORDER, ACTIVITY_BAR_ACTIVE_BACKGROUND, ACTIVITY_BAR_BADGE_BACKGROUND, ACTIVITY_BAR_BADGE_FOREGROUND, ACTIVITY_BAR_DRAG_AND_DROP_BORDER } from '../../../common/theme.js';
+import { contrastBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { CompositeBar, CompositeDragAndDrop } from '../compositeBar.js';
+import { isAncestor, addDisposableListener, EventType, asCSSUrl, createCSSRule, Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ActivityAction, ToggleCompositePinnedAction, ToggleCompositeBadgeAction } from '../compositeBarActions.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { getEnabledViewContainerContextKey } from '../../../common/contextkeys.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { assertIsDefined, isString } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { CustomMenubarControl } from '../titlebar/menubarControl.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { getMenuBarVisibility } from '../../../../platform/window/common/window.js';
+import { isNative } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { toAction, Separator } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { StringSHA1 } from 'monaco-editor/esm/vs/base/common/hash.js';
+let ActivitybarPart = class ActivitybarPart extends Part {
+    constructor(paneCompositePart, instantiationService, layoutService, themeService, storageService, extensionService, viewDescriptorService, contextKeyService, configurationService, environmentService) {
+        super("workbench.parts.activitybar" , { hasTitle: false }, themeService, storageService, layoutService);
+        this.paneCompositePart = paneCompositePart;
+        this.instantiationService = instantiationService;
+        this.storageService = storageService;
+        this.extensionService = extensionService;
+        this.viewDescriptorService = viewDescriptorService;
+        this.contextKeyService = contextKeyService;
+        this.configurationService = configurationService;
+        this.environmentService = environmentService;
+        this.minimumWidth = 48;
+        this.maximumWidth = 48;
+        this.minimumHeight = 0;
+        this.maximumHeight = Number.POSITIVE_INFINITY;
+        this.globalActivity = [];
+        this.accountsActivity = [];
+        this.compositeActions = ( new Map());
+        this.viewContainerDisposables = ( new Map());
+        this.keyboardNavigationDisposables = this._register(( new DisposableStore()));
+        this.location = 0 ;
+        this.hasExtensionsRegistered = false;
+        this.enabledViewContainersContextKeys = ( new Map());
+        this._cachedViewContainers = undefined;
+        for (const cachedViewContainer of this.cachedViewContainers) {
+            cachedViewContainer.visible = !this.shouldBeHidden(cachedViewContainer.id, cachedViewContainer);
+        }
+        this.compositeBar = this.createCompositeBar();
+        this.onDidRegisterViewContainers(this.getViewContainers());
+        this.registerListeners();
+    }
+    createCompositeBar() {
+        const cachedItems = ( this.cachedViewContainers
+            .map(container => ({
+            id: container.id,
+            name: container.name,
+            visible: container.visible,
+            order: container.order,
+            pinned: container.pinned,
+        })));
+        return this._register(this.instantiationService.createInstance(CompositeBar, cachedItems, {
+            icon: true,
+            orientation: 1 ,
+            activityHoverOptions: this.getActivityHoverOptions(),
+            preventLoopNavigation: true,
+            openComposite: async (compositeId, preserveFocus) => {
+                return (await this.paneCompositePart.openPaneComposite(compositeId, !preserveFocus)) ?? null;
+            },
+            getActivityAction: compositeId => this.getCompositeActions(compositeId).activityAction,
+            getCompositePinnedAction: compositeId => this.getCompositeActions(compositeId).pinnedAction,
+            getCompositeBadgeAction: compositeId => this.getCompositeActions(compositeId).badgeAction,
+            getOnCompositeClickAction: compositeId => toAction({ id: compositeId, label: '', run: async () => this.paneCompositePart.getActivePaneComposite()?.getId() === compositeId ? this.paneCompositePart.hideActivePaneComposite() : this.paneCompositePart.openPaneComposite(compositeId) }),
+            fillExtraContextMenuActions: (actions, e) => {
+                const menuBarVisibility = getMenuBarVisibility(this.configurationService);
+                if (menuBarVisibility === 'compact' || menuBarVisibility === 'hidden' || menuBarVisibility === 'toggle') {
+                    actions.unshift(...[toAction({ id: 'toggleMenuVisibility', label: ( localize('menu', "Menu")), checked: menuBarVisibility === 'compact', run: () => this.configurationService.updateValue('window.menuBarVisibility', menuBarVisibility === 'compact' ? 'toggle' : 'compact') }), ( new Separator())]);
+                }
+                if (menuBarVisibility === 'compact' && this.menuBarContainer && e?.target) {
+                    if (isAncestor(e.target, this.menuBarContainer)) {
+                        actions.unshift(...[toAction({ id: 'hideCompactMenu', label: ( localize('hideMenu', "Hide Menu")), run: () => this.configurationService.updateValue('window.menuBarVisibility', 'toggle') }), ( new Separator())]);
+                    }
+                }
+                actions.push(( new Separator()));
+                actions.push(toAction({ id: 'toggleAccountsVisibility', label: ( localize('accounts', "Accounts")), checked: this.accountsVisibilityPreference, run: () => this.accountsVisibilityPreference = !this.accountsVisibilityPreference }));
+                actions.push(( new Separator()));
+                actions.push(toAction({ id: ToggleSidebarPositionAction.ID, label: ToggleSidebarPositionAction.getLabel(this.layoutService), run: () => this.instantiationService.invokeFunction(accessor => ( new ToggleSidebarPositionAction()).run(accessor)) }));
+                actions.push(toAction({ id: ToggleActivityBarVisibilityAction.ID, label: ( localize('hideActivitBar', "Hide Activity Bar")), run: () => this.instantiationService.invokeFunction(accessor => ( new ToggleActivityBarVisibilityAction()).run(accessor)) }));
+            },
+            getContextMenuActionsForComposite: compositeId => this.getContextMenuActionsForComposite(compositeId),
+            getDefaultCompositeId: () => this.viewDescriptorService.getDefaultViewContainer(this.location)?.id,
+            hidePart: () => this.layoutService.setPartHidden(true, "workbench.parts.sidebar" ),
+            dndHandler: ( new CompositeDragAndDrop(
+                this.viewDescriptorService,
+                0 ,
+                async (id, focus) => { return (await this.paneCompositePart.openPaneComposite(id, focus)) ?? null; },
+                (from, to, before) => this.compositeBar.move(from, to, before?.verticallyBefore),
+                () => this.compositeBar.getCompositeBarItems()
+            )),
+            compositeSize: 52,
+            colors: (theme) => this.getActivitybarItemColors(theme),
+            overflowActionSize: ActivitybarPart.ACTION_HEIGHT
+        }));
+    }
+    getActivityHoverOptions() {
+        return {
+            position: () => this.layoutService.getSideBarPosition() === 0  ? 1  : 0 ,
+        };
+    }
+    getContextMenuActionsForComposite(compositeId) {
+        const actions = [];
+        const viewContainer = this.viewDescriptorService.getViewContainerById(compositeId);
+        const defaultLocation = this.viewDescriptorService.getDefaultViewContainerLocation(viewContainer);
+        if (defaultLocation !== this.viewDescriptorService.getViewContainerLocation(viewContainer)) {
+            actions.push(toAction({ id: 'resetLocationAction', label: ( localize('resetLocation', "Reset Location")), run: () => this.viewDescriptorService.moveViewContainerToLocation(viewContainer, defaultLocation) }));
+        }
+        else {
+            const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
+            if (viewContainerModel.allViewDescriptors.length === 1) {
+                const viewToReset = viewContainerModel.allViewDescriptors[0];
+                const defaultContainer = this.viewDescriptorService.getDefaultContainerById(viewToReset.id);
+                if (defaultContainer !== viewContainer) {
+                    actions.push(toAction({ id: 'resetLocationAction', label: ( localize('resetLocation', "Reset Location")), run: () => this.viewDescriptorService.moveViewsToContainer([viewToReset], defaultContainer) }));
+                }
+            }
+        }
+        return actions;
+    }
+    registerListeners() {
+        this._register(this.viewDescriptorService.onDidChangeViewContainers(({ added, removed }) => this.onDidChangeViewContainers(added, removed)));
+        this._register(this.viewDescriptorService.onDidChangeContainerLocation(({ viewContainer, from, to }) => this.onDidChangeViewContainerLocation(viewContainer, from, to)));
+        this.paneCompositePart.onDidPaneCompositeOpen(e => this.onDidChangeViewContainerVisibility(e.getId(), true));
+        this.paneCompositePart.onDidPaneCompositeClose(e => this.onDidChangeViewContainerVisibility(e.getId(), false));
+        const disposables = this._register(( new DisposableStore()));
+        this._register(this.extensionService.onDidRegisterExtensions(() => {
+            disposables.clear();
+            this.onDidRegisterExtensions();
+            this.compositeBar.onDidChange(() => this.saveCachedViewContainers(), this, disposables);
+            this.storageService.onDidChangeValue(e => this.onDidStorageValueChange(e), this, disposables);
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('window.menuBarVisibility')) {
+                if (getMenuBarVisibility(this.configurationService) === 'compact') {
+                    this.installMenubar();
+                }
+                else {
+                    this.uninstallMenubar();
+                }
+            }
+        }));
+    }
+    onDidChangeViewContainers(added, removed) {
+        removed.filter(({ location }) => location === 0 ).forEach(({ container }) => this.onDidDeregisterViewContainer(container));
+        this.onDidRegisterViewContainers(( added.filter(({ location }) => location === 0 ).map(({ container }) => container)));
+    }
+    onDidChangeViewContainerLocation(container, from, to) {
+        if (from === this.location) {
+            this.onDidDeregisterViewContainer(container);
+        }
+        if (to === this.location) {
+            this.onDidRegisterViewContainers([container]);
+        }
+    }
+    onDidChangeViewContainerVisibility(id, visible) {
+        if (visible) {
+            this.onDidViewContainerVisible(id);
+        }
+        else {
+            this.compositeBar.deactivateComposite(id);
+        }
+    }
+    onDidRegisterExtensions() {
+        this.hasExtensionsRegistered = true;
+        for (const { id } of this.cachedViewContainers) {
+            const viewContainer = this.getViewContainer(id);
+            if (viewContainer) {
+                this.showOrHideViewContainer(viewContainer);
+            }
+            else {
+                if (this.viewDescriptorService.isViewContainerRemovedPermanently(id)) {
+                    this.removeComposite(id);
+                }
+                else {
+                    this.hideComposite(id);
+                }
+            }
+        }
+        this.saveCachedViewContainers();
+    }
+    onDidViewContainerVisible(id) {
+        const viewContainer = this.getViewContainer(id);
+        if (viewContainer) {
+            this.addComposite(viewContainer);
+            this.compositeBar.activateComposite(viewContainer.id);
+            if (this.shouldBeHidden(viewContainer)) {
+                const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
+                if (viewContainerModel.activeViewDescriptors.length === 0) {
+                    this.hideComposite(viewContainer.id);
+                }
+            }
+        }
+    }
+    showActivity(viewContainerOrActionId, badge, clazz, priority) {
+        if (this.getViewContainer(viewContainerOrActionId)) {
+            return this.compositeBar.showActivity(viewContainerOrActionId, badge, clazz, priority);
+        }
+        if (viewContainerOrActionId === GLOBAL_ACTIVITY_ID) {
+            return this.showGlobalActivity(GLOBAL_ACTIVITY_ID, badge, clazz, priority);
+        }
+        if (viewContainerOrActionId === ACCOUNTS_ACTIVITY_ID) {
+            return this.showGlobalActivity(ACCOUNTS_ACTIVITY_ID, badge, clazz, priority);
+        }
+        return Disposable.None;
+    }
+    showGlobalActivity(activityId, badge, clazz, priority) {
+        if (typeof priority !== 'number') {
+            priority = 0;
+        }
+        const activity = { badge, clazz, priority };
+        const activityCache = activityId === GLOBAL_ACTIVITY_ID ? this.globalActivity : this.accountsActivity;
+        for (let i = 0; i <= activityCache.length; i++) {
+            if (i === activityCache.length) {
+                activityCache.push(activity);
+                break;
+            }
+            else if (activityCache[i].priority <= priority) {
+                activityCache.splice(i, 0, activity);
+                break;
+            }
+        }
+        this.updateGlobalActivity(activityId);
+        return toDisposable(() => this.removeGlobalActivity(activityId, activity));
+    }
+    removeGlobalActivity(activityId, activity) {
+        const activityCache = activityId === GLOBAL_ACTIVITY_ID ? this.globalActivity : this.accountsActivity;
+        const index = activityCache.indexOf(activity);
+        if (index !== -1) {
+            activityCache.splice(index, 1);
+            this.updateGlobalActivity(activityId);
+        }
+    }
+    updateGlobalActivity(activityId) {
+        const activityAction = activityId === GLOBAL_ACTIVITY_ID ? this.globalActivityAction : this.accountsActivityAction;
+        if (!activityAction) {
+            return;
+        }
+        const activityCache = activityId === GLOBAL_ACTIVITY_ID ? this.globalActivity : this.accountsActivity;
+        if (activityCache.length) {
+            const [{ badge, clazz, priority }] = activityCache;
+            if (badge instanceof NumberBadge && activityCache.length > 1) {
+                const cumulativeNumberBadge = this.getCumulativeNumberBadge(activityCache, priority);
+                activityAction.setBadge(cumulativeNumberBadge);
+            }
+            else {
+                activityAction.setBadge(badge, clazz);
+            }
+        }
+        else {
+            activityAction.setBadge(undefined);
+        }
+    }
+    getCumulativeNumberBadge(activityCache, priority) {
+        const numberActivities = activityCache.filter(activity => activity.badge instanceof NumberBadge && activity.priority === priority);
+        const number = numberActivities.reduce((result, activity) => { return result + activity.badge.number; }, 0);
+        const descriptorFn = () => {
+            return numberActivities.reduce((result, activity, index) => {
+                result = result + activity.badge.getDescription();
+                if (index < numberActivities.length - 1) {
+                    result = `${result}\n`;
+                }
+                return result;
+            }, '');
+        };
+        return ( new NumberBadge(number, descriptorFn));
+    }
+    uninstallMenubar() {
+        if (this.menuBar) {
+            this.menuBar.dispose();
+            this.menuBar = undefined;
+        }
+        if (this.menuBarContainer) {
+            this.menuBarContainer.remove();
+            this.menuBarContainer = undefined;
+            this.registerKeyboardNavigationListeners();
+        }
+    }
+    installMenubar() {
+        if (this.menuBar) {
+            return;
+        }
+        this.menuBarContainer = document.createElement('div');
+        this.menuBarContainer.classList.add('menubar');
+        const content = assertIsDefined(this.content);
+        content.prepend(this.menuBarContainer);
+        this.menuBar = this._register(this.instantiationService.createInstance(CustomMenubarControl));
+        this.menuBar.create(this.menuBarContainer);
+        this.registerKeyboardNavigationListeners();
+    }
+    createContentArea(parent) {
+        this.element = parent;
+        this.content = document.createElement('div');
+        this.content.classList.add('content');
+        parent.appendChild(this.content);
+        if (getMenuBarVisibility(this.configurationService) === 'compact') {
+            this.installMenubar();
+        }
+        this.compositeBarContainer = this.compositeBar.create(this.content);
+        this.globalActivitiesContainer = document.createElement('div');
+        this.content.appendChild(this.globalActivitiesContainer);
+        this.registerKeyboardNavigationListeners();
+        return this.content;
+    }
+    registerKeyboardNavigationListeners() {
+        this.keyboardNavigationDisposables.clear();
+        if (this.menuBarContainer) {
+            this.keyboardNavigationDisposables.add(addDisposableListener(this.menuBarContainer, EventType.KEY_DOWN, e => {
+                const kbEvent = ( new StandardKeyboardEvent(e));
+                if (kbEvent.equals(18 ) || kbEvent.equals(17 )) {
+                    this.compositeBar?.focus();
+                }
+            }));
+        }
+        if (this.compositeBarContainer) {
+            this.keyboardNavigationDisposables.add(addDisposableListener(this.compositeBarContainer, EventType.KEY_DOWN, e => {
+                const kbEvent = ( new StandardKeyboardEvent(e));
+                if (kbEvent.equals(18 ) || kbEvent.equals(17 )) {
+                    this.globalActivityActionBar?.focus(true);
+                }
+                else if (kbEvent.equals(16 ) || kbEvent.equals(15 )) {
+                    this.menuBar?.toggleFocus();
+                }
+            }));
+        }
+        if (this.globalActivitiesContainer) {
+            this.keyboardNavigationDisposables.add(addDisposableListener(this.globalActivitiesContainer, EventType.KEY_DOWN, e => {
+                const kbEvent = ( new StandardKeyboardEvent(e));
+                if (kbEvent.equals(16 ) || kbEvent.equals(15 )) {
+                    this.compositeBar?.focus(this.getVisiblePaneCompositeIds().length - 1);
+                }
+            }));
+        }
+    }
+    createGlobalActivityActionBar(container) {
+        this.globalActivityActionBar = this._register(( new ActionBar(container, {
+            actionViewItemProvider: action => {
+                if (action.id === 'workbench.actions.manage') {
+                    return this.instantiationService.createInstance(GlobalActivityActionViewItem, action, () => this.compositeBar.getContextMenuActions(), (theme) => this.getActivitybarItemColors(theme), this.getActivityHoverOptions());
+                }
+                if (action.id === 'workbench.actions.accounts') {
+                    return this.instantiationService.createInstance(AccountsActivityActionViewItem, action, () => this.compositeBar.getContextMenuActions(), (theme) => this.getActivitybarItemColors(theme), this.getActivityHoverOptions());
+                }
+                throw new Error(`No view item for action '${action.id}'`);
+            },
+            orientation: 1 ,
+            ariaLabel: ( localize('manage', "Manage")),
+            animated: false,
+            preventLoopNavigation: true
+        })));
+        this.globalActivityAction = this._register(( new ActivityAction({
+            id: 'workbench.actions.manage',
+            name: ( localize('manage', "Manage")),
+            classNames: ThemeIcon.asClassNameArray(ActivitybarPart.GEAR_ICON),
+        })));
+        if (this.accountsVisibilityPreference) {
+            this.accountsActivityAction = this._register(( new ActivityAction({
+                id: 'workbench.actions.accounts',
+                name: ( localize('accounts', "Accounts")),
+                classNames: ThemeIcon.asClassNameArray(ActivitybarPart.ACCOUNTS_ICON)
+            })));
+            this.globalActivityActionBar.push(this.accountsActivityAction, { index: ActivitybarPart.ACCOUNTS_ACTION_INDEX });
+        }
+        this.globalActivityActionBar.push(this.globalActivityAction);
+    }
+    toggleAccountsActivity() {
+        if (!!this.accountsActivityAction === this.accountsVisibilityPreference) {
+            return;
+        }
+        if (this.globalActivityActionBar) {
+            if (this.accountsActivityAction) {
+                this.globalActivityActionBar.pull(ActivitybarPart.ACCOUNTS_ACTION_INDEX);
+                this.accountsActivityAction = undefined;
+            }
+            else {
+                this.accountsActivityAction = this._register(( new ActivityAction({
+                    id: 'workbench.actions.accounts',
+                    name: ( localize('accounts', "Accounts")),
+                    classNames: ThemeIcon.asClassNameArray(Codicon.account)
+                })));
+                this.globalActivityActionBar.push(this.accountsActivityAction, { index: ActivitybarPart.ACCOUNTS_ACTION_INDEX });
+            }
+        }
+        this.updateGlobalActivity(ACCOUNTS_ACTIVITY_ID);
+    }
+    getCompositeActions(compositeId) {
+        let compositeActions = this.compositeActions.get(compositeId);
+        if (!compositeActions) {
+            const viewContainer = this.getViewContainer(compositeId);
+            if (viewContainer) {
+                const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
+                compositeActions = {
+                    activityAction: this.instantiationService.createInstance(ViewContainerActivityAction, this.toActivity(viewContainerModel), this.paneCompositePart),
+                    pinnedAction: ( new ToggleCompositePinnedAction(this.toActivity(viewContainerModel), this.compositeBar)),
+                    badgeAction: ( new ToggleCompositeBadgeAction(this.toActivity(viewContainerModel), this.compositeBar))
+                };
+            }
+            else {
+                const cachedComposite = this.cachedViewContainers.filter(c => c.id === compositeId)[0];
+                compositeActions = {
+                    activityAction: this.instantiationService.createInstance(PlaceHolderViewContainerActivityAction, ActivitybarPart.toActivity(compositeId, compositeId, cachedComposite?.icon, undefined), this.paneCompositePart),
+                    pinnedAction: ( new PlaceHolderToggleCompositePinnedAction(compositeId, this.compositeBar)),
+                    badgeAction: ( new PlaceHolderToggleCompositeBadgeAction(compositeId, this.compositeBar))
+                };
+            }
+            this.compositeActions.set(compositeId, compositeActions);
+        }
+        return compositeActions;
+    }
+    onDidRegisterViewContainers(viewContainers) {
+        for (const viewContainer of viewContainers) {
+            this.addComposite(viewContainer);
+            const cachedViewContainer = this.cachedViewContainers.filter(({ id }) => id === viewContainer.id)[0];
+            if (!cachedViewContainer) {
+                this.compositeBar.pin(viewContainer.id);
+            }
+            const visibleViewContainer = this.paneCompositePart.getActivePaneComposite();
+            if (visibleViewContainer?.getId() === viewContainer.id) {
+                this.compositeBar.activateComposite(viewContainer.id);
+            }
+            const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
+            this.updateActivity(viewContainer, viewContainerModel);
+            this.showOrHideViewContainer(viewContainer);
+            const disposables = ( new DisposableStore());
+            disposables.add(viewContainerModel.onDidChangeContainerInfo(() => this.updateActivity(viewContainer, viewContainerModel)));
+            disposables.add(viewContainerModel.onDidChangeActiveViewDescriptors(() => this.showOrHideViewContainer(viewContainer)));
+            this.viewContainerDisposables.set(viewContainer.id, disposables);
+        }
+    }
+    onDidDeregisterViewContainer(viewContainer) {
+        const disposable = this.viewContainerDisposables.get(viewContainer.id);
+        disposable?.dispose();
+        this.viewContainerDisposables.delete(viewContainer.id);
+        this.removeComposite(viewContainer.id);
+    }
+    updateActivity(viewContainer, viewContainerModel) {
+        const activity = this.toActivity(viewContainerModel);
+        const { activityAction, pinnedAction } = this.getCompositeActions(viewContainer.id);
+        activityAction.updateActivity(activity);
+        if (pinnedAction instanceof PlaceHolderToggleCompositePinnedAction) {
+            pinnedAction.setActivity(activity);
+        }
+        this.saveCachedViewContainers();
+    }
+    toActivity(viewContainerModel) {
+        return ActivitybarPart.toActivity(viewContainerModel.viewContainer.id, viewContainerModel.title, viewContainerModel.icon, viewContainerModel.keybindingId);
+    }
+    static toActivity(id, name, icon, keybindingId) {
+        let classNames = undefined;
+        let iconUrl = undefined;
+        if (URI.isUri(icon)) {
+            iconUrl = icon;
+            const cssUrl = asCSSUrl(icon);
+            const hash = ( new StringSHA1());
+            hash.update(cssUrl);
+            const iconId = `activity-${id.replace(/\./g, '-')}-${hash.digest()}`;
+            const iconClass = `.monaco-workbench .activitybar .monaco-action-bar .action-label.${iconId}`;
+            classNames = [iconId, 'uri-icon'];
+            createCSSRule(iconClass, `
+				mask: ${cssUrl} no-repeat 50% 50%;
+				mask-size: 24px;
+				-webkit-mask: ${cssUrl} no-repeat 50% 50%;
+				-webkit-mask-size: 24px;
+			`);
+        }
+        else if (ThemeIcon.isThemeIcon(icon)) {
+            classNames = ThemeIcon.asClassNameArray(icon);
+        }
+        return { id, name, classNames, iconUrl, keybindingId };
+    }
+    showOrHideViewContainer(viewContainer) {
+        let contextKey = this.enabledViewContainersContextKeys.get(viewContainer.id);
+        if (!contextKey) {
+            contextKey = this.contextKeyService.createKey(getEnabledViewContainerContextKey(viewContainer.id), false);
+            this.enabledViewContainersContextKeys.set(viewContainer.id, contextKey);
+        }
+        if (this.shouldBeHidden(viewContainer)) {
+            contextKey.set(false);
+            this.hideComposite(viewContainer.id);
+        }
+        else {
+            contextKey.set(true);
+            this.addComposite(viewContainer);
+        }
+    }
+    shouldBeHidden(viewContainerOrId, cachedViewContainer) {
+        const viewContainer = isString(viewContainerOrId) ? this.getViewContainer(viewContainerOrId) : viewContainerOrId;
+        const viewContainerId = isString(viewContainerOrId) ? viewContainerOrId : viewContainerOrId.id;
+        if (viewContainer) {
+            if (viewContainer.hideIfEmpty) {
+                if (this.viewDescriptorService.getViewContainerModel(viewContainer).activeViewDescriptors.length > 0) {
+                    return false;
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        if (!this.hasExtensionsRegistered && !(this.environmentService.remoteAuthority && isNative)) {
+            cachedViewContainer = cachedViewContainer || this.cachedViewContainers.find(({ id }) => id === viewContainerId);
+            if (!viewContainer && cachedViewContainer?.isBuiltin && cachedViewContainer?.visible) {
+                return false;
+            }
+            if (cachedViewContainer?.views?.length) {
+                return cachedViewContainer.views.every(({ when }) => !!when && !this.contextKeyService.contextMatchesRules(ContextKeyExpr.deserialize(when)));
+            }
+        }
+        return true;
+    }
+    addComposite(viewContainer) {
+        this.compositeBar.addComposite({ id: viewContainer.id, name: typeof viewContainer.title === 'string' ? viewContainer.title : viewContainer.title.value, order: viewContainer.order, requestedIndex: viewContainer.requestedIndex });
+    }
+    hideComposite(compositeId) {
+        this.compositeBar.hideComposite(compositeId);
+        const compositeActions = this.compositeActions.get(compositeId);
+        if (compositeActions) {
+            compositeActions.activityAction.dispose();
+            compositeActions.pinnedAction.dispose();
+            this.compositeActions.delete(compositeId);
+        }
+    }
+    removeComposite(compositeId) {
+        this.compositeBar.removeComposite(compositeId);
+        const compositeActions = this.compositeActions.get(compositeId);
+        if (compositeActions) {
+            compositeActions.activityAction.dispose();
+            compositeActions.pinnedAction.dispose();
+            this.compositeActions.delete(compositeId);
+        }
+    }
+    getPinnedPaneCompositeIds() {
+        const pinnedCompositeIds = ( this.compositeBar.getPinnedComposites().map(v => v.id));
+        return ( this.getViewContainers()
+            .filter(v => this.compositeBar.isPinned(v.id))
+            .sort((v1, v2) => pinnedCompositeIds.indexOf(v1.id) - pinnedCompositeIds.indexOf(v2.id))
+            .map(v => v.id));
+    }
+    getVisiblePaneCompositeIds() {
+        return ( this.compositeBar.getVisibleComposites()
+            .filter(v => this.paneCompositePart.getActivePaneComposite()?.getId() === v.id || this.compositeBar.isPinned(v.id))
+            .map(v => v.id));
+    }
+    focus() {
+        this.compositeBar.focus();
+    }
+    updateStyles() {
+        super.updateStyles();
+        const container = assertIsDefined(this.getContainer());
+        const background = this.getColor(ACTIVITY_BAR_BACKGROUND) || '';
+        container.style.backgroundColor = background;
+        const borderColor = this.getColor(ACTIVITY_BAR_BORDER) || this.getColor(contrastBorder) || '';
+        container.classList.toggle('bordered', !!borderColor);
+        container.style.borderColor = borderColor ? borderColor : '';
+    }
+    getActivitybarItemColors(theme) {
+        return {
+            activeForegroundColor: theme.getColor(ACTIVITY_BAR_FOREGROUND),
+            inactiveForegroundColor: theme.getColor(ACTIVITY_BAR_INACTIVE_FOREGROUND),
+            activeBorderColor: theme.getColor(ACTIVITY_BAR_ACTIVE_BORDER),
+            activeBackground: theme.getColor(ACTIVITY_BAR_ACTIVE_BACKGROUND),
+            badgeBackground: theme.getColor(ACTIVITY_BAR_BADGE_BACKGROUND),
+            badgeForeground: theme.getColor(ACTIVITY_BAR_BADGE_FOREGROUND),
+            dragAndDropBorder: theme.getColor(ACTIVITY_BAR_DRAG_AND_DROP_BORDER),
+            activeBackgroundColor: undefined, inactiveBackgroundColor: undefined, activeBorderBottomColor: undefined,
+        };
+    }
+    layout(width, height) {
+        if (!this.layoutService.isVisible("workbench.parts.activitybar" )) {
+            return;
+        }
+        const contentAreaSize = super.layoutContents(width, height).contentSize;
+        let availableHeight = contentAreaSize.height;
+        if (this.menuBarContainer) {
+            availableHeight -= this.menuBarContainer.clientHeight;
+        }
+        if (this.globalActivityActionBar) {
+            availableHeight -= (this.globalActivityActionBar.viewItems.length * ActivitybarPart.ACTION_HEIGHT);
+        }
+        this.compositeBar.layout(( new Dimension(width, availableHeight)));
+    }
+    getViewContainer(id) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(id);
+        return viewContainer && this.viewDescriptorService.getViewContainerLocation(viewContainer) === this.location ? viewContainer : undefined;
+    }
+    getViewContainers() {
+        return this.viewDescriptorService.getViewContainersByLocation(this.location);
+    }
+    onDidStorageValueChange(e) {
+        if (e.key === ActivitybarPart.PINNED_VIEW_CONTAINERS && e.scope === 0
+            && this.pinnedViewContainersValue !== this.getStoredPinnedViewContainersValue() ) {
+            this._pinnedViewContainersValue = undefined;
+            this._cachedViewContainers = undefined;
+            const newCompositeItems = [];
+            const compositeItems = this.compositeBar.getCompositeBarItems();
+            for (const cachedViewContainer of this.cachedViewContainers) {
+                newCompositeItems.push({
+                    id: cachedViewContainer.id,
+                    name: cachedViewContainer.name,
+                    order: cachedViewContainer.order,
+                    pinned: cachedViewContainer.pinned,
+                    visible: !!compositeItems.find(({ id }) => id === cachedViewContainer.id)
+                });
+            }
+            for (let index = 0; index < compositeItems.length; index++) {
+                if (!( newCompositeItems.some(({ id }) => id === compositeItems[index].id))) {
+                    const viewContainer = this.viewDescriptorService.getViewContainerById(compositeItems[index].id);
+                    newCompositeItems.splice(index, 0, {
+                        ...compositeItems[index],
+                        pinned: true,
+                        visible: true,
+                        order: viewContainer?.order,
+                    });
+                }
+            }
+            this.compositeBar.setCompositeBarItems(newCompositeItems);
+        }
+        if (e.key === AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY && e.scope === 0 ) {
+            this.toggleAccountsActivity();
+        }
+    }
+    saveCachedViewContainers() {
+        const state = [];
+        const compositeItems = this.compositeBar.getCompositeBarItems();
+        for (const compositeItem of compositeItems) {
+            const viewContainer = this.getViewContainer(compositeItem.id);
+            if (viewContainer) {
+                const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
+                const views = [];
+                for (const { when } of viewContainerModel.allViewDescriptors) {
+                    views.push({ when: when ? when.serialize() : undefined });
+                }
+                state.push({
+                    id: compositeItem.id,
+                    name: viewContainerModel.title,
+                    icon: URI.isUri(viewContainerModel.icon) && this.environmentService.remoteAuthority ? undefined : viewContainerModel.icon,
+                    views,
+                    pinned: compositeItem.pinned,
+                    order: compositeItem.order,
+                    visible: compositeItem.visible,
+                    isBuiltin: !viewContainer.extensionId
+                });
+            }
+            else {
+                state.push({ id: compositeItem.id, pinned: compositeItem.pinned, order: compositeItem.order, visible: false, isBuiltin: false });
+            }
+        }
+        this.storeCachedViewContainersState(state);
+    }
+    get cachedViewContainers() {
+        if (this._cachedViewContainers === undefined) {
+            this._cachedViewContainers = this.getPinnedViewContainers();
+            for (const placeholderViewContainer of this.getPlaceholderViewContainers()) {
+                const cachedViewContainer = this._cachedViewContainers.filter(cached => cached.id === placeholderViewContainer.id)[0];
+                if (cachedViewContainer) {
+                    cachedViewContainer.name = placeholderViewContainer.name;
+                    cachedViewContainer.icon = placeholderViewContainer.themeIcon ? placeholderViewContainer.themeIcon :
+                        placeholderViewContainer.iconUrl ? URI.revive(placeholderViewContainer.iconUrl) : undefined;
+                    if (URI.isUri(cachedViewContainer.icon) && this.environmentService.remoteAuthority) {
+                        cachedViewContainer.icon = undefined;
+                    }
+                    cachedViewContainer.views = placeholderViewContainer.views;
+                    cachedViewContainer.isBuiltin = placeholderViewContainer.isBuiltin;
+                }
+            }
+        }
+        return this._cachedViewContainers;
+    }
+    storeCachedViewContainersState(cachedViewContainers) {
+        this.setPinnedViewContainers(( cachedViewContainers.map(({ id, pinned, visible, order }) => ({
+            id,
+            pinned,
+            visible,
+            order
+        }))));
+        this.setPlaceholderViewContainers(( cachedViewContainers.map(({ id, icon, name, views, isBuiltin }) => ({
+            id,
+            iconUrl: URI.isUri(icon) ? icon : undefined,
+            themeIcon: ThemeIcon.isThemeIcon(icon) ? icon : undefined,
+            name,
+            isBuiltin,
+            views
+        }))));
+    }
+    getPinnedViewContainers() {
+        return JSON.parse(this.pinnedViewContainersValue);
+    }
+    setPinnedViewContainers(pinnedViewContainers) {
+        this.pinnedViewContainersValue = JSON.stringify(pinnedViewContainers);
+    }
+    get pinnedViewContainersValue() {
+        if (!this._pinnedViewContainersValue) {
+            this._pinnedViewContainersValue = this.getStoredPinnedViewContainersValue();
+        }
+        return this._pinnedViewContainersValue;
+    }
+    set pinnedViewContainersValue(pinnedViewContainersValue) {
+        if (this.pinnedViewContainersValue !== pinnedViewContainersValue) {
+            this._pinnedViewContainersValue = pinnedViewContainersValue;
+            this.setStoredPinnedViewContainersValue(pinnedViewContainersValue);
+        }
+    }
+    getStoredPinnedViewContainersValue() {
+        return this.storageService.get(ActivitybarPart.PINNED_VIEW_CONTAINERS, 0 , '[]');
+    }
+    setStoredPinnedViewContainersValue(value) {
+        this.storageService.store(ActivitybarPart.PINNED_VIEW_CONTAINERS, value, 0 , 0 );
+    }
+    getPlaceholderViewContainers() {
+        return JSON.parse(this.placeholderViewContainersValue);
+    }
+    setPlaceholderViewContainers(placeholderViewContainers) {
+        this.placeholderViewContainersValue = JSON.stringify(placeholderViewContainers);
+    }
+    get placeholderViewContainersValue() {
+        if (!this._placeholderViewContainersValue) {
+            this._placeholderViewContainersValue = this.getStoredPlaceholderViewContainersValue();
+        }
+        return this._placeholderViewContainersValue;
+    }
+    set placeholderViewContainersValue(placeholderViewContainesValue) {
+        if (this.placeholderViewContainersValue !== placeholderViewContainesValue) {
+            this._placeholderViewContainersValue = placeholderViewContainesValue;
+            this.setStoredPlaceholderViewContainersValue(placeholderViewContainesValue);
+        }
+    }
+    getStoredPlaceholderViewContainersValue() {
+        return this.storageService.get(ActivitybarPart.PLACEHOLDER_VIEW_CONTAINERS, 0 , '[]');
+    }
+    setStoredPlaceholderViewContainersValue(value) {
+        this.storageService.store(ActivitybarPart.PLACEHOLDER_VIEW_CONTAINERS, value, 0 , 1 );
+    }
+    get accountsVisibilityPreference() {
+        return this.storageService.getBoolean(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, 0 , true);
+    }
+    set accountsVisibilityPreference(value) {
+        this.storageService.store(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, value, 0 , 0 );
+    }
+    toJSON() {
+        return {
+            type: "workbench.parts.activitybar"
+        };
+    }
+};
+ActivitybarPart.PINNED_VIEW_CONTAINERS = 'workbench.activity.pinnedViewlets2';
+ActivitybarPart.PLACEHOLDER_VIEW_CONTAINERS = 'workbench.activity.placeholderViewlets';
+ActivitybarPart.ACTION_HEIGHT = 48;
+ActivitybarPart.ACCOUNTS_ACTION_INDEX = 0;
+ActivitybarPart.GEAR_ICON = ( registerIcon('settings-view-bar-icon', Codicon.settingsGear, ( localize('settingsViewBarIcon', "Settings icon in the view bar."))));
+ActivitybarPart.ACCOUNTS_ICON = ( registerIcon('accounts-view-bar-icon', Codicon.account, ( localize('accountsViewBarIcon', "Accounts icon in the view bar."))));
+ActivitybarPart = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IWorkbenchLayoutService)),
+    ( __param(3, IThemeService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IExtensionService)),
+    ( __param(6, IViewDescriptorService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IConfigurationService)),
+    ( __param(9, IWorkbenchEnvironmentService))
+], ActivitybarPart));
+export { ActivitybarPart };