@codingame/monaco-vscode-view-common-service-override 4.5.0-improve-code-splitting.1

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

@@ -0,0 +1,472 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import './media/paneCompositePart.css.js';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Extensions } from 'vscode/vscode/vs/workbench/browser/panecomposite';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
+import { DisposableStore, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { CompositePart } from './compositePart.js';
+import { PaneCompositeBar } from './paneCompositeBar.js';
+import { trackFocus, EventHelper, addDisposableListener, EventType, getWindow, $, prepend, Dimension } from 'vscode/vscode/vs/base/browser/dom';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService.service';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { CompositeDragAndDropObserver, toggleDropEffect } from 'vscode/vscode/vs/workbench/browser/dnd';
+import { EDITOR_DRAG_AND_DROP_BACKGROUND } from 'vscode/vscode/vs/workbench/common/theme';
+import { ToolBar } from 'vscode/vscode/vs/base/browser/ui/toolbar/toolbar';
+import { CompositeMenuActions } from 'vscode/vscode/vs/workbench/browser/actions';
+import { MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
+import { prepareActions } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { Gesture, EventType as EventType$1 } from 'vscode/vscode/vs/base/browser/touch';
+import { StandardMouseEvent } from 'vscode/vscode/vs/base/browser/mouseEvent';
+import { SubmenuAction } from 'vscode/vscode/vs/base/common/actions';
+import { ViewsSubMenu } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+import { createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+
+var AbstractPaneCompositePart_1;
+var CompositeBarPosition;
+( (function(CompositeBarPosition) {
+    CompositeBarPosition[CompositeBarPosition["TOP"] = 0] = "TOP";
+    CompositeBarPosition[CompositeBarPosition["TITLE"] = 1] = "TITLE";
+    CompositeBarPosition[CompositeBarPosition["BOTTOM"] = 2] = "BOTTOM";
+})(CompositeBarPosition || (CompositeBarPosition = {})));
+let AbstractPaneCompositePart = class AbstractPaneCompositePart extends CompositePart {
+    static { AbstractPaneCompositePart_1 = this; }
+    static { this.MIN_COMPOSITE_BAR_WIDTH = 50; }
+    get snap() {
+        return this.layoutService.isVisible(this.partId) || !!this.paneCompositeBar.value?.getVisiblePaneCompositeIds().length;
+    }
+    get onDidPaneCompositeOpen() { return ( Event.map(this.onDidCompositeOpen.event, compositeEvent => compositeEvent.composite)); }
+    constructor(partId, partOptions, activePaneCompositeSettingsKey, activePaneContextKey, paneFocusContextKey, nameForTelemetry, compositeCSSClass, titleForegroundColor, notificationService, storageService, contextMenuService, layoutService, keybindingService, instantiationService, themeService, viewDescriptorService, contextKeyService, extensionService, menuService) {
+        let location = 0 ;
+        let registryId = Extensions.Viewlets;
+        let globalActionsMenuId = MenuId.SidebarTitle;
+        if (partId === "workbench.parts.panel" ) {
+            location = 1 ;
+            registryId = Extensions.Panels;
+            globalActionsMenuId = MenuId.PanelTitle;
+        }
+        else if (partId === "workbench.parts.auxiliarybar" ) {
+            location = 2 ;
+            registryId = Extensions.Auxiliary;
+            globalActionsMenuId = MenuId.AuxiliaryBarTitle;
+        }
+        super(notificationService, storageService, contextMenuService, layoutService, keybindingService, instantiationService, themeService, ( Registry.as(registryId)), activePaneCompositeSettingsKey, viewDescriptorService.getDefaultViewContainer(location)?.id || '', nameForTelemetry, compositeCSSClass, titleForegroundColor, partId, partOptions);
+        this.partId = partId;
+        this.activePaneContextKey = activePaneContextKey;
+        this.paneFocusContextKey = paneFocusContextKey;
+        this.viewDescriptorService = viewDescriptorService;
+        this.contextKeyService = contextKeyService;
+        this.extensionService = extensionService;
+        this.menuService = menuService;
+        this.onDidPaneCompositeClose = this.onDidCompositeClose.event;
+        this.headerFooterCompositeBarDispoables = this._register(( new DisposableStore()));
+        this.paneCompositeBar = this._register(( new MutableDisposable()));
+        this.compositeBarPosition = undefined;
+        this.blockOpening = false;
+        this.location = location;
+        this.globalActions = this._register(this.instantiationService.createInstance(CompositeMenuActions, globalActionsMenuId, undefined, undefined));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.onDidPaneCompositeOpen(composite => this.onDidOpen(composite)));
+        this._register(this.onDidPaneCompositeClose(this.onDidClose, this));
+        this._register(this.globalActions.onDidChange(() => this.updateGlobalToolbarActions()));
+        this._register(this.registry.onDidDeregister((viewletDescriptor) => {
+            const activeContainers = this.viewDescriptorService.getViewContainersByLocation(this.location)
+                .filter(container => this.viewDescriptorService.getViewContainerModel(container).activeViewDescriptors.length > 0);
+            if (activeContainers.length) {
+                if (this.getActiveComposite()?.getId() === viewletDescriptor.id) {
+                    const defaultViewletId = this.viewDescriptorService.getDefaultViewContainer(this.location)?.id;
+                    const containerToOpen = activeContainers.filter(c => c.id === defaultViewletId)[0] || activeContainers[0];
+                    this.doOpenPaneComposite(containerToOpen.id);
+                }
+            }
+            else {
+                this.layoutService.setPartHidden(true, this.partId);
+            }
+            this.removeComposite(viewletDescriptor.id);
+        }));
+        this._register(this.extensionService.onDidRegisterExtensions(() => {
+            this.layoutCompositeBar();
+        }));
+    }
+    onDidOpen(composite) {
+        this.activePaneContextKey.set(composite.getId());
+    }
+    onDidClose(composite) {
+        const id = composite.getId();
+        if (this.activePaneContextKey.get() === id) {
+            this.activePaneContextKey.reset();
+        }
+    }
+    showComposite(composite) {
+        super.showComposite(composite);
+        this.layoutCompositeBar();
+        this.layoutEmptyMessage();
+    }
+    hideActiveComposite() {
+        const composite = super.hideActiveComposite();
+        this.layoutCompositeBar();
+        this.layoutEmptyMessage();
+        return composite;
+    }
+    create(parent) {
+        this.element = parent;
+        this.element.classList.add('pane-composite-part');
+        super.create(parent);
+        const contentArea = this.getContentArea();
+        if (contentArea) {
+            this.createEmptyPaneMessage(contentArea);
+        }
+        this.updateCompositeBar();
+        const focusTracker = this._register(trackFocus(parent));
+        this._register(focusTracker.onDidFocus(() => this.paneFocusContextKey.set(true)));
+        this._register(focusTracker.onDidBlur(() => this.paneFocusContextKey.set(false)));
+    }
+    createEmptyPaneMessage(parent) {
+        this.emptyPaneMessageElement = document.createElement('div');
+        this.emptyPaneMessageElement.classList.add('empty-pane-message-area');
+        const messageElement = document.createElement('div');
+        messageElement.classList.add('empty-pane-message');
+        messageElement.innerText = ( localizeWithPath(
+            'vs/workbench/browser/parts/paneCompositePart',
+            'pane.emptyMessage',
+            "Drag a view here to display."
+        ));
+        this.emptyPaneMessageElement.appendChild(messageElement);
+        parent.appendChild(this.emptyPaneMessageElement);
+        this._register(CompositeDragAndDropObserver.INSTANCE.registerTarget(this.emptyPaneMessageElement, {
+            onDragOver: (e) => {
+                EventHelper.stop(e.eventData, true);
+                if (this.paneCompositeBar.value) {
+                    const validDropTarget = this.paneCompositeBar.value.dndHandler.onDragEnter(e.dragAndDropData, undefined, e.eventData);
+                    toggleDropEffect(e.eventData.dataTransfer, 'move', validDropTarget);
+                }
+            },
+            onDragEnter: (e) => {
+                EventHelper.stop(e.eventData, true);
+                if (this.paneCompositeBar.value) {
+                    const validDropTarget = this.paneCompositeBar.value.dndHandler.onDragEnter(e.dragAndDropData, undefined, e.eventData);
+                    this.emptyPaneMessageElement.style.backgroundColor = validDropTarget ? this.theme.getColor(EDITOR_DRAG_AND_DROP_BACKGROUND)?.toString() || '' : '';
+                }
+            },
+            onDragLeave: (e) => {
+                EventHelper.stop(e.eventData, true);
+                this.emptyPaneMessageElement.style.backgroundColor = '';
+            },
+            onDragEnd: (e) => {
+                EventHelper.stop(e.eventData, true);
+                this.emptyPaneMessageElement.style.backgroundColor = '';
+            },
+            onDrop: (e) => {
+                EventHelper.stop(e.eventData, true);
+                this.emptyPaneMessageElement.style.backgroundColor = '';
+                if (this.paneCompositeBar.value) {
+                    this.paneCompositeBar.value.dndHandler.drop(e.dragAndDropData, undefined, e.eventData);
+                }
+            },
+        }));
+    }
+    createTitleArea(parent) {
+        const titleArea = super.createTitleArea(parent);
+        this._register(addDisposableListener(titleArea, EventType.CONTEXT_MENU, e => {
+            this.onTitleAreaContextMenu(( new StandardMouseEvent(getWindow(titleArea), e)));
+        }));
+        this._register(Gesture.addTarget(titleArea));
+        this._register(addDisposableListener(titleArea, EventType$1.Contextmenu, e => {
+            this.onTitleAreaContextMenu(( new StandardMouseEvent(getWindow(titleArea), e)));
+        }));
+        const globalTitleActionsContainer = titleArea.appendChild($('.global-actions'));
+        this.globalToolBar = this._register(( new ToolBar(globalTitleActionsContainer, this.contextMenuService, {
+            actionViewItemProvider: (action, options) => this.actionViewItemProvider(action, options),
+            orientation: 0 ,
+            getKeyBinding: action => this.keybindingService.lookupKeybinding(action.id),
+            anchorAlignmentProvider: () => this.getTitleAreaDropDownAnchorAlignment(),
+            toggleMenuTitle: ( localizeWithPath(
+                'vs/workbench/browser/parts/paneCompositePart',
+                'moreActions',
+                "More Actions..."
+            )),
+            hoverDelegate: this.toolbarHoverDelegate
+        })));
+        this.updateGlobalToolbarActions();
+        return titleArea;
+    }
+    createTitleLabel(parent) {
+        this.titleContainer = parent;
+        const titleLabel = super.createTitleLabel(parent);
+        this.titleLabelElement.draggable = true;
+        const draggedItemProvider = () => {
+            const activeViewlet = this.getActivePaneComposite();
+            return { type: 'composite', id: activeViewlet.getId() };
+        };
+        this._register(CompositeDragAndDropObserver.INSTANCE.registerDraggable(this.titleLabelElement, draggedItemProvider, {}));
+        return titleLabel;
+    }
+    updateCompositeBar() {
+        const wasCompositeBarVisible = this.compositeBarPosition !== undefined;
+        const isCompositeBarVisible = this.shouldShowCompositeBar();
+        const previousPosition = this.compositeBarPosition;
+        const newPosition = isCompositeBarVisible ? this.getCompositeBarPosition() : undefined;
+        if (previousPosition === newPosition) {
+            return;
+        }
+        if (wasCompositeBarVisible) {
+            const previousCompositeBarContainer = previousPosition === CompositeBarPosition.TITLE ? this.titleContainer : this.headerFooterCompositeBarContainer;
+            if (!this.paneCompositeBarContainer || !this.paneCompositeBar.value || !previousCompositeBarContainer) {
+                throw new Error('Composite bar containers should exist when removing the previous composite bar');
+            }
+            this.paneCompositeBarContainer.remove();
+            this.paneCompositeBarContainer = undefined;
+            this.paneCompositeBar.value = undefined;
+            previousCompositeBarContainer.classList.remove('has-composite-bar');
+            if (previousPosition === CompositeBarPosition.TOP) {
+                this.removeFooterHeaderArea(true);
+            }
+            else if (previousPosition === CompositeBarPosition.BOTTOM) {
+                this.removeFooterHeaderArea(false);
+            }
+        }
+        let newCompositeBarContainer;
+        switch (newPosition) {
+            case CompositeBarPosition.TOP:
+                newCompositeBarContainer = this.createHeaderArea();
+                break;
+            case CompositeBarPosition.TITLE:
+                newCompositeBarContainer = this.titleContainer;
+                break;
+            case CompositeBarPosition.BOTTOM:
+                newCompositeBarContainer = this.createFooterArea();
+                break;
+        }
+        if (isCompositeBarVisible) {
+            if (this.paneCompositeBarContainer || this.paneCompositeBar.value || !newCompositeBarContainer) {
+                throw new Error('Invalid composite bar state when creating the new composite bar');
+            }
+            newCompositeBarContainer.classList.add('has-composite-bar');
+            this.paneCompositeBarContainer = prepend(newCompositeBarContainer, $('.composite-bar-container'));
+            this.paneCompositeBar.value = this.createCompositeBar();
+            this.paneCompositeBar.value.create(this.paneCompositeBarContainer);
+            if (newPosition === CompositeBarPosition.TOP) {
+                this.setHeaderArea(newCompositeBarContainer);
+            }
+            else if (newPosition === CompositeBarPosition.BOTTOM) {
+                this.setFooterArea(newCompositeBarContainer);
+            }
+        }
+        this.compositeBarPosition = newPosition;
+    }
+    createHeaderArea() {
+        const headerArea = super.createHeaderArea();
+        return this.createHeaderFooterCompositeBarArea(headerArea);
+    }
+    createFooterArea() {
+        const footerArea = super.createFooterArea();
+        return this.createHeaderFooterCompositeBarArea(footerArea);
+    }
+    createHeaderFooterCompositeBarArea(area) {
+        if (this.headerFooterCompositeBarContainer) {
+            throw new Error('Header or Footer composite bar already exists');
+        }
+        this.headerFooterCompositeBarContainer = area;
+        this.headerFooterCompositeBarDispoables.add(addDisposableListener(area, EventType.CONTEXT_MENU, e => {
+            this.onCompositeBarAreaContextMenu(( new StandardMouseEvent(getWindow(area), e)));
+        }));
+        this.headerFooterCompositeBarDispoables.add(Gesture.addTarget(area));
+        this.headerFooterCompositeBarDispoables.add(addDisposableListener(area, EventType$1.Contextmenu, e => {
+            this.onCompositeBarAreaContextMenu(( new StandardMouseEvent(getWindow(area), e)));
+        }));
+        return area;
+    }
+    removeFooterHeaderArea(header) {
+        this.headerFooterCompositeBarContainer = undefined;
+        this.headerFooterCompositeBarDispoables.clear();
+        if (header) {
+            this.removeHeaderArea();
+        }
+        else {
+            this.removeFooterArea();
+        }
+    }
+    createCompositeBar() {
+        return this.instantiationService.createInstance(PaneCompositeBar, this.getCompositeBarOptions(), this.partId, this);
+    }
+    onTitleAreaUpdate(compositeId) {
+        super.onTitleAreaUpdate(compositeId);
+        this.layoutCompositeBar();
+    }
+    async openPaneComposite(id, focus) {
+        if (typeof id === 'string' && this.getPaneComposite(id)) {
+            return this.doOpenPaneComposite(id, focus);
+        }
+        await this.extensionService.whenInstalledExtensionsRegistered();
+        if (typeof id === 'string' && this.getPaneComposite(id)) {
+            return this.doOpenPaneComposite(id, focus);
+        }
+        return undefined;
+    }
+    doOpenPaneComposite(id, focus) {
+        if (this.blockOpening) {
+            return undefined;
+        }
+        if (!this.layoutService.isVisible(this.partId)) {
+            try {
+                this.blockOpening = true;
+                this.layoutService.setPartHidden(false, this.partId);
+            }
+            finally {
+                this.blockOpening = false;
+            }
+        }
+        return this.openComposite(id, focus);
+    }
+    getPaneComposite(id) {
+        return this.registry.getPaneComposite(id);
+    }
+    getPaneComposites() {
+        return this.registry.getPaneComposites()
+            .sort((v1, v2) => {
+            if (typeof v1.order !== 'number') {
+                return 1;
+            }
+            if (typeof v2.order !== 'number') {
+                return -1;
+            }
+            return v1.order - v2.order;
+        });
+    }
+    getPinnedPaneCompositeIds() {
+        return this.paneCompositeBar.value?.getPinnedPaneCompositeIds() ?? [];
+    }
+    getVisiblePaneCompositeIds() {
+        return this.paneCompositeBar.value?.getVisiblePaneCompositeIds() ?? [];
+    }
+    getActivePaneComposite() {
+        return this.getActiveComposite();
+    }
+    getLastActivePaneCompositeId() {
+        return this.getLastActiveCompositeId();
+    }
+    hideActivePaneComposite() {
+        if (this.layoutService.isVisible(this.partId)) {
+            this.layoutService.setPartHidden(true, this.partId);
+        }
+        this.hideActiveComposite();
+    }
+    focusComositeBar() {
+        this.paneCompositeBar.value?.focus();
+    }
+    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 && this.paneCompositeBar.value) {
+            const padding = this.compositeBarPosition === CompositeBarPosition.TITLE ? 16 : 8;
+            const borderWidth = this.partId === "workbench.parts.panel"  ? 0 : 1;
+            let availableWidth = this.contentDimension.width - padding - borderWidth;
+            availableWidth = Math.max(AbstractPaneCompositePart_1.MIN_COMPOSITE_BAR_WIDTH, availableWidth - this.getToolbarWidth());
+            this.paneCompositeBar.value.layout(availableWidth, this.dimension.height);
+        }
+    }
+    layoutEmptyMessage() {
+        const visible = !this.getActiveComposite();
+        this.emptyPaneMessageElement?.classList.toggle('visible', visible);
+        if (visible) {
+            this.titleLabel?.updateTitle('', '');
+        }
+    }
+    updateGlobalToolbarActions() {
+        const primaryActions = this.globalActions.getPrimaryActions();
+        const secondaryActions = this.globalActions.getSecondaryActions();
+        this.globalToolBar?.setActions(prepareActions(primaryActions), prepareActions(secondaryActions));
+    }
+    getToolbarWidth() {
+        if (!this.toolBar || this.compositeBarPosition !== CompositeBarPosition.TITLE) {
+            return 0;
+        }
+        const activePane = this.getActivePaneComposite();
+        if (!activePane) {
+            return 0;
+        }
+        const toolBarWidth = this.toolBar.getItemsWidth() + this.toolBar.getItemsLength() * 4;
+        const globalToolBarWidth = this.globalToolBar ? this.globalToolBar.getItemsWidth() + this.globalToolBar.getItemsLength() * 4 : 0;
+        return toolBarWidth + globalToolBarWidth + 5;
+    }
+    onTitleAreaContextMenu(event) {
+        if (this.shouldShowCompositeBar() && this.getCompositeBarPosition() === CompositeBarPosition.TITLE) {
+            return this.onCompositeBarContextMenu(event);
+        }
+        else {
+            const activePaneComposite = this.getActivePaneComposite();
+            const activePaneCompositeActions = activePaneComposite ? activePaneComposite.getContextMenuActions() : [];
+            if (activePaneCompositeActions.length) {
+                this.contextMenuService.showContextMenu({
+                    getAnchor: () => event,
+                    getActions: () => activePaneCompositeActions,
+                    getActionViewItem: (action, options) => this.actionViewItemProvider(action, options),
+                    actionRunner: activePaneComposite.getActionRunner(),
+                    skipTelemetry: true
+                });
+            }
+        }
+    }
+    onCompositeBarAreaContextMenu(event) {
+        return this.onCompositeBarContextMenu(event);
+    }
+    onCompositeBarContextMenu(event) {
+        if (this.paneCompositeBar.value) {
+            const actions = [...this.paneCompositeBar.value.getContextMenuActions()];
+            if (actions.length) {
+                this.contextMenuService.showContextMenu({
+                    getAnchor: () => event,
+                    getActions: () => actions,
+                    skipTelemetry: true
+                });
+            }
+        }
+    }
+    getViewsSubmenuAction() {
+        const viewPaneContainer = this.getActivePaneComposite()?.getViewPaneContainer();
+        if (viewPaneContainer) {
+            const disposables = ( new DisposableStore());
+            const viewsActions = [];
+            const scopedContextKeyService = disposables.add(this.contextKeyService.createScoped(this.element));
+            scopedContextKeyService.createKey('viewContainer', viewPaneContainer.viewContainer.id);
+            const menu = disposables.add(this.menuService.createMenu(ViewsSubMenu, scopedContextKeyService));
+            createAndFillInActionBarActions(menu, { shouldForwardArgs: true, renderShortTitle: true }, { primary: viewsActions, secondary: [] }, () => true);
+            disposables.dispose();
+            return viewsActions.length > 1 && ( viewsActions.some(a => a.enabled)) ? ( new SubmenuAction('views', ( localizeWithPath('vs/workbench/browser/parts/paneCompositePart', 'views', "Views")), viewsActions)) : undefined;
+        }
+        return undefined;
+    }
+};
+AbstractPaneCompositePart = AbstractPaneCompositePart_1 = ( __decorate([
+    ( __param(8, INotificationService)),
+    ( __param(9, IStorageService)),
+    ( __param(10, IContextMenuService)),
+    ( __param(11, IWorkbenchLayoutService)),
+    ( __param(12, IKeybindingService)),
+    ( __param(13, IInstantiationService)),
+    ( __param(14, IThemeService)),
+    ( __param(15, IViewDescriptorService)),
+    ( __param(16, IContextKeyService)),
+    ( __param(17, IExtensionService)),
+    ( __param(18, IMenuService))
+], AbstractPaneCompositePart));
+
+export { AbstractPaneCompositePart, CompositeBarPosition };

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

@@ -0,0 +1,68 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { AuxiliaryBarPart } from './auxiliarybar/auxiliaryBarPart.js';
+import { PanelPart } from './panel/panelPart.js';
+import { SidebarPart } from './sidebar/sidebarPart.js';
+import { ViewContainerLocations } from 'vscode/vscode/vs/workbench/common/views';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+
+let PaneCompositePartService = class PaneCompositePartService extends Disposable {
+    constructor(instantiationService) {
+        super();
+        this.paneCompositeParts = ( new Map());
+        const panelPart = instantiationService.createInstance(PanelPart);
+        const sideBarPart = instantiationService.createInstance(SidebarPart);
+        const auxiliaryBarPart = instantiationService.createInstance(AuxiliaryBarPart);
+        this.paneCompositeParts.set(1 , panelPart);
+        this.paneCompositeParts.set(0 , sideBarPart);
+        this.paneCompositeParts.set(2 , auxiliaryBarPart);
+        const eventDisposables = this._register(( new DisposableStore()));
+        this.onDidPaneCompositeOpen = Event.any(...( ViewContainerLocations.map(loc => ( Event.map(
+            this.paneCompositeParts.get(loc).onDidPaneCompositeOpen,
+            composite => { return { composite, viewContainerLocation: loc }; },
+            eventDisposables
+        )))));
+        this.onDidPaneCompositeClose = Event.any(...( ViewContainerLocations.map(loc => ( Event.map(
+            this.paneCompositeParts.get(loc).onDidPaneCompositeClose,
+            composite => { return { composite, viewContainerLocation: loc }; },
+            eventDisposables
+        )))));
+    }
+    openPaneComposite(id, viewContainerLocation, focus) {
+        return this.getPartByLocation(viewContainerLocation).openPaneComposite(id, focus);
+    }
+    getActivePaneComposite(viewContainerLocation) {
+        return this.getPartByLocation(viewContainerLocation).getActivePaneComposite();
+    }
+    getPaneComposite(id, viewContainerLocation) {
+        return this.getPartByLocation(viewContainerLocation).getPaneComposite(id);
+    }
+    getPaneComposites(viewContainerLocation) {
+        return this.getPartByLocation(viewContainerLocation).getPaneComposites();
+    }
+    getPinnedPaneCompositeIds(viewContainerLocation) {
+        return this.getPartByLocation(viewContainerLocation).getPinnedPaneCompositeIds();
+    }
+    getVisiblePaneCompositeIds(viewContainerLocation) {
+        return this.getPartByLocation(viewContainerLocation).getVisiblePaneCompositeIds();
+    }
+    getProgressIndicator(id, viewContainerLocation) {
+        return this.getPartByLocation(viewContainerLocation).getProgressIndicator(id);
+    }
+    hideActivePaneComposite(viewContainerLocation) {
+        this.getPartByLocation(viewContainerLocation).hideActivePaneComposite();
+    }
+    getLastActivePaneCompositeId(viewContainerLocation) {
+        return this.getPartByLocation(viewContainerLocation).getLastActivePaneCompositeId();
+    }
+    getPartByLocation(viewContainerLocation) {
+        return assertIsDefined(this.paneCompositeParts.get(viewContainerLocation));
+    }
+};
+PaneCompositePartService = ( __decorate([
+    ( __param(0, IInstantiationService))
+], PaneCompositePartService));
+
+export { PaneCompositePartService };