@codingame/monaco-vscode-views-service-override 2.1.4 → 2.2.0-next.2

package/vscode/src/vs/workbench/browser/parts/editor/editorPart.js

@@ -1,1020 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { Part } from 'vscode/vscode/vs/workbench/browser/part';
-import { getWindow, getActiveElement, isAncestorOfActiveElement, addDisposableGenericMouseDownListener, EventHelper, Dimension, $ } from 'vscode/vscode/vs/base/browser/dom';
-import { Emitter, Relay, Event } from 'vscode/vscode/vs/base/common/event';
-import { contrastBorder, editorBackground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { isGridBranchNode, createSerializedGrid, Sizing, SerializableGrid } from '../../../../base/browser/ui/grid/grid.js';
-import { EDITOR_GROUP_BORDER, EDITOR_PANE_BACKGROUND } from 'vscode/vscode/vs/workbench/common/theme';
-import { coalesce, distinct } from 'vscode/vscode/vs/base/common/arrays';
-import { getEditorPartOptions, impactsEditorPartOptions } from 'vscode/vscode/vs/workbench/browser/parts/editor/editor';
-import { EditorGroupView } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorGroupView';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { DisposableStore, toDisposable, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { isSerializedEditorGroupModel } from 'vscode/vscode/vs/workbench/common/editor/editorGroupModel';
-import { EditorDropTarget } from './editorDropTarget.js';
-import { Color } from 'vscode/vscode/vs/base/common/color';
-import { CenteredViewLayout } from '../../../../base/browser/ui/centered/centeredViewLayout.js';
-import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
-import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
-import { assertType, assertIsDefined } from 'vscode/vscode/vs/base/common/types';
-import { CompositeDragAndDropObserver } from 'vscode/vscode/vs/workbench/browser/dnd';
-import { DeferredPromise, Promises } from 'vscode/vscode/vs/base/common/async';
-import { findGroup } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupFinder';
-import { SIDE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
-import { IsAuxiliaryEditorPartContext, EditorPartMultipleEditorGroupsContext, EditorPartMaximizedEditorGroupContext } from 'vscode/vscode/vs/workbench/common/contextkeys';
-import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
-import { orthogonal } from '../../../../base/browser/ui/grid/gridview.js';
-
-var EditorPart_1;
-class GridWidgetView {
-    constructor() {
-        this.element = $('.grid-view-container');
-        this._onDidChange = ( new Relay());
-        this.onDidChange = this._onDidChange.event;
-    }
-    get minimumWidth() { return this.gridWidget ? this.gridWidget.minimumWidth : 0; }
-    get maximumWidth() { return this.gridWidget ? this.gridWidget.maximumWidth : Number.POSITIVE_INFINITY; }
-    get minimumHeight() { return this.gridWidget ? this.gridWidget.minimumHeight : 0; }
-    get maximumHeight() { return this.gridWidget ? this.gridWidget.maximumHeight : Number.POSITIVE_INFINITY; }
-    get gridWidget() {
-        return this._gridWidget;
-    }
-    set gridWidget(grid) {
-        this.element.innerText = '';
-        if (grid) {
-            this.element.appendChild(grid.element);
-            this._onDidChange.input = grid.onDidChange;
-        }
-        else {
-            this._onDidChange.input = Event.None;
-        }
-        this._gridWidget = grid;
-    }
-    layout(width, height, top, left) {
-        this.gridWidget?.layout(width, height, top, left);
-    }
-    dispose() {
-        this._onDidChange.dispose();
-    }
-}
-let EditorPart = class EditorPart extends Part {
-    static { EditorPart_1 = this; }
-    static { this.EDITOR_PART_UI_STATE_STORAGE_KEY = 'editorpart.state'; }
-    static { this.EDITOR_PART_CENTERED_VIEW_STORAGE_KEY = 'editorpart.centeredview'; }
-    constructor(editorPartsView, id, groupsLabel, windowId, instantiationService, themeService, configurationService, storageService, layoutService, hostService, contextKeyService) {
-        super(id, { hasTitle: false }, themeService, storageService, layoutService);
-        this.editorPartsView = editorPartsView;
-        this.groupsLabel = groupsLabel;
-        this.windowId = windowId;
-        this.instantiationService = instantiationService;
-        this.configurationService = configurationService;
-        this.hostService = hostService;
-        this.contextKeyService = contextKeyService;
-        this._onDidFocus = this._register(( new Emitter()));
-        this.onDidFocus = this._onDidFocus.event;
-        this._onDidLayout = this._register(( new Emitter()));
-        this.onDidLayout = this._onDidLayout.event;
-        this._onDidChangeActiveGroup = this._register(( new Emitter()));
-        this.onDidChangeActiveGroup = this._onDidChangeActiveGroup.event;
-        this._onDidChangeGroupIndex = this._register(( new Emitter()));
-        this.onDidChangeGroupIndex = this._onDidChangeGroupIndex.event;
-        this._onDidChangeGroupLabel = this._register(( new Emitter()));
-        this.onDidChangeGroupLabel = this._onDidChangeGroupLabel.event;
-        this._onDidChangeGroupLocked = this._register(( new Emitter()));
-        this.onDidChangeGroupLocked = this._onDidChangeGroupLocked.event;
-        this._onDidChangeGroupMaximized = this._register(( new Emitter()));
-        this.onDidChangeGroupMaximized = this._onDidChangeGroupMaximized.event;
-        this._onDidActivateGroup = this._register(( new Emitter()));
-        this.onDidActivateGroup = this._onDidActivateGroup.event;
-        this._onDidAddGroup = this._register(( new Emitter()));
-        this.onDidAddGroup = this._onDidAddGroup.event;
-        this._onDidRemoveGroup = this._register(( new Emitter()));
-        this.onDidRemoveGroup = this._onDidRemoveGroup.event;
-        this._onDidMoveGroup = this._register(( new Emitter()));
-        this.onDidMoveGroup = this._onDidMoveGroup.event;
-        this.onDidSetGridWidget = this._register(( new Emitter()));
-        this._onDidChangeSizeConstraints = this._register(( new Relay()));
-        this.onDidChangeSizeConstraints = Event.any(this.onDidSetGridWidget.event, this._onDidChangeSizeConstraints.event);
-        this._onDidScroll = this._register(( new Relay()));
-        this.onDidScroll = Event.any(this.onDidSetGridWidget.event, this._onDidScroll.event);
-        this._onDidChangeEditorPartOptions = this._register(( new Emitter()));
-        this.onDidChangeEditorPartOptions = this._onDidChangeEditorPartOptions.event;
-        this.workspaceMemento = this.getMemento(1 , 0 );
-        this.profileMemento = this.getMemento(0 , 1 );
-        this.groupViews = ( new Map());
-        this.mostRecentActiveGroups = [];
-        this.gridWidgetDisposables = this._register(( new DisposableStore()));
-        this.gridWidgetView = this._register(( new GridWidgetView()));
-        this.enforcedPartOptions = [];
-        this._partOptions = getEditorPartOptions(this.configurationService, this.themeService);
-        this.top = 0;
-        this.left = 0;
-        this.sideGroup = {
-            openEditor: (editor, options) => {
-                const [group] = this.scopedInstantiationService.invokeFunction(accessor => findGroup(accessor, { editor, options }, SIDE_GROUP));
-                return group.openEditor(editor, options);
-            }
-        };
-        this._isReady = false;
-        this.whenReadyPromise = ( new DeferredPromise());
-        this.whenReady = this.whenReadyPromise.p;
-        this.whenRestoredPromise = ( new DeferredPromise());
-        this.whenRestored = this.whenRestoredPromise.p;
-        this._willRestoreState = false;
-        this.priority = 2 ;
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
-        this._register(this.themeService.onDidFileIconThemeChange(() => this.handleChangedPartOptions()));
-        this._register(this.onDidChangeMementoValue(1 , this._store)(e => this.onDidChangeMementoState(e)));
-    }
-    onConfigurationUpdated(event) {
-        if (impactsEditorPartOptions(event)) {
-            this.handleChangedPartOptions();
-        }
-    }
-    handleChangedPartOptions() {
-        const oldPartOptions = this._partOptions;
-        const newPartOptions = getEditorPartOptions(this.configurationService, this.themeService);
-        for (const enforcedPartOptions of this.enforcedPartOptions) {
-            Object.assign(newPartOptions, enforcedPartOptions);
-        }
-        this._partOptions = newPartOptions;
-        this._onDidChangeEditorPartOptions.fire({ oldPartOptions, newPartOptions });
-    }
-    get partOptions() { return this._partOptions; }
-    enforcePartOptions(options) {
-        this.enforcedPartOptions.push(options);
-        this.handleChangedPartOptions();
-        return toDisposable(() => {
-            this.enforcedPartOptions.splice(this.enforcedPartOptions.indexOf(options), 1);
-            this.handleChangedPartOptions();
-        });
-    }
-    get contentDimension() { return this._contentDimension; }
-    get activeGroup() {
-        return this._activeGroup;
-    }
-    get groups() {
-        return Array.from(( this.groupViews.values()));
-    }
-    get count() {
-        return this.groupViews.size;
-    }
-    get orientation() {
-        return ((this.gridWidget && this.gridWidget.orientation === 0) ) ? 1  : 0 ;
-    }
-    get isReady() { return this._isReady; }
-    get hasRestorableState() {
-        return !!this.workspaceMemento[EditorPart_1.EDITOR_PART_UI_STATE_STORAGE_KEY];
-    }
-    get willRestoreState() { return this._willRestoreState; }
-    getGroups(order = 0 ) {
-        switch (order) {
-            case 0 :
-                return this.groups;
-            case 1 : {
-                const mostRecentActive = coalesce(( this.mostRecentActiveGroups.map(groupId => this.getGroup(groupId))));
-                return distinct([...mostRecentActive, ...this.groups]);
-            }
-            case 2 : {
-                const views = [];
-                if (this.gridWidget) {
-                    this.fillGridNodes(views, this.gridWidget.getViews());
-                }
-                return views;
-            }
-        }
-    }
-    fillGridNodes(target, node) {
-        if (isGridBranchNode(node)) {
-            node.children.forEach(child => this.fillGridNodes(target, child));
-        }
-        else {
-            target.push(node.view);
-        }
-    }
-    hasGroup(identifier) {
-        return ( this.groupViews.has(identifier));
-    }
-    getGroup(identifier) {
-        return this.groupViews.get(identifier);
-    }
-    findGroup(scope, source = this.activeGroup, wrap) {
-        if (typeof scope.direction === 'number') {
-            return this.doFindGroupByDirection(scope.direction, source, wrap);
-        }
-        if (typeof scope.location === 'number') {
-            return this.doFindGroupByLocation(scope.location, source, wrap);
-        }
-        throw new Error('invalid arguments');
-    }
-    doFindGroupByDirection(direction, source, wrap) {
-        const sourceGroupView = this.assertGroupView(source);
-        const neighbours = this.gridWidget.getNeighborViews(sourceGroupView, this.toGridViewDirection(direction), wrap);
-        neighbours.sort(((n1, n2) => this.mostRecentActiveGroups.indexOf(n1.id) - this.mostRecentActiveGroups.indexOf(n2.id)));
-        return neighbours[0];
-    }
-    doFindGroupByLocation(location, source, wrap) {
-        const sourceGroupView = this.assertGroupView(source);
-        const groups = this.getGroups(2 );
-        const index = groups.indexOf(sourceGroupView);
-        switch (location) {
-            case 0 :
-                return groups[0];
-            case 1 :
-                return groups[groups.length - 1];
-            case 2 : {
-                let nextGroup = groups[index + 1];
-                if (!nextGroup && wrap) {
-                    nextGroup = this.doFindGroupByLocation(0 , source);
-                }
-                return nextGroup;
-            }
-            case 3 : {
-                let previousGroup = groups[index - 1];
-                if (!previousGroup && wrap) {
-                    previousGroup = this.doFindGroupByLocation(1 , source);
-                }
-                return previousGroup;
-            }
-        }
-    }
-    activateGroup(group, preserveWindowOrder) {
-        const groupView = this.assertGroupView(group);
-        this.doSetGroupActive(groupView);
-        if (!preserveWindowOrder) {
-            this.hostService.moveTop(getWindow(this.element));
-        }
-        return groupView;
-    }
-    restoreGroup(group) {
-        const groupView = this.assertGroupView(group);
-        this.doRestoreGroup(groupView);
-        return groupView;
-    }
-    getSize(group) {
-        const groupView = this.assertGroupView(group);
-        return this.gridWidget.getViewSize(groupView);
-    }
-    setSize(group, size) {
-        const groupView = this.assertGroupView(group);
-        this.gridWidget.resizeView(groupView, size);
-    }
-    arrangeGroups(arrangement, target = this.activeGroup) {
-        if (this.count < 2) {
-            return;
-        }
-        if (!this.gridWidget) {
-            return;
-        }
-        const groupView = this.assertGroupView(target);
-        switch (arrangement) {
-            case 2 :
-                this.gridWidget.distributeViewSizes();
-                break;
-            case 0 :
-                if (this.groups.length < 2) {
-                    return;
-                }
-                this.gridWidget.maximizeView(groupView);
-                groupView.focus();
-                break;
-            case 1 :
-                this.gridWidget.expandView(groupView);
-                break;
-        }
-    }
-    toggleMaximizeGroup(target = this.activeGroup) {
-        if (this.hasMaximizedGroup()) {
-            this.unmaximizeGroup();
-        }
-        else {
-            this.arrangeGroups(0 , target);
-        }
-    }
-    toggleExpandGroup(target = this.activeGroup) {
-        if (this.isGroupExpanded(this.activeGroup)) {
-            this.arrangeGroups(2 );
-        }
-        else {
-            this.arrangeGroups(1 , target);
-        }
-    }
-    unmaximizeGroup() {
-        this.gridWidget.exitMaximizedView();
-        this._activeGroup.focus();
-    }
-    hasMaximizedGroup() {
-        return this.gridWidget.hasMaximizedView();
-    }
-    isGroupMaximized(targetGroup) {
-        return this.gridWidget.isViewMaximized(targetGroup);
-    }
-    isGroupExpanded(targetGroup) {
-        return this.gridWidget.isViewExpanded(targetGroup);
-    }
-    setGroupOrientation(orientation) {
-        if (!this.gridWidget) {
-            return;
-        }
-        const newOrientation = ((orientation === 0) ) ? 1  : 0 ;
-        if (this.gridWidget.orientation !== newOrientation) {
-            this.gridWidget.orientation = newOrientation;
-        }
-    }
-    applyLayout(layout) {
-        const restoreFocus = this.shouldRestoreFocus(this.container);
-        let layoutGroupsCount = 0;
-        function countGroups(groups) {
-            for (const group of groups) {
-                if (Array.isArray(group.groups)) {
-                    countGroups(group.groups);
-                }
-                else {
-                    layoutGroupsCount++;
-                }
-            }
-        }
-        countGroups(layout.groups);
-        let currentGroupViews = this.getGroups(2 );
-        if (layoutGroupsCount < currentGroupViews.length) {
-            const lastGroupInLayout = currentGroupViews[layoutGroupsCount - 1];
-            currentGroupViews.forEach((group, index) => {
-                if (index >= layoutGroupsCount) {
-                    this.mergeGroup(group, lastGroupInLayout);
-                }
-            });
-            currentGroupViews = this.getGroups(2 );
-        }
-        const activeGroup = this.activeGroup;
-        const gridDescriptor = createSerializedGrid({
-            orientation: this.toGridViewOrientation(layout.orientation, this.isTwoDimensionalGrid() ?
-                this.gridWidget.orientation :
-                orthogonal(this.gridWidget.orientation)
-            ),
-            groups: layout.groups
-        });
-        this.doApplyGridState(gridDescriptor, activeGroup.id, currentGroupViews);
-        if (restoreFocus) {
-            this._activeGroup.focus();
-        }
-    }
-    getLayout() {
-        const serializedGrid = this.gridWidget.serialize();
-        const orientation = serializedGrid.orientation === 1  ? 0  : 1 ;
-        const root = this.serializedNodeToGroupLayoutArgument(serializedGrid.root);
-        return {
-            orientation,
-            groups: root.groups
-        };
-    }
-    serializedNodeToGroupLayoutArgument(serializedNode) {
-        if (serializedNode.type === 'branch') {
-            return {
-                size: serializedNode.size,
-                groups: ( serializedNode.data.map(node => this.serializedNodeToGroupLayoutArgument(node)))
-            };
-        }
-        return { size: serializedNode.size };
-    }
-    shouldRestoreFocus(target) {
-        if (!target) {
-            return false;
-        }
-        const activeElement = getActiveElement();
-        if (activeElement === target.ownerDocument.body) {
-            return true;
-        }
-        return isAncestorOfActiveElement(target);
-    }
-    isTwoDimensionalGrid() {
-        const views = this.gridWidget.getViews();
-        if (isGridBranchNode(views)) {
-            return ( views.children.some(child => isGridBranchNode(child)));
-        }
-        return false;
-    }
-    addGroup(location, direction, groupToCopy) {
-        const locationView = this.assertGroupView(location);
-        let newGroupView;
-        if (locationView.groupsView === this) {
-            const restoreFocus = this.shouldRestoreFocus(locationView.element);
-            const shouldExpand = this.groupViews.size > 1 && this.isGroupExpanded(locationView);
-            newGroupView = this.doCreateGroupView(groupToCopy);
-            this.gridWidget.addView(newGroupView, this.getSplitSizingStyle(), locationView, this.toGridViewDirection(direction));
-            this.updateContainer();
-            this._onDidAddGroup.fire(newGroupView);
-            this.notifyGroupIndexChange();
-            if (shouldExpand) {
-                this.arrangeGroups(1 , newGroupView);
-            }
-            if (restoreFocus) {
-                locationView.focus();
-            }
-        }
-        else {
-            newGroupView = locationView.groupsView.addGroup(locationView, direction, groupToCopy);
-        }
-        return newGroupView;
-    }
-    getSplitSizingStyle() {
-        switch (this._partOptions.splitSizing) {
-            case 'distribute':
-                return Sizing.Distribute;
-            case 'split':
-                return Sizing.Split;
-            default:
-                return Sizing.Auto;
-        }
-    }
-    doCreateGroupView(from) {
-        let groupView;
-        if (from instanceof EditorGroupView) {
-            groupView = EditorGroupView.createCopy(from, this.editorPartsView, this, this.groupsLabel, this.count, this.scopedInstantiationService);
-        }
-        else if (isSerializedEditorGroupModel(from)) {
-            groupView = EditorGroupView.createFromSerialized(from, this.editorPartsView, this, this.groupsLabel, this.count, this.scopedInstantiationService);
-        }
-        else {
-            groupView = EditorGroupView.createNew(this.editorPartsView, this, this.groupsLabel, this.count, this.scopedInstantiationService);
-        }
-        this.groupViews.set(groupView.id, groupView);
-        const groupDisposables = ( new DisposableStore());
-        groupDisposables.add(groupView.onDidFocus(() => {
-            this.doSetGroupActive(groupView);
-            this._onDidFocus.fire();
-        }));
-        groupDisposables.add(groupView.onDidModelChange(e => {
-            switch (e.kind) {
-                case 3 :
-                    this._onDidChangeGroupLocked.fire(groupView);
-                    break;
-                case 1 :
-                    this._onDidChangeGroupIndex.fire(groupView);
-                    break;
-                case 2 :
-                    this._onDidChangeGroupLabel.fire(groupView);
-                    break;
-            }
-        }));
-        groupDisposables.add(groupView.onDidActiveEditorChange(() => {
-            this.updateContainer();
-        }));
-        Event.once(groupView.onWillDispose)(() => {
-            dispose(groupDisposables);
-            this.groupViews.delete(groupView.id);
-            this.doUpdateMostRecentActive(groupView);
-        });
-        return groupView;
-    }
-    doSetGroupActive(group) {
-        if (this._activeGroup !== group) {
-            const previousActiveGroup = this._activeGroup;
-            this._activeGroup = group;
-            this.doUpdateMostRecentActive(group, true);
-            if (previousActiveGroup && !previousActiveGroup.disposed) {
-                previousActiveGroup.setActive(false);
-            }
-            group.setActive(true);
-            this.doRestoreGroup(group);
-            this._onDidChangeActiveGroup.fire(group);
-        }
-        this._onDidActivateGroup.fire(group);
-    }
-    doRestoreGroup(group) {
-        if (!this.gridWidget) {
-            return;
-        }
-        if (this.hasMaximizedGroup() && !this.isGroupMaximized(group)) {
-            this.unmaximizeGroup();
-        }
-        try {
-            const viewSize = this.gridWidget.getViewSize(group);
-            if (viewSize.width === group.minimumWidth || viewSize.height === group.minimumHeight) {
-                this.arrangeGroups(1 , group);
-            }
-        }
-        catch (error) {
-        }
-    }
-    doUpdateMostRecentActive(group, makeMostRecentlyActive) {
-        const index = this.mostRecentActiveGroups.indexOf(group.id);
-        if (index !== -1) {
-            this.mostRecentActiveGroups.splice(index, 1);
-        }
-        if (makeMostRecentlyActive) {
-            this.mostRecentActiveGroups.unshift(group.id);
-        }
-    }
-    toGridViewDirection(direction) {
-        switch (direction) {
-            case 0 : return 0 ;
-            case 1 : return 1 ;
-            case 2 : return 2 ;
-            case 3 : return 3 ;
-        }
-    }
-    toGridViewOrientation(orientation, fallback) {
-        if (typeof orientation === 'number') {
-            return orientation === 0  ? 1  : 0 ;
-        }
-        return fallback;
-    }
-    removeGroup(group, preserveFocus) {
-        const groupView = this.assertGroupView(group);
-        if (this.count === 1) {
-            return;
-        }
-        if (groupView.isEmpty) {
-            this.doRemoveEmptyGroup(groupView, preserveFocus);
-        }
-        else {
-            this.doRemoveGroupWithEditors(groupView);
-        }
-    }
-    doRemoveGroupWithEditors(groupView) {
-        const mostRecentlyActiveGroups = this.getGroups(1 );
-        let lastActiveGroup;
-        if (this._activeGroup === groupView) {
-            lastActiveGroup = mostRecentlyActiveGroups[1];
-        }
-        else {
-            lastActiveGroup = mostRecentlyActiveGroups[0];
-        }
-        this.mergeGroup(groupView, lastActiveGroup);
-    }
-    doRemoveEmptyGroup(groupView, preserveFocus) {
-        const restoreFocus = !preserveFocus && this.shouldRestoreFocus(this.container);
-        if (this._activeGroup === groupView) {
-            const mostRecentlyActiveGroups = this.getGroups(1 );
-            const nextActiveGroup = mostRecentlyActiveGroups[1];
-            this.doSetGroupActive(nextActiveGroup);
-        }
-        this.gridWidget.removeView(groupView, this.getSplitSizingStyle());
-        groupView.dispose();
-        if (restoreFocus) {
-            this._activeGroup.focus();
-        }
-        this.notifyGroupIndexChange();
-        this.updateContainer();
-        this._onDidRemoveGroup.fire(groupView);
-    }
-    moveGroup(group, location, direction) {
-        const sourceView = this.assertGroupView(group);
-        const targetView = this.assertGroupView(location);
-        if (sourceView.id === targetView.id) {
-            throw new Error('Cannot move group into its own');
-        }
-        const restoreFocus = this.shouldRestoreFocus(sourceView.element);
-        let movedView;
-        if (sourceView.groupsView === targetView.groupsView) {
-            this.gridWidget.moveView(sourceView, this.getSplitSizingStyle(), targetView, this.toGridViewDirection(direction));
-            movedView = sourceView;
-        }
-        else {
-            movedView = targetView.groupsView.addGroup(targetView, direction, sourceView);
-            sourceView.closeAllEditors();
-            this.removeGroup(sourceView, restoreFocus);
-        }
-        if (restoreFocus) {
-            movedView.focus();
-        }
-        this._onDidMoveGroup.fire(movedView);
-        this.notifyGroupIndexChange();
-        return movedView;
-    }
-    copyGroup(group, location, direction) {
-        const groupView = this.assertGroupView(group);
-        const locationView = this.assertGroupView(location);
-        const restoreFocus = this.shouldRestoreFocus(groupView.element);
-        const copiedGroupView = this.addGroup(locationView, direction, groupView);
-        if (restoreFocus) {
-            copiedGroupView.focus();
-        }
-        return copiedGroupView;
-    }
-    mergeGroup(group, target, options) {
-        const sourceView = this.assertGroupView(group);
-        const targetView = this.assertGroupView(target);
-        const editors = [];
-        let index = (options && typeof options.index === 'number') ? options.index : targetView.count;
-        for (const editor of sourceView.editors) {
-            const inactive = !sourceView.isActive(editor) || this._activeGroup !== sourceView;
-            const sticky = sourceView.isSticky(editor);
-            const options = { index: !sticky ? index : undefined , inactive, preserveFocus: inactive };
-            editors.push({ editor, options });
-            index++;
-        }
-        if (options?.mode === 0 ) {
-            sourceView.copyEditors(editors, targetView);
-        }
-        else {
-            sourceView.moveEditors(editors, targetView);
-        }
-        if (sourceView.isEmpty && !sourceView.disposed ) {
-            this.removeGroup(sourceView, true);
-        }
-        return targetView;
-    }
-    mergeAllGroups(target) {
-        const targetView = this.assertGroupView(target);
-        for (const group of this.getGroups(1 )) {
-            if (group === targetView) {
-                continue;
-            }
-            this.mergeGroup(group, targetView);
-        }
-        return targetView;
-    }
-    assertGroupView(group) {
-        let groupView;
-        if (typeof group === 'number') {
-            groupView = this.editorPartsView.getGroup(group);
-        }
-        else {
-            groupView = group;
-        }
-        if (!groupView) {
-            throw new Error('Invalid editor group provided!');
-        }
-        return groupView;
-    }
-    createEditorDropTarget(container, delegate) {
-        assertType(container instanceof HTMLElement);
-        return this.scopedInstantiationService.createInstance(EditorDropTarget, container, delegate);
-    }
-    get minimumWidth() { return Math.min(this.centeredLayoutWidget.minimumWidth, this.layoutService.getMaximumEditorDimensions(this.layoutService.getContainer(getWindow(this.container))).width); }
-    get maximumWidth() { return this.centeredLayoutWidget.maximumWidth; }
-    get minimumHeight() { return Math.min(this.centeredLayoutWidget.minimumHeight, this.layoutService.getMaximumEditorDimensions(this.layoutService.getContainer(getWindow(this.container))).height); }
-    get maximumHeight() { return this.centeredLayoutWidget.maximumHeight; }
-    get snap() { return this.layoutService.getPanelAlignment() === 'center'; }
-    get onDidChange() { return Event.any(this.centeredLayoutWidget.onDidChange, this.onDidSetGridWidget.event); }
-    get gridSeparatorBorder() {
-        return this.theme.getColor(EDITOR_GROUP_BORDER) || this.theme.getColor(contrastBorder) || Color.transparent;
-    }
-    updateStyles() {
-        const container = assertIsDefined(this.container);
-        container.style.backgroundColor = this.getColor(editorBackground) || '';
-        const separatorBorderStyle = { separatorBorder: this.gridSeparatorBorder, background: this.theme.getColor(EDITOR_PANE_BACKGROUND) || Color.transparent };
-        this.gridWidget.style(separatorBorderStyle);
-        this.centeredLayoutWidget.styles(separatorBorderStyle);
-    }
-    createContentArea(parent, options) {
-        this.element = parent;
-        this.container = document.createElement('div');
-        this.container.classList.add('content');
-        if (this.windowId !== mainWindow.vscodeWindowId) {
-            this.container.classList.add('auxiliary');
-        }
-        parent.appendChild(this.container);
-        const scopedContextKeyService = this._register(this.contextKeyService.createScoped(this.container));
-        this.scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, scopedContextKeyService])));
-        this._willRestoreState = !options || options.restorePreviousState;
-        this.doCreateGridControl();
-        this.centeredLayoutWidget = this._register(( new CenteredViewLayout(
-            this.container,
-            this.gridWidgetView,
-            this.profileMemento[EditorPart_1.EDITOR_PART_CENTERED_VIEW_STORAGE_KEY],
-            this._partOptions.centeredLayoutFixedWidth
-        )));
-        this._register(this.onDidChangeEditorPartOptions(e => this.centeredLayoutWidget.setFixedWidth(e.newPartOptions.centeredLayoutFixedWidth ?? false)));
-        this.setupDragAndDropSupport(parent, this.container);
-        this.handleContextKeys(scopedContextKeyService);
-        this.whenReadyPromise.complete();
-        this._isReady = true;
-        Promises.settled(( this.groups.map(group => group.whenRestored))).finally(() => {
-            this.whenRestoredPromise.complete();
-        });
-        return this.container;
-    }
-    handleContextKeys(contextKeyService) {
-        const isAuxiliaryEditorPartContext = IsAuxiliaryEditorPartContext.bindTo(contextKeyService);
-        isAuxiliaryEditorPartContext.set(this.windowId !== mainWindow.vscodeWindowId);
-        const multipleEditorGroupsContext = EditorPartMultipleEditorGroupsContext.bindTo(contextKeyService);
-        const maximizedEditorGroupContext = EditorPartMaximizedEditorGroupContext.bindTo(contextKeyService);
-        const updateContextKeys = () => {
-            const groupCount = this.count;
-            if (groupCount > 1) {
-                multipleEditorGroupsContext.set(true);
-            }
-            else {
-                multipleEditorGroupsContext.reset();
-            }
-            if (this.hasMaximizedGroup()) {
-                maximizedEditorGroupContext.set(true);
-            }
-            else {
-                maximizedEditorGroupContext.reset();
-            }
-        };
-        updateContextKeys();
-        this._register(this.onDidAddGroup(() => updateContextKeys()));
-        this._register(this.onDidRemoveGroup(() => updateContextKeys()));
-        this._register(this.onDidChangeGroupMaximized(() => updateContextKeys()));
-    }
-    setupDragAndDropSupport(parent, container) {
-        this._register(this.createEditorDropTarget(container, Object.create(null)));
-        const overlay = document.createElement('div');
-        overlay.classList.add('drop-block-overlay');
-        parent.appendChild(overlay);
-        this._register(addDisposableGenericMouseDownListener(overlay, () => overlay.classList.remove('visible')));
-        this._register(CompositeDragAndDropObserver.INSTANCE.registerTarget(this.element, {
-            onDragStart: e => overlay.classList.add('visible'),
-            onDragEnd: e => overlay.classList.remove('visible')
-        }));
-        let horizontalOpenerTimeout;
-        let verticalOpenerTimeout;
-        let lastOpenHorizontalPosition;
-        let lastOpenVerticalPosition;
-        const openPartAtPosition = (position) => {
-            if (!this.layoutService.isVisible("workbench.parts.panel" ) && position === this.layoutService.getPanelPosition()) {
-                this.layoutService.setPartHidden(false, "workbench.parts.panel" );
-            }
-            else if (!this.layoutService.isVisible("workbench.parts.auxiliarybar" ) && position === ((this.layoutService.getSideBarPosition() === 1  ? 0  : 1) )) {
-                this.layoutService.setPartHidden(false, "workbench.parts.auxiliarybar" );
-            }
-        };
-        const clearAllTimeouts = () => {
-            if (horizontalOpenerTimeout) {
-                clearTimeout(horizontalOpenerTimeout);
-                horizontalOpenerTimeout = undefined;
-            }
-            if (verticalOpenerTimeout) {
-                clearTimeout(verticalOpenerTimeout);
-                verticalOpenerTimeout = undefined;
-            }
-        };
-        this._register(CompositeDragAndDropObserver.INSTANCE.registerTarget(overlay, {
-            onDragOver: e => {
-                EventHelper.stop(e.eventData, true);
-                if (e.eventData.dataTransfer) {
-                    e.eventData.dataTransfer.dropEffect = 'none';
-                }
-                const boundingRect = overlay.getBoundingClientRect();
-                let openHorizontalPosition = undefined;
-                let openVerticalPosition = undefined;
-                const proximity = 100;
-                if (e.eventData.clientX < boundingRect.left + proximity) {
-                    openHorizontalPosition = 0 ;
-                }
-                if (e.eventData.clientX > boundingRect.right - proximity) {
-                    openHorizontalPosition = 1 ;
-                }
-                if (e.eventData.clientY > boundingRect.bottom - proximity) {
-                    openVerticalPosition = 2 ;
-                }
-                if (horizontalOpenerTimeout && openHorizontalPosition !== lastOpenHorizontalPosition) {
-                    clearTimeout(horizontalOpenerTimeout);
-                    horizontalOpenerTimeout = undefined;
-                }
-                if (verticalOpenerTimeout && openVerticalPosition !== lastOpenVerticalPosition) {
-                    clearTimeout(verticalOpenerTimeout);
-                    verticalOpenerTimeout = undefined;
-                }
-                if (!horizontalOpenerTimeout && openHorizontalPosition !== undefined) {
-                    lastOpenHorizontalPosition = openHorizontalPosition;
-                    horizontalOpenerTimeout = setTimeout(() => openPartAtPosition(openHorizontalPosition), 200);
-                }
-                if (!verticalOpenerTimeout && openVerticalPosition !== undefined) {
-                    lastOpenVerticalPosition = openVerticalPosition;
-                    verticalOpenerTimeout = setTimeout(() => openPartAtPosition(openVerticalPosition), 200);
-                }
-            },
-            onDragLeave: () => clearAllTimeouts(),
-            onDragEnd: () => clearAllTimeouts(),
-            onDrop: () => clearAllTimeouts()
-        }));
-    }
-    centerLayout(active) {
-        this.centeredLayoutWidget.activate(active);
-        this._activeGroup.focus();
-    }
-    isLayoutCentered() {
-        if (this.centeredLayoutWidget) {
-            return this.centeredLayoutWidget.isActive();
-        }
-        return false;
-    }
-    doCreateGridControl() {
-        let restoreError = false;
-        if (this._willRestoreState) {
-            restoreError = !this.doCreateGridControlWithPreviousState();
-        }
-        if (!this.gridWidget || restoreError) {
-            const initialGroup = this.doCreateGroupView();
-            this.doSetGridWidget(( new SerializableGrid(initialGroup)));
-            this.doSetGroupActive(initialGroup);
-        }
-        this.updateContainer();
-        this.notifyGroupIndexChange();
-    }
-    doCreateGridControlWithPreviousState() {
-        const state = this.loadState();
-        if (state?.serializedGrid) {
-            try {
-                this.mostRecentActiveGroups = state.mostRecentActiveGroups;
-                this.doCreateGridControlWithState(state.serializedGrid, state.activeGroup);
-            }
-            catch (error) {
-                onUnexpectedError(( new Error(
-                    `Error restoring editor grid widget: ${error} (with state: ${JSON.stringify(state)})`
-                )));
-                this.disposeGroups();
-                return false;
-            }
-        }
-        return true;
-    }
-    doCreateGridControlWithState(serializedGrid, activeGroupId, editorGroupViewsToReuse) {
-        let reuseGroupViews;
-        if (editorGroupViewsToReuse) {
-            reuseGroupViews = editorGroupViewsToReuse.slice(0);
-        }
-        else {
-            reuseGroupViews = [];
-        }
-        const groupViews = [];
-        const gridWidget = SerializableGrid.deserialize(serializedGrid, {
-            fromJSON: (serializedEditorGroup) => {
-                let groupView;
-                if (reuseGroupViews.length > 0) {
-                    groupView = reuseGroupViews.shift();
-                }
-                else {
-                    groupView = this.doCreateGroupView(serializedEditorGroup);
-                }
-                groupViews.push(groupView);
-                if (groupView.id === activeGroupId) {
-                    this.doSetGroupActive(groupView);
-                }
-                return groupView;
-            }
-        }, { styles: { separatorBorder: this.gridSeparatorBorder } });
-        if (!this._activeGroup) {
-            this.doSetGroupActive(groupViews[0]);
-        }
-        if (( this.mostRecentActiveGroups.some(groupId => !this.getGroup(groupId)))) {
-            this.mostRecentActiveGroups = ( groupViews.map(group => group.id));
-        }
-        this.doSetGridWidget(gridWidget);
-    }
-    doSetGridWidget(gridWidget) {
-        let boundarySashes = {};
-        if (this.gridWidget) {
-            boundarySashes = this.gridWidget.boundarySashes;
-            this.gridWidget.dispose();
-        }
-        this.gridWidget = gridWidget;
-        this.gridWidget.boundarySashes = boundarySashes;
-        this.gridWidgetView.gridWidget = gridWidget;
-        this._onDidChangeSizeConstraints.input = gridWidget.onDidChange;
-        this._onDidScroll.input = gridWidget.onDidScroll;
-        this.gridWidgetDisposables.clear();
-        this.gridWidgetDisposables.add(gridWidget.onDidChangeViewMaximized(maximized => this._onDidChangeGroupMaximized.fire(maximized)));
-        this._onDidChangeGroupMaximized.fire(this.hasMaximizedGroup());
-        this.onDidSetGridWidget.fire(undefined);
-    }
-    updateContainer() {
-        const container = assertIsDefined(this.container);
-        container.classList.toggle('empty', this.isEmpty);
-    }
-    notifyGroupIndexChange() {
-        this.getGroups(2 ).forEach((group, index) => group.notifyIndexChanged(index));
-    }
-    notifyGroupsLabelChange(newLabel) {
-        for (const group of this.groups) {
-            group.notifyLabelChanged(newLabel);
-        }
-    }
-    get isEmpty() {
-        return this.count === 1 && this._activeGroup.isEmpty;
-    }
-    setBoundarySashes(sashes) {
-        this.gridWidget.boundarySashes = sashes;
-        this.centeredLayoutWidget.boundarySashes = sashes;
-    }
-    layout(width, height, top, left) {
-        this.top = top;
-        this.left = left;
-        const contentAreaSize = super.layoutContents(width, height).contentSize;
-        this.doLayout(Dimension.lift(contentAreaSize), top, left);
-    }
-    doLayout(dimension, top = this.top, left = this.left) {
-        this._contentDimension = dimension;
-        this.centeredLayoutWidget.layout(this._contentDimension.width, this._contentDimension.height, top, left);
-        this._onDidLayout.fire(dimension);
-    }
-    saveState() {
-        if (this.gridWidget) {
-            if (this.isEmpty) {
-                delete this.workspaceMemento[EditorPart_1.EDITOR_PART_UI_STATE_STORAGE_KEY];
-            }
-            else {
-                this.workspaceMemento[EditorPart_1.EDITOR_PART_UI_STATE_STORAGE_KEY] = this.createState();
-            }
-        }
-        if (this.centeredLayoutWidget) {
-            const centeredLayoutState = this.centeredLayoutWidget.state;
-            if (this.centeredLayoutWidget.isDefault(centeredLayoutState)) {
-                delete this.profileMemento[EditorPart_1.EDITOR_PART_CENTERED_VIEW_STORAGE_KEY];
-            }
-            else {
-                this.profileMemento[EditorPart_1.EDITOR_PART_CENTERED_VIEW_STORAGE_KEY] = centeredLayoutState;
-            }
-        }
-        super.saveState();
-    }
-    loadState() {
-        return this.workspaceMemento[EditorPart_1.EDITOR_PART_UI_STATE_STORAGE_KEY];
-    }
-    createState() {
-        return {
-            serializedGrid: this.gridWidget.serialize(),
-            activeGroup: this._activeGroup.id,
-            mostRecentActiveGroups: this.mostRecentActiveGroups
-        };
-    }
-    async applyState(state) {
-        for (const group of this.getGroups(1 )) {
-            const closed = await group.closeAllEditors();
-            if (!closed) {
-                return false;
-            }
-        }
-        this.disposeGroups();
-        this.mostRecentActiveGroups = state.mostRecentActiveGroups;
-        this.doApplyGridState(state.serializedGrid, state.activeGroup);
-        return true;
-    }
-    doApplyGridState(gridState, activeGroupId, editorGroupViewsToReuse) {
-        this.doCreateGridControlWithState(gridState, activeGroupId, editorGroupViewsToReuse);
-        this.doLayout(this._contentDimension);
-        this.updateContainer();
-        for (const groupView of this.getGroups(2 )) {
-            if (!editorGroupViewsToReuse?.includes(groupView)) {
-                this._onDidAddGroup.fire(groupView);
-            }
-        }
-        this.notifyGroupIndexChange();
-    }
-    onDidChangeMementoState(e) {
-        if (e.external && e.scope === 1 ) {
-            this.reloadMemento(e.scope);
-            const state = this.loadState();
-            if (state) {
-                this.applyState(state);
-            }
-        }
-    }
-    toJSON() {
-        return {
-            type: "workbench.parts.editor"
-        };
-    }
-    disposeGroups() {
-        for (const group of this.groups) {
-            group.dispose();
-            this._onDidRemoveGroup.fire(group);
-        }
-        this.groupViews.clear();
-        this.mostRecentActiveGroups = [];
-    }
-    dispose() {
-        this.disposeGroups();
-        this.gridWidget?.dispose();
-        super.dispose();
-    }
-};
-EditorPart = EditorPart_1 = ( __decorate([
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IThemeService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IStorageService)),
-    ( __param(8, IWorkbenchLayoutService)),
-    ( __param(9, IHostService)),
-    ( __param(10, IContextKeyService))
-], EditorPart));
-let MainEditorPart = class MainEditorPart extends EditorPart {
-    constructor(editorPartsView, instantiationService, themeService, configurationService, storageService, layoutService, hostService, contextKeyService) {
-        super(editorPartsView, "workbench.parts.editor" , '', mainWindow.vscodeWindowId, instantiationService, themeService, configurationService, storageService, layoutService, hostService, contextKeyService);
-    }
-};
-MainEditorPart = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IThemeService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, IWorkbenchLayoutService)),
-    ( __param(6, IHostService)),
-    ( __param(7, IContextKeyService))
-], MainEditorPart));
-
-export { EditorPart, MainEditorPart };