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

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

@@ -0,0 +1,211 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } 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 { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IViewDescriptorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service";
+import { IEditorWorkingSet } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+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 { 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 { ISessionChangesService } from "@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 { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+/**
+ * Per-session view state: auxiliary bar visibility and active view container.
+ * Treated as opaque persisted data by the base controller; only the desktop
+ * controller interprets it (see `desktopSessionLayoutController.md`).
+ */
+export interface ISessionViewState {
+    readonly auxiliaryBarVisible: boolean;
+    readonly auxiliaryBarActiveViewContainerId: string | undefined;
+    /** [D9] Marks an aux-bar hide caused only by collapsing the whole side pane. */
+    readonly auxiliaryBarHiddenByCollapse?: boolean;
+}
+/**
+ * Shared, platform-agnostic per-session layout state management. The behaviour
+ * specified here is enumerated as rules **B1-B6** in
+ * [baseSessionLayoutController.md](./baseSessionLayoutController.md).
+ *
+ * It owns the panel visibility (or, in single-pane, the panel view), editor
+ * working sets, persistence, and the multi-session suppression that every layout
+ * needs. Auxiliary bar management is platform-specific and supplied by subclasses
+ * through {@link _registerViewStateManagement} (see the desktop / mobile controllers).
+ */
+export declare abstract class BaseLayoutController extends Disposable {
+    protected readonly _layoutService: IAgentWorkbenchLayoutService;
+    private readonly _sessionManagementService;
+    protected readonly _sessionsService: ISessionsService;
+    protected readonly _viewsService: IViewsService;
+    protected readonly _paneCompositePartService: IPaneCompositePartService;
+    protected readonly _storageService: IStorageService;
+    protected readonly _configurationService: IConfigurationService;
+    protected readonly _editorService: IEditorService;
+    protected readonly _editorGroupsService: IEditorGroupsService;
+    private readonly _workspaceContextService;
+    protected readonly _sessionChangesService: ISessionChangesService;
+    protected readonly _changesViewService: IChangesViewService;
+    protected readonly _viewDescriptorService: IViewDescriptorService;
+    protected readonly _contextKeyService: IContextKeyService;
+    protected readonly _instantiationService: IInstantiationService;
+    protected readonly _lifecycleService: ILifecycleService;
+    protected readonly _panelVisibilityBySession: ResourceMap<boolean>;
+    protected readonly _panelViewBySession: ResourceMap<string>;
+    protected readonly _viewStateBySession: ResourceMap<ISessionViewState>;
+    protected readonly _workingSets: ResourceMap<IEditorWorkingSet>;
+    /**
+     * [B2] Whether the editor part was hidden (e.g. the user closed the Side
+     * Panel while keeping editors open) for a session, captured on switch-away so
+     * restoring the session's working set does not force the editor part open.
+     */
+    protected readonly _editorPartHiddenBySession: ResourceMap<boolean>;
+    private readonly _workingSetSequencer;
+    protected readonly activeSessionResourceObs: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservable<URI | undefined>;
+    protected readonly multipleSessionsVisibleObs: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservableWithChange<boolean, void>;
+    /**
+     * `> 0` while the controller is restoring a session's layout on a session
+     * switch (editor working set and/or auxiliary bar). Subclasses can use this to
+     * re-baseline responsive behaviour instead of reacting to the restore-driven
+     * part-visibility changes (see the desktop controller's [D7] sidebar logic).
+     */
+    private _restoringSessionLayoutDepth;
+    protected get _isRestoringSessionLayout(): boolean;
+    /**
+     * Fires when a session-switch layout restore fully settles (the restore depth
+     * returns to 0, after the — possibly async — working-set apply and aux-bar
+     * restore complete). Subclasses reconcile off this instead of reacting to the
+     * transient part/editor changes *during* the restore, which race the settled
+     * state (e.g. a new session's empty working set closing the docked tabs).
+     */
+    private readonly _onDidEndSessionLayoutRestore;
+    protected readonly onDidEndSessionLayoutRestore: Event<void>;
+    /**
+     * [D9] `true` between the layout service's side-pane will/did toggle events.
+     * The per-session aux-bar capture skips this window, so toggling the whole
+     * side pane is never recorded as an explicit aux-bar choice.
+     */
+    protected _togglingSidePane: boolean;
+    private readonly _useModalConfigObs;
+    /**
+     * Storage key for this controller's per-session layout state. Overridable so a
+     * sibling controller (e.g. single-pane) persists to a fresh key instead of
+     * sharing the classic desktop state.
+     */
+    protected get _layoutStateStorageKey(): string;
+    /**
+     * Legacy key migrated on first load, or `undefined` to skip migration (a fresh
+     * sibling controller has no legacy state to migrate).
+     */
+    protected get _legacyWorkingSetsStorageKey(): string | undefined;
+    protected get _isEditorPartVisibilityPerSession(): boolean;
+    protected get _isViewStatePerSession(): boolean;
+    /**
+     * The single gate for per-session panel state. When `true` [B1] the panel's
+     * *visibility* is remembered per session; when `false` the panel is governed at
+     * the workbench level (like the side pane) and its *view* is remembered per
+     * session instead [B6] — never both. Restoring the view never changes the
+     * panel's visibility.
+     */
+    protected get _isPanelVisibilityPerSession(): boolean;
+    constructor(_layoutService: IAgentWorkbenchLayoutService, _sessionManagementService: ISessionsManagementService, _sessionsService: ISessionsService, _viewsService: IViewsService, _paneCompositePartService: IPaneCompositePartService, _storageService: IStorageService, _configurationService: IConfigurationService, _editorService: IEditorService, _editorGroupsService: IEditorGroupsService, _workspaceContextService: IWorkspaceContextService, _sessionChangesService: ISessionChangesService, _changesViewService: IChangesViewService, _viewDescriptorService: IViewDescriptorService, _contextKeyService: IContextKeyService, _instantiationService: IInstantiationService, _lifecycleService: ILifecycleService);
+    /**
+     * Hook for a layout controller to create and own its auxiliary controllers.
+     * The base implementation does nothing.
+     */
+    protected _registerAuxiliaryControllers(): void;
+    /**
+     * Whether a custom view currently replaces the sessions grid. The parts it
+     * covers are force-hidden, so those transitions must not be captured as the
+     * active session's layout preference.
+     */
+    protected _isCustomViewVisible(): boolean;
+    /**
+     * Registers the `Toggle Side Panel` action (menu item, keybinding, and
+     * command-palette entry). The command calls the workbench layout service
+     * directly; this controller observes the service's toggle lifecycle events.
+     */
+    private _registerSidePaneToggleAction;
+    /**
+     * Hook for subclasses to register platform-specific auxiliary bar
+     * view-state management. Runs at the end of the base constructor. The base
+     * implementation does nothing.
+     */
+    protected _registerViewStateManagement(): void;
+    protected _onSessionReplaced(from: ISession, to: ISession): void;
+    /**
+     * Whether the auxiliary bar currently has at least one active view container
+     * (shown as a tab). Mirrors the workbench's own container-visibility rule
+     * (`!hideIfEmpty || isViewContainerActive`, folded into `isViewContainerActive`).
+     */
+    protected _hasActiveAuxViewContainers(): boolean;
+    /**
+     * Records a completed whole-side-pane toggle from the did event's before/after
+     * state while {@link _togglingSidePane} is still set.
+     */
+    protected _onSidePaneToggled(_collapsed: boolean, _previousAuxiliaryBarVisible: boolean, _auxiliaryBarVisible: boolean): void;
+    /**
+     * [B4] Hook that lets a subclass snapshot the active session's view state when
+     * state is about to be persisted. The base implementation does nothing.
+     */
+    protected _captureActiveSessionViewState(_sessionResource: URI): void;
+    /**
+     * Runs a session-switch layout restore with {@link _isRestoringSessionLayout}
+     * held until the (possibly async) work settles, so part-visibility changes the
+     * restore causes can be re-baselined rather than reacted to.
+     */
+    protected _withSessionLayoutRestore(work: () => void | Promise<unknown>): void;
+    private _endSessionLayoutRestore;
+    /**
+     * Hook to suppress editor-part auto-visibility for the whole session-switch
+     * restore. The base restore causes no layout-driven editor closes, so it
+     * returns `undefined`.
+     */
+    protected _suppressEditorVisibilityDuringRestore(): IDisposable | undefined;
+    /**
+     * Hook deciding whether {@link _applyWorkingSet} reveals the editor part when
+     * restoring a non-empty working set.
+     */
+    protected _shouldRevealEditorPartOnApply(editorPartHidden: boolean, isModal: boolean): boolean;
+    /**
+     * Hook deciding whether {@link _applyWorkingSet} reveals the editor part for an
+     * empty working set. The base never reveals in this case.
+     */
+    protected _shouldRevealEditorPartForEmptyWorkingSet(_revealEditorPart: boolean): boolean;
+    /**
+     * Hook deciding whether {@link _applyWorkingSet} actively hides the editor part
+     * when restoring a session that had it hidden. The base never hides (in the
+     * classic layout the editor part visibility is not a per-session choice); the
+     * single-pane layout restores its docked editor part both ways.
+     */
+    protected _shouldHideEditorPartOnApply(_editorPartHidden: boolean): boolean;
+    /** Hook invoked before a session working set is queued for application. */
+    protected _onWillApplyWorkingSet(_workingSet: IEditorWorkingSet | "empty"): void;
+    /**
+     * Reveals the editor part. Editor working sets are restored into the shared
+     * editor area on session switch, which requires the editor part to be visible.
+     */
+    private _revealEditorPartForWorkingSet;
+    /** Hides the editor part to restore a session that had its docked editor closed. */
+    private _hideEditorPartForWorkingSet;
+    private _loadState;
+    private _saveState;
+    private _syncPanelVisibility;
+    /**
+     * Restores the session's remembered panel view (falling back to the Terminal),
+     * but only while the panel is already visible — opening a pane composite would
+     * otherwise reveal the panel, whose visibility is governed elsewhere.
+     */
+    private _syncPanelView;
+    private _applyWorkingSet;
+    private _saveWorkingSet;
+    private _deleteWorkingSet;
+}