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

package/vscode/src/vs/sessions/contrib/layout/browser/baseSessionLayoutController.js

@@ -0,0 +1,587 @@
+
+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 { alert } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { Sequencer, isThenable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
+import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+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 { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IsAuxiliaryWindowContext, AuxiliaryBarVisibleContext, MainEditorAreaVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
+import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
+import { TERMINAL_VIEW_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal';
+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 { IPaneCompositePartService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/panecomposite/browser/panecomposite.service';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { SessionsWelcomeVisibleContext, IsQuickChatSessionContext, SinglePaneLayoutEnabledContext, CustomViewVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { logSidePanelToggle } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionsTelemetry';
+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 { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { derivedOpts, derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+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 { derivedObservableWithCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
+import { ISessionChangesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/sessionChangesService.service';
+
+const secondarySidebarToggleClosedIcon = registerIcon(
+    "agent-secondary-sidebar-toggle-closed",
+    Codicon.layoutSidebarRightOff,
+    ( localize(4086, "Icon for the sessions secondary sidebar when closed."))
+);
+const secondarySidebarToggleOpenIcon = registerIcon(
+    "agent-secondary-sidebar-toggle-open",
+    Codicon.layoutSidebarRight,
+    ( localize(4087, "Icon for the sessions secondary sidebar when open."))
+);
+const SESSION_LAYOUT_STATE_KEY = "sessions.layoutState";
+const WORKING_SETS_STORAGE_KEY = "sessions.workingSets";
+let BaseLayoutController = class BaseLayoutController extends Disposable {
+    get _isRestoringSessionLayout() {
+        return this._restoringSessionLayoutDepth > 0;
+    }
+    get _layoutStateStorageKey() {
+        return SESSION_LAYOUT_STATE_KEY;
+    }
+    get _legacyWorkingSetsStorageKey() {
+        return WORKING_SETS_STORAGE_KEY;
+    }
+    get _isEditorPartVisibilityPerSession() {
+        return true;
+    }
+    get _isViewStatePerSession() {
+        return true;
+    }
+    get _isPanelVisibilityPerSession() {
+        return true;
+    }
+    constructor(
+        _layoutService,
+        _sessionManagementService,
+        _sessionsService,
+        _viewsService,
+        _paneCompositePartService,
+        _storageService,
+        _configurationService,
+        _editorService,
+        _editorGroupsService,
+        _workspaceContextService,
+        _sessionChangesService,
+        _changesViewService,
+        _viewDescriptorService,
+        _contextKeyService,
+        _instantiationService,
+        _lifecycleService
+    ) {
+        super();
+        this._layoutService = _layoutService;
+        this._sessionManagementService = _sessionManagementService;
+        this._sessionsService = _sessionsService;
+        this._viewsService = _viewsService;
+        this._paneCompositePartService = _paneCompositePartService;
+        this._storageService = _storageService;
+        this._configurationService = _configurationService;
+        this._editorService = _editorService;
+        this._editorGroupsService = _editorGroupsService;
+        this._workspaceContextService = _workspaceContextService;
+        this._sessionChangesService = _sessionChangesService;
+        this._changesViewService = _changesViewService;
+        this._viewDescriptorService = _viewDescriptorService;
+        this._contextKeyService = _contextKeyService;
+        this._instantiationService = _instantiationService;
+        this._lifecycleService = _lifecycleService;
+        this._panelVisibilityBySession = ( new ResourceMap());
+        this._panelViewBySession = ( new ResourceMap());
+        this._viewStateBySession = ( new ResourceMap());
+        this._workingSets = ( new ResourceMap());
+        this._editorPartHiddenBySession = ( new ResourceMap());
+        this._workingSetSequencer = ( new Sequencer());
+        this._restoringSessionLayoutDepth = 0;
+        this._onDidEndSessionLayoutRestore = this._register(( new Emitter()));
+        this.onDidEndSessionLayoutRestore = this._onDidEndSessionLayoutRestore.event;
+        this._togglingSidePane = false;
+        this._loadState();
+        this._register(this._storageService.onWillSaveState(() => this._saveState()));
+        this.activeSessionResourceObs = derivedOpts({
+            equalsFn: isEqual
+        }, reader => {
+            const activeSession = this._sessionsService.activeSession.read(reader);
+            return activeSession?.resource;
+        });
+        this.multipleSessionsVisibleObs = derived(reader => {
+            return this._sessionsService.visibleSessions.read(reader).length > 1;
+        });
+        this._register(autorun(reader => {
+            const visibleSessions = this._sessionsService.visibleSessions.read(reader);
+            if (visibleSessions.length <= 1) {
+                return;
+            }
+            for (const session of visibleSessions) {
+                if (!session) {
+                    continue;
+                }
+                if (this._isViewStatePerSession) {
+                    this._viewStateBySession.delete(session.resource);
+                }
+                if (this._isPanelVisibilityPerSession) {
+                    this._panelVisibilityBySession.delete(session.resource);
+                }
+            }
+        }));
+        this._register(autorun(reader => {
+            if (!this._isPanelVisibilityPerSession) {
+                return;
+            }
+            const activeSessionResource = this.activeSessionResourceObs.read(reader);
+            if (this.multipleSessionsVisibleObs.read(reader)) {
+                return;
+            }
+            this._syncPanelVisibility(activeSessionResource);
+        }));
+        this._register(this._layoutService.onDidChangePartVisibility(e => {
+            if (!this._isPanelVisibilityPerSession || e.partId !== Parts.PANEL_PART) {
+                return;
+            }
+            if (this.multipleSessionsVisibleObs.get() || this._isCustomViewVisible()) {
+                return;
+            }
+            const activeSession = this._sessionsService.activeSession.get();
+            if (activeSession) {
+                this._panelVisibilityBySession.set(activeSession.resource, e.visible);
+            }
+        }));
+        this._register(this._paneCompositePartService.onDidPaneCompositeOpen(e => {
+            if (this._isPanelVisibilityPerSession || e.viewContainerLocation !== ViewContainerLocation.Panel) {
+                return;
+            }
+            if (this.multipleSessionsVisibleObs.get() || this._isCustomViewVisible()) {
+                return;
+            }
+            const activeSession = this._sessionsService.activeSession.get();
+            if (activeSession) {
+                this._panelViewBySession.set(activeSession.resource, e.composite.getId());
+            }
+        }));
+        this._register(autorun(reader => {
+            if (this._isPanelVisibilityPerSession) {
+                return;
+            }
+            const activeSessionResource = this.activeSessionResourceObs.read(reader);
+            if (this.multipleSessionsVisibleObs.read(reader)) {
+                return;
+            }
+            this._syncPanelView(activeSessionResource);
+        }));
+        this._register(this._layoutService.onDidChangePartVisibility(e => {
+            if (this._isPanelVisibilityPerSession || e.partId !== Parts.PANEL_PART || !e.visible) {
+                return;
+            }
+            if (this.multipleSessionsVisibleObs.get() || this._isCustomViewVisible()) {
+                return;
+            }
+            this._syncPanelView(this._sessionsService.activeSession.get()?.resource);
+        }));
+        this._register(this._layoutService.onDidChangePartVisibility(e => {
+            if (!this._isEditorPartVisibilityPerSession || e.partId !== Parts.EDITOR_PART || this._isRestoringSessionLayout) {
+                return;
+            }
+            if (this.multipleSessionsVisibleObs.get() || this._isCustomViewVisible()) {
+                return;
+            }
+            const activeSession = this._sessionsService.activeSession.get();
+            if (activeSession) {
+                this._editorPartHiddenBySession.set(activeSession.resource, !e.visible);
+            }
+        }));
+        this._useModalConfigObs = observableConfigValue("workbench.editor.useModal", "all", this._configurationService);
+        const workspaceFoldersObs = observableFromEvent(
+            this._workspaceContextService.onDidChangeWorkspaceFolders,
+            () => this._workspaceContextService.getWorkspace().folders
+        );
+        const activeSessionForWorkingSet = derivedObservableWithCache(this, (reader, lastValue) => {
+            const workspaceFolders = workspaceFoldersObs.read(reader);
+            const activeSession = this._sessionsService.activeSession.read(reader);
+            const activeSessionWorkspaceUri = activeSession?.workspace.read(reader)?.folders[0]?.workingDirectory;
+            if (activeSessionWorkspaceUri && !( workspaceFolders.some(folder => isEqual(folder.uri, activeSessionWorkspaceUri)))) {
+                return lastValue;
+            }
+            if (isEqual(activeSession?.resource, lastValue?.resource)) {
+                return lastValue;
+            }
+            return activeSession;
+        });
+        this._register(
+            runOnChange(this._sessionsService.activeSession, (session, previousSession) => {
+                if (previousSession && !isEqual(previousSession.resource, session?.resource) && previousSession.status.read(undefined) !== SessionStatus.Untitled && !this._isRestoringSessionLayout) {
+                    this._saveWorkingSet(previousSession.resource);
+                }
+            })
+        );
+        this._register(runOnChange(activeSessionForWorkingSet, (session, previousSession) => {
+            if (previousSession || (session && ( this._workingSets.has(session.resource)))) {
+                this._withSessionLayoutRestore(() => this._applyWorkingSet(session?.resource, {
+                    isInitialRestore: !previousSession
+                }));
+            }
+        }));
+        this._register(this._sessionManagementService.onDidChangeSessions(e => {
+            const archivedSessions = e.changed.filter(session => session.isArchived.read(undefined));
+            for (const session of [...e.removed, ...archivedSessions]) {
+                this._deleteWorkingSet(session.resource);
+                this._viewStateBySession.delete(session.resource);
+                this._editorPartHiddenBySession.delete(session.resource);
+                this._panelViewBySession.delete(session.resource);
+            }
+        }));
+        this._register(this._sessionManagementService.onDidReplaceSession((
+            {
+                from,
+                to
+            }
+        ) => this._onSessionReplaced(from, to)));
+        this._register(this._layoutService.onWillToggleSidePane(() => {
+            this._togglingSidePane = true;
+        }));
+        this._register(this._layoutService.onDidToggleSidePane((
+            {
+                before,
+                after
+            }
+        ) => {
+            try {
+                const wasVisible = before.editor || before.auxiliaryBar;
+                const visible = after.editor || after.auxiliaryBar;
+                this._onSidePaneToggled(wasVisible && !visible, before.auxiliaryBar, after.auxiliaryBar);
+            } finally {
+                this._togglingSidePane = false;
+            }
+        }));
+        this._register(this._registerSidePaneToggleAction());
+        this._registerViewStateManagement();
+        this._registerAuxiliaryControllers();
+    }
+    _registerAuxiliaryControllers() {}
+    _isCustomViewVisible() {
+        return this._layoutService.isVisible(Parts.CUSTOM_VIEW_GRID_PART);
+    }
+    _registerSidePaneToggleAction() {
+        return registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: "workbench.action.agentToggleSidePanel",
+                    title: ( localize2(4088, "Toggle Side Panel")),
+                    icon: secondarySidebarToggleClosedIcon,
+                    toggled: {
+                        condition: ( ContextKeyExpr.or(AuxiliaryBarVisibleContext, MainEditorAreaVisibleContext)),
+                        icon: secondarySidebarToggleOpenIcon
+                    },
+                    metadata: {
+                        description: ( localize(
+                            4089,
+                            "Open/Show and Close/Hide the Side Panel (editor area and auxiliary bar)"
+                        ))
+                    },
+                    category: Categories.View,
+                    f1: true,
+                    precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(( IsQuickChatSessionContext.negate()), SinglePaneLayoutEnabledContext)), ( CustomViewVisibleContext.negate()))),
+                    keybinding: {
+                        weight: KeybindingWeight.SessionsContrib,
+                        primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyB
+                    },
+                    menu: [{
+                        id: Menus.TitleBarSessionMenu,
+                        group: "navigation",
+                        order: 11,
+                        when: ( ContextKeyExpr.and(( IsAuxiliaryWindowContext.toNegated()), ( SessionsWelcomeVisibleContext.toNegated())))
+                    }]
+                });
+            }
+            run(accessor) {
+                const nowVisible = accessor.get(IAgentWorkbenchLayoutService).toggleSidePane();
+                logSidePanelToggle(accessor.get(ITelemetryService), nowVisible);
+                alert(nowVisible ? ( localize(4090, "Side Panel shown")) : ( localize(4091, "Side Panel hidden")));
+            }
+        });
+    }
+    _registerViewStateManagement() {}
+    _onSessionReplaced(from, to) {
+        const activeSession = this._sessionsService.activeSession.get();
+        const replacedSessionIsActive = isEqual(activeSession?.resource, from.resource) || isEqual(activeSession?.resource, to.resource);
+        if (this._isEditorPartVisibilityPerSession) {
+            const editorPartHidden = this._editorPartHiddenBySession.get(from.resource) ?? (replacedSessionIsActive ? !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow) : undefined);
+            if (editorPartHidden !== undefined) {
+                this._editorPartHiddenBySession.set(to.resource, editorPartHidden);
+            }
+        }
+        if (!this._isPanelVisibilityPerSession) {
+            const panelView = this._panelViewBySession.get(from.resource);
+            if (panelView !== undefined) {
+                this._panelViewBySession.set(to.resource, panelView);
+            }
+            if (replacedSessionIsActive) {
+                this._syncPanelView(to.resource);
+            }
+        }
+    }
+    _hasActiveAuxViewContainers() {
+        return ( this._viewDescriptorService.getViewContainersByLocation(ViewContainerLocation.AuxiliaryBar).some(container => this._viewsService.isViewContainerActive(container.id)));
+    }
+    _onSidePaneToggled(_collapsed, _previousAuxiliaryBarVisible, _auxiliaryBarVisible) {}
+    _captureActiveSessionViewState(_sessionResource) {}
+    _withSessionLayoutRestore(work) {
+        this._restoringSessionLayoutDepth++;
+        const suppression = this._suppressEditorVisibilityDuringRestore();
+        let settledSync = true;
+        try {
+            const result = work();
+            if (isThenable(result)) {
+                settledSync = false;
+                Promise.resolve(result).catch(() => undefined).finally(() => {
+                    this._endSessionLayoutRestore(suppression);
+                });
+            }
+        } finally {
+            if (settledSync) {
+                this._endSessionLayoutRestore(suppression);
+            }
+        }
+    }
+    _endSessionLayoutRestore(suppression) {
+        this._restoringSessionLayoutDepth--;
+        suppression?.dispose();
+        if (this._restoringSessionLayoutDepth === 0) {
+            this._onDidEndSessionLayoutRestore.fire();
+        }
+    }
+    _suppressEditorVisibilityDuringRestore() {
+        return undefined;
+    }
+    _shouldRevealEditorPartOnApply(editorPartHidden, isModal) {
+        return !editorPartHidden && !isModal;
+    }
+    _shouldRevealEditorPartForEmptyWorkingSet(_revealEditorPart) {
+        return false;
+    }
+    _shouldHideEditorPartOnApply(_editorPartHidden) {
+        return false;
+    }
+    _onWillApplyWorkingSet(_workingSet) {}
+    _revealEditorPartForWorkingSet() {
+        this._layoutService.setPartHidden(false, Parts.EDITOR_PART);
+    }
+    _hideEditorPartForWorkingSet() {
+        this._layoutService.setPartHidden(true, Parts.EDITOR_PART);
+    }
+    _loadState() {
+        const raw = this._storageService.get(this._layoutStateStorageKey, StorageScope.WORKSPACE);
+        if (raw) {
+            try {
+                for (const entry of JSON.parse(raw)) {
+                    const resource = ( URI.parse(entry.sessionResource));
+                    if (entry.editorWorkingSet) {
+                        this._workingSets.set(resource, entry.editorWorkingSet);
+                    }
+                    if (this._isEditorPartVisibilityPerSession && entry.editorPartHidden !== undefined) {
+                        this._editorPartHiddenBySession.set(resource, entry.editorPartHidden);
+                    }
+                    if (this._isViewStatePerSession && entry.viewState) {
+                        this._viewStateBySession.set(resource, entry.viewState);
+                    }
+                    if (!this._isPanelVisibilityPerSession && entry.panelViewContainerId) {
+                        this._panelViewBySession.set(resource, entry.panelViewContainerId);
+                    }
+                }
+                return;
+            } catch {
+                this._storageService.remove(this._layoutStateStorageKey, StorageScope.WORKSPACE);
+            }
+        }
+        const legacyKey = this._legacyWorkingSetsStorageKey;
+        if (!legacyKey) {
+            return;
+        }
+        const legacyRaw = this._storageService.get(legacyKey, StorageScope.WORKSPACE);
+        if (legacyRaw) {
+            try {
+                for (const entry of JSON.parse(legacyRaw)) {
+                    const resource = ( URI.parse(entry.sessionResource));
+                    if (entry.editorWorkingSet) {
+                        this._workingSets.set(resource, entry.editorWorkingSet);
+                    }
+                    if (entry.auxiliaryBarState) {
+                        this._viewStateBySession.set(resource, {
+                            auxiliaryBarVisible: entry.auxiliaryBarState.visible,
+                            auxiliaryBarActiveViewContainerId: entry.auxiliaryBarState.activeViewContainerId
+                        });
+                    }
+                }
+            } catch {}
+            this._storageService.remove(legacyKey, StorageScope.WORKSPACE);
+        }
+    }
+    _saveState() {
+        const activeSession = this._sessionsService.activeSession.get();
+        const multipleVisible = this._sessionsService.visibleSessions.get().length > 1;
+        if (activeSession && !multipleVisible && activeSession.status.read(undefined) !== SessionStatus.Untitled) {
+            this._captureActiveSessionViewState(activeSession.resource);
+        }
+        if (activeSession && activeSession.status.read(undefined) !== SessionStatus.Untitled) {
+            this._saveWorkingSet(activeSession.resource);
+        }
+        const allResources = ( new ResourceMap());
+        this._workingSets.forEach((_, r) => allResources.set(r, true));
+        if (this._isViewStatePerSession) {
+            this._viewStateBySession.forEach((_, r) => allResources.set(r, true));
+        }
+        if (this._isEditorPartVisibilityPerSession) {
+            this._editorPartHiddenBySession.forEach((_, r) => allResources.set(r, true));
+        }
+        if (!this._isPanelVisibilityPerSession) {
+            this._panelViewBySession.forEach((_, r) => allResources.set(r, true));
+        }
+        if (allResources.size === 0) {
+            this._storageService.remove(this._layoutStateStorageKey, StorageScope.WORKSPACE);
+            return;
+        }
+        const entries = [];
+        allResources.forEach((_, resource) => {
+            entries.push({
+                sessionResource: ( resource.toString()),
+                editorWorkingSet: this._workingSets.get(resource),
+                viewState: this._isViewStatePerSession ? this._viewStateBySession.get(resource) : undefined,
+                editorPartHidden: this._isEditorPartVisibilityPerSession ? this._editorPartHiddenBySession.get(resource) : undefined,
+                panelViewContainerId: !this._isPanelVisibilityPerSession ? this._panelViewBySession.get(resource) : undefined
+            });
+        });
+        this._storageService.store(
+            this._layoutStateStorageKey,
+            JSON.stringify(entries),
+            StorageScope.WORKSPACE,
+            StorageTarget.MACHINE
+        );
+    }
+    _syncPanelVisibility(sessionResource) {
+        if (!sessionResource) {
+            this._layoutService.setPartHidden(true, Parts.PANEL_PART);
+            return;
+        }
+        const wasVisible = this._panelVisibilityBySession.get(sessionResource);
+        this._layoutService.setPartHidden(wasVisible !== true, Parts.PANEL_PART);
+    }
+    _syncPanelView(sessionResource) {
+        if (!sessionResource || !this._layoutService.isVisible(Parts.PANEL_PART)) {
+            return;
+        }
+        const viewContainerId = this._panelViewBySession.get(sessionResource) ?? TERMINAL_VIEW_ID;
+        if (this._paneCompositePartService.getActivePaneComposite(ViewContainerLocation.Panel)?.getId() === viewContainerId) {
+            return;
+        }
+        this._paneCompositePartService.openPaneComposite(viewContainerId, ViewContainerLocation.Panel);
+    }
+    async _applyWorkingSet(sessionResource, options) {
+        const preserveFocus = true;
+        const workingSet = sessionResource ? (this._workingSets.get(sessionResource) ?? "empty") : "empty";
+        this._onWillApplyWorkingSet(workingSet);
+        return this._workingSetSequencer.queue(async () => {
+            if (this._sessionsService.visibleSessions.get().length > 1) {
+                const suppression = this._layoutService.suppressEditorPartAutoVisibility();
+                try {
+                    await this._editorGroupsService.applyWorkingSet(workingSet, {
+                        preserveFocus
+                    });
+                } finally {
+                    suppression.dispose();
+                }
+                return;
+            }
+            const isModal = this._useModalConfigObs.get() === "all";
+            const editorPartHidden = this._isEditorPartVisibilityPerSession && sessionResource ? this._editorPartHiddenBySession.get(sessionResource) === true : false;
+            const revealEditorPart = !options?.isInitialRestore && this._shouldRevealEditorPartOnApply(editorPartHidden, isModal);
+            const hideEditorPart = !options?.isInitialRestore && !revealEditorPart && this._shouldHideEditorPartOnApply(editorPartHidden);
+            if (workingSet === "empty") {
+                await this._editorGroupsService.applyWorkingSet(workingSet, {
+                    preserveFocus
+                });
+                if (this._shouldRevealEditorPartForEmptyWorkingSet(revealEditorPart) && !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                    this._revealEditorPartForWorkingSet();
+                } else if (hideEditorPart && this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                    this._hideEditorPartForWorkingSet();
+                }
+                return;
+            }
+            if (options?.isInitialRestore) {
+                const suppression = this._layoutService.suppressEditorPartAutoVisibility();
+                try {
+                    await this._editorGroupsService.applyWorkingSet(workingSet, {
+                        preserveFocus
+                    });
+                } finally {
+                    suppression.dispose();
+                }
+                if (this._shouldHideEditorPartOnApply(editorPartHidden) && this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                    this._hideEditorPartForWorkingSet();
+                }
+                return;
+            }
+            if (revealEditorPart && !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                this._revealEditorPartForWorkingSet();
+            } else if (hideEditorPart && this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                this._hideEditorPartForWorkingSet();
+            }
+            const result = await this._editorGroupsService.applyWorkingSet(workingSet, {
+                preserveFocus
+            });
+            if (revealEditorPart && result && !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                this._revealEditorPartForWorkingSet();
+            } else if (hideEditorPart && this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                this._hideEditorPartForWorkingSet();
+            }
+        });
+    }
+    _saveWorkingSet(sessionResource) {
+        this._deleteWorkingSet(sessionResource);
+        if (this._editorService.visibleEditors.length > 0) {
+            const workingSetName = `session-working-set:${( sessionResource.toString())}`;
+            const workingSet = this._editorGroupsService.saveWorkingSet(workingSetName);
+            this._workingSets.set(sessionResource, workingSet);
+        }
+    }
+    _deleteWorkingSet(sessionResource) {
+        const existingWorkingSet = this._workingSets.get(sessionResource);
+        if (!existingWorkingSet) {
+            return;
+        }
+        this._editorGroupsService.deleteWorkingSet(existingWorkingSet);
+        this._workingSets.delete(sessionResource);
+    }
+};
+BaseLayoutController = ( __decorate([( __param(0, IAgentWorkbenchLayoutService)), ( __param(1, ISessionsManagementService)), ( __param(2, ISessionsService)), ( __param(3, IViewsService)), ( __param(4, IPaneCompositePartService)), ( __param(5, IStorageService)), ( __param(6, IConfigurationService)), ( __param(7, IEditorService)), ( __param(8, IEditorGroupsService)), ( __param(9, IWorkspaceContextService)), ( __param(10, ISessionChangesService)), ( __param(11, IChangesViewService)), ( __param(12, IViewDescriptorService)), ( __param(13, IContextKeyService)), ( __param(14, IInstantiationService)), ( __param(15, ILifecycleService))], BaseLayoutController));
+
+export { BaseLayoutController };