@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/browser/parts/panel/panelPart.js

@@ -0,0 +1,753 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/basepanelpart.css";
+import "../../../../../../assets/panelpart.css";
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { toAction, Separator, SubmenuAction } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { prepareActions } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { getEnabledViewContainerContextKey, ActivePanelContext, PanelFocusContext } from '../../../common/contextkeys.js';
+import { CompositePart } from '../compositePart.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { PanelActivityAction, PlaceHolderToggleCompositePinnedAction, PlaceHolderPanelActivityAction, TogglePanelAction } from './panelActions.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { PANEL_ACTIVE_TITLE_BORDER, PANEL_ACTIVE_TITLE_FOREGROUND, PANEL_INACTIVE_TITLE_FOREGROUND, PANEL_DRAG_AND_DROP_BORDER, EDITOR_DRAG_AND_DROP_BACKGROUND, PANEL_BACKGROUND, PANEL_BORDER } from '../../../common/theme.js';
+import { badgeBackground, badgeForeground, contrastBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { CompositeDragAndDrop, CompositeBar } from '../compositeBar.js';
+import { ToggleCompositePinnedAction, ToggleCompositeBadgeAction } from '../compositeBarActions.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { asCSSUrl, createCSSRule, trackFocus, EventHelper, $, Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { assertIsDefined, isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { CompositeDragAndDropObserver, toggleDropEffect } from '../../dnd.js';
+import { Extensions } from '../../panecomposite.js';
+import { CompositeMenuActions } from '../../actions.js';
+import { MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { StringSHA1 } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ToolBar } from 'monaco-editor/esm/vs/base/browser/ui/toolbar/toolbar.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { PlaceHolderToggleCompositeBadgeAction } from '../activitybar/activitybarActions.js';
+import { createAndFillInContextMenuActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+let BasePanelPart = class BasePanelPart extends CompositePart {
+    get preferredHeight() {
+        return this.layoutService.dimension.height * 0.4;
+    }
+    get preferredWidth() {
+        const activeComposite = this.getActivePaneComposite();
+        if (!activeComposite) {
+            return;
+        }
+        const width = activeComposite.getOptimalWidth();
+        if (typeof width !== 'number') {
+            return;
+        }
+        return Math.max(width, 300);
+    }
+    get onDidPaneCompositeOpen() { return ( Event.map(this.onDidCompositeOpen.event, compositeEvent => compositeEvent.composite)); }
+    constructor(notificationService, storageService, telemetryService, contextMenuService, layoutService, keybindingService, instantiationService, themeService, viewDescriptorService, contextKeyService, extensionService, partId, activePanelSettingsKey, pinnedPanelsKey, placeholdeViewContainersKey, panelRegistryId, backgroundColor, viewContainerLocation, activePanelContextKey, panelFocusContextKey, panelOptions) {
+        super(notificationService, storageService, telemetryService, contextMenuService, layoutService, keybindingService, instantiationService, themeService, ( Registry.as(panelRegistryId)), activePanelSettingsKey, viewDescriptorService.getDefaultViewContainer(viewContainerLocation)?.id || '', 'panel', 'panel', undefined, partId, panelOptions);
+        this.viewDescriptorService = viewDescriptorService;
+        this.contextKeyService = contextKeyService;
+        this.extensionService = extensionService;
+        this.partId = partId;
+        this.pinnedPanelsKey = pinnedPanelsKey;
+        this.placeholdeViewContainersKey = placeholdeViewContainersKey;
+        this.backgroundColor = backgroundColor;
+        this.viewContainerLocation = viewContainerLocation;
+        this.activePanelContextKey = activePanelContextKey;
+        this.panelFocusContextKey = panelFocusContextKey;
+        this.panelOptions = panelOptions;
+        this.minimumWidth = 300;
+        this.maximumWidth = Number.POSITIVE_INFINITY;
+        this.minimumHeight = 77;
+        this.maximumHeight = Number.POSITIVE_INFINITY;
+        this.snap = true;
+        this.onDidPaneCompositeClose = this.onDidCompositeClose.event;
+        this.compositeActions = ( new Map());
+        this.panelDisposables = ( new Map());
+        this.blockOpeningPanel = false;
+        this.extensionsRegistered = false;
+        this.enabledViewContainersContextKeys = ( new Map());
+        this.panelRegistry = ( Registry.as(panelRegistryId));
+        this.dndHandler = ( new CompositeDragAndDrop(
+            this.viewDescriptorService,
+            this.viewContainerLocation,
+            (id, focus) => this.openPaneComposite(id, focus).then(panel => panel || null),
+            (from, to, before) => this.compositeBar.move(from, to, before?.horizontallyBefore),
+            () => this.compositeBar.getCompositeBarItems()
+        ));
+        this.compositeBar = this._register(this.instantiationService.createInstance(CompositeBar, this.getCachedPanels(), {
+            icon: !!this.panelOptions.useIcons,
+            orientation: 0 ,
+            activityHoverOptions: this.getActivityHoverOptions(),
+            openComposite: (compositeId, preserveFocus) => this.openPaneComposite(compositeId, !preserveFocus).then(panel => panel || null),
+            getActivityAction: compositeId => this.getCompositeActions(compositeId).activityAction,
+            getCompositePinnedAction: compositeId => this.getCompositeActions(compositeId).pinnedAction,
+            getCompositeBadgeAction: compositeId => this.getCompositeActions(compositeId).badgeAction,
+            getOnCompositeClickAction: compositeId => this.instantiationService.createInstance(PanelActivityAction, assertIsDefined(this.getPaneComposite(compositeId)), this.viewContainerLocation),
+            fillExtraContextMenuActions: actions => ( this.fillExtraContextMenuActions(actions)),
+            getContextMenuActionsForComposite: compositeId => this.getContextMenuActionsForComposite(compositeId),
+            getDefaultCompositeId: () => viewDescriptorService.getDefaultViewContainer(this.viewContainerLocation)?.id,
+            hidePart: () => this.layoutService.setPartHidden(true, this.partId),
+            dndHandler: this.dndHandler,
+            compositeSize: 0,
+            overflowActionSize: 44,
+            colors: theme => ({
+                activeBackgroundColor: theme.getColor(this.backgroundColor),
+                inactiveBackgroundColor: theme.getColor(this.backgroundColor),
+                activeBorderBottomColor: theme.getColor(PANEL_ACTIVE_TITLE_BORDER),
+                activeForegroundColor: theme.getColor(PANEL_ACTIVE_TITLE_FOREGROUND),
+                inactiveForegroundColor: theme.getColor(PANEL_INACTIVE_TITLE_FOREGROUND),
+                badgeBackground: theme.getColor(badgeBackground),
+                badgeForeground: theme.getColor(badgeForeground),
+                dragAndDropBorder: theme.getColor(PANEL_DRAG_AND_DROP_BORDER)
+            })
+        }));
+        this.registerListeners();
+        this.onDidRegisterPanels([...this.getPaneComposites()]);
+        this.globalActions = this._register(this.instantiationService.createInstance(CompositeMenuActions, partId === "workbench.parts.panel"  ? MenuId.PanelTitle : MenuId.AuxiliaryBarTitle, undefined, undefined));
+        this._register(this.globalActions.onDidChange(() => this.updateGlobalToolbarActions()));
+    }
+    getContextMenuActionsForComposite(compositeId) {
+        const result = [];
+        const viewContainer = this.viewDescriptorService.getViewContainerById(compositeId);
+        const defaultLocation = this.viewDescriptorService.getDefaultViewContainerLocation(viewContainer);
+        if (defaultLocation !== this.viewDescriptorService.getViewContainerLocation(viewContainer)) {
+            result.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) {
+                    result.push(toAction({ id: 'resetLocationAction', label: ( localize('resetLocation', "Reset Location")), run: () => this.viewDescriptorService.moveViewsToContainer([viewToReset], defaultContainer) }));
+                }
+            }
+        }
+        return result;
+    }
+    onDidRegisterPanels(panels) {
+        const cachedPanels = this.getCachedPanels();
+        for (const panel of panels) {
+            const cachedPanel = cachedPanels.filter(({ id }) => id === panel.id)[0];
+            const activePanel = this.getActivePaneComposite();
+            const isActive = activePanel?.getId() === panel.id ||
+                (this.extensionsRegistered && this.compositeBar.getVisibleComposites().length === 0);
+            if (isActive || !this.shouldBeHidden(panel.id, cachedPanel)) {
+                const newPanel = {
+                    id: panel.id,
+                    name: panel.name,
+                    order: panel.order,
+                    requestedIndex: panel.requestedIndex
+                };
+                this.compositeBar.addComposite(newPanel);
+                if (!cachedPanel) {
+                    this.compositeBar.pin(panel.id);
+                }
+                if (isActive) {
+                    this.compositeBar.activateComposite(panel.id);
+                    if (!activePanel && this.element && this.layoutService.isVisible(this.partId)) {
+                        this.doOpenPanel(panel.id);
+                    }
+                }
+            }
+        }
+        for (const panel of panels) {
+            const viewContainer = this.getViewContainer(panel.id);
+            const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
+            this.updateActivity(viewContainer, viewContainerModel);
+            this.showOrHideViewContainer(viewContainer, viewContainerModel);
+            const disposables = ( new DisposableStore());
+            disposables.add(viewContainerModel.onDidChangeActiveViewDescriptors(() => this.showOrHideViewContainer(viewContainer, viewContainerModel)));
+            disposables.add(viewContainerModel.onDidChangeContainerInfo(() => this.updateActivity(viewContainer, viewContainerModel)));
+            this.panelDisposables.set(panel.id, disposables);
+        }
+    }
+    async onDidDeregisterPanel(panelId) {
+        const disposable = this.panelDisposables.get(panelId);
+        disposable?.dispose();
+        this.panelDisposables.delete(panelId);
+        const activeContainers = this.viewDescriptorService.getViewContainersByLocation(this.viewContainerLocation)
+            .filter(container => this.viewDescriptorService.getViewContainerModel(container).activeViewDescriptors.length > 0);
+        if (activeContainers.length) {
+            if (this.getActivePaneComposite()?.getId() === panelId) {
+                const defaultPanelId = this.viewDescriptorService.getDefaultViewContainer(this.viewContainerLocation)?.id;
+                const containerToOpen = activeContainers.filter(c => c.id === defaultPanelId)[0] || activeContainers[0];
+                await this.openPaneComposite(containerToOpen.id);
+            }
+        }
+        else {
+            this.layoutService.setPartHidden(true, this.partId);
+        }
+        this.removeComposite(panelId);
+    }
+    updateActivity(viewContainer, viewContainerModel) {
+        const cachedTitle = this.getPlaceholderViewContainers().filter(panel => panel.id === viewContainer.id)[0]?.name;
+        const activity = {
+            id: viewContainer.id,
+            name: this.extensionsRegistered || cachedTitle === undefined ? viewContainerModel.title : cachedTitle,
+            keybindingId: viewContainerModel.keybindingId
+        };
+        const { activityAction, pinnedAction } = this.getCompositeActions(viewContainer.id);
+        activityAction.setActivity(this.toActivity(viewContainerModel));
+        if (pinnedAction instanceof PlaceHolderToggleCompositePinnedAction) {
+            pinnedAction.setActivity(activity);
+        }
+        this.compositeBar.recomputeSizes();
+        this.layoutCompositeBar();
+        if (this.extensionsRegistered) {
+            this.saveCachedPanels();
+        }
+    }
+    toActivity(viewContainerModel) {
+        return BasePanelPart.toActivity(viewContainerModel.viewContainer.id, viewContainerModel.title, this.panelOptions.useIcons ? viewContainerModel.icon : undefined, 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()}`;
+            classNames = [iconId, 'uri-icon'];
+            const iconClass = `.monaco-workbench .basepanel .monaco-action-bar .action-label.${iconId}`;
+            createCSSRule(iconClass, `
+				mask: ${cssUrl} no-repeat 50% 50%;
+				mask-size: 16px;
+				-webkit-mask: ${cssUrl} no-repeat 50% 50%;
+				-webkit-mask-size: 16px;
+				mask-origin: padding;
+				-webkit-mask-origin: padding;
+			`);
+        }
+        else if (ThemeIcon.isThemeIcon(icon)) {
+            classNames = ThemeIcon.asClassNameArray(icon);
+        }
+        return { id, name, classNames, iconUrl, keybindingId };
+    }
+    showOrHideViewContainer(viewContainer, viewContainerModel) {
+        let contextKey = this.enabledViewContainersContextKeys.get(viewContainer.id);
+        if (!contextKey) {
+            contextKey = this.contextKeyService.createKey(getEnabledViewContainerContextKey(viewContainer.id), false);
+            this.enabledViewContainersContextKeys.set(viewContainer.id, contextKey);
+        }
+        if (viewContainerModel.activeViewDescriptors.length) {
+            contextKey.set(true);
+            this.compositeBar.addComposite({ id: viewContainer.id, name: typeof viewContainer.title === 'string' ? viewContainer.title : viewContainer.title.value, order: viewContainer.order, requestedIndex: viewContainer.requestedIndex });
+            if (this.layoutService.isRestored() && this.layoutService.isVisible(this.partId)) {
+                const activeComposite = this.getActiveComposite();
+                if (activeComposite === undefined || activeComposite.getId() === viewContainer.id) {
+                    this.compositeBar.activateComposite(viewContainer.id);
+                }
+            }
+            this.layoutCompositeBar();
+            this.layoutEmptyMessage();
+        }
+        else if (viewContainer.hideIfEmpty) {
+            contextKey.set(false);
+            this.hideComposite(viewContainer.id);
+        }
+    }
+    shouldBeHidden(panelId, cachedPanel) {
+        const viewContainer = this.getViewContainer(panelId);
+        if (!viewContainer || !viewContainer.hideIfEmpty) {
+            return false;
+        }
+        return cachedPanel?.views && cachedPanel.views.length
+            ? cachedPanel.views.every(({ when }) => !!when && !this.contextKeyService.contextMatchesRules(ContextKeyExpr.deserialize(when)))
+            : false;
+    }
+    registerListeners() {
+        this._register(this.registry.onDidRegister(panel => this.onDidRegisterPanels([panel])));
+        this._register(this.registry.onDidDeregister(panel => this.onDidDeregisterPanel(panel.id)));
+        this._register(this.onDidPaneCompositeOpen(panel => this.onPanelOpen(panel)));
+        this._register(this.onDidPaneCompositeClose(this.onPanelClose, this));
+        const disposables = this._register(( new DisposableStore()));
+        this._register(this.extensionService.onDidRegisterExtensions(() => {
+            disposables.clear();
+            this.onDidRegisterExtensions();
+            this.compositeBar.onDidChange(() => this.saveCachedPanels(), this, disposables);
+            this.storageService.onDidChangeValue(e => this.onDidStorageValueChange(e), this, disposables);
+        }));
+    }
+    onDidRegisterExtensions() {
+        this.extensionsRegistered = true;
+        const panels = this.getPaneComposites();
+        for (const { id } of this.getCachedPanels()) {
+            if (panels.every(panel => panel.id !== id)) {
+                if (this.viewDescriptorService.isViewContainerRemovedPermanently(id)) {
+                    this.removeComposite(id);
+                }
+                else {
+                    this.hideComposite(id);
+                }
+            }
+        }
+        this.saveCachedPanels();
+    }
+    hideComposite(compositeId) {
+        this.compositeBar.hideComposite(compositeId);
+        const compositeActions = this.compositeActions.get(compositeId);
+        if (compositeActions) {
+            compositeActions.activityAction.dispose();
+            compositeActions.pinnedAction.dispose();
+            this.compositeActions.delete(compositeId);
+        }
+    }
+    onPanelOpen(panel) {
+        this.activePanelContextKey.set(panel.getId());
+        const foundPanel = this.panelRegistry.getPaneComposite(panel.getId());
+        if (foundPanel) {
+            this.compositeBar.addComposite(foundPanel);
+        }
+        this.compositeBar.activateComposite(panel.getId());
+        const panelDescriptor = this.panelRegistry.getPaneComposite(panel.getId());
+        if (panelDescriptor) {
+            const viewContainer = this.getViewContainer(panelDescriptor.id);
+            if (viewContainer?.hideIfEmpty) {
+                const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
+                if (viewContainerModel.activeViewDescriptors.length === 0) {
+                    this.hideComposite(panelDescriptor.id);
+                }
+            }
+        }
+        this.layoutCompositeBar();
+        this.layoutEmptyMessage();
+    }
+    onPanelClose(panel) {
+        const id = panel.getId();
+        if (this.activePanelContextKey.get() === id) {
+            this.activePanelContextKey.reset();
+        }
+        this.compositeBar.deactivateComposite(panel.getId());
+        this.layoutEmptyMessage();
+    }
+    create(parent) {
+        this.element = parent;
+        super.create(parent);
+        this.createEmptyPanelMessage();
+        const focusTracker = this._register(trackFocus(parent));
+        this._register(focusTracker.onDidFocus(() => this.panelFocusContextKey.set(true)));
+        this._register(focusTracker.onDidBlur(() => this.panelFocusContextKey.set(false)));
+    }
+    createEmptyPanelMessage() {
+        const contentArea = this.getContentArea();
+        this.emptyPanelMessageElement = document.createElement('div');
+        this.emptyPanelMessageElement.classList.add('empty-panel-message-area');
+        const messageElement = document.createElement('div');
+        messageElement.classList.add('empty-panel-message');
+        messageElement.innerText = ( localize('panel.emptyMessage', "Drag a view here to display."));
+        this.emptyPanelMessageElement.appendChild(messageElement);
+        contentArea.appendChild(this.emptyPanelMessageElement);
+        this._register(CompositeDragAndDropObserver.INSTANCE.registerTarget(this.emptyPanelMessageElement, {
+            onDragOver: (e) => {
+                EventHelper.stop(e.eventData, true);
+                const validDropTarget = this.dndHandler.onDragEnter(e.dragAndDropData, undefined, e.eventData);
+                toggleDropEffect(e.eventData.dataTransfer, 'move', validDropTarget);
+            },
+            onDragEnter: (e) => {
+                EventHelper.stop(e.eventData, true);
+                const validDropTarget = this.dndHandler.onDragEnter(e.dragAndDropData, undefined, e.eventData);
+                this.emptyPanelMessageElement.style.backgroundColor = validDropTarget ? this.theme.getColor(EDITOR_DRAG_AND_DROP_BACKGROUND)?.toString() || '' : '';
+            },
+            onDragLeave: (e) => {
+                EventHelper.stop(e.eventData, true);
+                this.emptyPanelMessageElement.style.backgroundColor = '';
+            },
+            onDragEnd: (e) => {
+                EventHelper.stop(e.eventData, true);
+                this.emptyPanelMessageElement.style.backgroundColor = '';
+            },
+            onDrop: (e) => {
+                EventHelper.stop(e.eventData, true);
+                this.emptyPanelMessageElement.style.backgroundColor = '';
+                this.dndHandler.drop(e.dragAndDropData, undefined, e.eventData);
+            },
+        }));
+    }
+    createTitleArea(parent) {
+        const element = super.createTitleArea(parent);
+        const globalTitleActionsContainer = element.appendChild($('.global-actions'));
+        this.globalToolBar = this._register(( new ToolBar(globalTitleActionsContainer, this.contextMenuService, {
+            actionViewItemProvider: action => this.actionViewItemProvider(action),
+            orientation: 0 ,
+            getKeyBinding: action => this.keybindingService.lookupKeybinding(action.id),
+            anchorAlignmentProvider: () => this.getTitleAreaDropDownAnchorAlignment(),
+            toggleMenuTitle: ( localize('moreActions', "More Actions..."))
+        })));
+        this.updateGlobalToolbarActions();
+        return element;
+    }
+    updateStyles() {
+        super.updateStyles();
+        const container = assertIsDefined(this.getContainer());
+        container.style.backgroundColor = this.getColor(this.backgroundColor) || '';
+        const borderColor = this.getColor(contrastBorder) || '';
+        container.style.borderLeftColor = borderColor;
+        container.style.borderRightColor = borderColor;
+        const title = this.getTitleArea();
+        if (title) {
+            title.style.borderTopColor = this.getColor(contrastBorder) || '';
+        }
+    }
+    doOpenPanel(id, focus) {
+        if (this.blockOpeningPanel) {
+            return undefined;
+        }
+        if (!this.layoutService.isVisible(this.partId)) {
+            try {
+                this.blockOpeningPanel = true;
+                this.layoutService.setPartHidden(false, this.partId);
+            }
+            finally {
+                this.blockOpeningPanel = false;
+            }
+        }
+        return this.openComposite(id, focus);
+    }
+    async openPaneComposite(id, focus) {
+        if (typeof id === 'string' && this.getPaneComposite(id)) {
+            return this.doOpenPanel(id, focus);
+        }
+        await this.extensionService.whenInstalledExtensionsRegistered();
+        if (typeof id === 'string' && this.getPaneComposite(id)) {
+            return this.doOpenPanel(id, focus);
+        }
+        return undefined;
+    }
+    showActivity(panelId, badge, clazz) {
+        return this.compositeBar.showActivity(panelId, badge, clazz);
+    }
+    getPaneComposite(panelId) {
+        return this.panelRegistry.getPaneComposite(panelId);
+    }
+    getPaneComposites() {
+        return this.panelRegistry.getPaneComposites()
+            .sort((v1, v2) => {
+            if (typeof v1.order !== 'number') {
+                return 1;
+            }
+            if (typeof v2.order !== 'number') {
+                return -1;
+            }
+            return v1.order - v2.order;
+        });
+    }
+    getPinnedPaneCompositeIds() {
+        const pinnedCompositeIds = ( this.compositeBar.getPinnedComposites().map(c => c.id));
+        return ( this.getPaneComposites()
+            .filter(p => pinnedCompositeIds.includes(p.id))
+            .sort((p1, p2) => pinnedCompositeIds.indexOf(p1.id) - pinnedCompositeIds.indexOf(p2.id))
+            .map(p => p.id));
+    }
+    getVisiblePaneCompositeIds() {
+        return ( this.compositeBar.getVisibleComposites()
+            .filter(v => this.getActivePaneComposite()?.getId() === v.id || this.compositeBar.isPinned(v.id))
+            .map(v => v.id));
+    }
+    getActivePaneComposite() {
+        return this.getActiveComposite();
+    }
+    getLastActivePaneCompositeId() {
+        return this.getLastActiveCompositeId();
+    }
+    hideActivePaneComposite() {
+        if (this.layoutService.isVisible(this.partId)) {
+            this.layoutService.setPartHidden(true, this.partId);
+        }
+        this.hideActiveComposite();
+    }
+    createTitleLabel(parent) {
+        const titleArea = this.compositeBar.create(parent);
+        titleArea.classList.add('panel-switcher-container');
+        return {
+            updateTitle: (id, title, keybinding) => {
+                const action = this.compositeBar.getAction(id);
+                if (action) {
+                    action.label = title;
+                }
+            },
+            updateStyles: () => {
+            }
+        };
+    }
+    onTitleAreaUpdate(compositeId) {
+        super.onTitleAreaUpdate(compositeId);
+        this.layoutCompositeBar();
+    }
+    layout(width, height, top, left) {
+        if (!this.layoutService.isVisible(this.partId)) {
+            return;
+        }
+        this.contentDimension = ( new Dimension(width, height));
+        super.layout(this.contentDimension.width, this.contentDimension.height, top, left);
+        this.layoutCompositeBar();
+        this.layoutEmptyMessage();
+    }
+    layoutCompositeBar() {
+        if (this.contentDimension && this.dimension) {
+            let availableWidth = this.contentDimension.width - 40;
+            if (this.toolBar) {
+                availableWidth = Math.max(BasePanelPart.MIN_COMPOSITE_BAR_WIDTH, availableWidth - this.getToolbarWidth());
+            }
+            this.compositeBar.layout(( new Dimension(availableWidth, this.dimension.height)));
+        }
+    }
+    layoutEmptyMessage() {
+        this.emptyPanelMessageElement?.classList.toggle('visible', this.compositeBar.getVisibleComposites().length === 0);
+    }
+    getViewContainer(id) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(id);
+        return viewContainer && this.viewDescriptorService.getViewContainerLocation(viewContainer) === this.viewContainerLocation ? viewContainer : undefined;
+    }
+    updateGlobalToolbarActions() {
+        const primaryActions = this.globalActions.getPrimaryActions();
+        const secondaryActions = this.globalActions.getSecondaryActions();
+        this.globalToolBar?.setActions(prepareActions(primaryActions), prepareActions(secondaryActions));
+    }
+    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(PanelActivityAction, this.toActivity(viewContainerModel), this.viewContainerLocation),
+                    pinnedAction: ( new ToggleCompositePinnedAction(this.toActivity(viewContainerModel), this.compositeBar)),
+                    badgeAction: ( new ToggleCompositeBadgeAction(this.toActivity(viewContainerModel), this.compositeBar))
+                };
+            }
+            else {
+                compositeActions = {
+                    activityAction: this.instantiationService.createInstance(PlaceHolderPanelActivityAction, compositeId, this.viewContainerLocation),
+                    pinnedAction: ( new PlaceHolderToggleCompositePinnedAction(compositeId, this.compositeBar)),
+                    badgeAction: ( new PlaceHolderToggleCompositeBadgeAction(compositeId, this.compositeBar))
+                };
+            }
+            this.compositeActions.set(compositeId, compositeActions);
+        }
+        return compositeActions;
+    }
+    removeComposite(compositeId) {
+        if (super.removeComposite(compositeId)) {
+            this.compositeBar.removeComposite(compositeId);
+            const compositeActions = this.compositeActions.get(compositeId);
+            if (compositeActions) {
+                compositeActions.activityAction.dispose();
+                compositeActions.pinnedAction.dispose();
+                this.compositeActions.delete(compositeId);
+            }
+            return true;
+        }
+        return false;
+    }
+    getToolbarWidth() {
+        const activePanel = this.getActivePaneComposite();
+        if (!activePanel || !this.toolBar) {
+            return 0;
+        }
+        return this.toolBar.getItemsWidth() + (this.globalToolBar?.getItemsWidth() ?? 0);
+    }
+    onDidStorageValueChange(e) {
+        if (e.key === this.pinnedPanelsKey && e.scope === 0
+            && this.cachedPanelsValue !== this.getStoredCachedPanelsValue() ) {
+            this._cachedPanelsValue = undefined;
+            const newCompositeItems = [];
+            const compositeItems = this.compositeBar.getCompositeBarItems();
+            const cachedPanels = this.getCachedPanels();
+            for (const cachedPanel of cachedPanels) {
+                newCompositeItems.push({
+                    id: cachedPanel.id,
+                    name: cachedPanel.name,
+                    order: cachedPanel.order,
+                    pinned: cachedPanel.pinned,
+                    visible: !!compositeItems.find(({ id }) => id === cachedPanel.id)
+                });
+            }
+            for (let index = 0; index < compositeItems.length; index++) {
+                if (!( newCompositeItems.some(({ id }) => id === compositeItems[index].id))) {
+                    newCompositeItems.splice(index, 0, compositeItems[index]);
+                }
+            }
+            this.compositeBar.setCompositeBarItems(newCompositeItems);
+        }
+    }
+    saveCachedPanels() {
+        const state = [];
+        const placeholders = [];
+        const compositeItems = this.compositeBar.getCompositeBarItems();
+        for (const compositeItem of compositeItems) {
+            const viewContainer = this.getViewContainer(compositeItem.id);
+            if (viewContainer) {
+                const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
+                state.push({ id: compositeItem.id, name: viewContainerModel.title, pinned: compositeItem.pinned, order: compositeItem.order, visible: compositeItem.visible });
+                placeholders.push({ id: compositeItem.id, name: this.getCompositeActions(compositeItem.id).activityAction.label });
+            }
+            else {
+                state.push({ id: compositeItem.id, name: compositeItem.name, pinned: compositeItem.pinned, order: compositeItem.order, visible: compositeItem.visible });
+            }
+        }
+        this.cachedPanelsValue = JSON.stringify(state);
+        this.setPlaceholderViewContainers(placeholders);
+    }
+    getCachedPanels() {
+        const registeredPanels = this.getPaneComposites();
+        const storedStates = JSON.parse(this.cachedPanelsValue);
+        const cachedPanels = ( storedStates.map(c => {
+            const serialized = typeof c === 'string'  ? { id: c, pinned: true, order: undefined, visible: true } : c;
+            const registered = ( registeredPanels.some(p => p.id === serialized.id));
+            serialized.visible = registered ? isUndefinedOrNull(serialized.visible) ? true : serialized.visible : false;
+            return serialized;
+        }));
+        for (const placeholderViewContainer of this.getPlaceholderViewContainers()) {
+            const cachedViewContainer = cachedPanels.filter(cached => cached.id === placeholderViewContainer.id)[0];
+            if (cachedViewContainer) {
+                cachedViewContainer.name = placeholderViewContainer.name;
+            }
+        }
+        return cachedPanels;
+    }
+    get cachedPanelsValue() {
+        if (!this._cachedPanelsValue) {
+            this._cachedPanelsValue = this.getStoredCachedPanelsValue();
+        }
+        return this._cachedPanelsValue;
+    }
+    set cachedPanelsValue(cachedViewletsValue) {
+        if (this.cachedPanelsValue !== cachedViewletsValue) {
+            this._cachedPanelsValue = cachedViewletsValue;
+            this.setStoredCachedViewletsValue(cachedViewletsValue);
+        }
+    }
+    getStoredCachedPanelsValue() {
+        return this.storageService.get(this.pinnedPanelsKey, 0 , '[]');
+    }
+    setStoredCachedViewletsValue(value) {
+        this.storageService.store(this.pinnedPanelsKey, 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(this.placeholdeViewContainersKey, 1 , '[]');
+    }
+    setStoredPlaceholderViewContainersValue(value) {
+        this.storageService.store(this.placeholdeViewContainersKey, value, 1 , 1 );
+    }
+};
+BasePanelPart.MIN_COMPOSITE_BAR_WIDTH = 50;
+BasePanelPart = ( __decorate([
+    ( __param(0, INotificationService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IWorkbenchLayoutService)),
+    ( __param(5, IKeybindingService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IThemeService)),
+    ( __param(8, IViewDescriptorService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, IExtensionService))
+], BasePanelPart));
+let PanelPart = class PanelPart extends BasePanelPart {
+    constructor(notificationService, storageService, telemetryService, contextMenuService, layoutService, keybindingService, instantiationService, themeService, viewDescriptorService, contextKeyService, extensionService, commandService, menuService) {
+        super(notificationService, storageService, telemetryService, contextMenuService, layoutService, keybindingService, instantiationService, themeService, viewDescriptorService, contextKeyService, extensionService, "workbench.parts.panel" , PanelPart.activePanelSettingsKey, 'workbench.panel.pinnedPanels', 'workbench.panel.placeholderPanels', Extensions.Panels, PANEL_BACKGROUND, 1 , ActivePanelContext.bindTo(contextKeyService), PanelFocusContext.bindTo(contextKeyService), {
+            useIcons: false,
+            hasTitle: true
+        });
+        this.commandService = commandService;
+        this.menuService = menuService;
+    }
+    updateStyles() {
+        super.updateStyles();
+        const container = assertIsDefined(this.getContainer());
+        const borderColor = this.getColor(PANEL_BORDER) || this.getColor(contrastBorder) || '';
+        container.style.borderLeftColor = borderColor;
+        container.style.borderRightColor = borderColor;
+        const title = this.getTitleArea();
+        if (title) {
+            title.style.borderTopColor = this.getColor(PANEL_BORDER) || this.getColor(contrastBorder) || '';
+        }
+    }
+    getActivityHoverOptions() {
+        return {
+            position: () => this.layoutService.getPanelPosition() === 2  && !this.layoutService.isPanelMaximized() ? 3  : 2 ,
+        };
+    }
+    fillExtraContextMenuActions(actions) {
+        const panelPositionMenu = this.menuService.createMenu(MenuId.PanelPositionMenu, this.contextKeyService);
+        const panelAlignMenu = this.menuService.createMenu(MenuId.PanelAlignmentMenu, this.contextKeyService);
+        const positionActions = [];
+        const alignActions = [];
+        createAndFillInContextMenuActions(panelPositionMenu, { shouldForwardArgs: true }, { primary: [], secondary: positionActions });
+        createAndFillInContextMenuActions(panelAlignMenu, { shouldForwardArgs: true }, { primary: [], secondary: alignActions });
+        panelAlignMenu.dispose();
+        panelPositionMenu.dispose();
+        actions.push(...[
+            ( new Separator()),
+            ( new SubmenuAction('workbench.action.panel.position', ( localize('panel position', "Panel Position")), positionActions)),
+            ( new SubmenuAction('workbench.action.panel.align', ( localize('align panel', "Align Panel")), alignActions)),
+            toAction({ id: TogglePanelAction.ID, label: ( localize('hidePanel', "Hide Panel")), run: () => this.commandService.executeCommand(TogglePanelAction.ID) })
+        ]);
+    }
+    layout(width, height, top, left) {
+        let dimensions;
+        if (this.layoutService.getPanelPosition() === 1 ) {
+            dimensions = ( new Dimension(width - 1, height));
+        }
+        else {
+            dimensions = ( new Dimension(width, height));
+        }
+        super.layout(dimensions.width, dimensions.height, top, left);
+    }
+    toJSON() {
+        return {
+            type: "workbench.parts.panel"
+        };
+    }
+};
+PanelPart.activePanelSettingsKey = 'workbench.panelpart.activepanelid';
+PanelPart = ( __decorate([
+    ( __param(0, INotificationService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IWorkbenchLayoutService)),
+    ( __param(5, IKeybindingService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IThemeService)),
+    ( __param(8, IViewDescriptorService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, IExtensionService)),
+    ( __param(11, ICommandService)),
+    ( __param(12, IMenuService))
+], PanelPart));
+export { BasePanelPart, PanelPart };