@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.1

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

@@ -1,783 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/activitybarpart.css.js';
-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 { AccountsActivityActionViewItem, GlobalActivityActionViewItem, 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';
-var ActivitybarPart_1;
-let ActivitybarPart = class ActivitybarPart extends Part {
-    static { ActivitybarPart_1 = this; }
-    static { this.PINNED_VIEW_CONTAINERS = 'workbench.activity.pinnedViewlets2'; }
-    static { this.PLACEHOLDER_VIEW_CONTAINERS = 'workbench.activity.placeholderViewlets'; }
-    static { this.ACTION_HEIGHT = 48; }
-    static { this.ACCOUNTS_ACTION_INDEX = 0; }
-    static { this.GEAR_ICON = registerIcon('settings-view-bar-icon', Codicon.settingsGear, ( localize('settingsViewBarIcon', "Settings icon in the view bar."))); }
-    static { this.ACCOUNTS_ICON = registerIcon('accounts-view-bar-icon', Codicon.account, ( localize('accountsViewBarIcon', "Accounts icon in the view bar."))); }
-    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_1.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(0 , ActivitybarPart_1.PINNED_VIEW_CONTAINERS, disposables)(e => this.onDidPinnedViewContainersStorageValueChange(e), this, disposables);
-            this.storageService.onDidChangeValue(0 , AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, disposables)(() => this.toggleAccountsActivity(), 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_1.GEAR_ICON),
-        })));
-        if (this.accountsVisibilityPreference) {
-            this.accountsActivityAction = this._register(( new ActivityAction({
-                id: 'workbench.actions.accounts',
-                name: ( localize('accounts', "Accounts")),
-                classNames: ThemeIcon.asClassNameArray(ActivitybarPart_1.ACCOUNTS_ICON)
-            })));
-            this.globalActivityActionBar.push(this.accountsActivityAction, { index: ActivitybarPart_1.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_1.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_1.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_1.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_1.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_1.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);
-    }
-    onDidPinnedViewContainersStorageValueChange(e) {
-        if (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);
-        }
-    }
-    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_1.PINNED_VIEW_CONTAINERS, 0 , '[]');
-    }
-    setStoredPinnedViewContainersValue(value) {
-        this.storageService.store(ActivitybarPart_1.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_1.PLACEHOLDER_VIEW_CONTAINERS, 0 , '[]');
-    }
-    setStoredPlaceholderViewContainersValue(value) {
-        this.storageService.store(ActivitybarPart_1.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 = ActivitybarPart_1 = ( __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 };