@codingame/monaco-vscode-api 36.2.7 → 37.1.0

package/vscode/src/vs/workbench/browser/parts/editor/editorGroupWatermark.js

@@ -23,7 +23,7 @@ import { IWorkspaceContextService } from '../../../../platform/workspace/common/
 var EditorGroupWatermark_1;
 const showChatContextKey = ( ContextKeyExpr.and(( ContextKeyExpr.equals("chatSetupHidden", false)), ( ContextKeyExpr.equals("chatSetupDisabledInWorkspace", false))));
 const openChat = {
-    text: ( localize(3680, "Open Chat")),
+    text: ( localize(3957, "Open Chat")),
     id: "workbench.action.chat.open",
     when: {
         native: showChatContextKey,
@@ -31,53 +31,53 @@ const openChat = {
     }
 };
 const showCommands = {
-    text: ( localize(3681, "Show All Commands")),
+    text: ( localize(3958, "Show All Commands")),
     id: "workbench.action.showCommands"
 };
 const gotoFile = {
-    text: ( localize(3682, "Go to File")),
+    text: ( localize(3959, "Go to File")),
     id: "workbench.action.quickOpen"
 };
 const openFile = {
-    text: ( localize(3683, "Open File")),
+    text: ( localize(3960, "Open File")),
     id: "workbench.action.files.openFile"
 };
 const openFolder = {
-    text: ( localize(3684, "Open Folder")),
+    text: ( localize(3961, "Open Folder")),
     id: "workbench.action.files.openFolder"
 };
 const openFileOrFolder = {
-    text: ( localize(3685, "Open File or Folder")),
+    text: ( localize(3962, "Open File or Folder")),
     id: "workbench.action.files.openFileFolder"
 };
 const openRecent = {
-    text: ( localize(3686, "Open Recent")),
+    text: ( localize(3963, "Open Recent")),
     id: "workbench.action.openRecent"
 };
 const newUntitledFile = {
-    text: ( localize(3687, "New Untitled Text File")),
+    text: ( localize(3964, "New Untitled Text File")),
     id: "workbench.action.files.newUntitledFile"
 };
 const findInFiles = {
-    text: ( localize(3688, "Find in Files")),
+    text: ( localize(3965, "Find in Files")),
     id: "workbench.action.findInFiles"
 };
 const toggleTerminal = {
-    text: ( localize(3689, "Toggle Terminal")),
+    text: ( localize(3966, "Toggle Terminal")),
     id: "workbench.action.terminal.toggleTerminal",
     when: {
         web: ( ContextKeyExpr.equals("terminalProcessSupported", true))
     }
 };
 const startDebugging = {
-    text: ( localize(3690, "Start Debugging")),
+    text: ( localize(3967, "Start Debugging")),
     id: "workbench.action.debug.start",
     when: {
         web: ( ContextKeyExpr.equals("terminalProcessSupported", true))
     }
 };
 const openSettings = {
-    text: ( localize(3691, "Open Settings")),
+    text: ( localize(3968, "Open Settings")),
     id: "workbench.action.openSettings"
 };
 const baseEntries = [openChat, showCommands];

package/vscode/src/vs/workbench/browser/parts/editor/editorHeaderControl.d.ts

@@ -0,0 +1,33 @@
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
+import { IEditorGroupMenuIds, IEditorGroupsView, IEditorGroupView, IEditorGroupViewOptions } from "./editor.js";
+export declare class EditorHeaderControl extends Disposable {
+    private readonly groupView;
+    private readonly groupsView;
+    private readonly menuIds;
+    private readonly reserveHeaderSpace;
+    private readonly instantiationService;
+    static readonly DEFAULT_HEIGHT = 32;
+    static readonly COMPACT_HEIGHT = 28;
+    private readonly headerContainer;
+    private readonly actionsContainer;
+    private readonly primaryActionsContainer;
+    private readonly secondaryActionsContainer;
+    private readonly layoutActionsContainer;
+    private primaryActionsToolbar;
+    private secondaryActionsToolbar;
+    private layoutActionsToolbar;
+    private readonly headerActions;
+    private readonly breadcrumbsContainer;
+    private readonly breadcrumbsControlFactory;
+    private get breadcrumbsControl();
+    private breadcrumbsVisible;
+    private visible;
+    get height(): number;
+    constructor(parent: HTMLElement, groupView: IEditorGroupView, groupsView: IEditorGroupsView, menuIds: IEditorGroupMenuIds | undefined, showHeader: boolean, reserveHeaderSpace: IEditorGroupViewOptions["reserveHeaderSpace"], instantiationService: IInstantiationService);
+    handleEditorsChange(changed: boolean): void;
+    layout(width: number): void;
+    private updateBreadcrumbsVisibility;
+    private updateVisibility;
+    private renderActions;
+}

package/vscode/src/vs/workbench/browser/parts/editor/editorHeaderControl.js

@@ -0,0 +1,215 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, $, Dimension, reset } from '../../../../base/browser/dom.js';
+import { Disposable, MutableDisposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { MenuWorkbenchToolBar } from '../../../../platform/actions/browser/toolbar.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { localize } from '../../../../nls.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { BreadcrumbsControl, BreadcrumbsControlFactory } from './breadcrumbsControl.js';
+
+var EditorHeaderControl_1;
+let EditorHeaderControl = class EditorHeaderControl extends Disposable {
+    static {
+        EditorHeaderControl_1 = this;
+    }
+    static {
+        this.DEFAULT_HEIGHT = 32;
+    }
+    static {
+        this.COMPACT_HEIGHT = 28;
+    }
+    get breadcrumbsControl() {
+        return this.breadcrumbsControlFactory?.control;
+    }
+    get height() {
+        if (this.headerContainer) {
+            if (!this.visible) {
+                return 0;
+            }
+            return this.groupsView.partOptions.tabHeight === "compact" ? EditorHeaderControl_1.COMPACT_HEIGHT : EditorHeaderControl_1.DEFAULT_HEIGHT;
+        }
+        return this.breadcrumbsControl?.isHidden() === false ? BreadcrumbsControl.HEIGHT : 0;
+    }
+    constructor(
+        parent,
+        groupView,
+        groupsView,
+        menuIds,
+        showHeader,
+        reserveHeaderSpace,
+        instantiationService
+    ) {
+        super();
+        this.groupView = groupView;
+        this.groupsView = groupsView;
+        this.menuIds = menuIds;
+        this.reserveHeaderSpace = reserveHeaderSpace;
+        this.instantiationService = instantiationService;
+        this.headerActions = this._register(( new MutableDisposable()));
+        this.breadcrumbsVisible = false;
+        this.visible = false;
+        let breadcrumbsParent = parent;
+        if (showHeader) {
+            this.headerContainer = breadcrumbsParent = append(parent, $(".editor-group-header.breadcrumbs-in-header"));
+            this.actionsContainer = $(".editor-group-header-actions");
+            this.primaryActionsContainer = append(this.actionsContainer, $(".editor-group-header-primary-actions"));
+            this.secondaryActionsContainer = append(this.actionsContainer, $(".editor-group-header-secondary-actions"));
+            this.layoutActionsContainer = append(this.actionsContainer, $(".editor-group-header-layout-actions"));
+            this._register(toDisposable(() => this.headerContainer?.remove()));
+            this._register(this.groupView.onDidActiveEditorChange(() => this.renderActions(true)));
+        }
+        if (showHeader || groupsView.partOptions.showTabs !== "single") {
+            this.breadcrumbsContainer = append(breadcrumbsParent, $(".breadcrumbs-below-tabs"));
+            this.breadcrumbsControlFactory = this._register(
+                this.instantiationService.createInstance(BreadcrumbsControlFactory, this.breadcrumbsContainer, this.groupView, {
+                    showFileIcons: true,
+                    showSymbolIcons: true,
+                    showDecorationColors: false,
+                    showPlaceholder: true,
+                    dragEditor: false,
+                    showEditorTypePicker: true
+                })
+            );
+            this._register(
+                this.breadcrumbsControlFactory.onDidEnablementChange(() => this.updateBreadcrumbsVisibility(true))
+            );
+            this._register(
+                this.breadcrumbsControlFactory.onDidVisibilityChange(() => this.updateBreadcrumbsVisibility(true))
+            );
+            this.updateBreadcrumbsVisibility(false);
+        }
+        if (this.headerContainer && this.actionsContainer) {
+            this.headerContainer.appendChild(this.actionsContainer);
+            this.renderActions(false);
+        }
+    }
+    handleEditorsChange(changed) {
+        if (changed) {
+            this.breadcrumbsControl?.update();
+        } else {
+            this.breadcrumbsControl?.revealLast();
+        }
+    }
+    layout(width) {
+        this.updateVisibility(false);
+        if (this.headerContainer) {
+            this.headerContainer.style.width = `${Math.max(0, width)}px`;
+        }
+        if (this.breadcrumbsControl?.isHidden() === false && this.breadcrumbsContainer) {
+            let breadcrumbsWidth = 0;
+            if (this.headerContainer) {
+                breadcrumbsWidth = Math.max(0, this.breadcrumbsControl.domNode.clientWidth);
+            } else {
+                breadcrumbsWidth = Math.max(0, width);
+                this.breadcrumbsContainer.style.width = `${breadcrumbsWidth}px`;
+            }
+            this.breadcrumbsControl.layout(( new Dimension(breadcrumbsWidth, BreadcrumbsControl.HEIGHT)));
+        }
+    }
+    updateBreadcrumbsVisibility(relayout) {
+        this.breadcrumbsVisible = this.breadcrumbsControl?.isHidden() === false;
+        this.breadcrumbsContainer?.classList.toggle("hidden", !this.breadcrumbsVisible);
+        this.updateVisibility(relayout);
+    }
+    updateVisibility(relayout) {
+        if (!this.headerContainer || !this.actionsContainer || !this.primaryActionsContainer || !this.secondaryActionsContainer || !this.layoutActionsContainer) {
+            if (relayout) {
+                this.groupView.relayout();
+            }
+            return;
+        }
+        const hasPrimaryActions = (this.primaryActionsToolbar?.getItemsLength() ?? 0) > 0;
+        const hasSecondaryActions = (this.secondaryActionsToolbar?.getItemsLength() ?? 0) > 0;
+        const hasLayoutActions = (this.layoutActionsToolbar?.getItemsLength() ?? 0) > 0;
+        const hasMenuActions = hasPrimaryActions || hasSecondaryActions || hasLayoutActions;
+        this.primaryActionsContainer.style.display = hasPrimaryActions ? "" : "none";
+        this.secondaryActionsContainer.style.display = hasSecondaryActions ? "" : "none";
+        this.secondaryActionsContainer.style.marginLeft = hasPrimaryActions ? "var(--vscode-spacing-size80, 8px)" : "";
+        this.layoutActionsContainer.style.display = hasLayoutActions ? "" : "none";
+        this.layoutActionsContainer.style.marginLeft = hasSecondaryActions && hasLayoutActions ? "var(--vscode-spacing-size40, 4px)" : "";
+        this.actionsContainer.style.display = hasMenuActions ? "" : "none";
+        this.actionsContainer.style.flex = this.breadcrumbsVisible ? "0 1 auto" : "1 1 auto";
+        this.actionsContainer.style.gridTemplateColumns = this.breadcrumbsVisible ? "auto auto auto" : "minmax(0, 1fr) auto auto";
+        this.visible = this.breadcrumbsVisible || hasMenuActions || this.reserveHeaderSpace?.(this.groupView.activeEditor ?? undefined) === true;
+        this.headerContainer.style.display = this.visible ? "" : "none";
+        if (relayout) {
+            this.groupView.relayout();
+        }
+    }
+    renderActions(relayout) {
+        if (!this.primaryActionsContainer || !this.secondaryActionsContainer || !this.layoutActionsContainer) {
+            return;
+        }
+        this.headerActions.clear();
+        this.primaryActionsToolbar = undefined;
+        this.secondaryActionsToolbar = undefined;
+        this.layoutActionsToolbar = undefined;
+        reset(this.primaryActionsContainer);
+        reset(this.secondaryActionsContainer);
+        reset(this.layoutActionsContainer);
+        const headerPrimaryMenuId = this.menuIds?.headerPrimary;
+        const headerSecondaryMenuId = this.menuIds?.headerSecondary;
+        const headerLayoutMenuId = this.menuIds?.headerLayout;
+        if (!headerPrimaryMenuId && !headerSecondaryMenuId && !headerLayoutMenuId) {
+            this.updateVisibility(relayout);
+            return;
+        }
+        const store = ( new DisposableStore());
+        const scopedInstantiationService = this.groupView.activeEditorPane?.scopedInstantiationService ?? this.instantiationService;
+        const createToolbarOptions = (ariaLabel, trailingSeparator = false) => ({
+            ariaLabel,
+            trailingSeparator,
+            menuOptions: {
+                arg: EditorResourceAccessor.getOriginalUri(this.groupView.activeEditor, {
+                    supportSideBySide: SideBySideEditor.PRIMARY
+                }),
+                shouldForwardArgs: true
+            },
+            highlightToggledItems: true,
+            toolbarOptions: {
+                primaryGroup: group => !group.startsWith("secondary/"),
+                useSeparatorsInPrimaryActions: true
+            }
+        });
+        if (headerPrimaryMenuId) {
+            this.primaryActionsToolbar = store.add(scopedInstantiationService.createInstance(
+                MenuWorkbenchToolBar,
+                this.primaryActionsContainer,
+                headerPrimaryMenuId,
+                createToolbarOptions(( localize(3969, "Editor primary actions")))
+            ));
+            store.add(
+                this.primaryActionsToolbar.onDidChangeMenuItems(() => this.updateVisibility(true))
+            );
+        }
+        if (headerLayoutMenuId) {
+            this.layoutActionsToolbar = store.add(scopedInstantiationService.createInstance(
+                MenuWorkbenchToolBar,
+                this.layoutActionsContainer,
+                headerLayoutMenuId,
+                createToolbarOptions(( localize(3970, "Editor layout actions")))
+            ));
+            store.add(
+                this.layoutActionsToolbar.onDidChangeMenuItems(() => this.renderActions(true))
+            );
+        }
+        if (headerSecondaryMenuId) {
+            const hasLayoutActions = (this.layoutActionsToolbar?.getItemsLength() ?? 0) > 0;
+            this.secondaryActionsToolbar = store.add(scopedInstantiationService.createInstance(
+                MenuWorkbenchToolBar,
+                this.secondaryActionsContainer,
+                headerSecondaryMenuId,
+                createToolbarOptions(( localize(3971, "Editor actions")), hasLayoutActions)
+            ));
+            store.add(
+                this.secondaryActionsToolbar.onDidChangeMenuItems(() => this.updateVisibility(true))
+            );
+        }
+        this.headerActions.value = store;
+        this.updateVisibility(relayout);
+    }
+};
+EditorHeaderControl = EditorHeaderControl_1 = ( __decorate([( __param(6, IInstantiationService))], EditorHeaderControl));
+
+export { EditorHeaderControl };

package/vscode/src/vs/workbench/browser/parts/editor/editorPanes.js

@@ -144,7 +144,7 @@ let EditorPanes = class EditorPanes extends Disposable {
             }
         }
         if (!message) {
-            message = ( localize(3692, "Unable to open '{0}'", editor.getName()));
+            message = ( localize(3972, "Unable to open '{0}'", editor.getName()));
         }
         const buttons = [];
         if (errorActions && errorActions.length > 0) {
@@ -156,7 +156,7 @@ let EditorPanes = class EditorPanes extends Disposable {
             }
         } else {
             buttons.push({
-                label: ( localize(3693, "&&OK")),
+                label: ( localize(3973, "&&OK")),
                 run: () => undefined
             });
         }

package/vscode/src/vs/workbench/browser/parts/editor/editorPart.d.ts

@@ -94,9 +94,9 @@ export declare class EditorPart extends Part<IEditorPartMemento> implements IEdi
     get contentDimension(): Dimension;
     private _contentRightInset;
     /**
-     * Reserves an inset (px) on the right of the editor content of the group(s) at the
-     * right edge of the editor part, while the title stays full width, so a docked panel
-     * can sit beside the editor content under one full-width tab bar. Only the right-edge
+     * Reserves an inset (px) on the right of the editor header and content of the group(s)
+     * at the right edge of the editor part, while tabs stay full width, so a docked panel
+     * can sit beside the editor under one full-width tab bar. Only the right-edge
      * groups (no neighbor to the right) are inset; interior groups in a split layout keep
      * full-width content. Recomputed when the group topology changes. `0` (default)
      * restores full-width content for all groups.
@@ -150,6 +150,11 @@ export declare class EditorPart extends Part<IEditorPartMemento> implements IEdi
     private isTwoDimensionalGrid;
     addGroup(location: IEditorGroupView | GroupIdentifier, direction: GroupDirection, groupToCopy?: IEditorGroupView): IEditorGroupView;
     private getSplitSizingStyle;
+    /**
+     * Base {@link IEditorGroupViewOptions} applied to every group this part creates.
+     * Subclasses override to configure part-wide group behavior (e.g. header menus).
+     */
+    protected getGroupViewOptions(): IEditorGroupViewOptions | undefined;
     private doCreateGroupView;
     private doSetGroupActive;
     private doRestoreGroup;
@@ -189,13 +194,6 @@ export declare class EditorPart extends Part<IEditorPartMemento> implements IEdi
     private get isEmpty();
     setBoundarySashes(sashes: IBoundarySashes): void;
     layout(width: number, height: number, top: number, left: number): void;
-    /**
-     * Returns the top and bottom margins (in pixels) to subtract from the editor height
-     * when the floating panels experiment is active. Accounts for panel position (a top
-     * panel pushes the editor down) and status bar visibility (hidden status bar means
-     * the editor is at the window bottom edge and gets a doubled bottom margin).
-     */
-    private getFloatingPanelHeightInsets;
     private doLayout;
     protected saveState(): void;
     protected loadState(): IEditorPartUIState | undefined;

package/vscode/src/vs/workbench/browser/parts/editor/editorPart.js

@@ -32,7 +32,7 @@ import { EditorDropTarget } from './editorDropTarget.js';
 import { Color } from '../../../../base/common/color.js';
 import { CenteredViewLayout } from '../../../../base/browser/ui/centered/centeredViewLayout.js';
 import { onUnexpectedError } from '../../../../base/common/errors.js';
-import { Parts, Position, getFloatingOuterEdgeOwners, FLOATING_PANEL_MARGIN } from '../../../services/layout/browser/layoutService.js';
+import { Parts, Position, getFloatingOuterEdgeOwners, getFloatingEditorVerticalOuterEdges, getFloatingPaneCompositeHorizontalMargins, getFloatingEditorVerticalMargins } from '../../../services/layout/browser/layoutService.js';
 import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.service.js';
 import { assertType } from '../../../../base/common/types.js';
 import { CompositeDragAndDropObserver } from '../../dnd.js';
@@ -538,7 +538,14 @@ let EditorPart = class EditorPart extends Part {
             return Sizing.Auto;
         }
     }
+    getGroupViewOptions() {
+        return undefined;
+    }
     doCreateGroupView(from, options) {
+        const resolvedOptions = {
+            ...this.getGroupViewOptions(),
+            ...options
+        };
         let groupView;
         if (from instanceof EditorGroupView) {
             groupView = EditorGroupView.createCopy(
@@ -548,7 +555,7 @@ let EditorPart = class EditorPart extends Part {
                 this.groupsLabel,
                 this.count,
                 this.scopedInstantiationService,
-                options
+                resolvedOptions
             );
         } else if (isSerializedEditorGroupModel(from)) {
             groupView = EditorGroupView.createFromSerialized(
@@ -558,7 +565,7 @@ let EditorPart = class EditorPart extends Part {
                 this.groupsLabel,
                 this.count,
                 this.scopedInstantiationService,
-                options
+                resolvedOptions
             );
         } else {
             groupView = EditorGroupView.createNew(
@@ -567,7 +574,7 @@ let EditorPart = class EditorPart extends Part {
                 this.groupsLabel,
                 this.count,
                 this.scopedInstantiationService,
-                options
+                resolvedOptions
             );
         }
         this.groupViews.set(groupView.id, groupView);
@@ -714,7 +721,9 @@ let EditorPart = class EditorPart extends Part {
         }
         else {
             movedView = targetView.groupsView.addGroup(targetView, direction, sourceView);
-            sourceView.closeAllEditors();
+            sourceView.closeAllEditors({
+                force: true
+            });
             this.removeGroup(sourceView, restoreFocus);
         }
         if (restoreFocus) {
@@ -1114,36 +1123,36 @@ let EditorPart = class EditorPart extends Part {
             const owners = getFloatingOuterEdgeOwners(this.layoutService);
             const outerLeft = owners.left === Parts.EDITOR_PART;
             const outerRight = owners.right === Parts.EDITOR_PART;
-            const leftMargin = outerLeft ? FLOATING_PANEL_MARGIN * 2 : FLOATING_PANEL_MARGIN;
-            const rightMargin = outerRight ? FLOATING_PANEL_MARGIN * 2 : FLOATING_PANEL_MARGIN;
+            const verticalOuterEdges = getFloatingEditorVerticalOuterEdges(this.layoutService);
+            const {
+                left: leftMargin,
+                right: rightMargin
+            } = getFloatingPaneCompositeHorizontalMargins(this.layoutService, Parts.EDITOR_PART);
             width = Math.max(0, width - leftMargin - rightMargin);
             const {
-                topMargin,
-                bottomMargin
-            } = this.getFloatingPanelHeightInsets();
-            height = Math.max(0, height - topMargin - bottomMargin);
+                top,
+                bottom
+            } = getFloatingEditorVerticalMargins(this.layoutService, mainWindow);
+            height = Math.max(0, height - top - bottom);
             if (!this.element.classList.contains("modal-editor-part")) {
                 width = Math.max(0, width - EDITOR_FRAME_BORDER_WIDTH * 2);
                 height = Math.max(0, height - EDITOR_FRAME_BORDER_WIDTH * 2);
             }
             this.element.classList.toggle("floating-editor-outer-left", outerLeft);
             this.element.classList.toggle("floating-editor-outer-right", outerRight);
+            this.element.classList.toggle("floating-editor-outer-top", verticalOuterEdges.top);
+            this.element.classList.toggle("floating-editor-outer-bottom", verticalOuterEdges.bottom);
         } else {
-            this.element.classList.remove("floating-editor-outer-left", "floating-editor-outer-right");
+            this.element.classList.remove(
+                "floating-editor-outer-left",
+                "floating-editor-outer-right",
+                "floating-editor-outer-top",
+                "floating-editor-outer-bottom"
+            );
         }
         const contentAreaSize = super.layoutContents(width, height).contentSize;
         this.doLayout(Dimension.lift(contentAreaSize), top, left);
     }
-    getFloatingPanelHeightInsets() {
-        const panelVisible = this.layoutService.isVisible(Parts.PANEL_PART);
-        const panelAtTop = panelVisible && this.layoutService.getPanelPosition() === Position.TOP;
-        const panelAtBottom = panelVisible && this.layoutService.getPanelPosition() === Position.BOTTOM;
-        const bottomMargin = !this.layoutService.isVisible(Parts.STATUSBAR_PART, mainWindow) && !panelAtBottom ? FLOATING_PANEL_MARGIN * 2 : FLOATING_PANEL_MARGIN;
-        return {
-            topMargin: panelAtTop ? FLOATING_PANEL_MARGIN : 0,
-            bottomMargin
-        };
-    }
     doLayout(dimension, top = this.top, left = this.left) {
         this._contentDimension = dimension;
         this.centeredLayoutWidget.layout(this._contentDimension.width, this._contentDimension.height, top, left);
@@ -1215,7 +1224,8 @@ let EditorPart = class EditorPart extends Part {
         const groups = this.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE);
         for (const group of groups) {
             await group.closeAllEditors({
-                excludeConfirming: true
+                excludeConfirming: true,
+                force: true
             });
         }
         return groups;

package/vscode/src/vs/workbench/browser/parts/editor/editorParts.d.ts

@@ -46,6 +46,7 @@ export declare class EditorParts extends MultiWindowParts<EditorPart, IEditorPar
     private readonly contextKeyService;
     readonly _serviceBrand: undefined;
     readonly mainPart: MainEditorPart;
+    private readonly modalEditorVisibleContext;
     private mostRecentActiveParts;
     constructor(instantiationService: IInstantiationService, storageService: IStorageService, themeService: IThemeService, auxiliaryWindowService: IAuxiliaryWindowService, contextKeyService: IContextKeyService);
     private registerListeners;
@@ -63,7 +64,9 @@ export declare class EditorParts extends MultiWindowParts<EditorPart, IEditorPar
     private modalEditorPosition;
     private modalEditorSidebarWidth;
     private modalEditorSidebarHidden;
+    private modalEditorPartCreatePromise;
     createModalEditorPart(options?: IModalEditorPartOptions): Promise<IModalEditorPart>;
+    private doCreateModalEditorPart;
     registerPart(part: EditorPart): IDisposable;
     protected unregisterPart(part: EditorPart): void;
     private registerEditorPartListeners;

package/vscode/src/vs/workbench/browser/parts/editor/editorParts.js

@@ -23,6 +23,7 @@ import { ServiceCollection } from '../../../../platform/instantiation/common/ser
 import { IEditorService } from '../../../services/editor/common/editorService.service.js';
 import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.service.js';
 import { mainWindow } from '../../../../base/browser/window.js';
+import { EditorPartModalVisibleContext } from '../../../common/contextkeys.js';
 
 var EditorParts_1;
 let EditorParts = class EditorParts extends MultiWindowParts {
@@ -73,6 +74,7 @@ let EditorParts = class EditorParts extends MultiWindowParts {
         this.contextKeyProviders = ( new Map());
         this.registeredContextKeys = ( new Map());
         this.contextKeyProviderDisposables = this._register(( new DisposableMap()));
+        this.modalEditorVisibleContext = EditorPartModalVisibleContext.bindTo(this.contextKeyService);
         this.editorWorkingSets = (() => {
             const workingSetsRaw = this.storageService.get(EditorParts_1.EDITOR_WORKING_SETS_STORAGE_KEY, StorageScope.WORKSPACE);
             if (workingSetsRaw) {
@@ -150,21 +152,41 @@ let EditorParts = class EditorParts extends MultiWindowParts {
             this.modalEditorPart.updateOptions(options);
             return this.modalEditorPart;
         }
+        if (this.modalEditorPartCreatePromise) {
+            const part = await this.modalEditorPartCreatePromise;
+            part.updateOptions(options);
+            return part;
+        }
+        const createPromise = this.doCreateModalEditorPart(options).finally(() => {
+            this.modalEditorPartCreatePromise = undefined;
+        });
+        this.modalEditorPartCreatePromise = createPromise;
+        return createPromise;
+    }
+    async doCreateModalEditorPart(options) {
+        this.modalEditorVisibleContext.set(true);
+        let result;
+        try {
+            result = await this.instantiationService.createInstance(ModalEditorPart, this).create({
+                ...options,
+                maximized: options?.maximized ?? this.modalEditorMaximized,
+                size: options?.size ?? this.modalEditorSize,
+                position: options?.position ?? this.modalEditorPosition,
+                sidebar: options?.sidebar ? {
+                    ...options.sidebar,
+                    sidebarWidth: options.sidebar.sidebarWidth ?? this.modalEditorSidebarWidth,
+                    sidebarHidden: options.sidebar.sidebarHidden ?? this.modalEditorSidebarHidden
+                } : undefined
+            });
+        } catch (error) {
+            this.modalEditorVisibleContext.set(false);
+            throw error;
+        }
         const {
             part,
             instantiationService,
             disposables
-        } = await this.instantiationService.createInstance(ModalEditorPart, this).create({
-            ...options,
-            maximized: options?.maximized ?? this.modalEditorMaximized,
-            size: options?.size ?? this.modalEditorSize,
-            position: options?.position ?? this.modalEditorPosition,
-            sidebar: options?.sidebar ? {
-                ...options.sidebar,
-                sidebarWidth: options.sidebar.sidebarWidth ?? this.modalEditorSidebarWidth,
-                sidebarHidden: options.sidebar.sidebarHidden ?? this.modalEditorSidebarHidden
-            } : undefined
-        });
+        } = result;
         this.modalEditorPart = part;
         this.modalPartInstantiationService = instantiationService;
         disposables.add(toDisposable(() => {
@@ -177,6 +199,7 @@ let EditorParts = class EditorParts extends MultiWindowParts {
             }
             this.modalPartInstantiationService = undefined;
             this.modalEditorPart = undefined;
+            this.modalEditorVisibleContext.set(false);
         }));
         this._onDidAddGroup.fire(part.activeGroup);
         return part;
@@ -241,7 +264,7 @@ let EditorParts = class EditorParts extends MultiWindowParts {
         }
     }
     getGroupsLabel(index) {
-        return localize(3694, "Window {0}", index + 1);
+        return localize(3974, "Window {0}", index + 1);
     }
     getPartByDocument(document) {
         const mruParts = this.mostRecentActiveParts;
@@ -396,7 +419,8 @@ let EditorParts = class EditorParts extends MultiWindowParts {
             }
             for (const group of part.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE)) {
                 await group.closeAllEditors({
-                    excludeConfirming: true
+                    excludeConfirming: true,
+                    force: true
                 });
             }
             const closed = part.close();