@codingame/monaco-vscode-api 2.1.4 → 2.2.0-next.1

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

@@ -0,0 +1,509 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/editordroptarget.css.js';
+import { DataTransfers } from '../../../../base/browser/dnd.js';
+import { DragAndDropObserver, EventHelper, addDisposableListener, getWindow, EventType, isAncestor } from '../../../../base/browser/dom.js';
+import { renderFormattedText } from '../../../../base/browser/formattedTextRenderer.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import { toDisposable } from '../../../../base/common/lifecycle.js';
+import { isWeb, isMacintosh } from '../../../../base/common/platform.js';
+import { assertIsDefined, assertAllDefined } from '../../../../base/common/types.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { activeContrastBorder } from '../../../../platform/theme/common/colorRegistry.js';
+import { Themable, IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { isTemporaryWorkspace, IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { LocalSelectionTransfer, Extensions, containsDragType, CodeDataTransfers } from '../../../../platform/dnd/browser/dnd.js';
+import { DraggedEditorGroupIdentifier, DraggedEditorIdentifier, extractTreeDropData, ResourcesDropHandler } from '../../dnd.js';
+import { fillActiveEditorViewState } from './editor.js';
+import { EDITOR_DRAG_AND_DROP_BACKGROUND, EDITOR_DROP_INTO_PROMPT_BACKGROUND, EDITOR_DROP_INTO_PROMPT_FOREGROUND, EDITOR_DROP_INTO_PROMPT_BORDER } from '../../../common/theme.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ITreeViewsDnDService } from '../../../../editor/common/services/treeViewsDndService.js';
+import { DraggedTreeItemsIdentifier } from '../../../../editor/common/services/treeViewsDnd.js';
+var DropOverlay_1;
+function isDropIntoEditorEnabledGlobally(configurationService) {
+    return configurationService.getValue('editor.dropIntoEditor.enabled');
+}
+function isDragIntoEditorEvent(e) {
+    return e.shiftKey;
+}
+let DropOverlay = class DropOverlay extends Themable {
+    static { DropOverlay_1 = this; }
+    static { this.OVERLAY_ID = 'monaco-workbench-editor-drop-overlay'; }
+    get disposed() { return !!this._disposed; }
+    constructor(groupView, themeService, configurationService, instantiationService, editorService, editorGroupService, treeViewsDragAndDropService, contextService) {
+        super(themeService);
+        this.groupView = groupView;
+        this.configurationService = configurationService;
+        this.instantiationService = instantiationService;
+        this.editorService = editorService;
+        this.editorGroupService = editorGroupService;
+        this.treeViewsDragAndDropService = treeViewsDragAndDropService;
+        this.contextService = contextService;
+        this.editorTransfer = LocalSelectionTransfer.getInstance();
+        this.groupTransfer = LocalSelectionTransfer.getInstance();
+        this.treeItemsTransfer = LocalSelectionTransfer.getInstance();
+        this.cleanupOverlayScheduler = this._register(( new RunOnceScheduler(() => this.dispose(), 300)));
+        this.enableDropIntoEditor = isDropIntoEditorEnabledGlobally(this.configurationService) && this.isDropIntoActiveEditorEnabled();
+        this.create();
+    }
+    create() {
+        const overlayOffsetHeight = this.getOverlayOffsetHeight();
+        const container = this.container = document.createElement('div');
+        container.id = DropOverlay_1.OVERLAY_ID;
+        container.style.top = `${overlayOffsetHeight}px`;
+        this.groupView.element.appendChild(container);
+        this.groupView.element.classList.add('dragged-over');
+        this._register(toDisposable(() => {
+            this.groupView.element.removeChild(container);
+            this.groupView.element.classList.remove('dragged-over');
+        }));
+        this.overlay = document.createElement('div');
+        this.overlay.classList.add('editor-group-overlay-indicator');
+        container.appendChild(this.overlay);
+        if (this.enableDropIntoEditor) {
+            this.dropIntoPromptElement = renderFormattedText(( localizeWithPath(
+                'vs/workbench/browser/parts/editor/editorDropTarget',
+                'dropIntoEditorPrompt',
+                "Hold __{0}__ to drop into editor",
+                isMacintosh ? '⇧' : 'Shift'
+            )), {});
+            this.dropIntoPromptElement.classList.add('editor-group-overlay-drop-into-prompt');
+            this.overlay.appendChild(this.dropIntoPromptElement);
+        }
+        this.registerListeners(container);
+        this.updateStyles();
+    }
+    updateStyles() {
+        const overlay = assertIsDefined(this.overlay);
+        overlay.style.backgroundColor = this.getColor(EDITOR_DRAG_AND_DROP_BACKGROUND) || '';
+        const activeContrastBorderColor = this.getColor(activeContrastBorder);
+        overlay.style.outlineColor = activeContrastBorderColor || '';
+        overlay.style.outlineOffset = activeContrastBorderColor ? '-2px' : '';
+        overlay.style.outlineStyle = activeContrastBorderColor ? 'dashed' : '';
+        overlay.style.outlineWidth = activeContrastBorderColor ? '2px' : '';
+        if (this.dropIntoPromptElement) {
+            this.dropIntoPromptElement.style.backgroundColor = this.getColor(EDITOR_DROP_INTO_PROMPT_BACKGROUND) ?? '';
+            this.dropIntoPromptElement.style.color = this.getColor(EDITOR_DROP_INTO_PROMPT_FOREGROUND) ?? '';
+            const borderColor = this.getColor(EDITOR_DROP_INTO_PROMPT_BORDER);
+            if (borderColor) {
+                this.dropIntoPromptElement.style.borderWidth = '1px';
+                this.dropIntoPromptElement.style.borderStyle = 'solid';
+                this.dropIntoPromptElement.style.borderColor = borderColor;
+            }
+            else {
+                this.dropIntoPromptElement.style.borderWidth = '0';
+            }
+        }
+    }
+    registerListeners(container) {
+        this._register(( new DragAndDropObserver(container, {
+            onDragOver: e => {
+                if (this.enableDropIntoEditor && isDragIntoEditorEvent(e)) {
+                    this.dispose();
+                    return;
+                }
+                const isDraggingGroup = this.groupTransfer.hasData(DraggedEditorGroupIdentifier.prototype);
+                const isDraggingEditor = this.editorTransfer.hasData(DraggedEditorIdentifier.prototype);
+                if (!isDraggingEditor && !isDraggingGroup && e.dataTransfer) {
+                    e.dataTransfer.dropEffect = 'copy';
+                }
+                let isCopy = true;
+                if (isDraggingGroup) {
+                    isCopy = this.isCopyOperation(e);
+                }
+                else if (isDraggingEditor) {
+                    const data = this.editorTransfer.getData(DraggedEditorIdentifier.prototype);
+                    if (Array.isArray(data)) {
+                        isCopy = this.isCopyOperation(e, data[0].identifier);
+                    }
+                }
+                if (!isCopy) {
+                    const sourceGroupView = this.findSourceGroupView();
+                    if (sourceGroupView === this.groupView) {
+                        if (isDraggingGroup || (isDraggingEditor && sourceGroupView.count < 2)) {
+                            this.hideOverlay();
+                            return;
+                        }
+                    }
+                }
+                let splitOnDragAndDrop = !!this.editorGroupService.partOptions.splitOnDragAndDrop;
+                if (this.isToggleSplitOperation(e)) {
+                    splitOnDragAndDrop = !splitOnDragAndDrop;
+                }
+                this.positionOverlay(e.offsetX, e.offsetY, isDraggingGroup, splitOnDragAndDrop);
+                if (this.cleanupOverlayScheduler.isScheduled()) {
+                    this.cleanupOverlayScheduler.cancel();
+                }
+            },
+            onDragLeave: e => this.dispose(),
+            onDragEnd: e => this.dispose(),
+            onDrop: e => {
+                EventHelper.stop(e, true);
+                this.dispose();
+                if (this.currentDropOperation) {
+                    this.handleDrop(e, this.currentDropOperation.splitDirection);
+                }
+            }
+        })));
+        this._register(addDisposableListener(container, EventType.MOUSE_OVER, () => {
+            if (!this.cleanupOverlayScheduler.isScheduled()) {
+                this.cleanupOverlayScheduler.schedule();
+            }
+        }));
+    }
+    isDropIntoActiveEditorEnabled() {
+        return !!this.groupView.activeEditor?.hasCapability(128 );
+    }
+    findSourceGroupView() {
+        if (this.groupTransfer.hasData(DraggedEditorGroupIdentifier.prototype)) {
+            const data = this.groupTransfer.getData(DraggedEditorGroupIdentifier.prototype);
+            if (Array.isArray(data)) {
+                return this.editorGroupService.getGroup(data[0].identifier);
+            }
+        }
+        else if (this.editorTransfer.hasData(DraggedEditorIdentifier.prototype)) {
+            const data = this.editorTransfer.getData(DraggedEditorIdentifier.prototype);
+            if (Array.isArray(data)) {
+                return this.editorGroupService.getGroup(data[0].identifier.groupId);
+            }
+        }
+        return undefined;
+    }
+    async handleDrop(event, splitDirection) {
+        const ensureTargetGroup = () => {
+            let targetGroup;
+            if (typeof splitDirection === 'number') {
+                targetGroup = this.editorGroupService.addGroup(this.groupView, splitDirection);
+            }
+            else {
+                targetGroup = this.groupView;
+            }
+            return targetGroup;
+        };
+        if (this.groupTransfer.hasData(DraggedEditorGroupIdentifier.prototype)) {
+            const data = this.groupTransfer.getData(DraggedEditorGroupIdentifier.prototype);
+            if (Array.isArray(data)) {
+                const sourceGroup = this.editorGroupService.getGroup(data[0].identifier);
+                if (sourceGroup) {
+                    if (typeof splitDirection !== 'number' && sourceGroup === this.groupView) {
+                        return;
+                    }
+                    let targetGroup;
+                    if (typeof splitDirection === 'number') {
+                        if (this.isCopyOperation(event)) {
+                            targetGroup = this.editorGroupService.copyGroup(sourceGroup, this.groupView, splitDirection);
+                        }
+                        else {
+                            targetGroup = this.editorGroupService.moveGroup(sourceGroup, this.groupView, splitDirection);
+                        }
+                    }
+                    else {
+                        let mergeGroupOptions = undefined;
+                        if (this.isCopyOperation(event)) {
+                            mergeGroupOptions = { mode: 0  };
+                        }
+                        this.editorGroupService.mergeGroup(sourceGroup, this.groupView, mergeGroupOptions);
+                    }
+                    if (targetGroup) {
+                        this.editorGroupService.activateGroup(targetGroup);
+                    }
+                }
+                this.groupTransfer.clearData(DraggedEditorGroupIdentifier.prototype);
+            }
+        }
+        else if (this.editorTransfer.hasData(DraggedEditorIdentifier.prototype)) {
+            const data = this.editorTransfer.getData(DraggedEditorIdentifier.prototype);
+            if (Array.isArray(data)) {
+                const draggedEditor = data[0].identifier;
+                const sourceGroup = this.editorGroupService.getGroup(draggedEditor.groupId);
+                if (sourceGroup) {
+                    const copyEditor = this.isCopyOperation(event, draggedEditor);
+                    let targetGroup = undefined;
+                    if (this.editorGroupService.partOptions.closeEmptyGroups && sourceGroup.count === 1 && typeof splitDirection === 'number' && !copyEditor) {
+                        targetGroup = this.editorGroupService.moveGroup(sourceGroup, this.groupView, splitDirection);
+                    }
+                    else {
+                        targetGroup = ensureTargetGroup();
+                        if (sourceGroup === targetGroup) {
+                            return;
+                        }
+                        const options = fillActiveEditorViewState(sourceGroup, draggedEditor.editor, {
+                            pinned: true,
+                            sticky: sourceGroup.isSticky(draggedEditor.editor),
+                        });
+                        if (!copyEditor) {
+                            sourceGroup.moveEditor(draggedEditor.editor, targetGroup, options);
+                        }
+                        else {
+                            sourceGroup.copyEditor(draggedEditor.editor, targetGroup, options);
+                        }
+                    }
+                    targetGroup.focus();
+                }
+                this.editorTransfer.clearData(DraggedEditorIdentifier.prototype);
+            }
+        }
+        else if (this.treeItemsTransfer.hasData(DraggedTreeItemsIdentifier.prototype)) {
+            const data = this.treeItemsTransfer.getData(DraggedTreeItemsIdentifier.prototype);
+            if (Array.isArray(data)) {
+                const editors = [];
+                for (const id of data) {
+                    const dataTransferItem = await this.treeViewsDragAndDropService.removeDragOperationTransfer(id.identifier);
+                    if (dataTransferItem) {
+                        const treeDropData = await extractTreeDropData(dataTransferItem);
+                        editors.push(...( treeDropData.map(editor => ({ ...editor, options: { ...editor.options, pinned: true } }))));
+                    }
+                }
+                if (editors.length) {
+                    this.editorService.openEditors(editors, ensureTargetGroup(), { validateTrust: true });
+                }
+            }
+            this.treeItemsTransfer.clearData(DraggedTreeItemsIdentifier.prototype);
+        }
+        else {
+            const dropHandler = this.instantiationService.createInstance(ResourcesDropHandler, { allowWorkspaceOpen: !isWeb || isTemporaryWorkspace(this.contextService.getWorkspace()) });
+            dropHandler.handleDrop(event, getWindow(this.groupView.element), () => ensureTargetGroup(), targetGroup => targetGroup?.focus());
+        }
+    }
+    isCopyOperation(e, draggedEditor) {
+        if (draggedEditor?.editor.hasCapability(8 )) {
+            return false;
+        }
+        return (e.ctrlKey && !isMacintosh) || (e.altKey && isMacintosh);
+    }
+    isToggleSplitOperation(e) {
+        return (e.altKey && !isMacintosh) || (e.shiftKey && isMacintosh);
+    }
+    positionOverlay(mousePosX, mousePosY, isDraggingGroup, enableSplitting) {
+        const preferSplitVertically = this.editorGroupService.partOptions.openSideBySideDirection === 'right';
+        const editorControlWidth = this.groupView.element.clientWidth;
+        const editorControlHeight = this.groupView.element.clientHeight - this.getOverlayOffsetHeight();
+        let edgeWidthThresholdFactor;
+        let edgeHeightThresholdFactor;
+        if (enableSplitting) {
+            if (isDraggingGroup) {
+                edgeWidthThresholdFactor = preferSplitVertically ? 0.3 : 0.1;
+            }
+            else {
+                edgeWidthThresholdFactor = 0.1;
+            }
+            if (isDraggingGroup) {
+                edgeHeightThresholdFactor = preferSplitVertically ? 0.1 : 0.3;
+            }
+            else {
+                edgeHeightThresholdFactor = 0.1;
+            }
+        }
+        else {
+            edgeWidthThresholdFactor = 0;
+            edgeHeightThresholdFactor = 0;
+        }
+        const edgeWidthThreshold = editorControlWidth * edgeWidthThresholdFactor;
+        const edgeHeightThreshold = editorControlHeight * edgeHeightThresholdFactor;
+        const splitWidthThreshold = editorControlWidth / 3;
+        const splitHeightThreshold = editorControlHeight / 3;
+        let splitDirection;
+        if (mousePosX > edgeWidthThreshold && mousePosX < editorControlWidth - edgeWidthThreshold &&
+            mousePosY > edgeHeightThreshold && mousePosY < editorControlHeight - edgeHeightThreshold) {
+            splitDirection = undefined;
+        }
+        else {
+            if (preferSplitVertically) {
+                if (mousePosX < splitWidthThreshold) {
+                    splitDirection = 2 ;
+                }
+                else if (mousePosX > splitWidthThreshold * 2) {
+                    splitDirection = 3 ;
+                }
+                else if (mousePosY < editorControlHeight / 2) {
+                    splitDirection = 0 ;
+                }
+                else {
+                    splitDirection = 1 ;
+                }
+            }
+            else {
+                if (mousePosY < splitHeightThreshold) {
+                    splitDirection = 0 ;
+                }
+                else if (mousePosY > splitHeightThreshold * 2) {
+                    splitDirection = 1 ;
+                }
+                else if (mousePosX < editorControlWidth / 2) {
+                    splitDirection = 2 ;
+                }
+                else {
+                    splitDirection = 3 ;
+                }
+            }
+        }
+        switch (splitDirection) {
+            case 0 :
+                this.doPositionOverlay({ top: '0', left: '0', width: '100%', height: '50%' });
+                this.toggleDropIntoPrompt(false);
+                break;
+            case 1 :
+                this.doPositionOverlay({ top: '50%', left: '0', width: '100%', height: '50%' });
+                this.toggleDropIntoPrompt(false);
+                break;
+            case 2 :
+                this.doPositionOverlay({ top: '0', left: '0', width: '50%', height: '100%' });
+                this.toggleDropIntoPrompt(false);
+                break;
+            case 3 :
+                this.doPositionOverlay({ top: '0', left: '50%', width: '50%', height: '100%' });
+                this.toggleDropIntoPrompt(false);
+                break;
+            default:
+                this.doPositionOverlay({ top: '0', left: '0', width: '100%', height: '100%' });
+                this.toggleDropIntoPrompt(true);
+        }
+        const overlay = assertIsDefined(this.overlay);
+        overlay.style.opacity = '1';
+        setTimeout(() => overlay.classList.add('overlay-move-transition'), 0);
+        this.currentDropOperation = { splitDirection };
+    }
+    doPositionOverlay(options) {
+        const [container, overlay] = assertAllDefined(this.container, this.overlay);
+        const offsetHeight = this.getOverlayOffsetHeight();
+        if (offsetHeight) {
+            container.style.height = `calc(100% - ${offsetHeight}px)`;
+        }
+        else {
+            container.style.height = '100%';
+        }
+        overlay.style.top = options.top;
+        overlay.style.left = options.left;
+        overlay.style.width = options.width;
+        overlay.style.height = options.height;
+    }
+    getOverlayOffsetHeight() {
+        if (!this.groupView.isEmpty && this.editorGroupService.partOptions.showTabs === 'multiple') {
+            return this.groupView.titleHeight.offset;
+        }
+        return 0;
+    }
+    hideOverlay() {
+        const overlay = assertIsDefined(this.overlay);
+        this.doPositionOverlay({ top: '0', left: '0', width: '100%', height: '100%' });
+        overlay.style.opacity = '0';
+        overlay.classList.remove('overlay-move-transition');
+        this.currentDropOperation = undefined;
+    }
+    toggleDropIntoPrompt(showing) {
+        if (!this.dropIntoPromptElement) {
+            return;
+        }
+        this.dropIntoPromptElement.style.opacity = showing ? '1' : '0';
+    }
+    contains(element) {
+        return element === this.container || element === this.overlay;
+    }
+    dispose() {
+        super.dispose();
+        this._disposed = true;
+    }
+};
+DropOverlay = DropOverlay_1 = ( __decorate([
+    ( __param(1, IThemeService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IEditorService)),
+    ( __param(5, IEditorGroupsService)),
+    ( __param(6, ITreeViewsDnDService)),
+    ( __param(7, IWorkspaceContextService))
+], DropOverlay));
+let EditorDropTarget = class EditorDropTarget extends Themable {
+    constructor(container, delegate, editorGroupService, themeService, configurationService, instantiationService) {
+        super(themeService);
+        this.container = container;
+        this.delegate = delegate;
+        this.editorGroupService = editorGroupService;
+        this.configurationService = configurationService;
+        this.instantiationService = instantiationService;
+        this.counter = 0;
+        this.editorTransfer = LocalSelectionTransfer.getInstance();
+        this.groupTransfer = LocalSelectionTransfer.getInstance();
+        this.registerListeners();
+    }
+    get overlay() {
+        if (this._overlay && !this._overlay.disposed) {
+            return this._overlay;
+        }
+        return undefined;
+    }
+    registerListeners() {
+        this._register(addDisposableListener(this.container, EventType.DRAG_ENTER, e => this.onDragEnter(e)));
+        this._register(addDisposableListener(this.container, EventType.DRAG_LEAVE, () => this.onDragLeave()));
+        for (const target of [this.container, getWindow(this.container)]) {
+            this._register(addDisposableListener(target, EventType.DRAG_END, () => this.onDragEnd()));
+        }
+    }
+    onDragEnter(event) {
+        if (isDropIntoEditorEnabledGlobally(this.configurationService) && isDragIntoEditorEvent(event)) {
+            return;
+        }
+        this.counter++;
+        if (!this.editorTransfer.hasData(DraggedEditorIdentifier.prototype) &&
+            !this.groupTransfer.hasData(DraggedEditorGroupIdentifier.prototype) &&
+            event.dataTransfer) {
+            const dndContributions = ( Registry.as(Extensions.DragAndDropContribution)).getAll();
+            const dndContributionKeys = ( Array.from(dndContributions).map(e => e.dataFormatKey));
+            if (!containsDragType(event, DataTransfers.FILES, CodeDataTransfers.FILES, DataTransfers.RESOURCES, CodeDataTransfers.EDITORS, ...dndContributionKeys)) {
+                event.dataTransfer.dropEffect = 'none';
+                return;
+            }
+        }
+        this.updateContainer(true);
+        const target = event.target;
+        if (target) {
+            if (this.overlay && !this.overlay.contains(target)) {
+                this.disposeOverlay();
+            }
+            if (!this.overlay) {
+                const targetGroupView = this.findTargetGroupView(target);
+                if (targetGroupView) {
+                    this._overlay = this.instantiationService.createInstance(DropOverlay, targetGroupView);
+                }
+            }
+        }
+    }
+    onDragLeave() {
+        this.counter--;
+        if (this.counter === 0) {
+            this.updateContainer(false);
+        }
+    }
+    onDragEnd() {
+        this.counter = 0;
+        this.updateContainer(false);
+        this.disposeOverlay();
+    }
+    findTargetGroupView(child) {
+        const groups = this.editorGroupService.groups;
+        return groups.find(groupView => isAncestor(child, groupView.element) || this.delegate.containsGroup?.(groupView));
+    }
+    updateContainer(isDraggedOver) {
+        this.container.classList.toggle('dragged-over', isDraggedOver);
+    }
+    dispose() {
+        super.dispose();
+        this.disposeOverlay();
+    }
+    disposeOverlay() {
+        if (this.overlay) {
+            this.overlay.dispose();
+            this._overlay = undefined;
+        }
+    }
+};
+EditorDropTarget = ( __decorate([
+    ( __param(2, IEditorGroupsService)),
+    ( __param(3, IThemeService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IInstantiationService))
+], EditorDropTarget));
+export { EditorDropTarget };

package/vscode/src/vs/workbench/browser/parts/editor/editorPane.d.ts

@@ -0,0 +1,112 @@
+import { Composite } from '../../composite.js';
+import { IEditorPane, IEditorOpenContext, IEditorMemento } from '../../../common/editor.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { IEditorGroup, IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { Event, Emitter } from '../../../../base/common/event.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IEditorOptions } from '../../../../platform/editor/common/editor.js';
+import { ITextResourceConfigurationService } from '../../../../editor/common/services/textResourceConfiguration.js';
+import { IBoundarySashes } from '../../../../base/browser/ui/sash/sash.js';
+
+/**
+ * The base class of editors in the workbench. Editors register themselves for specific editor inputs.
+ * Editors are layed out in the editor part of the workbench in editor groups. Multiple editors can be
+ * open at the same time. Each editor has a minimized representation that is good enough to provide some
+ * information about the state of the editor data.
+ *
+ * The workbench will keep an editor alive after it has been created and show/hide it based on
+ * user interaction. The lifecycle of a editor goes in the order:
+ *
+ * - `createEditor()`
+ * - `setEditorVisible()`
+ * - `layout()`
+ * - `setInput()`
+ * - `focus()`
+ * - `dispose()`: when the editor group the editor is in closes
+ *
+ * During use of the workbench, a editor will often receive a `clearInput()`, `setEditorVisible()`, `layout()` and
+ * `focus()` calls, but only one `create()` and `dispose()` call.
+ *
+ * This class is only intended to be subclassed and not instantiated.
+ */
+declare abstract class EditorPane extends Composite implements IEditorPane {
+    readonly onDidChangeSizeConstraints: Event<any>;
+    protected readonly _onDidChangeControl: Emitter<void>;
+    readonly onDidChangeControl: Event<void>;
+    private static readonly EDITOR_MEMENTOS;
+    get minimumWidth(): number;
+    get maximumWidth(): number;
+    get minimumHeight(): number;
+    get maximumHeight(): number;
+    protected _input: EditorInput | undefined;
+    get input(): EditorInput | undefined;
+    protected _options: IEditorOptions | undefined;
+    get options(): IEditorOptions | undefined;
+    private _group;
+    get group(): IEditorGroup | undefined;
+    /**
+     * Should be overridden by editors that have their own ScopedContextKeyService
+     */
+    get scopedContextKeyService(): IContextKeyService | undefined;
+    constructor(id: string, telemetryService: ITelemetryService, themeService: IThemeService, storageService: IStorageService);
+    create(parent: HTMLElement): void;
+    /**
+     * Called to create the editor in the parent HTMLElement. Subclasses implement
+     * this method to construct the editor widget.
+     */
+    protected abstract createEditor(parent: HTMLElement): void;
+    /**
+     * Note: Clients should not call this method, the workbench calls this
+     * method. Calling it otherwise may result in unexpected behavior.
+     *
+     * Sets the given input with the options to the editor. The input is guaranteed
+     * to be different from the previous input that was set using the `input.matches()`
+     * method.
+     *
+     * The provided context gives more information around how the editor was opened.
+     *
+     * The provided cancellation token should be used to test if the operation
+     * was cancelled.
+     */
+    setInput(input: EditorInput, options: IEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken): Promise<void>;
+    /**
+     * Called to indicate to the editor that the input should be cleared and
+     * resources associated with the input should be freed.
+     *
+     * This method can be called based on different contexts, e.g. when opening
+     * a different input or different editor control or when closing all editors
+     * in a group.
+     *
+     * To monitor the lifecycle of editor inputs, you should not rely on this
+     * method, rather refer to the listeners on `IEditorGroup` via `IEditorGroupsService`.
+     */
+    clearInput(): void;
+    /**
+     * Note: Clients should not call this method, the workbench calls this
+     * method. Calling it otherwise may result in unexpected behavior.
+     *
+     * Sets the given options to the editor. Clients should apply the options
+     * to the current input.
+     */
+    setOptions(options: IEditorOptions | undefined): void;
+    setVisible(visible: boolean, group?: IEditorGroup): void;
+    /**
+     * Indicates that the editor control got visible or hidden in a specific group. A
+     * editor instance will only ever be visible in one editor group.
+     *
+     * @param visible the state of visibility of this editor
+     * @param group the editor group this editor is in.
+     */
+    protected setEditorVisible(visible: boolean, group: IEditorGroup | undefined): void;
+    setBoundarySashes(_sashes: IBoundarySashes): void;
+    protected getEditorMemento<T>(editorGroupService: IEditorGroupsService, configurationService: ITextResourceConfigurationService, key: string, limit?: number): IEditorMemento<T>;
+    getViewState(): object | undefined;
+    protected saveState(): void;
+    dispose(): void;
+}
+
+export { EditorPane };