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

package/dist/vscode/vs/workbench/browser/parts/views/viewPaneContainer.js

@@ -0,0 +1,1020 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { DragAndDropObserver, addDisposableListener, EventType, isAncestor } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
+import { Gesture, EventType as EventType$1 } from 'monaco-editor/esm/vs/base/browser/touch.js';
+import { PaneView } from '../../../../base/browser/ui/splitview/paneview.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+import { toDisposable, dispose, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import "../../../../../../assets/paneviewlet.css";
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuRegistry, MenuId, registerAction2, Action2, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { activeContrastBorder, asCssVariable } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { CompositeMenuActions } from '../../actions.js';
+import { CompositeDragAndDropObserver, toggleDropEffect } from '../../dnd.js';
+import { Component } from '../../../common/component.js';
+import { PANEL_SECTION_DRAG_AND_DROP_BACKGROUND, SIDE_BAR_DRAG_AND_DROP_BACKGROUND, PANEL_SECTION_HEADER_FOREGROUND, SIDE_BAR_SECTION_HEADER_FOREGROUND, PANEL_SECTION_HEADER_BACKGROUND, SIDE_BAR_SECTION_HEADER_BACKGROUND, PANEL_SECTION_HEADER_BORDER, SIDE_BAR_SECTION_HEADER_BORDER, PANEL_SECTION_BORDER } from '../../../common/theme.js';
+import { ViewContainerLocationToString, IViewDescriptorService, ViewVisibilityState, IViewsService } from '../../../common/views.js';
+import { FocusedViewContext } from '../../../common/contextkeys.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+const ViewsSubMenu = ( new MenuId('Views'));
+MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
+    submenu: ViewsSubMenu,
+    title: ( nls.localize('views', "Views")),
+    order: 1,
+    when: ( ContextKeyExpr.equals(
+        'viewContainerLocation',
+        ViewContainerLocationToString(0 )
+    )),
+});
+class ViewPaneDropOverlay extends Themable {
+    get currentDropOperation() {
+        return this._currentDropOperation;
+    }
+    constructor(paneElement, orientation, bounds, location, themeService) {
+        super(themeService);
+        this.paneElement = paneElement;
+        this.orientation = orientation;
+        this.bounds = bounds;
+        this.location = location;
+        this.cleanupOverlayScheduler = this._register(( new RunOnceScheduler(() => this.dispose(), 300)));
+        this.create();
+    }
+    get disposed() {
+        return !!this._disposed;
+    }
+    create() {
+        this.container = document.createElement('div');
+        this.container.id = ViewPaneDropOverlay.OVERLAY_ID;
+        this.container.style.top = '0px';
+        this.paneElement.appendChild(this.container);
+        this.paneElement.classList.add('dragged-over');
+        this._register(toDisposable(() => {
+            this.paneElement.removeChild(this.container);
+            this.paneElement.classList.remove('dragged-over');
+        }));
+        this.overlay = document.createElement('div');
+        this.overlay.classList.add('pane-overlay-indicator');
+        this.container.appendChild(this.overlay);
+        this.registerListeners();
+        this.updateStyles();
+    }
+    updateStyles() {
+        this.overlay.style.backgroundColor = this.getColor(this.location === 1  ? PANEL_SECTION_DRAG_AND_DROP_BACKGROUND : SIDE_BAR_DRAG_AND_DROP_BACKGROUND) || '';
+        const activeContrastBorderColor = this.getColor(activeContrastBorder);
+        this.overlay.style.outlineColor = activeContrastBorderColor || '';
+        this.overlay.style.outlineOffset = activeContrastBorderColor ? '-2px' : '';
+        this.overlay.style.outlineStyle = activeContrastBorderColor ? 'dashed' : '';
+        this.overlay.style.outlineWidth = activeContrastBorderColor ? '2px' : '';
+        this.overlay.style.borderColor = activeContrastBorderColor || '';
+        this.overlay.style.borderStyle = 'solid' ;
+        this.overlay.style.borderWidth = '0px';
+    }
+    registerListeners() {
+        this._register(( new DragAndDropObserver(this.container, {
+            onDragEnter: e => undefined,
+            onDragOver: e => {
+                this.positionOverlay(e.offsetX, e.offsetY);
+                if (this.cleanupOverlayScheduler.isScheduled()) {
+                    this.cleanupOverlayScheduler.cancel();
+                }
+            },
+            onDragLeave: e => this.dispose(),
+            onDragEnd: e => this.dispose(),
+            onDrop: e => {
+                this.dispose();
+            }
+        })));
+        this._register(addDisposableListener(this.container, EventType.MOUSE_OVER, () => {
+            if (!this.cleanupOverlayScheduler.isScheduled()) {
+                this.cleanupOverlayScheduler.schedule();
+            }
+        }));
+    }
+    positionOverlay(mousePosX, mousePosY) {
+        const paneWidth = this.paneElement.clientWidth;
+        const paneHeight = this.paneElement.clientHeight;
+        const splitWidthThreshold = paneWidth / 2;
+        const splitHeightThreshold = paneHeight / 2;
+        let dropDirection;
+        if (this.orientation === 0 ) {
+            if (mousePosY < splitHeightThreshold) {
+                dropDirection = 0 ;
+            }
+            else if (mousePosY >= splitHeightThreshold) {
+                dropDirection = 1 ;
+            }
+        }
+        else if (this.orientation === 1 ) {
+            if (mousePosX < splitWidthThreshold) {
+                dropDirection = 2 ;
+            }
+            else if (mousePosX >= splitWidthThreshold) {
+                dropDirection = 3 ;
+            }
+        }
+        switch (dropDirection) {
+            case 0 :
+                this.doPositionOverlay({ top: '0', left: '0', width: '100%', height: '50%' });
+                break;
+            case 1 :
+                this.doPositionOverlay({ bottom: '0', left: '0', width: '100%', height: '50%' });
+                break;
+            case 2 :
+                this.doPositionOverlay({ top: '0', left: '0', width: '50%', height: '100%' });
+                break;
+            case 3 :
+                this.doPositionOverlay({ top: '0', right: '0', width: '50%', height: '100%' });
+                break;
+            default: {
+                let top = '0';
+                let left = '0';
+                let width = '100%';
+                let height = '100%';
+                if (this.bounds) {
+                    const boundingRect = this.container.getBoundingClientRect();
+                    top = `${this.bounds.top - boundingRect.top}px`;
+                    left = `${this.bounds.left - boundingRect.left}px`;
+                    height = `${this.bounds.bottom - this.bounds.top}px`;
+                    width = `${this.bounds.right - this.bounds.left}px`;
+                }
+                this.doPositionOverlay({ top, left, width, height });
+            }
+        }
+        if ((this.orientation === 0  && paneHeight <= 25) ||
+            (this.orientation === 1  && paneWidth <= 25)) {
+            this.doUpdateOverlayBorder(dropDirection);
+        }
+        else {
+            this.doUpdateOverlayBorder(undefined);
+        }
+        this.overlay.style.opacity = '1';
+        setTimeout(() => this.overlay.classList.add('overlay-move-transition'), 0);
+        this._currentDropOperation = dropDirection;
+    }
+    doUpdateOverlayBorder(direction) {
+        this.overlay.style.borderTopWidth = direction === 0  ? '2px' : '0px';
+        this.overlay.style.borderLeftWidth = direction === 2  ? '2px' : '0px';
+        this.overlay.style.borderBottomWidth = direction === 1  ? '2px' : '0px';
+        this.overlay.style.borderRightWidth = direction === 3  ? '2px' : '0px';
+    }
+    doPositionOverlay(options) {
+        this.container.style.height = '100%';
+        this.overlay.style.top = options.top || '';
+        this.overlay.style.left = options.left || '';
+        this.overlay.style.bottom = options.bottom || '';
+        this.overlay.style.right = options.right || '';
+        this.overlay.style.width = options.width;
+        this.overlay.style.height = options.height;
+    }
+    contains(element) {
+        return element === this.container || element === this.overlay;
+    }
+    dispose() {
+        super.dispose();
+        this._disposed = true;
+    }
+}
+ViewPaneDropOverlay.OVERLAY_ID = 'monaco-pane-drop-overlay';
+let ViewContainerMenuActions = class ViewContainerMenuActions extends CompositeMenuActions {
+    constructor(element, viewContainer, viewDescriptorService, contextKeyService, menuService) {
+        const scopedContextKeyService = contextKeyService.createScoped(element);
+        scopedContextKeyService.createKey('viewContainer', viewContainer.id);
+        const viewContainerLocationKey = scopedContextKeyService.createKey('viewContainerLocation', ViewContainerLocationToString(viewDescriptorService.getViewContainerLocation(viewContainer)));
+        super(MenuId.ViewContainerTitle, MenuId.ViewContainerTitleContext, { shouldForwardArgs: true }, scopedContextKeyService, menuService);
+        this._register(scopedContextKeyService);
+        this._register(Event.filter(viewDescriptorService.onDidChangeContainerLocation, e => e.viewContainer === viewContainer)(() => viewContainerLocationKey.set(ViewContainerLocationToString(viewDescriptorService.getViewContainerLocation(viewContainer)))));
+    }
+};
+ViewContainerMenuActions = ( __decorate([
+    ( __param(2, IViewDescriptorService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IMenuService))
+], ViewContainerMenuActions));
+let ViewPaneContainer = class ViewPaneContainer extends Component {
+    get onDidSashChange() {
+        return assertIsDefined(this.paneview).onDidSashChange;
+    }
+    get panes() {
+        return ( this.paneItems.map(i => i.pane));
+    }
+    get views() {
+        return this.panes;
+    }
+    get length() {
+        return this.paneItems.length;
+    }
+    get menuActions() {
+        return this._menuActions;
+    }
+    constructor(id, options, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService) {
+        super(id, themeService, storageService);
+        this.options = options;
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.layoutService = layoutService;
+        this.contextMenuService = contextMenuService;
+        this.telemetryService = telemetryService;
+        this.extensionService = extensionService;
+        this.storageService = storageService;
+        this.contextService = contextService;
+        this.viewDescriptorService = viewDescriptorService;
+        this.paneItems = [];
+        this.visible = false;
+        this.areExtensionsReady = false;
+        this.didLayout = false;
+        this.viewDisposables = [];
+        this._onTitleAreaUpdate = this._register(( new Emitter()));
+        this.onTitleAreaUpdate = this._onTitleAreaUpdate.event;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this._onDidAddViews = this._register(( new Emitter()));
+        this.onDidAddViews = this._onDidAddViews.event;
+        this._onDidRemoveViews = this._register(( new Emitter()));
+        this.onDidRemoveViews = this._onDidRemoveViews.event;
+        this._onDidChangeViewVisibility = this._register(( new Emitter()));
+        this.onDidChangeViewVisibility = this._onDidChangeViewVisibility.event;
+        this._onDidFocusView = this._register(( new Emitter()));
+        this.onDidFocusView = this._onDidFocusView.event;
+        this._onDidBlurView = this._register(( new Emitter()));
+        this.onDidBlurView = this._onDidBlurView.event;
+        const container = this.viewDescriptorService.getViewContainerById(id);
+        if (!container) {
+            throw new Error('Could not find container');
+        }
+        this.viewContainer = container;
+        this.visibleViewsStorageId = `${id}.numberOfVisibleViews`;
+        this.visibleViewsCountFromCache = this.storageService.getNumber(this.visibleViewsStorageId, 1 , undefined);
+        this._register(toDisposable(() => this.viewDisposables = dispose(this.viewDisposables)));
+        this.viewContainerModel = this.viewDescriptorService.getViewContainerModel(container);
+    }
+    create(parent) {
+        const options = this.options;
+        options.orientation = this.orientation;
+        this.paneview = this._register(( new PaneView(parent, this.options)));
+        if (this._boundarySashes) {
+            this.paneview.setBoundarySashes(this._boundarySashes);
+        }
+        this._register(this.paneview.onDidDrop(({ from, to }) => this.movePane(from, to)));
+        this._register(this.paneview.onDidScroll(_ => this.onDidScrollPane()));
+        this._register(this.paneview.onDidSashReset((index) => this.onDidSashReset(index)));
+        this._register(addDisposableListener(parent, EventType.CONTEXT_MENU, (e) => this.showContextMenu(( new StandardMouseEvent(e)))));
+        this._register(Gesture.addTarget(parent));
+        this._register(addDisposableListener(parent, EventType$1.Contextmenu, (e) => this.showContextMenu(( new StandardMouseEvent(e)))));
+        this._menuActions = this._register(this.instantiationService.createInstance(ViewContainerMenuActions, this.paneview.element, this.viewContainer));
+        this._register(this._menuActions.onDidChange(() => this.updateTitleArea()));
+        let overlay;
+        const getOverlayBounds = () => {
+            const fullSize = parent.getBoundingClientRect();
+            const lastPane = this.panes[this.panes.length - 1].element.getBoundingClientRect();
+            const top = this.orientation === 0  ? lastPane.bottom : fullSize.top;
+            const left = this.orientation === 1  ? lastPane.right : fullSize.left;
+            return {
+                top,
+                bottom: fullSize.bottom,
+                left,
+                right: fullSize.right,
+            };
+        };
+        const inBounds = (bounds, pos) => {
+            return pos.x >= bounds.left && pos.x <= bounds.right && pos.y >= bounds.top && pos.y <= bounds.bottom;
+        };
+        let bounds;
+        this._register(CompositeDragAndDropObserver.INSTANCE.registerTarget(parent, {
+            onDragEnter: (e) => {
+                bounds = getOverlayBounds();
+                if (overlay && overlay.disposed) {
+                    overlay = undefined;
+                }
+                if (!overlay && inBounds(bounds, e.eventData)) {
+                    const dropData = e.dragAndDropData.getData();
+                    if (dropData.type === 'view') {
+                        const oldViewContainer = this.viewDescriptorService.getViewContainerByViewId(dropData.id);
+                        const viewDescriptor = this.viewDescriptorService.getViewDescriptorById(dropData.id);
+                        if (oldViewContainer !== this.viewContainer && (!viewDescriptor || !viewDescriptor.canMoveView || this.viewContainer.rejectAddedViews)) {
+                            return;
+                        }
+                        overlay = ( new ViewPaneDropOverlay(
+                            parent,
+                            undefined,
+                            bounds,
+                            this.viewDescriptorService.getViewContainerLocation(this.viewContainer),
+                            this.themeService
+                        ));
+                    }
+                    if (dropData.type === 'composite' && dropData.id !== this.viewContainer.id) {
+                        const container = this.viewDescriptorService.getViewContainerById(dropData.id);
+                        const viewsToMove = this.viewDescriptorService.getViewContainerModel(container).allViewDescriptors;
+                        if (!( viewsToMove.some(v => !v.canMoveView)) && viewsToMove.length > 0) {
+                            overlay = ( new ViewPaneDropOverlay(
+                                parent,
+                                undefined,
+                                bounds,
+                                this.viewDescriptorService.getViewContainerLocation(this.viewContainer),
+                                this.themeService
+                            ));
+                        }
+                    }
+                }
+            },
+            onDragOver: (e) => {
+                if (overlay && overlay.disposed) {
+                    overlay = undefined;
+                }
+                if (overlay && !inBounds(bounds, e.eventData)) {
+                    overlay.dispose();
+                    overlay = undefined;
+                }
+                if (inBounds(bounds, e.eventData)) {
+                    toggleDropEffect(e.eventData.dataTransfer, 'move', overlay !== undefined);
+                }
+            },
+            onDragLeave: (e) => {
+                overlay?.dispose();
+                overlay = undefined;
+            },
+            onDrop: (e) => {
+                if (overlay) {
+                    const dropData = e.dragAndDropData.getData();
+                    const viewsToMove = [];
+                    if (dropData.type === 'composite' && dropData.id !== this.viewContainer.id) {
+                        const container = this.viewDescriptorService.getViewContainerById(dropData.id);
+                        const allViews = this.viewDescriptorService.getViewContainerModel(container).allViewDescriptors;
+                        if (!( allViews.some(v => !v.canMoveView))) {
+                            viewsToMove.push(...allViews);
+                        }
+                    }
+                    else if (dropData.type === 'view') {
+                        const oldViewContainer = this.viewDescriptorService.getViewContainerByViewId(dropData.id);
+                        const viewDescriptor = this.viewDescriptorService.getViewDescriptorById(dropData.id);
+                        if (oldViewContainer !== this.viewContainer && viewDescriptor && viewDescriptor.canMoveView) {
+                            this.viewDescriptorService.moveViewsToContainer([viewDescriptor], this.viewContainer);
+                        }
+                    }
+                    const paneCount = this.panes.length;
+                    if (viewsToMove.length > 0) {
+                        this.viewDescriptorService.moveViewsToContainer(viewsToMove, this.viewContainer);
+                    }
+                    if (paneCount > 0) {
+                        for (const view of viewsToMove) {
+                            const paneToMove = this.panes.find(p => p.id === view.id);
+                            if (paneToMove) {
+                                this.movePane(paneToMove, this.panes[this.panes.length - 1]);
+                            }
+                        }
+                    }
+                }
+                overlay?.dispose();
+                overlay = undefined;
+            }
+        }));
+        this._register(this.onDidSashChange(() => this.saveViewSizes()));
+        this._register(this.viewContainerModel.onDidAddVisibleViewDescriptors(added => this.onDidAddViewDescriptors(added)));
+        this._register(this.viewContainerModel.onDidRemoveVisibleViewDescriptors(removed => this.onDidRemoveViewDescriptors(removed)));
+        const addedViews = ( this.viewContainerModel.visibleViewDescriptors.map((viewDescriptor, index) => {
+            const size = this.viewContainerModel.getSize(viewDescriptor.id);
+            const collapsed = this.viewContainerModel.isCollapsed(viewDescriptor.id);
+            return ({ viewDescriptor, index, size, collapsed });
+        }));
+        if (addedViews.length) {
+            this.onDidAddViewDescriptors(addedViews);
+        }
+        this.extensionService.whenInstalledExtensionsRegistered().then(() => {
+            this.areExtensionsReady = true;
+            if (this.panes.length) {
+                this.updateTitleArea();
+                this.updateViewHeaders();
+            }
+        });
+        this._register(this.viewContainerModel.onDidChangeActiveViewDescriptors(() => this._onTitleAreaUpdate.fire()));
+    }
+    getTitle() {
+        const containerTitle = this.viewContainerModel.title;
+        if (this.isViewMergedWithContainer()) {
+            const paneItemTitle = this.paneItems[0].pane.title;
+            if (containerTitle === paneItemTitle) {
+                return this.paneItems[0].pane.title;
+            }
+            return paneItemTitle ? `${containerTitle}: ${paneItemTitle}` : containerTitle;
+        }
+        return containerTitle;
+    }
+    showContextMenu(event) {
+        for (const paneItem of this.paneItems) {
+            if (isAncestor(event.target, paneItem.pane.element)) {
+                return;
+            }
+        }
+        event.stopPropagation();
+        event.preventDefault();
+        const anchor = { x: event.posx, y: event.posy };
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => anchor,
+            getActions: () => this.menuActions?.getContextMenuActions() ?? []
+        });
+    }
+    getActionsContext() {
+        return undefined;
+    }
+    getActionViewItem(action) {
+        if (this.isViewMergedWithContainer()) {
+            return this.paneItems[0].pane.getActionViewItem(action);
+        }
+        return createActionViewItem(this.instantiationService, action);
+    }
+    focus() {
+        if (this.lastFocusedPane) {
+            this.lastFocusedPane.focus();
+        }
+        else if (this.paneItems.length > 0) {
+            for (const { pane: pane } of this.paneItems) {
+                if (pane.isExpanded()) {
+                    pane.focus();
+                    return;
+                }
+            }
+        }
+    }
+    get orientation() {
+        switch (this.viewDescriptorService.getViewContainerLocation(this.viewContainer)) {
+            case 0 :
+            case 2 :
+                return 0 ;
+            case 1 :
+                return this.layoutService.getPanelPosition() === 2  ? 1  : 0 ;
+        }
+        return 0 ;
+    }
+    layout(dimension) {
+        if (this.paneview) {
+            if (this.paneview.orientation !== this.orientation) {
+                this.paneview.flipOrientation(dimension.height, dimension.width);
+            }
+            this.paneview.layout(dimension.height, dimension.width);
+        }
+        this.dimension = dimension;
+        if (this.didLayout) {
+            this.saveViewSizes();
+        }
+        else {
+            this.didLayout = true;
+            this.restoreViewSizes();
+        }
+    }
+    setBoundarySashes(sashes) {
+        this._boundarySashes = sashes;
+        this.paneview?.setBoundarySashes(sashes);
+    }
+    getOptimalWidth() {
+        const additionalMargin = 16;
+        const optimalWidth = Math.max(...( this.panes.map(view => view.getOptimalWidth() || 0)));
+        return optimalWidth + additionalMargin;
+    }
+    addPanes(panes) {
+        const wasMerged = this.isViewMergedWithContainer();
+        for (const { pane: pane, size, index } of panes) {
+            this.addPane(pane, size, index);
+        }
+        this.updateViewHeaders();
+        if (this.isViewMergedWithContainer() !== wasMerged) {
+            this.updateTitleArea();
+        }
+        this._onDidAddViews.fire(( panes.map(({ pane }) => pane)));
+    }
+    setVisible(visible) {
+        if (this.visible !== !!visible) {
+            this.visible = visible;
+            this._onDidChangeVisibility.fire(visible);
+        }
+        this.panes.filter(view => view.isVisible() !== visible)
+            .forEach((view) => view.setVisible(visible));
+    }
+    isVisible() {
+        return this.visible;
+    }
+    updateTitleArea() {
+        this._onTitleAreaUpdate.fire();
+    }
+    createView(viewDescriptor, options) {
+        return this.instantiationService.createInstance(viewDescriptor.ctorDescriptor.ctor, ...(viewDescriptor.ctorDescriptor.staticArguments || []), options);
+    }
+    getView(id) {
+        return this.panes.filter(view => view.id === id)[0];
+    }
+    saveViewSizes() {
+        if (this.didLayout) {
+            this.viewContainerModel.setSizes(( this.panes.map(view => ({ id: view.id, size: this.getPaneSize(view) }))));
+        }
+    }
+    restoreViewSizes() {
+        if (this.didLayout) {
+            let initialSizes;
+            for (let i = 0; i < this.viewContainerModel.visibleViewDescriptors.length; i++) {
+                const pane = this.panes[i];
+                const viewDescriptor = this.viewContainerModel.visibleViewDescriptors[i];
+                const size = this.viewContainerModel.getSize(viewDescriptor.id);
+                if (typeof size === 'number') {
+                    this.resizePane(pane, size);
+                }
+                else {
+                    initialSizes = initialSizes ? initialSizes : this.computeInitialSizes();
+                    this.resizePane(pane, initialSizes.get(pane.id) || 200);
+                }
+            }
+        }
+    }
+    computeInitialSizes() {
+        const sizes = ( new Map());
+        if (this.dimension) {
+            const totalWeight = this.viewContainerModel.visibleViewDescriptors.reduce((totalWeight, { weight }) => totalWeight + (weight || 20), 0);
+            for (const viewDescriptor of this.viewContainerModel.visibleViewDescriptors) {
+                if (this.orientation === 0 ) {
+                    sizes.set(viewDescriptor.id, this.dimension.height * (viewDescriptor.weight || 20) / totalWeight);
+                }
+                else {
+                    sizes.set(viewDescriptor.id, this.dimension.width * (viewDescriptor.weight || 20) / totalWeight);
+                }
+            }
+        }
+        return sizes;
+    }
+    saveState() {
+        this.panes.forEach((view) => view.saveState());
+        this.storageService.store(this.visibleViewsStorageId, this.length, 1 , 0 );
+    }
+    onContextMenu(event, viewPane) {
+        event.stopPropagation();
+        event.preventDefault();
+        const actions = viewPane.menuActions.getContextMenuActions();
+        const anchor = { x: event.posx, y: event.posy };
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => anchor,
+            getActions: () => actions
+        });
+    }
+    openView(id, focus) {
+        let view = this.getView(id);
+        if (!view) {
+            this.toggleViewVisibility(id);
+        }
+        view = this.getView(id);
+        if (view) {
+            view.setExpanded(true);
+            if (focus) {
+                view.focus();
+            }
+        }
+        return view;
+    }
+    onDidAddViewDescriptors(added) {
+        const panesToAdd = [];
+        for (const { viewDescriptor, collapsed, index, size } of added) {
+            const pane = this.createView(viewDescriptor, {
+                id: viewDescriptor.id,
+                title: viewDescriptor.name,
+                fromExtensionId: viewDescriptor.extensionId,
+                expanded: !collapsed
+            });
+            pane.render();
+            const contextMenuDisposable = addDisposableListener(pane.draggableElement, 'contextmenu', e => {
+                e.stopPropagation();
+                e.preventDefault();
+                this.onContextMenu(( new StandardMouseEvent(e)), pane);
+            });
+            const collapseDisposable = Event.latch(( Event.map(pane.onDidChange, () => !pane.isExpanded())))(collapsed => {
+                this.viewContainerModel.setCollapsed(viewDescriptor.id, collapsed);
+            });
+            this.viewDisposables.splice(index, 0, combinedDisposable(contextMenuDisposable, collapseDisposable));
+            panesToAdd.push({ pane, size: size || pane.minimumSize, index });
+        }
+        this.addPanes(panesToAdd);
+        this.restoreViewSizes();
+        const panes = [];
+        for (const { pane } of panesToAdd) {
+            pane.setVisible(this.isVisible());
+            panes.push(pane);
+        }
+        return panes;
+    }
+    onDidRemoveViewDescriptors(removed) {
+        removed = removed.sort((a, b) => b.index - a.index);
+        const panesToRemove = [];
+        for (const { index } of removed) {
+            const [disposable] = this.viewDisposables.splice(index, 1);
+            disposable.dispose();
+            panesToRemove.push(this.panes[index]);
+        }
+        this.removePanes(panesToRemove);
+        for (const pane of panesToRemove) {
+            pane.setVisible(false);
+        }
+    }
+    toggleViewVisibility(viewId) {
+        if (( this.viewContainerModel.activeViewDescriptors.some(viewDescriptor => viewDescriptor.id === viewId))) {
+            const visible = !this.viewContainerModel.isVisible(viewId);
+            this.viewContainerModel.setVisible(viewId, visible);
+        }
+    }
+    addPane(pane, size, index = this.paneItems.length - 1) {
+        const onDidFocus = pane.onDidFocus(() => {
+            this._onDidFocusView.fire(pane);
+            this.lastFocusedPane = pane;
+        });
+        const onDidBlur = pane.onDidBlur(() => this._onDidBlurView.fire(pane));
+        const onDidChangeTitleArea = pane.onDidChangeTitleArea(() => {
+            if (this.isViewMergedWithContainer()) {
+                this.updateTitleArea();
+            }
+        });
+        const onDidChangeVisibility = pane.onDidChangeBodyVisibility(() => this._onDidChangeViewVisibility.fire(pane));
+        const onDidChange = pane.onDidChange(() => {
+            if (pane === this.lastFocusedPane && !pane.isExpanded()) {
+                this.lastFocusedPane = undefined;
+            }
+        });
+        const isPanel = this.viewDescriptorService.getViewContainerLocation(this.viewContainer) === 1 ;
+        pane.style({
+            headerForeground: asCssVariable(isPanel ? PANEL_SECTION_HEADER_FOREGROUND : SIDE_BAR_SECTION_HEADER_FOREGROUND),
+            headerBackground: asCssVariable(isPanel ? PANEL_SECTION_HEADER_BACKGROUND : SIDE_BAR_SECTION_HEADER_BACKGROUND),
+            headerBorder: asCssVariable(isPanel ? PANEL_SECTION_HEADER_BORDER : SIDE_BAR_SECTION_HEADER_BORDER),
+            dropBackground: asCssVariable(isPanel ? PANEL_SECTION_DRAG_AND_DROP_BACKGROUND : SIDE_BAR_DRAG_AND_DROP_BACKGROUND),
+            leftBorder: isPanel ? asCssVariable(PANEL_SECTION_BORDER) : undefined
+        });
+        const disposable = combinedDisposable(pane, onDidFocus, onDidBlur, onDidChangeTitleArea, onDidChange, onDidChangeVisibility);
+        const paneItem = { pane, disposable };
+        this.paneItems.splice(index, 0, paneItem);
+        assertIsDefined(this.paneview).addPane(pane, size, index);
+        let overlay;
+        this._register(CompositeDragAndDropObserver.INSTANCE.registerDraggable(pane.draggableElement, () => { return { type: 'view', id: pane.id }; }, {}));
+        this._register(CompositeDragAndDropObserver.INSTANCE.registerTarget(pane.dropTargetElement, {
+            onDragEnter: (e) => {
+                if (!overlay) {
+                    const dropData = e.dragAndDropData.getData();
+                    if (dropData.type === 'view' && dropData.id !== pane.id) {
+                        const oldViewContainer = this.viewDescriptorService.getViewContainerByViewId(dropData.id);
+                        const viewDescriptor = this.viewDescriptorService.getViewDescriptorById(dropData.id);
+                        if (oldViewContainer !== this.viewContainer && (!viewDescriptor || !viewDescriptor.canMoveView || this.viewContainer.rejectAddedViews)) {
+                            return;
+                        }
+                        overlay = ( new ViewPaneDropOverlay(
+                            pane.dropTargetElement,
+                            this.orientation ?? 0 ,
+                            undefined,
+                            this.viewDescriptorService.getViewContainerLocation(this.viewContainer),
+                            this.themeService
+                        ));
+                    }
+                    if (dropData.type === 'composite' && dropData.id !== this.viewContainer.id && !this.viewContainer.rejectAddedViews) {
+                        const container = this.viewDescriptorService.getViewContainerById(dropData.id);
+                        const viewsToMove = this.viewDescriptorService.getViewContainerModel(container).allViewDescriptors;
+                        if (!( viewsToMove.some(v => !v.canMoveView)) && viewsToMove.length > 0) {
+                            overlay = ( new ViewPaneDropOverlay(
+                                pane.dropTargetElement,
+                                this.orientation ?? 0 ,
+                                undefined,
+                                this.viewDescriptorService.getViewContainerLocation(this.viewContainer),
+                                this.themeService
+                            ));
+                        }
+                    }
+                }
+            },
+            onDragOver: (e) => {
+                toggleDropEffect(e.eventData.dataTransfer, 'move', overlay !== undefined);
+            },
+            onDragLeave: (e) => {
+                overlay?.dispose();
+                overlay = undefined;
+            },
+            onDrop: (e) => {
+                if (overlay) {
+                    const dropData = e.dragAndDropData.getData();
+                    const viewsToMove = [];
+                    let anchorView;
+                    if (dropData.type === 'composite' && dropData.id !== this.viewContainer.id && !this.viewContainer.rejectAddedViews) {
+                        const container = this.viewDescriptorService.getViewContainerById(dropData.id);
+                        const allViews = this.viewDescriptorService.getViewContainerModel(container).allViewDescriptors;
+                        if (allViews.length > 0 && !( allViews.some(v => !v.canMoveView))) {
+                            viewsToMove.push(...allViews);
+                            anchorView = allViews[0];
+                        }
+                    }
+                    else if (dropData.type === 'view') {
+                        const oldViewContainer = this.viewDescriptorService.getViewContainerByViewId(dropData.id);
+                        const viewDescriptor = this.viewDescriptorService.getViewDescriptorById(dropData.id);
+                        if (oldViewContainer !== this.viewContainer && viewDescriptor && viewDescriptor.canMoveView && !this.viewContainer.rejectAddedViews) {
+                            viewsToMove.push(viewDescriptor);
+                        }
+                        if (viewDescriptor) {
+                            anchorView = viewDescriptor;
+                        }
+                    }
+                    if (viewsToMove) {
+                        this.viewDescriptorService.moveViewsToContainer(viewsToMove, this.viewContainer);
+                    }
+                    if (anchorView) {
+                        if (overlay.currentDropOperation === 1  ||
+                            overlay.currentDropOperation === 3 ) {
+                            const fromIndex = this.panes.findIndex(p => p.id === anchorView.id);
+                            let toIndex = this.panes.findIndex(p => p.id === pane.id);
+                            if (fromIndex >= 0 && toIndex >= 0) {
+                                if (fromIndex > toIndex) {
+                                    toIndex++;
+                                }
+                                if (toIndex < this.panes.length && toIndex !== fromIndex) {
+                                    this.movePane(this.panes[fromIndex], this.panes[toIndex]);
+                                }
+                            }
+                        }
+                        if (overlay.currentDropOperation === 0  ||
+                            overlay.currentDropOperation === 2 ) {
+                            const fromIndex = this.panes.findIndex(p => p.id === anchorView.id);
+                            let toIndex = this.panes.findIndex(p => p.id === pane.id);
+                            if (fromIndex >= 0 && toIndex >= 0) {
+                                if (fromIndex < toIndex) {
+                                    toIndex--;
+                                }
+                                if (toIndex >= 0 && toIndex !== fromIndex) {
+                                    this.movePane(this.panes[fromIndex], this.panes[toIndex]);
+                                }
+                            }
+                        }
+                        if (viewsToMove.length > 1) {
+                            viewsToMove.slice(1).forEach(view => {
+                                let toIndex = this.panes.findIndex(p => p.id === anchorView.id);
+                                const fromIndex = this.panes.findIndex(p => p.id === view.id);
+                                if (fromIndex >= 0 && toIndex >= 0) {
+                                    if (fromIndex > toIndex) {
+                                        toIndex++;
+                                    }
+                                    if (toIndex < this.panes.length && toIndex !== fromIndex) {
+                                        this.movePane(this.panes[fromIndex], this.panes[toIndex]);
+                                        anchorView = view;
+                                    }
+                                }
+                            });
+                        }
+                    }
+                }
+                overlay?.dispose();
+                overlay = undefined;
+            }
+        }));
+    }
+    removePanes(panes) {
+        const wasMerged = this.isViewMergedWithContainer();
+        panes.forEach(pane => this.removePane(pane));
+        this.updateViewHeaders();
+        if (wasMerged !== this.isViewMergedWithContainer()) {
+            this.updateTitleArea();
+        }
+        this._onDidRemoveViews.fire(panes);
+    }
+    removePane(pane) {
+        const index = this.paneItems.findIndex(i => i.pane === pane);
+        if (index === -1) {
+            return;
+        }
+        if (this.lastFocusedPane === pane) {
+            this.lastFocusedPane = undefined;
+        }
+        assertIsDefined(this.paneview).removePane(pane);
+        const [paneItem] = this.paneItems.splice(index, 1);
+        paneItem.disposable.dispose();
+    }
+    movePane(from, to) {
+        const fromIndex = this.paneItems.findIndex(item => item.pane === from);
+        const toIndex = this.paneItems.findIndex(item => item.pane === to);
+        const fromViewDescriptor = this.viewContainerModel.visibleViewDescriptors[fromIndex];
+        const toViewDescriptor = this.viewContainerModel.visibleViewDescriptors[toIndex];
+        if (fromIndex < 0 || fromIndex >= this.paneItems.length) {
+            return;
+        }
+        if (toIndex < 0 || toIndex >= this.paneItems.length) {
+            return;
+        }
+        const [paneItem] = this.paneItems.splice(fromIndex, 1);
+        this.paneItems.splice(toIndex, 0, paneItem);
+        assertIsDefined(this.paneview).movePane(from, to);
+        this.viewContainerModel.move(fromViewDescriptor.id, toViewDescriptor.id);
+        this.updateTitleArea();
+    }
+    resizePane(pane, size) {
+        assertIsDefined(this.paneview).resizePane(pane, size);
+    }
+    getPaneSize(pane) {
+        return assertIsDefined(this.paneview).getPaneSize(pane);
+    }
+    updateViewHeaders() {
+        if (this.isViewMergedWithContainer()) {
+            if (this.paneItems[0].pane.isExpanded()) {
+                this.lastMergedCollapsedPane = undefined;
+            }
+            else {
+                this.lastMergedCollapsedPane = this.paneItems[0].pane;
+                this.paneItems[0].pane.setExpanded(true);
+            }
+            this.paneItems[0].pane.headerVisible = false;
+        }
+        else {
+            this.paneItems.forEach(i => {
+                i.pane.headerVisible = true;
+                if (i.pane === this.lastMergedCollapsedPane) {
+                    i.pane.setExpanded(false);
+                }
+            });
+            this.lastMergedCollapsedPane = undefined;
+        }
+    }
+    isViewMergedWithContainer() {
+        if (!(this.options.mergeViewWithContainerWhenSingleView && this.paneItems.length === 1)) {
+            return false;
+        }
+        if (!this.areExtensionsReady) {
+            if (this.visibleViewsCountFromCache === undefined) {
+                return this.paneItems[0].pane.isExpanded();
+            }
+            return this.visibleViewsCountFromCache === 1;
+        }
+        return true;
+    }
+    onDidScrollPane() {
+        for (const pane of this.panes) {
+            pane.onDidScrollRoot();
+        }
+    }
+    onDidSashReset(index) {
+        let firstPane = undefined;
+        let secondPane = undefined;
+        for (let i = index; i >= 0; i--) {
+            if (this.paneItems[i].pane?.isVisible() && this.paneItems[i]?.pane.isExpanded()) {
+                firstPane = this.paneItems[i].pane;
+                break;
+            }
+        }
+        for (let i = index + 1; i < this.paneItems.length; i++) {
+            if (this.paneItems[i].pane?.isVisible() && this.paneItems[i]?.pane.isExpanded()) {
+                secondPane = this.paneItems[i].pane;
+                break;
+            }
+        }
+        if (firstPane && secondPane) {
+            const firstPaneSize = this.getPaneSize(firstPane);
+            const secondPaneSize = this.getPaneSize(secondPane);
+            const newFirstPaneSize = Math.ceil((firstPaneSize + secondPaneSize) / 2);
+            const newSecondPaneSize = Math.floor((firstPaneSize + secondPaneSize) / 2);
+            if (firstPaneSize > secondPaneSize) {
+                this.resizePane(firstPane, newFirstPaneSize);
+                this.resizePane(secondPane, newSecondPaneSize);
+            }
+            else {
+                this.resizePane(secondPane, newSecondPaneSize);
+                this.resizePane(firstPane, newFirstPaneSize);
+            }
+        }
+    }
+    dispose() {
+        super.dispose();
+        this.paneItems.forEach(i => i.disposable.dispose());
+        if (this.paneview) {
+            this.paneview.dispose();
+        }
+    }
+};
+ViewPaneContainer = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IWorkbenchLayoutService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, ITelemetryService)),
+    ( __param(7, IExtensionService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, IStorageService)),
+    ( __param(10, IWorkspaceContextService)),
+    ( __param(11, IViewDescriptorService))
+], ViewPaneContainer));
+class ViewPaneContainerAction extends Action2 {
+    constructor(desc) {
+        super(desc);
+        this.desc = desc;
+    }
+    run(accessor, ...args) {
+        const viewPaneContainer = accessor.get(IViewsService).getActiveViewPaneContainerWithId(this.desc.viewPaneContainerId);
+        if (viewPaneContainer) {
+            return this.runInViewPaneContainer(accessor, viewPaneContainer, ...args);
+        }
+    }
+}
+class MoveViewPosition extends Action2 {
+    constructor(desc, offset) {
+        super(desc);
+        this.offset = offset;
+    }
+    async run(accessor) {
+        const viewDescriptorService = accessor.get(IViewDescriptorService);
+        const contextKeyService = accessor.get(IContextKeyService);
+        const viewId = FocusedViewContext.getValue(contextKeyService);
+        if (viewId === undefined) {
+            return;
+        }
+        const viewContainer = viewDescriptorService.getViewContainerByViewId(viewId);
+        const model = viewDescriptorService.getViewContainerModel(viewContainer);
+        const viewDescriptor = model.visibleViewDescriptors.find(vd => vd.id === viewId);
+        const currentIndex = model.visibleViewDescriptors.indexOf(viewDescriptor);
+        if (currentIndex + this.offset < 0 || currentIndex + this.offset >= model.visibleViewDescriptors.length) {
+            return;
+        }
+        const newPosition = model.visibleViewDescriptors[currentIndex + this.offset];
+        model.move(viewDescriptor.id, newPosition.id);
+    }
+}
+registerAction2(class MoveViewUp extends MoveViewPosition {
+    constructor() {
+        super({
+            id: 'views.moveViewUp',
+            title: ( nls.localize('viewMoveUp', "Move View Up")),
+            keybinding: {
+                primary: KeyChord(2048  + 41 , 16 ),
+                weight: 200  + 1,
+                when: ( FocusedViewContext.notEqualsTo(''))
+            }
+        }, -1);
+    }
+});
+registerAction2(class MoveViewLeft extends MoveViewPosition {
+    constructor() {
+        super({
+            id: 'views.moveViewLeft',
+            title: ( nls.localize('viewMoveLeft', "Move View Left")),
+            keybinding: {
+                primary: KeyChord(2048  + 41 , 15 ),
+                weight: 200  + 1,
+                when: ( FocusedViewContext.notEqualsTo(''))
+            }
+        }, -1);
+    }
+});
+registerAction2(class MoveViewDown extends MoveViewPosition {
+    constructor() {
+        super({
+            id: 'views.moveViewDown',
+            title: ( nls.localize('viewMoveDown', "Move View Down")),
+            keybinding: {
+                primary: KeyChord(2048  + 41 , 18 ),
+                weight: 200  + 1,
+                when: ( FocusedViewContext.notEqualsTo(''))
+            }
+        }, 1);
+    }
+});
+registerAction2(class MoveViewRight extends MoveViewPosition {
+    constructor() {
+        super({
+            id: 'views.moveViewRight',
+            title: ( nls.localize('viewMoveRight', "Move View Right")),
+            keybinding: {
+                primary: KeyChord(2048  + 41 , 17 ),
+                weight: 200  + 1,
+                when: ( FocusedViewContext.notEqualsTo(''))
+            }
+        }, 1);
+    }
+});
+registerAction2(class MoveViews extends Action2 {
+    constructor() {
+        super({
+            id: 'vscode.moveViews',
+            title: ( nls.localize('viewsMove', "Move Views")),
+        });
+    }
+    async run(accessor, options) {
+        if (!Array.isArray(options?.viewIds) || typeof options?.destinationId !== 'string') {
+            return Promise.reject('Invalid arguments');
+        }
+        const viewDescriptorService = accessor.get(IViewDescriptorService);
+        const destination = viewDescriptorService.getViewContainerById(options.destinationId);
+        if (!destination) {
+            return;
+        }
+        for (const viewId of options.viewIds) {
+            const viewDescriptor = viewDescriptorService.getViewDescriptorById(viewId);
+            if (viewDescriptor?.canMoveView) {
+                viewDescriptorService.moveViewsToContainer([viewDescriptor], destination, ViewVisibilityState.Default);
+            }
+        }
+        await accessor.get(IViewsService).openViewContainer(destination.id, true);
+    }
+});
+export { ViewPaneContainer, ViewPaneContainerAction, ViewsSubMenu };