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

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

@@ -0,0 +1,336 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as sessionsPart from './media/sessionsPart.css';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+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 { agentsPanelBorder } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/theme';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { assertReturnsDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { LayoutPriority } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/splitview/splitview';
+import { SerializableGrid, Sizing, Direction } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/grid/grid';
+import { Part } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/part';
+import { ActiveSessionsContext, SessionsFocusContext, MultipleSessionsVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { $, trackFocus, isAncestor, isAncestorOfActiveElement, addDisposableListener, EventType, addDisposableGenericMouseDownListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { SessionView } from './sessionView.js';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Color } from '@codingame/monaco-vscode-api/vscode/vs/base/common/color';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import { contrastBorder } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { SessionDropTarget } from './sessionDropTarget.js';
+import { ProgressBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/progressbar/progressbar';
+import { defaultProgressBarStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { AbstractProgressScope, ScopedProgressIndicator } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/progress/browser/progressIndicator';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { applyAgentsPartCardStyles, getAgentsPartCardContentSize } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/agentsPartCard';
+import { SessionsChatBackgroundRenderer } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/chatBackground/browser/chatBackgroundRenderer';
+import { ISessionsChatBackgroundService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/chatBackground/browser/chatBackgroundService.service';
+
+registerCss(sessionsPart, 0);
+let SessionsPart = class SessionsPart extends Part {
+    get snap() {
+        return false;
+    }
+    static {
+        this.BORDER_WIDTH = 1;
+    }
+    get _sessionViewsVisible() {
+        return this._isPartVisible && this._contentVisible;
+    }
+    get preferredHeight() {
+        return this.layoutService.mainContainerDimension.height * 0.4;
+    }
+    constructor(
+        themeService,
+        storageService,
+        agentWorkbenchLayoutService,
+        contextKeyService,
+        instantiationService,
+        chatBackgroundService
+    ) {
+        super(Parts.SESSIONS_PART, {
+            hasTitle: false,
+            borderWidth: () => 0
+        }, themeService, storageService, agentWorkbenchLayoutService);
+        this.agentWorkbenchLayoutService = agentWorkbenchLayoutService;
+        this.instantiationService = instantiationService;
+        this.chatBackgroundService = chatBackgroundService;
+        this.minimumWidth = 300;
+        this.maximumWidth = Number.POSITIVE_INFINITY;
+        this.minimumHeight = 0;
+        this.maximumHeight = Number.POSITIVE_INFINITY;
+        this._slots = [];
+        this._onDidFocusSession = this._register(( new Emitter()));
+        this.onDidFocusSession = this._onDidFocusSession.event;
+        this._isPartVisible = true;
+        this._contentVisible = true;
+        this.priority = LayoutPriority.High;
+        ActiveSessionsContext.bindTo(contextKeyService);
+        this._sessionsFocusKey = SessionsFocusContext.bindTo(contextKeyService);
+        this._multipleSessionsVisibleKey = MultipleSessionsVisibleContext.bindTo(contextKeyService);
+    }
+    create(parent) {
+        this.element = parent;
+        parent.classList.add("sessionspart");
+        super.create(parent);
+    }
+    createContentArea(parent) {
+        const backgroundRenderer = this._register(( new SessionsChatBackgroundRenderer(parent)));
+        const updateBackground = () => backgroundRenderer.setBackground(this.chatBackgroundService.getBackground());
+        this._register(this.chatBackgroundService.onDidChangeBackground(updateBackground));
+        updateBackground();
+        const contentArea = $(".content");
+        parent.appendChild(contentArea);
+        const focusTracker = this._register(trackFocus(contentArea));
+        this._register(focusTracker.onDidFocus(() => this._sessionsFocusKey.set(true)));
+        this._register(focusTracker.onDidBlur(() => this._sessionsFocusKey.set(false)));
+        this._progressBar = this._register(( new ProgressBar(contentArea, defaultProgressBarStyles)));
+        this._progressBar.hide();
+        const placeholder = this._createSlot();
+        this._gridWidget = this._register(( new SerializableGrid(placeholder.view, {
+            styles: {
+                separatorBorder: this._gridSeparatorBorder
+            }
+        })));
+        this._slots.push(placeholder);
+        contentArea.appendChild(this._gridWidget.element);
+        this._register(
+            this._gridWidget.onDidChangeViewMaximized(() => this._updateMaximizedState())
+        );
+        const dropDelegate = {
+            findTargetView: child => this._findTargetView(child)
+        };
+        this._register(
+            this.instantiationService.createInstance(SessionDropTarget, contentArea, dropDelegate)
+        );
+        return contentArea;
+    }
+    _findTargetView(child) {
+        for (const slot of this._slots) {
+            if (slot.boundSessionId === undefined) {
+                continue;
+            }
+            if (isAncestor(child, slot.view.element)) {
+                return {
+                    sessionId: slot.boundSessionId,
+                    element: slot.view.element
+                };
+            }
+        }
+        return undefined;
+    }
+    updateVisibleSessions(visible, active) {
+        if (!this._gridWidget) {
+            return;
+        }
+        const desiredCount = Math.max(visible.length, 1);
+        while (this._slots.length < desiredCount) {
+            const slot = this._createSlot();
+            const reference = this._slots[this._slots.length - 1].view;
+            this._gridWidget.addView(slot.view, Sizing.Distribute, reference, Direction.Right);
+            this._slots.push(slot);
+        }
+        while (this._slots.length > desiredCount) {
+            const slot = this._slots.pop();
+            this._gridWidget.removeView(slot.view, Sizing.Distribute);
+            slot.disposables.dispose();
+        }
+        for (let i = 0; i < this._slots.length; i++) {
+            const slot = this._slots[i];
+            const session = visible[i];
+            slot.boundSessionId = session?.sessionId;
+            slot.view.openSession(session, {});
+        }
+        const activeId = active?.sessionId;
+        for (const slot of this._slots) {
+            const isActive = (slot.boundSessionId !== undefined && slot.boundSessionId === activeId) || this._slots.length === 1;
+            slot.view.element.classList.toggle("is-active", isActive);
+            slot.view.setActive(isActive);
+        }
+        if (this._gridWidget.hasMaximizedView()) {
+            const maximizedSlot = this._slots.find(s => this._gridWidget.isViewMaximized(s.view));
+            if (maximizedSlot && maximizedSlot.boundSessionId !== activeId) {
+                this._gridWidget.exitMaximizedView();
+            }
+        }
+        this._updateContextKeys(visible);
+    }
+    _updateContextKeys(visible) {
+        this._multipleSessionsVisibleKey.set(visible.length > 1);
+    }
+    _updateMaximizedState() {
+        if (!this._gridWidget) {
+            return;
+        }
+        for (const slot of this._slots) {
+            slot.view.setMaximized(this._gridWidget.isViewMaximized(slot.view));
+        }
+    }
+    toggleMaximizeSession(sessionId) {
+        if (!this._gridWidget) {
+            return undefined;
+        }
+        const slot = this._slots.find(s => s.boundSessionId === sessionId);
+        if (!slot) {
+            return undefined;
+        }
+        if (this._gridWidget.isViewMaximized(slot.view)) {
+            this._gridWidget.exitMaximizedView();
+            return false;
+        } else if (this._slots.filter(s => s.boundSessionId !== undefined).length >= 2) {
+            this._gridWidget.maximizeView(slot.view);
+            slot.view.focus();
+            return true;
+        }
+        return undefined;
+    }
+    getSessionView(sessionId) {
+        return this._slots.find(s => s.boundSessionId === sessionId)?.view;
+    }
+    getFocusedSessionView() {
+        return this._slots.find(slot => isAncestorOfActiveElement(slot.view.element))?.view;
+    }
+    focusSession(sessionId) {
+        const slot = this._slots.find(s => s.boundSessionId === sessionId);
+        if (!slot) {
+            return;
+        }
+        this._revealView(slot.view);
+        slot.view.focus();
+    }
+    _revealView(view) {
+        if (!this._gridWidget) {
+            return;
+        }
+        const containerRect = this._gridWidget.element.getBoundingClientRect();
+        const viewRect = view.element.getBoundingClientRect();
+        const isFullyVisible = viewRect.left >= containerRect.left - 1 && viewRect.right <= containerRect.right + 1;
+        if (!isFullyVisible) {
+            view.element.scrollIntoView({
+                block: "nearest",
+                inline: "nearest"
+            });
+        }
+    }
+    getProgressIndicator() {
+        if (!this._progressIndicator) {
+            const progressBar = assertReturnsDefined(this._progressBar);
+            const scopeId = Parts.SESSIONS_PART;
+            const isVisible = this.layoutService.isVisible(scopeId);
+            const onDidVisibilityChange = this.onDidVisibilityChange;
+            const scope = this._register(new (class extends AbstractProgressScope {
+                constructor() {
+                    super(scopeId, isVisible);
+                    this._register(onDidVisibilityChange(
+                        visible => visible ? this.onScopeOpened(scopeId) : this.onScopeClosed(scopeId)
+                    ));
+                }
+            })());
+            this._progressIndicator = this._register(( new ScopedProgressIndicator(progressBar, scope)));
+        }
+        return this._progressIndicator;
+    }
+    _createSlot() {
+        const disposables = ( new DisposableStore());
+        const view = disposables.add(this.instantiationService.createInstance(SessionView));
+        view.setPartVisible(this._sessionViewsVisible);
+        const slot = {
+            view,
+            disposables,
+            boundSessionId: undefined
+        };
+        const fireFocus = () => {
+            if (slot.boundSessionId !== undefined) {
+                this._restoreSessionOnActivation(view);
+                this._onDidFocusSession.fire(slot.boundSessionId);
+            }
+        };
+        disposables.add(addDisposableListener(view.element, EventType.FOCUS_IN, fireFocus, true));
+        disposables.add(addDisposableGenericMouseDownListener(view.element, fireFocus, true));
+        return slot;
+    }
+    _restoreSessionOnActivation(view) {
+        if (!this._gridWidget) {
+            return;
+        }
+        const viewSize = this._gridWidget.getViewSize(view);
+        if (viewSize.width === view.minimumWidth) {
+            this._gridWidget.expandView(view);
+        }
+    }
+    get _gridSeparatorBorder() {
+        return this.theme.getColor(agentsPanelBorder) || this.theme.getColor(contrastBorder) || Color.transparent;
+    }
+    updateStyles() {
+        super.updateStyles();
+        const container = assertReturnsDefined(this.getContainer());
+        applyAgentsPartCardStyles(container, this.theme);
+        this._gridWidget?.style({
+            separatorBorder: this._gridSeparatorBorder
+        });
+    }
+    setContentVisible(visible) {
+        if (this._contentVisible === visible) {
+            return;
+        }
+        this._contentVisible = visible;
+        this._updateSessionViewsVisibility();
+    }
+    _updateSessionViewsVisibility() {
+        const visible = this._sessionViewsVisible;
+        for (const slot of this._slots) {
+            slot.view.setPartVisible(visible);
+        }
+    }
+    setVisible(visible) {
+        if (this._isPartVisible !== visible) {
+            this._isPartVisible = visible;
+            this._updateSessionViewsVisibility();
+        }
+        super.setVisible(visible);
+    }
+    layout(width, height, top, left) {
+        if (!this.layoutService.isVisible(Parts.SESSIONS_PART)) {
+            return;
+        }
+        this._lastLayout = {
+            width,
+            height,
+            top,
+            left
+        };
+        const cardSize = getAgentsPartCardContentSize(width, height, this.agentWorkbenchLayoutService.isEditorPaneVisible());
+        const {
+            contentSize
+        } = this.layoutContents(cardSize.width, cardSize.height);
+        this._gridWidget?.layout(contentSize.width, contentSize.height, top, left);
+        super.layout(width, height, top, left);
+    }
+    dispose() {
+        for (const slot of this._slots) {
+            slot.disposables.dispose();
+        }
+        this._slots.length = 0;
+        super.dispose();
+    }
+    toJSON() {
+        return {
+            type: Parts.SESSIONS_PART
+        };
+    }
+};
+SessionsPart = ( __decorate([( __param(0, IThemeService)), ( __param(1, IStorageService)), ( __param(2, IAgentWorkbenchLayoutService)), ( __param(3, IContextKeyService)), ( __param(4, IInstantiationService)), ( __param(5, ISessionsChatBackgroundService))], SessionsPart));
+
+export { SessionsPart };

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

@@ -0,0 +1,33 @@
+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 { SessionView } from "./sessionView.js";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { IProgressIndicator } from "@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IToggleMaximizeSessionEvent } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService";
+import { ISessionsPartService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service";
+/**
+ * Owns the lifecycle of the {@link SessionsPart}. 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.
+ *
+ * The part is a passive renderer: the {@link ISessionsService} drives the
+ * grid via {@link updateVisibleSessions}/{@link focusSession} and listens to
+ * {@link onDidFocusSession}. The part observes neither the model nor the view.
+ */
+export declare class SessionsParts extends Disposable implements ISessionsPartService {
+    readonly _serviceBrand: undefined;
+    private readonly _mainPart;
+    private readonly _onDidToggleMaximizeSession;
+    readonly onDidToggleMaximizeSession: Event<IToggleMaximizeSessionEvent>;
+    get onDidFocusSession(): Event<string>;
+    constructor(instantiationService: IInstantiationService);
+    updateVisibleSessions(visible: readonly (IActiveSession | undefined)[], active: IActiveSession | undefined): void;
+    setContentVisible(visible: boolean): void;
+    toggleMaximizeSession(session: IActiveSession | undefined): void;
+    focusSession(session: IActiveSession | undefined): void;
+    getSessionView(sessionId: string | undefined): SessionView | undefined;
+    getFocusedSessionView(): SessionView | undefined;
+    getProgressIndicator(): IProgressIndicator;
+}

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

@@ -0,0 +1,62 @@
+
+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 { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+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 { SessionsPart } from './sessionsPart.js';
+import { MobileSessionsPart } from './mobile/mobileSessionsPart.js';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+
+let SessionsParts = class SessionsParts extends Disposable {
+    get onDidFocusSession() {
+        return this._mainPart.onDidFocusSession;
+    }
+    constructor(instantiationService) {
+        super();
+        this._onDidToggleMaximizeSession = this._register(( new Emitter()));
+        this.onDidToggleMaximizeSession = this._onDidToggleMaximizeSession.event;
+        const {
+            width
+        } = getClientArea(mainWindow.document.body);
+        const isPhoneLayout = width < 640;
+        this._mainPart = this._register(
+            instantiationService.createInstance(isPhoneLayout ? MobileSessionsPart : SessionsPart)
+        );
+    }
+    updateVisibleSessions(visible, active) {
+        this._mainPart.updateVisibleSessions(visible, active);
+    }
+    setContentVisible(visible) {
+        this._mainPart.setContentVisible(visible);
+    }
+    toggleMaximizeSession(session) {
+        if (!session) {
+            this._mainPart.toggleMaximizeSession(undefined);
+            return;
+        }
+        const maximized = this._mainPart.toggleMaximizeSession(session.sessionId);
+        if (maximized !== undefined) {
+            this._onDidToggleMaximizeSession.fire({
+                session,
+                maximized
+            });
+        }
+    }
+    focusSession(session) {
+        this._mainPart.focusSession(session?.sessionId);
+    }
+    getSessionView(sessionId) {
+        return this._mainPart.getSessionView(sessionId);
+    }
+    getFocusedSessionView() {
+        return this._mainPart.getFocusedSessionView();
+    }
+    getProgressIndicator() {
+        return this._mainPart.getProgressIndicator();
+    }
+};
+SessionsParts = ( __decorate([( __param(0, IInstantiationService))], SessionsParts));
+
+export { SessionsParts };

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

@@ -0,0 +1,13 @@
+import { AuxiliaryBarPart } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/auxiliaryBarPart";
+/**
+ * Single-pane variant of the auxiliary bar. In the single-pane layout the
+ * auxiliary bar is docked inside the editor part as a contextual detail panel:
+ * it has no title/composite bar, shares the editor background so the pane reads
+ * as one card, and fills the exact rectangle the workbench positions it in.
+ */
+export declare class SinglePaneAuxiliaryBarPart extends AuxiliaryBarPart {
+    create(parent: HTMLElement): void;
+    protected shouldShowCompositeBar(): boolean;
+    protected getPartBackgroundColor(): string;
+    layout(width: number, height: number, top: number, left: number): void;
+}

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

@@ -0,0 +1,36 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorBackground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { AbstractPaneCompositePart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/paneCompositePart';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { AuxiliaryBarPart } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/auxiliaryBarPart';
+
+class SinglePaneAuxiliaryBarPart extends AuxiliaryBarPart {
+    create(parent) {
+        this.options = { ...this.options, hasTitle: false };
+        super.create(parent);
+    }
+    shouldShowCompositeBar() {
+        return false;
+    }
+    getPartBackgroundColor() {
+        return this.getColor(editorBackground) || '';
+    }
+    layout(width, height, top, left) {
+        if (!this.layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+            return;
+        }
+        AbstractPaneCompositePart.prototype.layout.call(this, width, height, top, left);
+    }
+}
+
+export { SinglePaneAuxiliaryBarPart };

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

@@ -0,0 +1,65 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+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 { IEditorGroupView, IEditorGroupViewOptions, IEditorPartCreationOptions, IEditorPartsView } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editor";
+import { IEditorPartUIState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPart";
+import { GroupIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { EditorGroupLayout, GroupDirection, IEditorDropTargetDelegate } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { IHostService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service";
+import { IAgentWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service";
+import { MainEditorPart } from "./editorPart.js";
+import { SinglePaneAuxiliaryBarPart } from "./singlePaneAuxiliaryBarPart.js";
+/**
+ * Single-pane editor part: owns the docked auxiliary bar so "tab bar + editor
+ * header + editor + auxiliary bar" is a single unit. It creates the
+ * {@link SinglePaneAuxiliaryBarPart} (lazily, so the pane composite service and
+ * the editor part share one instance) and the {@link DockedAuxiliaryBarController}
+ * that docks and sizes the auxiliary bar inside the editor part. The header itself
+ * is rendered by the editor group from the group's configured header
+ * menus, supplied via {@link getGroupViewOptions}, and also hosts breadcrumbs in
+ * that row for text file editors. The part only reacts to the tab row's height to
+ * reposition the docked auxiliary bar.
+ */
+export declare class SinglePaneMainEditorPart extends MainEditorPart {
+    private readonly _instantiationService;
+    private readonly agentWorkbenchLayoutService;
+    private _auxiliaryBar;
+    private _dockedAuxBar;
+    private readonly _groupRelayoutListeners;
+    private readonly _tabsOverride;
+    private _enforcedShowTabs;
+    protected getGroupViewOptions(): IEditorGroupViewOptions;
+    get preferredWidth(): number | undefined;
+    get minimumWidth(): number;
+    get snap(): boolean;
+    constructor(editorPartsView: IEditorPartsView, _instantiationService: IInstantiationService, themeService: IThemeService, configurationService: IConfigurationService, storageService: IStorageService, agentWorkbenchLayoutService: IAgentWorkbenchLayoutService, hostService: IHostService, contextKeyService: IContextKeyService);
+    private _updateTabsOverride;
+    private _getShowTabsOverride;
+    /**
+     * The auxiliary bar owned by this editor part, created on first access. The
+     * pane composite service reads this so both share the same instance.
+     */
+    get auxiliaryBar(): SinglePaneAuxiliaryBarPart;
+    /**
+     * Creates the editor part's DOM. Besides the base content (the editor grid), the
+     * single-pane part docks the auxiliary bar here — in the same place the base part
+     * creates its content — and enables the header separator border on every group.
+     */
+    protected createContentArea(parent: HTMLElement, options?: IEditorPartCreationOptions): HTMLElement;
+    addGroup(location: IEditorGroupView | GroupIdentifier, _direction: GroupDirection, _groupToCopy?: IEditorGroupView): IEditorGroupView;
+    applyLayout(layout: EditorGroupLayout): void;
+    createEditorDropTarget(container: unknown, delegate: IEditorDropTargetDelegate): IDisposable;
+    applyState(state: IEditorPartUIState | "empty", options?: IEditorGroupViewOptions): Promise<void>;
+    private _ensureSingleEditorGroup;
+    /**
+     * Keeps the docked auxiliary bar aligned after group-local relayouts.
+     */
+    private _registerGroupRelayoutListeners;
+    private _registerGroupRelayoutListener;
+    layout(width: number, height: number, top: number, left: number): void;
+    /** Re-layouts the docked auxiliary bar. Called by the workbench on layout changes. */
+    layoutDockedAuxiliaryBar(): void;
+}