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

package/vscode/src/vs/sessions/contrib/layout/browser/singlePane/singlePaneDockedTabsCoordinator.js

@@ -0,0 +1,513 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { Sequencer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { EditorActivation } from '@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor';
+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 { EditorResourceAccessor, SideBySideEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { SinglePaneChangesTabMissingContext, SinglePaneFilesTabMissingContext, SinglePaneChangesTabAvailableContext, SinglePaneFilesTabAvailableContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { DockedEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/dockedEditorInput';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { SessionChangesEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesEditorInput';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService';
+import { IChangesViewService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changesViewService.service';
+import { EmptyFileEditorInput } from '../../../editor/browser/emptyFileEditorInput.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { ISessionChangesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/sessionChangesService.service';
+
+const CHANGES_TAB_OPTIONS = {
+    pinned: true,
+    index: 0,
+    inactive: true,
+    preserveFocus: true,
+    activation: EditorActivation.PRESERVE,
+    isExplicit: false
+};
+const CHANGES_TAB_ACTIVE_OPTIONS = {
+    pinned: true,
+    index: 0,
+    preserveFocus: true,
+    isExplicit: false
+};
+const FILES_TAB_OPTIONS = {
+    pinned: true,
+    inactive: true,
+    preserveFocus: true,
+    activation: EditorActivation.PRESERVE,
+    isExplicit: false
+};
+function mergeTriggers(a, b) {
+    return {
+        openDefaultsIfEmpty: a.openDefaultsIfEmpty || b.openDefaultsIfEmpty,
+        ensureChanges: a.ensureChanges || b.ensureChanges,
+        ensureChangesActive: a.ensureChangesActive || b.ensureChangesActive,
+        workingSetRestored: a.workingSetRestored || b.workingSetRestored
+    };
+}
+let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator extends Disposable {
+    constructor(
+        _ctx,
+        _layoutService,
+        _sessionsService,
+        _editorService,
+        _editorGroupsService,
+        _sessionChangesService,
+        _changesViewService,
+        contextKeyService,
+        _instantiationService
+    ) {
+        super();
+        this._ctx = _ctx;
+        this._layoutService = _layoutService;
+        this._sessionsService = _sessionsService;
+        this._editorService = _editorService;
+        this._editorGroupsService = _editorGroupsService;
+        this._sessionChangesService = _sessionChangesService;
+        this._changesViewService = _changesViewService;
+        this._instantiationService = _instantiationService;
+        this._sequencer = ( new Sequencer());
+        this._generation = 0;
+        this._filesTabDismissed = false;
+        this._changingFilesInternally = false;
+        this._changesTabMissingContext = SinglePaneChangesTabMissingContext.bindTo(contextKeyService);
+        this._filesTabMissingContext = SinglePaneFilesTabMissingContext.bindTo(contextKeyService);
+        this._changesTabAvailableContext = SinglePaneChangesTabAvailableContext.bindTo(contextKeyService);
+        this._filesTabAvailableContext = SinglePaneFilesTabAvailableContext.bindTo(contextKeyService);
+        let previousChangesSessionResource;
+        this._register(autorun(reader => {
+            const target = this._readTarget(reader);
+            const ensureChanges = !!target.changesSessionResource && (!previousChangesSessionResource || !isEqual(previousChangesSessionResource, target.changesSessionResource));
+            previousChangesSessionResource = target.changesSessionResource;
+            if (!target.wantsChangesTab) {
+                this._filesTabDismissed = false;
+            }
+            this.queueReconcile(target, {
+                openDefaultsIfEmpty: true,
+                ensureChanges
+            });
+        }));
+        this._register(this._layoutService.onDidRevealSidePane(() => {
+            this.queueReconcile(this._readTarget(undefined), {
+                openDefaultsIfEmpty: true
+            });
+        }));
+        const partVisibilityChangedSignal = observableSignalFromEvent(this, this._layoutService.onDidChangePartVisibility);
+        const editorsChangedSignal = observableSignalFromEvent(this, Event.any(
+            this._editorService.onDidActiveEditorChange,
+            this._editorService.onDidEditorsChange
+        ));
+        this._register(autorun(reader => {
+            partVisibilityChangedSignal.read(reader);
+            editorsChangedSignal.read(reader);
+            this.queueReconcile(this._readTarget(undefined), {});
+        }));
+        this._register(this._ctx.onDidEndSessionLayoutRestore(() => {
+            const session = this._sessionsService.activeSession.get();
+            const target = this._readTarget(undefined);
+            const ensureChanges = target.wantsChangesTab && session?.isCreated.get() === false;
+            this.queueReconcile(target, {
+                openDefaultsIfEmpty: true,
+                ensureChanges,
+                workingSetRestored: true
+            });
+        }));
+        this._register(this._editorService.onWillOpenEditor(e => {
+            if (e.editor instanceof EmptyFileEditorInput && !this._changingFilesInternally && !this._ctx.isRestoringSessionLayout) {
+                this._filesTabDismissed = false;
+            }
+            if (this._ctx.isRestoringSessionLayout || !this._isWorkspaceFileEditor(e.editor)) {
+                return;
+            }
+            const group = this._editorGroupsService.mainPart.getGroup(e.groupId);
+            if (!group || group.contains(e.editor)) {
+                return;
+            }
+            this._queue(() => this._removeFilesTab(this._editorGroupsService.mainPart.activeGroup));
+        }));
+        this._register(this._editorService.onDidCloseEditor(e => {
+            if (e.editor instanceof EmptyFileEditorInput && !this._changingFilesInternally && !this._ctx.isRestoringSessionLayout && !this._layoutService.isEditorPartAutoVisibilitySuppressed() && this._readTarget(undefined).wantsChangesTab) {
+                this._filesTabDismissed = true;
+            }
+        }));
+        const editorAreaVisibleObs = observableSignalFromEvent(this, this._layoutService.onDidChangePartVisibility);
+        this._register(autorun(reader => {
+            editorAreaVisibleObs.read(reader);
+            const visible = this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow);
+            if (this._editorAreaVisible === undefined) {
+                this._editorAreaVisible = visible;
+                return;
+            }
+            if (visible === this._editorAreaVisible) {
+                return;
+            }
+            this._editorAreaVisible = visible;
+            if (this._ctx.isRestoringSessionLayout) {
+                return;
+            }
+            if (visible) {
+                this._queue(() => this._restoreCollapsedTabs());
+                return;
+            }
+            if (this._ctx.togglingSidePane) {
+                return;
+            }
+            if (this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+                this._queue(() => this._collapseNonManagedTabs());
+            }
+        }));
+        this._register(
+            this._ctx.onDidEndSessionLayoutRestore(() => this._queueCollapseIfDetailsOnly())
+        );
+        this._register(this._editorService.onDidEditorsChange(() => {
+            if (!this._ctx.isRestoringSessionLayout) {
+                this._queueCollapseIfDetailsOnly();
+            }
+        }));
+    }
+    getChangesEditorResource(editor) {
+        const resource = editor.resource;
+        return resource && this._sessionChangesService.getSessionResource(resource) ? resource : undefined;
+    }
+    prepareWorkingSetRestore(hasSavedWorkingSet) {
+        const sessionKey = this._sessionsService.activeSession.get()?.resource.toString();
+        this._preserveMissingFilesForSessionKey = hasSavedWorkingSet && this._filesTabDismissed ? sessionKey : undefined;
+    }
+    readTarget(reader) {
+        return this._readTarget(reader);
+    }
+    queueReconcile(target, trigger) {
+        const sessionKey = this._sessionsService.activeSession.get()?.resource.toString();
+        const mergedTrigger = this._pending && this._pending.sessionKey === sessionKey ? mergeTriggers(this._pending.trigger, trigger) : trigger;
+        this._pending = {
+            sessionKey,
+            target,
+            trigger: mergedTrigger
+        };
+        const generation = ++this._generation;
+        this._queue(() => this._reconcile(generation));
+    }
+    _readTarget(reader) {
+        const read = obs => reader ? obs.read(reader) : obs.get();
+        const session = read(this._sessionsService.activeSession);
+        const isQuickChat = session?.isQuickChat ? read(session.isQuickChat) : false;
+        const workspace = session ? read(session.workspace) : undefined;
+        if (!session || isQuickChat || !workspace) {
+            return {
+                changesSessionResource: undefined,
+                workspace: undefined,
+                wantsChangesTab: false,
+                wantsFilesTab: false
+            };
+        }
+        return {
+            changesSessionResource: session.resource,
+            workspace,
+            wantsChangesTab: true,
+            wantsFilesTab: true
+        };
+    }
+    dispose() {
+        this._generation++;
+        this._pending = undefined;
+        super.dispose();
+    }
+    _queue(task) {
+        void this._sequencer.queue(() => this._store.isDisposed ? Promise.resolve() : task()).catch(error => {
+            if (!this._store.isDisposed) {
+                onUnexpectedError(error);
+            }
+        });
+    }
+    async _reconcile(generation) {
+        if (this._store.isDisposed || generation !== this._generation || !this._pending) {
+            return;
+        }
+        const pending = this._pending;
+        this._pending = undefined;
+        try {
+            await this._reconcileCore(pending.target, pending.trigger, generation);
+        } finally {
+            const successor = this._pending;
+            if (generation !== this._generation && successor && successor.sessionKey === pending.sessionKey) {
+                this._pending = {
+                    ...successor,
+                    trigger: mergeTriggers(successor.trigger, pending.trigger)
+                };
+            }
+        }
+    }
+    async _reconcileCore(target, trigger, generation) {
+        const group = this._editorGroupsService.mainPart.activeGroup;
+        let groupDisposed = false;
+        const groupDisposeListener = Event.once(group.onWillDispose)(() => groupDisposed = true);
+        const isCancelled = () => this._store.isDisposed || groupDisposed || generation !== this._generation;
+        this._resetCollapsedEditorsOnSessionChange();
+        const changesResource = target.changesSessionResource ? this._sessionChangesService.getChangesEditorResource(target.changesSessionResource) : undefined;
+        const suppression = this._layoutService.suppressEditorPartAutoVisibility();
+        try {
+            await this._reconcileForeignChangesEditors(group, changesResource, isCancelled);
+            if (isCancelled()) {
+                return;
+            }
+            this._updateFilesEditors(group, target.workspace);
+            const sessionKey = this._sessionsService.activeSession.get()?.resource.toString();
+            const preserveMissingFiles = !!trigger.workingSetRestored && this._preserveMissingFilesForSessionKey === sessionKey;
+            if (preserveMissingFiles) {
+                await this._removeFilesTab(group);
+                if (isCancelled()) {
+                    return;
+                }
+            }
+            const openIntoEmpty = !!trigger.openDefaultsIfEmpty && group.editors.length === 0;
+            const changesPresent = !!changesResource && !!this._findChangesEditor(group, changesResource);
+            const filesPresent = ( group.editors.some(editor => editor instanceof EmptyFileEditorInput));
+            const activeChangesResource = this._editorService.activeEditor && this.getChangesEditorResource(this._editorService.activeEditor);
+            const activateChanges = !!trigger.ensureChangesActive && !!changesResource && (!activeChangesResource || !isEqual(activeChangesResource, changesResource));
+            const ensureAllInputs = this._layoutService.isVisible(Parts.AUXILIARYBAR_PART) && !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow);
+            const openChanges = target.wantsChangesTab && !!changesResource && (activateChanges || (!changesPresent && (openIntoEmpty || ensureAllInputs || trigger.ensureChanges)));
+            const openFiles = target.wantsFilesTab && !filesPresent && !preserveMissingFiles && (openIntoEmpty || ensureAllInputs);
+            const isCreated = this._sessionsService.activeSession.get()?.isCreated.get() ?? false;
+            const openFilesFirst = openChanges && openFiles && !isCreated && group.editors.length === 0;
+            if (openFilesFirst) {
+                await this._openFilesTab(group, target.workspace);
+                if (isCancelled()) {
+                    return;
+                }
+            }
+            if (openChanges && changesResource) {
+                if (!(await this._openChangesTab(
+                    target.changesSessionResource,
+                    changesResource,
+                    group,
+                    activateChanges,
+                    isCancelled
+                ))) {
+                    return;
+                }
+            }
+            if (openFiles && !openFilesFirst) {
+                await this._openFilesTab(group, target.workspace);
+                if (isCancelled()) {
+                    return;
+                }
+            }
+        } catch (error) {
+            if (!this._store.isDisposed && !groupDisposed) {
+                throw error;
+            }
+        } finally {
+            suppression.dispose();
+            groupDisposeListener.dispose();
+            if (!isCancelled()) {
+                if (trigger.workingSetRestored) {
+                    this._preserveMissingFilesForSessionKey = undefined;
+                }
+                this._updateAddTabContexts(target);
+            }
+        }
+    }
+    _resetCollapsedEditorsOnSessionChange() {
+        const sessionKey = this._sessionsService.activeSession.get()?.resource.toString();
+        if (sessionKey !== this._lastSyncedSessionKey) {
+            this._collapsedEditors = undefined;
+            this._lastSyncedSessionKey = sessionKey;
+        }
+    }
+    async _openChangesTab(sessionResource, changesResource, group, active, isCancelled) {
+        this._changesViewService.setChangesetId(undefined);
+        await this._sessionChangesService.openChangesEditor(
+            sessionResource,
+            active ? CHANGES_TAB_ACTIVE_OPTIONS : CHANGES_TAB_OPTIONS,
+            group
+        );
+        if (isCancelled()) {
+            return false;
+        }
+        const changesEditor = this._findChangesEditor(group, changesResource);
+        if (changesEditor) {
+            this._pinFirst(group, changesEditor);
+        }
+        return true;
+    }
+    async _openFilesTab(group, workspace) {
+        const suppression = this._layoutService.suppressEditorPartAutoVisibility();
+        this._changingFilesInternally = true;
+        try {
+            await this._editorService.openEditor(
+                this._instantiationService.createInstance(EmptyFileEditorInput, workspace),
+                FILES_TAB_OPTIONS,
+                group
+            );
+            this._filesTabDismissed = false;
+        } finally {
+            this._changingFilesInternally = false;
+            suppression.dispose();
+        }
+    }
+    async _removeFilesTab(group) {
+        const placeholder = group.editors.find(editor => editor instanceof EmptyFileEditorInput);
+        if (placeholder) {
+            this._changingFilesInternally = true;
+            try {
+                await this._closeManagedEditors(group, [placeholder]);
+            } finally {
+                this._changingFilesInternally = false;
+            }
+        }
+    }
+    async _reconcileForeignChangesEditors(group, activeChangesResource, isCancelled) {
+        const foreign = group.editors.filter(editor => {
+            const resource = this.getChangesEditorResource(editor);
+            return resource && (!activeChangesResource || !isEqual(resource, activeChangesResource));
+        });
+        if (foreign.length === 0) {
+            return;
+        }
+        if (!activeChangesResource) {
+            await this._closeManagedEditors(group, foreign);
+            return;
+        }
+        const [editorToReplace, ...editorsToClose] = foreign;
+        const wasActive = group.activeEditor === editorToReplace;
+        await group.replaceEditors([{
+            editor: editorToReplace,
+            replacement: this._instantiationService.createInstance(SessionChangesEditorInput, activeChangesResource),
+            options: wasActive ? CHANGES_TAB_ACTIVE_OPTIONS : CHANGES_TAB_OPTIONS
+        }]);
+        if (isCancelled()) {
+            return;
+        }
+        if (editorsToClose.length > 0) {
+            await this._closeManagedEditors(group, editorsToClose);
+        }
+    }
+    _updateFilesEditors(group, workspace) {
+        for (const editor of group.editors) {
+            if (editor instanceof EmptyFileEditorInput) {
+                editor.setWorkspace(workspace);
+            }
+        }
+    }
+    async _closeManagedEditors(group, editors) {
+        await this._editorService.closeEditors(editors.map(editor => ({
+            groupId: group.id,
+            editor
+        })), {
+            preserveFocus: true,
+            force: true
+        });
+    }
+    _pinFirst(group, editor) {
+        if (!group.isPinned(editor)) {
+            group.pinEditor(editor);
+        }
+        if (group.getIndexOfEditor(editor) !== 0) {
+            group.moveEditor(editor, group, CHANGES_TAB_OPTIONS);
+        }
+    }
+    _findChangesEditor(group, changesResource) {
+        return group.editors.find(editor => {
+            const resource = this.getChangesEditorResource(editor);
+            return !!resource && isEqual(resource, changesResource);
+        });
+    }
+    _isWorkspaceFileEditor(editor) {
+        if (editor instanceof DockedEditorInput) {
+            return false;
+        }
+        const resource = EditorResourceAccessor.getCanonicalUri(editor, {
+            supportSideBySide: SideBySideEditor.PRIMARY
+        });
+        return resource?.scheme === Schemas.file || resource?.scheme === Schemas.vscodeRemote;
+    }
+    _updateAddTabContexts(target) {
+        const group = this._editorGroupsService.mainPart.activeGroup;
+        const changesPresent = ( group.editors.some(editor => this.getChangesEditorResource(editor) !== undefined));
+        const filesPresent = ( group.editors.some(editor => editor instanceof EmptyFileEditorInput));
+        this._changesTabAvailableContext.set(target.wantsChangesTab);
+        this._filesTabAvailableContext.set(target.wantsFilesTab);
+        this._changesTabMissingContext.set(target.wantsChangesTab && !changesPresent);
+        this._filesTabMissingContext.set(target.wantsFilesTab && !filesPresent);
+    }
+    _queueCollapseIfDetailsOnly() {
+        if (!this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow) && this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+            this._queue(() => this._collapseNonManagedTabs());
+        }
+    }
+    async _collapseNonManagedTabs() {
+        const group = this._editorGroupsService.mainPart.activeGroup;
+        const captured = [...(this._collapsedEditors ?? [])];
+        const toClose = [];
+        group.editors.forEach((editor, index) => {
+            if (editor instanceof DockedEditorInput || this.getChangesEditorResource(editor)) {
+                return;
+            }
+            const untyped = editor.toUntyped();
+            if (untyped) {
+                captured.push({
+                    editor: untyped,
+                    index
+                });
+            }
+            toClose.push(editor);
+        });
+        if (toClose.length === 0) {
+            return;
+        }
+        this._collapsedEditors = captured;
+        const suppressEditorPartAutoVisibility = this._layoutService.suppressEditorPartAutoVisibility();
+        try {
+            await this._editorService.closeEditors(toClose.map(editor => ({
+                groupId: group.id,
+                editor
+            })), {
+                preserveFocus: true
+            });
+        } finally {
+            suppressEditorPartAutoVisibility.dispose();
+        }
+    }
+    async _restoreCollapsedTabs() {
+        const captured = this._collapsedEditors;
+        this._collapsedEditors = undefined;
+        if (!captured || captured.length === 0) {
+            return;
+        }
+        const group = this._editorGroupsService.mainPart.activeGroup;
+        const suppressEditorPartAutoVisibility = this._layoutService.suppressEditorPartAutoVisibility();
+        try {
+            await this._editorService.openEditors([...captured].sort((a, b) => a.index - b.index).map((
+                {
+                    editor,
+                    index
+                }
+            ) => ({
+                ...editor,
+                options: {
+                    ...editor.options,
+                    index,
+                    inactive: true,
+                    preserveFocus: true,
+                    pinned: true
+                }
+            })), group);
+        } finally {
+            suppressEditorPartAutoVisibility.dispose();
+        }
+    }
+};
+SinglePaneDockedTabsCoordinator = ( __decorate([( __param(1, IAgentWorkbenchLayoutService)), ( __param(2, ISessionsService)), ( __param(3, IEditorService)), ( __param(4, IEditorGroupsService)), ( __param(5, ISessionChangesService)), ( __param(6, IChangesViewService)), ( __param(7, IContextKeyService)), ( __param(8, IInstantiationService))], SinglePaneDockedTabsCoordinator));
+
+export { SinglePaneDockedTabsCoordinator };

package/vscode/src/vs/sessions/contrib/layout/browser/singlePane/singlePaneDraftSessionStrategy.d.ts

@@ -0,0 +1,44 @@
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IAgentWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+import { ISessionChangesService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService";
+import { SinglePaneDetailPanelCoordinator } from "./singlePaneDetailPanelCoordinator.js";
+import { ISinglePaneLayoutContext, SinglePaneLayoutStrategy } from "./singlePaneLayoutStrategy.js";
+import { SinglePaneVisibilityProfileStore } from "./singlePaneVisibilityProfileStore.js";
+/**
+ * Owns workspace-backed and workspace-less draft layout behavior.
+ */
+export declare class SinglePaneDraftSessionStrategy extends SinglePaneLayoutStrategy {
+    private readonly _detailPanel;
+    private readonly _visibilityStore;
+    private readonly _layoutService;
+    private readonly _sessionsService;
+    private readonly _editorService;
+    private readonly _editorGroupsService;
+    private readonly _sessionChangesService;
+    private readonly _logService;
+    private _pendingEntryHideSessionKey;
+    private _replacementDraftKey;
+    private _pendingSidePaneOpenHideSessionKey;
+    private _detailHiddenTransiently;
+    private _detailHiddenByEditor;
+    private _activeQuickChatKey;
+    private _pendingEditorRestoreKey;
+    private _changingVisibility;
+    constructor(ctx: ISinglePaneLayoutContext, _detailPanel: SinglePaneDetailPanelCoordinator, _visibilityStore: SinglePaneVisibilityProfileStore, _layoutService: IAgentWorkbenchLayoutService, _sessionsService: ISessionsService, _editorService: IEditorService, _editorGroupsService: IEditorGroupsService, _sessionChangesService: ISessionChangesService, _logService: ILogService);
+    private _registerEntryEditorHide;
+    private _registerQuickChatVisibility;
+    private _captureQuickChatSharedVisibility;
+    private _hideQuickChatSidePaneTransiently;
+    private _applyQuickChatSharedVisibility;
+    private _registerSidePaneOpenEditorHide;
+    private _registerLastEditorClose;
+    private _getMainPartEditors;
+    private _getActiveNewSessionKey;
+    private _readActiveNewSessionKey;
+    private _registerDetailPanel;
+    private _syncDetailVisibility;
+    private _computeTarget;
+}