@codingame/monaco-vscode-api 1.79.0-next.0 → 1.79.1

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

@@ -0,0 +1,841 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { Part } from '../../part.js';
+import { isAncestor, addDisposableGenericMouseDownListener, EventHelper, Dimension, $ } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Emitter, Relay, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { contrastBorder, editorBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { isGridBranchNode, createSerializedGrid, Sizing, SerializableGrid } from '../../../../base/browser/ui/grid/grid.js';
+import { EDITOR_GROUP_BORDER, EDITOR_PANE_BACKGROUND } from '../../../common/theme.js';
+import { coalesce, distinct, firstOrDefault } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { getEditorPartOptions, impactsEditorPartOptions } from './editor.js';
+import { EditorGroupView } from './editorGroupView.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { toDisposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { isSerializedEditorGroupModel } from '../../../common/editor/editorGroupModel.js';
+import { EditorDropTarget } from './editorDropTarget.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { CenteredViewLayout } from '../../../../base/browser/ui/centered/centeredViewLayout.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { CompositeDragAndDropObserver } from '../../dnd.js';
+import { DeferredPromise, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { findGroup } from '../../../services/editor/common/editorGroupFinder.js';
+import { SIDE_GROUP } from '../../../services/editor/common/editorService.js';
+import { orthogonal } from '../../../../base/browser/ui/grid/gridview.js';
+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 {
+    constructor(instantiationService, themeService, configurationService, storageService, layoutService) {
+        super("workbench.parts.editor" , { hasTitle: false }, themeService, storageService, layoutService);
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        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._onDidChangeGroupLocked = this._register(( new Emitter()));
+        this.onDidChangeGroupLocked = this._onDidChangeGroupLocked.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 , 1 );
+        this.profileMemento = this.getMemento(0 , 1 );
+        this.groupViews = ( new Map());
+        this.mostRecentActiveGroups = [];
+        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.instantiationService.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.priority = 2 ;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
+        this._register(this.themeService.onDidFileIconThemeChange(() => this.handleChangedPartOptions()));
+    }
+    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.EDITOR_PART_UI_STATE_STORAGE_KEY];
+    }
+    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);
+        }
+    }
+    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) {
+        const groupView = this.assertGroupView(group);
+        this.doSetGroupActive(groupView);
+        this._onDidActivateGroup.fire(groupView);
+        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;
+        }
+        switch (arrangement) {
+            case 1 :
+                this.gridWidget.distributeViewSizes();
+                break;
+            case 0 :
+                this.gridWidget.maximizeViewSize(target);
+                break;
+            case 2 :
+                if (this.isGroupMaximized(target)) {
+                    this.arrangeGroups(1 );
+                }
+                else {
+                    this.arrangeGroups(0 );
+                }
+                break;
+        }
+    }
+    isGroupMaximized(targetGroup) {
+        return this.gridWidget.isViewSizeMaximized(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.doCreateGridControlWithState(gridDescriptor, activeGroup.id, currentGroupViews);
+        this.doLayout(this._contentDimension);
+        this.updateContainer();
+        for (const groupView of this.getGroups(2 )) {
+            if (!currentGroupViews.includes(groupView)) {
+                this._onDidAddGroup.fire(groupView);
+            }
+        }
+        this.notifyGroupIndexChange();
+        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 = document.activeElement;
+        if (activeElement === document.body) {
+            return true;
+        }
+        return isAncestor(activeElement, target);
+    }
+    isTwoDimensionalGrid() {
+        const views = this.gridWidget.getViews();
+        if (isGridBranchNode(views)) {
+            return ( views.children.some(child => isGridBranchNode(child)));
+        }
+        return false;
+    }
+    addGroup(location, direction, options) {
+        const locationView = this.assertGroupView(location);
+        const group = this.doAddGroup(locationView, direction);
+        if (options?.activate) {
+            this.doSetGroupActive(group);
+        }
+        return group;
+    }
+    doAddGroup(locationView, direction, groupToCopy) {
+        const shouldMaximize = this.groupViews.size > 1 && this.isGroupMaximized(locationView);
+        const newGroupView = this.doCreateGroupView(groupToCopy);
+        this.gridWidget.addView(newGroupView, this.getSplitSizingStyle(), locationView, this.toGridViewDirection(direction));
+        this.updateContainer();
+        this._onDidAddGroup.fire(newGroupView);
+        this.notifyGroupIndexChange();
+        if (shouldMaximize) {
+            this.arrangeGroups(0 , newGroupView);
+        }
+        return newGroupView;
+    }
+    getSplitSizingStyle() {
+        return this._partOptions.splitSizing === 'split' ? Sizing.Split : Sizing.Distribute;
+    }
+    doCreateGroupView(from) {
+        let groupView;
+        if (from instanceof EditorGroupView) {
+            groupView = EditorGroupView.createCopy(from, this, this.count, this.instantiationService);
+        }
+        else if (isSerializedEditorGroupModel(from)) {
+            groupView = EditorGroupView.createFromSerialized(from, this, this.count, this.instantiationService);
+        }
+        else {
+            groupView = EditorGroupView.createNew(this, this.count, this.instantiationService);
+        }
+        this.groupViews.set(groupView.id, groupView);
+        const groupDisposables = ( new DisposableStore());
+        groupDisposables.add(groupView.onDidFocus(() => {
+            this.doSetGroupActive(groupView);
+        }));
+        groupDisposables.add(groupView.onDidModelChange(e => {
+            switch (e.kind) {
+                case 2 :
+                    this._onDidChangeGroupLocked.fire(groupView);
+                    break;
+                case 1 :
+                    this._onDidChangeGroupIndex.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) {
+            return;
+        }
+        const previousActiveGroup = this._activeGroup;
+        this._activeGroup = group;
+        this.doUpdateMostRecentActive(group, true);
+        previousActiveGroup?.setActive(false);
+        group.setActive(true);
+        this.doRestoreGroup(group);
+        this._onDidChangeActiveGroup.fire(group);
+    }
+    doRestoreGroup(group) {
+        if (this.gridWidget) {
+            const viewSize = this.gridWidget.getViewSize(group);
+            if (viewSize.width === group.minimumWidth || viewSize.height === group.minimumHeight) {
+                this.arrangeGroups(0 , group);
+            }
+        }
+    }
+    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) {
+        const groupView = this.assertGroupView(group);
+        if (this.count === 1) {
+            return;
+        }
+        if (groupView.isEmpty) {
+            return this.doRemoveEmptyGroup(groupView);
+        }
+        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) {
+        const restoreFocus = this.shouldRestoreFocus(this.container);
+        if (this._activeGroup === groupView) {
+            const mostRecentlyActiveGroups = this.getGroups(1 );
+            const nextActiveGroup = mostRecentlyActiveGroups[1];
+            this.activateGroup(nextActiveGroup);
+        }
+        this.gridWidget.removeView(groupView, this.getSplitSizingStyle());
+        groupView.dispose();
+        if (restoreFocus) {
+            this._activeGroup.focus();
+        }
+        this.notifyGroupIndexChange();
+        this.updateContainer();
+        if (this.count === 1) {
+            firstOrDefault(this.groups)?.lock(false);
+        }
+        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);
+        this.gridWidget.moveView(sourceView, this.getSplitSizingStyle(), targetView, this.toGridViewDirection(direction));
+        if (restoreFocus) {
+            sourceView.focus();
+        }
+        this._onDidMoveGroup.fire(sourceView);
+        this.notifyGroupIndexChange();
+        return sourceView;
+    }
+    copyGroup(group, location, direction) {
+        const groupView = this.assertGroupView(group);
+        const locationView = this.assertGroupView(location);
+        const restoreFocus = this.shouldRestoreFocus(groupView.element);
+        const copiedGroupView = this.doAddGroup(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);
+        }
+        return targetView;
+    }
+    mergeAllGroups(target = this.activeGroup) {
+        for (const group of this.getGroups(1 )) {
+            if (group === target) {
+                continue;
+            }
+            this.mergeGroup(group, target);
+        }
+        return target;
+    }
+    assertGroupView(group) {
+        let groupView;
+        if (typeof group === 'number') {
+            groupView = this.getGroup(group);
+        }
+        else {
+            groupView = group;
+        }
+        if (!groupView) {
+            throw new Error('Invalid editor group provided!');
+        }
+        return groupView;
+    }
+    createEditorDropTarget(container, delegate) {
+        return this.instantiationService.createInstance(EditorDropTarget, this, container, delegate);
+    }
+    get minimumWidth() { return Math.min(this.centeredLayoutWidget.minimumWidth, this.layoutService.getMaximumEditorDimensions().width); }
+    get maximumWidth() { return this.centeredLayoutWidget.maximumWidth; }
+    get minimumHeight() { return Math.min(this.centeredLayoutWidget.minimumHeight, this.layoutService.getMaximumEditorDimensions().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');
+        parent.appendChild(this.container);
+        this.doCreateGridControl(options);
+        this.centeredLayoutWidget = this._register(( new CenteredViewLayout(
+            this.container,
+            this.gridWidgetView,
+            this.profileMemento[EditorPart.EDITOR_PART_CENTERED_VIEW_STORAGE_KEY]
+        )));
+        this._register(this.onDidChangeEditorPartOptions(e => this.centeredLayoutWidget.setFixedWidth(e.newPartOptions.centeredLayoutFixedWidth ?? false)));
+        this.setupDragAndDropSupport(parent, this.container);
+        this.whenReadyPromise.complete();
+        this._isReady = true;
+        Promises.settled(( this.groups.map(group => group.whenRestored))).finally(() => {
+            this.whenRestoredPromise.complete();
+        });
+        return this.container;
+    }
+    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(options) {
+        let restoreError = false;
+        if (!options || options.restorePreviousState) {
+            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 uiState = this.workspaceMemento[EditorPart.EDITOR_PART_UI_STATE_STORAGE_KEY];
+        if (uiState?.serializedGrid) {
+            try {
+                this.mostRecentActiveGroups = uiState.mostRecentActiveGroups;
+                this.doCreateGridControlWithState(uiState.serializedGrid, uiState.activeGroup);
+                this._activeGroup.focus();
+            }
+            catch (error) {
+                onUnexpectedError(( new Error(
+                    `Error restoring editor grid widget: ${error} (with state: ${JSON.stringify(uiState)})`
+                )));
+                this.groupViews.forEach(group => group.dispose());
+                this.groupViews.clear();
+                this.mostRecentActiveGroups = [];
+                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.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));
+    }
+    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) {
+            const uiState = {
+                serializedGrid: this.gridWidget.serialize(),
+                activeGroup: this._activeGroup.id,
+                mostRecentActiveGroups: this.mostRecentActiveGroups
+            };
+            if (this.isEmpty) {
+                delete this.workspaceMemento[EditorPart.EDITOR_PART_UI_STATE_STORAGE_KEY];
+            }
+            else {
+                this.workspaceMemento[EditorPart.EDITOR_PART_UI_STATE_STORAGE_KEY] = uiState;
+            }
+        }
+        if (this.centeredLayoutWidget) {
+            const centeredLayoutState = this.centeredLayoutWidget.state;
+            if (this.centeredLayoutWidget.isDefault(centeredLayoutState)) {
+                delete this.profileMemento[EditorPart.EDITOR_PART_CENTERED_VIEW_STORAGE_KEY];
+            }
+            else {
+                this.profileMemento[EditorPart.EDITOR_PART_CENTERED_VIEW_STORAGE_KEY] = centeredLayoutState;
+            }
+        }
+        super.saveState();
+    }
+    toJSON() {
+        return {
+            type: "workbench.parts.editor"
+        };
+    }
+    dispose() {
+        this.groupViews.forEach(group => group.dispose());
+        this.groupViews.clear();
+        this.gridWidget?.dispose();
+        super.dispose();
+    }
+};
+EditorPart.EDITOR_PART_UI_STATE_STORAGE_KEY = 'editorpart.state';
+EditorPart.EDITOR_PART_CENTERED_VIEW_STORAGE_KEY = 'editorpart.centeredview';
+EditorPart = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IThemeService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, IWorkbenchLayoutService))
+], EditorPart));
+export { EditorPart };