@codingame/monaco-vscode-workbench-service-override 37.5.0 → 37.6.1

package/index.js

@@ -52,9 +52,9 @@ let CustomWorkbench = class CustomWorkbench extends Workbench {
     initServices() {
         return this.instantiationService;
     }
-    restore(accessor) {
+    restore(instantiationService) {
         try {
-            this.restoreParts(accessor);
+            this.restoreParts(instantiationService);
         }
         catch (error) {
             onUnexpectedError(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-workbench-service-override",
-  "version": "37.5.0",
+  "version": "37.6.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - workbench service-override",
   "keywords": [],
@@ -15,15 +15,15 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "37.5.0",
-    "@codingame/monaco-vscode-environment-service-override": "37.5.0",
-    "@codingame/monaco-vscode-katex-common": "37.5.0",
-    "@codingame/monaco-vscode-keybindings-service-override": "37.5.0",
-    "@codingame/monaco-vscode-quickaccess-service-override": "37.5.0",
-    "@codingame/monaco-vscode-view-banner-service-override": "37.5.0",
-    "@codingame/monaco-vscode-view-common-service-override": "37.5.0",
-    "@codingame/monaco-vscode-view-status-bar-service-override": "37.5.0",
-    "@codingame/monaco-vscode-view-title-bar-service-override": "37.5.0"
+    "@codingame/monaco-vscode-api": "37.6.1",
+    "@codingame/monaco-vscode-environment-service-override": "37.6.1",
+    "@codingame/monaco-vscode-katex-common": "37.6.1",
+    "@codingame/monaco-vscode-keybindings-service-override": "37.6.1",
+    "@codingame/monaco-vscode-quickaccess-service-override": "37.6.1",
+    "@codingame/monaco-vscode-view-banner-service-override": "37.6.1",
+    "@codingame/monaco-vscode-view-common-service-override": "37.6.1",
+    "@codingame/monaco-vscode-view-status-bar-service-override": "37.6.1",
+    "@codingame/monaco-vscode-view-title-bar-service-override": "37.6.1"
   },
   "main": "index.js",
   "module": "index.js",

package/session.js

@@ -21,6 +21,7 @@ import { SessionsParts } from './vscode/src/vs/sessions/browser/parts/sessionsPa
 import { SessionsSetUpService } from './vscode/src/vs/sessions/browser/sessionsSetUpService.js';
 import { ISessionsSetUpService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/sessionsSetUpService.service';
 import { Workbench } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench';
+import { SinglePaneWorkbench } from './vscode/src/vs/sessions/browser/singlePaneWorkbench.js';
 import { IDevContainerAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/devContainerAgentHostService.service';
 import { ChatDashboardServiceImpl } from './vscode/src/vs/sessions/contrib/accountMenu/browser/account.contribution.js';
 import { IAgentFeedbackService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/agentFeedback/browser/agentFeedbackService.service';
@@ -120,6 +121,7 @@ import { EditorParts } from './vscode/src/vs/sessions/browser/parts/editorParts.
 import getServiceOverride$3 from '@codingame/monaco-vscode-environment-service-override';
 export { agentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostFileSystemProvider';
 export { agentHostAuthority } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { DOCK_DETAIL_PANEL_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionConfig';
 import './vscode/src/vs/sessions/browser/parts/menubar.contribution.js';
 import './vscode/src/vs/sessions/contrib/aiCustomizationTreeView/browser/aiCustomizationTreeView.contribution.js';
 import './vscode/src/vs/sessions/contrib/aquarium/browser/aquarium.contribution.js';
@@ -159,6 +161,7 @@ import './vscode/src/vs/sessions/contrib/terminal/browser/sessionsTerminalContri
 import './vscode/src/vs/sessions/contrib/applyCommitsToParentRepo/browser/applyChangesToParentRepo.js';
 import './vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostSessionBranchActions.js';
 import '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/sidebar/sidebarActions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { observableFromPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
 export { AbstractResourceEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/resourceEditorInput';
 export { AbstractTextResourceEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/textResourceEditorInput';
@@ -173,37 +176,51 @@ export { SplitView } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/u
 export { ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
 export { ViewPaneContainer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
 
-let CustomWorkbench = class CustomWorkbench extends Workbench {
-    constructor(options, logService, _instantiationService) {
-        super(getWorkbenchContainer(), options, new ServiceCollection(), logService);
-        this._instantiationService = _instantiationService;
-        this.mainContainer.classList.add('monaco-workbench-part');
-    }
-    registerErrorHandler(logService) {
-        setUnexpectedErrorHandler((error) => this.handleUnexpectedError(error, logService));
-    }
-    createNotificationsHandlers() {
-        this.registerNotificationRowHeight();
-    }
-    initServices() {
-        return this._instantiationService;
-    }
-    restore(accessor) {
-        try {
-            this.restoreParts(accessor);
+function createCustomWorkbench(BaseWorkbench) {
+    let CustomWorkbench = class CustomWorkbench extends BaseWorkbench {
+        constructor(options, logService, _instantiationService, _configurationService) {
+            super(getWorkbenchContainer(), options, new ServiceCollection(), logService);
+            this._instantiationService = _instantiationService;
+            this.mainContainer.classList.add('monaco-workbench-part');
+        }
+        registerErrorHandler(logService) {
+            setUnexpectedErrorHandler((error) => this.handleUnexpectedError(error, logService));
         }
-        catch (error) {
-            onUnexpectedError(error);
+        createNotificationsHandlers() {
+            this.registerNotificationRowHeight();
         }
-        void this.sessionsService.restoreVisibleSessions().catch((e) => {
-            this.logService.error('[Workbench] restoreVisibleSessions failed', e);
-        });
+        initServices() {
+            return this._instantiationService;
+        }
+        restore(lifecycleService) {
+            try {
+                this.restoreParts();
+            }
+            catch (error) {
+                onUnexpectedError(error);
+            }
+            void this.sessionsService.restoreVisibleSessions().catch((e) => {
+                this.logService.error('[Workbench] restoreVisibleSessions failed', e);
+            });
+        }
+    };
+    CustomWorkbench = __decorate([
+        __param(1, ILogService),
+        __param(2, IInstantiationService),
+        __param(3, IConfigurationService)
+    ], CustomWorkbench);
+    return CustomWorkbench;
+}
+const CustomSinglePaneWorkbench = createCustomWorkbench(SinglePaneWorkbench);
+const CustomWorkbench = new Proxy(createCustomWorkbench(Workbench), {
+    construct(target, args) {
+        const configurationService = args[3];
+        const WorkbenchClass = configurationService.getValue(DOCK_DETAIL_PANEL_SETTING)
+            ? CustomSinglePaneWorkbench
+            : target;
+        return Reflect.construct(WorkbenchClass, args);
     }
-};
-CustomWorkbench = __decorate([
-    __param(1, ILogService),
-    __param(2, IInstantiationService)
-], CustomWorkbench);
+});
 onLayout(async (accessor) => {
     accessor.get(IWorkbenchLayoutService).startup();
     const detectedFullScreen = detectFullscreen(mainWindow, getWorkbenchContainer());

package/vscode/src/vs/sessions/browser/singlePaneWorkbench.d.ts

@@ -0,0 +1,76 @@
+import { ISerializableView, ISerializedNode, IViewSize } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/grid/grid";
+import { IEditorWillOpenEvent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { Workbench } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench";
+/**
+ * Remembers the editor width captured around visibility transitions.
+ */
+export declare class DockedEditorSizeMemento {
+    /** Editor node size captured when the editor is hidden with the detail still visible. */
+    dockedEditorSizeBeforeHide: IViewSize | undefined;
+}
+/**
+ * Single-pane workbench: the auxiliary bar is docked inside the editor part (below
+ * a shared tab bar) rather than being its own grid column. The editor part
+ * ({@link SinglePaneMainEditorPart}) owns the auxiliary bar and its docked
+ * controller; this workbench owns the docked width, the reveal-sync, and the
+ * docked size bookkeeping.
+ */
+export declare class SinglePaneWorkbench extends Workbench {
+    /** Node width past the detail width at which editor content counts as visible. */
+    private static readonly _EDITOR_CONTENT_VISIBLE_THRESHOLD;
+    private _dockedAuxiliaryBarWidth;
+    private _syncingEditorVisibility;
+    private readonly _memento;
+    get isSinglePaneLayoutEnabled(): boolean;
+    isEditorPaneVisible(): boolean;
+    toggleSecondarySideBar(): void;
+    isSecondarySideBarVisible(): boolean;
+    protected readonly _defaultSidePaneState: {
+        editor: boolean;
+        auxiliaryBar: boolean;
+    };
+    /**
+     * A docked-detail editor (Changes/Files) renders its content in the docked
+     * detail panel. While that panel is open and the editor area is closed,
+     * re-activating such an editor (closing a neighbouring tab, or clicking the
+     * tab) must not reveal the editor area. When the detail panel is closed the
+     * base reveal still runs so the content becomes visible.
+     */
+    protected revealEditorOnOpen(e: IEditorWillOpenEvent): void;
+    getDockedAuxiliaryBarWidth(): number;
+    setDockedAuxiliaryBarWidth(width: number): void;
+    getPreferredEditorPartWidth(): number | undefined;
+    /** Re-layouts the docked auxiliary bar, which the editor part owns. */
+    private _layoutDockedAuxBar;
+    protected _applyLayoutContainerClass(): void;
+    protected _auxiliaryBarLayoutWidth(): number;
+    protected _auxiliaryBarViewSize(): IViewSize;
+    protected _setAuxiliaryBarViewSize(size: IViewSize): void;
+    protected _resizeAuxiliaryBarBy(deltaWidth: number, _deltaHeight: number): void;
+    protected _restoreAuxiliaryBarWidth(width: number): void;
+    protected _persistedEditorWidth(editorGridWidth: number | undefined): number | undefined;
+    protected _persistedGridViewSize(view: ISerializableView, dimension: "width" | "height", visible: boolean): number | undefined;
+    protected _defaultSideBarSize(policySideBarSize: number): number;
+    protected _editorNodeSize(effectiveEditorWidth: number, effectiveAuxBarWidth: number): number;
+    protected _editorNodeVisible(editorVisible: boolean, auxBarVisible: boolean): boolean;
+    protected _minimumPartWidthForActivation(view: ISerializableView): number;
+    protected _topRightSectionChildren(sessionsNode: ISerializedNode, editorNode: ISerializedNode, _auxiliaryBarNode: ISerializedNode, customViewGridNode: ISerializedNode): ISerializedNode[];
+    protected _layoutSidePane(): void;
+    protected _layoutGrid(): void;
+    private _preserveSessionsEditorRatio;
+    protected _applyEditorAreaVisibility(): void;
+    protected _onGridDidChange(): void;
+    protected _onEditorNodeResized(nodeWidth: number): void;
+    private _syncEditorVisibility;
+    protected _runWithEditorResizeSyncSuspended(fn: () => void): void;
+    protected _applyEditorVisibility(hidden: boolean): void;
+    protected _onWillHideAuxiliaryBar(hidden: boolean): void;
+    /**
+     * No-op unless detail-only (editor content hidden): there the shared node is a
+     * snap view, so sash-drag collapse/reveal maps onto hiding/showing the auxiliary bar.
+     */
+    protected _onEditorPartGridVisibilityChange(visible: boolean): void;
+    protected _applyAuxiliaryBarVisibility(hidden: boolean, source?: "resize"): void;
+    protected _shouldOpenAuxiliaryPaneComposite(containerId: string): boolean;
+    protected _handleAllEditorsClosed(): void;
+}

package/vscode/src/vs/sessions/browser/singlePaneWorkbench.js

@@ -0,0 +1,320 @@
+
+import { Sizing } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/grid/grid';
+import { alert } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { DockedEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/dockedEditorInput';
+import { DockedAuxiliaryBarController } from './dockedAuxiliaryBarController.js';
+import { EDITOR_PART_MINIMUM_WIDTH } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/editorPartSizing';
+import { Workbench } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench';
+
+class DockedEditorSizeMemento {}
+class SinglePaneWorkbench extends Workbench {
+    constructor() {
+        super(...arguments);
+        this._dockedAuxiliaryBarWidth = DockedAuxiliaryBarController.DEFAULT_WIDTH;
+        this._syncingEditorVisibility = false;
+        this._memento = ( new DockedEditorSizeMemento());
+        this._defaultSidePaneState = {
+            editor: true,
+            auxiliaryBar: false
+        };
+    }
+    static {
+        this._EDITOR_CONTENT_VISIBLE_THRESHOLD = 4;
+    }
+    get isSinglePaneLayoutEnabled() {
+        return true;
+    }
+    isEditorPaneVisible() {
+        return this.workbenchGrid ? this.workbenchGrid.isViewVisible(this.editorPartView) : super.isEditorPaneVisible();
+    }
+    toggleSecondarySideBar() {
+        const visible = this.toggleSidePane();
+        alert(visible ? ( localize(3071, "Side pane shown")) : ( localize(3072, "Side pane hidden")));
+    }
+    isSecondarySideBarVisible() {
+        return this.isSidePaneVisible();
+    }
+    revealEditorOnOpen(e) {
+        if (!this.isRestored() && !this.partVisibility.editor) {
+            return;
+        }
+        if (e.editor instanceof DockedEditorInput && this.partVisibility.auxiliaryBar && !this.partVisibility.editor) {
+            return;
+        }
+        super.revealEditorOnOpen(e);
+    }
+    getDockedAuxiliaryBarWidth() {
+        return this._dockedAuxiliaryBarWidth;
+    }
+    setDockedAuxiliaryBarWidth(width) {
+        this._dockedAuxiliaryBarWidth = width;
+        if (this.workbenchGrid && this.partVisibility.auxiliaryBar && !this.partVisibility.editor) {
+            this._syncingEditorVisibility = true;
+            try {
+                this.workbenchGrid.resizeView(this.editorPartView, {
+                    width: this._dockedAuxiliaryBarWidth,
+                    height: this.workbenchGrid.getViewSize(this.editorPartView).height
+                });
+            } finally {
+                this._syncingEditorVisibility = false;
+            }
+        }
+        this._layoutDockedAuxBar();
+    }
+    getPreferredEditorPartWidth() {
+        if (!this.partVisibility.editor) {
+            return DockedAuxiliaryBarController.DEFAULT_WIDTH;
+        }
+        if (!this.partVisibility.auxiliaryBar || !this.workbenchGrid) {
+            return undefined;
+        }
+        const sessionsWidth = this.workbenchGrid.getViewSize(this.sessionsPartView).width;
+        const editorNodeWidth = this.workbenchGrid.getViewSize(this.editorPartView).width;
+        const totalWidth = sessionsWidth + editorNodeWidth;
+        return Math.round(
+            this._dockedAuxiliaryBarWidth + (totalWidth - this._dockedAuxiliaryBarWidth) / 2
+        );
+    }
+    _layoutDockedAuxBar() {
+        this.editorGroupService.mainPart.layoutDockedAuxiliaryBar();
+    }
+    _applyLayoutContainerClass() {
+        this.mainContainer.classList.toggle("dock-detail-panel", true);
+    }
+    _auxiliaryBarLayoutWidth() {
+        return this._dockedAuxiliaryBarWidth;
+    }
+    _auxiliaryBarViewSize() {
+        return {
+            width: this._dockedAuxiliaryBarWidth,
+            height: this._editorPartContainer?.clientHeight ?? 0
+        };
+    }
+    _setAuxiliaryBarViewSize(size) {
+        this._dockedAuxiliaryBarWidth = Math.max(DockedAuxiliaryBarController.MIN_WIDTH, size.width);
+        this._layoutDockedAuxBar();
+    }
+    _resizeAuxiliaryBarBy(deltaWidth, _deltaHeight) {
+        this._dockedAuxiliaryBarWidth = Math.max(
+            DockedAuxiliaryBarController.MIN_WIDTH,
+            this._dockedAuxiliaryBarWidth + deltaWidth
+        );
+        this._layoutDockedAuxBar();
+    }
+    _restoreAuxiliaryBarWidth(width) {
+        this._dockedAuxiliaryBarWidth = Math.max(DockedAuxiliaryBarController.MIN_WIDTH, width);
+    }
+    _persistedEditorWidth(editorGridWidth) {
+        if (typeof editorGridWidth !== "number") {
+            return editorGridWidth;
+        }
+        const dockedDetailWidth = this.partVisibility.auxiliaryBar ? this._dockedAuxiliaryBarWidth : 0;
+        return Math.max(0, editorGridWidth - dockedDetailWidth);
+    }
+    _persistedGridViewSize(view, dimension, visible) {
+        if (view === this.auxiliaryBarPartView) {
+            return this._dockedAuxiliaryBarWidth;
+        }
+        return super._persistedGridViewSize(view, dimension, visible);
+    }
+    _defaultSideBarSize(policySideBarSize) {
+        return Math.min(policySideBarSize, 280);
+    }
+    _editorNodeSize(effectiveEditorWidth, effectiveAuxBarWidth) {
+        if (!this.partVisibility.editor && this.partVisibility.auxiliaryBar) {
+            return this._dockedAuxiliaryBarWidth;
+        }
+        return effectiveEditorWidth + effectiveAuxBarWidth;
+    }
+    _editorNodeVisible(editorVisible, auxBarVisible) {
+        return editorVisible || auxBarVisible;
+    }
+    _minimumPartWidthForActivation(view) {
+        if (view === this.editorPartView && this.partVisibility.auxiliaryBar) {
+            return view.minimumWidth + this._dockedAuxiliaryBarWidth;
+        }
+        return super._minimumPartWidthForActivation(view);
+    }
+    _topRightSectionChildren(sessionsNode, editorNode, _auxiliaryBarNode, customViewGridNode) {
+        return [sessionsNode, editorNode, customViewGridNode];
+    }
+    _layoutSidePane() {
+        this._layoutDockedAuxBar();
+    }
+    _layoutGrid() {
+        const sessionsSize = this.workbenchGrid.getViewSize(this.sessionsPartView);
+        const editorSize = this.workbenchGrid.getViewSize(this.editorPartView);
+        const preserveRatio = this.partVisibility.editor && this.workbenchGrid.isViewVisible(this.sessionsPartView) && this.workbenchGrid.isViewVisible(this.editorPartView) && sessionsSize.width > 0 && editorSize.width > 0;
+        super._layoutGrid();
+        if (preserveRatio) {
+            this._preserveSessionsEditorRatio(sessionsSize.width, editorSize.width);
+        }
+    }
+    _preserveSessionsEditorRatio(previousSessionsWidth, previousEditorWidth) {
+        const sessionsSize = this.workbenchGrid.getViewSize(this.sessionsPartView);
+        const editorSize = this.workbenchGrid.getViewSize(this.editorPartView);
+        const previousTotalWidth = previousSessionsWidth + previousEditorWidth;
+        const totalWidth = sessionsSize.width + editorSize.width;
+        if (totalWidth === previousTotalWidth) {
+            return;
+        }
+        const minimumEditorWidth = this._minimumPartWidthForActivation(this.editorPartView);
+        const maximumEditorWidth = totalWidth - this._minimumPartWidthForActivation(this.sessionsPartView);
+        if (maximumEditorWidth < minimumEditorWidth) {
+            return;
+        }
+        const proportionalEditorWidth = Math.round(totalWidth * previousEditorWidth / previousTotalWidth);
+        const targetEditorWidth = Math.min(maximumEditorWidth, Math.max(minimumEditorWidth, proportionalEditorWidth));
+        if (targetEditorWidth === editorSize.width) {
+            return;
+        }
+        this._runWithEditorResizeSyncSuspended(() => {
+            this.workbenchGrid.resizeView(this.editorPartView, {
+                width: targetEditorWidth,
+                height: editorSize.height
+            });
+        });
+    }
+    _applyEditorAreaVisibility() {
+        this.workbenchGrid.setViewVisible(this.editorPartView, this._editorNodeShouldBeVisible());
+        this._layoutDockedAuxBar();
+    }
+    _onGridDidChange() {
+        const nodeWidth = this.workbenchGrid.getViewSize(this.editorPartView).width;
+        this._syncEditorVisibility(nodeWidth);
+    }
+    _onEditorNodeResized(nodeWidth) {
+        this._syncEditorVisibility(nodeWidth);
+    }
+    _syncEditorVisibility(nodeWidth) {
+        if (this._syncingEditorVisibility) {
+            return;
+        }
+        if (this._isEditorPartAutoVisibilitySuppressed) {
+            return;
+        }
+        this._syncingEditorVisibility = true;
+        try {
+            const effectiveAuxiliaryBarWidth = DockedAuxiliaryBarController.getEffectiveWidth(this._dockedAuxiliaryBarWidth, nodeWidth);
+            const editorContentVisible = nodeWidth > effectiveAuxiliaryBarWidth + SinglePaneWorkbench._EDITOR_CONTENT_VISIBLE_THRESHOLD;
+            if (this.partVisibility.editor && !editorContentVisible && this.partVisibility.auxiliaryBar) {
+                this.partVisibility.editor = false;
+                this._setMainEditorAreaHidden(true);
+                this._editorRevealedExplicitly = false;
+                this._layoutDockedAuxBar();
+                this._fireDidChangePartVisibility(Parts.EDITOR_PART, false);
+                this._savePartVisibility();
+                return;
+            }
+        } finally {
+            this._syncingEditorVisibility = false;
+        }
+    }
+    _runWithEditorResizeSyncSuspended(fn) {
+        this._syncingEditorVisibility = true;
+        try {
+            fn();
+        } finally {
+            this._syncingEditorVisibility = false;
+        }
+    }
+    _applyEditorVisibility(hidden) {
+        if (hidden) {
+            const contentWidth = this._persistedEditorWidth(this.workbenchGrid.getViewSize(this.editorPartView).width);
+            if (contentWidth !== undefined && contentWidth >= EDITOR_PART_MINIMUM_WIDTH) {
+                this._savedPartSizes = {
+                    ...this._savedPartSizes,
+                    editor: contentWidth
+                };
+            }
+        }
+        const dockedEditorSizeBeforeHide = this._memento.dockedEditorSizeBeforeHide;
+        const savedEditorWidth = this._savedPartSizes.editor;
+        const canRestoreSavedWidth = savedEditorWidth !== undefined && savedEditorWidth >= EDITOR_PART_MINIMUM_WIDTH;
+        const shouldRestoreDockedEditorSize = !hidden && !!dockedEditorSizeBeforeHide;
+        const shouldRestoreSavedWidth = !hidden && !shouldRestoreDockedEditorSize && canRestoreSavedWidth;
+        const shouldApplyEvenSplit = !hidden && !shouldRestoreDockedEditorSize && !shouldRestoreSavedWidth;
+        this.workbenchGrid.setViewVisible(
+            this.editorPartView,
+            this._editorNodeShouldBeVisible(),
+            shouldApplyEvenSplit ? Sizing.Distribute : undefined
+        );
+        if (hidden) {
+            if (this.partVisibility.auxiliaryBar) {
+                this._memento.dockedEditorSizeBeforeHide = this.workbenchGrid.getViewSize(this.editorPartView);
+                this.workbenchGrid.resizeView(this.editorPartView, {
+                    width: this._dockedAuxiliaryBarWidth,
+                    height: this._memento.dockedEditorSizeBeforeHide.height
+                });
+            } else {
+                this._memento.dockedEditorSizeBeforeHide = undefined;
+            }
+        } else if (shouldRestoreDockedEditorSize && dockedEditorSizeBeforeHide) {
+            this.workbenchGrid.resizeView(this.editorPartView, dockedEditorSizeBeforeHide);
+            this._memento.dockedEditorSizeBeforeHide = undefined;
+        } else if (shouldRestoreSavedWidth) {
+            this._memento.dockedEditorSizeBeforeHide = undefined;
+            const height = this.workbenchGrid.getViewSize(this.editorPartView).height;
+            const detailWidth = this.partVisibility.auxiliaryBar ? this._dockedAuxiliaryBarWidth : 0;
+            this.workbenchGrid.resizeView(this.editorPartView, {
+                width: savedEditorWidth + detailWidth,
+                height
+            });
+        } else if (!hidden) {
+            this._memento.dockedEditorSizeBeforeHide = undefined;
+        }
+        if (shouldApplyEvenSplit) {
+            this._hasAppliedInitialEditorSplit = true;
+        }
+        this._layoutDockedAuxBar();
+        this._fireDidChangePartVisibility(Parts.EDITOR_PART, !hidden);
+        this._notifyContainerDidLayout();
+    }
+    _onWillHideAuxiliaryBar(hidden) {
+        if (hidden && !this.partVisibility.editor && !this._isEditorPartAutoVisibilitySuppressed) {
+            this.setEditorHidden(false,  true);
+        }
+    }
+    _onEditorPartGridVisibilityChange(visible) {
+        if (this.partVisibility.editor) {
+            return;
+        }
+        if (!visible) {
+            const suppression = this.suppressEditorPartAutoVisibility();
+            try {
+                this.setAuxiliaryBarHiddenForResize(true);
+            } finally {
+                suppression.dispose();
+            }
+            return;
+        }
+        this.setAuxiliaryBarHiddenForResize(false);
+    }
+    _applyAuxiliaryBarVisibility(hidden, source) {
+        if (this.workbenchGrid) {
+            this.workbenchGrid.setViewVisible(this.editorPartView, this._editorNodeShouldBeVisible());
+            if (!hidden && !this.partVisibility.editor) {
+                this._syncingEditorVisibility = true;
+                try {
+                    this.workbenchGrid.resizeView(this.editorPartView, {
+                        width: this._dockedAuxiliaryBarWidth,
+                        height: this.workbenchGrid.getViewSize(this.editorPartView).height
+                    });
+                } finally {
+                    this._syncingEditorVisibility = false;
+                }
+            }
+        }
+        this._layoutDockedAuxBar();
+        this._fireDidChangePartVisibility(Parts.AUXILIARYBAR_PART, !hidden, source);
+        this._notifyContainerDidLayout();
+    }
+    _shouldOpenAuxiliaryPaneComposite(containerId) {
+        return this._isAuxViewContainerActive(containerId);
+    }
+    _handleAllEditorsClosed() {}
+}
+
+export { DockedEditorSizeMemento, SinglePaneWorkbench };