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

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

@@ -1,444 +0,0 @@
-
-import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
-import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
-import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
-import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
-import { ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
-import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
-import { sessionHasChanges } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
-import { CHANGES_VIEW_ID, CHANGES_VIEW_CONTAINER_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changes';
-import { SESSIONS_FILES_CONTAINER_ID } from '../../files/browser/files.contribution.js';
-import { BaseLayoutController } from './baseSessionLayoutController.js';
-import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
-import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
-import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
-
-const NEW_SESSION_VIEW_STATE_KEY = "sessions.newSessionViewState";
-const SMALL_WINDOW_MAX_WIDTH = 1800;
-const RESPONSIVE_SIDEBAR_SETTING = "sessions.layout.autoCollapseSessionsSidebar";
-class LayoutController extends BaseLayoutController {
-    constructor() {
-        super(...arguments);
-        this._sidebarAutoHidden = false;
-        this._applyingAutoSidebar = false;
-        this._previousSpaceConstrained = false;
-        this._hidingAuxiliaryBarForRestore = false;
-    }
-    static {
-        this.ID = "workbench.contrib.sessionsLayoutController";
-    }
-    _registerViewStateManagement() {
-        this._loadNewSessionViewState();
-        const activeSessionIsCreatedObs = derived(reader => {
-            const activeSession = this._sessionsService.activeSession.read(reader);
-            return activeSession?.isCreated.read(reader) ?? false;
-        });
-        const activeSessionHasWorkspaceObs = derived(reader => {
-            const activeSession = this._sessionsService.activeSession.read(reader);
-            return activeSession?.workspace.read(reader)?.folders?.[0]?.root !== undefined;
-        });
-        const editorMaximizedObs = observableFromEvent(
-            this,
-            this._layoutService.onDidChangeEditorMaximized,
-            () => this._layoutService.isEditorMaximized()
-        );
-        let previousSessionResource;
-        let previousIsCreated = false;
-        this._register(autorun(reader => {
-            const editorMaximized = editorMaximizedObs.read(reader);
-            const activeSessionResource = this.activeSessionResourceObs.read(reader);
-            const isCreated = activeSessionIsCreatedObs.read(reader);
-            if (editorMaximized) {
-                previousSessionResource = activeSessionResource;
-                previousIsCreated = isCreated;
-                void this._viewsService.openView(CHANGES_VIEW_ID, false);
-                return;
-            }
-            const activeSessionHasWorkspace = activeSessionHasWorkspaceObs.read(reader);
-            const multipleVisible = this.multipleSessionsVisibleObs.read(reader);
-            if (multipleVisible) {
-                previousSessionResource = activeSessionResource;
-                previousIsCreated = isCreated;
-                return;
-            }
-            const isSessionSwitch = previousSessionResource !== undefined && !isEqual(previousSessionResource, activeSessionResource);
-            if (isSessionSwitch) {
-                this._captureViewState(previousSessionResource);
-            }
-            const isSubmit = previousSessionResource !== undefined && !isSessionSwitch && !previousIsCreated && isCreated && activeSessionResource !== undefined;
-            previousSessionResource = activeSessionResource;
-            previousIsCreated = isCreated;
-            if (isSubmit) {
-                this._withSessionLayoutRestore(() => this._onNewSessionSubmitted(activeSessionResource));
-                return;
-            }
-            this._withSessionLayoutRestore(
-                () => this._syncAuxiliaryBarVisibility(activeSessionResource, activeSessionHasWorkspace, isCreated)
-            );
-        }));
-        this._register(this._layoutService.onDidChangePartVisibility(e => {
-            if (e.partId !== Parts.AUXILIARYBAR_PART) {
-                return;
-            }
-            if (this._togglingSidePane) {
-                return;
-            }
-            if (this._hidingAuxiliaryBarForRestore) {
-                return;
-            }
-            if (this._isRestoringSessionLayout) {
-                return;
-            }
-            if (this.multipleSessionsVisibleObs.get()) {
-                return;
-            }
-            if (this._layoutService.isEditorMaximized()) {
-                return;
-            }
-            const activeSession = this._sessionsService.activeSession.get();
-            if (!activeSession) {
-                return;
-            }
-            if (!activeSession.isCreated.get()) {
-                this._setNewSessionViewState({
-                    auxiliaryBarVisible: e.visible
-                });
-            } else {
-                if (e.visible && this._restoreSavedAuxiliaryBarContainerOnReveal(activeSession.resource)) {
-                    return;
-                }
-                this._captureViewState(activeSession.resource);
-            }
-        }));
-        this._registerChangesAutoReveal();
-        this._registerResponsiveSidebar();
-        this._registerAuxiliaryBarPartVisibility();
-        this._registerNewSessionRules();
-    }
-    _registerChangesAutoReveal() {
-        this._register(
-            this._editorService.onDidActiveEditorChange(() => this._revealChangesViewOnFirstOpen())
-        );
-        this._register(this._layoutService.onDidChangePartVisibility(e => {
-            if (e.partId === Parts.EDITOR_PART && e.visible) {
-                this._revealChangesViewOnFirstOpen();
-            }
-        }));
-    }
-    _registerNewSessionRules() {}
-    _onSessionReplaced(from, to) {
-        super._onSessionReplaced(from, to);
-        const activeSession = this._sessionsService.activeSession.get();
-        const replacedSessionIsActive = isEqual(activeSession?.resource, from.resource) || isEqual(activeSession?.resource, to.resource);
-        const auxiliaryBarVisible = replacedSessionIsActive ? this._layoutService.isVisible(Parts.AUXILIARYBAR_PART) : this._newSessionViewState?.auxiliaryBarVisible;
-        if (auxiliaryBarVisible === undefined) {
-            return;
-        }
-        this._viewStateBySession.set(to.resource, {
-            auxiliaryBarVisible,
-            auxiliaryBarActiveViewContainerId: replacedSessionIsActive && auxiliaryBarVisible ? this._paneCompositePartService.getActivePaneComposite(ViewContainerLocation.AuxiliaryBar)?.getId() : undefined
-        });
-    }
-    _registerAuxiliaryBarPartVisibility() {
-        const modelListeners = this._register(( new DisposableStore()));
-        const rewire = () => {
-            modelListeners.clear();
-            for (const container of this._viewDescriptorService.getViewContainersByLocation(ViewContainerLocation.AuxiliaryBar)) {
-                modelListeners.add(
-                    this._viewDescriptorService.getViewContainerModel(container).onDidChangeActiveViewDescriptors(() => this._syncAuxiliaryBarPartVisibility())
-                );
-            }
-            this._syncAuxiliaryBarPartVisibility();
-        };
-        this._register(this._viewDescriptorService.onDidChangeViewContainers(rewire));
-        this._register(this._viewDescriptorService.onDidChangeContainerLocation(rewire));
-        this._register(this._viewsService.onDidChangeViewContainerVisibility(e => {
-            if (e.location === ViewContainerLocation.AuxiliaryBar) {
-                this._syncAuxiliaryBarPartVisibility();
-            }
-        }));
-        this._register(this._layoutService.onDidChangePartVisibility(e => {
-            if (e.partId === Parts.AUXILIARYBAR_PART && e.visible) {
-                this._syncAuxiliaryBarPartVisibility();
-            }
-        }));
-        rewire();
-    }
-    _syncAuxiliaryBarPartVisibility() {
-        if (this._layoutService.isSinglePaneLayoutEnabled) {
-            return;
-        }
-        if (this._hasActiveAuxViewContainers()) {
-            return;
-        }
-        const activeSession = this._sessionsService.activeSession.get();
-        if (activeSession?.isQuickChat?.get() !== true) {
-            return;
-        }
-        if (this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
-            const suppression = this._layoutService.suppressEditorPartAutoVisibility();
-            try {
-                this._hideAuxiliaryBarForRestore();
-            } finally {
-                suppression.dispose();
-            }
-        }
-    }
-    _revealChangesViewOnFirstOpen() {
-        if (this._togglingSidePane) {
-            return;
-        }
-        const activeEditorResource = this._editorService.activeEditor?.resource;
-        if (!activeEditorResource) {
-            return;
-        }
-        const changesSessionResource = this._sessionChangesService.getSessionResource(activeEditorResource);
-        if (!changesSessionResource) {
-            return;
-        }
-        if (this.multipleSessionsVisibleObs.get() || this._layoutService.isEditorMaximized()) {
-            return;
-        }
-        const activeSession = this._sessionsService.activeSession.get();
-        if (!activeSession || !isEqual(activeSession.resource, changesSessionResource)) {
-            return;
-        }
-        if (!activeSession.isCreated.get()) {
-            return;
-        }
-        if (!this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
-            return;
-        }
-        const savedState = this._viewStateBySession.get(changesSessionResource);
-        if (savedState) {
-            if (this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
-                return;
-            }
-            if (!savedState.auxiliaryBarVisible && !savedState.auxiliaryBarHiddenByCollapse) {
-                return;
-            }
-        }
-        void this._viewsService.openView(CHANGES_VIEW_ID, false);
-    }
-    _registerResponsiveSidebar() {
-        const enabledObs = observableConfigValue(
-            RESPONSIVE_SIDEBAR_SETTING,
-            product.quality !== "stable",
-            this._configurationService
-        );
-        const smallWindowObs = observableFromEvent(
-            this,
-            this._layoutService.onDidLayoutMainContainer,
-            () => this._layoutService.mainContainerDimension.width <= SMALL_WINDOW_MAX_WIDTH
-        );
-        const editorVisibleObs = observableFromEvent(
-            this,
-            this._layoutService.onDidChangePartVisibility,
-            () => this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)
-        );
-        const auxiliaryBarVisibleObs = observableFromEvent(
-            this,
-            this._layoutService.onDidChangePartVisibility,
-            () => this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)
-        );
-        const editorMaximizedObs = observableFromEvent(
-            this,
-            this._layoutService.onDidChangeEditorMaximized,
-            () => this._layoutService.isEditorMaximized()
-        );
-        const spaceConstrainedObs = derived(
-            reader => enabledObs.read(reader) && !this.multipleSessionsVisibleObs.read(reader) && smallWindowObs.read(reader) && editorVisibleObs.read(reader) && auxiliaryBarVisibleObs.read(reader)
-        );
-        this._previousSpaceConstrained = spaceConstrainedObs.get();
-        this._register(autorun(reader => {
-            if (editorMaximizedObs.read(reader)) {
-                return;
-            }
-            const constrained = spaceConstrainedObs.read(reader);
-            if (this._isRestoringSessionLayout) {
-                this._previousSpaceConstrained = constrained;
-                return;
-            }
-            if (constrained === this._previousSpaceConstrained) {
-                return;
-            }
-            this._previousSpaceConstrained = constrained;
-            if (constrained) {
-                if (this._setSidebarAutoHidden(true)) {
-                    this._sidebarAutoHidden = true;
-                }
-            } else if (this._sidebarAutoHidden) {
-                this._setSidebarAutoHidden(false);
-                this._sidebarAutoHidden = false;
-            }
-        }));
-        this._register(this._layoutService.onDidChangePartVisibility(e => {
-            if (e.partId !== Parts.SIDEBAR_PART || this._applyingAutoSidebar) {
-                return;
-            }
-            this._sidebarAutoHidden = false;
-        }));
-    }
-    _setSidebarAutoHidden(hidden) {
-        if (this._layoutService.isVisible(Parts.SIDEBAR_PART) === !hidden) {
-            return false;
-        }
-        this._applyingAutoSidebar = true;
-        try {
-            this._layoutService.setPartHidden(hidden, Parts.SIDEBAR_PART);
-        } finally {
-            this._applyingAutoSidebar = false;
-        }
-        return true;
-    }
-    _captureActiveSessionViewState(sessionResource) {
-        this._captureViewState(sessionResource);
-    }
-    _onSidePaneToggled(collapsed, previousAuxiliaryBarVisible, auxiliaryBarVisible) {
-        if (this.multipleSessionsVisibleObs.get()) {
-            return;
-        }
-        const activeSession = this._sessionsService.activeSession.get();
-        if (!activeSession) {
-            return;
-        }
-        if (!activeSession.isCreated.get()) {
-            this._setNewSessionViewState({
-                auxiliaryBarVisible
-            });
-            return;
-        }
-        if (collapsed && previousAuxiliaryBarVisible) {
-            const activeViewContainerId = this._paneCompositePartService.getActivePaneComposite(ViewContainerLocation.AuxiliaryBar)?.getId();
-            this._viewStateBySession.set(activeSession.resource, {
-                auxiliaryBarVisible: false,
-                auxiliaryBarActiveViewContainerId: activeViewContainerId,
-                auxiliaryBarHiddenByCollapse: true
-            });
-            return;
-        }
-        this._captureViewState(activeSession.resource);
-    }
-    _captureViewState(sessionResource) {
-        const auxiliaryBarVisible = this._layoutService.isVisible(Parts.AUXILIARYBAR_PART);
-        const activeViewContainerId = this._paneCompositePartService.getActivePaneComposite(ViewContainerLocation.AuxiliaryBar)?.getId();
-        const previous = this._viewStateBySession.get(sessionResource);
-        const auxiliaryBarHiddenByCollapse = !auxiliaryBarVisible && previous?.auxiliaryBarHiddenByCollapse === true;
-        this._viewStateBySession.set(sessionResource, {
-            auxiliaryBarVisible,
-            auxiliaryBarActiveViewContainerId: activeViewContainerId,
-            ...(auxiliaryBarHiddenByCollapse ? {
-                auxiliaryBarHiddenByCollapse: true
-            } : {})
-        });
-    }
-    _setNewSessionViewState(state) {
-        this._newSessionViewState = state;
-        this._storageService.store(
-            NEW_SESSION_VIEW_STATE_KEY,
-            JSON.stringify(state),
-            StorageScope.WORKSPACE,
-            StorageTarget.MACHINE
-        );
-    }
-    _onNewSessionSubmitted(sessionResource) {
-        const auxiliaryBarVisible = this._layoutService.isVisible(Parts.AUXILIARYBAR_PART);
-        this._viewStateBySession.set(sessionResource, {
-            auxiliaryBarVisible,
-            auxiliaryBarActiveViewContainerId: auxiliaryBarVisible ? this._paneCompositePartService.getActivePaneComposite(ViewContainerLocation.AuxiliaryBar)?.getId() : undefined
-        });
-    }
-    _syncAuxiliaryBarVisibility(sessionResource, hasWorkspace, isCreated) {
-        if (!sessionResource || !hasWorkspace) {
-            return;
-        }
-        if (!isCreated) {
-            if (this._newSessionViewState && !this._newSessionViewState.auxiliaryBarVisible) {
-                this._hideAuxiliaryBarForRestore();
-                return;
-            }
-            void this._openDefaultAuxiliaryBarContainer();
-            return;
-        }
-        const savedState = this._viewStateBySession.get(sessionResource);
-        if (!savedState || !savedState.auxiliaryBarVisible) {
-            this._hideAuxiliaryBarForRestore();
-            return;
-        }
-        const savedContainerId = savedState.auxiliaryBarActiveViewContainerId;
-        if (savedContainerId && this._isAuxiliaryBarContainerPinned(savedContainerId)) {
-            void this._viewsService.openViewContainer(savedContainerId, false);
-            return;
-        }
-        void this._openDefaultAuxiliaryBarContainer();
-    }
-    _defaultAuxiliaryBarContainerId() {
-        if (!this._isAuxiliaryBarContainerPinned(SESSIONS_FILES_CONTAINER_ID)) {
-            return CHANGES_VIEW_CONTAINER_ID;
-        }
-        const activeSession = this._sessionsService.activeSession.get();
-        return activeSession && sessionHasChanges(activeSession, undefined) ? CHANGES_VIEW_CONTAINER_ID : SESSIONS_FILES_CONTAINER_ID;
-    }
-    _openDefaultAuxiliaryBarContainer(containerId = this._defaultAuxiliaryBarContainerId()) {
-        if (containerId === CHANGES_VIEW_CONTAINER_ID) {
-            return this._viewsService.openView(CHANGES_VIEW_ID, false);
-        }
-        return this._viewsService.openViewContainer(containerId, false);
-    }
-    _restoreSavedAuxiliaryBarContainerOnReveal(sessionResource) {
-        const savedState = this._viewStateBySession.get(sessionResource);
-        if (!savedState || savedState.auxiliaryBarVisible) {
-            return false;
-        }
-        const savedContainerId = savedState.auxiliaryBarActiveViewContainerId;
-        if (savedContainerId && this._isAuxiliaryBarContainerPinned(savedContainerId)) {
-            this._viewStateBySession.set(sessionResource, {
-                ...savedState,
-                auxiliaryBarVisible: true
-            });
-            void this._viewsService.openViewContainer(savedContainerId, false);
-        } else {
-            const defaultContainerId = this._defaultAuxiliaryBarContainerId();
-            this._viewStateBySession.set(sessionResource, {
-                auxiliaryBarVisible: true,
-                auxiliaryBarActiveViewContainerId: defaultContainerId
-            });
-            void this._openDefaultAuxiliaryBarContainer(defaultContainerId);
-        }
-        return true;
-    }
-    _hideAuxiliaryBarForRestore() {
-        this._hidingAuxiliaryBarForRestore = true;
-        try {
-            this._layoutService.setPartHidden(true, Parts.AUXILIARYBAR_PART);
-        } finally {
-            this._hidingAuxiliaryBarForRestore = false;
-        }
-    }
-    _isAuxiliaryBarContainerPinned(containerId) {
-        return this._paneCompositePartService.getPinnedPaneCompositeIds(ViewContainerLocation.AuxiliaryBar).includes(containerId);
-    }
-    _loadNewSessionViewState() {
-        const newSessionRaw = this._storageService.get(NEW_SESSION_VIEW_STATE_KEY, StorageScope.WORKSPACE);
-        if (!newSessionRaw) {
-            return;
-        }
-        try {
-            const parsed = JSON.parse(newSessionRaw);
-            if (parsed && typeof parsed.auxiliaryBarVisible === "boolean") {
-                this._newSessionViewState = {
-                    auxiliaryBarVisible: parsed.auxiliaryBarVisible
-                };
-            } else {
-                this._storageService.remove(NEW_SESSION_VIEW_STATE_KEY, StorageScope.WORKSPACE);
-            }
-        } catch {
-            this._storageService.remove(NEW_SESSION_VIEW_STATE_KEY, StorageScope.WORKSPACE);
-        }
-    }
-}
-
-export { LayoutController, RESPONSIVE_SIDEBAR_SETTING };

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

@@ -1,43 +0,0 @@
-
-import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import { DiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/diffEditorInput';
-import { BrowserEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/browserView/common/browserEditorInput';
-import { CustomEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
-import { FileEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/editors/fileEditorInput';
-import { MultiDiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
-import { WebviewInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
-import { EmptyFileEditorInput } from '../../../editor/browser/emptyFileEditorInput.js';
-
-const MARKDOWN_EDITOR_VIEW_TYPES = ( new Set([
-    "markdown.preview",
-    "vscode.markdown.editor",
-    "vscode.markdown.preview.editor"
-]));
-const PULL_REQUEST_OVERVIEW_VIEW_TYPE = "PullRequestOverview";
-const ISSUE_OVERVIEW_VIEW_TYPE = "IssueOverview";
-function isMainPartEmpty(editorGroupsService) {
-    for (const group of editorGroupsService.mainPart.groups) {
-        if (!group.isEmpty) {
-            return false;
-        }
-    }
-    return true;
-}
-function isChangesEditorInput(editor, sessionChangesService) {
-    if (editor instanceof DiffEditorInput || editor instanceof MultiDiffEditorInput) {
-        return true;
-    }
-    const resource = editor.resource;
-    return !!resource && sessionChangesService.getSessionResource(resource) !== undefined;
-}
-function isFileEditorInput(editor) {
-    if (editor instanceof WebviewInput) {
-        return ( MARKDOWN_EDITOR_VIEW_TYPES.has(editor.viewType)) || ( MARKDOWN_EDITOR_VIEW_TYPES.has(editor.providerId ?? "")) || (editor instanceof CustomEditorInput && editor.resource?.scheme === Schemas.untitled);
-    }
-    return editor instanceof EmptyFileEditorInput || editor instanceof FileEditorInput || editor.resource?.scheme === Schemas.untitled;
-}
-function isEditorWithoutDockedDetails(editor) {
-    return editor instanceof BrowserEditorInput || (editor instanceof CustomEditorInput && editor.resource?.scheme !== Schemas.untitled) || (editor instanceof WebviewInput && (editor.viewType === PULL_REQUEST_OVERVIEW_VIEW_TYPE || editor.providerId === PULL_REQUEST_OVERVIEW_VIEW_TYPE || editor.viewType === ISSUE_OVERVIEW_VIEW_TYPE || editor.providerId === ISSUE_OVERVIEW_VIEW_TYPE));
-}
-
-export { isChangesEditorInput, isEditorWithoutDockedDetails, isFileEditorInput, isMainPartEmpty };

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

@@ -1,55 +0,0 @@
-import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IEditorWorkingSet } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
-import { BaseLayoutController } from "./baseSessionLayoutController.js";
-export { TOGGLE_DETAILS_COMMAND_ID } from "./singlePane/singlePaneExistingSessionStrategy.js";
-/**
- * Layout controller for the single-pane detail-panel layout. A sibling of the
- * classic {@link import('./desktopSessionLayoutController.js').LayoutController}
- * (both extend {@link BaseLayoutController}), it owns its behaviour through exactly
- * two composed lifecycle strategies rather than desktop inheritance:
- *  - {@link SinglePaneDraftSessionStrategy} — workspace-backed and workspace-less drafts;
- *  - {@link SinglePaneExistingSessionStrategy} — a created, workspace-backed session
- *    (also owns the Toggle Details command and the shared managed-tabs coordinator);
- *
- * Each owns the full vertical slice of behaviour for its stage: side-pane visibility, the
- * detail-panel (Changes/Files) mapping, and — for the two workspace stages — a supplementary
- * nuance on the shared managed-docked-tabs reconcile pipeline (`SinglePaneDockedTabsCoordinator`,
- * which also performs the detail-only editor-area collapse). That coordinator, the detail
- * panel's sync mechanics (`SinglePaneDetailPanelCoordinator`), and the shared New/Existing
- * Editor-visibility-profile storage (`SinglePaneVisibilityProfileStore`) are non-strategy coordinator
- * objects — see `singlePane/singlePaneLayoutStrategy.ts`'s doc comment for why.
- *
- * Strategies coordinate through this controller (the {@link ISinglePaneLayoutContext}):
- * a session-switch restore is signalled by {@link _isRestoringSessionLayout}, so
- * a restore-driven editor change is never mistaken for a user action.
- */
-export declare class SinglePaneLayoutController extends BaseLayoutController {
-    private _context;
-    private _existingSession;
-    private _managedTabs;
-    protected get _layoutStateStorageKey(): string;
-    protected get _legacyWorkingSetsStorageKey(): string | undefined;
-    private get _ctx();
-    protected _registerViewStateManagement(): void;
-    protected _registerAuxiliaryControllers(): void;
-    /** Toggle the detail panel and return whether it is now visible. */
-    toggleDetails(): boolean;
-    /**
-     * A session-switch restore closes/opens the docked editors (empty working-set
-     * apply, managed-tab reconciliation), so suppress editor-part auto-visibility
-     * for the whole restore to avoid closing the side pane or mistaking a
-     * layout-driven close for a user dismissing a managed tab.
-     */
-    protected _suppressEditorVisibilityDuringRestore(): IDisposable | undefined;
-    protected get _isEditorPartVisibilityPerSession(): boolean;
-    protected get _isViewStatePerSession(): boolean;
-    /**
-     * Governs the panel at the workbench level (like the side pane). Flipping this
-     * single gate off makes the base remember the panel's *view* per session instead
-     * (defaulting to the Terminal).
-     */
-    protected get _isPanelVisibilityPerSession(): boolean;
-    protected _shouldRevealEditorPartOnApply(_editorPartHidden: boolean, _isModal: boolean): boolean;
-    protected _shouldHideEditorPartOnApply(_editorPartHidden: boolean): boolean;
-    protected _onWillApplyWorkingSet(workingSet: IEditorWorkingSet | "empty"): void;
-}

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

@@ -1,91 +0,0 @@
-
-import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
-import { BaseLayoutController } from './baseSessionLayoutController.js';
-import { SinglePaneDetailPanelCoordinator } from './singlePane/singlePaneDetailPanelCoordinator.js';
-import { SinglePaneDockedTabsCoordinator } from './singlePane/singlePaneDockedTabsCoordinator.js';
-import { SinglePaneDraftSessionStrategy } from './singlePane/singlePaneDraftSessionStrategy.js';
-import { SinglePaneExistingSessionStrategy } from './singlePane/singlePaneExistingSessionStrategy.js';
-export { TOGGLE_DETAILS_COMMAND_ID } from './singlePane/singlePaneExistingSessionStrategy.js';
-import { SinglePaneVisibilityProfileStore } from './singlePane/singlePaneVisibilityProfileStore.js';
-
-const SINGLE_PANE_LAYOUT_STATE_KEY = "sessions.singlePane.layoutState";
-class SinglePaneLayoutController extends BaseLayoutController {
-    get _layoutStateStorageKey() {
-        return SINGLE_PANE_LAYOUT_STATE_KEY;
-    }
-    get _legacyWorkingSetsStorageKey() {
-        return undefined;
-    }
-    get _ctx() {
-        if (!this._context) {
-            const that = this;
-            this._context = {
-                get isRestoringSessionLayout() {
-                    return that._isRestoringSessionLayout;
-                },
-                withSessionLayoutRestore: work => that._withSessionLayoutRestore(work),
-                onDidEndSessionLayoutRestore: that.onDidEndSessionLayoutRestore,
-                get togglingSidePane() {
-                    return that._togglingSidePane;
-                },
-                get multipleSessionsVisibleObs() {
-                    return that.multipleSessionsVisibleObs;
-                },
-                get activeSessionResourceObs() {
-                    return that.activeSessionResourceObs;
-                },
-                hasSavedWorkingSet: sessionResource => ( that._workingSets.has(sessionResource))
-            };
-        }
-        return this._context;
-    }
-    _registerViewStateManagement() {
-        const visibilityStore = this._instantiationService.createInstance(SinglePaneVisibilityProfileStore);
-        const detailPanel = this._register(
-            this._instantiationService.createInstance(SinglePaneDetailPanelCoordinator)
-        );
-        this._existingSession = this._register(
-            this._instantiationService.createInstance(SinglePaneExistingSessionStrategy, this._ctx, visibilityStore, detailPanel)
-        );
-        this._register(
-            this._instantiationService.createInstance(SinglePaneDraftSessionStrategy, this._ctx, detailPanel, visibilityStore)
-        );
-    }
-    _registerAuxiliaryControllers() {
-        this._lifecycleService.when(LifecyclePhase.Restored).then(() => {
-            if (this._store.isDisposed) {
-                return;
-            }
-            this._managedTabs = this._register(
-                this._instantiationService.createInstance(SinglePaneDockedTabsCoordinator, this._ctx)
-            );
-            this._existingSession?.registerManagedTabs(this._managedTabs);
-        });
-    }
-    toggleDetails() {
-        return this._existingSession?.toggleDetails() ?? false;
-    }
-    _suppressEditorVisibilityDuringRestore() {
-        return this._layoutService.suppressEditorPartAutoVisibility();
-    }
-    get _isEditorPartVisibilityPerSession() {
-        return false;
-    }
-    get _isViewStatePerSession() {
-        return false;
-    }
-    get _isPanelVisibilityPerSession() {
-        return false;
-    }
-    _shouldRevealEditorPartOnApply(_editorPartHidden, _isModal) {
-        return false;
-    }
-    _shouldHideEditorPartOnApply(_editorPartHidden) {
-        return false;
-    }
-    _onWillApplyWorkingSet(workingSet) {
-        this._managedTabs?.prepareWorkingSetRestore(workingSet !== "empty");
-    }
-}
-
-export { SinglePaneLayoutController };

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostClaudePermissionModePicker.d.ts

@@ -1,26 +0,0 @@
-import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
-import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
-import { IActionListItem } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionList";
-import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
-import { ClaudeSessionConfigKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/claudeSessionConfigKeys";
-import { SessionConfigPropertySchema } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
-import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
-import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
-import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
-import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
-import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
-import { AgentHostSessionEnumPicker, IAgentHostSessionEnumPickerItem } from "./agentHostModePicker.js";
-export declare class AgentHostClaudePermissionModePicker extends AgentHostSessionEnumPicker {
-    private readonly _openerService;
-    protected readonly _property = ClaudeSessionConfigKey.PermissionMode;
-    protected readonly _pickerId = "agentHostClaudePermissionModePicker";
-    protected readonly _telemetryId = "NewChatAgentHostClaudePermissionModePicker";
-    constructor(session: IObservable<IActiveSession | undefined>, actionWidgetService: IActionWidgetService, sessionsProvidersService: ISessionsProvidersService, telemetryService: ITelemetryService, hoverService: IHoverService, _openerService: IOpenerService);
-    protected _isWellKnownSchema(schema: SessionConfigPropertySchema): boolean;
-    protected _getTriggerIcon(value: string | undefined): ThemeIcon | undefined;
-    protected _getActionItemIcon(item: IAgentHostSessionEnumPickerItem): ThemeIcon | undefined;
-    protected _getTriggerAriaLabel(label: string): string;
-    protected _getWidgetAriaLabel(): string;
-    protected _getFooterActionItems(): readonly IActionListItem<IAgentHostSessionEnumPickerItem>[];
-    protected _handleFooterActionItem(item: IAgentHostSessionEnumPickerItem): boolean;
-}