@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/sessions/browser/parts/customViewGridPart.d.ts

@@ -0,0 +1,43 @@
+import { LayoutPriority } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/splitview/splitview";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { Part } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/part";
+import { ICustomViewDescriptor } from "../../services/customView/browser/customView.js";
+import { IAgentWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service";
+/**
+ * Hosts the custom views that replace the sessions grid while one is shown. It
+ * is a passive renderer: the workbench drives it from
+ * `ICustomViewService.activeCustomView` via {@link setView}.
+ *
+ * Only a single view can be shown today; the part is structured as a grid of
+ * {@link CustomViewNode} leaves so more can be added later.
+ */
+export declare class CustomViewGridPart extends Part {
+    protected readonly agentWorkbenchLayoutService: IAgentWorkbenchLayoutService;
+    private readonly instantiationService;
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    readonly minimumHeight: number;
+    readonly maximumHeight: number;
+    get snap(): boolean;
+    readonly priority = LayoutPriority.High;
+    private _contentArea;
+    private readonly _node;
+    private _descriptor;
+    protected _lastContentSize: {
+        readonly width: number;
+        readonly height: number;
+    } | undefined;
+    constructor(themeService: IThemeService, storageService: IStorageService, agentWorkbenchLayoutService: IAgentWorkbenchLayoutService, instantiationService: IInstantiationService);
+    create(parent: HTMLElement): void;
+    protected createContentArea(parent: HTMLElement): HTMLElement;
+    /** Renders the given custom view, replacing (and disposing) the previous one. */
+    setView(descriptor: ICustomViewDescriptor | undefined): void;
+    private _renderView;
+    focus(): void;
+    updateStyles(): void;
+    layout(width: number, height: number, top: number, left: number): void;
+    protected _layoutNode(width: number, height: number): void;
+    toJSON(): object;
+}

package/vscode/src/vs/sessions/browser/parts/customViewGridPart.js

@@ -0,0 +1,113 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as customViewGridPart from './media/customViewGridPart.css';
+import { $, size } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { LayoutPriority } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/splitview/splitview';
+import { assertReturnsDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { Part } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/part';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { applyAgentsPartCardStyles, getAgentsPartCardContentSize } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/agentsPartCard';
+import { CustomViewNode } from './customViewNode.js';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+
+registerCss(customViewGridPart, 0);
+let CustomViewGridPart = class CustomViewGridPart extends Part {
+    get snap() {
+        return false;
+    }
+    constructor(
+        themeService,
+        storageService,
+        agentWorkbenchLayoutService,
+        instantiationService
+    ) {
+        super(Parts.CUSTOM_VIEW_GRID_PART, {
+            hasTitle: false,
+            borderWidth: () => 0
+        }, themeService, storageService, agentWorkbenchLayoutService);
+        this.agentWorkbenchLayoutService = agentWorkbenchLayoutService;
+        this.instantiationService = instantiationService;
+        this.minimumWidth = 300;
+        this.maximumWidth = Number.POSITIVE_INFINITY;
+        this.minimumHeight = 0;
+        this.maximumHeight = Number.POSITIVE_INFINITY;
+        this.priority = LayoutPriority.High;
+        this._node = this._register(( new MutableDisposable()));
+    }
+    create(parent) {
+        this.element = parent;
+        super.create(parent);
+    }
+    createContentArea(parent) {
+        const contentArea = $(".custom-view-grid");
+        parent.appendChild(contentArea);
+        this._contentArea = contentArea;
+        this._renderView();
+        return contentArea;
+    }
+    setView(descriptor) {
+        if (this._descriptor === descriptor) {
+            return;
+        }
+        this._descriptor = descriptor;
+        this._renderView();
+    }
+    _renderView() {
+        if (!this._contentArea) {
+            return;
+        }
+        this._node.clear();
+        if (!this._descriptor) {
+            return;
+        }
+        const node = this.instantiationService.createInstance(CustomViewNode, this._descriptor);
+        this._node.value = node;
+        this._contentArea.appendChild(node.element);
+        if (this._lastContentSize) {
+            this._layoutNode(this._lastContentSize.width, this._lastContentSize.height);
+        }
+    }
+    focus() {
+        this._node.value?.focus();
+    }
+    updateStyles() {
+        super.updateStyles();
+        applyAgentsPartCardStyles(assertReturnsDefined(this.getContainer()), this.theme);
+    }
+    layout(width, height, top, left) {
+        if (!this.layoutService.isVisible(Parts.CUSTOM_VIEW_GRID_PART)) {
+            return;
+        }
+        const cardSize = getAgentsPartCardContentSize(width, height, this.agentWorkbenchLayoutService.isEditorPaneVisible());
+        const {
+            contentSize
+        } = this.layoutContents(cardSize.width, cardSize.height);
+        this._layoutNode(contentSize.width, contentSize.height);
+        super.layout(width, height, top, left);
+    }
+    _layoutNode(width, height) {
+        this._lastContentSize = {
+            width,
+            height
+        };
+        const node = this._node.value;
+        if (!node) {
+            return;
+        }
+        size(node.element, width, height);
+        node.layout(width, height);
+    }
+    toJSON() {
+        return {
+            type: Parts.CUSTOM_VIEW_GRID_PART
+        };
+    }
+};
+CustomViewGridPart = ( __decorate([( __param(0, IThemeService)), ( __param(1, IStorageService)), ( __param(2, IAgentWorkbenchLayoutService)), ( __param(3, IInstantiationService))], CustomViewGridPart));
+
+export { CustomViewGridPart };

package/vscode/src/vs/sessions/browser/parts/customViewGridParts.d.ts

@@ -0,0 +1,17 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ICustomViewDescriptor } from "../../services/customView/browser/customView.js";
+import { ICustomViewGridPartService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/customView/browser/customViewGridPartService.service";
+/**
+ * Owns the lifecycle of the {@link CustomViewGridPart}. Selects the mobile vs.
+ * desktop variant based on viewport width at construction time. Registered as an
+ * eager singleton so the part registers itself with the workbench layout service
+ * before the workbench starts laying out parts.
+ */
+export declare class CustomViewGridParts extends Disposable implements ICustomViewGridPartService {
+    readonly _serviceBrand: undefined;
+    private readonly _mainPart;
+    constructor(instantiationService: IInstantiationService);
+    setView(descriptor: ICustomViewDescriptor | undefined): void;
+    focusActiveView(): void;
+}

package/vscode/src/vs/sessions/browser/parts/customViewGridParts.js

@@ -0,0 +1,31 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { getClientArea } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { CustomViewGridPart } from './customViewGridPart.js';
+import { MobileCustomViewGridPart } from './mobile/mobileCustomViewGridPart.js';
+
+let CustomViewGridParts = class CustomViewGridParts extends Disposable {
+    constructor(instantiationService) {
+        super();
+        const {
+            width
+        } = getClientArea(mainWindow.document.body);
+        const isPhoneLayout = width < 640;
+        this._mainPart = this._register(
+            instantiationService.createInstance(isPhoneLayout ? MobileCustomViewGridPart : CustomViewGridPart)
+        );
+    }
+    setView(descriptor) {
+        this._mainPart.setView(descriptor);
+    }
+    focusActiveView() {
+        this._mainPart.focus();
+    }
+};
+CustomViewGridParts = ( __decorate([( __param(0, IInstantiationService))], CustomViewGridParts));
+
+export { CustomViewGridParts };

package/vscode/src/vs/sessions/browser/parts/customViewNode.d.ts

@@ -0,0 +1,24 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ICustomViewDescriptor } from "../../services/customView/browser/customView.js";
+/**
+ * A leaf of the custom view grid. Owns the shared chrome — a header with the
+ * title, an optional description and the contributed actions, above a scroll
+ * container — and hosts one {@link AbstractCustomView} inside it.
+ */
+export declare class CustomViewNode extends Disposable {
+    readonly element: HTMLElement;
+    private readonly _headerEl;
+    private readonly _headerBandEl;
+    private readonly _titleEl;
+    private readonly _descriptionEl;
+    private readonly _contentEl;
+    private readonly _scrollable;
+    private readonly _view;
+    private readonly _maxWidth;
+    private _lastLayout;
+    constructor(descriptor: ICustomViewDescriptor, instantiationService: IInstantiationService);
+    layout(width: number, height: number): void;
+    focus(): void;
+    private _layoutChildren;
+}

package/vscode/src/vs/sessions/browser/parts/customViewNode.js

@@ -0,0 +1,131 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as customViewGridPart from './media/customViewGridPart.css';
+import { $, addDisposableListener, EventType, scheduleAtNextAnimationFrame, getWindow, isAncestorOfActiveElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { DomScrollableElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { Disposable, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ScrollbarVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/common/scrollable';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { asCssVariable } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import { AGENTS_CENTERED_CONTENT_MAX_WIDTH } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/layoutConstants';
+import { activeSessionViewBackground, activeSessionViewForeground } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/theme';
+import { ChatPillActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/chatPills';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(customViewGridPart, 0);
+let CustomViewNode = class CustomViewNode extends Disposable {
+    constructor(descriptor, instantiationService) {
+        super();
+        this.element = $(".custom-view-node");
+        this._view = this._register(instantiationService.createInstance(descriptor.ctor));
+        this._maxWidth = this._view.maxWidth ?? AGENTS_CENTERED_CONTENT_MAX_WIDTH;
+        this.element.style.setProperty("--session-view-background", asCssVariable(activeSessionViewBackground));
+        this.element.style.setProperty("--session-view-foreground", asCssVariable(activeSessionViewForeground));
+        this.element.setAttribute("role", "region");
+        this.element.setAttribute("data-view-id", descriptor.id);
+        this._headerEl = $(".custom-view-header");
+        this.element.appendChild(this._headerEl);
+        this._headerBandEl = $(".custom-view-header-band");
+        this._headerEl.appendChild(this._headerBandEl);
+        const titleRow = $(".custom-view-header-title-row");
+        this._headerBandEl.appendChild(titleRow);
+        this._titleEl = $(".custom-view-header-title");
+        titleRow.appendChild(this._titleEl);
+        this._descriptionEl = $(".custom-view-header-description");
+        this._headerBandEl.appendChild(this._descriptionEl);
+        if (descriptor.actions) {
+            const buttonBar = descriptor.actions.style === "buttonBar";
+            const actionsContainer = $(".custom-view-header-actions");
+            actionsContainer.classList.toggle("custom-view-header-actions-buttons", buttonBar);
+            titleRow.appendChild(actionsContainer);
+            const toolbar = this._register(
+                instantiationService.createInstance(MenuWorkbenchToolBar, actionsContainer, descriptor.actions.menuId, {
+                    hiddenItemStrategy: HiddenItemStrategy.Ignore,
+                    menuOptions: {
+                        shouldForwardArgs: true
+                    },
+                    toolbarOptions: {
+                        primaryGroup: () => true
+                    },
+                    actionViewItemProvider: buttonBar ? (action, options) => action instanceof MenuItemAction ? instantiationService.createInstance(ChatPillActionViewItem, undefined, action, options) : undefined : undefined
+                })
+            );
+            this._register(toolbar.onDidChangeMenuItems(() => this._layoutChildren()));
+        }
+        const scrollContent = $(".custom-view-scroll-content");
+        this._contentEl = $(".custom-view-content");
+        this._contentEl.tabIndex = -1;
+        scrollContent.appendChild(this._contentEl);
+        this._scrollable = this._register(( new DomScrollableElement(scrollContent, {
+            horizontal: ScrollbarVisibility.Hidden,
+            vertical: ScrollbarVisibility.Auto,
+            useShadows: false
+        })));
+        this._register(addDisposableListener(scrollContent, EventType.SCROLL, () => {
+            this._scrollable.setScrollPosition({
+                scrollTop: scrollContent.scrollTop
+            });
+        }));
+        const focusScrollSync = this._register(( new MutableDisposable()));
+        this._register(addDisposableListener(scrollContent, EventType.FOCUS_IN, () => {
+            focusScrollSync.value = scheduleAtNextAnimationFrame(getWindow(scrollContent), () => {
+                this._scrollable.setScrollPosition({
+                    scrollTop: scrollContent.scrollTop
+                });
+            });
+        }));
+        this._scrollable.getDomNode().classList.add("custom-view-body");
+        this.element.appendChild(this._scrollable.getDomNode());
+        this._view.render(this._contentEl);
+        const resizeObserver = ( new ResizeObserver(() => this._scrollable.scanDomNode()));
+        resizeObserver.observe(this._contentEl);
+        this._register(toDisposable(() => resizeObserver.disconnect()));
+        this._register(autorun(reader => {
+            const title = this._view.title.read(reader);
+            this._titleEl.textContent = title;
+            this.element.setAttribute("aria-label", title);
+            this._layoutChildren();
+        }));
+        this._register(autorun(reader => {
+            const description = this._view.description.read(reader);
+            this._descriptionEl.textContent = description ?? "";
+            this._descriptionEl.classList.toggle("hidden", !description);
+            this._layoutChildren();
+        }));
+        this._register(toDisposable(() => this.element.remove()));
+    }
+    layout(width, height) {
+        this._lastLayout = {
+            width,
+            height
+        };
+        this._layoutChildren();
+    }
+    focus() {
+        this._view.focus();
+        if (!isAncestorOfActiveElement(this.element)) {
+            this._contentEl.focus();
+        }
+    }
+    _layoutChildren() {
+        if (!this._lastLayout) {
+            return;
+        }
+        const {
+            width,
+            height
+        } = this._lastLayout;
+        const bandWidth = Math.min(width, this._maxWidth);
+        this._headerBandEl.style.width = `${bandWidth}px`;
+        this._contentEl.style.width = `${bandWidth}px`;
+        this._view.layout(bandWidth, Math.max(0, height - this._headerEl.offsetHeight));
+        this._scrollable.scanDomNode();
+    }
+};
+CustomViewNode = ( __decorate([( __param(1, IInstantiationService))], CustomViewNode));
+
+export { CustomViewNode };

package/vscode/src/vs/sessions/browser/parts/editorPart.d.ts

@@ -0,0 +1,11 @@
+import { LayoutPriority } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/splitview/splitview";
+import { MainEditorPart as MainEditorPartBase } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPart";
+export declare class MainEditorPart extends MainEditorPartBase {
+    static readonly MARGIN_TOP = 0;
+    static readonly MARGIN_BOTTOM = 0;
+    static readonly MARGIN_LEFT = 0;
+    static readonly MARGIN_RIGHT = 0;
+    get minimumWidth(): number;
+    priority: LayoutPriority;
+    layout(width: number, height: number, top: number, left: number): void;
+}

package/vscode/src/vs/sessions/browser/parts/editorPart.js

@@ -0,0 +1,36 @@
+
+import { LayoutPriority } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/splitview/splitview';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { MainEditorPart as MainEditorPart$1 } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPart';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { EDITOR_PART_MINIMUM_WIDTH } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/editorPartSizing';
+
+class MainEditorPart extends MainEditorPart$1 {
+    constructor() {
+        super(...arguments);
+        this.priority = LayoutPriority.Normal;
+    }
+    static { this.MARGIN_TOP = 0; }
+    static { this.MARGIN_BOTTOM = 0; }
+    static { this.MARGIN_LEFT = 0; }
+    static { this.MARGIN_RIGHT = 0; }
+    get minimumWidth() {
+        return Math.max(EDITOR_PART_MINIMUM_WIDTH, super.minimumWidth);
+    }
+    layout(width, height, top, left) {
+        const agentLayoutService = this.layoutService;
+        const keepForDockedTabBar = agentLayoutService.isSinglePaneLayoutEnabled
+            && this.layoutService.isVisible(Parts.AUXILIARYBAR_PART);
+        if (!this.layoutService.isVisible(Parts.EDITOR_PART, mainWindow) && !keepForDockedTabBar) {
+            return;
+        }
+        const adjustedWidth = width - MainEditorPart.MARGIN_RIGHT - MainEditorPart.MARGIN_LEFT - 2 ;
+        const adjustedHeight = height - MainEditorPart.MARGIN_TOP - MainEditorPart.MARGIN_BOTTOM - 2 ;
+        super.layout(adjustedWidth, adjustedHeight, top, left);
+        if (agentLayoutService.isSinglePaneLayoutEnabled && !this.layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+            agentLayoutService.handleDockedEditorPartLayout(width);
+        }
+    }
+}
+
+export { MainEditorPart };

package/vscode/src/vs/sessions/browser/parts/editorParts.d.ts

@@ -0,0 +1,12 @@
+import { IEditorGroupView } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editor";
+import { EditorParts as EditorPartsBase } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorParts";
+import { GroupIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { GroupDirection } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { MainEditorPart } from "./editorPart.js";
+export declare class EditorParts extends EditorPartsBase {
+    protected createMainEditorPart(): MainEditorPart;
+    moveGroup(group: IEditorGroupView | GroupIdentifier, location: IEditorGroupView | GroupIdentifier, direction: GroupDirection): IEditorGroupView;
+    copyGroup(group: IEditorGroupView | GroupIdentifier, location: IEditorGroupView | GroupIdentifier, direction: GroupDirection): IEditorGroupView;
+    private involvesSinglePaneMainPart;
+    private resolveGroup;
+}

package/vscode/src/vs/sessions/browser/parts/editorParts.js

@@ -0,0 +1,45 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import * as editorPart from './media/editorPart.css';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { EditorParts as EditorParts$1 } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorParts';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { MainEditorPart } from './editorPart.js';
+import { SinglePaneMainEditorPart } from './singlePaneEditorPart.js';
+
+registerCss(editorPart, 0);
+class EditorParts extends EditorParts$1 {
+    createMainEditorPart() {
+        const layoutService = this.instantiationService.invokeFunction(accessor => accessor.get(IAgentWorkbenchLayoutService));
+        const editorPart = layoutService.isSinglePaneLayoutEnabled ? this.instantiationService.createInstance(SinglePaneMainEditorPart, this) : this.instantiationService.createInstance(MainEditorPart, this);
+        this._register(editorPart.enforcePartOptions({
+            tabActionReserveSpace: false
+        }));
+        return editorPart;
+    }
+    moveGroup(group, location, direction) {
+        if (this.involvesSinglePaneMainPart(group, location)) {
+            return this.resolveGroup(group);
+        }
+        return super.moveGroup(group, location, direction);
+    }
+    copyGroup(group, location, direction) {
+        if (this.involvesSinglePaneMainPart(group, location)) {
+            return this.resolveGroup(group);
+        }
+        return super.copyGroup(group, location, direction);
+    }
+    involvesSinglePaneMainPart(group, location) {
+        return this.mainPart instanceof SinglePaneMainEditorPart && (this.getPart(group) === this.mainPart || this.getPart(location) === this.mainPart);
+    }
+    resolveGroup(group) {
+        const resolvedGroup = typeof group === "number" ? this.getGroup(group) : group;
+        if (!resolvedGroup) {
+            throw ( new Error("Invalid editor group provided!"));
+        }
+        return resolvedGroup;
+    }
+}
+
+export { EditorParts };