@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/contrib/layout/browser/{singlePane/singlePaneDraftSessionStrategy.js → desktop/desktopDraftSessionStrategy.js}

@@ -11,16 +11,16 @@ import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscod
 import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
 import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService';
 import { EmptyFileEditorInput } from '../../../editor/browser/emptyFileEditorInput.js';
-import { DetailPanelTarget } from './singlePaneDetailPanelCoordinator.js';
-import { isChangesEditorInput, isMainPartEmpty, isEditorWithoutDockedDetails, isFileEditorInput } from './singlePaneSharedHelpers.js';
-import { SinglePaneLayoutStrategy } from './singlePaneLayoutStrategy.js';
-import { SessionVisibilityProfile } from './singlePaneVisibilityProfileStore.js';
+import { DetailPanelTarget } from './desktopDetailPanelCoordinator.js';
+import { isChangesEditorInput, isMainPartEmpty, isEditorWithoutDockedDetails, getFilesDetailsState, FilesDetailsState } from './desktopSharedHelpers.js';
+import { DesktopLayoutStrategy } from './desktopLayoutStrategy.js';
+import { SessionVisibilityProfile } from './desktopVisibilityProfileStore.js';
 import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
 import { ISessionChangesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/sessionChangesService.service';
 
-let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extends SinglePaneLayoutStrategy {
+let DesktopDraftSessionStrategy = class DesktopDraftSessionStrategy extends DesktopLayoutStrategy {
     constructor(
         ctx,
         _detailPanel,
@@ -49,6 +49,57 @@ let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extend
         this._registerSidePaneOpenEditorHide();
         this._registerLastEditorClose();
         this._registerDetailPanel();
+        this._registerOwnerComposition();
+    }
+    _activeOwnerKey() {
+        if (!this._ctx.chatLayoutActive()) {
+            return undefined;
+        }
+        const activeSession = this._sessionsService.activeSession.get();
+        return activeSession && !activeSession.isCreated.get() && !activeSession.isQuickChat?.get() ? this._ctx.ownerKeyFor(activeSession) : undefined;
+    }
+    _readOwnerComposition() {
+        const ownerKey = this._activeOwnerKey();
+        return ownerKey ? this._ctx.compositionStore.get(ownerKey) : undefined;
+    }
+    _applyOwnerComposition(state) {
+        const suppression = this._layoutService.suppressEditorPartAutoVisibility();
+        this._changingVisibility = true;
+        try {
+            if (state.auxiliaryBar !== this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+                this._layoutService.setPartHidden(!state.auxiliaryBar, Parts.AUXILIARYBAR_PART);
+            }
+            if (state.editor !== this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                this._layoutService.setPartHidden(!state.editor, Parts.EDITOR_PART);
+            }
+        } finally {
+            this._changingVisibility = false;
+            suppression.dispose();
+        }
+    }
+    _captureOwnerCompositionIfApplicable() {
+        if (this._changingVisibility || this._ctx.isRestoringSessionLayout || this._ctx.chatLayoutSuspended() || this._layoutService.isEditorMaximized()) {
+            return;
+        }
+        const ownerKey = this._activeOwnerKey();
+        if (!ownerKey) {
+            return;
+        }
+        this._ctx.compositionStore.set(ownerKey, {
+            editor: this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow),
+            auxiliaryBar: this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)
+        });
+    }
+    _registerOwnerComposition() {
+        this._register(this._layoutService.onDidChangePartVisibility(event => {
+            if ((event.partId !== Parts.EDITOR_PART && event.partId !== Parts.AUXILIARYBAR_PART) || event.source === "resize") {
+                return;
+            }
+            this._captureOwnerCompositionIfApplicable();
+        }));
+        this._register(
+            this._layoutService.onDidToggleSidePane(() => this._captureOwnerCompositionIfApplicable())
+        );
     }
     _registerEntryEditorHide() {
         const editorSetChanged = observableSignalFromEvent(this, Event.any(
@@ -79,6 +130,12 @@ let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extend
                 this._pendingEntryHideSessionKey = undefined;
                 return;
             }
+            const storedComposition = this._readOwnerComposition();
+            if (storedComposition) {
+                this._pendingEntryHideSessionKey = undefined;
+                this._applyOwnerComposition(storedComposition);
+                return;
+            }
             const editors = this._getMainPartEditors();
             if (editors.length === 0) {
                 return;
@@ -115,7 +172,7 @@ let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extend
                 previousDraftKey = draftKey;
                 if (this._replacementDraftKey) {
                     this._logService.trace(
-                        `[SinglePaneLayout] Preserving draft composition: session=${this._replacementDraftKey} editor=${this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)} details=${this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)}`
+                        `[DesktopLayout] Preserving draft composition: session=${this._replacementDraftKey} editor=${this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)} details=${this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)}`
                     );
                 }
             }
@@ -143,12 +200,19 @@ let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extend
             }
             const sessionKey = ( activeSession.resource.toString());
             const multipleSessionsVisible = this._ctx.multipleSessionsVisibleObs.read(reader);
+            if (multipleSessionsVisible) {
+                this._pendingEditorRestoreKey = undefined;
+            }
             if (this._activeQuickChatKey !== sessionKey) {
                 this._activeQuickChatKey = sessionKey;
                 const hasSavedWorkingSet = this._ctx.hasSavedWorkingSet(activeSession.resource);
-                this._pendingEditorRestoreKey = !multipleSessionsVisible && hasSavedWorkingSet ? sessionKey : undefined;
+                const isRestoringSessionLayout = this._ctx.isRestoringSessionLayout;
+                this._pendingEditorRestoreKey = !multipleSessionsVisible ? sessionKey : undefined;
                 if (!multipleSessionsVisible && hasSavedWorkingSet) {
                     this._applyQuickChatSharedVisibility();
+                } else if (!multipleSessionsVisible && !isRestoringSessionLayout && isMainPartEmpty(this._editorGroupsService)) {
+                    this._pendingEditorRestoreKey = undefined;
+                    this._hideQuickChatSidePaneTransiently();
                 }
                 this._detailPanel.sync(DetailPanelTarget.Files);
             }
@@ -160,7 +224,7 @@ let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extend
                 return;
             }
             this._logService.trace(
-                `[SinglePaneLayout] No workspace layout restore settled: session=${sessionKey} width=${this._layoutService.getSize(Parts.EDITOR_PART).width} editor=${this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)} details=${this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)}`
+                `[DesktopLayout] No workspace layout restore settled: session=${sessionKey} width=${this._layoutService.getSize(Parts.EDITOR_PART).width} editor=${this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)} details=${this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)}`
             );
             if (this._pendingEditorRestoreKey !== sessionKey) {
                 return;
@@ -293,8 +357,13 @@ let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extend
         }));
     }
     _registerLastEditorClose() {
-        this._register(this._editorService.onDidCloseEditor(() => {
-            if (!this._getActiveNewSessionKey() || this._ctx.multipleSessionsVisibleObs.get() || this._ctx.isRestoringSessionLayout || this._layoutService.isEditorPartAutoVisibilitySuppressed() || !isMainPartEmpty(this._editorGroupsService)) {
+        this._register(this._editorService.onDidCloseEditor(event => {
+            if (!this._editorGroupsService.mainPart.getGroup(event.groupId)) {
+                return;
+            }
+            const session = this._sessionsService.activeSession.get();
+            const isQuickChat = session?.isQuickChat?.get() ?? false;
+            if ((!this._getActiveNewSessionKey() && !isQuickChat) || this._ctx.multipleSessionsVisibleObs.get() || this._ctx.isRestoringSessionLayout || this._layoutService.isEditorPartAutoVisibilitySuppressed() || !isMainPartEmpty(this._editorGroupsService)) {
                 return;
             }
             this._pendingEntryHideSessionKey = undefined;
@@ -310,14 +379,14 @@ let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extend
         if (!session || session.isCreated.get() || session.isQuickChat?.get() || !session.workspace.get() || this._ctx.multipleSessionsVisibleObs.get()) {
             return undefined;
         }
-        return ( session.resource.toString());
+        return this._ctx.ownerKeyFor(session)?.toString();
     }
     _readActiveNewSessionKey(reader) {
         const session = this._sessionsService.activeSession.read(reader);
         if (!session || session.isCreated.read(reader) || (session.isQuickChat?.read(reader) ?? false) || !session.workspace.read(reader) || this._ctx.multipleSessionsVisibleObs.read(reader)) {
             return undefined;
         }
-        return ( session.resource.toString());
+        return this._ctx.ownerKeyFor(session, reader)?.toString();
     }
     _registerDetailPanel() {
         const activeEditorObs = observableFromEvent(
@@ -356,12 +425,12 @@ let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extend
             }
             const activeEditor = activeEditorObs.read(reader);
             const editorPartVisible = editorPartVisibleObs.read(reader);
-            const sessionKey = ( activeSession.resource.toString());
+            const sessionKey = this._ctx.ownerKeyFor(activeSession, reader)?.toString();
             const emptyFilesShown = activeEditor instanceof EmptyFileEditorInput && editorPartVisible && this._replacementDraftKey !== sessionKey && !this._ctx.isRestoringSessionLayout && (activeEditor !== previousActiveEditor || !previousEditorPartVisible || sessionKey !== previousEditorSessionKey);
             previousActiveEditor = activeEditor;
             previousEditorPartVisible = editorPartVisible;
             previousEditorSessionKey = sessionKey;
-            const target = this._computeTarget(reader, activeEditor, editorMaximizedObs, editorPartVisible);
+            const target = this._computeTarget(reader, activeEditor, editorMaximizedObs, editorPartVisible, workspace);
             const revealOnly = this._ctx.multipleSessionsVisibleObs.read(reader);
             this._syncDetailVisibility(target, revealOnly, emptyFilesShown);
             this._detailPanel.sync(target);
@@ -384,10 +453,11 @@ let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extend
         if (this._ctx.isRestoringSessionLayout || target === DetailPanelTarget.Preserve) {
             return;
         }
-        if (target === DetailPanelTarget.Hidden || target === DetailPanelTarget.EditorHidden) {
-            if ((target === DetailPanelTarget.EditorHidden || !revealOnly) && detailVisible) {
+        if (target === DetailPanelTarget.Hidden || target === DetailPanelTarget.EditorHidden || target === DetailPanelTarget.FilesHidden) {
+            const hiddenByEditor = target === DetailPanelTarget.EditorHidden || target === DetailPanelTarget.FilesHidden;
+            if ((hiddenByEditor || !revealOnly) && detailVisible) {
                 this._detailHiddenTransiently = true;
-                this._detailHiddenByEditor = target === DetailPanelTarget.EditorHidden;
+                this._detailHiddenByEditor = hiddenByEditor;
                 this._layoutService.setAuxiliaryBarHiddenForResize(true);
             }
             return;
@@ -399,7 +469,7 @@ let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extend
         this._detailHiddenByEditor = false;
         this._layoutService.setAuxiliaryBarHiddenForResize(false);
     }
-    _computeTarget(reader, activeEditor, editorMaximizedObs, editorPartVisible) {
+    _computeTarget(reader, activeEditor, editorMaximizedObs, editorPartVisible, workspace) {
         if (activeEditor && isEditorWithoutDockedDetails(activeEditor)) {
             return editorPartVisible ? DetailPanelTarget.EditorHidden : DetailPanelTarget.Files;
         }
@@ -412,12 +482,15 @@ let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extend
         if (isChangesEditorInput(activeEditor, this._sessionChangesService)) {
             return DetailPanelTarget.ChangesForced;
         }
-        if (isFileEditorInput(activeEditor)) {
+        switch (getFilesDetailsState(activeEditor, workspace)) {
+        case FilesDetailsState.Active:
             return DetailPanelTarget.FilesForced;
+        case FilesDetailsState.Available:
+            return editorPartVisible ? DetailPanelTarget.FilesHidden : DetailPanelTarget.Files;
         }
-        return DetailPanelTarget.Preserve;
+        return editorPartVisible ? DetailPanelTarget.EditorHidden : DetailPanelTarget.Files;
     }
 };
-SinglePaneDraftSessionStrategy = ( __decorate([( __param(3, IAgentWorkbenchLayoutService)), ( __param(4, ISessionsService)), ( __param(5, IEditorService)), ( __param(6, IEditorGroupsService)), ( __param(7, ISessionChangesService)), ( __param(8, ILogService))], SinglePaneDraftSessionStrategy));
+DesktopDraftSessionStrategy = ( __decorate([( __param(3, IAgentWorkbenchLayoutService)), ( __param(4, ISessionsService)), ( __param(5, IEditorService)), ( __param(6, IEditorGroupsService)), ( __param(7, ISessionChangesService)), ( __param(8, ILogService))], DesktopDraftSessionStrategy));
 
-export { SinglePaneDraftSessionStrategy };
+export { DesktopDraftSessionStrategy };

package/vscode/src/vs/sessions/contrib/layout/browser/{singlePane/singlePaneExistingSessionStrategy.d.ts → desktop/desktopExistingSessionStrategy.d.ts}

@@ -3,11 +3,11 @@ import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench
 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 { SinglePaneDockedTabsCoordinator } from "./singlePaneDockedTabsCoordinator.js";
-import { ISinglePaneLayoutContext, SinglePaneLayoutStrategy } from "./singlePaneLayoutStrategy.js";
-import { SinglePaneVisibilityProfileStore } from "./singlePaneVisibilityProfileStore.js";
-/** Command that toggles the single-pane detail panel (auxiliary bar) from the editor header. */
+import { DesktopDetailPanelCoordinator } from "./desktopDetailPanelCoordinator.js";
+import { DesktopDockedTabsCoordinator } from "./desktopDockedTabsCoordinator.js";
+import { IDesktopLayoutContext, DesktopLayoutStrategy } from "./desktopLayoutStrategy.js";
+import { DesktopVisibilityProfileStore } from "./desktopVisibilityProfileStore.js";
+/** Command that toggles the desktop detail panel (auxiliary bar) from the editor header. */
 export declare const TOGGLE_DETAILS_COMMAND_ID = "workbench.action.agentSessions.toggleDetails";
 /**
  * Behaviour for the **Existing Session** lifecycle stage — a created, workspace-backed
@@ -19,11 +19,11 @@ export declare const TOGGLE_DETAILS_COMMAND_ID = "workbench.action.agentSessions
  *  - the detail-panel mapping while an Existing Session is active;
  *  - the Toggle Details command (kind-agnostic — it also applies while a New Session's docked
  *    tabs are visible — hosted here since Existing is the steady-state default);
- *  - owning (constructing/disposing) the shared {@link SinglePaneDockedTabsCoordinator}, whose
+ *  - owning (constructing/disposing) the shared {@link DesktopDockedTabsCoordinator}, whose
  *    managed-tabs reconcile pipeline and detail-only editor-area collapse must stay
  *    single-instance across the New→Existing submit transition — see its doc comment.
  */
-export declare class SinglePaneExistingSessionStrategy extends SinglePaneLayoutStrategy {
+export declare class DesktopExistingSessionStrategy extends DesktopLayoutStrategy {
     private readonly _visibilityStore;
     private readonly _detailPanel;
     private readonly _layoutService;
@@ -35,7 +35,7 @@ export declare class SinglePaneExistingSessionStrategy extends SinglePaneLayoutS
     private _detailHiddenTransiently;
     private _detailHiddenByEditor;
     private _changingDetailTransiently;
-    constructor(ctx: ISinglePaneLayoutContext, _visibilityStore: SinglePaneVisibilityProfileStore, _detailPanel: SinglePaneDetailPanelCoordinator, _layoutService: IAgentWorkbenchLayoutService, _sessionsService: ISessionsService, _editorService: IEditorService, _editorGroupsService: IEditorGroupsService, _sessionChangesService: ISessionChangesService);
+    constructor(ctx: IDesktopLayoutContext, _visibilityStore: DesktopVisibilityProfileStore, _detailPanel: DesktopDetailPanelCoordinator, _layoutService: IAgentWorkbenchLayoutService, _sessionsService: ISessionsService, _editorService: IEditorService, _editorGroupsService: IEditorGroupsService, _sessionChangesService: ISessionChangesService);
     /** Toggle the detail panel and return whether it is now visible. */
     toggleDetails(): boolean;
     private _registerEmptyGroupClose;
@@ -45,14 +45,16 @@ export declare class SinglePaneExistingSessionStrategy extends SinglePaneLayoutS
      * the controller (mirrors the original managed-tabs/editor-collapse strategies' timing) so
      * the reconcile pipeline only starts once the workbench's restored editor group exists.
      */
-    registerManagedTabs(managedTabs: SinglePaneDockedTabsCoordinator): void;
+    registerManagedTabs(managedTabs: DesktopDockedTabsCoordinator): void;
     private get managedTabs();
     private _registerVisibility;
+    private _capturePreHideComposition;
+    private _correctToggleReopen;
+    private _activeOwnerKey;
+    private _resolveComposition;
     private _captureExistingProfileIfApplicable;
-    /** Seeds the Existing profile from the on-screen composition for an in-place lifecycle transition. */
     private _captureExistingProfile;
     private _apply;
-    private _reveal;
     private _registerDetailPanel;
     private _syncDetailVisibility;
     private _setDetailHiddenTransiently;