@codingame/monaco-vscode-api 1.83.16 → 1.85.0-next.0

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

@@ -1,7 +1,7 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import './media/editorstatus.css.js';
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { runAtThisOrScheduleAtNextAnimationFrame } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { runAtThisOrScheduleAtNextAnimationFrame, getWindowById } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { format, splitLines, compare } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { extname, basename, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { areFunctions, assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
@@ -44,6 +44,9 @@ import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/
 import { Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
 import { TabFocus } from 'monaco-editor/esm/vs/editor/browser/config/tabFocus.js';
+import { mainWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
 var ShowLanguageExtensionsAction_1;
 class SideBySideEditorEncodingSupport {
     constructor(primary, secondary) {
@@ -257,8 +260,9 @@ const nlsEOLCRLF = ( localizeWithPath(
     "CRLF"
 ));
 let EditorStatus = class EditorStatus extends Disposable {
-    constructor(editorService, quickInputService, languageService, textFileService, statusbarService, instantiationService, configurationService) {
+    constructor(targetWindowId, editorService, quickInputService, languageService, textFileService, statusbarService, instantiationService, configurationService) {
         super();
+        this.targetWindowId = targetWindowId;
         this.editorService = editorService;
         this.quickInputService = quickInputService;
         this.languageService = languageService;
@@ -278,8 +282,8 @@ let EditorStatus = class EditorStatus extends Disposable {
         this.state = ( new State());
         this.activeEditorListeners = this._register(( new DisposableStore()));
         this.delayedRender = this._register(( new MutableDisposable()));
-        this.toRender = null;
-        this.tabFocusMode = instantiationService.createInstance(TabFocusMode);
+        this.tabFocusMode = this.instantiationService.createInstance(TabFocusMode);
+        this.toRender = undefined;
         this.registerCommands();
         this.registerListeners();
     }
@@ -557,12 +561,12 @@ let EditorStatus = class EditorStatus extends Disposable {
         }
         if (!this.toRender) {
             this.toRender = changed;
-            this.delayedRender.value = runAtThisOrScheduleAtNextAnimationFrame(() => {
+            this.delayedRender.value = runAtThisOrScheduleAtNextAnimationFrame(getWindowById(this.targetWindowId)?.window ?? mainWindow, () => {
                 this.delayedRender.clear();
                 const toRender = this.toRender;
-                this.toRender = null;
+                this.toRender = undefined;
                 if (toRender) {
-                    this.doRenderNow(toRender);
+                    this.doRenderNow();
                 }
             });
         }
@@ -570,7 +574,7 @@ let EditorStatus = class EditorStatus extends Disposable {
             this.toRender.combine(changed);
         }
     }
-    doRenderNow(changed) {
+    doRenderNow() {
         this.updateTabFocusModeElement(!!this.state.tabFocusMode);
         this.updateColumnSelectionModeElement(!!this.state.columnSelectionMode);
         this.updateIndentationElement(this.state.indentation);
@@ -806,14 +810,29 @@ let EditorStatus = class EditorStatus extends Disposable {
     }
 };
 EditorStatus = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IQuickInputService)),
-    ( __param(2, ILanguageService)),
-    ( __param(3, ITextFileService)),
-    ( __param(4, IStatusbarService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IConfigurationService))
+    ( __param(1, IEditorService)),
+    ( __param(2, IQuickInputService)),
+    ( __param(3, ILanguageService)),
+    ( __param(4, ITextFileService)),
+    ( __param(5, IStatusbarService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IConfigurationService))
 ], EditorStatus));
+let EditorStatusContribution = class EditorStatusContribution extends Disposable {
+    constructor(instantiationService, editorGroupService, editorService) {
+        super();
+        const mainInstantiationService = instantiationService.createChild(( new ServiceCollection([IEditorService, editorService.createScoped('main', this._store)])));
+        this._register(mainInstantiationService.createInstance(EditorStatus, mainWindow.vscodeWindowId));
+        this._register(editorGroupService.onDidCreateAuxiliaryEditorPart(({ part, instantiationService, disposables }) => {
+            disposables.add(instantiationService.createInstance(EditorStatus, part.windowId));
+        }));
+    }
+};
+EditorStatusContribution = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, IEditorService))
+], EditorStatusContribution));
 let ShowCurrentMarkerInStatusbarContribution = class ShowCurrentMarkerInStatusbarContribution extends Disposable {
     constructor(statusbarService, markerService, configurationService) {
         super();
@@ -1406,4 +1425,4 @@ class ChangeEncodingAction extends Action2 {
         activeTextEditorControl.focus();
     }
 }
-export { ChangeEOLAction, ChangeEncodingAction, ChangeLanguageAction, EditorStatus, ShowLanguageExtensionsAction };
+export { ChangeEOLAction, ChangeEncodingAction, ChangeLanguageAction, EditorStatusContribution, ShowLanguageExtensionsAction };

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

@@ -0,0 +1,348 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/editortabscontrol.css.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { DataTransfers, applyDragImage } from 'monaco-editor/esm/vs/base/browser/dnd.js';
+import { getWindow, isMouseEvent } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
+import { prepareActions } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { listActiveSelectionBackground, listActiveSelectionForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { DraggedEditorGroupIdentifier, isWindowDraggedOver, fillEditorsDragData } from '../../dnd.js';
+import { EditorPane } from './editorPane.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { ResourceContextKey, ActiveEditorPinnedContext, ActiveEditorFirstInGroupContext, ActiveEditorLastInGroupContext, ActiveEditorStickyContext, ActiveEditorAvailableEditorIdsContext, ActiveEditorCanSplitInGroupContext, SideBySideEditorActiveContext, ActiveEditorGroupLockedContext, applyAvailableEditorIds } from '../../../common/contextkeys.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { isFirefox } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
+import { WorkbenchToolBar } from 'monaco-editor/esm/vs/platform/actions/browser/toolbar.js';
+import { LocalSelectionTransfer } from 'monaco-editor/esm/vs/platform/dnd/browser/dnd.js';
+import { IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
+import { EDITOR_CORE_NAVIGATION_COMMANDS } from './editorCommands.js';
+import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+var EditorTabsControl_1;
+class EditorCommandsContextActionRunner extends ActionRunner {
+    constructor(context) {
+        super();
+        this.context = context;
+    }
+    run(action, context) {
+        let mergedContext = this.context;
+        if (context?.preserveFocus) {
+            mergedContext = {
+                ...this.context,
+                preserveFocus: true
+            };
+        }
+        return super.run(action, mergedContext);
+    }
+}
+let EditorTabsControl = class EditorTabsControl extends Themable {
+    static { EditorTabsControl_1 = this; }
+    static { this.EDITOR_TAB_HEIGHT = {
+        normal: 35,
+        compact: 22
+    }; }
+    constructor(parent, editorPartsView, groupsView, groupView, tabsModel, contextMenuService, instantiationService, contextKeyService, keybindingService, notificationService, quickInputService, themeService, editorResolverService, hostService) {
+        super(themeService);
+        this.parent = parent;
+        this.editorPartsView = editorPartsView;
+        this.groupsView = groupsView;
+        this.groupView = groupView;
+        this.tabsModel = tabsModel;
+        this.contextMenuService = contextMenuService;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.keybindingService = keybindingService;
+        this.notificationService = notificationService;
+        this.quickInputService = quickInputService;
+        this.editorResolverService = editorResolverService;
+        this.hostService = hostService;
+        this.editorTransfer = LocalSelectionTransfer.getInstance();
+        this.groupTransfer = LocalSelectionTransfer.getInstance();
+        this.treeItemsTransfer = LocalSelectionTransfer.getInstance();
+        this.editorActionsToolbarDisposables = this._register(( new DisposableStore()));
+        this.editorActionsDisposables = this._register(( new DisposableStore()));
+        this.resourceContext = this._register(instantiationService.createInstance(ResourceContextKey));
+        this.editorPinnedContext = ActiveEditorPinnedContext.bindTo(contextKeyService);
+        this.editorIsFirstContext = ActiveEditorFirstInGroupContext.bindTo(contextKeyService);
+        this.editorIsLastContext = ActiveEditorLastInGroupContext.bindTo(contextKeyService);
+        this.editorStickyContext = ActiveEditorStickyContext.bindTo(contextKeyService);
+        this.editorAvailableEditorIds = ActiveEditorAvailableEditorIdsContext.bindTo(this.contextKeyService);
+        this.editorCanSplitInGroupContext = ActiveEditorCanSplitInGroupContext.bindTo(contextKeyService);
+        this.sideBySideEditorContext = SideBySideEditorActiveContext.bindTo(contextKeyService);
+        this.groupLockedContext = ActiveEditorGroupLockedContext.bindTo(contextKeyService);
+        this.renderDropdownAsChildElement = false;
+        this.create(parent);
+    }
+    create(parent) {
+        this.updateTabHeight();
+    }
+    get editorActionsEnabled() {
+        return this.groupsView.partOptions.editorActionsLocation === 'default' && this.groupsView.partOptions.showTabs !== 'none';
+    }
+    createEditorActionsToolBar(parent, classes) {
+        this.editorActionsToolbarContainer = document.createElement('div');
+        this.editorActionsToolbarContainer.classList.add(...classes);
+        parent.appendChild(this.editorActionsToolbarContainer);
+        this.handleEditorActionToolBarVisibility(this.editorActionsToolbarContainer);
+    }
+    handleEditorActionToolBarVisibility(container) {
+        const editorActionsEnabled = this.editorActionsEnabled;
+        const editorActionsVisible = !!this.editorActionsToolbar;
+        if (editorActionsEnabled && !editorActionsVisible) {
+            this.doCreateEditorActionsToolBar(container);
+        }
+        else if (!editorActionsEnabled && editorActionsVisible) {
+            this.editorActionsToolbar?.getElement().remove();
+            this.editorActionsToolbar = undefined;
+            this.editorActionsToolbarDisposables.clear();
+            this.editorActionsDisposables.clear();
+        }
+        container.classList.toggle('hidden', !editorActionsEnabled);
+    }
+    doCreateEditorActionsToolBar(container) {
+        const context = { groupId: this.groupView.id };
+        this.editorActionsToolbar = this.editorActionsToolbarDisposables.add(this.instantiationService.createInstance(WorkbenchToolBar, container, {
+            actionViewItemProvider: action => this.actionViewItemProvider(action),
+            orientation: 0 ,
+            ariaLabel: ( localizeWithPath(
+                'vs/workbench/browser/parts/editor/editorTabsControl',
+                'ariaLabelEditorActions',
+                "Editor actions"
+            )),
+            getKeyBinding: action => this.getKeybinding(action),
+            actionRunner: this.editorActionsToolbarDisposables.add(( new EditorCommandsContextActionRunner(context))),
+            anchorAlignmentProvider: () => 1 ,
+            renderDropdownAsChildElement: this.renderDropdownAsChildElement,
+            telemetrySource: 'editorPart',
+            resetMenu: MenuId.EditorTitle,
+            overflowBehavior: { maxItems: 9, exempted: EDITOR_CORE_NAVIGATION_COMMANDS },
+            highlightToggledItems: true
+        }));
+        this.editorActionsToolbar.context = context;
+        this.editorActionsToolbarDisposables.add(this.editorActionsToolbar.actionRunner.onDidRun(e => {
+            if (e.error && !isCancellationError(e.error)) {
+                this.notificationService.error(e.error);
+            }
+        }));
+    }
+    actionViewItemProvider(action) {
+        const activeEditorPane = this.groupView.activeEditorPane;
+        if (activeEditorPane instanceof EditorPane) {
+            const result = activeEditorPane.getActionViewItem(action);
+            if (result) {
+                return result;
+            }
+        }
+        return createActionViewItem(this.instantiationService, action, { menuAsChild: this.renderDropdownAsChildElement });
+    }
+    updateEditorActionsToolbar() {
+        if (!this.editorActionsEnabled) {
+            return;
+        }
+        this.editorActionsDisposables.clear();
+        const editorActions = this.groupView.createEditorActions(this.editorActionsDisposables);
+        this.editorActionsDisposables.add(editorActions.onDidChange(() => this.updateEditorActionsToolbar()));
+        const editorActionsToolbar = assertIsDefined(this.editorActionsToolbar);
+        const { primary, secondary } = this.prepareEditorActions(editorActions.actions);
+        editorActionsToolbar.setActions(prepareActions(primary), prepareActions(secondary));
+    }
+    getEditorPaneAwareContextKeyService() {
+        return this.groupView.activeEditorPane?.scopedContextKeyService ?? this.contextKeyService;
+    }
+    clearEditorActionsToolbar() {
+        if (!this.editorActionsEnabled) {
+            return;
+        }
+        const editorActionsToolbar = assertIsDefined(this.editorActionsToolbar);
+        editorActionsToolbar.setActions([], []);
+    }
+    onGroupDragStart(e, element) {
+        if (e.target !== element) {
+            return;
+        }
+        this.groupTransfer.setData([( new DraggedEditorGroupIdentifier(this.groupView.id))], DraggedEditorGroupIdentifier.prototype);
+        if (e.dataTransfer) {
+            e.dataTransfer.effectAllowed = 'copyMove';
+        }
+        let hasDataTransfer = false;
+        if (this.groupsView.partOptions.showTabs === 'multiple') {
+            hasDataTransfer = this.doFillResourceDataTransfers(this.groupView.getEditors(1 ), e);
+        }
+        else {
+            if (this.groupView.activeEditor) {
+                hasDataTransfer = this.doFillResourceDataTransfers([this.groupView.activeEditor], e);
+            }
+        }
+        if (!hasDataTransfer && isFirefox) {
+            e.dataTransfer?.setData(DataTransfers.TEXT, String(this.groupView.label));
+        }
+        if (this.groupView.activeEditor) {
+            let label = this.groupView.activeEditor.getName();
+            if (this.groupsView.partOptions.showTabs === 'multiple' && this.groupView.count > 1) {
+                label = ( localizeWithPath(
+                    'vs/workbench/browser/parts/editor/editorTabsControl',
+                    'draggedEditorGroup',
+                    "{0} (+{1})",
+                    label,
+                    this.groupView.count - 1
+                ));
+            }
+            applyDragImage(e, label, 'monaco-editor-group-drag-image', this.getColor(listActiveSelectionBackground), this.getColor(listActiveSelectionForeground));
+        }
+    }
+    async onGroupDragEnd(e, previousDragEvent, element) {
+        this.groupTransfer.clearData(DraggedEditorGroupIdentifier.prototype);
+        if (e.target !== element ||
+            !this.isNewWindowOperation(previousDragEvent ?? e) ||
+            isWindowDraggedOver()) {
+            return;
+        }
+        const auxiliaryEditorPart = await this.maybeCreateAuxiliaryEditorPartAt(e, element);
+        if (!auxiliaryEditorPart) {
+            return;
+        }
+        const targetGroup = auxiliaryEditorPart.activeGroup;
+        this.groupsView.mergeGroup(this.groupView, targetGroup.id, {
+            mode: this.isMoveOperation(previousDragEvent ?? e, targetGroup.id) ? 1  : 0
+        });
+        targetGroup.focus();
+    }
+    async maybeCreateAuxiliaryEditorPartAt(e, offsetElement) {
+        const { point, display } = (await this.hostService.getCursorScreenPoint()) ?? { point: { x: e.screenX, y: e.screenY } };
+        const window = getWindow(e);
+        if (window.document.visibilityState === 'visible') {
+            if (point.x >= window.screenX && point.x <= window.screenX + window.outerWidth && point.y >= window.screenY && point.y <= window.screenY + window.outerHeight) {
+                return;
+            }
+        }
+        const offsetX = offsetElement.offsetWidth / 2;
+        const offsetY = 30  + offsetElement.offsetHeight / 2;
+        const bounds = {
+            x: point.x - offsetX,
+            y: point.y - offsetY
+        };
+        if (display) {
+            if (bounds.x < display.x) {
+                bounds.x = display.x;
+            }
+            if (bounds.y < display.y) {
+                bounds.y = display.y;
+            }
+        }
+        return this.editorPartsView.createAuxiliaryEditorPart({ bounds });
+    }
+    isNewWindowOperation(e) {
+        if (this.groupsView.partOptions.dragToOpenWindow) {
+            return !e.altKey;
+        }
+        return e.altKey;
+    }
+    isMoveOperation(e, sourceGroup, sourceEditor) {
+        if (sourceEditor?.hasCapability(8 )) {
+            return true;
+        }
+        const isCopy = (e.ctrlKey && !isMacintosh) || (e.altKey && isMacintosh);
+        return (!isCopy || sourceGroup === this.groupView.id);
+    }
+    doFillResourceDataTransfers(editors, e) {
+        if (editors.length) {
+            this.instantiationService.invokeFunction(fillEditorsDragData, ( editors.map(editor => ({ editor, groupId: this.groupView.id }))), e, { disableStandardTransfer: this.isNewWindowOperation(e) });
+            return true;
+        }
+        return false;
+    }
+    onTabContextMenu(editor, e, node) {
+        const currentResourceContext = this.resourceContext.get();
+        this.resourceContext.set(EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY } ?? null));
+        const currentPinnedContext = !!this.editorPinnedContext.get();
+        this.editorPinnedContext.set(this.tabsModel.isPinned(editor));
+        const currentEditorIsFirstContext = !!this.editorIsFirstContext.get();
+        this.editorIsFirstContext.set(this.tabsModel.isFirst(editor));
+        const currentEditorIsLastContext = !!this.editorIsLastContext.get();
+        this.editorIsLastContext.set(this.tabsModel.isLast(editor));
+        const currentStickyContext = !!this.editorStickyContext.get();
+        this.editorStickyContext.set(this.tabsModel.isSticky(editor));
+        const currentGroupLockedContext = !!this.groupLockedContext.get();
+        this.groupLockedContext.set(this.tabsModel.isLocked);
+        const currentEditorCanSplitContext = !!this.editorCanSplitInGroupContext.get();
+        this.editorCanSplitInGroupContext.set(editor.hasCapability(32 ));
+        const currentSideBySideEditorContext = !!this.sideBySideEditorContext.get();
+        this.sideBySideEditorContext.set(editor.typeId === SideBySideEditorInput.ID);
+        const currentEditorAvailableEditorIds = this.editorAvailableEditorIds.get() ?? '';
+        applyAvailableEditorIds(this.editorAvailableEditorIds, editor, this.editorResolverService);
+        let anchor = node;
+        if (isMouseEvent(e)) {
+            anchor = ( new StandardMouseEvent(getWindow(node), e));
+        }
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => anchor,
+            menuId: MenuId.EditorTitleContext,
+            menuActionOptions: { shouldForwardArgs: true, arg: this.resourceContext.get() },
+            contextKeyService: this.contextKeyService,
+            getActionsContext: () => ({ groupId: this.groupView.id, editorIndex: this.groupView.getIndexOfEditor(editor) }),
+            getKeyBinding: action => this.getKeybinding(action),
+            onHide: () => {
+                this.resourceContext.set(currentResourceContext || null);
+                this.editorPinnedContext.set(currentPinnedContext);
+                this.editorIsFirstContext.set(currentEditorIsFirstContext);
+                this.editorIsLastContext.set(currentEditorIsLastContext);
+                this.editorStickyContext.set(currentStickyContext);
+                this.groupLockedContext.set(currentGroupLockedContext);
+                this.editorCanSplitInGroupContext.set(currentEditorCanSplitContext);
+                this.sideBySideEditorContext.set(currentSideBySideEditorContext);
+                this.editorAvailableEditorIds.set(currentEditorAvailableEditorIds);
+                this.groupsView.activeGroup.focus();
+            }
+        });
+    }
+    getKeybinding(action) {
+        return this.keybindingService.lookupKeybinding(action.id, this.getEditorPaneAwareContextKeyService());
+    }
+    getKeybindingLabel(action) {
+        const keybinding = this.getKeybinding(action);
+        return keybinding ? keybinding.getLabel() ?? undefined : undefined;
+    }
+    get tabHeight() {
+        return this.groupsView.partOptions.tabHeight !== 'compact' ? EditorTabsControl_1.EDITOR_TAB_HEIGHT.normal : EditorTabsControl_1.EDITOR_TAB_HEIGHT.compact;
+    }
+    updateTabHeight() {
+        this.parent.style.setProperty('--editor-group-tab-height', `${this.tabHeight}px`);
+    }
+    updateOptions(oldOptions, newOptions) {
+        if (oldOptions.tabHeight !== newOptions.tabHeight) {
+            this.updateTabHeight();
+        }
+        if (oldOptions.editorActionsLocation !== newOptions.editorActionsLocation ||
+            oldOptions.showTabs !== newOptions.showTabs) {
+            if (this.editorActionsToolbarContainer) {
+                this.handleEditorActionToolBarVisibility(this.editorActionsToolbarContainer);
+                this.updateEditorActionsToolbar();
+            }
+        }
+    }
+};
+EditorTabsControl = EditorTabsControl_1 = ( __decorate([
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IKeybindingService)),
+    ( __param(9, INotificationService)),
+    ( __param(10, IQuickInputService)),
+    ( __param(11, IThemeService)),
+    ( __param(12, IEditorResolverService)),
+    ( __param(13, IHostService))
+], EditorTabsControl));
+export { EditorCommandsContextActionRunner, EditorTabsControl };

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

@@ -35,29 +35,31 @@ let EditorsObserver = class EditorsObserver extends Disposable {
         }
         return arg1;
     }
-    constructor(editorGroupsService, storageService) {
+    constructor(editorGroupsContainer, editorGroupService, storageService) {
         super();
-        this.editorGroupsService = editorGroupsService;
+        this.editorGroupService = editorGroupService;
         this.storageService = storageService;
         this.keyMap = ( new Map());
         this.mostRecentEditorsMap = ( new LinkedMap());
         this.editorsPerResourceCounter = ( new ResourceMap());
         this._onDidMostRecentlyActiveEditorsChange = this._register(( new Emitter()));
         this.onDidMostRecentlyActiveEditorsChange = this._onDidMostRecentlyActiveEditorsChange.event;
+        this.editorGroupsContainer = editorGroupsContainer ?? editorGroupService;
+        this.isScoped = !!editorGroupsContainer;
         this.registerListeners();
+        this.loadState();
     }
     registerListeners() {
+        this._register(this.editorGroupsContainer.onDidAddGroup(group => this.onGroupAdded(group)));
+        this._register(this.editorGroupsContainer.onDidChangeEditorPartOptions(e => this.onDidChangeEditorPartOptions(e)));
         this._register(this.storageService.onWillSaveState(() => this.saveState()));
-        this._register(this.editorGroupsService.onDidAddGroup(group => this.onGroupAdded(group)));
-        this._register(this.editorGroupsService.onDidChangeEditorPartOptions(e => this.onDidChangeEditorPartOptions(e)));
-        this.editorGroupsService.whenReady.then(() => this.loadState());
     }
     onGroupAdded(group) {
         const groupEditorsMru = group.getEditors(0 );
         for (let i = groupEditorsMru.length - 1; i >= 0; i--) {
             this.addMostRecentEditor(group, groupEditorsMru[i], false , true );
         }
-        if (this.editorGroupsService.activeGroup === group && group.activeEditor) {
+        if (this.editorGroupsContainer.activeGroup === group && group.activeEditor) {
             this.addMostRecentEditor(group, group.activeEditor, true , false );
         }
         this.registerGroupListeners(group);
@@ -67,12 +69,12 @@ let EditorsObserver = class EditorsObserver extends Disposable {
         groupDisposables.add(group.onDidModelChange(e => {
             switch (e.kind) {
                 case 0 : {
-                    if (this.editorGroupsService.activeGroup === group && group.activeEditor) {
+                    if (this.editorGroupsContainer.activeGroup === group && group.activeEditor) {
                         this.addMostRecentEditor(group, group.activeEditor, true , false );
                     }
                     break;
                 }
-                case 3 : {
+                case 4 : {
                     if (e.editor) {
                         this.addMostRecentEditor(group, e.editor, false , true );
                         this.ensureOpenedEditorsLimit({ groupId: group.id, editor: e.editor }, group.id);
@@ -86,14 +88,14 @@ let EditorsObserver = class EditorsObserver extends Disposable {
         }));
         groupDisposables.add(group.onDidActiveEditorChange(e => {
             if (e.editor) {
-                this.addMostRecentEditor(group, e.editor, this.editorGroupsService.activeGroup === group, false );
+                this.addMostRecentEditor(group, e.editor, this.editorGroupsContainer.activeGroup === group, false );
             }
         }));
         Event.once(group.onWillDispose)(() => dispose(groupDisposables));
     }
     onDidChangeEditorPartOptions(event) {
         if (!equals(event.newPartOptions.limit, event.oldPartOptions.limit)) {
-            const activeGroup = this.editorGroupsService.activeGroup;
+            const activeGroup = this.editorGroupsContainer.activeGroup;
             let exclude = undefined;
             if (activeGroup.activeEditor) {
                 exclude = { editor: activeGroup.activeEditor, groupId: activeGroup.id };
@@ -191,21 +193,21 @@ let EditorsObserver = class EditorsObserver extends Disposable {
         return key;
     }
     async ensureOpenedEditorsLimit(exclude, groupId) {
-        if (!this.editorGroupsService.partOptions.limit?.enabled ||
-            typeof this.editorGroupsService.partOptions.limit.value !== 'number' ||
-            this.editorGroupsService.partOptions.limit.value <= 0) {
+        if (!this.editorGroupsContainer.partOptions.limit?.enabled ||
+            typeof this.editorGroupsContainer.partOptions.limit.value !== 'number' ||
+            this.editorGroupsContainer.partOptions.limit.value <= 0) {
             return;
         }
-        const limit = this.editorGroupsService.partOptions.limit.value;
-        if (this.editorGroupsService.partOptions.limit?.perEditorGroup) {
+        const limit = this.editorGroupsContainer.partOptions.limit.value;
+        if (this.editorGroupsContainer.partOptions.limit?.perEditorGroup) {
             if (typeof groupId === 'number') {
-                const group = this.editorGroupsService.getGroup(groupId);
+                const group = this.editorGroupsContainer.getGroup(groupId);
                 if (group) {
                     await this.doEnsureOpenedEditorsLimit(limit, ( group.getEditors(0 ).map(editor => ({ editor, groupId }))), exclude);
                 }
             }
             else {
-                for (const group of this.editorGroupsService.groups) {
+                for (const group of this.editorGroupsContainer.groups) {
                     await this.ensureOpenedEditorsLimit(exclude, group.id);
                 }
             }
@@ -216,7 +218,7 @@ let EditorsObserver = class EditorsObserver extends Disposable {
     }
     async doEnsureOpenedEditorsLimit(limit, mostRecentEditors, exclude) {
         let mostRecentEditorsCountingForLimit;
-        if (this.editorGroupsService.partOptions.limit?.excludeDirty) {
+        if (this.editorGroupsContainer.partOptions.limit?.excludeDirty) {
             mostRecentEditorsCountingForLimit = mostRecentEditors.filter(({ editor }) => {
                 if ((editor.isDirty() && !editor.isSaving()) || editor.hasCapability(512 )) {
                     return false;
@@ -237,7 +239,7 @@ let EditorsObserver = class EditorsObserver extends Disposable {
             if (exclude && editor === exclude.editor && groupId === exclude.groupId) {
                 return false;
             }
-            if (this.editorGroupsService.getGroup(groupId)?.isSticky(editor)) {
+            if (this.editorGroupsContainer.getGroup(groupId)?.isSticky(editor)) {
                 return false;
             }
             return true;
@@ -257,13 +259,16 @@ let EditorsObserver = class EditorsObserver extends Disposable {
             }
         }
         for (const [groupId, editors] of mapGroupToEditorsToClose) {
-            const group = this.editorGroupsService.getGroup(groupId);
+            const group = this.editorGroupsContainer.getGroup(groupId);
             if (group) {
                 await group.closeEditors(editors, { preserveFocus: true });
             }
         }
     }
     saveState() {
+        if (this.isScoped) {
+            return;
+        }
         if (this.mostRecentEditorsMap.isEmpty()) {
             this.storageService.remove(EditorsObserver_1.STORAGE_KEY, 1 );
         }
@@ -277,7 +282,7 @@ let EditorsObserver = class EditorsObserver extends Disposable {
         const mapGroupToSerializableEditorsOfGroup = ( new Map());
         return {
             entries: coalesce(( entries.map(({ editor, groupId }) => {
-                const group = this.editorGroupsService.getGroup(groupId);
+                const group = this.editorGroupsContainer.getGroup(groupId);
                 if (!group) {
                     return undefined;
                 }
@@ -297,13 +302,20 @@ let EditorsObserver = class EditorsObserver extends Disposable {
             })))
         };
     }
-    loadState() {
-        const serialized = this.storageService.get(EditorsObserver_1.STORAGE_KEY, 1 );
-        if (serialized) {
-            this.deserialize(JSON.parse(serialized));
+    async loadState() {
+        if (this.editorGroupsContainer === this.editorGroupService.mainPart || this.editorGroupsContainer === this.editorGroupService) {
+            await this.editorGroupService.mainPart.whenReady;
         }
-        else {
-            const groups = this.editorGroupsService.getGroups(1 );
+        let hasRestorableState = false;
+        if (!this.isScoped) {
+            const serialized = this.storageService.get(EditorsObserver_1.STORAGE_KEY, 1 );
+            if (serialized) {
+                hasRestorableState = true;
+                this.deserialize(JSON.parse(serialized));
+            }
+        }
+        if (!hasRestorableState) {
+            const groups = this.editorGroupsContainer.getGroups(1 );
             for (let i = groups.length - 1; i >= 0; i--) {
                 const group = groups[i];
                 const groupEditorsMru = group.getEditors(0 );
@@ -312,14 +324,14 @@ let EditorsObserver = class EditorsObserver extends Disposable {
                 }
             }
         }
-        for (const group of this.editorGroupsService.groups) {
+        for (const group of this.editorGroupsContainer.groups) {
             this.registerGroupListeners(group);
         }
     }
     deserialize(serialized) {
         const mapValues = [];
         for (const { groupId, index } of serialized.entries) {
-            const group = this.editorGroupsService.getGroup(groupId);
+            const group = this.editorGroupsContainer.getGroup(groupId);
             if (!group) {
                 continue;
             }
@@ -335,7 +347,7 @@ let EditorsObserver = class EditorsObserver extends Disposable {
     }
 };
 EditorsObserver = EditorsObserver_1 = ( __decorate([
-    ( __param(0, IEditorGroupsService)),
-    ( __param(1, IStorageService))
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, IStorageService))
 ], EditorsObserver));
 export { EditorsObserver };

package/vscode/src/vs/workbench/browser/parts/editor/media/editortabscontrol.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .part.editor>.content .editor-group-container>.title{cursor:pointer}.monaco-workbench .part.editor>.content .editor-group-container>.title .tabs-container>.tab .tab-label,.monaco-workbench .part.editor>.content .editor-group-container>.title .title-label{flex:1;white-space:nowrap}.monaco-workbench .part.editor>.content .editor-group-container>.title .tabs-container>.tab .tab-label a,.monaco-workbench .part.editor>.content .editor-group-container>.title .title-label a{font-size:13px}.monaco-workbench .part.editor>.content .editor-group-container>.title .monaco-icon-label:before,.monaco-workbench .part.editor>.content .editor-group-container>.title .tabs-container>.tab .monaco-icon-label:before,.monaco-workbench .part.editor>.content .editor-group-container>.title .tabs-container>.tab .tab-label a,.monaco-workbench .part.editor>.content .editor-group-container>.title .tabs-container>.tab .tab-label span,.monaco-workbench .part.editor>.content .editor-group-container>.title .title-label a,.monaco-workbench .part.editor>.content .editor-group-container>.title .title-label h2{cursor:pointer}.monaco-workbench .part.editor>.content .editor-group-container>.title .monaco-icon-label:before{height:var(--editor-group-tab-height)}.monaco-workbench .part.editor>.content .editor-group-container>.title.breadcrumbs .monaco-icon-label:after,.monaco-workbench .part.editor>.content .editor-group-container>.title.tabs .monaco-icon-label:after{margin-right:0}.monaco-editor-group-drag-image{border-radius:10px;display:inline-block;font-size:12px;padding:1px 7px;position:absolute}";
+n(css,{});
+export { css, css as default };